Подтвердить что ты не робот

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

Официальная документация о Activity перечисляет 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()
4b9b3361

Ответ 1

onPostResume:

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

Он выполнит следующие действия

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

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

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

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

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

  • onResume() - Activity

  • onResume() - Фрагмент check third point as explained above

  • onPostResume() - Активность

Ответ 2

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

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

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

  • Активность
  • Фрагментные резюме
  • onPostResume вызывается в Activity

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

Ответ 3

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

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

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

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

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

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

Теперь предположим, что вы делаете нечто вроде Activity class - базовый класс с некоторыми битами логики и тот, который будет сильно унаследован, вероятно, с глубокими иерархиями наследования. Теперь вы должны подумать о том, где (когда) будет рассмотрена логика подклассов относительно логики в вашем базовом классе. Важная сложная часть здесь заключается в том, что вы хотите, чтобы ваши подклассы добавляли свою дополнительную логику вокруг шага № 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 разных метода, обеспечивающих выполнение некоторой последовательности выполнения. Как правило, вы помещаете весь свой код в свои подклассы внутри метода "main" onXyz, если у вас нет веских причин помещать его в один из двух других, то есть вы ожидаете, что ваш класс также будет подклассифицирован, и вы хотите обеспечить некоторое выполнение заказ.

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

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

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

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

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

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

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

Ответ 4

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

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

в родительской активности:

//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 для фрагмента. Поэтому после вызова/загрузки фрагмента, если вы хотите выполнить какой-либо код в действии (любая задача через acivity после загрузки фрагмента), вы можете сделать это

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

Ответ 5

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

onPostResume()

добавлен в уровень API 1

void onPostResume ()

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

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

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

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