启动另一个 activity(无论是您应用中的 activity 还是其他应用中的 activity)不一定要是单向操作。您也可以启动一个 activity 并接收返回的结果。例如,您的应用可启动相机应用并接收拍摄的照片作为结果。或者,您可以启动“通讯录”应用以便用户选择联系人,然后接收联系人详细信息作为结果。
虽然所有 API 级别的 Activity
类均提供底层 startActivityForResult()
和 onActivityResult()
API,但 Google 强烈建议您使用 AndroidX Activity
和 Fragment
类中引入的 Activity Result API。
Activity Result API 提供了用于注册结果的组件, 启动生成结果的 activity,并在完成后处理结果 由系统进行分派
针对 activity 结果注册回调
在启动 activity 以获取结果时,可能会出现您的进程和 activity 因内存不足而被销毁的情况;如果是使用相机等内存密集型操作,几乎可以确定会出现这种情况。
因此,Activity Result API 会将结果回调从您之前启动另一个 activity 的代码位置分离开来。由于在重新创建进程和 activity 时需要使用结果回调,因此每次创建 activity 时都必须无条件注册回调,即使启动另一个 activity 的逻辑仅基于用户输入内容或其他业务逻辑也是如此。
位于 ComponentActivity
或 Fragment
中时,Activity Result API 会提供 registerForActivityResult()
API,用于注册结果回调。registerForActivityResult()
接受 ActivityResultContract
和 ActivityResultCallback
作为参数,并返回 ActivityResultLauncher
,供您用来启动另一个 activity。
ActivityResultContract
定义生成结果所需的输入类型以及结果的输出类型。这些 API 可为拍照和请求权限等基本 intent 操作提供默认协定。您还可以创建自定义协定。
ActivityResultCallback
是单一方法接口,带有 onActivityResult()
方法,可接受 ActivityResultContract
中定义的输出类型的对象:
Kotlin
val getContent = registerForActivityResult(GetContent()) { uri: Uri? -> // Handle the returned Uri }
Java
// GetContent creates an ActivityResultLauncher<String> to let you pass // in the mime type you want to let the user select ActivityResultLauncher<String> mGetContent = registerForActivityResult(new GetContent(), new ActivityResultCallback<Uri>() { @Override public void onActivityResult(Uri uri) { // Handle the returned Uri } });
如果您有多个使用不同协定或需要单独回调的 activity 结果调用,则可以多次调用 registerForActivityResult()
,以注册多个 ActivityResultLauncher
实例。每次创建 fragment 或 activity 时,都必须按照相同的顺序调用 registerForActivityResult()
,以便将生成的结果传递给正确的回调。
在 fragment 或 activity 创建完毕之前可安全地调用 registerForActivityResult()
,因此,在为返回的 ActivityResultLauncher
实例声明成员变量时可以直接使用它。
启动 activity 以获取结果
虽然 registerForActivityResult()
会注册您的回调,但它不会启动另一个 activity 并发出结果请求。这些操作由返回的 ActivityResultLauncher
实例负责。
如果存在输入内容,启动器会接受与 ActivityResultContract
的类型匹配的输入内容。调用 launch()
会启动生成结果的过程。当用户完成后续 activity 并返回时,系统将执行 ActivityResultCallback
中的 onActivityResult()
,如以下示例所示:
Kotlin
val getContent = registerForActivityResult(GetContent()) { uri: Uri? -> // Handle the returned Uri } override fun onCreate(savedInstanceState: Bundle?) { // ... val selectButton = findViewById<Button>(R.id.select_button) selectButton.setOnClickListener { // Pass in the mime type you want to let the user select // as the input getContent.launch("image/*") } }
Java
ActivityResultLauncher<String> mGetContent = registerForActivityResult(new GetContent(), new ActivityResultCallback<Uri>() { @Override public void onActivityResult(Uri uri) { // Handle the returned Uri } }); @Override public void onCreate(@Nullable Bundle savedInstanceState) { // ... Button selectButton = findViewById(R.id.select_button); selectButton.setOnClickListener(new OnClickListener() { @Override public void onClick(View view) { // Pass in the mime type you want to let the user select // as the input mGetContent.launch("image/*"); } }); }
除了传递输入内容之外,launch()
的重载版本还允许您传递 ActivityOptionsCompat
。
在单独的类中接收 activity 结果
虽然 ComponentActivity
和 Fragment
类通过实现 ActivityResultCaller
接口来允许您使用 registerForActivityResult()
API,但您也可以直接使用 ActivityResultRegistry
在未实现 ActivityResultCaller
的单独类中接收 activity 结果。
例如,您可能需要实现一个 LifecycleObserver
,用于处理协定的注册和启动器的启动:
Kotlin
class MyLifecycleObserver(private val registry : ActivityResultRegistry) : DefaultLifecycleObserver { lateinit var getContent : ActivityResultLauncher<String> override fun onCreate(owner: LifecycleOwner) { getContent = registry.register("key", owner, GetContent()) { uri -> // Handle the returned Uri } } fun selectImage() { getContent.launch("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() } } }
Java
class MyLifecycleObserver implements DefaultLifecycleObserver { private final ActivityResultRegistry mRegistry; private ActivityResultLauncher<String> mGetContent; MyLifecycleObserver(@NonNull ActivityResultRegistry registry) { mRegistry = registry; } public void onCreate(@NonNull LifecycleOwner owner) { // ... mGetContent = mRegistry.register(“key”, owner, new GetContent(), new ActivityResultCallback<Uri>() { @Override public void onActivityResult(Uri uri) { // Handle the returned Uri } }); } public void selectImage() { // Open the activity to select an image mGetContent.launch("image/*"); } } class MyFragment extends Fragment { private MyLifecycleObserver mObserver; @Override void onCreate(Bundle savedInstanceState) { // ... mObserver = new MyLifecycleObserver(requireActivity().getActivityResultRegistry()); getLifecycle().addObserver(mObserver); } @Override void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) { Button selectButton = findViewById(R.id.select_button); selectButton.setOnClickListener(new OnClickListener() { @Override public void onClick(View view) { mObserver.selectImage(); } }); } }
使用 ActivityResultRegistry
API 时,Google 强烈建议您使用可接受 LifecycleOwner
作为参数的 API,因为 LifecycleOwner
会在 Lifecycle
被销毁时自动移除已注册的启动器。不过,如果 LifecycleOwner
不可用,每个 ActivityResultLauncher
类都允许您手动调用 unregister()
作为替代。
测试
默认情况下,registerForActivityResult()
会自动使用 activity 提供的 ActivityResultRegistry
。此外,它还提供了一个重载,让您可以传入自己的 ActivityResultRegistry
实例。该实例可用于测试您的 activity 结果调用,无需实际启动另一个 activity。
测试应用的 fragment 时,使用 FragmentFactory
将 ActivityResultRegistry
传入该 fragment 的构造函数即可提供测试 ActivityResultRegistry
。
例如,使用 TakePicturePreview
协定获取图片缩略图的 fragment 可能按类似如下所示的方式编写:
Kotlin
class MyFragment( private val registry: ActivityResultRegistry ) : Fragment() { val thumbnailLiveData = MutableLiveData<Bitmap?> val takePicture = registerForActivityResult(TakePicturePreview(), registry) { bitmap: Bitmap? -> thumbnailLiveData.setValue(bitmap) } // ... }
Java
public class MyFragment extends Fragment { private final ActivityResultRegistry mRegistry; private final MutableLiveData<Bitmap> mThumbnailLiveData = new MutableLiveData(); private final ActivityResultLauncher<Void> mTakePicture = registerForActivityResult(new TakePicturePreview(), mRegistry, new ActivityResultCallback<Bitmap>() { @Override public void onActivityResult(Bitmap thumbnail) { mThumbnailLiveData.setValue(thumbnail); } }); public MyFragment(@NonNull ActivityResultRegistry registry) { super(); mRegistry = registry; } @VisibleForTesting @NonNull ActivityResultLauncher<Void> getTakePicture() { return mTakePicture; } @VisibleForTesting @NonNull LiveData<Bitmap> getThumbnailLiveData() { return mThumbnailLiveData; } // ... }
创建专用于测试的 ActivityResultRegistry
时,必须实现 onLaunch()
方法。您的测试实现可以直接调用 dispatchResult()
,而不是调用 startActivityForResult()
,从而提供要在测试中使用的确切结果:
val testRegistry = object : ActivityResultRegistry() {
override fun <I, O> onLaunch(
requestCode: Int,
contract: ActivityResultContract<I, O>,
input: I,
options: ActivityOptionsCompat?
) {
dispatchResult(requestCode, expectedResult)
}
}
完整的测试会创建预期结果,构造一个测试 ActivityResultRegistry
,将其传递给 fragment,直接触发启动器或使用 Espresso 等其他测试 API 来触发启动器,然后验证结果:
@Test
fun activityResultTest {
// Create an expected result Bitmap
val expectedResult = Bitmap.createBitmap(1, 1, Bitmap.Config.RGBA_F16)
// Create the test ActivityResultRegistry
val testRegistry = object : ActivityResultRegistry() {
override fun <I, O> onLaunch(
requestCode: Int,
contract: ActivityResultContract<I, O>,
input: I,
options: ActivityOptionsCompat?
) {
dispatchResult(requestCode, expectedResult)
}
}
// Use the launchFragmentInContainer method that takes a
// lambda to construct the Fragment with the testRegistry
with(launchFragmentInContainer { MyFragment(testRegistry) }) {
onFragment { fragment ->
// Trigger the ActivityResultLauncher
fragment.takePicture()
// Verify the result is set
assertThat(fragment.thumbnailLiveData.value)
.isSameInstanceAs(expectedResult)
}
}
}
创建自定义协定
虽然 ActivityResultContracts
包含一些预先构建的 ActivityResultContract
类供您使用,但您可以使用自己的协定,提供您所需要的精确类型安全 API。
每个 ActivityResultContract
都需要定义好的输入和输出类,如果您不需要任何输入,请使用 Void
作为输入类型(在 Kotlin 中,请使用 Void?
或 Unit
)。
每个协定都必须实现 createIntent()
方法,该方法接受 Context
和输入内容作为参数,并构造将与 startActivityForResult()
配合使用的 Intent
。
每个协定还必须实现 parseResult()
,它会根据指定的 resultCode
(如 Activity.RESULT_OK
或 Activity.RESULT_CANCELED
)和 Intent
生成输出。
如果无需调用 createIntent()
、启动另一个 activity 并借助 parseResult()
来构建结果即可确定指定输入内容的结果,协定可以选择性地实现 getSynchronousResult()
。
以下示例展示了如何构造 ActivityResultContract
:
Kotlin
class PickRingtone : ActivityResultContract<Int, Uri?>() { override fun createIntent(context: Context, ringtoneType: Int) = Intent(RingtoneManager.ACTION_RINGTONE_PICKER).apply { putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, ringtoneType) } override fun parseResult(resultCode: Int, result: Intent?) : Uri? { if (resultCode != Activity.RESULT_OK) { return null } return result?.getParcelableExtra(RingtoneManager.EXTRA_RINGTONE_PICKED_URI) } }
Java
public class PickRingtone extends ActivityResultContract<Integer, Uri> { @NonNull @Override public Intent createIntent(@NonNull Context context, @NonNull Integer ringtoneType) { Intent intent = new Intent(Intent.ACTION_GET_CONTENT); intent.putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, ringtoneType.intValue()); return intent; } @Override public Uri parseResult(int resultCode, @Nullable Intent result) { if (resultCode != Activity.RESULT_OK || result == null) { return null; } return result.getParcelableExtra(RingtoneManager.EXTRA_RINGTONE_PICKED_URI); } }
如果您不需要自定义协定,则可以使用 StartActivityForResult
协定。这是一个通用协定,它可接受任何 Intent
作为输入内容并返回 ActivityResult
,让您能够在回调中提取 resultCode
和 Intent
,如以下示例所示:
Kotlin
val startForResult = registerForActivityResult(StartActivityForResult()) { result: ActivityResult -> if (result.resultCode == Activity.RESULT_OK) { val intent = result.data // Handle the Intent } } override fun onCreate(savedInstanceState: Bundle) { // ... val startButton = findViewById(R.id.start_button) startButton.setOnClickListener { // Use the Kotlin extension in activity-ktx // passing it the Intent you want to start startForResult.launch(Intent(this, ResultProducingActivity::class.java)) } }
Java
ActivityResultLauncher<Intent> mStartForResult = registerForActivityResult(new StartActivityForResult(), new ActivityResultCallback<ActivityResult>() { @Override public void onActivityResult(ActivityResult result) { if (result.getResultCode() == Activity.RESULT_OK) { Intent intent = result.getData(); // Handle the Intent } } }); @Override public void onCreate(@Nullable savedInstanceState: Bundle) { // ... Button startButton = findViewById(R.id.start_button); startButton.setOnClickListener(new OnClickListener() { @Override public void onClick(View view) { // The launcher with the Intent you want to start mStartForResult.launch(new Intent(this, ResultProducingActivity.class)); } }); }