如何在任意的地方监控指定的Activity的生命周期呢，首先想到的方式就是创建一个BaseActivtiy，让所有的Activity都继承自BaseActivity，当然这样也可以实现，就是比较麻烦一点，以下我会把两种方式都实现来对比一下（完整代码附在最后）：
首先用BaseActivity的方式，我们需要一个全局的map存储对应Activity的监听器，每个Activity维护一个监听器列表，这样可以保证前后设置不会覆盖，互不干扰：
public static final HashMap<Activity, List<LifecycleCallback>> lifecycleListeners = new HashMap<>();
public static void addLifecycleListener(Activity activity, LifecycleCallbackAdapter callbackAdapter) {
if (activity == null || callbackAdapter == null)
return;
List<LifecycleCallback> callbacks = lifecycleListeners.get(activity);
if (callbacks == null) {
ArrayList<LifecycleCallback> calllist = new ArrayList<>();
calllist.add(callbackAdapter);
lifecycleListeners.put(activity, calllist);
} else {
callbacks.add(callbackAdapter);
}
}然后新建BaseActivity在Activity每个生命周期里面找到该Activity对应的监听器列表去遍历回调，这样确实复杂一点，为了节省代码，新建一个枚举类(这是个错误的示范，我是想练习一下敲代码。别跟我学，大家可以用字符串)，代表回调方法的名称，如下：
public enum ActivityStateEnum {
ON_CREATE("onCreate"),
ON_START("onStart"),
ON_RESUME("onResume"),
ON_PAUSE("onPause"),
ON_STOP("onStop"),
ON_DESTROY("onDestroy");
String methodName;
ActivityStateEnum(String methodName) {
this.methodName = methodName;
}
public String getMethodName() {
return methodName;
}
}然后回到BaseActivity来回调添加的监听器，这里图省事，用了反射：
public class BaseActivity extends AppCompatActivity {
public final static ArrayList<Activity> activities = new ArrayList<>();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
callbackLifecycle(ActivityStateEnum.ON_CREATE);
}
@Override
protected void onStart() {
super.onStart();
callbackLifecycle(ActivityStateEnum.ON_START);
}
@Override
protected void onResume() {
super.onResume();
callbackLifecycle(ActivityStateEnum.ON_RESUME);
}
// ...... 剩下的回调我就不多写了，以此类推
private void callbackLifecycle(ActivityStateEnum state) {
// 查找Activity 是否有设置回调监控
List<ActivityPluginUtil.LifecycleCallback> callbacks = ActivityPluginUtil.lifecycleListeners.get(this);
if (callbacks != null && callbacks.size() > 0) {
for (ActivityPluginUtil.LifecycleCallback callback : callbacks) {
if (callback != null) {
// 反射获取方法名 直接调用对应的回调
Class<?> clazz = callback.getClass();
Method method = null;
try {
method = clazz.getDeclaredMethod(state.getMethodName(), Activity.class);
method.setAccessible(true);
method.invoke(callback, this);
Log.e("callbackLifecycle","反射调用成功->"+state.getMethodName());
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}这就是第一种方式监控生命周期，确实比较麻烦，接下来上强度：可以引入Google官方推荐的Jetpack组件 Lifecycle 来监控，具体实现方法很简单：
if (activity instanceof LifecycleOwner) {
((LifecycleOwner) activity).getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_CREATE) {
} else if (event == Lifecycle.Event.ON_START) {
} else if (event == Lifecycle.Event.ON_RESUME) {
} else if (event == Lifecycle.Event.ON_PAUSE) {
} else if (event == Lifecycle.Event.ON_STOP) {
} else if (event == Lifecycle.Event.ON_DESTROY) {
}
}
});
}这种方式实现起来很简单，没有那么多的代码逻辑，只需要注意测一个观察者就可以监控到Activity的生命周期，原理也比较简单，看源码可以发现他的实现原理是在Activity添加了一个Fragment，通过ReportFragment的生命周期给观察者分发，实现了对Activity无代码入侵，达到了解耦的效果，非常方便，不得不说角度很厉害：
如果需要详细了解的可以去看看源码，这里不多说了，下面附上源码：
源代码写在最后：
import androidx.annotation.NonNull;
import androidx.lifecycle.Lifecycle;
import androidx.lifecycle.LifecycleEventObserver;
import androidx.lifecycle.LifecycleOwner;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
/**
* 监控 Activity 生命周期
*/
public class ActivityPluginUtil {
public static final HashMap<Activity, List<LifecycleCallback>> lifecycleListeners = new HashMap<>();
public static void addLifecycleListener(Activity activity, LifecycleCallbackAdapter callbackAdapter) {
if (activity == null || callbackAdapter == null)
return;
if (activity instanceof LifecycleOwner) {
((LifecycleOwner) activity).getLifecycle().addObserver(new LifecycleEventObserver() {
@Override
public void onStateChanged(@NonNull LifecycleOwner source, @NonNull Lifecycle.Event event) {
if (event == Lifecycle.Event.ON_CREATE) {
callbackAdapter.onCreate(activity);
} else if (event == Lifecycle.Event.ON_START) {
callbackAdapter.onStart(activity);
} else if (event == Lifecycle.Event.ON_RESUME) {
callbackAdapter.onResume(activity);
} else if (event == Lifecycle.Event.ON_PAUSE) {
callbackAdapter.onPause(activity);
} else if (event == Lifecycle.Event.ON_STOP) {
callbackAdapter.onStop(activity);
} else if (event == Lifecycle.Event.ON_DESTROY) {
callbackAdapter.onDestroy(activity);
}
}
});
} else {
List<LifecycleCallback> callbacks = lifecycleListeners.get(activity);
if (callbacks == null) {
ArrayList<LifecycleCallback> calllist = new ArrayList<>();
calllist.add(callbackAdapter);
lifecycleListeners.put(activity, calllist);
} else {
callbacks.add(callbackAdapter);
}
}
}
public static class LifecycleCallbackAdapter implements LifecycleCallback {
@Override
public void onCreate(Activity activity) { }
@Override
public void onStart(Activity activity) { }
@Override
public void onResume(Activity activity) { }
@Override
public void onPause(Activity activity) { }
@Override
public void onStop(Activity activity) { }
@Override
public void onDestroy(Activity activity) { }
}
public interface LifecycleCallback {
void onCreate(Activity activity);
void onStart(Activity activity);
void onResume(Activity activity);
void onPause(Activity activity);
void onStop(Activity activity);
void onDestroy(Activity activity);
}
}public enum ActivityStateEnum {
ON_CREATE("onCreate"),
ON_START("onStart"),
ON_RESUME("onResume"),
ON_PAUSE("onPause"),
ON_STOP("onStop"),
ON_DESTROY("onDestroy");
String methodName;
ActivityStateEnum(String methodName) {
this.methodName = methodName;
}
public String getMethodName() {
return methodName;
}
}
public class BaseActivity extends AppCompatActivity {
private final Handler handler = new Handler(Looper.getMainLooper());
public final static ArrayList<Activity> activities = new ArrayList<>();
@Override
protected void onCreate(@Nullable Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
activities.add(this);
callbackLifecycle(ActivityStateEnum.ON_CREATE);
}
@Override
protected void onStart() {
super.onStart();
callbackLifecycle(ActivityStateEnum.ON_START);
}
@Override
protected void onResume() {
super.onResume();
callbackLifecycle(ActivityStateEnum.ON_RESUME);
}
// 剩下的回调我就不多写了，以此类推
@Override
protected void onPause() {
super.onPause();
callbackLifecycle(ActivityStateEnum.ON_PAUSE);
}
@Override
protected void onStop() {
super.onStop();
callbackLifecycle(ActivityStateEnum.ON_STOP);
}
@Override
protected void onDestroy() {
super.onDestroy();
activities.remove(this);
callbackLifecycle(ActivityStateEnum.ON_DESTROY);
}
private void callbackLifecycle(ActivityStateEnum state) {
// 查找Activity 是否有设置回调监控
List<ActivityPluginUtil.LifecycleCallback> callbacks = ActivityPluginUtil.lifecycleListeners.get(this);
if (callbacks != null && callbacks.size() > 0) {
for (ActivityPluginUtil.LifecycleCallback callback : callbacks) {
if (callback != null) {
// 反射获取方法名 直接调用对应的回调
Class<?> clazz = callback.getClass();
Method method = null;
try {
method = clazz.getDeclaredMethod(state.getMethodName(), Activity.class);
method.setAccessible(true);
method.invoke(callback, this);
Log.e("callbackLifecycle","反射调用成功->"+state.getMethodName());
} catch (Exception e) {
e.printStackTrace();
}
}
}
}
}
public void showToast(CharSequence message) {
if (Looper.myLooper() != Looper.getMainLooper()) {
handler.post(() -> showToast(message));
return;
}
try {
Toast toast = new Toast(this);
toast.setDuration(Toast.LENGTH_SHORT);
toast.setGravity(Gravity.CENTER, 0, 0);
View view = LayoutInflater.from(this).inflate(R.layout.common_toast_layout, null);
((TextView) view.findViewById(R.id.message)).setText(message);
toast.setView(view);
toast.show();
} catch (Exception e) {
e.printStackTrace();
}
}
public static Activity getTopActivity() {
if (activities.isEmpty())
return null;
return activities.get(activities.size() - 1);
}
}
3505
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
