组件化之路 - Lifecycle一知半解

最新推荐文章于 2023-03-21 16:09:35 发布
最新推荐文章于 2023-03-21 16:09:35 发布
阅读量1.4k 收藏
点赞数
分类专栏： Android组件化之路 Android进阶之路 文章标签： Android Jetpack 组件化框架 Lifecycle
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_20451879/article/details/122166166
版权

减法、减法、做减法，终于在2021年的最后一天把这篇 Lifecycle 基本完善了，话说做技术真是学无止境啊 ~

Android Architecture Components 架构组件

关于Lifecycle的学习，以及Lifecycle近几年的一个发展情况，都可以结合 官方文档 与 三方blog进行补课 ~

基本认知

Google于2017年在JetPack下推出了Lifecycle组件，主要用于动态感知Activity、Fragment组件的生命周期，随着Lifecycle组件的不断更新，现在已经可以感知Application和Service的生命周期
在这里插入图片描述

关于Lifecycle如何动态感知生命周期组件？主要还是因其内部采用了观察者模式，Activity、Fragment这样的基础组件作为被观察者后，一般我们只需定义观察者即可~

  • LifecycleOwner 被观察者 （被监听者，提供了生命周期）
  • LifecycleObserver 观察者（监听者，只要生命周期改变，我们都可以实时感知）

Look Here:其实Lifecycle的观察者有俩种实现方式

具体使用哪种观察者自己看就行，性能上也没啥区别

  • DefaultLifecycleObserver 感知生命周期与绑定组件的生命周期相对应
  • LifecycleObserver 结合 @OnLifecycleEvent注解实现动态监听，灵活性较高

像Activity、Fragment作为被观察者，如何绑定观察者？…嗯，看完下面的 “小小源码” 你就知道用addObserver 了，具体如下

   getLifecycle().addObserver(观察者);

在早期1.0版本时，使用Lifecycle组件需要引入相关的依赖implementation "android.arch.lifecycle:extensions:1.0.0-alpha4"，直到2018年以后，也就是 support library26.1.0后Lifecycle才处于一个相对稳定的版本

之所以称之为稳定版本，主要是Lifecycle被Google集成到了Activity和Fragment的基类，这点在Lifecycle的1.1.0版本中已经提到了~
在这里插入图片描述
接着我们可以打开项目跟着Activity或Fragment看看基类的接口实现

Activity - AppCompatActivity - FragmentActivity - ComponentActivity 我们可以看到在ComponentActivity已经实现了LifecycleOwner接口 > <
在这里插入图片描述
Fragment 可以直接看到已经实现了LifecycleOwner 接口
在这里插入图片描述

小小源码

既然学习Lifecycle，那么我们来看一下Lifecycle中都有什么 ~

源码

仅是部分表面源码，并入深入，等有需求或时间的话，在去细读内部源码

package androidx.lifecycle;

import androidx.annotation.MainThread;
import androidx.annotation.NonNull;
import androidx.annotation.RestrictTo;

import java.util.concurrent.atomic.AtomicReference;

public abstract class Lifecycle {

    @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
    @NonNull
    AtomicReference<Object> mInternalScopeRef = new AtomicReference<>();

    @MainThread
    public abstract void addObserver(@NonNull LifecycleObserver observer);
    
    @MainThread
    public abstract void removeObserver(@NonNull LifecycleObserver observer);

    /**
     * Returns the current state of the Lifecycle.
     *
     * @return The current state of the Lifecycle.
     */
    @MainThread
    @NonNull
    public abstract State getCurrentState();

    @SuppressWarnings("WeakerAccess")
    public enum Event {
        ON_CREATE,
        ON_START,
        ON_RESUME,
        ON_PAUSE,
        ON_STOP,
        ON_DESTROY,
        ON_ANY
    }

    @SuppressWarnings("WeakerAccess")
    public enum State {
        DESTROYED,
        INITIALIZED,
        CREATED,
        STARTED,
        RESUMED;

        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
}
方法分析

如果你熟悉观察者模式的话，有的方法很好理解

  • addObserver 添加观察者
  • removeObserver 删除观察者
  • getCurrentState 获取当前状态
  • Event枚举 生命周期与组件周期相对应
 public enum Event {
        /**
         * Constant for onCreate event of the {@link LifecycleOwner}.
         */
        ON_CREATE,
        /**
         * Constant for onStart event of the {@link LifecycleOwner}.
         */
        ON_START,
        /**
         * Constant for onResume event of the {@link LifecycleOwner}.
         */
        ON_RESUME,
        /**
         * Constant for onPause event of the {@link LifecycleOwner}.
         */
        ON_PAUSE,
        /**
         * Constant for onStop event of the {@link LifecycleOwner}.
         */
        ON_STOP,
        /**
         * Constant for onDestroy event of the {@link LifecycleOwner}.
         */
        ON_DESTROY,
        /**
         * An {@link Event Event} constant that can be used to match all events.
         * Look here : 这里稍微注意一下，只要组件的生命周期改变，就会调用该回调
         */
        ON_ANY
    }
  • State枚举 State代表阶段性的生命周期
    public enum State {
        /**
         * Destroyed state for a LifecycleOwner. After this event, this Lifecycle will not dispatch
         * any more events. For instance, for an {@link android.app.Activity}, this state is reached
         * <b>right before</b> Activity's {@link android.app.Activity#onDestroy() onDestroy} call.
         * 顺序值为0 
         */
        DESTROYED,

        /**
         * Initialized state for a LifecycleOwner. For an {@link android.app.Activity}, this is
         * the state when it is constructed but has not received
         * {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} yet.
         * 顺序值为1
         */
        INITIALIZED,

        /**
         * Created state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached in two cases:
         * <ul>
         *     <li>after {@link android.app.Activity#onCreate(android.os.Bundle) onCreate} call;
         *     <li><b>right before</b> {@link android.app.Activity#onStop() onStop} call.
         * </ul>
         * 顺序值为2
         */
        CREATED,

        /**
         * Started state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached in two cases:
         * <ul>
         *     <li>after {@link android.app.Activity#onStart() onStart} call;
         *     <li><b>right before</b> {@link android.app.Activity#onPause() onPause} call.
         * </ul>
         * 顺序值为3
         */
        STARTED,

        /**
         * Resumed state for a LifecycleOwner. For an {@link android.app.Activity}, this state
         * is reached after {@link android.app.Activity#onResume() onResume} is called.
         * 顺序值为4
         */
        RESUMED;

        /**
         * Compares if this State is greater or equal to the given {@code state}.
         *
         * @param state State to compare with
         * @return true if this State is greater or equal to the given {@code state}
         */
        public boolean isAtLeast(@NonNull State state) {
            return compareTo(state) >= 0;
        }
    }
为何Event与State不对应？

我们可以看到Event有7个状态，而State为何只有5个状态？它们是如何对应的？其实这个以前我看别人 blog 图画的挺好的，直接就借鉴说明一下吧~

官方解释

其实官方的图，解释的也蛮清楚的，表明了State处于不同阶段时，Event都执行了哪些生命周期（这里要注意，Create、Start、Resume 一般都有对应的生命周期 如 Destroy、Stop、Pause）
请添加图片描述
我看了一下那篇 blog 讲的，其实就像我上面说的一样，当你把生命周期组成小组对应关系时，就能很快理解为何State和Event不同了，当然源码中可能说的是用数字去判断状态这样的逻辑 > <
请添加图片描述

基本使用

Lifecycle文档提示了，要配置
在这里插入图片描述
build.gradle

allprojects {
    repositories {
        jcenter()
        google()
    }
}

官网依赖，示例

    dependencies {
        def lifecycle_version = "2.4.0"
        def arch_version = "2.1.0"

        // ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel:$lifecycle_version"
        // LiveData
        implementation "androidx.lifecycle:lifecycle-livedata:$lifecycle_version"
        // Lifecycles only (without ViewModel or LiveData)
        implementation "androidx.lifecycle:lifecycle-runtime:$lifecycle_version"

        // Saved state module for ViewModel
        implementation "androidx.lifecycle:lifecycle-viewmodel-savedstate:$lifecycle_version"

        // Annotation processor
        annotationProcessor "androidx.lifecycle:lifecycle-compiler:$lifecycle_version"
        // alternately - if using Java8, use the following instead of lifecycle-compiler
        implementation "androidx.lifecycle:lifecycle-common-java8:$lifecycle_version"

        // optional - helpers for implementing LifecycleOwner in a Service
        implementation "androidx.lifecycle:lifecycle-service:$lifecycle_version"

        // optional - ProcessLifecycleOwner provides a lifecycle for the whole application process
        implementation "androidx.lifecycle:lifecycle-process:$lifecycle_version"

        // optional - ReactiveStreams support for LiveData
        implementation "androidx.lifecycle:lifecycle-reactivestreams:$lifecycle_version"

        // optional - Test helpers for LiveData
        testImplementation "androidx.arch.core:core-testing:$arch_version"
    }

bulid.gradle 个人示例：因为Lifecycle用到了JDK1.8的东西，所以在build.gradle（Module）加入以下配置

android {
    ...
    compileOptions {
        sourceCompatibility JavaVersion.VERSION_1_8
        targetCompatibility JavaVersion.VERSION_1_8
    }
}

dependencies {
	...
    implementation "androidx.lifecycle:lifecycle-common-java8:2.2.0"
    implementation 'androidx.lifecycle:lifecycle-extensions:2.2.0'
    implementation "androidx.lifecycle:lifecycle-service:2.2.0"
}

其实在使用Lifecycle中，我们很少自己写 LifecycleOwner 被观察者, 主要是因为基础组件基本都实现了LifecycleOwner 接口

定义 ActivityOwner （被观察者）

首先说明一下，Owner被观察者一般都不需要自己写 ，之所以这里会写，主要是为了让大家了解一下 被观察者都做了什么？

package com.example.lifecycle;

import android.app.Activity;
import android.os.Bundle;

import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LifecycleRegistry;

/**
 * @author MrLiu
 * @date 2021/12/31
 * desc 自定义被观察者
 */
public class BasicActivity extends Activity implements LifecycleOwner {

    private LifecycleRegistry lifecycleRegistry;

	//实现LifecycleOwner 接口后需要重写的方法
    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return lifecycleRegistry;
    }

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_basic);
        //这行比较关键：注册Lifecycle的组件
        lifecycleRegistry = new LifecycleRegistry(this);
        //设置组件周期状态
        lifecycleRegistry.setCurrentState(Lifecycle.State.CREATED);
        //绑定观察者,这里的观察者下面有说明
        getLifecycle().addObserver(new MainLifecycleObserver());
    }

    @Override
    protected void onStart() {
        super.onStart();
        lifecycleRegistry.setCurrentState(Lifecycle.State.STARTED);
    }

    @Override
    protected void onResume() {
        super.onResume();
        lifecycleRegistry.setCurrentState(Lifecycle.State.RESUMED);
    }
    
	//这里都没有设置状态，主要是State是阶段性的一个状态，具体可以看上方提到的
    @Override
    protected void onPause() {
        super.onPause();
    }
    
	//这里都没有设置状态，主要是State是阶段性的一个状态，具体可以看上方提到的
    @Override
    protected void onStop() {
        super.onStop();
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        lifecycleRegistry.setCurrentState(Lifecycle.State.DESTROYED);
    }

}
定义 LifecycleObserver （观察者）

没事儿做，写个 Observe 玩一玩 ，下面用的是@OnLifecycleEvent注解方式观察者，主要是一个简单的生命周期感知学习，用到的是 @OnLifecycleEvent(Lifecycle.Event.XXXXX)注解 ~

MainLifecycleObserver

package com.example.lifecycle;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

/**
 * @author MrLiu
 * @date 2021/12/20
 * desc LifecycleObserver 观察者
 */
class MainLifecycleObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void any() {
        System.out.println("Main: any");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void create() {
        System.out.println("Main: create");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void start() {
        System.out.println("Main: start");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void resume() {
        System.out.println("Main: resume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void pause() {
        System.out.println("Main: pause");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void stop() {
        System.out.println("Main: stop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void destroy() {
        System.out.println("Main: destroy");
    }

}
Lifecycle 组件集成效果

组件启动
在这里插入图片描述
组件启动 - 组件销毁
在这里插入图片描述

使用方式

关于Lifecycle常见的使用场景，一般有三种！

  • LifecycleObserver
  • DefaultLifecycleObserver
  • LifecycleObserver + 组件封装

这里写个Activity，作为下面观察的被观察者

package com.example.lifecycle;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.view.View;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        //绑定观察者：LifecycleObserver 观察者
        getLifecycle().addObserver(new MainLifecycleObserver());
        //绑定观察者：DefaultLifecycleObserver 观察者
        getLifecycle().addObserver(new DefaultLifecycleObserver());
        //绑定观察者：LifecycleObserver观察者 + 组件封装
        getLifecycle().addObserver(new VideoPlayerObserver());
    }
}
LifecycleObserver

MainLifecycleObserver

package com.example.lifecycle;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

/**
 * @author MrLiu
 * @date 2021/12/20
 * desc LifecycleObserver 观察者
 */
class MainLifecycleObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void any() {
        System.out.println("Main: any");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void create() {
        System.out.println("Main: create");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void start() {
        System.out.println("Main: start");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void resume() {
        System.out.println("Main: resume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void pause() {
        System.out.println("Main: pause");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void stop() {
        System.out.println("Main: stop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void destroy() {
        System.out.println("Main: destroy");
    }

}

MainLifecycleObserver - 测试效果

组件启动
在这里插入图片描述
组件启动 - 组件销毁
在这里插入图片描述

DefaultLifecycleObserver

使用实现DefaultLifecycleObserver接口的观察者，需要依赖implementation "androidx.lifecycle:lifecycle-common-java8:2.2.0"，要注意其内部的生命周期都是固定的，我们直接重写接口的方法即可，扩展性稍微有限 ~

DefaultLifecycleObserver

package com.example.lifecycle;

import android.util.Log;

import androidx.annotation.NonNull;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.OnLifecycleEvent;

/**
 * @author MrLiu
 * @date 2021/10/27
 * desc DefaultLifecycleObserver 观察者
 */
public class DefaultLifecycleObserver implements androidx.lifecycle.DefaultLifecycleObserver {
    private static String TAG = "lifecycle";

    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "create");
    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "start");
    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "resume");
    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "pause");
    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "stop");
    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {
        Log.e(TAG, "destroy");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void any() {
        Log.e(TAG, "any");
    }

}

DefaultLifecycleObserver - 测试效果

组件启动 （上面我特意写了LifecycleObserver的注解方式，然后你可以发现在DefaultLifecycleObserver 是无效的哈~）
在这里插入图片描述
组件启动 - 组件销毁
在这里插入图片描述

LifecycleObserver + 组件封装

在真实开发中，我们经常有些业务在Activity、Fragment生命周期改变时做出相应的改变，网上常见的示例就是 Video 在特定的周期内播放、暂停、回收 ~

package com.example.lifecycle;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

/**
 * @author MrLiu
 * @date 2021/12/31
 * desc 组件+Lifecycle封装
 */
public class VideoPlayerObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void playVideo() {
        System.out.println("开始播放VideoView");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void pauseVideo() {
        System.out.println("组件在走onPause周期，先停止播放Video吧");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void finish() {
        System.out.println("取消VideoView的播放，防止内存泄露");
    }
}

VideoPlayerObserver - 测试效果
在这里插入图片描述

使用场景

在不同的组件场景中，使用Lifecycle的方式都有小小区别，继续吧

Activity 场景

关于Activity场景的使用，其实完全可以使用上面写到的使用方式，这里的话，我直接将上方部分copy下来一个节点，免得有些朋友跳的看blog，而导致错过这部分内容

MainLifecycleObserver - 观察者

package com.example.lifecycle;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

/**
 * @author MrLiu
 * @date 2021/12/20
 * desc LifecycleObserver 观察者
 */
class MainLifecycleObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void any() {
        System.out.println("Main: any");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void create() {
        System.out.println("Main: create");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void start() {
        System.out.println("Main: start");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void resume() {
        System.out.println("Main: resume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void pause() {
        System.out.println("Main: pause");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void stop() {
        System.out.println("Main: stop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void destroy() {
        System.out.println("Main: destroy");
    }

}

MainActivity - 被观察者

package com.example.lifecycle;

import androidx.appcompat.app.AppCompatActivity;

import android.os.Bundle;
import android.view.View;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        
        //绑定观察者：LifecycleObserver 观察者
        getLifecycle().addObserver(new MainLifecycleObserver());
    }
}

MainLifecycleObserver - 测试效果

组件启动
在这里插入图片描述
组件启动 - 组件销毁
在这里插入图片描述

Service 场景

看了挺多blog，很少有提到LifecycleService这个类，自行可以追代码看到LifecycleService是属于Service的一个子类，且内部实现了LifecycleOwner接口，内部已经自行封装监听了Service的生命周期，我们可以直接使用这个类

依赖：implementation "androidx.lifecycle:lifecycle-service:2.2.0"

look here：Service的Lifecycle并非集成到Service父类(压根没父类，它就是基类)，而是使用了Service派发的LifecycleService子类
在这里插入图片描述
VideoPlayerObserver - 观察者

package com.example.lifecycle;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

/**
 * @author MrLiu
 * @date 2021/12/31
 * desc 组件+Lifecycle封装
 */
public class VideoPlayerObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void playVideo() {
        System.out.println("开始播放VideoView");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void finish() {
        System.out.println("终止VideoView的播放，防止内存泄露");
    }
}

TestService - 被观察者

package com.example.lifecycle;

import androidx.lifecycle.LifecycleService;

/**
 * @author MrLiu
 * @date 2021/12/31
 * desc 通过LifecycleService实现动态感知Service生命周期
 */
public class TestService extends LifecycleService {
    @Override
    public void onCreate() {
        super.onCreate();
        getLifecycle().addObserver(new VideoPlayerObserver());
    }
}

MainActivity

我这里是在Activity动态启动，终止服务

package com.example.lifecycle;

import androidx.appcompat.app.AppCompatActivity;

import android.content.Intent;
import android.os.Bundle;
import android.view.View;

public class MainActivity extends AppCompatActivity {

    private Intent serviceIntent;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
		//启动服务
        serviceIntent = new Intent(this, TestService.class);
        startService(serviceIntent);
    }

    @Override
    protected void onDestroy() {
        super.onDestroy();
        //终止服务
        stopService(serviceIntent);
    }
}

测试效果
在这里插入图片描述

Application 场景

关于Application对于Lifecycle的集成稍有不同，因为监听Application生命周期的是ProcessLifecycleOwner类，见名猜其意：进程生命周期拥有者

依赖：implementation "androidx.lifecycle:lifecycle-process:2.2.0"（有的依赖包含此项，并非必须添加，但是添加没坏处 - -）

一个操作系统中有很多软件，每个软件中有很多进程，每个进程中有很多线程，但是常规每个app启动后，我们都将其看做是一个进程，进程关闭后app也就被关闭了
在这里插入图片描述
TestAppLifecycleObserver - 观察者

package com.example.lifecycle;

import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleObserver;
import androidx.lifecycle.OnLifecycleEvent;

/**
 * @author MrLiu
 * @date 2021/12/20
 * desc 观察者
 */
class TestAppLifecycleObserver implements LifecycleObserver {

//    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
//    public void any() {
//        System.out.println("TestApplication: any");
//    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    void create() {
        System.out.println("TestApplication: create");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    void start() {
        System.out.println("TestApplication: start");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    void resume() {
        System.out.println("TestApplication: resume");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    void pause() {
        System.out.println("TestApplication: pause");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_STOP)
    void stop() {
        System.out.println("TestApplication: stop");
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_DESTROY)
    void destroy() {
        System.out.println("TestApplication: destroy");
    }

}

TestApplication - 被观察者，稍有特殊

package com.example.lifecycle;

import android.app.Application;

import androidx.lifecycle.ProcessLifecycleOwner;

/**
 * @author MrLiu
 * @date 2021/12/31
 * desc Application 被观察者
 */
public class TestApplication extends Application {

    @Override
    public void onCreate() {
        super.onCreate();
        //绑定观察者：以下的绑定方式，稍有特殊
        ProcessLifecycleOwner.get().getLifecycle().addObserver(new TestAppLifecycleObserver());
    }
}

记得将我们的Application配置到AndroidMainfests

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.lifecycle">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:roundIcon="@mipmap/ic_launcher_round"
        android:supportsRtl="true"
       android:name=".TestApplication"
        android:theme="@style/Theme.Lifecycle">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

测试效果
在这里插入图片描述
嗯... 这就完了??? 有没有发现没有监听到应用的onDestroy???

通过查看ProcessLifecycleOwner类，可以发现压根内部没有封装onDestroy生命周期，Application因为是将整个进程作为生命周期的提供类，所有有些特殊，例如下面这些特点

  • Lifecycle.Event.ON_CREATE 只会被调用一次，而 Lifecycle.Event.ON_DESTROY 永远不会被调用。
  • ProcessLifecycleOwner 是针对整个应用程序的监听，与 Activity 的数量无关
  • Lifecycle.Event.ON_PAUSE 和 Lifecycle.Event.ON_STOP 的调用会有一定的延后，因为系统需要为“屏幕旋转，由于配置发生变化而导致的 Activity 重新创建” 的情况预留一些时间
    在这里插入图片描述
远方那座山
关注
专栏目录
Android实现发送短信功能
是阿超
06-26 1542
使用Android实现发送短信，可自定义联系人自定义短信内容
终极组件化框架项目方案详解：一个极具参考的组件化项目
Java和Android架构
01-08 3653
热文导读 | 点击标题阅读Java和Android架构2017年总结：文章精选吊炸天！74款APP完整源码！如何避免贫穷和忙碌，在2018年你需要这样提升自己作者：啊哈啊哈哈https://juejin.im/user/57a211b47db2a2005a7c7216前言本文所讲的组件化案例是基于自己开源的组件化框架项目：https://github.com/HelloChenJinJun/New
Android-调用系统应用发送短信
Android_yh的博客
03-21 280
Android 调用系统应用发送短信
android调用系统发送短信
weixin_41454168的博客
03-12 4003
思路1、获取用户输入的将要接收短信的号码；2、获取用户输入的将要发生发送的短信内容3、利用 Intent 调用系统发送短信；实践1、layout布局&lt;EditText android:id="@+id/tel" android:layout_width="match_parent" android:layout_height="wrap_content" an...
Lifecycle+Retrofit+Room完美结合 领略架构之美
常兴E站
12-11 7636
安卓开发技术发展到现在已经非常成熟，有很多的技术专项如插件，热修，加固，瘦身，性能优化，自动化测试等已经在业界有了完善的或者开源的解决方案。 作为一枚多年的安卓研发，有必要学习或了解下这些优秀的解决方案，领略那些行业开创者的思想魅力，然后转化为自己的技术技能，争取应用到日常的开发中去，提高自己研发水平。Lifecycle+Retrofit+Room 云端漫步飞一般的感觉安卓项目的开发结构
iDRAC-with-Lifecycle-Controller_Firmware_40T1C_WN32_2.63.60.61_A00.zip
09-21
此压缩包文件"iDRAC-with-Lifecycle-Controller_Firmware_40T1C_WN32_2.63.60.61_A00.zip"是针对iDRAC及其Lifecycle Controller的固件更新程序。版本号2.63.60.61表明这是该组件的一个特定版本，可能包含了性能改进...
戴尔iDRAC9-with-Lifecycle-Controller 版本6.10.80.00
08-10
戴尔iDRAC9-with-Lifecycle-Controller 版本6.10.80.00，在Windows下升级
androidx-lifecycle-common-2.1.0.jar
05-30
androidx-lifecycle-common-2.1.0.jar
iDRAC8-with-Lifecycle-Controller-Firmware-G79DW-LN64-2.84.84.84
最新发布
08-11
iDRAC8固件2.84.84.84升级程序，在Linux下运行 iDRAC8-with-Lifecycle-Controller_Firmware_G79DW_LN64_2.84.84.84
androidx-lifecycle-livedata-core-2.0.0.aar
05-30
androidx-lifecycle-livedata-core-2.0.0.aar
安卓调用系统自带的发短信功能
04-18
该程序能实现简单的调用系统的发短信功能，简单易懂。
android 发送短信，调用系统和秘密发送
03-23
NULL 博文链接：https://ouyangfeng521.iteye.com/blog/1094857
android 调用短信,android中可以通过两种方式调用接口发送短信
weixin_36407256的博客
05-25 779
第一：调用系统短信接口直接发送短信；主要代码如下：//直接调用短信接口发短信SmsManager smsManager = SmsManager.getDefault();List divideContents = smsManager.divideMessage(content);for (String text : divideContents) {smsManager.sendTextMes...
android 调用短信,Android 调用发送短信的方法
weixin_35619710的博客
05-25 856
Android 调用发送短信的方法功能：调用发送短信功能1 、 权限2、具体实现Uri smstoUri = Uri.parse("smsto:");Intent intent = new Intent(Intent.ACTION_VIEW,smstoUri);intent.putExtra("address","电话号码"); // 没有电话号码的话为默认的，即显示的时候是为空的intent.p...
Android 调用系统接口发短信
Mr_qyw的专栏
01-21 915
（1） 通过系统接口发短信，首先需要获取短信管理器： android.telephony.SmsManager smsManager = android.telephony.SmsManager.getDefault();    （2）然后因为手机短信有长度限制，所以需要拆分短信内容 List divideContents = smsManager.divideMessage(
Android调用系统的打电话和发短信功能
热门推荐
yangshuangyue的博客
07-14 1万+
一、打电话      1、添加打电话的权限在manifast文件中。                 2、使用Uri.parse(String a)创建Uri。            Uri uri = Uri.parse("tel:"+1008611);      3、创建打电话的意图。           Intent intent = new Intent(Intent.A
Android使用Intent发送短信SMS
xiaowanggedege的专栏
11-24 5782
两种发送短信方式： 方法一、使用Intent发送短信 Intent smsIntent = new Intent(); smsIntent.setAction(Intent.ACTION_VIEW); smsIntent.putExtra("sms_body", "默认内容哈哈。"); smsIntent.setType("vnd.android-dir/mms-sms");
Android调用系统短信功能发送短信
iteye_19930的博客
04-17 630
android调用系统短信功能发送短信有两种方法， 第一种，设定发送的号码，和内容，界面没有联系人，群组组等按钮，如下图所示： 代码如下： Uri smsToUri = Uri.parse("smsto:114");// 联系人地址 Intent mIntent = new Intent(android.content.Intent.ACTION_SENDTO, ...
Android开发app实现发送短信功能
sinat_38536045的博客
05-28 1万+
程序使用手机发短信的方法短信收发：◆发送短信只需要几行代码，如下：SmsManager sms = SmsManager.getDefault();PendingIntent pi = PendingIntent.getBroadcast(this, 0, new Intent(), 0);sms.sendTextMessage(phoneNumber, null, MsgStr, pi, nul...
elasticjob-lite-lifecycle 3.1.0
07-28
elasticjob-lite-lifecycle 3.1.0 是一个轻量级分布式任务调度器的生命周期管理工具。它是 ElasticJob 的一个组件，可以帮助开发者更方便地管理任务的生命周期。 elasticjob-lite-lifecycle 3.1.0 提供了以下主要...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

远方那座山

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

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

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

打赏作者

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

抵扣说明：

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

余额充值