再见！onActivityResult！你好，Activity Results API！

时间  2021-08-14 标签 java android 面试 微信 markdown app 框架 ide gradle

背景

在Android应用程序开发中，启动一个Activity不必定是单项操做，从启动的Activity获取数据是常见的场景，最传统的方式是经过Intent携带数据，而后使用startActivityForResult方法来启动下一个Activity，而后经过onActivityResult来接收返回的结果，代码以下：java

  1. 调用startActivityForResult方法启动
startActivityForResult(intent,1)
复制代码
  1. 实现onActivityResult方法
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if(resultCode == 1 && resultCode == Activity.RESULT_OK){
            // 处理第二个页面带回的数据
        }
}
复制代码

以上方式，onActivityResult就能获取从上一个界面返回的数据，这种方式很是有用，不只能同一个应用中，也能够从其余应用中获取数据，好比咱们常见的，调用系统相机、相册获取照片，获取系统通信录等。android

但也有一些问题...面试

随着应用的扩展，onActivityResult回调方法各类嵌套、耦合严重、难以维护。 最多见的场景就是调用系统相机相册获取照片了。代码可能像是以下这样：微信

class MainActivity : AppCompatActivity() {

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

    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        if (resultCode == Activity.RESULT_OK) {
            when (requestCode) {
                REQUEST_PERMISSION -> {
                    // 处理权限
                }
                REQUEST_CAMERA -> {
                    // 相机获取图片结果
                }
                REQUEST_ALBUM -> {
                    // 相册获取图片结果
                }
                REQUEST_CROP -> {
                    // 系统裁剪
                }
            }
        }

        super.onActivityResult(requestCode, resultCode, data)
    }

    companion object {
        const val REQUEST_PERMISSION = 1001
        const val REQUEST_CAMERA = 1002
        const val REQUEST_ALBUM = 1003
        const val REQUEST_CROP = 1004
    }
}
复制代码

各类处理结果都耦合在onActivityResult回调里，而且还得定义一堆额外的常量REQUEST_CODE,用与判断是哪一个请求的回调结果。markdown

onActivityResult 现状？

Google 可能也意识到onActivityResult的这些问题，在androidx.activity:activity:1.2.0-alpha02 和androidx.fragment:fragment:1.3.0-alpha02 中，已经废弃了startActivityForResult和onActivityResult方法。app

/** * {@inheritDoc} * * @deprecated use * {@link #registerForActivityResult(ActivityResultContract, ActivityResultCallback)} * passing in a {@link StartActivityForResult} object for the {@link ActivityResultContract}. */
   @Override
   @Deprecated
   public void startActivityForResult(@SuppressLint("UnknownNullness") Intent intent, int requestCode) {
       super.startActivityForResult(intent, requestCode);
   }
复制代码
/** * {@inheritDoc} * * @deprecated use * {@link #registerForActivityResult(ActivityResultContract, ActivityResultCallback)} * with the appropriate {@link ActivityResultContract} and handling the result in the * {@link ActivityResultCallback#onActivityResult(Object) callback}. */
   @CallSuper
   @Override
   @Deprecated
   protected void onActivityResult(int requestCode, int resultCode, @Nullable Intent data) {
       if (!mActivityResultRegistry.dispatchResult(requestCode, resultCode, data)) {
           super.onActivityResult(requestCode, resultCode, data);
       }
   }
复制代码

能够看到，这两个方法都被标记为了Deprecated，那这两个方法不推荐使用了，Google推荐使用什么方式从Activity中更好的获取数据呢？答案就是 Activity Results API框架

Activity Results API

Activity Results API 是 Google官方推荐的Activity、Fragment获取数据的方式。ide

Activity Results API 到底怎么用？相比onActivityResult有哪些优点？接下来，将一一为你解答。gradle

在介绍如何使用以前，先为你们介绍Activity Results API 中两个重要的组件：ActivityResultContract和ActivityResultLauncher。ui

  • ActivityResultContract: 协议，它定义了如何传递数据和如何处理返回的数据。ActivityResultContract是一个抽象类，你须要继承它来建立本身的协议，每一个 ActivityResultContract 都须要定义输入和输出类，若是您不须要任何输入，可以使用 Void（在 Kotlin 中，使用 Void? 或 Unit）做为输入类型。

  • ActivityResultLauncher: 启动器，调用ActivityResultLauncher的launch方法来启动页面跳转，做用至关于原来的startActivity()

使用 Activity Results API 在Activity之间传递数据
1. 首先，在app下的build.gradle中加入依赖:
implementation 'androidx.activity:activity:1.2.0-beta01'
implementation 'androidx.fragment:fragment:1.3.0-beta01'
复制代码
2. 定义协议

新建一个Contract类，继承自ActivityResultContract<I,O>，其中，I是输入的类型，O是输出的类型。须要实现2个方法，createIntent和parseResult,输入类型I做为createIntent的参数，输出类型O做为parseResult方法的返回值，在下面的例子中，输入输出类型都是String:

class MyActivityResultContract: ActivityResultContract<String,String>(){
        override fun createIntent(context: Context, input: String?): Intent {
            return Intent(context,SecondActivity::class.java).apply {
                putExtra("name",input)
            }
        }

        override fun parseResult(resultCode: Int, intent: Intent?): String? {
            val data = intent?.getStringExtra("result")
            return if (resultCode == Activity.RESULT_OK && data != null) data
            else null
        }

    }
复制代码

如上代码，咱们在createIntent方法中建立了Intent，而且携带了参数name,在parseResult方法中，获取了返回的数据result。

3. 注册协议，获取启动器-ActivityResultLauncher

注册协议，使用registerForActivityResult方法，该方法由ComponentActivity或者Fragment提供,接受2个参数，第一个参数就是咱们定义的Contract协议，第二个参数是一个回调ActivityResultCallback<O>,其中O就是前面Contract的输出类型。代码以下：

private val myActivityLauncher = registerForActivityResult(MyActivityResultContract()){result ->
   Toast.makeText(applicationContext,result,Toast.LENGTH_SHORT).show()
   textView.text = "回传数据：$result"
}
复制代码

如上代码，注册了MyActivityResultContract,registerForActivityResult方法的返回值是ActivityResultLauncher, 所以咱们定义了一个myActivityLauncher,回调方法中，result就是从上一个界面传回的值。这里咱们简单的用Toast显示。

4. 最后，调用启动器的launch方法开启界面跳转

MainActivity中添加一个Button,点击Button时，调用launch方法跳转：

button.setOnClickListener {
      // 开启页面跳转
      myActivityLauncher.launch("Hello,技术最TOP")
 }
复制代码

SecondActivity的代码很简单：

class SecondActivity : AppCompatActivity(){

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

        val name = intent.getStringExtra("name")
        textView3.text = "接收到的数据为：$name"

        button2.setOnClickListener {
            val intent = Intent().apply {
                putExtra("result","Hello，依然范特西稀，我是回传的数据！")
            }
            setResult(Activity.RESULT_OK,intent)
            finish()
        }
    }
}
复制代码

以上3步，就实现了使用新的Activity Results API 来完成Activity之间的数据传递，并获取Activity返回的数据

看一下效果:

这就完了吗？

你可能会有疑问，虽然确实减小了代码耦合，可是使用并不简单啊。

确实，但这并无完！！！

预约义的Contract

大伙都看出来，新的Activity Results API使用起来好像有点麻烦，每次都得定义Contract。Google确定考虑到了这个问题的，因而，Google 预约义了不少Contract,把大家能想到的使用场景基本上都想到了，它们都定义在类ActivityResultContracts中,有如下这些Contract:

StartActivityForResult() 
RequestMultiplePermissions()
RequestPermission()
TakePicturePreview()
TakePicture()
TakeVideo()
PickContact()
CreateDocument()
OpenDocumentTree()
OpenMultipleDocuments()
OpenDocument()
GetMultipleContents()
GetContent()
复制代码

下面分别介绍一下这些Contract:

  • StartActivityForResult: 通用的Contract,不作任何转换，Intent做为输入，ActivityResult做为输出，这也是最经常使用的一个协定。

  • RequestMultiplePermissions： 用于请求一组权限

  • RequestPermission: 用于请求单个权限

  • TakePicturePreview: 调用MediaStore.ACTION_IMAGE_CAPTURE拍照，返回值为Bitmap图片

  • TakePicture: 调用MediaStore.ACTION_IMAGE_CAPTURE拍照，并将图片保存到给定的Uri地址，返回true表示保存成功。

  • TakeVideo: 调用MediaStore.ACTION_VIDEO_CAPTURE 拍摄视频，保存到给定的Uri地址，返回一张缩略图。

  • PickContact: 从通信录APP获取联系人

  • GetContent: 提示用选择一条内容，返回一个经过ContentResolver#openInputStream(Uri)访问原生数据的Uri地址（content://形式） 。默认状况下，它增长了 Intent#CATEGORY_OPENABLE, 返回能够表示流的内容。

  • CreateDocument: 提示用户选择一个文档，返回一个(file:/http:/content:)开头的Uri。

  • OpenMultipleDocuments: 提示用户选择文档（能够选择多个），分别返回它们的Uri，以List的形式。

  • OpenDocumentTree: 提示用户选择一个目录，并返回用户选择的做为一个Uri返回，应用程序能够彻底管理返回目录中的文档。

上面这些预约义的Contract中，除了StartActivityForResult和RequestMultiplePermissions以外，基本都是处理的与其余APP交互，返回数据的场景，好比，拍照，选择图片，选择联系人，打开文档等等。使用最多的就是StartActivityForResult和RequestMultiplePermissions了。

有了这些预约义的Contract, Activity之间传递数据就简单多了，好比，前面的例子，能够简化成这样：

1. 注册协议，获取ActivityResultLauncher:

private val myActivityLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()){ activityResult ->  
        if(activityResult.resultCode == Activity.RESULT_OK){
            val result = activityResult.data?.getStringExtra("result")
            Toast.makeText(applicationContext,result,Toast.LENGTH_SHORT).show()
            textView.text = "回传数据：$result"
        }
    }
复制代码

2. 构造须要传递的数据，启动页面跳转

button.setOnClickListener {
        val  intent = Intent(this,SecondActivity::class.java).apply {
             putExtra("name","Hello,技术最TOP")
        }
        myActivityLauncher.launch(intent)
}
复制代码

OK，就是这么简单！！！

在好比，咱们的权限，申请，请看代码：

request_permission.setOnClickListener {
    requestPermission.launch(permission.BLUETOOTH)
}

request_multiple_permission.setOnClickListener {
    requestMultiplePermissions.launch(
        arrayOf(
            permission.BLUETOOTH,
            permission.NFC,
            permission.ACCESS_FINE_LOCATION
        )
    )
}

// 请求单个权限
private val requestPermission =
    registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
        // Do something if permission granted
        if (isGranted) toast("Permission is granted")
        else toast("Permission is denied")
    }

// 请求一组权限
private val requestMultiplePermissions =
    registerForActivityResult(ActivityResultContracts.RequestMultiplePermissions()) { permissions : Map<String, Boolean> ->
        // Do something if some permissions granted or denied
        permissions.entries.forEach {
            // Do checking here
        }                                                                             
}
复制代码

有了这个，咱们就能够抛弃全部的第三方权限请求框架，只须要将这两个Contract放到BaseActivity中，或者抽取到一个单独的类中，就能随时随地申请权限。是否是很方便！！！

在非Activity/Fragment的类中接收Activity的结果

在Activity和Fragment中，咱们能直接使用registerForActivityResultAPI ，那是由于ConponentActivity和Fragment基类实现了ActivityResultCaller 接口,在非Activity/Fragment中，若是咱们想要接收Activity回传的数据，能够直接使用 ActivityResultRegistry 来实现。

好比，用一个单独的类来实现协议的注册和启动器的启动：

class MyLifecycleObserver(private val registry : ActivityResultRegistry)
            : DefaultLifecycleObserver {
        lateinit var getContent : ActivityResultLauncher<String>

        fun onCreate(owner: LifecycleOwner) {
            getContent = registry.register("key", owner, GetContent()) { uri ->
                // Handle the returned Uri
            }
        }

        fun selectImage() {
            getContent("image/*")
        }
    }

    class MyFragment : Fragment() {
        lateinit var observer : MyLifecycleObserver

        override fun onCreate(savedInstanceState: Bundle?) {
            // ...

            observer = MyLifecycleObserver(requireActivity().activityResultRegistry)
            lifecycle.addObserver(observer)
        }

        override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
            val selectButton = view.findViewById<Button>(R.id.select_button)

            selectButton.setOnClickListener {
                // Open the activity to select an image
                observer.selectImage()
            }
        }
    }
复制代码

示例中，咱们在MyLifecycleObserver中实现协议注册和启动器启动，为何要实现LifecycleObserver 呢？由于，使用生命周期组件，LifecycleOwner 会在 Lifecycle 被销毁时自动移除已注册的启动器。不过，若是 LifecycleOwner 不存在，则每一个 ActivityResultLauncher 类都容许您手动调用 unregister() 做为替代。但在使用ActivityResultRegistry时，Google官方强烈建议咱们使用可接受 LifecycleOwner 做为参数的 API。

Activity和Fragment中为何不须要手动调用unregister()呢？,由于ComponentActivity和Fragment已经实现了LifecycleObserver。

ComponentActivity源码在这里：

Fragment中源码在这里：

总结

新的Activity Result API提供了一种执行许多常见任务的简便方法，好比咱们调用第三方APP 获取数据，请求权限、拍照、选图片、获取联系人等等。除此以外，下降了代码的耦合，减小了样板代码（好比，定义requestCode常量）。另外，startActivityForResult和onActivityResult已经被废弃，官方也是强烈建议使用这种方式来进行数据传递并获取Activity返回的数据。

还没用起来的，赶快使用起来，贼香！！！祝你们编码愉快！！！

文章首发于公众号：「 技术最TOP 」，天天都有干货文章持续更新，能够微信搜索「 技术最TOP 」第一时间阅读，回复【思惟导图】【面试】【简历】有我准备一些Android进阶路线、面试指导和简历模板送给你

联系我们 沪ICP备13005482号-10