現(xiàn)在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"
可能會導(dǎo)致
java.lang.IllegalArgumentException: Can only use lower 16 bits for requestCode
要將版本升到1.3.0之后才行
我尋思著干脆將版本直接升到最高吧1.5.0好了,然而升到1.5.0又會導(dǎo)致構(gòu)建版本太低的項(xiàng)目中報錯......
無語......
算了就用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里監(jiān)聽有太大區(qū)別嗎?
這特么不還是得分成兩段代碼,一點(diǎn)都不優(yōu)雅好吧.
那么這么不優(yōu)雅的問題有辦法解決嗎?
我們先分析下為什么會崩吧,先看看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的時候,在最前面就先判斷了當(dāng)前生命周期,如果生命周期不在STARTED之前就會直接拋異常......
然而講道理,它非要我們在onCreate里注冊的原因不過是它需要在Activity生命周期為onStart的時候執(zhí)行這么一個操作
mKeyToCallback.put(key, new CallbackAndContract<>(callback, contract));
主要是存儲一個回調(diào)接口.
當(dāng)然在onStart時還包含了mParsedPendingResults和mPendingResults的處理,不過這兩個處理主要如果Activity 觸發(fā)了onStop,則將結(jié)果回調(diào)從onActivityResult延時到Activity重新onStart的時候觸發(fā).不過這里我不是很理解延遲回調(diào)到onStart的意義是什么,如果有知道的大佬希望可以指點(diǎn)一二.
回到主題,也就是說,為了以上操作,直接就讓我們不能在onStart之后注冊了,感覺就挺離譜的......
不過話說回來ActivityResultRegistry源碼中其實(shí)也考慮了不用生命周期的注冊方式,注冊過程不會拋異常,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>() {
//......
};
}
這個方法挺好的,有什么需要處理的直接就處理了.不過因?yàn)闆]有監(jiān)聽Activity的生命周期變化,如果不在不需要的時候解除注冊可能會導(dǎo)致Activity內(nèi)存泄漏.
我們可以嘗試借助第二個方法來實(shí)現(xiàn)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)
}
通過以上代碼我們就能優(yōu)雅的實(shí)現(xiàn)在onStart之后依然能注冊Result Api, 而且將注冊和launch的過程結(jié)合提高代碼的緊湊性.
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,為此我覺得還可以更優(yōu)雅的將此裝封到RxJava擴(kuò)展中,代碼如下
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實(shí)現(xiàn)極致的優(yōu)雅.
activity.rxStartContractForResult(ActivityResultContracts.StartActivityForResult(), Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS))
.subscribe {
Log.d(TAG, "get activity result")
}
具體源碼參見 https://github.com/dqh147258/RxAndroidExtensions
當(dāng)然,其實(shí)以上功能吧,long long ago,就有大佬們通過Fragment實(shí)現(xiàn)了......
不過畢竟通過一個不可見的Fragment還是太騷了,也會影響一些關(guān)于Fragment數(shù)量的邏輯判斷
emmmmm, that's all.
