Application 组件设计

为什么我要封装 application

application 在以前是非常重要的一个地方，刚开始开发时我们会在 application 中存储数据，提供全局公共方法，application 尽管很方便，但是渐渐的我们还是放弃了在 application 里面做其余的工作，现在 application 主要的应用场景是：

• 提供全局上下文对象

• 管理 app 生命周期

但是我在使用 application 时还是遇到了少量问题不好解决：

• 平台化时，公司一个团队要同时开发多个 app，不同的 app 有不同的 application 实现类，这样我们在业务module 里怎样统一方便的拿到 application

• application 没有提供 启动，退出，切到后端，前端的相应方法

• 没有优雅的退出 app 的方法

• 没有能拿到 app 当前状态的地方，ActivityManage 又存在适配问题，有的设施 TM 的就是出幺蛾子

我想大家都曾为了上面的问题烦恼过吧，也许你已经处理了，也许你只是临时处理了，也许你还没处理。同样这也困扰过我，以前我只是临时处理，代码耦合难看，还没发适应越来越高的复用要求，一处该，处处动，这样的代码不是我想要的，早就该扫到垃圾箱里去了，于是诞生了今天的文章

我对 application 是这样安排的:

• 使用代理商统一方便的对外提供 application 上下文对象

• 自己计数，精确的提供 app 启动，退出，切到后端，前端的回调

• 自己维护 app 当前的状态

• 仿照 Lifecycle 的思路，把相应的生命周期回调改成响应式

• 优雅的退出 app

话说官方的 Lifecycle 刚出来时我是非常兴奋的，我想这下 app 的生命周期该好用了吧，兴奋的我一看官方压根就没动 application，只是把 Activity 的公告周期函数响应式化了，我是很失望的，也许 google 考虑兼容性吧

• github 地址
  zb25810045/BW_Libs

回顾下 ActivityLifecycleCallbacks

application 的核心就是这个了，一切的基础都是他在身上做的

public class Application extends ContextWrapper implements ComponentCallbacks2 {    private ArrayList<ActivityLifecycleCallbacks> mActivityLifecycleCallbacks = new ArrayList<ActivityLifecycleCallbacks>();    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);    }}

我们平常使用 ActivityLifecycleCallbacks 基本都是这个样子的

         this.registerActivityLifecycleCallbacks(object : ActivityLifecycleCallbacks {            override fun onActivityCreated(activity: Activity?, savedInstanceState: Bundle?) {                Log.d("AA", "onActivityCreated")            }            override fun onActivityResumed(activity: Activity?) {                Log.d("AA", "onActivityResumed")            }            override fun onActivityStarted(activity: Activity?) {                Log.d("AA", "onActivityStarted")            }            override fun onActivityPaused(activity: Activity?) {                Log.d("AA", "AA")            }            override fun onActivityDestroyed(activity: Activity?) {                Log.d("AA", "onActivityDestroyed")            }            override fun onActivitySaveInstanceState(activity: Activity?, outState: Bundle?) {                Log.d("AA", "onActivitySaveInstanceState")            }            override fun onActivityStopped(activity: Activity?) {                Log.d("AA", "onActivityStopped")            }        })

跟进源码看看

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

注意看是 add 方法，这说明啥，这说明 ActivityLifecycleCallbacks 我们可以增加多个，Activity 会在相应的生命周期函数中发射相关消息

  protected void onCreate(@Nullable Bundle savedInstanceState) {        getApplication().dispatchActivityCreated(this, savedInstanceState);}    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);            }        }    }

我们增加 2个 ActivityLifecycleCallbacks 进去

事实证实，确实可以增加多个回调，并且没有问题，这也是我们自己封装 application 组件的基石

类结构

我就不画 UML 类图，由于很简单

考虑到我要在 application 组件里增加很多功能进来，那么良好正当的分层就必不可少了，即使是该功能非常简单，直接在 ApplicationManage 里实现更方便，但是基于单一职责准则必需分工明确，现在费点劲，以后省大事

我设计了以下几个角色：

• ApplicationManage - 提供统一入口，对外提供功能，内部封装管理各细分功能实现和相互交互

• exit - 用于优雅退出 app

• ExitActivity - 阻拦 app 退出事件

• ExitManage - 管理 app 退出功能，对 ApplicationManage 提供功能实现

• ExitMessage - app 退出相关参数

• Lifecycle - app 生命周期改响应式

• LifecycleManage - 用于发射相关消息

• LifecycleMessage - 消息数据类型

• StateManage - app 状态管理

Lifecycle 和 StateManage 都是私有的，不是应该外部可见的。外部只要要注册生命周期的 observer，不需要知道我怎样实现的。同样 外部不需要知道我们怎样管理的 app 当前状态，只要要知道现在 app 是个什么样子。这部分我通过 ApplicationManage 对外提供相应方法

另外我在写消息类型和 app 状态类型时，我考虑了下相应的 type 放在哪里合适，是相应 manage 的内部类，还是专门一个类。内部类方便外界使用，专门的类方便查看代码结构，这就得看实际场景了，Lifecycle 这块我是用的内部类做的，这样逻辑顺延好些代码，exit 这块基本都是对内的，不暴露出来，所以专门维护了一个类

使用效果

class MyApplication : Application() {    override fun onCreate() {        super.onCreate()        ScreenAutoManager.instance.init(this, 1080.0f, ScreenAutoManager.BASE_LINE_WIDTH)        ApplicationManage.init(this)        ApplicationManage.instance.addObserver { lifecycleMessage ->            when (lifecycleMessage.type) {                ApplicationManage.MessageType.MESSAGE_ACTIVITY_CREATE -> {                    if (lifecycleMessage.activity != null) ScreenAutoManager.instance.onActivityCreated(lifecycleMessage.activity)                    Log.d("AA", "MESSAGE_ACTIVITY_CREATE")                }                ApplicationManage.MessageType.MESSAGE_ACTIVITY_START -> {                    if (lifecycleMessage.activity != null) ScreenAutoManager.instance.onActivityStarted(lifecycleMessage.activity)                    Log.d("AA", "MESSAGE_ACTIVITY_START")                }                ApplicationManage.MessageType.MESSAGE_ACTIVITY_RESUME -> {                    if (lifecycleMessage.activity != null) ScreenAutoManager.instance.onActivityResumed(lifecycleMessage.activity)                    Log.d("AA", "MESSAGE_ACTIVITY_RESUME")                }                ApplicationManage.MessageType.MESSAGE_ACTIVITY_PAUSE -> Log.d("AA", "MESSAGE_ACTIVITY_PAUSE")                ApplicationManage.MessageType.MESSAGE_ACTIVITY_STOP -> Log.d("AA", "MESSAGE_ACTIVITY_STOP")                ApplicationManage.MessageType.MESSAGE_ACTIVITY_SAVEINSTANCESTATE -> Log.d("AA", "MESSAGE_ACTIVITY_SAVEINSTANCESTATE")                ApplicationManage.MessageType.MESSAGE_ACTIVITY_DESTROYED -> Log.d("AA", "MESSAGE_ACTIVITY_DESTROYED")                ApplicationManage.MessageType.MESSAGE_APP_START -> Log.d("AA", "MESSAGE_APP_START")                ApplicationManage.MessageType.MESSAGE_APP_EXIT -> Log.d("AA", "MESSAGE_APP_EXIT")                ApplicationManage.MessageType.MESSAGE_APP_FORNT -> Log.d("AA", "MESSAGE_APP_FORNT")                ApplicationManage.MessageType.MESSAGE_APP_BACKGROUD -> Log.d("AA", "MESSAGE_APP_BACKGROUD")            }        }    }

改造 application 生命周期管理

我个人是很喜欢 Lifecycle 的，官方人家可是用的 apt 做的，我注解这块写不好，借助的是 Livedata，在 registerActivityLifecycleCallbacks 时发射相应的消息出来

class LifecycleManage {    var lifecycleLivaData: MyLiveData<LifecycleMessage> = MyLiveData()    /**     * 初始化方法     */    fun init(application: Application) {        registerActivityLifecycleCallbacks(application)    }    /**     * 注册 application 生命周期回调函数，在对应的函数回调中发射对应的消息     */    private fun registerActivityLifecycleCallbacks(application: Application) {        if (application == null) return        application.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {            override fun onActivityCreated(activity: Activity?, savedInstanceState: Bundle?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_CREATE, activity = activity, savedInstanceState = savedInstanceState))            }            override fun onActivityStarted(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_START, activity = activity))            }            override fun onActivityResumed(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_RESUME, activity = activity))            }            override fun onActivityPaused(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_PAUSE, activity = activity))            }            override fun onActivityStopped(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_STOP, activity = activity))            }            override fun onActivityDestroyed(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_DESTROYED, activity = activity))            }            override fun onActivitySaveInstanceState(activity: Activity?, outState: Bundle?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_SAVEINSTANCESTATE, activity = activity, savedInstanceState = outState))            }        })    }}

而后大家通过 ApplicationManage 实现注册 observer

    fun addObserver(tag: String? = null, lifecycle: Lifecycle? = null, observer: (lifecycleMessage: LifecycleMessage) -> Unit) {        lifecycleManage.lifecycleLivaData.addObserver(tag, lifecycle, observer)    }

而后是使用

        ApplicationManage.instance.addObserver { lifecycleMessage ->            when (lifecycleMessage.type) {                ApplicationManage.MessageType.MESSAGE_ACTIVITY_CREATE -> {                    if (lifecycleMessage.activity != null) ScreenAutoManager.instance.onActivityCreated(lifecycleMessage.activity)                    Log.d("AA", "MESSAGE_ACTIVITY_CREATE")                }                ApplicationManage.MessageType.MESSAGE_ACTIVITY_START -> {                    if (lifecycleMessage.activity != null) ScreenAutoManager.instance.onActivityStarted(lifecycleMessage.activity)                    Log.d("AA", "MESSAGE_ACTIVITY_START")                }                ApplicationManage.MessageType.MESSAGE_ACTIVITY_RESUME -> {                    if (lifecycleMessage.activity != null) ScreenAutoManager.instance.onActivityResumed(lifecycleMessage.activity)                    Log.d("AA", "MESSAGE_ACTIVITY_RESUME")                }                ApplicationManage.MessageType.MESSAGE_ACTIVITY_PAUSE -> Log.d("AA", "MESSAGE_ACTIVITY_PAUSE")                ApplicationManage.MessageType.MESSAGE_ACTIVITY_STOP -> Log.d("AA", "MESSAGE_ACTIVITY_STOP")                ApplicationManage.MessageType.MESSAGE_ACTIVITY_SAVEINSTANCESTATE -> Log.d("AA", "MESSAGE_ACTIVITY_SAVEINSTANCESTATE")                ApplicationManage.MessageType.MESSAGE_ACTIVITY_DESTROYED -> Log.d("AA", "MESSAGE_ACTIVITY_DESTROYED")                ApplicationManage.MessageType.MESSAGE_APP_START -> Log.d("AA", "MESSAGE_APP_START")                ApplicationManage.MessageType.MESSAGE_APP_EXIT -> Log.d("AA", "MESSAGE_APP_EXIT")                ApplicationManage.MessageType.MESSAGE_APP_FORNT -> Log.d("AA", "MESSAGE_APP_FORNT")                ApplicationManage.MessageType.MESSAGE_APP_BACKGROUD -> Log.d("AA", "MESSAGE_APP_BACKGROUD")            }        }

可以看到这里 app 的启动，退出，前后端切换我也都发送相关的消息了

实现不难，思路就使用 livedata 在合适的位置转发一下数据，官方的 Lifecycle 也是这个思路做的

判断 app 启动，退出，前后端切换

我想大家都关心这个，相信大家也都有自己的实现，基本思路都是在 registerActivityLifecycleCallbacks 里升级计数器判断 app 状态，这里我也是一样的，只不过多了一步罢了

我标识了 app 的3种状态: app state 默认是 no - app没启动

val STATE_APP_NO: Int = 31val STATE_APP_FORNT: Int = 32val STATE_APP_BACKGROUD: Int = 33

判断逻辑如下：

• app 启动 - 触发 create 函数，state = STATE_APP_NO，说明 app 之前没启动，那么此时必然就是启动了

• app 退出 - 触发 destroy 函数，若活跃 activity 计数 =0 了，那说明 app 就是关闭了

• app 切入后端 - 触发 stop 函数，活跃 activity 计数先--，若 =0 了并且 state = STATE_APP_FORNT，那就是说明前端没有活跃显示的 activity 了，进入后端了

• app 切回前端 - 触发 start 函数，先判断 活跃 activity 计数，若 =0 了并且 state = STATE_APP_BACKGROUD，那说明又切回前端来了，计数器再++

注意：onActivityStarted 这个函数即表示 onStart，也表示 onRestart ，所以在计数时要更外小心，由于 start 的起因 oncreate 不适合计数器++了，要不会和 start 重复

这样我们也可以返回 app 当前的状态了，不用再用 AM 来判断了，AM 很多人反应部分手机无效，其实返回 app 状态的这个小功能非常实用的，在推送时我们要判断 app 是不是启来了，由于由不同的操作

优雅的退出 app

我这里思路很简单，就是主界面下面垫一个透明无界面的 Activity，我们想退出 app 时启动这个 Activity，在 onNewIntent 里面 finish 页面就行了，不过这个功能有侵入行：

• 一是需要屏蔽主界面的 onBackPressed 函数，不控制返回键的话就回到这个透明的页面了

• 二是闪屏页启动主界面时需要使用该功能的启动页面方法

// 退出 appApplicationManage.instance.exitmanage.exitApp()// 代理商方法启动主界面ApplicationManage.instance.exitmanage.startActivityProxy(this, Intent(this@SplaseActivity, MainActivity::class.java))// 屏蔽主界面返回按键默认操作override fun onBackPressed() {//  super.onBackPressed()}

具体代码

我知道大家都懒得看 demo，这代码长也得贴出来

• ApplicationManage

/** * 作者 ： BloodCrown * 时间 ： 2019-05-08 21:33 * 形容 ： *  application 封装类，在方便提供 application 上下文对象的同时， *  也提供了少量功能 * * 功能 ： *  1. Application 上下文代理商，任何板块都不必关心 application 具体的实现类型 *  有 ApplicationManage 在时刻都能获取全局上下文对象 * *  2. 提供优雅退出 app 的功能，通过在主页面下面增加一个透明的 activity + singleTask 实现优雅退出 * *  3. Application 的生命周期实现响应式，像 EventBus，RxBus 那样响应消息就行，另外我还增加了 *  app 启动，退出，切入后端，切回前端的相应进来 * *  4. 在实现功能3时，实现了 app 当前状态的保存，极大的方便了我们在注入推送时判断 app 能否启动等操作 * *  最后说一点，我没有使用 ActivityManage 来判断 app 状态，由于 ActivityManage 存在适配问题， *  总有那么一小撮手机就是不配合，臣妾也是没办法呀~ * */class ApplicationManage {    companion object Help {        // 饿汉式单例，加上同步限制，这样可以避免 application 操作类单例为null 的情况        val instance: ApplicationManage by lazy(LazyThreadSafetyMode.SYNCHRONIZED) {            return@lazy ApplicationManage()        }        // 标准初始化方法，        fun init(application: Application) {            instance.init(application)        }    }    // 全局上下文对象    var application: Application? = null    // 退出 app 工具类    var exitmanage: ExitManage = ExitManage()    // app 全局生命周期管理类，使用 livedata 实现，考虑其若是外部可见，就能使用他乱发射数据，数据私有    private var lifecycleManage: LifecycleManage = LifecycleManage()    // app 状态管理类，也是私有，这个实现绝对是不对外的，大家关心结果就好了，由 ApplicationManage 衔接    private var stateManage: StateManage = StateManage()    /**     * 初始化方法私有，由静态方法衔接     */    private fun init(application: Application) {        this.application = application        lifecycleManage.init(application)        stateManage.initStateManage(lifecycleManage)    }    /**     * 增加监听     */    fun addObserver(tag: String? = null, lifecycle: Lifecycle? = null, observer: (lifecycleMessage: LifecycleMessage) -> Unit) {        lifecycleManage.lifecycleLivaData.addObserver(tag, lifecycle, observer)    }    /**     * 解绑     */    fun removeobserver(tag: String) {        lifecycleManage.lifecycleLivaData.removeOberver(tag)    }    /**     * 获取当前 app 状态     */    fun getCurrentState(): Int {        return stateManage.STAET_CURRENT    }    /**     * 消息类型     */    class MessageType {        companion object {            // 对应 activity 的生命周期            @JvmField            val MESSAGE_ACTIVITY_CREATE: Int = 11            @JvmField            val MESSAGE_ACTIVITY_RESUME: Int = 12            @JvmField            val MESSAGE_ACTIVITY_START: Int = 13            @JvmField            val MESSAGE_ACTIVITY_PAUSE: Int = 14            @JvmField            val MESSAGE_ACTIVITY_STOP: Int = 15            @JvmField            val MESSAGE_ACTIVITY_DESTROYED: Int = 16            @JvmField            val MESSAGE_ACTIVITY_SAVEINSTANCESTATE: Int = 17            // app 启动，退出,切换到前端，切换到后端            @JvmField            val MESSAGE_APP_START: Int = 21            @JvmField            val MESSAGE_APP_EXIT: Int = 25            @JvmField            val MESSAGE_APP_FORNT: Int = 22            @JvmField            val MESSAGE_APP_BACKGROUD: Int = 23        }    }}

• LifecycleManage

/** * 作者 ： BloodCrown * 时间 ： 2019-05-08 21:38 * 形容 ： */class LifecycleManage {    var lifecycleLivaData: MyLiveData<LifecycleMessage> = MyLiveData()    /**     * 初始化方法     */    fun init(application: Application) {        registerActivityLifecycleCallbacks(application)    }    /**     * 注册 application 生命周期回调函数，在对应的函数回调中发射对应的消息     */    private fun registerActivityLifecycleCallbacks(application: Application) {        if (application == null) return        application.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks {            override fun onActivityCreated(activity: Activity?, savedInstanceState: Bundle?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_CREATE, activity = activity, savedInstanceState = savedInstanceState))            }            override fun onActivityStarted(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_START, activity = activity))            }            override fun onActivityResumed(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_RESUME, activity = activity))            }            override fun onActivityPaused(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_PAUSE, activity = activity))            }            override fun onActivityStopped(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_STOP, activity = activity))            }            override fun onActivityDestroyed(activity: Activity?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_DESTROYED, activity = activity))            }            override fun onActivitySaveInstanceState(activity: Activity?, outState: Bundle?) {                lifecycleLivaData.sendValue(LifecycleMessage(type = ApplicationManage.MessageType.MESSAGE_ACTIVITY_SAVEINSTANCESTATE, activity = activity, savedInstanceState = outState))            }        })    }}

• LifecycleMessage

class LifecycleMessage(var type: Int, var activity: Activity? = null, var savedInstanceState: Bundle? = null) {}

• StateManage

/** * 作者 ： BloodCrown * 时间 ： 2019-05-09 21:32 * 形容 ： */class StateManage {    companion object stateType {        // 没启动，前端，后端        @JvmField        val STATE_APP_NO: Int = 31        @JvmField        val STATE_APP_FORNT: Int = 32        @JvmField        val STATE_APP_BACKGROUD: Int = 33    }    var STAET_CURRENT: Int = STATE_APP_NO    var aliveActivitys: Int = 0    fun initStateManage(lifecycleManage: LifecycleManage) {        if (lifecycleManage == null) return        addObserver(lifecycleManage)    }    /**     * 增加管理器     */    private fun addObserver(lifecycleManage: LifecycleManage) {        if (lifecycleManage == null) return        lifecycleManage.lifecycleLivaData.addObserver {            when (it.type) {                ApplicationManage.MessageType.MESSAGE_ACTIVITY_CREATE -> {                    // 标记是没启动，那么触发 create 肯定是app 启动                    if (STAET_CURRENT == STATE_APP_NO) {                        STAET_CURRENT = STATE_APP_FORNT                        lifecycleManage.lifecycleLivaData.sendValue(LifecycleMessage(ApplicationManage.MessageType.MESSAGE_APP_START))                    }                }                ApplicationManage.MessageType.MESSAGE_ACTIVITY_START -> {                    // 活动 ac 数量为0，并且当前标记是 app 在后端，那么此时触发 start，那么就是切会到前端来了                    if (aliveActivitys == 0 && STAET_CURRENT == STATE_APP_BACKGROUD) {                        STAET_CURRENT = STATE_APP_FORNT                        lifecycleManage.lifecycleLivaData.sendValue(LifecycleMessage(ApplicationManage.MessageType.MESSAGE_APP_FORNT))                    }                    aliveActivitys++                }                ApplicationManage.MessageType.MESSAGE_ACTIVITY_STOP -> {                    aliveActivitys--                    if (aliveActivitys == 0 && STAET_CURRENT == STATE_APP_FORNT) {                        STAET_CURRENT = STATE_APP_BACKGROUD                        lifecycleManage.lifecycleLivaData.sendValue(LifecycleMessage(ApplicationManage.MessageType.MESSAGE_APP_BACKGROUD))                    }                }                ApplicationManage.MessageType.MESSAGE_ACTIVITY_DESTROYED -> {                    if (aliveActivitys == 0) {                        STAET_CURRENT = STATE_APP_NO                        lifecycleManage.lifecycleLivaData.sendValue(LifecycleMessage(ApplicationManage.MessageType.MESSAGE_APP_EXIT))                    }                }            }        }    }}

• ExitActivity

class ExitActivity : AppCompatActivity() {    override fun onCreate(savedInstanceState: Bundle?) {        super.onCreate(savedInstanceState)        setContentView(R.layout.activity_exit)    }    override fun onNewIntent(intent: Intent?) {        super.onNewIntent(intent)        if (intent == null) return        val action: Int = intent.getIntExtra(ExitMessage.MESSAGE_ACTION, ExitMessage.ACTION_EXIT)        when (action) {            ExitMessage.ACTION_EXIT -> this@ExitActivity.finish()            else -> this@ExitActivity.finish()        }    }}

class ExitManage {    fun exitApp(): Boolean {        if (ApplicationManage.instance.application == null) return false        var intent = Intent(ApplicationManage.instance.application, ExitActivity::class.java)        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)        ApplicationManage.instance.application?.startActivity(intent)        return true    }    fun exitAppBySystem() {        System.exit(0)    }    fun startActivityProxy(activity: Activity, intentYou: Intent) {        if (activity == null) return        var intentExit = Intent(activity, ExitActivity::class.java)        intentExit.putExtra(ExitMessage.MESSAGE_ACTION, ExitMessage.ACTION_EXIT)        activity.startActivity(intentExit)        activity.startActivity(intentYou)    }}

• ExitMessage

object ExitMessage {    val MESSAGE_ACTION: String = "message_action"    val ACTION_EXIT: Int = 101}

能看到这里的都是相当给面子的了~

最后吐槽下吧

锁屏，解锁时我即使按照下面的设置设了

android:screenOrientation="portrait"android:configChanges="orientation|screenSize|keyboardHidden"

但是蛋疼的有的手机就是不给面子，还是会走1-2遍 activity 销毁，重建的过程，太蛋疼了，手头的 meizu 16h就这样，好在这样的手机只是少部分，但是带给我们的影响就是前后端切换的消息会走好几次，这我也没办法，昨天下午一下午的时间就是在找资料搞订这个，一下午的时间过去了也不行，算了就这样吧，大家记得android 这啃爹玩意完事不是 100% 有些偏差就得了，我监听锁屏，解锁广播，发现最后才收到广播，公告周期函数早就执行完了，广播才来还有个P用啊

唉，一下午的时间身心俱疲啊~

觉得有帮助的话大家点点喜欢支持一下

更多资料分享欢迎Android工程师朋友们加入安卓开发技术进阶互助：856328774免费提供安卓开发架构的资料（包括Fultter、高级UI、性能优化、架构师课程、 NDK、Kotlin、混合式开发（ReactNative+Weex）和一线互联网公司关于Android面试的题目汇总。