Aplicativo de monitoramento Android muda para segundo plano e primeiro plano

Uma delas é registrar-se para monitoramento:

@HiltAndroidApp
class MyApplication :Application{
    constructor() : super()
    override fun onCreate() {
        super.onCreate()
         Log.e("MyApplication","=====MyApplication")
         registerActivityLifecycleCallbacks(activityLifecycleCallbacks)
    }


    val activityLifecycleCallbacks:ActivityLifecycleCallbacks=   object:ActivityLifecycleCallbacks{

        private var activityStartCount = 0
        override fun onActivityCreated(activity: Activity, savedInstanceState: Bundle?) {
        }

        override fun onActivityStarted(activity: Activity) {
            activityStartCount++
            if(activityStartCount==1){
                //从后台切换到前台
            }

        }

        override fun onActivityResumed(activity: Activity) {
        }

        override fun onActivityPaused(activity: Activity) {
        }

        override fun onActivityStopped(activity: Activity) {
            activityStartCount--
            if (activityStartCount == 0){
                //从前台切换到后台
            }
        }

        override fun onActivitySaveInstanceState(activity: Activity, outState: Bundle) {
        }

        override fun onActivityDestroyed(activity: Activity) {
        }

    }
}

RegisterActivityLifecycleCallbacks(activityLifecycleCallbacks) monitora o ciclo de vida de todas as atividades. Por que isso pode ser feito? A seguir iremos analisá-lo lentamente.

ActivityLifecycleCallbacks é uma interface interna do aplicativo.

O aplicativo fornece

registrarActivityLifecycleCallbacks(retorno de chamada de ActivityLifecycleCallbacks)

unregisterActivityLifecycleCallbacks(retorno de chamada de ActivityLifecycleCallbacks)

Dois métodos.

Analisamos o método registerActivityLifecycleCallbacks()

   public void registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
        synchronized (mActivityLifecycleCallbacks) {
            mActivityLifecycleCallbacks.add(callback);
        }
    }

A descoberta consiste em adicionar a implementação da interface a uma coleção de aplicativos

private ArrayList<ActivityLifecycleCallbacks> mActivityLifecycleCallbacks = 
        new ArrayList<ActivityLifecycleCallbacks>();

Este é outro padrão típico de observador.

Então, onde essa coleção deve ser chamada? A pesquisa global descobriu que ele foi convertido em um array neste método

    @UnsupportedAppUsage
    private Object[] collectActivityLifecycleCallbacks() {
        Object[] callbacks = null;
        synchronized (mActivityLifecycleCallbacks) {
            if (mActivityLifecycleCallbacks.size() > 0) {
                callbacks = mActivityLifecycleCallbacks.toArray();
            }
        }
        return callbacks;
    }

Esta matriz está no aplicativo

expediçãoActivityCreated

expediçãoActivityStarted

expediçãoActivityResumed

é chamado em outros métodos, conforme mostrado abaixo:

  /* package */ void dispatchActivityDestroyed(@NonNull Activity activity) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivityDestroyed(activity);
            }
        }
    }

Os métodos acima correspondem obviamente ao ciclo de vida da actividade, pelo que obviamente estes métodos devem ser chamados durante o ciclo de vida da actividade, caso contrário o ciclo de vida da actividade não pode ser monitorizado. Vamos para a atividade pai da atividade para encontrá-la.

Nós analisamos isso

Um ciclo de vida do Currículo (outros são semelhantes), como segue:

   protected void onResume() {
        if (DEBUG_LIFECYCLE) Slog.v(TAG, "onResume " + this);
        dispatchActivityResumed();  //调用这方法
        mActivityTransitionState.onResume(this);
        enableAutofillCompatibilityIfNeeded();
        if (mAutoFillResetNeeded) {
            if (!mAutoFillIgnoreFirstResumePause) {
                View focus = getCurrentFocus();
                if (focus != null && focus.canNotifyAutofillEnterExitEvent()) {
                    // TODO(b/148815880): Bring up keyboard if resumed from inline authentication.
                    // TODO: in Activity killed/recreated case, i.e. SessionLifecycleTest#
                    // testDatasetVisibleWhileAutofilledAppIsLifecycled: the View's initial
                    // window visibility after recreation is INVISIBLE in onResume() and next frame
                    // ViewRootImpl.performTraversals() changes window visibility to VISIBLE.
                    // So we cannot call View.notifyEnterOrExited() which will do nothing
                    // when View.isVisibleToUser() is false.
                    getAutofillManager().notifyViewEntered(focus);
                }
            }
        }

        notifyContentCaptureManagerIfNeeded(CONTENT_CAPTURE_RESUME);

        mCalled = true;
    }

 Com certeza, o método do objeto em Application foi chamado.

  
// getApplication().dispatchActivityResumed(this); 调用了Application中的分发方法

  private void dispatchActivityResumed() {
        getApplication().dispatchActivityResumed(this);
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i = 0; i < callbacks.length; i++) {
                ((Application.ActivityLifecycleCallbacks) callbacks[i]).onActivityResumed(this);
            }
        }
    }

2. Use o método de extensão do Ciclo de Vida

Adicione dependências:
 

    //只能适用于androidX项目
    implementation("androidx.lifecycle:lifecycle-process:2.2.0")

Adicione o seguinte código em mainActivity ou application: 

   ProcessLifecycleOwner.get().lifecycle.addObserver(object:DefaultLifecycleObserver{
            override fun onStop(owner: LifecycleOwner) {
                super.onStop(owner)
                //后台
            }


            override fun onStart(owner: LifecycleOwner) {
                super.onStart(owner)
                //前台
            }

        })