Android ActivityResult 介绍

最新推荐文章于 2024-11-20 08:30:00 发布
最新推荐文章于 2024-11-20 08:30:00 发布
阅读量5k 收藏 6
点赞数 3
分类专栏： Android 开发 文章标签： android java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/caoshen2014/article/details/121375418
版权

Android ActivityResult 介绍

ActivityResult API 是 androidx.activity:activity 包引入的新 API，用来替代原有的 onActivityResult 获取上一个 Activity 返回的结果。

被废弃的 startActivityForResult 和 onActivityResult

startActivityForResult

从 ComponentActivity 的 startActivityForResult 方法 @Deprecated 注解可以看出这个方法已经被废弃，建议使用 registerForActivityResult 替代。

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

onActivityResult

从 ComponentActivity 的 onActivityResult 方法 @Deprecated 注解可以看出这个方法已经被废弃，建议使用 registerForActivityResult 替代。


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

ActivityResult 用法

registerForActivityResult

registerForActivityResult 是 ComponentActivity 的 public 方法，它接收一个 ActivityResultContract 和一个 ActivityResultCallback。

ActivityResultContract

ActivityResultContract 表示本次 Activity 启动的类型。

如果启动一个需要返回结果的 Activity，可以使用 ActivityResultContracts.StartActivityForResult()。

如果启动一个权限 Activity，就可以使用 ActivityResultContracts.RequestPermission()。

如果需要使用照片预览，可以使用 ActivityResultContracts.TakePicturePreview()。

ActivityResultCallback

ActivityResultCallback 表示上一个 Activity 回传的 ActivityResult 结果。

用法

首先使用 registerForActivityResult 得到 ActivityResultLauncher，在闭包中写上需要处理的ActivityResult。

    private val activityResultLauncher: ActivityResultLauncher<Intent> =
        registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { activityResult: ActivityResult ->
            if (activityResult.resultCode == Activity.RESULT_OK) {
                // 收到 ActivityResult
            }
        }

如果要启动一个 Activity，使用 activityResultLauncher 的 launch 方法，替代原来的 startActivityForResult。

            activityResultLauncher.launch(Intent(this, SecondActivity::class.java))

在需要返回结果的被启动 Activity 调用 setResult。

            setResult(Activity.RESULT_OK, Intent().putExtra("key", "value"))
            finish()

ActivityResult 好处

registerForActivityResult 的第一个参数 ActivityResultContracts 封装了很多常用的启动类型。不再需要调用者写不同 Activity 的启动代码。

使用 registerForActivityResult 之后也不需要再为 startActivityForResult 定义 requestCode。

ActivityResultContracts 有 14 个封装好的子类。

StartActivityForResult

常用的 Activity 启动，不带任何转换。

        @NonNull
        @Override
        public Intent createIntent(@NonNull Context context, @NonNull Intent input) {
            return input;
        }

StartIntentSenderForResult

启动 IntentSender，调用了 Activity 的 startIntentSender 方法。

        @NonNull
        @Override
        public Intent createIntent(@NonNull Context context, @NonNull IntentSenderRequest input) {
            return new Intent(ACTION_INTENT_SENDER_REQUEST)
                    .putExtra(EXTRA_INTENT_SENDER_REQUEST, input);
        }

RequestMultiplePermissions

请求多个权限

        @NonNull
        static Intent createIntent(@NonNull String[] input) {
            return new Intent(ACTION_REQUEST_PERMISSIONS).putExtra(EXTRA_PERMISSIONS, input);
        }

解析 Intent 调用了 ContextCompat.checkSelfPermission 方法。

        @Override
        public @Nullable SynchronousResult<Map<String, Boolean>> getSynchronousResult(
                @NonNull Context context, @Nullable String[] input) {

            if (input == null || input.length == 0) {
                return new SynchronousResult<>(Collections.<String, Boolean>emptyMap());
            }

            Map<String, Boolean> grantState = new ArrayMap<>();
            boolean allGranted = true;
            for (String permission : input) {
                boolean granted = ContextCompat.checkSelfPermission(context, permission)
                        == PackageManager.PERMISSION_GRANTED;
                grantState.put(permission, granted);
                if (!granted) allGranted = false;
            }

            if (allGranted) {
                return new SynchronousResult<>(grantState);
            }
            return null;
        }

RequestPermission

请求单个权限，间接调用了 RequestMultiplePermissions

        @NonNull
        @Override
        public Intent createIntent(@NonNull Context context, @NonNull String input) {
            return RequestMultiplePermissions.createIntent(new String[] { input });
        }

TakePicturePreview

照片预览。构造 MediaStore.ACTION_IMAGE_CAPTURE 的 Intent。

new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

TakePicture

拍照并保存。传递 URI 作为保存路径。

        public Intent createIntent(@NonNull Context context, @NonNull Uri input) {
            return new Intent(MediaStore.ACTION_IMAGE_CAPTURE)
                    .putExtra(MediaStore.EXTRA_OUTPUT, input);
        }

TakeVideo

录像并保存。

        public Intent createIntent(@NonNull Context context, @NonNull Uri input) {
            return new Intent(MediaStore.ACTION_VIDEO_CAPTURE)
                    .putExtra(MediaStore.EXTRA_OUTPUT, input);
        }

PickContact

选择通讯录

        @NonNull
        @Override
        public Intent createIntent(@NonNull Context context, @Nullable Void input) {
            return new Intent(Intent.ACTION_PICK).setType(ContactsContract.Contacts.CONTENT_TYPE);
        }

GetContent

根据 Uri 从 ContentResolver 加载内容。

        public Intent createIntent(@NonNull Context context, @NonNull String input) {
            return new Intent(Intent.ACTION_GET_CONTENT)
                    .addCategory(Intent.CATEGORY_OPENABLE)
                    .setType(input);
        }

GetMultipleContents

根据 Uri 从 ContentResolver 加载多个内容。

        @CallSuper
        @NonNull
        @Override
        public Intent createIntent(@NonNull Context context, @NonNull String input) {
            return new Intent(Intent.ACTION_GET_CONTENT)
                    .addCategory(Intent.CATEGORY_OPENABLE)
                    .setType(input)
                    .putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true);
        }

OpenDocument

打开文档。

        @CallSuper
        @NonNull
        @Override
        public Intent createIntent(@NonNull Context context, @NonNull String[] input) {
            return new Intent(Intent.ACTION_OPEN_DOCUMENT)
                    .putExtra(Intent.EXTRA_MIME_TYPES, input)
                    .setType("*/*");
        }

OpenMultipleDocuments

打开多个文档。

        @CallSuper
        @NonNull
        @Override
        public Intent createIntent(@NonNull Context context, @NonNull String[] input) {
            return new Intent(Intent.ACTION_OPEN_DOCUMENT)
                    .putExtra(Intent.EXTRA_MIME_TYPES, input)
                    .putExtra(Intent.EXTRA_ALLOW_MULTIPLE, true)
                    .setType("*/*");
        }

OpenDocumentTree

打开目录。

        @CallSuper
        @NonNull
        @Override
        public Intent createIntent(@NonNull Context context, @Nullable Uri input) {
            Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT_TREE);
            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
                    && input != null) {
                intent.putExtra(DocumentsContract.EXTRA_INITIAL_URI, input);
            }
            return intent;
        }

CreateDocument

创建文档

        @CallSuper
        @NonNull
        @Override
        public Intent createIntent(@NonNull Context context, @NonNull String input) {
            return new Intent(Intent.ACTION_CREATE_DOCUMENT)
                    .setType("*/*")
                    .putExtra(Intent.EXTRA_TITLE, input);
        }

ActivityResult 原理

ActivityResult 使用 ActivityResultLauncher 的 launch 方法代替了 startActivityForResult。

            activityResultLauncher.launch(Intent(this, SecondActivity::class.java))

ActivityResultLauncher 是一个抽象类，它的 launch 方法如下：

ActivityResultLauncher

launch 方法调用了 2 个参数的 launch 抽象方法。

    public void launch(@SuppressLint("UnknownNullness") I input) {
        launch(input, null);
    }

    public abstract void launch(@SuppressLint("UnknownNullness") I input,
            @Nullable ActivityOptionsCompat options);

registerForActivityResult

ComponentActivity 的 registerForActivityResult 方法调用了 registry 的 register 方法。mActivityResultRegistry 是 ComponentActivity 的私有类变量。

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

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

ActivityResultRegistry

ComponentActivity 的 mActivityResultRegistry 实现 ActivityResultRegistry 类的 onLaunch 抽象方法，表示 Intent 启动时需要做的事情。

ActivityResultRegistry.onLaunch
    private final ActivityResultRegistry mActivityResultRegistry = new ActivityResultRegistry() {

        @Override
        public <I, O> void onLaunch(
                final int requestCode,
                @NonNull ActivityResultContract<I, O> contract,
                I input,
                @Nullable ActivityOptionsCompat options) {
            ComponentActivity activity = ComponentActivity.this;

            // Immediate result path
            final ActivityResultContract.SynchronousResult<O> synchronousResult =
                    contract.getSynchronousResult(activity, input);
            // 1. 如果有同步结果，发到主线程执行。
            if (synchronousResult != null) {
                new Handler(Looper.getMainLooper()).post(new Runnable() {
                    @Override
                    public void run() {
                        dispatchResult(requestCode, synchronousResult.getValue());
                    }
                });
                return;
            }

            // 2. 从 ActivityResultContract 的 createIntent 方法获取 目标Intent。
            // Start activity path
            Intent intent = contract.createIntent(activity, input);
            ...
            // 3. 处理权限请求。
            if (ACTION_REQUEST_PERMISSIONS.equals(intent.getAction())) {
            ...
                ActivityCompat.requestPermissions(activity, permissions, requestCode);
            } else if (ACTION_INTENT_SENDER_REQUEST.equals(intent.getAction())) {
            ...
            // 4. 处理 IntentSender。
                ...
                    ActivityCompat.startIntentSenderForResult(activity, request.getIntentSender(),
                            requestCode, request.getFillInIntent(), request.getFlagsMask(),
                            request.getFlagsValues(), 0, optionsBundle);
                ...
            } else {
            // 5. 其他情况调用 startActivityForResult
                // startActivityForResult path
                ActivityCompat.startActivityForResult(activity, intent, requestCode, optionsBundle);
            }
        }
    };
ActivityResultRegistry.register

ActivityResultRegistry 的 register 方法返回了一个匿名内部类 ActivityResultLauncher，ActivityResultLauncher 的 launch 方法调用了 ActivityResultRegistry 的 onLaunch。

register 方法如下：

    @NonNull
    public final <I, O> ActivityResultLauncher<I> register(
            @NonNull final String key,
            @NonNull final LifecycleOwner lifecycleOwner,
            @NonNull final ActivityResultContract<I, O> contract,
            @NonNull final ActivityResultCallback<O> callback) {

        ...
        LifecycleEventObserver observer = new LifecycleEventObserver() {
            @Override
            public void onStateChanged(
                    @NonNull LifecycleOwner lifecycleOwner,
                    @NonNull Lifecycle.Event event) {
                if (Lifecycle.Event.ON_START.equals(event)) {
                    mKeyToCallback.put(key, new CallbackAndContract<>(callback, contract));
                    if (mParsedPendingResults.containsKey(key)) {
                        ...
                        // 1. 预解析的同步的 ActivityResult
                        callback.onActivityResult(parsedPendingResult);
                    }
                    final ActivityResult pendingResult = mPendingResults.getParcelable(key);
                    if (pendingResult != null) {
                        ...
                        // 2. 先调用 contract 解析，再返回 ActivityResult
                        callback.onActivityResult(contract.parseResult(
                                pendingResult.getResultCode(),
                                pendingResult.getData()));
                    }
                } else if (Lifecycle.Event.ON_STOP.equals(event)) {
                    mKeyToCallback.remove(key);
                } else if (Lifecycle.Event.ON_DESTROY.equals(event)) {
                    unregister(key);
                }
            }
        };
        ...

        return new ActivityResultLauncher<I>() {
        
            // 3. launch 方法。
            @Override
            public void launch(I input, @Nullable ActivityOptionsCompat options) {
                mLaunchedKeys.add(key);
                // 4. 回调 ActivityResultRegistry 的 onLaunch 方法。
                // 间接调用 ComponentActivity 的 startActivityForResult。
                onLaunch(requestCode, contract, input, options);
            }

            @Override
            public void unregister() {
                ActivityResultRegistry.this.unregister(key);
            }

            @NonNull
            @Override
            public ActivityResultContract<I, ?> getContract() {
                return contract;
            }
        };
    }

总结

ActivityResult API 是 androidx.activity:activity 包引入的新 API，用来替代原有的 onActivityResult、requestCode 和 startActivityForResult。

ActivityResult 预置了一些常用的 Activity 启动类型，使用更为方便。

ActivityResultLauncher 的 launch 本质是在 ComponentActivity 的 ActivityResultRegistry 的 onLaunch 调用 startActivityForResult 启动 Activity。

Activity Result API 使用与源码分析
mm627mm的博客
03-18 1085
如果系统内置协定不满足需求，可以通过继承类来自定义协定，有两个范型参数，Input和Output。然后现实它的两个方法，方法来创建你的意图Intent方法通过resultCode和intent来解析结果并返回Output类型。类似源码。
Android Activity Result API使用
yuantian_shenhai的博客
07-21 1460
在Android开发中时常需要用到跳转新页面获取结果回传数据，一直以来使用的方法就是startActivityForResult和onActivityResult两个方法，但是startActivityForResult方法却已经被deprecation，官方推荐使用ActivityResultAPI。......
Android笔记【6】
最新发布
m0_72696598的博客
11-20 1005
通过百度网盘分享的文件：cy实验课一讲解作业三.zip链接：https://pan.baidu.com/s/1R-z3Jx6y-QWBqANWskgDmg?pwd=i3eu提取码：i3eu--来自百度网盘超级会员V1的分享。
Android 使用 ActivityResult 处理 Activity 之间的数据通信及调起拍照实例
weixin_45828419的博客
10-21 2209
在 Android 中，我们如果想在 Activity 之间双向传递数据，需要使用 startActivityForResult 启动，然后在 onActivityResult 中处理返回，另外申请权限也是类似的步骤。 但是这样的处理方式会让我们的代码变得非常复杂，并且也无法保证在 Activity 发送或接收数据时参数的类型安全。 ActivityResult 是 Jetpack 提供的一个功能，可以简化 Activity 直接的数据传递 (包括权限申请)。它通过提供类型安全的 contract (协定)
Android Results API
qq_41818873的博客
11-10 2478
开发过程中，我们经常需要从当前活动启动另一个活动获取一些数据，比如从图库选择图片，读取通讯录，拍照等，以前我们通常都是使用startActivityForResult去启动一个Activity，但是现在发现它过时了，官方推荐使用Activity Results API,下面我们看一下它的使用方式。 1、导入依赖 implementation 'androidx.activity:activity:1.2.0-beta01' implementation 'androidx.fragment:fragment
Android Activity Result API 使用
一只程序菜鸡的博客
07-20 1279
1.在app下的build.gradle引入： implementation 'androidx.activity:activity:1.2.0-beta01' implementation 'androidx.fragment:fragment:1.3.0-beta01' 2.页面普通跳转（原startActivityForResult） （1）第一个页面： class MainActivity : AppCompatActivity() { private lateinit var text
Android-Activity介绍
zengkaiqiang562的博客
12-05 332
Activity相关知识点介绍 Activity常用配置属性介绍： android:exported=“true/false” ： 指定该Activity是否允许被其他应用调用。true表示可以被其他应用调用。 android:launchMode=“singleTask” : 指定Activity的启动模式（加载模式），支持standard(默认)、singleTop、singleTask、si...
(Android) Activity介绍
科学技术是第一生产力
04-25 227
Activity概念： Activity是一个应用程序组件； 为应用程序提供一个可视化页面； 用户通过此页面与应用程序进行交互； 启动Activity： manifest.xml：主配置文件 MainActivity：主界面 Layout：布局文件 XML语言： XML是一种可扩展的、用于标记电子文件使其具有结构性的标记语言。与HTML类似，都是标准通用标记语言的子集。 ...
android获取相册图片和路径的实现方法
01-20
Log.e("TAG->onresult", "ActivityResult resultCode error"); return; } Bitmap bm = null; ContentResolver resolver = getContentResolver(); if (requestCode == IMAGE_CODE) { try { // 获取选择的...
Android中的Activity介绍
04-27
介绍Android中的Activity组件，包括下列内容 （1）组件，进程和任务 （2）Activity类 （3）生命周期和启动模式 （4）Activity启动过程
Android视频压缩并且上传
11-29
3. **处理ActivityResult**：当用户选择视频后，系统会回调`onActivityResult()`方法。在这里，你可以通过`data.getData()`获取选择的视频的Uri，并进行后续操作。 4. **视频解码**：在处理视频之前，需要将其解码...
Android开发笔记：使用Activity Result API 清爽地请求权限 和 启动Activity
Tai_Monster的博客
03-13 3724
虽然所有 API 级别的 Activity 类均提供底层 startActivityForResult() 和 onActivityResult() API，但我们强烈建议您使用 AndroidX Activity 和 Fragment 中引入的 Activity Result API。Activity Result API 提供了用于注册结果、启动结果以及在系统分派结果后对其进行处理的组件。由于该API强大的灵活性，因此我们需要学习使用该API处理权限申请，结果回调等操作。
安卓 onActivityResult 废弃，registerForActivityResult 使用详解
暗诺星刻的博客
01-11 9193
registerForActivityResult 是 Activtity 的一个方法，它可以生成一个对象，该对象的 launch 方法可以启动一次 Activtity 调用流程。该对象可以启动一个 Activtity 并与之绑定，这样，将这个启动的 Activtity 回传时，接收回传数据的代码就无需使用请求码了。可以向 launch 提供一个实参来表示本次 Activtity 调用流程的输入。这个输入可以是任意类型，也可以为 null。// 这里的 this 指向的是一个 Activity。
Android使用ActivityResultContract
Ser_Bad的博客
02-23 1686
从AndroidX的Activity 1.2.0-alpha02 和 Fragment 1.3.0-alpha02开始，startActivityForResult被标注为弃用了，因为多了一种新的办法，这里做个记录。 新建一个自己的契约类ActivityResultContract，继承自ActivityResultContract，写上自己要传入的参数和要返回的结果。 class PersonalActivityResultContract : ActivityRe
Activity Result Api使用
ucasyzj的博客
01-31 462
activity跳转Activity Result API学习
【Jetpack】ActivityResult介绍及原理分析
公众号：BennuCTech
04-12 1319
ActivityResult是Jetpack提供的一个功能，可以简化Activity直接的数据传递（包括权限申请）。它通过提供类型安全的 contract (协定) 来简化处理来自 Activity 的数据。这些协定为一些常见操作 (比如: 拍照或请求权限) 定义了预期的输入和输出类型，除此之外您还能够自定义协定来满足不同场景的需求。
android Activity简介
qq1761310972
02-06 978
文章来源：http://developer.android.com/guide/topics/fundamentals/activities.html 一个活动是一个应用程序组件，它提供了一个屏幕，用户可以使用互动，以做一些事情，如拨打电话，拍照，发送电子邮件，或查看地图，。每项活动的一个窗口，在其中绘制它的用户界面。通常的窗口填满整个屏幕，但可能比其它窗口上方的屏幕上和
Android入门第70天-调用手机摄像头拍照的最全讲解
lifetragedy的专栏
06-21 259
手机摄像头应用广泛，从拍照到识图、扫码，无所不包。然而，网上教程却少有完整实现高清拍照并后续处理的指南。本文揭示了Android系统中完整的摄像头拍照和后续处理流程，填补了这一空白领域。让我们深入了解手机摄像头背后的技术，掌握在Android系统中拍照和处理照片的全过程。让手机摄像头真正发挥其潜力，为我们带来更多的便利和创造力。
startActivityForResult 和 onActivityResult 问题
过河卒子
10-08 4287
奇怪问题 startActivityForResult() 后直接调用 onActivityResult()     开发人员都知道，可以通过使用 startActivityForResult() 和 onActivityResult() 方法来传递或接收参数。 然而在“轻听”项目中，还没等到被调用的 Activity 返回，onActivityResult() 就被执行了。 找了很久，
Android Activity Result API
zenmela2011的专栏
07-27 984
自定义Contract需要继承自ActivityResultContract，其中I是输入的类型，O是输出的类型，并实现2个方法：createIntent和parseResult，输入类型I作为createIntent方法的参数，输出类型O作为parseResult方法的返回值。使用Activity Result API完全移除了对onActivityResult()方法的重写，而是通过调用registerForActivityResult()方法注册了一个对Activity结果的监听。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值