Android的Lifecycle源码分析

2018-07-05 604

1. 简介

很早就听说了Google的Lifecycle组件，因为项目没有使用过，所以并没有过多的接触。不过最近看到了一篇文章，其中的一条评论提到了LiveData。恰巧这两天工作内容不多，所以赶紧研究一波！
不过在看LiveData之前，我觉得还是先看下Lifecycle吧（Lifecycle更像是LiveData的基础，LiveData就不写了，感觉没啥东西）。

2. Lifecycle的简单介绍

Lifecycle的介绍，我们还是拿Google的官方文档作为参考吧。
Lifecycle主要解决的是业务和Activity/Fragment生命周期相关的问题。例如：我们在onResume()/onStart()中请求定位，在onPause()/onStop()中停止定位。那么我们一般的做法：

Google Simple Code
class MyLocationListener {
    public MyLocationListener(Context context, Callback callback) {
        // ...
    }

    void start() {
        // connect to system location service
    }

    void stop() {
        // disconnect from system location service
    }
}

class MyActivity extends AppCompatActivity {
    private MyLocationListener myLocationListener;

    @Override
    public void onCreate(...) {
        myLocationListener = new MyLocationListener(this, (location) -> {
            // update UI
        });
    }

    @Override
    public void onStart() {
        super.onStart();
        myLocationListener.start();
        // manage other components that need to respond
        // to the activity lifecycle
    }

    @Override
    public void onStop() {
        super.onStop();
        myLocationListener.stop();
        // manage other components that need to respond
        // to the activity lifecycle
    }
}

上面的代码虽然看起来还可以，但在真实的应用程序中，可能会有很多的方法都需要根据当前Activity/Fragment的生命周期来进行不同的操作。因此其生命周期方法中可能会被放置大量代码，例如onStart()和 onStop()中，这使得它们难以维护。因此Lifecycle应运而生！

3. Lifecycle的使用

Lifecycle已经发布了release版，所以其中的一些默认支持已经包含到了support-v7:26.1.0以及更高。
添加依赖：

implementation "android.arch.lifecycle:extensions:1.1.1"
annotationProcessor "android.arch.lifecycle:compiler:1.1.1"

使用方式1：实现LifecycleObserver接口，使用@OnLifecycleEvent注解，通过编译时注解生成代码：

public class MyLifecycleObserver implements LifecycleObserver {

    private static final String TAG = MyLifecycleObserver.class.getSimpleName();

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void start(LifecycleOwner lifecycleOwner) {
        Lifecycle.State currentState = lifecycleOwner.getLifecycle().getCurrentState();
        Log.d(TAG, "start: " + currentState);
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    public void stop(LifecycleOwner lifecycleOwner) {
        Log.d(TAG, "stop: " + lifecycleOwner.getLifecycle().getCurrentState());
    }
}

APT生成的代码

使用方式2： 实现GenericLifecycleObserver接口，实现其onStateChanged方法：

public class MyLifecycleObserver implements GenericLifecycleObserver {

    private static final String TAG = MyLifecycleObserver.class.getSimpleName();

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        Log.d(TAG, event.name());
    }
}

创建完成后，我们需要将其添加：

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        getLifecycle().addObserver(new MyLifecycleObserver());
    }
}

结果图：

方法1

方法2

4. 源码分析

Lifecycle的获取
根据源码追踪我们可以看到Lifecycle是在SupportActivity中：

private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
public Lifecycle getLifecycle() {
    return mLifecycleRegistry;
}

这里还有个挺重要的代码：

SupportActivity.java
protected void onCreate(@Nullable Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    ReportFragment.injectIfNeededIn(this);
}
ReportFragment.java
public static void injectIfNeededIn(Activity activity) {
    android.app.FragmentManager manager = activity.getFragmentManager();
    if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
        manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
        manager.executePendingTransactions();
    }
}

这里在Activity中添加了一个Fragment，至于作用，留到后面在讲。

addObserver
addObserver方法的话，还是简单来看吧：

LifecycleRegistry.java
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
    ......
    // 对状态的修正，这里会对已经过去的状态进行分发。也就是说如果添加observer时状态已经改变，那么也会被通知到！
}

// 有状态的Observer
static class ObserverWithState {
    State mState;
    GenericLifecycleObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
        mLifecycleObserver = Lifecycling.getCallback(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

我们将实现的接口通过装饰者（我认为是这样）模式转成ObserverWithState对象，并将该对象添加到mObserverMap中。
在ObserverWithState的构造方法中，有对我们传入的LifecycleObserver进行包装：

Lifecycling.java
@NonNull
static GenericLifecycleObserver getCallback(Object object) {
    // 这里应该算第三种实现方式，然而FullLifecycleObserver不是public，所以不能使用
    if (object instanceof FullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object);
    }
    // 我们的第一种方式
    if (object instanceof GenericLifecycleObserver) {
        return (GenericLifecycleObserver) object;
    }
    // 通过注解生成的
    final Class<?> klass = object.getClass();
    // 将生成的MyLifecycleObserver_LifecycleAdapter放到Map中
    int type = getObserverConstructorType(klass);
    if (type == GENERATED_CALLBACK) {
        List<Constructor<? extends GeneratedAdapter>> constructors =
                sClassToAdapters.get(klass);
        if (constructors.size() == 1) {
            GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                    constructors.get(0), object);
            return new SingleGeneratedAdapterObserver(generatedAdapter);
        }
        GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
        for (int i = 0; i < constructors.size(); i++) {
            adapters[i] = createGeneratedAdapter(constructors.get(i), object);
        }
        return new CompositeGeneratedAdaptersObserver(adapters);
    }
    return new ReflectiveGenericLifecycleObserver(object);
}

根据我们传入的对象进行解析，最终返回结果为：GenericLifecycleObserver或者GenericLifecycleObserver的实现类。附获取生成MyLifecycleObserver_LifecycleAdapter代码：

// 通过名称获取
public static String getAdapterName(String className) {
    return className.replace(".", "_") + "_LifecycleAdapter";
}

最终通过Class.forName方式获得Class。

事件分发
Lifecycle的事件分发在ObserverWithState类中：

// 事件分发
void dispatchEvent(LifecycleOwner owner, Event event) {
    State newState = getStateAfter(event);
    mState = min(mState, newState);
    mLifecycleObserver.onStateChanged(owner, event);
    mState = newState;
}

看下哪里调用了dispatchEvent方法：

调用

我们看这个方法，其中一个在 addObserver中调用，另外的两个都会通过 sync()方法调用：

// happens only on the top of stack (never in reentrance),
// so it doesn't have to take in account parents
private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        Log.w(LOG_TAG, "LifecycleOwner is garbage collected, you shouldn't try dispatch "
                + "new events from it.");
        return;
    }
    // 最新的状态和当前状态不一致，则需要进行状态修改
    while (!isSynced()) {
        mNewEventOccurred = false;
        // no need to check eldest for nullability, because isSynced does it for us.
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}
// 是否状态同步的
private boolean isSynced() {
    if (mObserverMap.size() == 0) {
        return true;
    }
    // 最新的和最后添加的Observer状态一致，并且当前的状态和最新状态一致，则已经同步了
    State eldestObserverState = mObserverMap.eldest().getValue().mState;
    State newestObserverState = mObserverMap.newest().getValue().mState;
    return eldestObserverState == newestObserverState && mState == newestObserverState;
}

这里的同步方法用于同步当前Observer的状态，如果最新的和最老的Observer的状态不一致或者当前的状态和最新的状态不一致时，那么需要进行状态同步。同步包括了向前同步和向后同步。
调用sync()方法一共就两处，一处在addObserver方法，另一处是moveToState方法，而调用moveToState方法也有两处：

@SuppressWarnings("WeakerAccess")
@MainThread
public void markState(@NonNull State state) {
    moveToState(state);
}

public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    State next = getStateAfter(event);
    moveToState(next);
}

handleLifecycleEvent方法有很多处调用：

handleLifecycleEvent调用

看图的话，就可以知道 Fragment在不同的生命周期调用了 handleLifecycleEvent方法，随便看一个吧：

ON_CREATE

还记得上面说的 ReportFragment吗？这里也出现了，我们看下 ReportFragment到底做什么的：

// 调用Activity的
private void dispatch(Lifecycle.Event event) {
    Activity activity = getActivity();
    if (activity instanceof LifecycleRegistryOwner) {
        ((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
        return;
    }

    if (activity instanceof LifecycleOwner) {
        Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
        if (lifecycle instanceof LifecycleRegistry) {
            ((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
        }
    }
}

// 生命周期
@Override
public void onDestroy() {
    super.onDestroy();
    dispatch(Lifecycle.Event.ON_DESTROY);
    // just want to be sure that we won't leak reference to an activity
    mProcessListener = null;
}

可以看到，ReportFragment只是作为一个中间层，通过它来分发各种事件！
由于篇幅原因（已经啰嗦了很多了），这里就不写LifecycleDispatcher和ProcessLifecycleOwner了，这两个通过自定义的内容提供者ProcessLifecycleOwnerInitializer进行初始化，并且通过registerActivityLifecycleCallbacks和registerFragmentLifecycleCallbacks注册统一的观察回调。有兴趣的话，自己看看吧。

5 总结

Lifecycle简单来说就是用于处理和生命周期相关的业务，其原理以及实现还是很简单的。当然了，项目中并没有使用到Lifecycle，所以实际应用效果怎样只能靠猜想了。

微信关注我们

原文链接：https://yq.aliyun.com/articles/665825

转载内容版权归作者及来源网站所有！

低调大师中文资讯倾力打造互联网数据资讯、行业资源、电子商务、移动互联网、网络营销平台。持续更新报道IT业界、互联网、市场资讯、驱动更新,是最及时权威的产业资讯及硬件资讯报道平台。

Flutter Plugin调用Native APIs

作者：闲鱼技术-储睿关键词：Flutter, Flutter Plugin, Platform Channel, Method Channel, Flutter Package, Flutter插件 Flutter是Google使用Dart语言开发的一套移动应用开发框架。它不同于其他开发框架：（1）因为Flutter使用AOT预编译代码为机器码，所以它的运行效率更高。（2）Flutter的UI控件并没有使用底层的原生控件，而是使用Skia渲染引擎绘制而成，因为不依赖底层控件，所以多端一致性非常好。（3）Flutter的扩展性也非常强，开发者可以通过Plugin与Native进行通信。闲鱼开发Flutter过程中，经常会需要各种Native的能力，如获取设备信息、使用基础网络库等，这时会使用Plugin来做桥接。本文将对P

2018-07-06

642

为什么选用极光？因为这个 jpush-react-native 是极光官网维护的，而且关于原生方面配置也不是很多，方便搞前端从事RN的同学使用。官网注册账号https://www.jiguang.cn/，获取 AppKey image.png 自动link配置 npm install jpush-react-native --save rnpm link jpush-react-native 我这里报错了需要 link jcore-react-native Project :app declares a dependency from configuration 'compile' to configuration 'default' which is not declared in the descriptor for project :jcore-react-native. 执行完 link 项目后可能会出现报错，需要手动配置一下 build.gradle 文件。如果没有手动加上 image.png image.png image.png 在AndroidManifes...

2018-07-06

634

资源下载

更多资源

优质分享App

近一个月的开发和优化，本站点的第一个app全新上线。该app采用极致压缩，本体才4.36MB。系统里面做了大量数据访问、缓存优化。方便用户在手机上查看文章。后续会推出HarmonyOS的适配版本。

Mario

马里奥是站在游戏界顶峰的超人气多面角色。马里奥靠吃蘑菇成长，特征是大鼻子、头戴帽子、身穿背带裤，还留着胡子。与他的双胞胎兄弟路易基一起，长年担任任天堂的招牌角色。

腾讯云软件源

为解决软件依赖安装时官方源访问速度慢的问题，腾讯云为一些软件搭建了缓存服务。您可以通过使用腾讯云软件源站来提升依赖包的安装速度。为了方便用户自由搭建服务架构，目前腾讯云软件源站支持公网访问和内网访问。

Rocky Linux

Rocky Linux（中文名：洛基）是由Gregory Kurtzer于2020年12月发起的企业级Linux发行版，作为CentOS稳定版停止维护后与RHEL（Red Hat Enterprise Linux）完全兼容的开源替代方案，由社区拥有并管理，支持x86_64、aarch64等架构。其通过重新编译RHEL源代码提供长期稳定性，采用模块化包装和SELinux安全架构，默认包含GNOME桌面环境及XFS文件系统，支持十年生命周期更新。