Jetpack ---- Lifecycle源码解析（4）响应的观察者们

最新推荐文章于 2024-07-16 15:26:55 发布

detachment_w

最新推荐文章于 2024-07-16 15:26:55 发布

阅读量140

点赞数

文章标签： android

本文链接：https://blog.csdn.net/aha_jasper/article/details/111183308

版权

android框架使用及源码解析专栏收录该内容

37 篇文章 5 订阅

订阅专栏

转载自青蛙要fly，略有删减，注意原作者分析的代码不是最新的，但是变化不大，我更换了原作者的源码

看源码最好还是自己先去android官网的该模块看一下，如果大家英语不太好，可以去看我的这篇博客 Jetpack ---- Lifecycle入门，如果哪里不太对，可以指正。

如果看完这系列文章对lifecycle还有疑惑可以在阅读一下一下几篇博客，不过最主要的还是自己看完之后结合源码自己思考一下: 其实我看完原作者的博客之后，也是自己回过头来有看了一遍下面的博客，才对于Lifecycling、ProcessLifecycleOwner、LifecycleDispatcher有了更清晰的认识。
【AAC系列二】深入理解架构组件的基石：生命周期
 3. Jetpack原始解析—使用生命周期管理生命周期
 剖析Lifecycle源码

正文

在上一篇 Jetpack ---- Lifecycle源码解析（3）注册监听 & 发送事件中我们我们可以看到：最后通过真正的观察者进行方法调用进行替换通知：

mLifecycleObserver.onStateChanged(owner, event);

但是我们再平常使用的时候，貌似是这样的：

class LifeObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void CCCC(LifecycleOwner owner) {
        
    }
}

都没有这个onStateChanged方法，那这又是为什么呢？

实际上这个mLifecycleObserver并不是我们预期的Observer，而是中间适配器观察者，它先接受到了通知，然后内部在调用我们自己写的Observer，进行发送通知。

简单来说就是ObserverWithState.dispatchEvent->包含onStateChanged（所有者，事件）方法的适配器观察者AdapterObserver（如果我们替换的Observer包含onStateChanged方法，如GenericLifecycleObserver，则直接没有中间这个适配器观察者）->我们的观察者

我们前面说过，我们的观察者对象被通过addObserver方法被封装到了，加入到ObserverWithState对象里面：

 static class ObserverWithState {
    State mState;
    LifecycleEventObserver mLifecycleObserver;

    ObserverWithState(LifecycleObserver observer, State initialState) {
    	//我们可以看到我们的传入的Observer被getCallback转成了其他的Observer(或者适配器):mLifecycleObserver
        mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
        mState = initialState;
    }

    void dispatchEvent(LifecycleOwner owner, Event event) {
        State newState = getStateAfter(event);
        mState = min(mState, newState);
        //可以看到最后的回调的时候是调用mLifecycleObserver的onStateChanged方法
        mLifecycleObserver.onStateChanged(owner, event);
        mState = newState;
    }
}

响应的观察者们

我们来具体看下，我们的观察者到底被转换成什么样的观察者：

Lifecycling

static LifecycleEventObserver lifecycleEventObserver(Object object) {
    boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
    boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
    '1. FullLifecycleObserver观察者也是LifecycleEventObserver观察者，返回FullLifecycleObserverAdapter适配器类'
    if (isLifecycleEventObserver && isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
                (LifecycleEventObserver) object);
    }
    '1. FullLifecycleObserver观察者，返回FullLifecycleObserverAdapter适配器类'
    if (isFullLifecycleObserver) {
        return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
    }
	'2. LifecycleEventObserver观察者，同时直接返回该类'
    if (isLifecycleEventObserver) {
        return (LifecycleEventObserver) object;
    }

    final Class<?> klass = object.getClass();
    '把传入的Observer通过getObserverConstructorType方法传入判断，是否有相应的生成的辅助类'
    int type = getObserverConstructorType(klass);
    '如果有相应生成的辅助类'
    if (type == GENERATED_CALLBACK) {
        List<Constructor<? extends GeneratedAdapter>> constructors =
                sClassToAdapters.get(klass);
        //'只有一个构造器'
        if (constructors.size() == 1) {
         	'3. GeneratedAdapter适配器类'
            GeneratedAdapter generatedAdapter = createGeneratedAdapter(
                    constructors.get(0), object);
            '3.把上面的类再封装为SingleGeneratedAdapterObserver适配器类,(内部有一个GeneratedAdapter)'    
            return new SingleGeneratedAdapterObserver(generatedAdapter);
        }
        GeneratedAdapter[] adapters = new GeneratedAdapter[constructors.size()];
        //多个构造器
        for (int i = 0; i < constructors.size(); i++) {
            '4.生成多个GeneratedAdapter适配器类'
			adapters[i] = createGeneratedAdapter(constructors.get(i), object);
        }
        '4. CompositeGeneratedAdaptersObserver类(内部有GeneratedAdapter队列)' 
        return new CompositeGeneratedAdaptersObserver(adapters);
    }
    '5. ReflectiveGenericLifecycleObserver类' 
    return new ReflectiveGenericLifecycleObserver(object);
}

所以我们可以看到现在有以下图片这些观察者：
在这里插入图片描述

使用FullLifecycleObserver

interface FullLifecycleObserver extends LifecycleObserver {

    void onCreate(LifecycleOwner owner);

    void onStart(LifecycleOwner owner);

    void onResume(LifecycleOwner owner);

    void onPause(LifecycleOwner owner);

    void onStop(LifecycleOwner owner);

    void onDestroy(LifecycleOwner owner);
}

我们可以看到该接口不是public类型，所以我们不能直接外部编写实现类，但是我们可以依赖：

implementation "android.arch.lifecycle:common-java8:1.1.1"

这样我们就可以使用DefaultLifecycleObserver接口类：

public interface DefaultLifecycleObserver extends FullLifecycleObserver {

}

我们可以看到是public的。

DefaultLifecycleObserver observer = new DefaultLifecycleObserver() {
    @Override
    public void onCreate(@NonNull LifecycleOwner owner) {

    }

    @Override
    public void onStart(@NonNull LifecycleOwner owner) {

    }

    @Override
    public void onResume(@NonNull LifecycleOwner owner) {

    }

    @Override
    public void onPause(@NonNull LifecycleOwner owner) {

    }

    @Override
    public void onStop(@NonNull LifecycleOwner owner) {

    }

    @Override
    public void onDestroy(@NonNull LifecycleOwner owner) {

    }
};

同时发生的时候，通过FullLifecycleObserverAdapter转换器观察者来进行：

class FullLifecycleObserverAdapter implements LifecycleEventObserver {

    private final FullLifecycleObserver mFullLifecycleObserver;
    private final LifecycleEventObserver mLifecycleEventObserver;

    FullLifecycleObserverAdapter(FullLifecycleObserver fullLifecycleObserver,
            LifecycleEventObserver lifecycleEventObserver) {
        mFullLifecycleObserver = fullLifecycleObserver;
        mLifecycleEventObserver = lifecycleEventObserver;
    }

    @Override
    public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
        switch (event) {
            case ON_CREATE:
                mFullLifecycleObserver.onCreate(source);
                break;
            case ON_START:
                mFullLifecycleObserver.onStart(source);
                break;
            case ON_RESUME:
                mFullLifecycleObserver.onResume(source);
                break;
            case ON_PAUSE:
                mFullLifecycleObserver.onPause(source);
                break;
            case ON_STOP:
                mFullLifecycleObserver.onStop(source);
                break;
            case ON_DESTROY:
                mFullLifecycleObserver.onDestroy(source);
                break;
            case ON_ANY:
                throw new IllegalArgumentException("ON_ANY must not been send by anybody");
        }
        if (mLifecycleEventObserver != null) {
            mLifecycleEventObserver.onStateChanged(source, event);
        }
    }
}

使用GenericLifecycleObserver(现在已废弃）

public interface GenericLifecycleObserver extends LifecycleObserver {

    void onStateChanged(LifecycleOwner source, Lifecycle.Event event);
    
}

我们可以直接使用：

class AObserver implements GenericLifecycleObserver{

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        
    }
}

我们可以AdapterObserver看到都是调用onStateChanged方法，然后间接调用我们写的具体的Observer相关方法，而GenericLifecycleObserver内部正好就是onStateChanged，所以就不需要AdapterObserver额外的适配器观察者，所以就直接返回了该Observer了。

使用普通的LifecycleObserver

先说过搞笑的事情，就是很多文章都会说：

开头说加入依赖 annotationProcessor "android.arch.lifecycle:compiler:1.1.1"。

后面说Lifecycle你写了XXXLifecycleObserver后，编译后会自动生成XXXLifeObserver_LifecycleAdapter文件。

然后我忘记帖子了上面的引用，找这个辅助文件怎么找都找不到，然后相关关联通知又能够顺利成功成功，搞得我一脸懵逼，后面只能去看源码，才知道了原因：有引用，就会生成辅助文件，没有依赖就会自动通过反射调用相关方法，去调用。

（生成辅助文件）使用单个GeneratedAdapterObserver / CompositeGeneratedAdaptersObserver

public class SingleGeneratedAdapterObserver implements GenericLifecycleObserver {

    private final GeneratedAdapter mGeneratedAdapter;

    SingleGeneratedAdapterObserver(GeneratedAdapter generatedAdapter) {
        mGeneratedAdapter = generatedAdapter;
    }

    @Override
    public void onStateChanged(LifecycleOwner source, Lifecycle.Event event) {
        '//调用了GeneratedAdapter的callMethods方法'
        mGeneratedAdapter.callMethods(source, event, false, null);
        mGeneratedAdapter.callMethods(source, event, true, null);
    }
}

这是我们自己写的Observer类：

class DemoLifeObserver implements LifecycleObserver {

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void CCCC(LifecycleOwner owner) {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
    public void AAAA(LifecycleOwner owner) {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_START)
    public void DDDD(LifecycleOwner owner) {

    }

    @OnLifecycleEvent(Lifecycle.Event.ON_ANY)
    public void EEEE(LifecycleOwner owner,Lifecycle.Event event) {

    }
}

我们生成的辅助文件（也就是GeneratedAdapter类）：

public class DemoLifeObserver_LifecycleAdapter implements GeneratedAdapter {
  final DemoLifeObserver mReceiver;

  DemoLifeObserver_LifecycleAdapter(DemoLifeObserver receiver) {
    this.mReceiver = receiver;
  }
    
    
  //'调用了callMethods方法：'
  @Override
  public void callMethods(LifecycleOwner owner, Lifecycle.Event event, boolean onAny,
      MethodCallsLogger logger) {
    boolean hasLogger = logger != null;
    if (onAny) {
      if (!hasLogger || logger.approveCall("EEEE", 4)) {
        '//调用了我们具体的观察者的方法'
        mReceiver.EEEE(owner,event);
      }
      return;
    }
    if (event == Lifecycle.Event.ON_CREATE) {
      if (!hasLogger || logger.approveCall("CCCC", 2)) {
      '//调用了我们具体的观察者的方法'
        mReceiver.CCCC(owner);
      }
      if (!hasLogger || logger.approveCall("AAAA", 2)) {
      '//调用了我们具体的观察者的方法'
        mReceiver.AAAA(owner);
      }
      return;
    }
    if (event == Lifecycle.Event.ON_START) {
      if (!hasLogger || logger.approveCall("DDDD", 2)) {
      '//调用了我们具体的观察者的方法'
        mReceiver.DDDD(owner);
      }
      return;
    }
  }
}

步骤

首先使用DemoLifeObserver，然后点击make project 如下：
在这里插入图片描述

然后即可在如下目录下找到自动生成的类：

（通过反射来调用）使用ReflectiveGenericLifecycleObserver

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

我们看到这个Observer自带了onStateChanged方法，所以肯定不需要ObserverAdapter适配做中转了，直接返回这个对象即可。

然后具体跟下去，我们来看mInfo.invokeCallbacks(source, event, mWrapped);，无非就是根据注解的值，反射调用相应的代码：

void invokeCallbacks(LifecycleOwner source, Lifecycle.Event event, Object target) {
    invokeMethodsForEvent(mEventToHandlers.get(event), source, event, target);
    invokeMethodsForEvent(mEventToHandlers.get(Lifecycle.Event.ON_ANY), source, event,target);
}
    

private static void invokeMethodsForEvent(List<MethodReference> handlers,
        LifecycleOwner source, Lifecycle.Event event, Object mWrapped) {
    if (handlers != null) {
        for (int i = handlers.size() - 1; i >= 0; i--) {
            handlers.get(i).invokeCallback(source, event, mWrapped);
        }
    }
}
          
void invokeCallback(LifecycleOwner source, Lifecycle.Event event, Object target) {
    //noinspection TryWithIdenticalCatches
    try {
        switch (mCallType) {
            case CALL_TYPE_NO_ARG:
                mMethod.invoke(target);
                break;
            case CALL_TYPE_PROVIDER:
                mMethod.invoke(target, source);
                break;
            case CALL_TYPE_PROVIDER_WITH_EVENT:
                mMethod.invoke(target, source, event);
                break;
        }
    } catch (InvocationTargetException e) {
        throw new RuntimeException("Failed to call observer method", e.getCause());
    } catch (IllegalAccessException e) {
        throw new RuntimeException(e);
    }
}

通过反射调用的参数我们也可以知道，我们的参数可以写多个：

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void AAAA(LifecycleOwner owner) {

}

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void AAAA(LifecycleOwner source, Lifecycle.Event event) {

}

@OnLifecycleEvent(Lifecycle.Event.ON_CREATE)
public void AAAA(LifecycleOwner source, Lifecycle.Event event, Object target) {
        //'这个Object target参数也就是你自己写的并且通过addObserver传入的Observer'
}

结语

该文章介绍了我们预期不同的观察者后，内部是怎么转换处理，以及最后的通知我们的上层。

PS：但是这里我觉得有一点命名的误区：
都是中间的适配器观察者：SingleGeneratedAdapterObserver，FullLifecycleObserverAdapter，CompositeGeneratedAdaptersObserver。
大家看到没有，FullLife的居然叫ObserverAdapter，理论上我觉得应该是FullLifecycleAdapterObserver，哈哈，因为它也是一个观察者。

detachment_w

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Jetpack ---- Lifecycle源码解析（4）响应的观察者们

转载自青蛙要fly，略有删减，注意原作者分析的代码不是最新的，但是变化不大Jetpack ---- Lifecycle源码解析（4）响应的观察者们正文响应的观察者们使用FullLifecycleObserver使用GenericLifecycleObserver(现在已废弃）使用普通的LifecycleObserver（生成辅助文件）使用单个GeneratedAdapterObserver / CompositeGeneratedAdaptersObserver（通过反射来调用）使用Reflectiv
复制链接

扫一扫