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 考虑兼容性吧
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 进去
image事实证实，确实可以增加多个回调，并且没有问题，这也是我们自己封装 application 组件的基石
我就不画 UML 类图，由于很简单
image考虑到我要在 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") } } }我个人是很喜欢 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 也是这个思路做的
我想大家都关心这个，相信大家也都有自己的实现，基本思路都是在 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 是不是启来了，由于由不同的操作
我这里思路很简单，就是主界面下面垫一个透明无界面的 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，这代码长也得贴出来
/** * 作者 ： 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 } }}/** * 作者 ： 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)) } }) }}class LifecycleMessage(var type: Int, var activity: Activity? = null, var savedInstanceState: Bundle? = null) {}/** * 作者 ： 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)) } } } } }}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) }}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用啊
唉，一下午的时间身心俱疲啊~
觉得有帮助的话大家点点喜欢支持一下