Жизненный цикл активности Android-для чего все эти методы?

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

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] 

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

активность имеет шесть государств

• создано
• Started
• возобновить
• пауза
• остановил
• уничтожил

жизненный цикл активности семь методов

• onCreate()
• onStart()
• onResume()
• onPause()
• onStop()
• onRestart()
• onDestroy()

ситуации

• при открытии приложения

  onCreate() --> onStart() -->  onResume()
  

• при нажатии кнопки "назад" и выходе из app

  onPaused() -- > onStop() --> onDestory()
  

• при нажатии кнопки home

  onPaused() --> onStop()
  

• после нажатия кнопки "Домой", когда снова откройте приложение из списка последних задач или нажмите на значок

  onRestart() --> onStart() --> onResume()
  

• при открытии приложения другое приложение из панели уведомлений или откройте Настройки

  onPaused() --> onStop()
  

• кнопка Назад нажата из другого приложения или настроек затем используется может увидеть наше приложение

  onRestart() --> onStart() --> onResume()
  

• при открытии любого диалога на экране

  onPause()
  

• после кнопку закрыть диалоговое окно или из диалога

  onResume()
  

• любой телефон звонит и пользователь в приложении

  onPause() --> onResume() 
  

• когда пользователь нажал ответ телефона кнопка

  onPause()
  

• после

  onResume()
  

• когда экран телефона выключен

  onPaused() --> onStop()
  

• когда экран снова включен

  onRestart() --> onStart() --> onResume()
  

ANDROID ЖИЗНЕННОГО ЦИКЛА

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

• onCreate ()
• onStart ()
• onResume()
• onRestart()
• onPause ()
• onStop ()
• onDestroy()

ответ для чего все эти методы:

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

• Предположим, вы используете приложение калькулятора. Вызываются три метода преемственность для запуска приложения.

onCreate() - - -> onStart() - - -> onResume()

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

onPause() - - -> onStop()

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

onRestart() - - -> onStart() - - -> onResume()

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

onStop() - - -> onDestroy()

существует четыре состояния, в которых может существовать активность:

• Начальное Состояние
• Под Управлением Государства
• Приостановлена
• остановлен

начальное состояние включает в себя:

создание нового процесса Linux, выделение новой памяти для новых объектов пользовательского интерфейса и настройка на весь экран. Так что большая часть работы здесь.

состояние выполнения включает в себя:

это действие (состояние), которое в настоящее время находится на экране. Только это состояние обрабатывает такие вещи, как ввод текста на экране и касание и нажатие кнопок.

приостановленное состояние включает:

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

остановленном состоянии включает в себя:

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

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

Мне нравится этот вопрос и ответы на него, но до сих пор нет покрытия менее часто используемых обратных вызовов, таких как onPostCreate () или onPostResume (). Стив Померой попытался диаграмму, включая эти и как они относятся к Android фрагмент жизненный цикл, at https://github.com/xxv/android-lifecycle. Я пересмотрел большую диаграмму Стива, чтобы включить только активность часть и отформатировал его для распечатки размером в одну страницу. Я разместил его как текстовый PDF на https://github.com/code-read/android-lifecycle/blob/master/AndroidActivityLifecycle1.pdf а ниже его изображение:

со страницы разработчиков Android,

onPause ():

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

onStop ():

вызывается, когда действие больше не отображается пользователю, потому что была возобновлена другая деятельность, которая охватывает и эту. Май этого года происходит либо потому, что запускается новое действие, существующее его либо приводят к этому, либо уничтожают. Затем либо onRestart (), если это действие возвращается к взаимодействовать пользователь или onDestroy (), если это действие уходит.

теперь предположим, что есть три действия, и вы переходите от A к B, тогда onPause Of A будет вызываться теперь от B к C, затем onPause of B и onStop Of A будет вызываться.

приостановленное действие получает резюме, а остановленное перезапускается.

когда вы называете this.finish(), onPause-onStop-onDestroy будет вызван. Главное, что нужно помнить: приостановленные действия останавливаются, а остановленная деятельность Уничтожается всякий раз, когда Android требует памяти для других операций.

Я надеюсь, это достаточно ясно.

добавление дополнительной информации поверх высоко оцененного ответа (добавлен дополнительный раздел KILLABLE и следующий набор методов, которые будут вызваны в жизненном цикле):

источник:developer.android.com

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

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

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

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

onPostCreate(Bundle savedInstanceState)

вызывается, когда запуск активности завершен (после onStart() и onRestoreInstanceState(Bundle) называют).

onPostResume()

вызывается, когда возобновление активности завершено (после onResume() называют).

onSaveInstanceState(Bundle outState)

вызывается для извлечения состояния экземпляра из действия перед убийством, чтобы состояние можно было восстановить в onCreate(Bundle) или onRestoreInstanceState(Bundle) (the Пакет, заполненный этим методом, будет передан обоим).

onRestoreInstanceState(Bundle savedInstanceState)

этот метод называется после onStart() когда действие повторно инициализируется из ранее сохраненного состояния, приведенного здесь в savedInstanceState.

мой код приложения, используя все эти методы:

public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    private EditText txtUserName;
    private EditText txtPassword;
    Button  loginButton;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.d("Ravi","Main OnCreate");
        txtUserName=(EditText) findViewById(R.id.username);
        txtPassword=(EditText) findViewById(R.id.password);
        loginButton =  (Button)  findViewById(R.id.login);
        loginButton.setOnClickListener(this);

    }

    @Override
    public void onClick(View view) {
        Log.d("Ravi", "Login processing initiated");
        Intent intent = new Intent(this,LoginActivity.class);
        Bundle bundle = new Bundle();
        bundle.putString("userName",txtUserName.getText().toString());
        bundle.putString("password",txtPassword.getText().toString());
        intent.putExtras(bundle);
        startActivityForResult(intent,1);
       // IntentFilter
    }
    public void onActivityResult(int requestCode, int resultCode, Intent resIntent){
        Log.d("Ravi back result:", "start");
        String result = resIntent.getStringExtra("result");
        Log.d("Ravi back result:", result);
        TextView txtView = (TextView)findViewById(R.id.txtView);
        txtView.setText(result);

        Intent sendIntent = new Intent();
        //sendIntent.setPackage("com.whatsapp");
        sendIntent.setAction(Intent.ACTION_SEND);
        sendIntent.putExtra(Intent.EXTRA_TEXT, "Message...");
        sendIntent.setType("text/plain");
        startActivity(sendIntent);
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("Ravi","Main Start");
    }

    @Override
    protected void onRestart() {
        super.onRestart();
        Log.d("Ravi","Main ReStart");
    }

    @Override
    protected void onPause() {
        super.onPause();
        Log.d("Ravi","Main Pause");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d("Ravi","Main Resume");
    }

    @Override
    protected void onStop() {
        super.onStop();
        Log.d("Ravi","Main Stop");
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        Log.d("Ravi","Main OnDestroy");
    }

    @Override
    public void onPostCreate(Bundle savedInstanceState, PersistableBundle persistentState) {
        super.onPostCreate(savedInstanceState, persistentState);
        Log.d("Ravi","Main onPostCreate");
    }

    @Override
    protected void onPostResume() {
        super.onPostResume();
        Log.d("Ravi","Main PostResume");
    }

    @Override
    public void onSaveInstanceState(Bundle outState, PersistableBundle outPersistentState) {
        super.onSaveInstanceState(outState, outPersistentState);
    }

    @Override
    protected void onRestoreInstanceState(Bundle savedInstanceState) {
        super.onRestoreInstanceState(savedInstanceState);
    }
}

Вход В Систему:

public class LoginActivity extends AppCompatActivity {

    private TextView txtView;
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_login);
        txtView = (TextView) findViewById(R.id.Result);
        Log.d("Ravi","Login OnCreate");
        Bundle bundle = getIntent().getExtras();
        txtView.setText(bundle.getString("userName")+":"+bundle.getString("password"));
        //Intent  intent = new Intent(this,MainActivity.class);
        Intent  intent = new Intent();
        intent.putExtra("result","Success");
        setResult(1,intent);
       // finish();
    }
}

выход: ( до перерыва)

D/Ravi: Main OnCreate
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume

вывод: (после возобновления с пауза)

D/Ravi: Main ReStart
D/Ravi: Main Start
D/Ravi: Main Resume
D/Ravi: Main PostResume

отметим, что onPostResume() вызывается, даже если он не указан как метод жизненного цикла.

начните с основ у меня есть много учебных пособий, связанных с компонентами жизненного цикла .. вы учитесь для жизненного цикла, как ваш вопрос быть https://www.youtube.com/watch?v=e-ews5dRMwI