Методы жизненного цикла деятельности: значение onPostResume

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

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

Но я считаю, что этот метод является важным методом.

В течение жизненного цикла, когда активность видна из скрытого состояния отображения,

 onRestart() onStart() onResume() onPostResume() 

Были вызваны в порядке.

Мой фрагмент кода:

 package ravindra.projects.my_app_1; import android.content.Intent; import android.content.IntentFilter; import android.os.PersistableBundle; import android.support.v7.app.AppCompatActivity; import android.os.Bundle; import android.util.Log; import android.view.View; import android.widget.Button; import android.widget.EditText; import android.widget.TextView; 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); } @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 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); } } 

Внедрение onPostResume() , пропуская ниже методы, не служит цели?

 onRestart(), onStart(), onResume() 

Каковы преимущества реализации этих трех методов, если я реализую onPostResume() ?

 onRestart(), onStart(), onResume() 

Solutions Collecting From Web of "Методы жизненного цикла деятельности: значение onPostResume"

OnPostResume:

Вызывается, когда возобновление активности завершено (после вызова функции {@link #onResume}). Приложения обычно не реализуют этот метод; Он предназначен для того, чтобы системные классы выполняли окончательную настройку после запуска кода резюме приложения.

Он будет делать следующие вещи

  1. Это обеспечит видимость экрана пользователю и сделает окончательную настройку активности.

  2. Удалите все ожидающие сообщения сообщений с кодом «что», которые находятся в очереди сообщений.

  3. Проверить, что все фрагменты возобновлены, и перемещает все фрагменты, управляемые FragmentManager контроллера, в состояние возобновления.

  4. Выполните любые ожидающие действия для Фрагментов, управляемых FragmentManager контроллера.

Если вы проверите его тираж, он работает, как показано ниже.

  1. OnResume () – Активность

  2. OnResume () – check third point as explained above фрагмента, check third point as explained above

  3. OnPostResume () – Активность

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

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

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

  1. Деятельность
  2. Фрагмент резюме
  3. OnPostResume вызывается в действии

Я добавлю слово предостережения для будущих читателей – если вы используете onPostResume для ожидания своего фрагмента, для вызова метода get (например), то у вас плохой, ненадежный дизайн. Вместо этого вы должны иметь обратный шаблон из вашего фрагмента и иметь фрагмент «отправить» данные обратно в действие, когда он будет готов

После использования методов регистрации и переопределения жизненного цикла активности я пришел к следующему выводу: этот метод может быть очень полезен, если вы хотите выполнить какую-либо конкретную задачу в родительской активности после возобновления фрагмента (после загрузки фрагмента) ….

Я использовал / попробовал следующие фрагменты кода, чтобы получить следующий вывод:

В родительской деятельности:

 //postResumemethod @Override protected void onPostResume() { super.onPostResume(); Log.v("testPostResume","reached_postResume") ; } In called Fragment : //On ResumeMethod @Override public void onResume() { super.onResume(); Log.v("testStartFragment","reached_Startfragment") ; } 

Это мой журнал: V / testStartFragment: достигнуто_Startfragment V / testPostResume: reach_postResume


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

Надеюсь, это пояснит запрос

Перед тем, как ответить на ваш вопрос, поговорим о onPostResume() Согласно андроиду

 onPostResume() 

Добавлен в API уровня 1

 void onPostResume () 

Вызывается, когда возобновление activity завершено ( after onResume() has been called ). Приложения обычно не реализуют этот метод; Он предназначен для того, чтобы системные классы выполняли окончательную настройку после запуска кода резюме приложения .

Так как они сказали, что это называется, как только активность возобновляется. Поэтому, если вы хотите что-то сделать после возобновления работы, вы можете использовать этот метод. Но в основном мы делаем все в onResume() например, начинаем анимацию, открываем устройства с эксклюзивным доступом (например, камеру) и т. Д., Поэтому, как только действие возобновляется на onPostResumed() . Так вы не думаете, что это отличается от резюме? Потому что в onPostResume () по активности os уже возобновлено. И для onPause и onStop (). Они разные. Это когда активность идет в фоновом режиме, но пока еще не убита и не вызвана, когда вы больше не видите пользователя. Таким образом, они отличаются от onResume() и onPostResume() .

Теперь, прежде чем полагаться на onPostResume (), вы должны прочитать эти две вещи. Что касается developers.android 1 – Applications, как правило, не реализует этот метод; Он предназначен для того, чтобы системные классы выполняли окончательную настройку после запуска кода резюме приложения. (Но мы можем использовать его для наших целей независимо от того, что это за цель). 2 – Проверьте эту ссылку . Он сказал, что onPostResume () не ВСЕГДА называется. И его дело было для фрагментов (конечно, они над человеком деятельности). Вот ответ. Проблема полностью решена в 16-м уровне api и поддерживает библиотеку rev 9. Должен использоваться новый метод « FragmentActivity.onResumeFragments() ».

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

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

Но я считаю, что этот метод является важным методом.

Скорее всего, ваши чувства ошибочны. И мой ответ о том, почему это так, немного длинный и абстрактный.

Абстрактная (но важная) часть

Обычно различные onPreXyz и onPostXyz (aka onBeforeXyz и onAfterXyz ) – это попытка сделать базовый класс открытым для расширения подклассами, но при этом сохраняя некоторые важные аспекты поведения. Предположим, что вы разрабатываете собственный базовый класс, и у вас есть событие жизненного цикла «Xyz», и поведение по умолчанию в вашем поведении следующее:

  1. Сделайте некоторую инициализацию перед любой другой обработкой
  2. Выполнять фактическую обработку события, включая настраиваемую логику
  3. Когда вся настраиваемая обработка выполняется, выполните некоторую финишную логику

Теперь предположим, что вы делаете что-то вроде класса Activity – базового класса с некоторыми битами логики и того, который будет сильно унаследован, вероятно, с глубокими иерархиями наследования. Теперь вы должны подумать о том, где (когда) будет рассмотрена логика подклассов относительно логики вашего базового класса. Важная сложная часть здесь заключается в том, что вы хотите, чтобы ваши подклассы добавляли свою дополнительную логику вокруг шага №2 (т.е. после # 1 и до # 3). Вы не можете легко достичь этой цели с помощью простого виртуального метода, потому что подкласс может либо поместить свою логику после вызова в super которая после # 3, либо (редко) перед super вызовом, т.е. до # 1. Так что бы вы сделали? Шаблон метода шаблонов приходит на помощь. Вы упорядочиваете код следующим образом

 class Activity { public final void performXyz(XyzEventData eventData) { onPreXyz(eventData); onXyz(eventData); onPostXyz(eventData); } protected void onPreXyz(XyzEventData eventData) { // put you logic from step #1 here } protected void onXyz(XyzEventData eventData) { // put you logic from step #2 here } protected void onPostXyz(XyzEventData eventData) { // put you logic from step #3 here } } 

Таким образом, у вас есть одна внешняя точка входа performXyz , вызываемая любым контекстом, генерирующим события жизненного цикла, когда происходит событие Xyz, и оно отправляет событие изнутри на 3 разных метода, обеспечивающих выполнение некоторой последовательности выполнения. Как правило, вы помещаете весь свой код в свои подклассы внутри «основного» метода onXyz если у вас нет веских причин помещать его в один из двух других, т. onXyz Вы ожидаете, что ваш класс также будет подклассифицирован, и вы хотите обеспечить некоторый порядок выполнения.

Стоит отметить еще несколько замечаний:

  1. Метод entry-point performXyz является final (т.е. не виртуальным). Таким образом, вы гарантируете, что никто не сможет переопределить его и нарушить логику выполнения порядка выполнения.

  2. Базовый класс может даже оставить onPreXyz и onPostXyz пустым, поместив свои шаги # 1 и # 3 непосредственно в performXyz . Но если конструктор базового класса ожидает возможных глубоких иерархий наследования, где некоторый промежуточный подкласс, который будет базовым классом для многих других более глубоких подклассов (например, супертипа Layer ), может потребоваться одна и та же функция выполнения порядка выполнения, имеет смысл Таким образом, предоставлять такие методы в базовом классе.

  3. Один из onPreXyz или onPostXyz может быть полностью опущен, если ваш случай не требует onPostXyz разделения выполнения и достаточно двух шагов. Это то, что часто случается в Android: существует намного больше методов onPostXyz чем onPreXyz но AsyncTask похоже, является одним из примечательных исключений, которые используют оба из них.

Ближе взгляните на Android (и onPostResume)

Итак, после этого длительного введения, как Android использует этот подход для onPostResume ? Если вы посмотрите на код в Activity.onPostResume вы заметите, что в базовом классе очень мало вещей и те, которые тесно связаны с материалами пользовательского интерфейса и, вероятно, ожидают, что все структуры данных будут полностью готовы. Это, конечно, не удивительно.

Более интересно то, как он используется в подклассах. Одним из немногих переопределений является FragmentActivity из библиотеки поддержки v4, которая предоставляет backported функции «Fragments» для старых устройств. FragmentActivity.onPostResume содержит логику для возобновления дочерних фрагментов. Вы можете заметить, что в стандартном классе Activity аналогичная логика для возобновления фрагментов помещается непосредственно в метод mInstrumentation.callActivityOnResume(this); между mInstrumentation.callActivityOnResume(this); И onPostResume(); Звонит, поэтому он кажется частью шага №3 в моем более раннем абстрактном описании, просто помещенном в код вызывающего абонента. Очевидно, что FragmentActivity не может поместить какой-либо новый код в Activity.performResume чтобы убедиться, что он будет выполнен после возобновления работы. Таким образом, он ставит логику переопределенному FragmentActivity.onPostResume и таким образом сохраняет ту же семантику, что фрагменты должны быть возобновлены после того, как активность уже возобновлена. Заметим также, что тот факт, что эта семантика, явно сохраненная в классах Activity и FragmentActivity указывает на то, что так лучше. Поэтому, если ваш код действительно использует фрагменты, вам лучше не onPostResume обширную логику в ваш onPostResume или что-то плохое может случиться (не уверен, что именно).