关于android:再见onActivityResult你好Activity-Results-API

45次阅读

共计 9213 个字符，预计需要花费 24 分钟才能阅读完成。

背景

在 Android 利用程序开发中，启动一个 Activity 不肯定是单项操作，从启动的 Activity 获取数据是常见的场景，最传统的形式是通过 Intent 携带数据，而后应用 startActivityForResult 办法来启动下一个 Activity，而后通过 onActivityResult 来接管返回的数据，代码如下：

  1. 调用 startActivityForResult 办法启动
 startActivityForResult(intent,1)
  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
发表至： android
2020-10-26
 0
关于android:某开发者上架-bundle应用测试闪退被驳回
关于android:Android-12-已来你的-App-崩溃了吗
关于android:协程中的取消和异常-取消操作详解
关于android:Android高级进阶之路二十分钟彻底弄明白-View-事件分发机制