startActivityForResult的新解决办法:ActivityResultContract

转自:Google 更新：Android开发者是时候丢掉 onActivityResult 了！
但是这边文章的相关api是alpha时的api,现在有点方法名已经变了哦

在学习Jetpack相关库的时候,在ComponentActivity(属于:androidx.activity:activity:1.2.0-alpha05)里看到了ActivityResultRegistry这个类,刚好在知乎又看到过类似的文章,于是来学习一下.

但凡涉及到启动新Activity,并获取返回值,或者调用相机拍照,那一定会逃不过startActivityForResult 和 onActivityResult的,在有些业务情景中,这个模式很大的制约了代码的设计,谷歌在Activity 1.2.0-alpha02 和 Fragment 1.3.0-alpha02 开始,提供了新的Result API,让我们能更加优雅的处理onActivityResult,已到达:减少样板代码,解耦,灵活,易测试的目的

1.传统的startActivityForResult

最简单的场景: MainActivity跳到SecondActivity,SecondActivity传值回来,代码如下:

const val TAG = "ActivityResultContracts"

class MainActivity : ComponentActivity(R.layout.activity_main) {
    private val REQUEST_CODE = 1

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        button2.setOnClickListener {
            jump()
        }
    }

    //<editor-fold desc="页面跳转 传统写法">
    private fun jump() {
        startActivityForResult(
            Intent(this, SecondActivity::class.java),
            REQUEST_CODE
        )
    }

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (resultCode == Activity.RESULT_OK && requestCode == REQUEST_CODE) {
            Toast.makeText(
                this,
                data?.getStringExtra("value") ?: "no return data",
                Toast.LENGTH_SHORT
            ).show()
        }
    }

    //</editor-fold>
}

class SecondActivity : AppCompatActivity(R.layout.activity_second) {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        back.setOnClickListener {
            setResult(Activity.RESULT_OK, Intent().putExtra("value", "I am back !"))
            finish()
        }
    }
}

当我们集成了androidx.activity:activity:1.2.0-alpha05后,startActivityForResult方法已经被标记为了@Deprecated

插播:
新的AppCompatActivity以及ComponentActivity,支持构造函数中传入layotuId了,不用再setContentView()了

基本的流程是:

定义一个 REQUEST_CODE ，同一页面有多个时，保证不重复
调用 startActivityForResult
在 onActivityResult 中接收回调，并判断 requestCode，resultCode
而且上述代码,都必须写在视图控制器(Activity/Fragment)里,也就造成了不容易测试等问题,

但是长久以来,我们也只有这一个选择，所以也很少看到有人抱怨 onActivityResult。
Google 工程师为我们改进了这一问题。就推出了新的 Activity Result API 。

2.Activity Result API

    //<editor-fold desc="页面跳转 新的写法">
    private val startActivity =
        registerForActivityResult(ActivityResultContracts.StartActivityForResult()) {
            Log.d(TAG, "activityResult -> $it")
            Log.d(TAG, "activityResult -> ${it.data?.getStringExtra("value")}")
            textView.text = it.data?.getStringExtra("value")
        }

    fun jumpV2() {
        startActivity.launch(Intent(this, SecondActivity::class.java))
    }

    //</editor-fold>

P.S.
registerForActivityResult方法,在之前较早的版本总是叫做prepareCall的

可以看到,主要就是2个方法: registerForActivityResult 和 launch

下面来详细解读一下这两个方法:

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

registerForActivityResult方法接收两个参数，ActivityResultContract 和 ActivityResultCallback ，返回值是 ActivityResultLauncher 。这几个名字取得都很好，见名知意。

ActivityResultContract

ActivityResultContract 可以理解为一种协议，它是一个抽象类，提供了两个能力，createIntent 和 parseResult 。

这两个能力放到启动 Activity 中就很好理解了，createIntent 负责为 startActivityForResult 提供 Intent ，parseResult 负责处理 onActivityResult 中获取的结果。

上面的例子中，registerForActivityResult() 方法传入的协议实现类是 StartActivityForResult 。

它是 ActivityResultContracts 类中的静态内部类。除了 StartActivityForResult 之外，官方还默认提供了 RequestPermissions ，Dial ，RequestPermission ，TakePicture，它们都是 ActivityResultContract 的实现类,而且都位于ActivityResultContracts 这个final类里面

所以，除了可以简化 startActivityForResult ，权限请求，拨打电话，拍照，都可以通过 Activity Result API 得到了简化。

除了使用官方默认提供的这些之外，我们还可以自己实现 ActivityResultContract，在后面的代码中会进行演示。

ActivityResultCallback

public interface ActivityResultCallback<O> {

    /**
     * Called when result is available
     */
    void onActivityResult(@SuppressLint("UnknownNullness") O result);
}

这个就很容易立即,是结果的回调接口
需要注意的是: registerForActivityResult()方法的泛型现在,这里的返回值result即泛型里的O (output)泛型,一定是类型安全的.

StartActivityForResult --> ActivityResult
TakePicture --> Bitmap
Dial/RequestPermission --> Boolean
RequestPermissions--> Map
具体的,可以去ActivityResultContracts类里面查看各个协议的具体参数类型

ActivityResultLauncher

registerForActivityResult的返回值,通过调用launch()方法,执行业务,最终会调用ActivityResultRegistry.register()方法,具体的源码这里就不分析了，后面原博会单独写一篇源码解析。

大致流程是: 自动生成 requestCode，注册回调并存储起来，绑定生命周期，当收到 Lifecycle.Event.ON_DESTROY 事件时，自动解绑注册。

代替 startActivityForResult() 的就是 ActivityResultLauncher.launch()方法，最后会调用到 ActivityResultRegistry.invoke() 方法，如下所示：

Intent intent = contract.createIntent(activity, input);
                    if ("androidx.activity.result.contract.action.REQUEST_PERMISSIONS".equals(intent.getAction())) {
                        // handle request permissions
                    } else if ("androidx.activity.result.contract.action.INTENT_SENDER_REQUEST".equals(intent.getAction())) {
                       // handle intentSender
                    } else {
                        Bundle optionsBundle = null;
                        if (intent.hasExtra("androidx.activity.result.contract.extra.ACTIVITY_OPTIONS_BUNDLE")) {
                            optionsBundle = intent.getBundleExtra("androidx.activity.result.contract.extra.ACTIVITY_OPTIONS_BUNDLE");
                        } else if (options != null) {
                            optionsBundle = options.toBundle();
                        }

                        ActivityCompat.startActivityForResult(activity, intent, requestCode, optionsBundle);
                    }

可以看到,最终调用的是 ActivityCompat.startActivityForResult();

中间那一块处理 request permissions 的我给掐掉了。这样看起来看清晰。本来准备单独水一篇源码解析的，这马上核心源码都讲完了。

前面展示过了 startActivityForResult() ，再来展示一下权限请求。


    private val permissionRequest =
        registerForActivityResult(ActivityResultContracts.RequestPermission()) {
            Log.d(TAG, "permissionResult -> $it")
            textView.text = "CAMERA result -> $it"
        }

    fun jumpV3() {
        permissionRequest.launch(Manifest.permission.CAMERA)
    }

其余权限的请求,在这里就不展示了

3.如何自定义返回值？

前面提到的都是系统预置的协议(ActivityResultContract)，输入值,返回值类型也都是固定的。那么，如何返回自定义类型的值呢？其实也很简单，自定义 ActivityResultContract,指明业务所需要的泛型就ok了

我们以TakePicturePreview为例,输入值是Void 默认返回值是Bitmap,现在假如我们需要返回Drawable

    private class TakeDrawable(val context: Context) : ActivityResultContract<Void, Drawable>() {
        override fun createIntent(context: Context, input: Void?): Intent {
            return Intent(MediaStore.ACTION_IMAGE_CAPTURE)
        }

        override fun parseResult(resultCode: Int, intent: Intent?): Drawable? {
            if (null == intent || resultCode != Activity.RESULT_OK)
                return null
            if (intent == null || resultCode != Activity.RESULT_OK) return null;
            val bitmap = intent.getParcelableExtra<Bitmap>("data")
            return BitmapDrawable(context.resources, bitmap);
        }

    }

    private val picture =
        registerForActivityResult(TakeDrawable(this)) {
            Log.d(TAG, "picture -> $it")
            imageView.setImageDrawable(it)
        }


    fun takePic() {
        picture.launch(null);
    }

大部分代码参照TakePicturePreview的逻辑,只需要在parseResult里面,使用构造方法传入的Context,把bimap对象转换为BitmapDrawable即可.
这样就可以调用系统相机拍照并在结果回调中拿到 Drawable 对象了。

4.说好的解耦呢？

有时候我们可能会在结果回调中进行一些复杂的处理操作，无论是之前的 onActivityResult() 还是上面内部类的写法，都是直接耦合在视图控制器中的。

通过新的 Activity Result API，我们还可以单独的类中处理结果回调，真正做到单一职责。

其实 Activity Result API 的核心操作都是通过 ActivityResultRegistry 来完成的，ComponentActivity 中包含了一个 ActivityResultRegistry 对象

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

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

    /**
     * Get the {@link ActivityResultRegistry} associated with this activity.
     *
     * @return the {@link ActivityResultRegistry}
     */
    @NonNull
    @Override
    public final ActivityResultRegistry getActivityResultRegistry() {
        return mActivityResultRegistry;
    }

通过新的 Activity Result API，我们还可以单独的类中处理结果回调，真正做到单一职责。

其实 Activity Result API 的核心操作都是通过 ActivityResultRegistry 来完成的，ComponentActivity 中包含了一个 ActivityResultRegistry 对象

我们可以看到,registerForActivityResult(,,_)方法的第二个参数,就是ActivityResultRegistry,并且ComponentActivity还提供了相应的get方法暴露ActivityResultRegistry

现在要脱离 Activity 完成操作，就需要把ActivityResultRegistry 提供给外部,用来来进行结果回调的注册工作。同时，我们一般通过实现 LifecycleObserver 接口，绑定个 LifecycleOwner 来进行自动解绑注册。

class TakePicPreviewObserver(
    val activityResultRegistry: ActivityResultRegistry,
    val onResult: (Bitmap) -> Unit
) : DefaultLifecycleObserver {
    lateinit var takePhotoLauncher :ActivityResultLauncher<Void>
    override fun onCreate(owner: LifecycleOwner) {
        Log.d("TakePicObsver","onCreate")
        takePhotoLauncher = activityResultRegistry.register(
            "key",
            ActivityResultContracts.TakePicturePreview(),
            onResult
        )
    }
    fun takePicture() {
        takePhotoLauncher.launch(null)
    }

    override fun onDestroy(owner: LifecycleOwner) {
        Log.d("TakePicObsver","onDestroy")
        takePhotoLauncher.unregister()
    }
}

插播:对DefaultLifycycleObserver的说明

DefaultLifecyclerObserver是'androidx.lifecycle:lifecycle-common-java8:2.3.0-alpha03'包里的,也是唯一个文件,
继承自FullLifecyclerObserver(androidx.lifecycle:lifecycle-common:2.3.0-alpha03包内的),
而且两个类完全一样,而且DefaultLifecyclerObserver
@SuppressWarnings("unused") 表示该属性在方法或类中没有使用。添加此注解可以去除属性上的黄色警告！！！
但是FullLifecycleObserver不是public的是package private(即:我们常说的包保护)的,因此,
外部类是不能直接实现它的,所以需要借助DefaultLifecyclerObserver,来使用相应方法


/**
 * Callback interface for listening to {@link LifecycleOwner} state changes.
 * <p>
 * If you use Java 8 language, <b>always</b> prefer it over annotations.
 * <p>
 * If a class implements both this interface and {@link LifecycleEventObserver}, then
 * methods of {@code DefaultLifecycleObserver} will be called first, and then followed by the call
 * of {@link LifecycleEventObserver#onStateChanged(LifecycleOwner, Lifecycle.Event)}
 * <p>
 * If a class implements this interface and in the same time uses {@link OnLifecycleEvent}, then
 * annotations will be ignored.
 */

上面的注释也已经指明,DefaultLifecyclerObserver是LifecycleOwner的一个回调接口,
如果使用java8 作为语言环境,那么使用这个DefaultLifecyclerObserver是优于使用注解处理生命周期回调的

下面翻译一下上方注释的其余部分:

如果某个类实现了即实现了{@link DefaultLifecyclerObserver}  又实现了{@link LifecycleEventObserver}接口,
那么 {@link DefaultLifecyclerObserver}的实现方法,优先调用,然后会回调 {@link LifecycleEventObserver#onStateChanged(LifecycleOwner, Lifecycle.Event)}
方法

如果某个类实现了{@link DefaultLifecyclerObserver}接口,同时,又使用了 {@link OnLifecycleEvent}的注解,
那么注解会被忽略,不会被调用

再附上 LifecycleObserver FullLifecycleObserver LifecycleEventObserver DefaultLifecyclerObserver
的层级关系

LifecycleObserver
   ↳LifecycleEventObserver
   ↳FullLifecycleObserver(package private)
        ↳DefaultLifecyclerObserver

5.再玩点花出来？结合LiveData,进行数据观察

在 Github 上看到了一些花式写法，和大家分享一下。

class TakePicPreviewLiveData(
    val activityResultRegistry: ActivityResultRegistry
) : LiveData<Bitmap>() {
    private  lateinit var takePhotoLauncher: ActivityResultLauncher<Void>
    override fun onActive() {
        super.onActive()
        Log.d("TakePicLiveData", "onActive")
        takePhotoLauncher = activityResultRegistry.register(
            "key",
            ActivityResultContracts.TakePicturePreview()
        ) {
            Log.d("TakePicLiveData", "onActive callback thread: ${Thread.currentThread().name}")
            value = it
        }
    }
    fun takePicture() {
        takePhotoLauncher.launch(null)
    }
    override fun onInactive() {
        super.onInactive()
        Log.d("TakePicLiveData", "onInactive")
        //takePhotoLauncher.unregister()
    }
}

但是,又一个问题出现了,目前不知道如何解决:可以看到,在onInactive()这个LiveData的生命周期里,
我注释掉了一句代码takePhotoLauncher.unregister()
这么做的原因是,当我们唤起相机,进行拍照时,我们的Activity或Fragment作为LifecycleOwener,会进入onPause()
生命周期,同时onInactive(),会在生命周期不是{@link Lifecycle.State#STARTED} 时 {@link Lifecycle.State#RESUMED}
被回调,也就是说,我们唤起相机拍照时,onInactive会被回调,如果我们在这里对ActivityResultLauncher进行unregister(),
那么,我们就拿不到返回的结果了,也就无法通过LiveData进一步把数据通知出去了.

对于这个问题,我暂时没有想到好的解决办法,
只有一个想法,就是我们在继承LiveData的同时,实现DefaultLifecycleObserver,就想之前写的TakePicPreviewObserver一样,
在DefaultLifecycleObserver#onDestroy 里进行 unregister()

至此,关于Activity Result API的学习,就暂告一段落,希望对你有所帮助...

本篇文字写于: 2020/6/8