Android进阶——借助简单便捷的ActivityLifecycleCallbacks实现全周期监听Activity

最新推荐文章于 2024-08-08 08:42:25 发布
最新推荐文章于 2024-08-08 08:42:25 发布
阅读量7.4k 收藏 8
点赞数 2
分类专栏： Android 进阶 # Android系统组件使用 文章标签： android activity生命周期 顶部Activity Lifecycle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/crazymo_/article/details/78875686
版权

引言

在开发中由于业务的需求，我们需要在Activity对应的生命周期方法中去完成对应的工作，比如说需要在Activity的onResume中注册某个SDK或者广播接收器、抑或是尝试打开Camera、判断app 是否在后台运行除了令人蛋疼的判断当前runningProcess 或者runningTasks 方法等，然后在Activity的onPause()中及时注销或释放掉，以前也许会在每个Activity对应的方法中增加对应的代码即可，但是从一定意义上说这代码是冗余的且不优雅，从Android4.0之后添加了Application.ActivityLifecycleCallbacks接口，我们开发者就有了一种更优雅的方案。

一、Application.ActivityLifecycleCallbacksgais概述

记得我第一次知道这个接口之后，第一时间跑到官网中查询文档，结果发现Google 又偷懒了，Summary部分竟然一句话都没有关于它的描述，差点怀疑是否进错了网站，ORZ，才发现其实是这个接口太简单了背后的原理也十分简单，本来我还以为会是观察者模式，后面发现就是一个普通回调。但是借助它我可以优雅地监控Activity的生命周期——一经注册，就会自动监听整个APP 中所有Activity 的生命周期方法的执行（会在对应的父类Activity的方法被执行之后自动触发）。

二、Application.ActivityLifecycleCallbacks源码急背后的原理简要描述

Application.ActivityLifecycleCallbacks是Application中的一个接口，使用起来也很简单，只需要调用registerActivityLifecycleCallbacks方法即可完成注册（通常是在Application中完成的）。


public class Application extends ContextWrapper implements ComponentCallbacks2 {
    private ArrayList<ComponentCallbacks> mComponentCallbacks =
            new ArrayList<ComponentCallbacks>();
    private ArrayList<ActivityLifecycleCallbacks> mActivityLifecycleCallbacks =
            new ArrayList<ActivityLifecycleCallbacks>();
    private ArrayList<OnProvideAssistDataListener> mAssistCallbacks = null;

    /** @hide */
    public LoadedApk mLoadedApk;

    public interface ActivityLifecycleCallbacks {
        void onActivityCreated(Activity activity, Bundle savedInstanceState);
        void onActivityStarted(Activity activity);
        void onActivityResumed(Activity activity);
        void onActivityPaused(Activity activity);
        void onActivityStopped(Activity activity);
        void onActivitySaveInstanceState(Activity activity, Bundle outState);
        void onActivityDestroyed(Activity activity);
    }

    public Application() {
        super(null);
    }

    @CallSuper
    public void onCreate() {
    }

    /**
     * This method is for use in emulated process environments.  It will
     * never be called on a production Android device, where processes are
     * removed by simply killing them; no user code (including this callback)
     * is executed when doing so.
     */
    @CallSuper
    public void onTerminate() {
    }

    @CallSuper
    public void onConfigurationChanged(Configuration newConfig) {
        Object[] callbacks = collectComponentCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ComponentCallbacks)callbacks[i]).onConfigurationChanged(newConfig);
            }
        }
    }

    @CallSuper
    public void onLowMemory() {
        Object[] callbacks = collectComponentCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ComponentCallbacks)callbacks[i]).onLowMemory();
            }
        }
    }

    @CallSuper
    public void onTrimMemory(int level) {
        Object[] callbacks = collectComponentCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                Object c = callbacks[i];
                if (c instanceof ComponentCallbacks2) {
                    ((ComponentCallbacks2)c).onTrimMemory(level);
                }
            }
        }
    }
    /*
    **注册ActivityLifecycleCallbacks回调
    */
    public void registerActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
        synchronized (mActivityLifecycleCallbacks) {
            mActivityLifecycleCallbacks.add(callback);
        }
    }

    public void unregisterActivityLifecycleCallbacks(ActivityLifecycleCallbacks callback) {
        synchronized (mActivityLifecycleCallbacks) {
            mActivityLifecycleCallbacks.remove(callback);
        }
    }


    // ------------------ Internal API ------------------
    /* package */ void dispatchActivityCreated(Activity activity, Bundle savedInstanceState) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivityCreated(activity,
                        savedInstanceState);
            }
        }
    }

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

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

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

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

    /* package */ void dispatchActivitySaveInstanceState(Activity activity, Bundle outState) {
        Object[] callbacks = collectActivityLifecycleCallbacks();
        if (callbacks != null) {
            for (int i=0; i<callbacks.length; i++) {
                ((ActivityLifecycleCallbacks)callbacks[i]).onActivitySaveInstanceState(activity,
                        outState);
            }
        }
    }

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

然后在Activity的对应的生命周期方法的内部，通过Application来调用对应的dispatchActivityXxxxx方法，从而实现全生命周期的监听

public class Activity extends ContextThemeWrapper implements LayoutInflater.Factory2,Window.Callback, KeyEvent.Callback,
        OnCreateContextMenuListener, ComponentCallbacks2,
        Window.OnWindowDismissedCallback, WindowControllerCallback {
        ...
        @MainThread
    @CallSuper
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        if (DEBUG_LIFECYCLE) Slog.v(TAG, "onCreate " + this + ": " + savedInstanceState);
        if (mLastNonConfigurationInstances != null) {
            mFragments.restoreLoaderNonConfig(mLastNonConfigurationInstances.loaders);
        }
        if (mActivityInfo.parentActivityName != null) {
            if (mActionBar == null) {
                mEnableDefaultActionBarUp = true;
            } else {
                mActionBar.setDefaultDisplayHomeAsUpEnabled(true);
            }
        }
        if (savedInstanceState != null) {
            Parcelable p = savedInstanceState.getParcelable(FRAGMENTS_TAG);
            mFragments.restoreAllState(p, mLastNonConfigurationInstances != null
                    ? mLastNonConfigurationInstances.fragments : null);
        }
        mFragments.dispatchCreate();
        getApplication().dispatchActivityCreated(this, savedInstanceState);
        if (mVoiceInteractor != null) {
            mVoiceInteractor.attachActivity(this);
        }
        mCalled = true;
    }

    @CallSuper
    protected void onStart() {
        if (DEBUG_LIFECYCLE) Slog.v(TAG, "onStart " + this);
        mCalled = true;

        mFragments.doLoaderStart();

        getApplication().dispatchActivityStarted(this);
    }
    ...
    }

三、ActivityLifecycleCallbacks的应用

Application.ActivityLifecycleCallbacks中对应的监听的生命周期方法会在Activity中的生命方法调用父类的方法之后被触发，由源码也可得知。

  • 继承Application重写onCreate等方法
  • 调用registerActivityLifecycleCallbacks方法注册ActivityLifecycleCallbacks
package com.crazyview.activitylifecycle;

import android.app.Activity;
import android.app.Application;
import android.os.Bundle;
import android.util.Log;

/**
 * Created by cmo on 2017/12/23.
 */

public class LifecycleApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        init();
    }

    private void init() {
        registerActivityLifecycleCallbacks(new ActivityLifecycleCallbacks() {
            @Override
            public void onActivityCreated(Activity activity, Bundle savedInstanceState) {
                Log.e("Lifecycle",activity.getLocalClassName()+" was Created"+"activity==null   "
                        +(activity==null)+"     activity.isFinishing()  "+(activity.isFinishing())+"    activity.isDestroyed()  "+activity.isDestroyed());
            }

            @Override
            public void onActivityStarted(Activity activity) {
                Log.e("Lifecycle",activity.getLocalClassName()+" was Started"+"activity==null   "
                            +(activity==null)+"     activity.isFinishing()   "+(activity.isFinishing())+"   activity.isDestroyed()  "+activity.isDestroyed());
            }

            @Override
            public void onActivityResumed(Activity activity) {
                 Log.e("Lifecycle",activity.getLocalClassName()+" was oResumed"+"activity==null   "
                        +(activity==null)+"activity.isFinishing()   "+(activity.isFinishing())+"activity.isDestroyed() "+activity.isDestroyed());
            }

            @Override
            public void onActivityPaused(Activity activity) {
                Log.e("Lifecycle",activity.getLocalClassName()+" was Pauseed"+"activity==null   "
                        +(activity==null)+"activity.isFinishing()   "+(activity.isFinishing())+"activity.isDestroyed()  "+activity.isDestroyed());
            }

            @Override
            public void onActivityStopped(Activity activity) {
                Log.e("Lifecycle",activity.getLocalClassName()+" was Stoped"+"activity==null    "
                        +(activity==null)+"activity.isFinishing()   "+(activity.isFinishing())+"activity.isDestroyed() "+activity.isDestroyed());
            }

            @Override
            public void onActivitySaveInstanceState(Activity activity, Bundle outState) {
                Log.e("Lifecycle",activity.getLocalClassName()+" was SaveInstanceState"+"activity==null "
                        +(activity==null)+"activity.isFinishing()   "+(activity.isFinishing())+"activity.isDestroyed()  "+activity.isDestroyed());
            }

            @Override
            public void onActivityDestroyed(Activity activity) {
                Log.e("Lifecycle",activity.getLocalClassName()+" was Destroyed"+"activity==null"
                        +(activity==null)+"  activity.isFinishing()  "+(activity.isFinishing())+"  activity.isDestroyed()"+activity.isDestroyed());
            }
        });
    }
}
  • 在清单中声明Application，无需在Activity添加额外的代码就可以实现监控
package com.crazyview.activitylifecycle;

import android.content.Intent;
import android.os.Bundle;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;

public class MainActivity extends AppCompatActivity {

    public static final String LIFECYCLE = "MainActivity:Lifecycle";

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        Log.e(LIFECYCLE, "onCreate() is Running__before super.onCreate called");
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Log.e(LIFECYCLE, "onCreate() is Running__after super.onCreate called");
    }

    @Override
    protected void onRestart() {
        Log.e(LIFECYCLE, "onRestart() is Running__before super's called");
        super.onRestart();
        Log.e(LIFECYCLE, "onRestart() is Running__after super's called");
    }

    @Override
    protected void onStart() {
        Log.e(LIFECYCLE, "onStart() is Running__before super.onStart called");
        super.onStart();
        Log.e(LIFECYCLE, "onStart() is Running__after super.onStart called");
    }

    @Override
    protected void onResume() {
        Log.e(LIFECYCLE, "onResume() is Running__before super.onResume called");
        super.onResume();
        Log.e(LIFECYCLE, "onResume() is Running__after super.onResume called");
    }

    @Override
    protected void onPause() {
        Log.e(LIFECYCLE, "onPause() is Running__before super's called");
        super.onPause();
        Log.e(LIFECYCLE, "onPause() is Running__after super's called");
    }

    @Override
    protected void onStop() {
        Log.e(LIFECYCLE, "onStop() is Running__before super's called");
        super.onStop();
        Log.e(LIFECYCLE, "onStop() is Running__after super's called");
    }

    @Override
    protected void onDestroy() {
        Log.e(LIFECYCLE, "onDestroy() is Running__before super's called");
        super.onDestroy();
        Log.e(LIFECYCLE, "onDestroy() is Running__after super's called");
    }

    public void toTask(View view) {
        startActivity(new Intent(this, TaskActivity.class));
        //finish();
    }
}

打开MainActivity时候的运行结果：
这里写图片描述
finish当前Activity时：
这里写图片描述

PS:一些有用的adb命令

1、通过adb 命令获取当前运行的Activity

adb shell dumpsys activity | findstr "mFocusedActivity"

2、通过adb 使用命令行截取对应的log并保存到硬盘对应目录下

adb logcat -s tag >d:log.txt

3、将log和当前时间 保存到当前目录下

adb logcat -v time >a.log

4、通过android.app.ActivityManager获取topActivity

 public static String getTopActivity(Context context) {
        android.app.ActivityManager am = (android.app.ActivityManager) context.getSystemService(ACTIVITY_SERVICE);
        ComponentName cn = am.getRunningTasks(1).get(0).topActivity;
        return cn.getShortClassName().toString();
    }
CrazyMo_
关注
专栏目录
Android面试，给正在找工作的安卓攻城师们 ... ...
王丽君同学的专栏
06-30 8054
从java基础技能到安卓进阶技能，有你想象不到的全面。 ☆  JAVA技能 « 有良好的JAVA基础，熟练掌握面向对象思想： 理解面向对象： 面向对象是一种思想，是基于面向过程而言的，就是说面向对象是将功能等通过对象来实现，将功能封装进对象之中，让对象去实现具体的细节；这种思想是将数据作为第一位，而方法或者说是算法作为其次，这是对数据一种优化，操作起来更加的方便，简化了过程。面向对象有三大
Android 中 ActivityLifecycleCallbacks的实例详解
01-20
Android 中 ActivityLifecycleCallbacks的实例详解           以上就是使用ActivityLifecycleCallbacks的实例，代码注释写的很清楚大家可以参考下， MyApplication如下: package com.cc; import java.util.LinkedList; import android.app.Activity; import android.app.Application; import android.os.Bundle; /** * Demo示例: * ActivityLifecycleCallba
Android在Application层级维护和管理全局所有Activity的方法ActivityLifecycleCallbacks
Zhang Phil
06-22 1360
Android在Application层级维护和管理全局所有Activity的方法ActivityLifecycleCallbacks经常看到有些项目中经常性的把所有activity继承自一个base的Activity，然后在每一次启动新activity时候添加当前activity到一个全局List那样的列表中，已达到全局管理和维护activity的目的，这种做法大概是四五年前的技术解决方案。如今...
超实用的Application.ActivityLifecycleCallbacks 实现第一次启动、冷启动、热启动、切换后台以及返回前台功能
最新发布
白高林的专栏
08-08 161
ActivityLifecycleCallbacks监听相关首次、冷、热启动、前后台等
ActivityLifecycleCallbacks
weixin_34357436的博客
02-24 109
2019独角兽企业重金招聘Python工程师标准>>> ...
Android ActivityLifecycleCallbacks
YK
12-02 2819
android-30     ActivityLifecycleCallbacks 是 Application 的一个接口；     Activity 的生命周期，对应 ActivityLifecycleCallbacks 中的方法；     当实现ActivityLifecycleCallbacks 接口后，系统会在在调用 Activity 的方法后，再调用实现的ActivityLi.
Android -- ActivityLifeCycleCallbacks
weixin_33856370的博客
11-11 129
ActivityLifeCycleCallbacks Application通过此接口提供了一套回调方法，用于让开发者对Activity的生命周期事件进行集中处理。 为什么用ActivityLifecycleCallbacks 以往若需监测Activity的生命周期事件代码，你可能是这样做的，重写每一个Acivity的onResume()，然后作统计和处理： @Override protect...
Android ActivityLifecycleCallback使用
wolf0706的专栏
11-02 487
通过实现 ActivityLifecycleCallbacks 接口，可以在 Activity 的创建、启动、暂停、恢复、停止和销毁等各个阶段执行相应的操作。需要注意的是，ActivityLifecycleCallbacks 是 API Level 14 (Android 4.0) 引入的功能，因此在使用时要确保目标设备的最低 API 等级满足要求。应用程序将会在每个 Activity 的生命周期事件发生时调用相应的回调方法，以便根据需要执行特定的操作，例如记录日志、收集统计数据或执行其他自定义逻辑。
Android（安卓）开发零基础入门课程【笔记】
Flameyjh的博客
04-28 3817
此文章是根据B站的视频教程整理总结的笔记，用白话说明一些Android开发的入门知识，共勉。 B站教程链接：https://www.bilibili.com/video/BV13y4y1E7pF?p=12&spm_id_from=pageDriver
Android基础知识
zzh_receive的博客
08-02 991
Android基础知识五种布局： FrameLayout 、 LinearLayout 、 AbsoluteLayout 、 RelativeLayout 、 TableLayout 全都继承自ViewGroup，各自特点及绘制效率对比。 FrameLayout(框架布局)此布局是五种布局中最简单的布局，Android中并没有对child view的摆布进行控制，这个布局中所有的控件都会默认出现在视
Android Service
moira33的博客
01-25 994
【Android Service】 Service 简介（★★★） 很多情况下，一些与用户很少需要产生交互的应用程序，我们一般让它们在后台运 行就行了，而且在它们运行期间我们仍然能运行其他的应用。为了处理这种后台进程， Android 引入了 Service 的概念。 Service 在 Android 中是一种长生命周期的组件，它不实现任何用户界面，是一个没有界面的 Activity
2020 android面试题答案
疾风剑豪
05-04 4926
（1）java面试题（基础+进阶）（必须） java中==和equals和hashCode的区别 ==是运算符，用来比较两个值、两个对象的内存地址是否相等； equals是Object类的方法，默认情况下比较两个对象是否是同一个对象，内部实现是通过“==”来实现的。 如果想比较两个对象的其他内容，则可以通过重写equals方法， hashCoed也是Object类里面的方法，返回值是一个对象的哈希...
Android ActivityLifecycleCallbacks 分析
寻梦者
07-07 1664
最近产品有个需求就是需要统计前台页面的停留时间，用我们程序员的话来说就是统计Activity在前台的时间，也就是如果程序从启动开始到按home键切换到后台的时候的这段时间内。之前还不知道 ActivityLifecycleCallbacks的时候我就写了一个BaseActivity，然后所有的Activity都去继承该类。但是如果后期项目都已经做好了的话，那在统计的时候就有可能会出现统计不完整的情况
Android 生命周期 - ActivityLifecycleCallbacks
u012005313的专栏
07-19 1211
参考：Android Studio 活动的最佳实践 知晓当前是在哪一个活动 随时随地地进入程序 启动活动的最佳写法 第一行代码：http://blog.csdn.net/u012005313/article/details/47018101 之前在郭霖的《第一行代码》里学习到一种方法，可以知晓当前运行在哪个活动的哪个生命周期方法中，非常好用，现在又有了一种新的方法，可以知晓当前活动的生命周期主要内
Android 集中处理Activity的生命周期事件: Application.ActivityLifecycleCallbacks
打渔还是晒网 —— stone
03-03 1722
ActivityLifecycleCallbacks可以用来集中处理Activity的生命周期事件。API Level 14之后，开始支持。其声明在Application中： public interface ActivityLifecycleCallbacks { void onActivityCreated(Activity activity, Bundle savedIn
Android 使用 Application.ActivityLifecycleCallbacks 来判断应用前后台状态的监听
WindfallSheng的博客
04-07 974
Android 使用 Application.ActivityLifecycleCallbacks 来处理应用前后台切换状态的监听： package com.windfallsheng.base; import android.app.Activity; import android.app.Application; import android.os.Bundle; import androidx.annotation.NonNull; import androidx.annotation.Null
Android中ActivityLifecycleCallbacks的使用
Jason_Lee155的博客
04-21 3481
一、ActivityLifecycleCallbacks接口介绍 官方地址：https://developer.android.com/reference/android/app/Application.ActivityLifecycleCallbacks 在 Android API 14之后的Application类中，为我们提供了一个应用生命周期回调的注册方法，用来对应用的生命周期进行集中管理，这个接口叫registerActivityLifecycleCallbacks，可以通过它注册自己的Act
Application.ActivityLifecycleCallbacks监听App进入前后台状态最佳实践
群鸿
01-23 2366
笔者最近在一款Android端App产品开发中，有这样一个需求：监听当前App的状态：处于前台，亦或是后台？ 产品需求：当用户点击当前播放视频进入后台，视频暂停，再次进入前台，首先获取服务器播放进度，然后更新本地视频播放进度，以此保证App端视频的同步。 笔者在一番技术选型之后，决定使用 Application.ActivityLifecycleCallbacks 来处理，至于其原理和简述，读...
Android中ActivityLifecycleCallbacks监听Activity们的生命周期
热门推荐
lintcgirl的博客
05-04 1万+
如果你还在Activity的声明周期函数（onCreate、onStart）打印log来看activity的声明周期，那么你就out了！ 今天楼主叫你用ActivityLifecycleCallbacks来监听activity们的声明周期。 接下来上代码： AndroidManifest.xml： <manifest xmlns:android="http://schemas.andro
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CrazyMo_

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值