android arch 学习之lifecycle-aware components

发表于 | 更新于:

前言

　　早在去年的时候就看到了Google新发布的arch库，但是当时还是在alpha版本，就没有过多的去关注，现在arch库已经处于稳定的阶段，于是决定好好的学习一下arch库。

原文地址

翻墙地址：https://developer.android.com/topic/libraries/architecture/lifecycle
国内地址：https://developer.android.google.cn/topic/libraries/architecture/lifecycle

举个栗子

　　BroadcastReceiver相信大家用的非常多了，当然你说现在EventBus等总线框架这么强大， 基本没自己手写过广播那我就没办法了，但是用法总归是记得的。这里我们编写一个简单的监听电池信息的广播，同时使用动态注册的方式。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class BatteryReceiver : BroadcastReceiver() {
    override fun onReceive(context: Context?, intent: Intent?) {
        if (Intent.ACTION_BATTERY_CHANGED == intent?.action) {
            //...
        }
    }
}

class BatteryActivity : AppCompatActivity() {

    private val receiver: BatteryReceiver
            by lazy {
                BatteryReceiver()
            }
    private val filter: IntentFilter
            by lazy {
                IntentFilter(Intent.ACTION_BATTERY_CHANGED)
            }

    override fun onResume() {
        super.onResume()
        registerReceiver(receiver, filter)
    }

    override fun onPause() {
        super.onPause()
        unregisterReceiver(receiver)
    }

}

　　这也是一般情况下我们通用的形式，一旦某个东西需要和生命周期联动，就重写组件的生命周期方法在里面做一些操作，一旦这些操作过多之后就会导致难以管理。于是乎lifecycle-aware Components就这么产生了。先看结果，后续再来详细的分析。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class BatteryLifecycleObserver(
        private val context: Context
) : LifecycleObserver {
    private val receiver: BatteryReceiver
            by lazy {
                BatteryReceiver()
            }

    private val filter: IntentFilter
            by lazy {
                IntentFilter(Intent.ACTION_BATTERY_CHANGED)
            }

    @OnLifecycleEvent(Lifecycle.Event.ON_RESUME)
    fun register() {
        context.registerReceiver(receiver, filter)
    }

    @OnLifecycleEvent(Lifecycle.Event.ON_PAUSE)
    fun unregister() {
        context.unregisterReceiver(receiver)
    }
}

class BatteryActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?, persistentState: PersistableBundle?) {
        super.onCreate(savedInstanceState, persistentState)
        lifecycle.addObserver(BatteryLifecycleObserver(this))
    }
}

　　可以看到我们完全将广播的操作从Activity中抽离出来，而我们需要做的仅仅是在Activity中通过lifecycle成员的addObserver()与BatteryLifecycleObserver进行关联，这样的Activity更加的易于阅读和管理。

Lifecycle

　　那么Lifecycle是什么呢？

  1. Lifecycle它持有当前所关联的生命周期组件的生命周期状态；
  2. 它允许LifecycleObserver对这些生命周期进行监听。

Event

　　这些枚举值对应生命周期组件的生命周期回调。

1
2
3
4
5
6
7
ON_CREATE
ON_START
ON_RESUME
ON_PAUSE
ON_STOP
ON_DESTROY
ON_ANY

　　ON_CREATE,ON_START,ON_RESUME这些事件关联的方法会在生命周期组件的对应方法之后调用；而ON_PAUSE,ON_STOP,ON_DESTROY这些事件关联的方法会在生命周期组件的对应方法之前调用。(具体你们编写一个测试的项目就知道了，这里我就不粘贴测试相关的代码了)
　　ON_ANY事件所关联的生命周期方法允许定义两个参数，一个是LifecycleOwner，另一个是Lifecycle.EVENT。其他的时间所关联的方法运行定义一个参数Lifecycle，这一点让同一个LifecycleObserver的实例观察不同的LifecycleOwner成为了可能。

State

　　表示生命周期组件的生命周期状态。

1
2
3
4
5
6
7
8
9
INITIALIZED
DESTROYED
CREATED
STARTED
RESUMED

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

　　而State和Event之间的关系我们盗用下官方的图。001。

其他方法

　　除了添加和移除LifecycleObserver外，还允许获取当前生命周期组件的状态。

1
2
3
public abstract void addObserver(@NonNull LifecycleObserver observer);
public abstract void removeObserver(@NonNull LifecycleObserver observer);
public abstract State getCurrentState();

LifecycleOwner

　　这是一个只含有一个方法的接口，它的作用实际上就是将Lifecycle从生命周期组件中抽象出来。

1
2
3
4
5
6
7
8
9
public interface LifecycleOwner {
    /**
     * Returns the Lifecycle of the provider.
     *
     * @return The lifecycle of the provider.
     */
    @NonNull
    Lifecycle getLifecycle();
}

　　通常情况下你可以使用LifecycleRegistry来管理生命周期，但是如果你想管理整个application的生命周期，你可以考虑使用ProcessLifecycleOwner。

自定义LifecycleOwner

　　如果你的support library不低于26.1.0版本，那么SupportActivity默认就是实现了LifecycleOwner接口的，如果你是低于这个版本，那么就需要自己实现LifecycleOwner，前面说了，通常情况下你只要使用LifecycleRegistry就可以了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public class MyActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry mLifecycleRegistry;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        mLifecycleRegistry = new LifecycleRegistry(this);
        mLifecycleRegistry.markState(Lifecycle.State.CREATED);
    }

    @Override
    public void onStart() {
        super.onStart();
        mLifecycleRegistry.markState(Lifecycle.State.STARTED);
    }

    @NonNull
    @Override
    public Lifecycle getLifecycle() {
        return mLifecycleRegistry;
    }
}

LifecycleObserver

　　这个接口没有任何的方法定义。

1
2
3
public interface LifecycleObserver {

}

　　如果你的项目里面使用的是Java8，那么你完全可以实现DefaultLifecycleObserver即可，因为Java 8支持默认接口实现，如果仍旧使用的是Java7，你可以实现LifecycleObserver接口，并通过OnLifecycleEvent注解来进行编写。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
/*Java 8*/
/**
 * 如果你出现这个问题
 * method in super class are prohibited in JVM target 1.6. Recompile with -jvm-target 1.8
 * 
 * 请在build.gradle文件中添加
 * kaptOption{
     jvmTarget = '1.8'
 * }
 */
class TestObserver implements DefaultLifecycleObserver {
     @Override
     public void onCreate(LifecycleOwner owner) {
         // your code
     }
}
/*Java 7*/
class TestObserver implements LifecycleObserver {
    @OnLifecycleEvent(ON_STOP)
    void onStopped() {
        // your code
    }
}

源码分析

　　简单的介绍说完了，如果你只是想停留在如何使用的阶段下面的内容完全可以忽略了。

LifecycleRegistry

　　这个类继承自Lifecycle，我们可以看到在SupportActivity中就是通过这个类来管理lifecycle的。

1
2
3
public class SupportActivity extends Activity implements LifecycleOwner {
    private LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
}

　　首先我们来看看addObserver()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
public void addObserver(@NonNull LifecycleObserver observer) {
    //1. 生成ObserverWithState类
    State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
    ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
    //2.当前缓存中存在则返回已存在的，否则添加到缓存，并返回null
    ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
    //这种情况是缓存中存在
    if (previous != null) {
        return;
    }   
    
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();

    boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
    State targetState = calculateTargetState(observer);
    mAddingObserverCounter++;
    // 保证observer的前序事件方法都执行
    while ((statefulObserver.mState.compareTo(targetState) < 0
            && mObserverMap.contains(observer))) {
        pushParentState(statefulObserver.mState);
        statefulObserver.dispatchEvent(lifecycleOwner, upEvent(statefulObserver.mState));
        popParentState();
        targetState = calculateTargetState(observer);
    }

    if (!isReentrance) {
        sync();
    }
    mAddingObserverCounter--;
}

　　处理生命周期事件分发的方法是handleLifecycleEvent()，这个方法是在ReportFragment的dispatch()方法中调用的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
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);
        }
    }
}

　　我们可以看到实际上处理时间的方法是在sync()中。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
    State next = getStateAfter(event);
    moveToState(next);
}

private void moveToState(State next) {
    if (mState == next) {
        return;
    }
    mState = next;
    if (mHandlingEvent || mAddingObserverCounter != 0) {
        mNewEventOccurred = true;
        return;
    }
    mHandlingEvent = true;
    sync();
    mHandlingEvent = false;
}

　　所以我们还是来看看sync()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
private void sync() {
    LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
    if (lifecycleOwner == null) {
        return;
    }
    while (!isSynced()) {
        mNewEventOccurred = false;
        //举个栗子，Observer的State是ON_RESUME,现在Activity退到后台，生命周期组件的State变成ON_START，反向迭代调用Observer的事件方法，并更新Observer的State
        if (mState.compareTo(mObserverMap.eldest().getValue().mState) < 0) {
            backwardPass(lifecycleOwner);
        }
        Entry<LifecycleObserver, ObserverWithState> newest = mObserverMap.newest();
        //举个栗子，Observer的State是ON_CREATE,现在Activity走到OnResume，生命周期组件的State变成ON_RESUME，则正序迭代调用Observer的事件方法，并更新Observer的State
        if (!mNewEventOccurred && newest != null
                && mState.compareTo(newest.getValue().mState) > 0) {
            forwardPass(lifecycleOwner);
        }
    }
    mNewEventOccurred = false;
}

　　backwardPass()和forwardPass()方法的处理逻辑是一样的，只是遍历顺序不一样而已。这里只看关键代码。

1
2
3
4
5
6
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
        && mObserverMap.contains(entry.getKey()))) {
    pushParentState(observer.mState);
    observer.dispatchEvent(lifecycleOwner, upEvent(observer.mState));
    popParentState();
}

　　调用给ObserverWithState的dispatchEvent()，而这个方法是调用GenericLifecycleObserver的onStateChanged()方法，里面就会调用到对应的LifecycleObserver，这就是生命周期事件的调用走向。

1
2
3
4
5
6
void dispatchEvent(LifecycleOwner owner, Event event) {
    State newState = getStateAfter(event);
    mState = min(mState, newState);
    mLifecycleObserver.onStateChanged(owner, event);
    mState = newState;
}

ObserverWithState

　　这是LifecycleRegistry里面定义的静态内部类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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;
    }
}

　　那么LifecycleObserver是如何被转换成GenericLifecycleObserver的呢，我们追溯一下Lifecycling的getCallback()方法。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
static GenericLifecycleObserver getCallback(Object object) {
    //...
    final Class<?> klass = object.getClass();
    //这个方法会找GenerateAdapter的type
    int type = getObserverConstructorType(klass);
    if (type == GENERATED_CALLBACK) {
        List<Constructor<? extends GeneratedAdapter>> constructors =
                sClassToAdapters.get(klass);
        if (constructors.size() == 1) {
        //这里通过createGeneratedAdapter方法获取到GeneratedAdapter
            GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                    constructors.get(0), object);
            //生成GenericLifecycleObserver
            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);
    }
    // 如果是REFLECTIVE_CALLBACK
    return new ReflectiveGenericLifecycleObserver(object);
}

　　来看看getObserverConstructorType()方法。

1
2
3
4
5
6
7
8
9
10
11
private static int getObserverConstructorType(Class<?> klass) {
    //1.如果在map中有observer  type的缓存，就直接返回
    if (sCallbackCache.containsKey(klass)) {
        return sCallbackCache.get(klass);
    }
    //2.如果缓存中没有则调用resolveObserverCallbackType()
    int type = resolveObserverCallbackType(klass);
    //3.然后再将其添加到缓存中
    sCallbackCache.put(klass, type);
    return type;
}

　　sCallbackCache是一个map，value保存的是class对应的ObserverType。再看这个方法是不是很清晰了。

  1. 首先从sCallbackCache缓存中获取ObserverType，如果有则直接返回；
  2. 如果没有则调用resolveObserverCallbackType()；
  3. 最后再将生成的type存放到sCallbackCache缓存中。

　　那么resolveObserverCallbackType()又做了什么事情呢？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
private static int resolveObserverCallbackType(Class<?> klass) {
    //通过generatedConstructor生成适配器的构造器，典型的适配器模式
    Constructor<? extends GeneratedAdapter> constructor = generatedConstructor(klass);
    if (constructor != null) {
        //将GeneratedAdapter的构造器存放到缓存中
        sClassToAdapters.put(klass, Collections
                .<Constructor<? extends GeneratedAdapter>>singletonList(constructor));
        return GENERATED_CALLBACK;
    }
    // 没有添加apt对应的compiler或者没有任何方法有OnLifecycleEvent注解
    
    // 含有OnLifecycleEvent注解对应的方法
    boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);
    if (hasLifecycleMethods) {
        return REFLECTIVE_CALLBACK;
    }

    Class<?> superclass = klass.getSuperclass();
    List<Constructor<? extends GeneratedAdapter>> adapterConstructors = null;
    // 如果父类是LifecycleObserver的子类
    if (isLifecycleParent(superclass)) {
        if (getObserverConstructorType(superclass) == REFLECTIVE_CALLBACK) {
            return REFLECTIVE_CALLBACK;
        }
        adapterConstructors = new ArrayList<>(sClassToAdapters.get(superclass));
    }
    // 如果接口实现中有LifecycleObserver
    for (Class<?> intrface : klass.getInterfaces()) {
        if (!isLifecycleParent(intrface)) {
            continue;
        }
        if (getObserverConstructorType(intrface) == REFLECTIVE_CALLBACK) {
            return REFLECTIVE_CALLBACK;
        }
        if (adapterConstructors == null) {
            adapterConstructors = new ArrayList<>();
        }
        adapterConstructors.addAll(sClassToAdapters.get(intrface));
    }
    if (adapterConstructors != null) {
        sClassToAdapters.put(klass, adapterConstructors);
        return GENERATED_CALLBACK;
    }
}

　　generatedConstructor()这个方法是生成GeneratedAdapter构造器的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private static Constructor<? extends GeneratedAdapter> generatedConstructor(Class<?> klass) {
    try {
        Package aPackage = klass.getPackage();
        String name = klass.getCanonicalName();
        final String fullPackage = aPackage != null ? aPackage.getName() : "";
        final String adapterName = getAdapterName(fullPackage.isEmpty() ? name :
                name.substring(fullPackage.length() + 1));
        //找packageName.className_LifecycleAdapter类，这个类是由apt在编译的时候生成的。
        @SuppressWarnings("unchecked") final Class<? extends GeneratedAdapter> aClass =
                (Class<? extends GeneratedAdapter>) Class.forName(
                        fullPackage.isEmpty() ? adapterName : fullPackage + "." + adapterName);
        Constructor<? extends GeneratedAdapter> constructor =
                aClass.getDeclaredConstructor(klass);
        if (!constructor.isAccessible()) {
            constructor.setAccessible(true);
        }
        return constructor;
    } catch (ClassNotFoundException e) {
        return null;
    } catch (NoSuchMethodException e) {
        throw new RuntimeException(e);
    }
}

　　这个类做的事情非常明确，就一件事情，找到apt生成的GenerateAdapter类的constructor。
　　这里值得说一下，arch库使用的是编译时注解，在编译的时候会对使用了OnLifecycleEvent注解的类自动生成一个ClassName_LifecycleAdapter的类，这个类可以在/app/build/generated/source/apt/packageName下面找到。
　　什么，你说你没有找到，那你看看是不是没有添加annotationProcessor在build.gradle文件中。

1
2
3
4
5
/*Java*/
AnnotationProcessor "android.arch.lifecycle:compiler:1.1.1"
/*kotlin*/
apply plugin: "kotlin-kapt"
kapt "android.arch.lifecycle:compiler:1.1.1"

　　下面是笔者生成的GenerateAdapter类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class BatteryLifecycleObserver_LifecycleAdapter implements GeneratedAdapter {
  final BatteryLifecycleObserver mReceiver;

  BatteryLifecycleObserver_LifecycleAdapter(BatteryLifecycleObserver receiver) {
    this.mReceiver = receiver;
  }

  @Override
  public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny, MethodCallsLogger logger) {
    boolean hasLogger = logger != null;
    if (event == Lifecycle.Event.ON_RESUME) {
      if (!hasLogger || logger.approveCall("register", 2)) {
        mReceiver.register(owner);
      }
      return;
    }
    if (event == Lifecycle.Event.ON_PAUSE) {
      if (!hasLogger || logger.approveCall("register", 2)) {
        mReceiver.unRegister(owner);
      }
      return;
    }
  }
}

GenericLifecycleObserver

　　这个接口继承自LifecycleObserver，提供了一个方法，onStateChanged()。

1
2
3
public interface GenericLifecycleObserver extends LifecycleObserver {
    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
}

SingleGeneratedLifecycleObserver

　　这个类是GenericLifecycleObserver的子类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class SingleGeneratedAdapterObserver implements GenericLifecycleObserver {
    // 有一个GeneratedAdapter的成员
    private final GeneratedAdapter mGeneratedAdapter;

    SingleGeneratedAdapterObserver(GeneratedAdapter generatedAdapter) {
        mGeneratedAdapter = generatedAdapter;
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        //非onAny事件
        mGeneratedAdapter.callMethods(source, event, false, null);
        //onAny事件
        mGeneratedAdapter.callMethods(source, event, true, null);
    }
}

ReflectiveGenericLifecycleObserver

　　这个类也是GenericLifecycleObserver的子类，如果type是GENERATIVE_CALLBACK，则会使用到这个类。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
class ReflectiveGenericLifecycleObserver implements GenericLifecycleObserver {
    private final Object mWrapped;
    private final CallbackInfo mInfo;

    ReflectiveGenericLifecycleObserver(Object wrapped) {
        mWrapped = wrapped;
        mInfo = ClassesInfoCache.sInstance.getInfo(mWrapped.getClass());
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Event event) {
        mInfo.invokeCallbacks(source, event, mWrapped);
    }
}

GeneratedAdapter

　　这也是只有一个方法的接口。

1
2
3
public interface GeneratedAdapter {
    void callMethods(LifecycleOwner source, Lifecycle.Event event, boolean onAny, MethodCallsLogger logger);
}

本文标题:android arch 学习之lifecycle-aware components

文章作者:严方雄

发布时间:2018-05-17

最后更新:2018-09-13

原始链接:http://yanfangxiong.com/2018/05/17/android-arch-学习之lifecycle-aware-components/

0%