阅读须知
1.LifeCycleOwner: 生命周期持有者，即有生命周期的组件 如 Activity/Fragment/Service 等
2.LifeCycleObserver: 生命周期观察者，即开发者注入的观察者，生命周期持有者周期发生变动后，通知观察者即回调观察者
一、LifeCycleOwner
@SuppressWarnings({"WeakerAccess", "unused"})
public interface LifecycleOwner {
/**
* Returns the Lifecycle of the provider.
*
* @return The lifecycle of the provider.
*/
@NonNull
Lifecycle getLifecycle();
}
LifeCycleOwner 是个接口类，即生命周期持有者需要实现这个接口
Activity 实现了这个接口：
public class ComponentActivity extends
androidx.core.app.ComponentActivity implements LifecycleOwner {
/*
* 省略其他代码
*/
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@NonNull
@Override
public Lifecycle getLifecycle() {
return mLifecycleRegistry;
}
/*
* 省略其他代码
*/
}
ComponentActivity 实现了 LifeCycleOwner 接口 ，继承关系：Activity-->AppCompatActivity-->FragmentActivity-->ComponentActivity
ComponentActiivty 实现返回的是 mLifecycleRegistry， 而 mLifecycleRegistry 是Activity 生成时就 new出来的，并且入参是当前Activity
二、LifeCycle
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);
//获取当前生命周期所属的状态
@MainThread
@NonNull
public abstract State getCurrentState();
//生命周期枚举
@SuppressWarnings("WeakerAccess")
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.
*/
ON_ANY;
// downFrom downTo upFrom upTo 可以参考下下面图理解下
@Nullable
public static Event downFrom(@NonNull State state) {
switch (state) {
case CREATED:
return ON_DESTROY;
case STARTED:
return ON_STOP;
case RESUMED:
return ON_PAUSE;
default:
return null;
}
}
// 根据state 推算下一个 event
@Nullable
public static Event downTo(@NonNull State state) {
switch (state) {
case DESTROYED:
return ON_DESTROY;
case CREATED:
return ON_STOP;
case STARTED:
return ON_PAUSE;
default:
return null;
}
}
@Nullable
public static Event upFrom(@NonNull State state) {
switch (state) {
case INITIALIZED:
return ON_CREATE;
case CREATED:
return ON_START;
case STARTED:
return ON_RESUME;
default:
return null;
}
}
@Nullable
public static Event upTo(@NonNull State state) {
switch (state) {
case CREATED:
return ON_CREATE;
case STARTED:
return ON_START;
case RESUMED:
return ON_RESUME;
default:
return null;
}
}
//返回生命周期对应的参考下面图 state 如果传入ON_ANY,会抛IllegalArgumentException 异常
@NonNull
public State getTargetState() {
switch (this) {
case ON_CREATE:
case ON_STOP:
return State.CREATED;
case ON_START:
case ON_PAUSE:
return State.STARTED;
case ON_RESUME:
return State.RESUMED;
case ON_DESTROY:
return State.DESTROYED;
case ON_ANY:
break;
}
throw new IllegalArgumentException(this + " has no target state");
}
}
/**
* 参考下图
*/
@SuppressWarnings("WeakerAccess")
public enum State {
DESTROYED,
INITIALIZED,
CREATED,
STARTED,
RESUMED,
public boolean isAtLeast(@NonNull State state) {
return compareTo(state) >= 0;
}
}
我们来看张图：
用这张图来理解下state 和 event 的转化关系：
downFrom:根据传入的state,返回下一个Event,对应图片的下半部分
downTo: 根据传入的state,返回上一个Event,对应图片的下半部分
upFrom: 根据传入的state,返回下一个Event,对应图片的上半部分
upTo: 根据传入的state,返回上一个Event,对应图片的上半部分
LifyCycle类：
（1）定义了EVNET 、STATE 及 EVENT 和 STATE的转化关系
（2）抽象了几个方法，getCurrentState/add/remove Oberver 方法，并且都需要在主线程调用
三、LifeCycleRegistry
public class LifecycleRegistry extends Lifecycle {
//存放map key 是 Observer, value 是 ObserverWithState
private FastSafeIterableMap<LifecycleObserver, ObserverWithState> mObserverMap =
new FastSafeIterableMap<>();
//当前的state,对应LifeCycle 中的state
private State mState;
//生命周期持有者的弱引用 例如Activity
private final WeakReference<LifecycleOwner> mLifecycleOwner;
//正在添加的 Obeserver 数量
private int mAddingObserverCounter = 0;
//是否正在处event
private boolean mHandlingEvent = false;
//是否有新的event 产生
private boolean mNewEventOccurred = false;
//存放state列表
private ArrayList<State> mParentStates = new ArrayList<>();
//是否强制在主线程执行
private final boolean mEnforceMainThread;
//构造函数 入参：生命周期持有者，即实现了 LifeCycleOwner 的类，如Acitivity
public LifecycleRegistry(@NonNull LifecycleOwner provider) {
this(provider, true);
}
//构造函数2 多了一个入参 是否强制主线程，是私有的，默认是强制主线程
private LifecycleRegistry(@NonNull LifecycleOwner provider, boolean enforceMainThread) {
mLifecycleOwner = new WeakReference<>(provider);
mState = INITIALIZED;
mEnforceMainThread = enforceMainThread;
}
// 设置当前state,会先校验下当前是否主线程，该方法已废弃，采用 setCurrentState
@Deprecated
@MainThread
public void markState(@NonNull State state) {
enforceMainThreadIfNeeded("markState");
setCurrentState(state);
}
//设置新的state,会校验下当前是否是主线程，然后调用moveToState
@MainThread
public void setCurrentState(@NonNull State state) {
enforceMainThreadIfNeeded("setCurrentState");
moveToState(state);
}
//将当前状态值变更为设置的状态
private void moveToState(State next) {
//如果 当前状态和目标状态相等，则直接返回
if (mState == next) {
return;
}
mState = next;
//如果正在处理event 或者 正在添加观察者 则变更mNewEventOccurred 变量值后返回
if (mHandlingEvent || mAddingObserverCounter != 0) {
mNewEventOccurred = true;
return;
}
//处理Event
mHandlingEvent = true;
sync();
mHandlingEvent = false;
}
//处理并分发event
private void sync() {
//获取生命周期持有者 如果为空 抛出异常
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
throw new IllegalStateException("LifecycleOwner of this LifecycleRegistry is already"
+ "garbage collected. It is too late to change lifecycle state.");
}
while (!isSynced()) {
mNewEventOccurred = false;
//先处理逆向事件
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;
}
/**
* Sets the current state and notifies the observers.
* <p>
* Note that if the {@code currentState} is the same state as the last call to this method,
* calling this method has no effect.
*
* @param event The event that was received
*/
public void handleLifecycleEvent(@NonNull Lifecycle.Event event) {
enforceMainThreadIfNeeded("handleLifecycleEvent");
moveToState(event.getTargetState());
}
//判断是否需要同步事件
private boolean isSynced() {
//如果观察者数量是0 返回true
if (mObserverMap.size() == 0) {
return true;
}
//返回第一个加入Observer中的state
State eldestObserverState = mObserverMap.eldest().getValue().mState;
//返回最后一个加入的Observer的state
State newestObserverState = mObserverMap.newest().getValue().mState;
//判断最当前新的state 和 上述两个 state 是否相等
return eldestObserverState == newestObserverState && mState == newestObserverState;
}
//计算目标State
private State calculateTargetState(LifecycleObserver observer) {
Entry<LifecycleObserver, ObserverWithState> previous = mObserverMap.ceil(observer);
State siblingState = previous != null ? previous.getValue().mState : null;
State parentState = !mParentStates.isEmpty() ? mParentStates.get(mParentStates.size() - 1)
: null;
return min(min(mState, siblingState), parentState);
}
@Override
public void addObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded("addObserver");
//判断当先状态是否是DesTroyed,如果不是 则置为初始状态
State initialState = mState == DESTROYED ? DESTROYED : INITIALIZED;
//将当前Observer 和 初始状态封装，放入 map 中
ObserverWithState statefulObserver = new ObserverWithState(observer, initialState);
//如果已经存在 则返回 已存在的Observer,如果不存在，加入map 返回null
ObserverWithState previous = mObserverMap.putIfAbsent(observer, statefulObserver);
//说明已经存在，不需要同步状态
if (previous != null) {
return;
}
LifecycleOwner lifecycleOwner = mLifecycleOwner.get();
if (lifecycleOwner == null) {
// it is null we should be destroyed. Fallback quickly
return;
}
//计算当前新的Observer 和上一个Observer 之间的状态差距，同步状态,也就是 将新加入的 Obserbver 漏发的event补发
boolean isReentrance = mAddingObserverCounter != 0 || mHandlingEvent;
State targetState = calculateTargetState(observer);
mAddingObserverCounter++;
while ((statefulObserver.mState.compareTo(targetState) < 0
&& mObserverMap.contains(observer))) {
pushParentState(statefulObserver.mState);
final Event event = Event.upFrom(statefulObserver.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + statefulObserver.mState);
}
statefulObserver.dispatchEvent(lifecycleOwner, event);
popParentState();
// mState / subling may have been changed recalculate
targetState = calculateTargetState(observer);
}
if (!isReentrance) {
// we do sync only on the top level.
sync();
}
mAddingObserverCounter--;
}
//删除states 列表的最后一个
private void popParentState() {
mParentStates.remove(mParentStates.size() - 1);
}
//添加一个state 到states 列表
private void pushParentState(State state) {
mParentStates.add(state);
}
//删除一个观察者 检查完线程后直接从 map 中移除
@Override
public void removeObserver(@NonNull LifecycleObserver observer) {
enforceMainThreadIfNeeded("removeObserver");
mObserverMap.remove(observer);
}
//获取观察者数量 检查完是否是主线程后 返回map size
@SuppressWarnings("WeakerAccess")
public int getObserverCount() {
enforceMainThreadIfNeeded("getObserverCount");
return mObserverMap.size();
}
//获取当前state
@NonNull
@Override
public State getCurrentState() {
return mState;
}
//对应上图的 上半部分 正向处理 state 即 Observer 的state 比 当前state 小，并查找 observer.state 和当前 state 之间的所有事件 ，触发Observer 分发event，并更新Observer state
//注意这里是一个循环，也就是 比如说跳跃了 state 则会将中间的 事件也会一并 下发给Observer 通知更新,直到state 一致
private void forwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> ascendingIterator =
mObserverMap.iteratorWithAdditions();
while (ascendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = ascendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) < 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
pushParentState(observer.mState);
final Event event = Event.upFrom(observer.mState);
if (event == null) {
throw new IllegalStateException("no event up from " + observer.mState);
}
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
//对应上图的 下半部分 逆向处理 state ，根据 Observer 的 state 和 当前的 state 确定 中间经历了哪些 event 并通知 Observer 触发 event 回调
// 注意这里是一个循环，也就是 比如说跳跃了 state 则会将中间的 事件也会一并 下发给Observer 通知更新,直到state 一致
private void backwardPass(LifecycleOwner lifecycleOwner) {
Iterator<Entry<LifecycleObserver, ObserverWithState>> descendingIterator =
mObserverMap.descendingIterator();
while (descendingIterator.hasNext() && !mNewEventOccurred) {
Entry<LifecycleObserver, ObserverWithState> entry = descendingIterator.next();
ObserverWithState observer = entry.getValue();
while ((observer.mState.compareTo(mState) > 0 && !mNewEventOccurred
&& mObserverMap.contains(entry.getKey()))) {
Event event = Event.downFrom(observer.mState);
if (event == null) {
throw new IllegalStateException("no event down from " + observer.mState);
}
pushParentState(event.getTargetState());
observer.dispatchEvent(lifecycleOwner, event);
popParentState();
}
}
}
//是否有强制线程检测
@SuppressLint("RestrictedApi")
private void enforceMainThreadIfNeeded(String methodName) {
if (mEnforceMainThread) {
if (!ArchTaskExecutor.getInstance().isMainThread()) {
throw new IllegalStateException("Method " + methodName + " must be called on the "
+ "main thread");
}
}
}
//提供一种子线程，生成LifyCycle 的方法
@VisibleForTesting
@NonNull
public static LifecycleRegistry createUnsafe(@NonNull LifecycleOwner owner) {
return new LifecycleRegistry(owner, false);
}
//返回较小的一个 state
static State min(@NonNull State state1, @Nullable State state2) {
return state2 != null && state2.compareTo(state1) < 0 ? state2 : state1;
}
//Observer 和 state 的封装 下面会讲
static class ObserverWithState {
State mState;
LifecycleEventObserver mLifecycleObserver;
ObserverWithState(LifecycleObserver observer, State initialState) {
mLifecycleObserver = Lifecycling.lifecycleEventObserver(observer);
mState = initialState;
}
void dispatchEvent(LifecycleOwner owner, Event event) {
State newState = event.getTargetState();
mState = min(mState, newState);
mLifecycleObserver.onStateChanged(owner, event);
mState = newState;
}
}
LifyCycleRegistry 类：
（1）对外提供了 setCurrentState 和 handleLifecycleEvent 的方法，用于 生命周期持有者 通过这两个方法 来触发状态变更;
（2）同时通过比较观察者 stat e和 新设置的 state ，来确定状态间经历了哪些 event;
（3）然后触发Observer 的 onStateChanged 方法，回调 event
四、ReportFragment
上节了解了 LifyCycleRegistry 触发Observer 回调的逻辑，及对外暴露了状态变更，那么状态变更的处理 是在哪里处理的？ 处理机制是什么？
(1)ComponentActivity
public class ComponentActivity extends androidx.core.app.ComponentActivity implements
LifecycleOwner {
private final LifecycleRegistry mLifecycleRegistry = new LifecycleRegistry(this);
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
//主要看下这块逻辑
ReportFragment.injectIfNeededIn(this);
}
}
(2)ReportFragment
public class ReportFragment extends android.app.Fragment {
private static final String REPORT_FRAGMENT_TAG = "androidx.lifecycle"+ ".LifecycleDispatcher.report_fragment_tag";
public static void injectIfNeededIn(Activity activity) {
//API>=29 直接使用 ActivityLifecycleCallbacks
if (Build.VERSION.SDK_INT >= 29) {
// On API 29+, we can register for the correct Lifecycle callbacks directly
LifecycleCallbacks.registerIn(activity);
}
//添加一个空的Fragment
android.app.FragmentManager manager = activity.getFragmentManager();
if (manager.findFragmentByTag(REPORT_FRAGMENT_TAG) == null) {
manager.beginTransaction().add(new ReportFragment(), REPORT_FRAGMENT_TAG).commit();
// Hopefully, we are the first to make a transaction.
manager.executePendingTransactions();
}
}
@SuppressWarnings("deprecation")
static void dispatch(@NonNull Activity activity, @NonNull Lifecycle.Event event) {
//官方注释LifecycleRegistryOwner 没有使用场景一般是使用LifecycleOwner
if (activity instanceof LifecycleRegistryOwner) {
((LifecycleRegistryOwner) activity).getLifecycle().handleLifecycleEvent(event);
return;
}
//如果activity 实现了 LifecycleOwner 且lifeCycle 是 LifecycleRegistry，则调用 handleLifecycleEvent 这个方法触发事件变更
if (activity instanceof LifecycleOwner) {
Lifecycle lifecycle = ((LifecycleOwner) activity).getLifecycle();
if (lifecycle instanceof LifecycleRegistry) {
((LifecycleRegistry) lifecycle).handleLifecycleEvent(event);
}
}
}
static ReportFragment get(Activity activity) {
return (ReportFragment) activity.getFragmentManager().findFragmentByTag(
REPORT_FRAGMENT_TAG);
}
@Override
public void onActivityCreated(Bundle savedInstanceState) {
super.onActivityCreated(savedInstanceState);
dispatch(Lifecycle.Event.ON_CREATE);
}
@Override
public void onStart() {
super.onStart();
dispatch(Lifecycle.Event.ON_START);
}
@Override
public void onResume() {
super.onResume();
dispatch(Lifecycle.Event.ON_RESUME);
}
@Override
public void onPause() {
super.onPause();
dispatch(Lifecycle.Event.ON_PAUSE);
}
@Override
public void onStop() {
super.onStop();
dispatch(Lifecycle.Event.ON_STOP);
}
@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;
}
private void dispatch(@NonNull Lifecycle.Event event) {
if (Build.VERSION.SDK_INT < 29) {
// Only dispatch events from ReportFragment on API levels prior
// to API 29. On API 29+, this is handled by the ActivityLifecycleCallbacks
// added in ReportFragment.injectIfNeededIn
dispatch(getActivity(), event);
}
}
// this class isn't inlined only because we need to add a proguard rule for it (b/142778206)
// In addition to that registerIn method allows to avoid class verification failure,
// because registerActivityLifecycleCallbacks is available only since api 29.
@RequiresApi(29)
static class LifecycleCallbacks implements Application.ActivityLifecycleCallbacks {
static void registerIn(Activity activity) {
activity.registerActivityLifecycleCallbacks(new LifecycleCallbacks());
}
@Override
public void onActivityCreated(@NonNull Activity activity,
@Nullable Bundle bundle) {
}
@Override
public void onActivityPostCreated(@NonNull Activity activity,
@Nullable Bundle savedInstanceState) {
dispatch(activity, Lifecycle.Event.ON_CREATE);
}
@Override
public void onActivityStarted(@NonNull Activity activity) {
}
@Override
public void onActivityPostStarted(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_START);
}
@Override
public void onActivityResumed(@NonNull Activity activity) {
}
@Override
public void onActivityPostResumed(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_RESUME);
}
@Override
public void onActivityPrePaused(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_PAUSE);
}
@Override
public void onActivityPaused(@NonNull Activity activity) {
}
@Override
public void onActivityPreStopped(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_STOP);
}
@Override
public void onActivityStopped(@NonNull Activity activity) {
}
@Override
public void onActivitySaveInstanceState(@NonNull Activity activity,
@NonNull Bundle bundle) {
}
@Override
public void onActivityPreDestroyed(@NonNull Activity activity) {
dispatch(activity, Lifecycle.Event.ON_DESTROY);
}
@Override
public void onActivityDestroyed(@NonNull Activity activity) {
}
}
ReportFragment:
(1)在ComptonentActivity create 时 注入了 RePortFragment来感知生命周期
（2）ReportFragment会判断API版本 如果>=29 则直接使用LifecycleCallbacks（ActivityLifecycleCallbacks），在系统侧Activity生命周期起发生变更时 ActivityLifecycleCallbacks 的回调，而ActivityLifecycleCallbacks 里又触发了 dispatch(activity, Event),dispatch 通过activity获取 LifeCycleRegistry,进而触发LifeCycleRegistry 的handleLifecycleEvent 的 处理，进而通知观察者
（3）在API < 29 时，会在 ReportFragment 的各个生命周期起回调中 调用dispatch(Event),然后触发dispatch(activity, Event)，后续流程一致
五、ObserverWithState & LifeCycling
ObserverWithState 通过 LifeCycling 将Observer 包装成 LifecycleEventObserver 或者 FullLifecycleObserverAdapter 或者根据注解生成 Observer。
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP_PREFIX)
public class Lifecycling {
//通过注解及反射生成 Observer 不推荐使用 也可以忽略
private static final int REFLECTIVE_CALLBACK = 1;
private static final int GENERATED_CALLBACK = 2;
private static Map<Class<?>, Integer> sCallbackCache = new HashMap<>();
private static Map<Class<?>, List<Constructor<? extends GeneratedAdapter>>> sClassToAdapters =
new HashMap<>();
// Left for binary compatibility when lifecycle-common goes up 2.1 as transitive dep
// but lifecycle-runtime stays 2.0
/**
* @deprecated Left for compatibility with lifecycle-runtime:2.0
*/
@SuppressWarnings("deprecation")
@Deprecated
@NonNull
static GenericLifecycleObserver getCallback(final Object object) {
final LifecycleEventObserver observer = lifecycleEventObserver(object);
return new GenericLifecycleObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source,
@NonNull Lifecycle.Event event) {
observer.onStateChanged(source, event);
}
};
}
//将外部传入的Observer 转换成 包装后的Observer
// 如果是继承了 isFullLifecycleObserver 则通过FullLifecycleObserverAdapter 封装起来返回FullLifecycleObserverAdapter
// 如果都不符合 则通过注解和反射生成
@NonNull
static LifecycleEventObserver lifecycleEventObserver(Object object) {
boolean isLifecycleEventObserver = object instanceof LifecycleEventObserver;
boolean isFullLifecycleObserver = object instanceof FullLifecycleObserver;
if (isLifecycleEventObserver && isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object,
(LifecycleEventObserver) object);
}
if (isFullLifecycleObserver) {
return new FullLifecycleObserverAdapter((FullLifecycleObserver) object, null);
}
if (isLifecycleEventObserver) {
return (LifecycleEventObserver) object;
}
final Class<?> klass = object.getClass();
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);
}
private static GeneratedAdapter createGeneratedAdapter(
Constructor<? extends GeneratedAdapter> constructor, Object object) {
//noinspection TryWithIdenticalCatches
try {
return constructor.newInstance(object);
} catch (IllegalAccessException e) {
throw new RuntimeException(e);
} catch (InstantiationException e) {
throw new RuntimeException(e);
} catch (InvocationTargetException e) {
throw new RuntimeException(e);
}
}
@Nullable
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)); @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) {
// this should not happen
throw new RuntimeException(e);
}
}
private static int getObserverConstructorType(Class<?> klass) {
Integer callbackCache = sCallbackCache.get(klass);
if (callbackCache != null) {
return callbackCache;
}
int type = resolveObserverCallbackType(klass);
sCallbackCache.put(klass, type);
return type;
}
private static int resolveObserverCallbackType(Class<?> klass) {
// anonymous class bug:35073837
if (klass.getCanonicalName() == null) {
return REFLECTIVE_CALLBACK;
}
Constructor<? extends GeneratedAdapter> constructor = generatedConstructor(klass);
if (constructor != null) {
sClassToAdapters.put(klass, Collections
.<Constructor<? extends GeneratedAdapter>>singletonList(constructor));
return GENERATED_CALLBACK;
}
boolean hasLifecycleMethods = ClassesInfoCache.sInstance.hasLifecycleMethods(klass);
if (hasLifecycleMethods) {
return REFLECTIVE_CALLBACK;
}
Class<?> superclass = klass.getSuperclass();
List<Constructor<? extends GeneratedAdapter>> adapterConstructors = null;
if (isLifecycleParent(superclass)) {
if (getObserverConstructorType(superclass) == REFLECTIVE_CALLBACK) {
return REFLECTIVE_CALLBACK;
}
adapterConstructors = new ArrayList<>(sClassToAdapters.get(superclass));
}
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;
}
return REFLECTIVE_CALLBACK;
