现在Activity的startActivityForResult废弃了,Google建议我们使用Activity Result Api.
然而这个Activity Result Api坑倒是不少
比如在使用
def activity_version = "1.2.2"
implementation "androidx.activity:activity:$activity_version"
implementation "androidx.activity:activity-ktx:$activity_version"
implementation "androidx.fragment:fragment:$activity_version"
可能会导致
java.lang.IllegalArgumentException: Can only use lower 16 bits for requestCode
要将版本升到1.3.0之后才行
我寻思着干脆将版本直接升到最高吧1.5.0好了,然而升到1.5.0又会导致构建版本太低的项目中报错......
无语......
算了就用1.3.0了.
回归我们的主题,Android Result Api必须在Activity 生命周期onStart之前注册,也就是基本上我们必须在onCreate的时候注册
val launcher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
Log.d(TAG, "get activity result")
}
然后在需要使用的时候再launch
launcher.launch(Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS))
如果我们不在onCreate中注册,那么我们launch的时候就会报如下错误然后崩掉
java.lang.IllegalStateException: LifecycleOwner com.yxf.extensions.MainActivity@f8e47f4 is attempting to register while current state is RESUMED. LifecycleOwners must call register before they are STARTED.
这操作就离谱,这和原本的startActivityForResult,然后在onActivityResult里监听有太大区别吗?
这特么不还是得分成两段代码,一点都不优雅好吧.
那么这么不优雅的问题有办法解决吗?
我们先分析下为什么会崩吧,先看看registerForActivityResult都做了什么
@NonNull
@Override
public final <I, O> ActivityResultLauncher<I> registerForActivityResult(
@NonNull final ActivityResultContract<I, O> contract,
@NonNull final ActivityResultRegistry registry,
@NonNull final ActivityResultCallback<O> callback) {
return registry.register(
"activity_rq#" + mNextLocalRequestCode.getAndIncrement(), this, contract, callback);
}
@NonNull
public final <I, O> ActivityResultLauncher<I> register(
@NonNull final String key,
@NonNull final LifecycleOwner lifecycleOwner,
@NonNull final ActivityResultContract<I, O> contract,
@NonNull final ActivityResultCallback<O> callback) {
Lifecycle lifecycle = lifecycleOwner.getLifecycle();
if (lifecycle.getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
throw new IllegalStateException("LifecycleOwner " + lifecycleOwner + " is "
+ "attempting to register while current state is "
+ lifecycle.getCurrentState() + ". LifecycleOwners must call register before "
+ "they are STARTED.");
}
final int requestCode = registerKey(key);
LifecycleContainer lifecycleContainer = mKeyToLifecycleContainers.get(key);
if (lifecycleContainer == null) {
lifecycleContainer = new LifecycleContainer(lifecycle);
}
LifecycleEventObserver observer = new LifecycleEventObserver() {
@Override
public void onStateChanged(
@NonNull LifecycleOwner lifecycleOwner,
@NonNull Lifecycle.Event event) {
if (Lifecycle.Event.ON_START.equals(event)) {
mKeyToCallback.put(key, new CallbackAndContract<>(callback, contract));
//......
} else if (Lifecycle.Event.ON_STOP.equals(event)) {
mKeyToCallback.remove(key);
} else if (Lifecycle.Event.ON_DESTROY.equals(event)) {
unregister(key);
}
}
};
lifecycleContainer.addObserver(observer);
//......
return new ActivityResultLauncher<I>() {
//......
};
}
可以看到在register的时候,在最前面就先判断了当前生命周期,如果生命周期不在STARTED之前就会直接抛异常......
然而讲道理,它非要我们在onCreate里注册的原因不过是它需要在Activity生命周期为onStart的时候执行这么一个操作
mKeyToCallback.put(key, new CallbackAndContract<>(callback, contract));
主要是存储一个回调接口.
当然在onStart时还包含了mParsedPendingResults和mPendingResults的处理,不过这两个处理主要如果Activity 触发了onStop,则将结果回调从onActivityResult延时到Activity重新onStart的时候触发.不过这里我不是很理解延迟回调到onStart的意义是什么,如果有知道的大佬希望可以指点一二.
回到主题,也就是说,为了以上操作,直接就让我们不能在onStart之后注册了,感觉就挺离谱的......
不过话说回来ActivityResultRegistry源码中其实也考虑了不用生命周期的注册方式,注册过程不会抛异常,ActivityResultRegistry的第二个注册方法如下
@NonNull
public final <I, O> ActivityResultLauncher<I> register(
@NonNull final String key,
@NonNull final ActivityResultContract<I, O> contract,
@NonNull final ActivityResultCallback<O> callback) {
final int requestCode = registerKey(key);
mKeyToCallback.put(key, new CallbackAndContract<>(callback, contract));
//......
return new ActivityResultLauncher<I>() {
//......
};
}
这个方法挺好的,有什么需要处理的直接就处理了.不过因为没有监听Activity的生命周期变化,如果不在不需要的时候解除注册可能会导致Activity内存泄漏.
我们可以尝试借助第二个方法来实现Result Api的即时注册和即时使用,方法如下
private val nextLocalRequestCode = AtomicInteger()
fun <I, O> FragmentActivity.startContractForResult(
contract: ActivityResultContract<I, O>,
input: I,
callback: ActivityResultCallback<O>
) {
val key = "activity_rq_for_result#${nextLocalRequestCode.getAndIncrement()}"
val registry = activityResultRegistry
var launcher: ActivityResultLauncher<I>? = null
val observer = object : LifecycleEventObserver {
override fun onStateChanged(source: LifecycleOwner, event: Lifecycle.Event) {
if (Lifecycle.Event.ON_DESTROY == event) {
launcher?.unregister()
lifecycle.removeObserver(this)
}
}
}
lifecycle.addObserver(observer)
val newCallback = ActivityResultCallback<O> {
launcher?.unregister()
lifecycle.removeObserver(observer)
callback.onActivityResult(it)
}
launcher = registry.register(key, contract, newCallback)
launcher.launch(input)
}
通过以上代码我们就能优雅的实现在onStart之后依然能注册Result Api, 而且将注册和launch的过程结合提高代码的紧凑性.
activity.startContractForResult(ActivityResultContracts.StartActivityForResult(), Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS)) {
if (it.resultCode == Activity.RESULT_OK) {
Log.d(TAG, "get activity result successfully")
} else {
Log.w(TAG, "get activity result failed")
}
}
如果你像我一样依然还在使用RxJava,为此我觉得还可以更优雅的将此装封到RxJava扩展中,代码如下
internal class ObservableStartContractForResult<I, O>(
private var fragmentActivity: FragmentActivity?,
private val contract: ActivityResultContract<I, O>,
private val input: I
) : Observable<O>() {
override fun subscribeActual(observer: Observer<in O>) {
observer.onSubscribe(StartContractForResultObserver(observer, fragmentActivity, contract, input))
fragmentActivity = null
}
private inner class StartContractForResultObserver(
private val downStream: Observer<in O>,
private var activity: FragmentActivity?,
private val contract: ActivityResultContract<I, O>,
private val input: I
) : AtomicReference<Disposable>(), Disposable {
private var launcher: ActivityResultLauncher<I>? = null
val observer = LifecycleEventObserver { _, event ->
if (Lifecycle.Event.ON_DESTROY == event) {
releaseAll()
downStream.onError(LifecycleDestroyedException())
}
}
init {
runOnMainThreadSync {
val key = "activity_rq_for_result#${nextLocalRequestCode.getAndIncrement()}"
val registry = activity!!.activityResultRegistry
activity!!.lifecycle.addObserver(observer)
val newCallback = ActivityResultCallback<O> {
releaseAll()
downStream.onNext(it)
downStream.onComplete()
}
launcher = registry.register(key, contract, newCallback)
launcher?.launch(input)
}
}
private fun releaseAll() {
releaseObserver()
releaseLauncher()
releaseActivity()
}
private fun releaseActivity() {
activity = null
}
private fun releaseLauncher() {
launcher?.unregister()
launcher = null
}
private fun releaseObserver() {
activity?.lifecycle?.removeObserver(observer)
}
override fun dispose() {
if (isDisposed) {
return
}
DisposableHelper.dispose(this)
runOnMainThread{
releaseAll()
}
}
override fun isDisposed(): Boolean {
return get() == DisposableHelper.DISPOSED
}
}
}
fun <I, O> FragmentActivity.rxStartContractForResult(contract: ActivityResultContract<I, O>, input: I): Observable<O> {
return RxJavaPlugins.onAssembly(ObservableStartContractForResult(this, contract, input))
}
如此我们便可以配合RxJava实现极致的优雅.
activity.rxStartContractForResult(ActivityResultContracts.StartActivityForResult(), Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS))
.subscribe {
Log.d(TAG, "get activity result")
}
具体源码参见 https://github.com/dqh147258/RxAndroidExtensions
当然,其实以上功能吧,long long ago,就有大佬们通过Fragment实现了......
不过毕竟通过一个不可见的Fragment还是太骚了,也会影响一些关于Fragment数量的逻辑判断
emmmmm, that's all.
