================================
OnBackPressedDispatcher 源码不多,我直接带着问题入手,帮你梳理 OnBackPressedDispatcher 内部的实现原理:
3.1 Activity 如何将事件分发到 OnBackPressedDispatcher?
答:ComponentActivity 内部组合了分发器对象,返回键回调 onBackPressed() 会直接分发给 OnBackPressedDispatcher#onBackPressed()。另外,Activity 本身的回退逻辑则封装为 Runnable 交给分发器处理。
androidx.activity.ComponentActivity.java
private final OnBackPressedDispatcher mOnBackPressedDispatcher =
new OnBackPressedDispatcher(new Runnable() {
@Override
public void run() {
// Activity 本身的回退逻辑
ComponentActivity.super.onBackPressed();
}
});
@Override
@MainThread
public void onBackPressed() {
mOnBackPressedDispatcher.onBackPressed();
}
@NonNull
@Override
public final OnBackPressedDispatcher getOnBackPressedDispatcher() {
return mOnBackPressedDispatcher;
}
3.2 说一下 OnBackPressedDispatcher 的处理流程?
答:分发器整体采用责任链设计模式,向分发器添加的回调对象都会成为责任链上的一个节点。当用户触发返回键时,将按顺序遍历责任链,如果回调对象是启用状态(Enabled),则会消费该回退事件,并且停止遍历。如果最后事件没有被消费,则交回到 Activity#onBackPressed() 处理。
OnBackPressedDispatcher.java
// final 回调:Activity#onBackPressed()
@Nullable
private final Runnable mFallbackOnBackPressed;
// 责任链
final ArrayDeque mOnBackPressedCallbacks = new ArrayDeque<>();
// 构造器
public OnBackPressedDispatcher() {
this(null);
}
// 构造器
public OnBackPressedDispatcher(@Nullable Runnable fallbackOnBackPressed) {
mFallbackOnBackPressed = fallbackOnBackPressed;
}
// 判断是否有启用的回调
@MainThread
public boolean hasEnabledCallbacks() {
Iterator iterator = mOnBackPressedCallbacks.descendingIterator();
while (iterator.hasNext()) {
if (iterator.next().isEnabled()) {
return true;
}
}
return false;
}
入口方法:责任链上的每个回调方法仅在前面的回调处于未启用状态(unEnabled)才能调用。
如果如果都没有启用,最后会回调给 mFallbackOnBackPressed
@MainThread
public void onBackPressed() {
Iterator iterator = mOnBackPressedCallbacks.descendingIterator();
while (iterator.hasNext()) {
OnBackPressedCallback callback = iterator.next();
if (callback.isEnabled()) {
callback.handleOnBackPressed();
// 消费
return;
}
}
if (mFallbackOnBackPressed != null) {
mFallbackOnBackPressed.run();
}
}
3.3 回调方法执行在主线程还是子线程?
答:主线程,分发器的入口方法 Activity#onBackPressed() 执行在主线程,因此回调方法也是执行在主线程。另外,添加回调的 addCallback() 方法也要求在主线程执行,分发器内部使用非并发安全容器 ArrayDeque 存储回调对象。
3.4 OnBackPressedCallback 可以同时添加到不同分发器吗?
答:可以。
3.5 加入返回栈的Fragment 事务,如何回退?
答:FragmentManager 也将事务回退交给 OnBackPressedDispatcher 处理。首先,在 Fragment attach 时,会创建一个回调对象加入分发器,回调处理时弹出返回栈栈顶事务。不过初始状态是未启用,只有当事务添加进返回栈后,才会修改回调对象为启用状态。源码体现如下:
FragmentManagerImpl.java
// 3.5.1 分发器与回调对象(初始状态是未启用)
private OnBackPressedDispatcher mOnBackPressedDispatcher;
private final OnBackPressedCallback mOnBackPressedCallback =
new OnBackPressedCallback(false) {
@Override
public void handleOnBackPressed() {
execPendingActions();
if (mOnBackPressedCallback.isEnabled()) {
popBackStackImmediate();
} else {
mOnBackPressedDispatcher.onBackPressed();
}
}
};
// 3.5.2 添加回调对象 addCallback
public void attachController(@NonNull FragmentHostCallback host, @NonNull FragmentContainer container, @Nullable final Fragment parent) {
if (mHost != null) throw new IllegalStateException(“Already attached”);
…
// Set up the OnBackPressedCallback
if (host instanceof OnBackPressedDispatcherOwner) {
OnBackPressed
《Android学习笔记总结+最新移动架构视频+大厂安卓面试真题+项目实战源码讲义》
【docs.qq.com/doc/DSkNLaERkbnFoS0ZF】 完整内容开源分享
DispatcherOwner dispatcherOwner = ((OnBackPressedDispatcherOwner) host);
mOnBackPressedDispatcher = dispatcherOwner.getOnBackPressedDispatcher();
LifecycleOwner owner = parent != null ? parent : dispatcherOwner;
mOnBackPressedDispatcher.addCallback(owner, mOnBackPressedCallback);
}
…
}
// 3.5.3 执行事务时,尝试修改回调对象状态
void scheduleCommit() {
…
updateOnBackPressedCallbackEnabled();
}
private void updateOnBackPressedCallbackEnabled() {
if (mPendingActions != null && !mPendingActions.isEmpty()) {
mOnBackPressedCallback.setEnabled(true);
return;
}
mOnBackPressedCallback.setEnabled(getBackStackEntryCount() > 0 && isPrimaryNavigation(mParent));
}
// 3.5.4 回收
public void dispatchDestroy() {
mDestroyed = true;
…
if (mOnBackPressedDispatcher != null) {
// mOnBackPressedDispatcher can hold a reference to the host
// so we need to null it out to prevent memory leaks
mOnBackPressedCallback.remove();
mOnBackPressedDispatcher = null;
}
}
如果你对 Fragment 事务缺乏清晰的概念,务必看下我之前写的一篇文章:你真的懂 Fragment 吗?AndroidX Fragment 核心原理分析
讨论完 OnBackPressedDispatcher 的使用方法 & 实现原理,下面我们直接通过一些应用场景来实践:
4. 再按一次返回键退出
再按一次返回键退出是一个很常见的功能,本质上是一种退出挽回。网上也流传着很多不全面的实现方式。其实,这个功能看似简单,却隐藏着一些优化细节,一起来看看~
4.1 需求分析
首先,我分析了几十款知名的 App,梳理总结出 4 类返回键交互:
分类 | 描述 | 举例 |
---|---|---|
1、系统默认行为 | 返回键事件交给系统处理,应用不做干预 | 微信、支付宝等 |
2、再按一次退出 | 是否两秒内再次点击返回键,是则退出 | 爱奇艺、高德等 |
3、返回首页 Tab | 按一次先返回首页 Tab,再按一次退出 | Facebook、Instagram等 |
4、刷新信息流 | 按一次先刷新信息流,再按一次退出 | 小红书、今日头条等 |
4.2 如何退出 App?
交互逻辑主要依赖于产品形态和具体应用场景,对于我们技术同学还需要考虑不同的退出 App 的方式的区别。通过观测以上 App 的实际效果,我梳理出以下 4 种退出 App 的实现方式:
-
1、系统默认行为: 将回退事件交给系统处理,而系统的默认行为是 finish() 当前 Activity,如果当前 Activity 位于栈底,则将 Activity 任务栈转入后台;
-
2、调用 moveTaskToBack(): 手动将当前 Activity 所在任务栈转入后台,效果与系统的默认行为类似(该方法接收一个 nonRoot 参数:true:要求只有当前 Activity 处于栈底有效、false:不要求当前 Activity 处于栈底)。因为 Activity 实际上并没有销毁,所以用户下次返回应用时是热启动;
-
3、调用 finish(): 结束当前 Activity,如果当前 Activity 处于栈底,则销毁 Activity 任务栈,如果当前 Activity 是进程最后一个组件,则进程也会结束。需要注意的时,进程结束后内存不会立即被回收,将来(一段时间内)用户重新启动应用为温启动,启动速度比冷启动更快;
-
4、调用 System.exit(0) 杀死应用 杀死进程 JVM,将来用户重新启动为冷启动,需要花费更多时间。
那么,我们应该如何选择呢?一般情况下,“调用 moveTaskToBack()” 表现最佳,两个论点:
-
1、两次点击返回键的目的是挽回用户,确认用户真的需要退出。那么,退出后的行为与无拦截的默认行为相同,这点 moveTaskToBack() 可以满足,而 finish() 和 System.exit(0) 的行为比默认行为更严重;
-
2、moveTaskToBack() 退出应用并没有真正销毁应用,用户重新返回应用是热启动,恢复速度最快。
需要注意,一般不推荐使用 System.exit(0) 和 Process.killProcess(Process.myPid) 来退出应用。因为这些 API 的表现并不理想:
-
1、当调用的 Activity 不位于栈顶时,杀死进程系统会立即重新启动 App(可能是系统认为 前台 App 是意外终止的,会自动重启);
-
2、当 App 退出后,粘性服务会自动重启(Service#onStartCommand() 返回 START_STICKY 的 Service),粘性服务会一致运行除非手动停止。
分类 | 应用返回效果 | 举例 |
---|---|---|
1、系统默认行为 | 热启动 | 微信、支付宝等 |
2、调用 moveTaskToBack() | 热启动 | QQ 音乐、小红书等 |
3、调用 finish() | 温启动 | 待确认(备选爱奇艺、高德等) |
4、调用 System.exit(0) 杀死应用 | 冷启动 | 待确认(备选爱奇艺、高德等) |
Process.killProcess(Process.myPid) 和 System.exit(0) 的区别? todo
4.3 具体代码实现
BackPressActivity.kt
fun Context.startBackPressActivity() {
startActivity(Intent(this, BackPressActivity::class.java))
}
class BackPressActivity : AppCompatActivity(R.layout.activity_backpress) {
// ViewBinding + Kotlin 委托
private val binding by viewBinding(ActivityBackpressBinding::bind)
/**
- 上次点击返回键的时间
*/
private var lastBackPressTime = -1L
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
// 添加回调对象
onBackPressedDispatcher.addCallback(this, onBackPress)
// 返回按钮
binding.ivBack.setOnClickListener {
onBackPressed()
}
}
private val onBackPress = object : OnBackPressedCallback(true) {
override fun handleOnBackPressed() {
if (popBackStack()) {
return
}
val currentTIme = System.currentTimeMillis()
if (lastBackPressTime == -1L || currentTIme - lastBackPressTime >= 2000) {
// 显示提示信息
showBackPressTip()
// 记录时间
lastBackPressTime = currentTIme
} else {
//退出应用
finish()
// android.os.Process.killProcess(android.os.Process.myPid())
// System.exit(0) // exitProcess(0)
// moveTaskToBack(false)
}
}
}
private fun showBackPressTip() {
Toast.makeText(this, “再按一次退出”, Toast.LENGTH_SHORT).show();
}
}
这段代码的逻辑并不复杂,我们主要通过 OnBackPressedDispatcher#addCallback() 添加了一个回调对象,从而干预了返回键事件的逻辑:“首次点击返回键弹出提示,两秒内再次点击返回键退出应用”。
另外,需要解释下这句代码: private val binding by viewBinding(ActivityBackpressBinding::bind)
。这里其实是使用了 ViewBinding + Kotlin 委托属性的视图绑定方案,相对于传统的 findViewById、ButterKnife、Kotlin Synthetics 等方案,这个方案从多个角度上表现更好。具体分析你可以看我之前写过的一篇文章:Android | ViewBinding 与 Kotlin 委托双剑合璧
4.4 优化:兼容 Fragment 返回栈
上一节基本能满足需求,但考虑一种情况:页面内有多个 Fragment 事务加入了返回栈,点击返回键时需要先依次清空返回栈,最后再走 “再按一次返回键退出” 逻辑。
此时,你会发现上一节的方法不会等返回栈清空就直接走退出逻辑了。原因也很好理解,因为 Activity 的回退对象的加入时机比 FragmentManagerImpl 中的回退对象加入时机更早,所以 Activity 的回退逻辑优先处理。解决方法就是在 Activtiy 回退逻辑中手动弹出 Fragment 事务返回栈。完整演示代码如下:
BackPressActivity.kt
class BackPressActivity : AppCompatActivity(R.layout.activity_backpress) {
private val binding by viewBinding(ActivityBackpressBinding::bind)
/**
- 上次点击返回键的时间
*/
private var lastBackPressTime = -1L
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
addFragmentToStack()
onBackPressedDispatcher.addCallback(this, onBackPress)
binding.ivBack.setOnClickListener {
onBackPressed()
}
}
private fun addFragmentToStack() {
// 提示:为了聚焦问题,这里不考虑 Activity 重建的场景
for (index in 1…5) {
supportFragmentManager.beginTransaction().let { it ->
it.add(
R.id.container,
BackPressFragment().also { it.text = “fragment_KaTeX parse error: Expected 'EOF', got '}' at position 8: index" }̲, "fragment_index”
)
it.addToBackStack(null)
it.commit()
}
}
}
/**
- @return true:没有Fragment弹出 false:有Fragment弹出
*/
private fun popBackStack(): Boolean {
// 当 Fragment 状态以保存,不弹出返回栈
return supportFragmentManager.isStateSaved
|| supportFragmentManager.popBackStackImmediate()
}
private val onBackPress = object : OnBackPressedCallback(true) {
)
it.addToBackStack(null)
it.commit()
}
}
}
/**
- @return true:没有Fragment弹出 false:有Fragment弹出
*/
private fun popBackStack(): Boolean {
// 当 Fragment 状态以保存,不弹出返回栈
return supportFragmentManager.isStateSaved
|| supportFragmentManager.popBackStackImmediate()
}
private val onBackPress = object : OnBackPressedCallback(true) {