Простой жизненный цикл Android-активности

Я заметил, что раздел "Активность разработчиков Android" обновлен с момента запуска моего приложения, но я все еще не понимаю, что такое простой жизненный цикл активности.

Насколько я могу разобраться:

onCreate, onResume и onPause являются важными.

Активность может быть удалена в любое время после onPause, поэтому я должен сохранить все состояние приложения в файле onPause и не полагаться на onStop или onDestroy. Кроме того, onSaveInstanceState не вызывается перед каждым onPause, поэтому его не стоит использовать.

Вместо того, чтобы пытаться написать множество кода для обработки всех сценариев, почему бы не уничтожить Activity в конце его onPause?

Тогда жизненный цикл будет onCreate и onResume, прежде чем он станет активным, а затем onPause, когда он станет неактивным. Другие методы не нужны.

Я бы использовал onCreate для вызова setContentView и настройки прослушивателей, но все остальное было бы включено в onResume, включая загрузку восстановленного состояния из файла? Как указано ранее, onPause сохранит состояние в файле и уничтожит действие.

Насколько я вижу, единственным недостатком этого может быть то, что когда всплывающее окно отображается на экране, действие удаляется и его нужно воссоздавать, когда всплывающее окно закрывается, что означает, что активность не будет видна за popup (хотя я не тестировал это)

Для перезапуска активности может потребоваться немного больше времени, но поскольку система могла бы удалить операцию в любом случае без какого-либо уведомления, вы все равно должны сохранить все состояние.

Любые мысли?

Обновление: Я полагаю, что я думал о том, где активность "главной страницы" вызывает игру. Активность на главной странице будет вызывать игру, когда игрок нажимает кнопку "Play"

Игровая активность создала бы свои представления и слушателей и т.д. в onCreate, а в onResume загрузила файл, содержащий состояние игры, или запустила новую игру, если файл не существовал.

onPause игры, он записывает состояние игры в файл, то, что бы ни случилось с игровой деятельностью (ничего, или остановлено/уничтожено или что-то еще), метод onResume всегда будет загружать все данные обратно из файл.

Это то, о чем я думал, если это имеет смысл?

Update2: Я разработал простое решение, которое я документировал в ответе ниже, если кому-то интересно!

Он не поддерживает состояния жизненного цикла Android "приостановил" и "остановился". Как только он больше не отображается, он убивает себя и его необходимо перезапустить вручную, но он продолжается с того места, где вы остановились!

Ответ 1

Вы ищете это?

Чтобы еще раз ответить на ваш вопрос, да, как вы можете ясно видеть из приведенной выше диаграммы, "самый простой" (т.е. наименьшее число вызовов методов) действительно onCreate(); onStart(); onResume(); onPause();.

Вы также должны знать о onSaveInstanceState() и onRetainNonConfigurationInstance(). Это НЕ методы жизненного цикла.

Все эти методы очень хорошо документированы. Пожалуйста, внимательно прочитайте эту документацию.

Чтобы прояснить ситуацию, вот пара реальных сценариев:

Активность запущена, другие действия появляются поверх нее, вызывается onPause. В системе заканчивается память, вызывает onSaveInstanceState, убивает активность. Пользователь несколько раз отжимал, активность необходимо повторно создать (предпочтительно используя данные, сохраненные в onSaveInstanceState).
Активность запущена, пользователь нажимает назад. На этом этапе onPause->onDestroy вызывается, не вызывая onSaveInstanceState.

Вы должны понимать существенную разницу между onPause и onSaveInstanceState. Первая называется всегда, тогда как последняя вызывается только тогда, когда операция экземпляр может быть повторно создана в будущем. Следуя этой мысли, ваши пользователи ожидают две вещи:

Когда они перемещаются от вашей деятельности, а затем возвращаются к ней, они хотят, чтобы она была в том же экземпляре, что и они, и это было достигнуто с помощью onSaveInstanceState). Они не ожидают, что если они выйдут вашу деятельность. Однако:
Они ожидают, что данные , которые они ввели, будут сохранены (что будет сделано в onPause). Например, если они приступают к составлению сообщения, они ожидают увидеть его как черновик в следующий раз, когда они вернутся, даже если они выйдут из этой операции.

Вы должны понимать, как эти методы должны использоваться, чтобы получить то, что ожидают ваши пользователи. Как вы их используете, зависит от вас, ваших потребностей и природы приложения.

Ответ 2

Android-система обрабатывает жизненный цикл: т.е. запускает действия и вызывает методы жизненного цикла. Поэтому я не знаю, что вы подразумеваете под "уничтожением деятельности". Вы, как разработчик, не имеете таких способностей.

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

Ответ 3

Я изучал жизненный цикл активности и полный процесс того, что происходит, когда вы начинаете какую-либо деятельность, начиная с onCreate. Вот вам диаграмма UML.

Нажмите эту ссылку, чтобы увидеть версию высокого разрешения.

Ответ 4

Ответ прост, как жизненный цикл. Только переопределять обратные вызовы, когда вам нужно обрабатывать файлы там.

Android всегда будет вызывать каждый обратный вызов, как он должен, за исключением определенных обстоятельств.

Просто потому, что определенные обратные вызовы не гарантируются, что они называются, не означает, что они бесполезны. Просто не пытайтесь обрабатывать разумные вещи в таких методах обратного вызова.

Ответ 5

Я думаю, что нашел то, что я ищу! (Me 1, Bono 0)

Это для одной активности "Игра", которая использует минимальные методы для управления потоком GameThread, который обрабатывает игру. Он использует дополнительный класс GameData для хранения данных, которые должны быть постоянными между активациями.

Если приложение теряет фокус (т.е. входящий телефонный звонок или пользователь щелкает назад и т.д.), игра сохраняет GameData в файл и завершается. Чтобы возобновить работу, просто запустите приложение, и оно вернется обратно туда, где вы остановились.

Файл макета "game.xml" - это SurfaceView, охватывающий весь экран

Game.java:

onCreate устанавливает SurfaceHolder для SurfaceView и создает GameThread
surfaceChanged вызывает GameThread.startThread, чтобы запустить GameThread, если он еще не запущен, передача размера экрана
onPause вызывает GameThread.endThread для завершения GameThread и завершает это действие.
onTouch передает события касания к методу GameThread.doTouch.

GameThread.java:

startThread устанавливает локально хранящиеся данные, загружает GameData из файла и запускает поток
run - это стандартный игровой цикл, вызывающий достаточно стандартные функции updatePhysics и drawScreen для каждого фрейма. После окончания игрового цикла он сохраняет GameData в файл
endThread останавливает цикл игры в запуске и ждет завершения.
Действия doTouch касаются событий из игровой активности.

Кажется, что сработало. Это означает необходимость обрабатывать различные экраны (например, экран заголовка, параметры, игру и игру) в одном потоке, но это не конец света, IMHO.

Возможно, я опубликую код в CodeReview (я обновлю это, если найду) и посмотрю, есть ли у кого-нибудь комментарии. Между тем, мне лучше получить кодирование следующих Angry Birds!

Ответ 6

onCreate(), очевидно, сначала. Затем ваша деятельность может войти в onPause(). Оттуда он может быть либо onResume(), либо onDestroy(). Это самый простой путь по жизненному циклу, о котором я знаю.

У меня была активность, у которой не было метода onPause(). Через нечетную серию событий я заметил в DDMS, что мое приложение не было видно, но оно все еще запрашивало freshAds от AdMob:) Хорошая батарея присоски. Это было разрешено, но напомнил мне, насколько важны простые вещи.

Ответ 7

Я лично считаю, что разработчик должен разделить работу на разные состояния своей деятельности. Последовательность работы должна быть сохранена в этом случае, что более важно, о чем я думаю, и именно поэтому, поскольку Android не может обрабатывать длинную обработку пользовательского интерфейса в одном потоке, и это дает ошибку, что у Android есть "столько работы, чтобы сделать" в эта ссылка, которая может быть причиной сбоя иногда. Поэтому мы должны помешать написать весь код в разделе. Код будет записан в разностные функции или классы, и мы можем получить эти функции в соответствии с требованием. Спасибо.

Ответ 8

В приложении Android есть 7 методов, которые управляют жизненным циклом действия:

OnCreate()
OnStart()
onResume()
onRestart()
OnPause()
OnStop()
OnDestroy()

Я более подробно описал эти методы на мой блог

Ответ 9

В соответствии с ответом, предоставленным @Felix, перейдет зрелое, полнофункциональное и функциональное приложение для Android (состояние = функция времени).

Но что делать, если вы просто хотите создать приложение, которое даже не имеет графического интерфейса. И вы хотите простейший жизненный цикл, тогда я отвечу ниже.

Этот ответ, вероятно, вы найдете интересным. Система Android после чтения AndroidManifest.xml знает, какая точка входа. Какая бы деятельность ни имела это

<activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

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

Ваше основное создание процесса - задача системы Android. Когда запускается компонент приложения, и в приложении нет других запущенных компонентов, система Android запускает новый процесс Linux. После того, как процесс вызывает onCreate(), он создает основной поток.. Это причина, по которой вы должны называть onCreate(), потому что основной поток затем инициализируется, и основной поток является триггером для всех ваших будущих действий.

В onCreate() вы получили свой основной поток. После этого все зависит от вас, какие обратные вызовы вы хотите вызвать. Нет правила, которое вы должны вызывать onStart() после onCreate().

Только один жизненный цикл onCreate() гарантированно будет вашим жизненным циклом компонента.

И, кроме того, чтобы понять, что каждый метод жизненного цикла делает внутри него, введите ниже код.

//add the log line
        Log.i(this.getClass().getCanonicalName(), "##############");
        int count = 0;
        for (StackTraceElement stackTraceElement:  Thread.currentThread().getStackTrace()) {
            count++;
            Log.i(this.getClass().getCanonicalName(), "\""+Thread.currentThread().getStackTrace()[2].getMethodName()+"\" "+count+" "+stackTraceElement.getMethodName());
        }; //end of log line

Итак, всегда добавляйте выше того же кода для просмотра журналов в консоли журнала cat.

Когда ваше приложение запускает GUI, он вызывает onStart(). Если вы не вызываете метод super() внутри обратного вызова, система андроидов показывает поврежденную ошибку канала и не может выполнять дальнейшую обработку и отладку.

Но вы можете реализовать свою собственную логику внутри каждого метода обратного вызова. Например, вы можете суммировать два числа на onStart().

Таким образом, все методы обратного вызова android являются частично реализованными методами. Они не являются чисто абстрактными методами, потому что вы должны вызвать метод super() внутри них.

Прилагаемое изображение сообщает: Application main process вызывает onCreate(), он делегирует свои обязанности основному потоку (поток пользовательского интерфейса), а основной поток вызывает эти 16 других обратных вызовов.

Кроме того, если вы хотите увидеть все свои методы в определенное время, поставьте этот ниже код.

//to see all the methods (including super methods) at this time, you call use the java reflection as below
    Log.i(this.getClass().getCanonicalName(), "##############");
    int count1 = 0;
    for (Method method:  this.getClass().getMethods()) {
        count1++;
        count++;
        Log.i(this.getClass().getCanonicalName(), count1+" "+method);
    }; //end of log line

    //At another time, after you add some other methods or android using GC removes some methods, you see your changed state (Bundle Snapshot) of your class
    //Because your bundle (i.e, the state of your class/activity) is the function of time.

В моем сценарии, из приведенного выше фрагмента кода, я вижу, что он вызвал 375 методов.

Примечание. Если вы добавили другой метод внутри onCreate() перед тем, как распечатать все свои методы, используя только выше фрагмент кода, вы бы тоже увидели этот метод. Это означает, что ваше состояние класса (т.е. Моментальный снимок) соответствует вам, что вы делаете время от времени, вы постоянно обновляете свой снимок.