FragmentManager未绑定宿主异常：异步请求后更新Fragment报错

我正在使用OkHttp库（版本4.9.0，不过我认为版本无关）。在Activity中，我需要远程校验某些内容，并根据响应更新Fragment。简化后的代码如下：

val request = Request.Builder()
  .url(url)
  .post(requestData, "application/json")
  .build()

client.newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                // 执行其他无关操作
            }

            override fun onResponse(call: Call, response: Response) {
                try {
                  Handler(Looper.getMainLooper()).post {
                                supportFragmentManager.commit(true) {
                                    setReorderingAllowed(true)
                                    replace(R.id.container, MyFragment::class.java, argsBundle)
                                }
                  }
                } finally {
                    response.close()
                }
            }
        })

正常情况下代码运行无问题，但遇到一种场景：用户打开应用并发起请求后，收到系统弹窗（如Gmail的保存密码提示）。此时请求已执行完成，在执行replace(R.id.container, MyFragment::class.java, argsBundle)时，应用抛出如下异常：

java.lang.IllegalStateException: The FragmentManager must be attached to itshost to create a Fragment

堆栈追踪：

androidx.fragment.app.FragmentTransaction.createFragment FragmentTransaction.java:200
androidx.fragment.app.FragmentTransaction.replace FragmentTransaction.java:374
androidx.fragment.app.FragmentTransaction.replace FragmentTransaction.java:341

（注：itshost是Android支持库代码中的原文）。我未在Google上找到该异常相关信息，但认为本质是架构问题。请问异步请求完成后，如何检查Activity是否已准备好操作Fragment？

1. 直接检查Activity生命周期状态 #

在执行Fragment事务前，必须确认Activity处于可操作Fragment的稳定状态：

• 先判断isFinishing和isDestroyed：这两个方法能快速识别Activity是否已进入销毁流程，此时绝对不能执行Fragment操作。
• 对于AndroidX Activity，额外检查lifecycle.currentState是否至少为STARTED：只有当Activity处于STARTED或RESUMED状态时，FragmentManager才会保持与宿主的绑定。

修改后的回调代码示例：

Handler(Looper.getMainLooper()).post {
    if (!isFinishing && !isDestroyed && lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
        supportFragmentManager.commit(true) {
            setReorderingAllowed(true)
            replace(R.id.container, MyFragment::class.java, argsBundle)
        }
    }
}

2. 用Lifecycle组件绑定异步任务 #

更稳妥的方式是利用AndroidX的Lifecycle特性，让异步回调自动感知Activity生命周期：

• 推荐用lifecycleScope（Kotlin协程）替代Handler发起请求，它会自动在Activity销毁时取消任务，且回调默认在主线程执行：

lifecycleScope.launch {
    try {
        val response = client.newCall(request).execute()
        // 解析响应得到argsBundle
        val argsBundle = ...
        // 此时Activity状态合法，直接执行Fragment事务
        supportFragmentManager.commit(true) {
            setReorderingAllowed(true)
            replace(R.id.container, MyFragment::class.java, argsBundle)
        }
        response.close()
    } catch (e: IOException) {
        // 处理请求失败逻辑
    }
}

如果必须保留OkHttp的enqueue回调，可以通过LifecycleObserver维护一个可操作标记：

private var canOperateFragment = false

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    lifecycle.addObserver(object : DefaultLifecycleObserver {
        override fun onStart(owner: LifecycleOwner) {
            canOperateFragment = true
        }

        override fun onStop(owner: LifecycleOwner) {
            canOperateFragment = false
        }

        override fun onDestroy(owner: LifecycleOwner) {
            canOperateFragment = false
            lifecycle.removeObserver(this)
        }
    })
}

// 在回调中判断标记
Handler(Looper.getMainLooper()).post {
    if (canOperateFragment && !isFinishing && !isDestroyed) {
        // 执行Fragment事务
    }
}

3. 架构层面优化：将请求逻辑移至ViewModel #

从根源上避免生命周期不匹配问题，建议把异步请求逻辑抽离到ViewModel中：

• ViewModel的生命周期独立于Activity的配置变更，且可以通过LiveData或StateFlow将结果通知给UI层。
• Activity/Fragment观察LiveData时，只有在活跃状态（STARTED/RESUMED）才会收到回调，天然规避了FragmentManager绑定异常。

示例代码：

// ViewModel中处理请求
class MyViewModel : ViewModel() {
    private val _fragmentArgs = MutableLiveData<Bundle?>()
    val fragmentArgs: LiveData<Bundle?> = _fragmentArgs

    fun fetchData(url: String, requestData: RequestBody) {
        val request = Request.Builder()
            .url(url)
            .post(requestData, "application/json")
            .build()
        
        OkHttpClient().newCall(request).enqueue(object : Callback {
            override fun onFailure(call: Call, e: IOException) {
                // 处理失败逻辑
            }

            override fun onResponse(call: Call, response: Response) {
                try {
                    // 解析响应生成argsBundle
                    val argsBundle = ...
                    _fragmentArgs.postValue(argsBundle)
                } finally {
                    response.close()
                }
            }
        })
    }
}

// Activity中观察结果
class MyActivity : AppCompatActivity() {
    private val viewModel by viewModels<MyViewModel>()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        viewModel.fragmentArgs.observe(this) { argsBundle ->
            argsBundle?.let {
                supportFragmentManager.commit(true) {
                    setReorderingAllowed(true)
                    replace(R.id.container, MyFragment::class.java, it)
                }
            }
        }

        // 发起请求
        viewModel.fetchData(url, requestData)
    }
}

内容的提问来源于stack exchange，提问作者zaitsman