背景
在Android应用程序开发中，启动一个Activity不一定是单项操作，从启动的Activity获取数据是常见的场景，最传统的方式是通过Intent携带数据，然后使用startActivityForResult方法来启动下一个Activity，然后通过onActivityResult来接收返回的数据，代码如下：
- 调用
startActivityForResult方法启动
startActivityForResult(intent,1)- 实现
onActivityResult方法
override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
super.onActivityResult(requestCode, resultCode, data)
if(requestCode == 1 && resultCode == Activity.RESULT_OK){
// 处理第二个页面带回的数据
}
}以上方式，onActivityResult就能获取从上一个界面返回的数据，这种方式非常有用，不仅能同一个应用中，也可以从其他应用中获取数据，比如我们常见的，调用系统相机、相册获取照片，获取系统通讯录等。
但也有一些问题...
随着应用的扩展，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,用与判断是哪个请求的回调结果。
onActivityResult 现状？
Google 可能也意识到onActivityResult的这些问题，在androidx.activity:activity:1.2.0-alpha02
和`androidx.fragment:fragment:1.3.0-alpha02` 中，已经废弃了`startActivityForResult`和`onActivityResult`方法。
/**
* {@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获取数据的方式。
Activity Results API 到底怎么用？相比onActivityResult有哪些优势？接下来，将一一为你解答。
在介绍如何使用之前，先为大家介绍Activity Results API 中两个重要的组件：ActivityResultContract和ActivityResultLauncher。
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返回的数据。
还没用起来的，赶快使用起来，贼香！！！祝大家编码愉快！！！
android
java
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。