startActivityForResult的替代方法：registerForActivityResult

startActivityForResult的替代方法：registerForActivityResult

在startActivityForResult的用法一文的最后提到startActivityForResult方法已经废弃，推荐使用AndroidX中的registerForActivityResult方法。

@NonNull
    @Override
    public final <I, O> ActivityResultLauncher<I> registerForActivityResult(
            @NonNull ActivityResultContract<I, O> contract,
            @NonNull ActivityResultCallback<O> callback) {
        return registerForActivityResult(contract, mActivityResultRegistry, callback);
    }

将ActivityResultCallback注册到ActivityResultRegistry中：

@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);
    }

1、registerForActivityResult

以注册获取启动Activity返回的结果为例，这里借助ActivityResultContracts，提供了丰富的实现，只需要通过其中的StartActivityForResult()方法即可获取ActivityResultContract<Intent, ActivityResult>：

val register:ActivityResultContract<Intent, ActivityResult> = ActivityResultContracts.StartActivityForResult()

然后再重写ActivityResultCallback接口：

val callback = object : ActivityResultCallback<ActivityResult> {
	override fun onActivityResult(result: ActivityResult?) {
		Log.d("TAG", "resultCode:${result?.resultCode}  data:${result?.data}")
	}
    }

用前面提到的registerForActivityResult()方法将两者注册：

registerForActivityResult(register, callback)

会获得返回的ActivityResultLauncher对象：

val launcher: ActivityResultLauncher<Intent> = registerForActivityResult(register, callback)

通过该ActivityResultLauncher可以启动我们的Activity：

val intent = Intent()
    //
    
    launcher.launch(intent)

看到这里它的优势相比也显而易见，将繁杂的注册和结果回调解耦，不用全部集中在Activity的一个onActivityResult()回调方法中。且每种不同的业务启动不同的Activity，都可以有自己独立的launcher和处理回调。

2、各种ActivityResultContract

Android开发中除了获取启动Activity返回的结果，申请权限的回调。还有非常多的场景，可以通过实现ActivityResultContract<I,O>完成不同场景下的启动：

abstract class ActivityResultContract<I, O> {
	/**
	 * Create an intent that can be used for [android.app.Activity.startActivityForResult].
	 */
	abstract fun createIntent(context: Context, input: I): Intent
	
	/**
	 * Convert result obtained from [android.app.Activity.onActivityResult] to [O].
	 */
	abstract fun parseResult(resultCode: Int, intent: Intent?): O
	
	/**
	 * An optional method you can implement that can be used to potentially provide a result in
	 * lieu of starting an activity.
	 *
	 * @return the result wrapped in a [SynchronousResult] or `null` if the call
	 * should proceed to start an activity.
	 */
	open fun getSynchronousResult(context: Context, input: I): SynchronousResult<O>? {
		return null
	}
	
	/**
	 * The wrapper for a result provided in [getSynchronousResult]. This allows differentiating
	 * between a null [T] synchronous result and no synchronous result at all.
	 */
	class SynchronousResult<T>(val value: T)
    }

而且ActivityResultContracts也提供了非常多现成的实现，比如启动文件选择、获取照片选择结果、启动相机拍照获取结果等等。

3、registerForActivityResult原理

前面了解了startActivityForResult的原理，registerForActivityResult其实也一样，它的注册流程如下：

通过返回的ActivityResultLauncher启动Activity流程：

接着startActivityForResult的原理一文，我们知道结果回调。这里AndroidX库中的ComponentActivity重写了onActivityResult()回调方法：

@Override
    protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
        if (!mActivityResultRegistry.dispatchResult(requestCode, resultCode, data)) {
            super.onActivityResult(requestCode, resultCode, data);
        }
    }

通过前面注册的mActivityResultRegistry分发处理这次回调结果，如果没有被处理，还是走原来的处理onActivityResult()回调逻辑。

@MainThread
    public final boolean dispatchResult(int requestCode, int resultCode, @Nullable Intent data) {
        String key = mRcToKey.get(requestCode);
        if (key == null) {
            return false;
        }
        doDispatch(key, resultCode, data, mKeyToCallback.get(key));
        return true;
    }

紧接着调用doDispatch()方法处理分发结果：

private <O> void doDispatch(String key, int resultCode, @Nullable Intent data,
            @Nullable CallbackAndContract<O> callbackAndContract) {
        if (callbackAndContract != null && callbackAndContract.mCallback != null
                && mLaunchedKeys.contains(key)) {
            ActivityResultCallback<O> callback = callbackAndContract.mCallback;
            ActivityResultContract<?, O> contract = callbackAndContract.mContract;
            callback.onActivityResult(contract.parseResult(resultCode, data));
            mLaunchedKeys.remove(key);
        } else {
            // Remove any parsed pending result
            mParsedPendingResults.remove(key);
            // And add these pending results in their place
            mPendingResults.putParcelable(key, new ActivityResult(resultCode, data));
        }
    }

最终是在我们注册的ActivityResultCallback回调中处理onActivityResult结果：

/**
	* A type-safe callback to be called when an {@link Activity#onActivityResult activity result}
	* is available.
	*
	* @param <O> result type
    */
    public interface ActivityResultCallback<O> {
	/**
	 * Called when result is available
		*/
	void onActivityResult(@SuppressLint("UnknownNullness") O result);
    }

上面整体的流程是：