Разница между onStart () и onResume ()

Я не могу понять значение onStart()переходного состояния. onResume()Метод всегда вызывается после onStart(). Почему это не может быть onResume()вызвано после, onRestart()а onCreate()методы просто исключены onStart()? Какова его цель?

Почему мы не можем жить без onStart(). Я все еще считаю это излишним (вероятно, потому что не понимаю его значение полностью).

Почему это не может быть onResume () вызывается после методов onRestart () и onCreate (), исключая onStart ()? Какова его цель?

Хорошо, поскольку мой первый ответ был довольно длинным, я не буду его расширять, поэтому давайте попробуем это ...

public DriveToWorkActivity extends Activity
    implements onReachedGroceryStoreListener {
}

public GroceryStoreActivity extends Activity {}

ПОЖАЛУЙСТА, ОБРАТИТЕ ВНИМАНИЕ: я намеренно пропустил призывы к таким вещам и super.onCreate(...)т. Д. Это псевдокод, поэтому дайте мне немного художественной лицензии здесь. ;)

Методы для DriveToWorkActivityследования ...

protected void onCreate(...) {
    openGarageDoor();
    unlockCarAndGetIn();
    closeCarDoorAndPutOnSeatBelt();
    putKeyInIgnition();
}

protected void onStart() {
    startEngine();
    changeRadioStation();
    switchOnLightsIfNeeded();
    switchOnWipersIfNeeded();
}

protected void onResume() {
    applyFootbrake();
    releaseHandbrake();
    putCarInGear();
    drive();
}

protected void onPause() {
    putCarInNeutral();
    applyHandbrake();
}

protected void onStop() {
    switchEveryThingOff();
    turnOffEngine();
    removeSeatBeltAndGetOutOfCar();
    lockCar();
}

protected void onDestroy() {
    enterOfficeBuilding();
}

protected void onReachedGroceryStore(...) {
    Intent i = new Intent(ACTION_GET_GROCERIES, ...,  this, GroceryStoreActivity.class);
}

protected void onRestart() {
    unlockCarAndGetIn();
    closeDoorAndPutOnSeatBelt();
    putKeyInIgnition();
}

ОК, так что это еще один длинный (извините, ребята). Но вот мое объяснение ...

onResume()это когда я начинаю движение, и onPause()когда я прихожу к временной остановке. Итак, я еду, затем достигаю красного света, поэтому я делаю паузу ... свет становится зеленым, и я возобновляю. Еще один красный свет, и я пауза, затем зеленый, поэтому я возобновляю. onPause() -> onResume() -> onPause() -> onResume()Петля плотно один и происходит много раз в моем путешествии.

Цикл от остановки обратно через перезапуск (подготовка к продолжению моего путешествия) до повторного запуска, возможно, менее распространен. В одном случае я замечаю продуктовый магазин, и GroceryStoreActivityон запускается (доводя меня DriveToWorkActivityдо точки onStop()). Когда я возвращаюсь из магазина, я прохожу onRestart()и onStart()возобновляю свое путешествие.

Я мог бы поместить код, который входит в onStart()оба, onCreate()и onRestart()не беспокоиться о переопределении onStart()вообще, но чем больше нужно сделать между onCreate() -> onResume()и onRestart() -> onResume(), тем больше я дублирую вещи.

Итак, пересобрать еще раз ...

Почему это не может быть onResume () вызывается после методов onRestart () и onCreate (), исключая onStart ()?

Если вы не переопределите, onStart()то именно это и происходит. Хотя onStart()метод Activityбудет вызываться неявно, эффект в вашем коде будет эффективным onCreate() -> onResume()или onRestart() -> onResume().

Короткий ответ:

Мы не можем жить без OnStart, потому что это состояние, когда действие становится «видимым» для пользователя, но пользователь не может «взаимодействовать» с ним, но может быть потому, что оно перекрывается каким-то другим небольшим диалогом. Эта способность взаимодействовать с пользователем является той, которая различает onStart и onResume. Думайте об этом как о человеке за стеклянной дверью. Вы можете видеть человека, но не можете взаимодействовать (разговаривать / слушать / пожать ему руку). OnResume похож на механизм открывания дверей, после которого вы можете начать взаимодействие.

Кроме того onRestart () является наименее понятным. Мы можем задать вопрос, почему бы не перейти непосредственно к onStart () или onResume () после onStop () вместо onRestart (). Это станет легче понять, если мы заметим, что onRestart () частично эквивалентен onCreate (), если часть создания не указана. В основном оба состояния приводят к onStart () (т.е. активность становится видимой). Таким образом, оба государства должны «подготовить» материал для отображения. OnCreate несет дополнительную ответственность за «создание» материала для отображения

Таким образом, их структуры кода могут соответствовать чему-то вроде:

onCreate()
{
     createNecessaryObjects();

     prepareObjectsForDisplay();
}


onRestart()
{
     prepareObjectsForDisplay();

}

Вся путаница вызвана тем, что Google выбрал неинтуитивные имена вместо чего-то следующего:

onCreateAndPrepareToDisplay()   [instead of onCreate() ]
onPrepareToDisplay()            [instead of onRestart() ]
onVisible()                     [instead of onStart() ]
onBeginInteraction()            [instead of onResume() ]
onPauseInteraction()            [instead of onPause() ]
onInvisible()                   [instead of onStop]
onDestroy()                     [no change] 

Диаграмма действий может быть интерпретирована как:

onStart()вызывается, когда активность становится видимой для пользователя. onResume()вызывается, когда действие начнет взаимодействовать с пользователем. Вы можете сделать разные вещи в этом случае.

Смотрите эту ссылку для справки.

onResume() называется:

1. после onStart()
2. когда Activityвыходит на первый план.

От http://developer.android.com/reference/android/app/Activity.html#ActivityLifecycle :

Книга «Здравствуй, Android, представляя платформу мобильной разработки Google» дает хорошее объяснение жизненного цикла приложений для Android. К счастью у них есть определенная глава онлайн как выдержка. Смотрите рисунок на странице 39 в http://media.pragprog.com/titles/eband3/concepts.pdf.

Кстати, эта книга очень рекомендуется для начинающих Android!

Особенно нахальный пример - когда вы решаете показать управляемый диалог из действия showDialog(). Если пользователь поворачивает экран, пока диалоговое окно все еще открыто (мы называем это «изменением конфигурации»), то основное действие будет проходить через все вызовы завершающего жизненного цикла до тех пор onDestroy(), пока не будет воссоздано, и вернется обратно через жизненные циклы. То , что вы не могли бы ожидать , однако, заключается в том , что onCreateDialog()и onPrepareDialog()(методы, которые вызываются , когда вы делаете , showDialog()и теперь снова автоматически воссоздать диалог - автоматически , так как это управляемый диалог) называются между onStart() и onResume(). Суть в том, что диалоговое окно не покрывает весь экран и, следовательно, оставляет часть основной активности видимой. Это деталь, но это важно!

onStart()

1. Вызывается после onCreate (Bundle) или после onRestart (), за которым следует onResume () .
2. Вы можете зарегистрировать BroadcastReceiver в onStart() для мониторинга изменений, которые влияют на ваш пользовательский интерфейс. Вы должны отменить его регистрацию в onStop ()
3. Производные классы должны вызывать реализацию этого метода в суперклассе. Если этого не произойдет, будет выдано исключение.

onResume()

1. Вызывается после onRestoreInstanceState (Bundle), onRestart () или onPause ()
2. Начните анимацию, откройте устройства с эксклюзивным доступом (например, камеру)

onStart() обычно отправляет работу в фоновый поток, чьи возвращаемые значения:

• START_STICKY для автоматического перезапуска, если его убили, чтобы он оставался активным.

• START_REDELIVER_INTENT для автоматического перезапуска и повторите попытку, если служба была прервана до stopSelf ().

onResume()вызывается операционной системой после того, как устройство переходит в спящий режим или после того, как оповещение или другие дочерние действия с частичным экраном оставляют видимой часть предыдущего окна, поэтому необходим метод для повторной инициализации полей (в структуре try с перехватом исключений) ). Такая ситуация не onStop()вызывает, когда ребенок закрывается.

onResume() называется без onStart() когда активность возобновляется из фона

Для получения более подробной информации вы можете посетить Android_activity_lifecycle_gotcha And Activity Lifecycle

Надеюсь, простое объяснение:

onStart () -> вызывается, когда действие становится видимым, но может не находиться на переднем плане (например, AlertFragment находится сверху или любой другой возможный вариант использования).

onResume () -> вызывается, когда действие находится на переднем плане, или пользователь может взаимодействовать с действием.

onStart()означает, что Activityвведено в видимое состояние и макет создан, но не может взаимодействовать с этим макетом активности.

Resume() означает, что теперь вы можете делать взаимодействие с макетом деятельности.

Обратите внимание, что между вызовами onStart () и onResume () происходят некоторые вещи. А именно, onNewIntent (), который я мучительно узнал.

Если вы используете флаг SINGLE_TOP и отправляете некоторые данные в свою деятельность, используя дополнительные намерения, вы сможете получить к ним доступ только в onNewIntent (), который вызывается после onStart () и перед onResume (). Поэтому обычно вы берете новые (возможно, только измененные) данные из дополнений и устанавливаете их для некоторых членов класса, или используете setIntent (), чтобы установить новое намерение в качестве исходного намерения действия, и обрабатывать данные в onResume ().

Ссылка на http://developer.android.com/training/basics/activity-lifecycle/starting.html

onResume()Вызывается непосредственно перед тем, как действие начинает взаимодействовать с пользователем. В этот момент активность находится на вершине стека активности, и пользовательский ввод идет к нему. Всегда следует onPause().

onPause()Вызывается, когда система собирается возобновить другое действие. Этот метод обычно используется для фиксации несохраненных изменений в постоянных данных, остановки анимации и других вещей, которые могут потреблять процессор, и так далее. Он должен делать все, что он делает очень быстро, потому что следующее действие не будет возобновлено, пока оно не вернется. Затем следует, onResume()если действие возвращается обратно на фронт, или onStop()если оно становится невидимым для пользователя.

Не уверен, что это считается ответом, но вот видео YouTube с курса Google (Разработка приложений для Android с Kotlin), которое объясняет разницу.

• При запуске вызывается, когда активность становится видимой
• On Pause вызывается, когда действие теряет фокус (как всплывающее диалоговое окно)
• Возобновление вызывается, когда действие получает фокус (например, когда диалог исчезает)