Application 组件设计

最新推荐文章于 2020-11-26 19:55:15 发布
最新推荐文章于 2020-11-26 19:55:15 发布
阅读量249 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/H176Nhx7/article/details/90205005
版权 
 
 
code小生,一个专注 Android 领域的技术平台
 
 
公众号回复 Android 加入我的安卓技术群
 
 
 
  
作者：血色王冠
链接：https://juejin.im/post/5cd5154951882535d137aee3
声明：本文来自血色王冠投稿，转发等请联系原作者授权
 
 
 
 
为什么我要封装 application 
 
 
application 在以前是非常重要的一个地方，刚开始开发时我们会在 application 中存储数据，提供全局公共方法，application 虽然很方便，但是渐渐的我们还是放弃了在 application 里面做其他的工作，现在 application 主要的应用场景是：
 
 
但是我在使用 application 时还是遇到了一些问题不好处理：
 
 
我想大家都曾为了上面的问题烦恼过吧，也许你已经解决了，也许你只是临时解决了，也许你还没解决。同样这也困扰过我，以前我只是临时解决，代码耦合难看，还没发适应越来越高的复用要求，一处该，处处动，这样的代码不是我想要的，早就该扫到垃圾箱里去了，于是诞生了今天的文章
 
 
我对 application 是这样安排的:
 
 
话说官方的 Lifecycle 刚出来时我是非常兴奋的，我想这下 app 的生命周期该好用了吧，兴奋的我一看官方压根就没动 application，只是把 Activity 的声明周期函数响应式化了，我是很失望的，也许 google 考虑兼容性吧
 
 
 
 
回顾下 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);    }}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")            }        })

            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);        }    }
        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);            }        }    }
        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  进去
 
 
 
  640?wx_fmt=png 
 
 
 
事实证明，的确可以添加多个回调，并且没有问题，这也是我们自己封装 application 组件的基石
 
 
 
 
类结构 
 
 
我就不画 UML 类图，因为很简单
 
 
 
  640?wx_fmt=png 
 
 
 
考虑到我要在 application 组件里添加很多功能进来，那么良好合理的分层就必不可少了，即便是该功能非常简单，直接在 ApplicationManage 里实现更方便，但是基于单一职责原则必须分工明确，现在费点劲，以后省大事
 
 
我设计了以下几个角色：
 
 
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")            }        }    }

    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))            }        })    }}
    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)    }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")            }        }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 = 33Int = 31
val STATE_APP_FORNT: Int = 32
val STATE_APP_BACKGROUD: Int = 33
 
 
判断逻辑如下：
 
 
注意：onActivityStarted 这个函数即表示 onStart，也表示 onRestart ，所以在计数时要更外小心，因为 start  的原因 oncreate 不适合计数器++了，要不会和 start  重复
 
 
这样我们也可以返回 app 当前的状态了，不用再用 AM 来判断了，AM 很多人反应部分手机无效，其实返回 app 状态的这个小功能非常实用的，在推送时我们要判断 app 是不是启来了，因为由不同的操作
 
 
 
 
优雅的退出 app 
 
 
我这里思路很简单，就是主界面下面垫一个透明无界面的 Activity，我们想退出 app 时启动这个 Activity，在 onNewIntent 里面 finish 页面就行了，不过这个功能有侵入行：
 
 
// 退出 appApplicationManage.instance.exitmanage.exitApp()// 代理方法启动主界面ApplicationManage.instance.exitmanage.startActivityProxy(this, Intent(this@SplaseActivity, MainActivity::class.java))// 屏蔽主界面返回按键默认操作override fun onBackPressed() {//  super.onBackPressed()}
ApplicationManage.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        }    }}
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 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) {}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 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()        }    }}

    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)    }}

    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}
    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用啊
 
 
唉，一下午的时间身心俱疲啊~
 
 
我知道高玩们是看不上我这篇文章的，不喷我就是好的了，全当是自娱自乐吧
 
 
640?wx_fmt=jpeg
 
 
支持，「在看」640
 


                

        

        

    

  


    

      

        

            

              
                
                  code小生_
                
              
            

            

                关注
              
            

        

        

          
      

      









                



	

		

			

				
					
Application=Code+Markup

				
			

			

				

					08-18
				

			

		

		

			
				
Application=Code+Markup绝对的中文版。在网上长的好长时间

			
		

	



                

              
                



	

		

			

				
					
组件化之Application

					
最新发布

				
			

			

				

					qq_34022794的博客
				

				

					07-03
					
					76
					
				

			

		

		

			
				
并在AndroidManifest.xml中配置。四、在主app模块中实现Application。三、创建基类Application。

			
		

	



                


  
              

                


	

		

			

				
					
application 组件设计

				
			

			

				

					weixin_34363171的博客
				

				

					05-10
					
					124
					
				

			

		

		

			
				
大家给点评论好不好，我发上来是希望看看大家的意见想法，赞对我没太大的意义

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

			
		

	





	

		

			

				
					
应用程序组件------Application

				
			

			

				

					Callanna的专栏
				

				

					11-27
					
					352
					
				

			

		

		

			
				
Application和Activity,Service一样是android框架的一个系统组件，当android程序启动时系统会创建一个 application对象，用来存储系统的一些信息。类似的，Java，C运行时都有自己的主函数，其实在android.app.Application这个类的onCreate才是真正的Android入口点，只不过大多数开发者无需重写该类，系统会自动帮我们创建，如果需

			
		

	



		

			
		



	

		

			

				
					
ASP.NET组件设计

				
			

			

				

					08-18
				

			

		

		

			
				
ASP.NET组件设计是Web开发领域中的一个重要概念，它涉及到如何构建可重用、高效且易于维护的代码模块。ASP.NET是Microsoft .NET框架的一部分，它为开发者提供了丰富的工具和技术来创建动态网页应用。本资源“《深入...

			
		

	





	

		

			

				
					
MyApplication:组件化、

				
			

			

				

					05-26
				

			

		

		

			
				
在IT行业中，组件化是一种将复杂系统分解为可重用、独立部分的软件设计方法。在Java编程中，组件化是构建大型应用的关键技术之一，它有助于提高代码的可维护性、可扩展性和复用性。针对“MyApplication”这个项目，...

			
		

	





	

		

			

				
					
Java组件设计.pdf

				
			

			

				

					10-01
				

			

		

		

			
				
在本段落中，我们能够了解到与Java组件设计相关的多个重要知识点。以下是对文档内容的详细解释：  1. **Java组件设计**: 文档的标题表明这是关于Java组件设计的内容。Java组件设计通常涉及创建、维护和集成可在多个...

			
		

	





	

		

			

				
					
MyApplication.zip

				
			

			

				

					04-23
				

			

		

		

			
				
在Android开发中，自由移动组件（Free Floating Components）是一种创新的UI设计，允许用户在屏幕上自由拖动和放置应用的各个部分，以实现高度自定义的界面布局。这种技术能够提高用户体验，尤其适用于那些需要多...

			
		

	





	

		

			

				
					
BAS app ui设计组件包 .psd素材下载

				
			

			

				

					04-20
				

			

		

		

			
				
“BAS app ui设计组件包”标签表明了这个资源是专门为BAS（可能是Business Application System或某种特定的应用场景）的用户界面设计的，意味着它可能包含符合商业应用审美和功能需求的元素。而“psd素材下载”则...

			
		

	





	

		

			

				
					
关于Application组件和Context

				
			

			

				

					Jrue的专栏
				

				

					11-20
					
					532
					
				

			

		

		

			
				
一、Application的定义

			
		

	





	

		

			

				
					
Application Loader 的使用以及常见问题汇总

				
			

			

				

					blueCat_1128的博客
				

				

					08-02
					
					1万+
					
				

			

		

		

			
				
Application Loader的使用，以及上传过程中的常见问题汇总

			
		

	





	

		

			

				
					
好尴尬的错误： Please specify constructor invocation; classifier 'Basics' does not have a companion object

				
			

			

				

					androidfszl的博客
				

				

					06-14
					
					3192
					
				

			

		

		

			
				
好尴尬的错误： Please specify constructor invocation; classifier 'Basics' does not have a companion object

			
		

	





	

		

			

				
					
Android Kotlin开发之使用object和companion object

				
			

			

				

					宝爷的专栏
				

				

					11-11
					
					2708
					
				

			

		

		

			
				
Java中修饰静态方法，使用关键字static，例如：

class Util {


    public static String getCurrentVersion() {
        return BuildConfig.VERSION_NAME;
    }

}

调用：Stringversion_name = Util.getCurrentVersion();

Kotlin语言中使用"object"修饰静态类，被修饰的类，可以使用类名.方法名的形式调用，如下：


object Ut.

			
		

	





	

		

			

				
					
Android-组件化如何处理多个ModuleApplication共存问题？

					
热门推荐

				
			

			

				

					浅浅同学的开发笔记
				

				

					08-27
					
					2万+
					
				

			

		

		

			
				
一个美好的设想

组件化的目的是为了业务解耦，每个业务模块需要不同的功能，例如车辆详情模块需要第三方分享，城市定位模块需要百度地位等。有些特殊功能的初始化需要在 Application 中去做，但是这些功能并非全部业务组件都用到的东西，放到 BaseApplication 不合适。

因此，我想这样操作：


模块共有的初始化，放入BaseApplication 中。
模块自身的特殊功能初始化，放...

			
		

	





	

		

			

				
					
安卓核心五application组件

				
			

			

				

					lucky_eyefocus的博客
				

				

					01-07
					
					376
					
				

			

		

		

			
				
安卓核心五application组件
简介：application组件，在注册方式上来说，这也是一个核心组件，因为这个组件在使用的时候同样要注册，但是这个组件代表了整个应用，根据这个特征可以用于存储一些全局变量，这样变量的生命周期会延长到整个应用。
- 使用方式：使用方式和service类似，编写类继承application，然后在AndroidManifest.xml文件中声明，生命方式也很简单，

			
		

	





	

		

			

				
					
VS2012中自定义工具“MyApplicationCodeGenerator”与文件“My Project\Application.myapp”相关联，但在项目中找不到该自定义工具的输出

				
			

			

				

					业精于勤，荒于嬉
				

				

					07-31
					
					1373
					
				

			

		

		

			
				
重装系统后安装了VS2012代替了之前的2010版本，但是出现了下述问题。
      一调试就出现自定义工具无法使用的警告，虽然不耽误运行但是看的很心烦。在网上找到该问题解决方法，原文在此:http://social.msdn.microsoft.com/Forums/en-US/vseditor/thread/4cf49a66-17aa-4758-8588-8d988c1291d8/、

			
		

	





	

		

			

				
					
Kotlin中静态方法（companion object），静态类（object）

				
			

			

				

					BettyLi的博客
				

				

					06-04
					
					5949
					
				

			

		

		

			
				
最近楼主team中有一个开发使用了kotlin开发，楼主被迫只能也去学习一下，这篇博客就简单的纪录下学习过程中的问题。Java中修饰静态方法，使用关键字static，例如：public static String getName() {
    return BuildConfig.VERSION_NAME;
}Kotlin语言中使用"object"修饰静态类，被修饰的类，可以使用类名.方法名的形...

			
		

	





	

		

			

				
					
Android 全局Application上下文

				
			

			

				

					qq_37658380的博客
				

				

					11-26
					
					556
					
				

			

		

		

			
				
随时获取全局对象Application的方式主要有两种：
自定义Application

创建自己的Application继承自Application

class BaseApplication : Application() {
    companion object{
        lateinit var application: BaseApplication
    }
	override fun onCreate() {
        super.onCreate()
        a

			
		

	





	

		

			

				
					
iOS组件化：深度解析路由设计策略

				
			

			

				

					
				

			

		

		

			
				
iOS组件化——路由设计思路分析  随着移动应用市场竞争激烈，用户需求的多元化和对用户体验的高要求促使开发人员不断优化App架构。原本简单的MVC架构逐渐被MVVM、VIPER等高级架构所取代，旨在提高代码可维护性和灵活...

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		
评论 1

	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值