Android Fragment 的妙用 - 优雅地申请权限和处理 onActivityResult

2019年5月8日 206次阅读 来源: Android高级架构探索

前言

Fragment，简称碎片，可以简单地认为它就是一个“控件”，更加具体一点就是“View控制器”。它自身有生命周期。在开发中，我们经常用到，再熟悉不过了。然而，Fragment 的一些巧妙引用，不知道你是否了解过？

  • 使用 Fragment 封装权限申请
  • 使用 Fragment 优雅处理 onActivityResult
  • Activity reCreate 的时候用来存储数据

这篇文章主要讲解以下内容

  • 使用 Fragment 封装权限申请
  • 使用 Fragment 优雅处理 onActivityResult

当然，这些封装，网上都有相应的开源库了， RxPermission, EasyPermision， RxActivityReslut 等，这里讲解如何封装，主要是让大家了解背后的原理，加深理解。想要成为一名优秀的工程师（程序猿），光停留在表面是远远不够的，我们要多读源码，理解背后的原理。哈哈，废话不多说，开始进入正文。

Fragment 封装权限申请

Android 6.0 动态权限机制，大家再熟悉不过了，如果我们没有对其进行封装，那我们每一次在申请权限的时候，大概需要以下几步：

这里我们已拨打电话为例子进行讲解

  • 检查是否拥有电话权限，没有的话进行申请
if (ContextCompat.checkSelfPermission(this, Manifest.permission.CALL_PHONE) 
        != PackageManager.PERMISSION_GRANTED) {
    ActivityCompat.requestPermissions(this,
            new String[]{Manifest.permission.CALL_PHONE},
            10);
} else{
    callPhone();
}
  • 在 onRequestPermissionsResult 方法里面进行处理，然后进行相应的操作。
@Override
public void onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {

    if (requestCode == 10) {
        if (grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            callPhone();
        } else {
            // Permission Denied
            Toast.makeText(TestResultActivity.this, "Permission Denied", Toast.LENGTH_SHORT).show();
        }
        return;
    }
}

看到这样的代码你会不会很烦，每次涉及权限操作的时候，都要写这样一堆这样重复的代码，枯燥，且很多代码逻辑会耦合在 Activity 中，不方便维护。那有没有办法，将这些繁琐的步骤封装起来呢，答案是有的。

现在网上的做法一般有以下几种

  • 使用透明的 Activity 进行申请
  • 使用 Fragment 进行申请
  • 反射
  • AOSP

这里我们使用 Fragment 进行封装。

我们知道， Fragment 一般依赖于 Activity 存活，并且生命周期跟 Activity 差不多，因此，我们进行权限申请的时候，可以利用透明的 Fragment 进行申请，在里面处理完之后，再进行相应的回调。

  • 当我们申请权限申请的时候，先查找我们当前 Activity 是否存在代理 fragment,不存在，进行添加，并使用代理 Fragment 进行申请权限
  • 第二步：在代理 Fragment 的 onRequestPermissionsResult 方法进行相应的处理，判断是否授权成功
  • 第三步：进行相应的回调

首先，我们先来看一下代理 Fragment EachPermissionFragment 是怎么封装的？

public class EachPermissionFragment extends Fragment {

    private SparseArray<IPermissionListenerWrap.IPermissionListener> mCallbacks = new SparseArray<>();
    private SparseArray<IPermissionListenerWrap.IEachPermissionListener> mEachCallbacks = new SparseArray<>();
    private Random mCodeGenerator = new Random();
    private FragmentActivity mActivity;

    public EachPermissionFragment() {
        // Required empty public constructor
    }

    public static EachPermissionFragment newInstance() {
        return new EachPermissionFragment();
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        // 设置为 true，表示 configuration change 的时候，fragment 实例不会背重新创建
        setRetainInstance(true);
        mActivity = getActivity();

    }

    public void requestPermissions(@NonNull String[] permissions, IPermissionListenerWrap.IPermissionListener callback) {
        int requestCode = makeRequestCode();
        mCallbacks.put(requestCode, callback);
        requestPermissions(permissions, requestCode);
    }

    public void requestEachPermissions(@NonNull String[] permissions, IPermissionListenerWrap.IEachPermissionListener callback) {
        int requestCode = makeRequestCode();
        mEachCallbacks.put(requestCode, callback);
        requestPermissions(permissions, requestCode);
    }


    /**
     * 随机生成唯一的requestCode，最多尝试10次
     *
     * @return
     */
    private int makeRequestCode() {
        int requestCode;
        int tryCount = 0;
        do {
            requestCode = mCodeGenerator.nextInt(0x0000FFFF);
            tryCount++;
        } while (mCallbacks.indexOfKey(requestCode) >= 0 && tryCount < 10);
        return requestCode;
    }


    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        handlePermissionCallBack(requestCode, grantResults);
        handleEachPermissionCallBack(requestCode, permissions, grantResults);
    }

    private void handlePermissionCallBack(int requestCode, @NonNull int[] grantResults) {
        IPermissionListenerWrap.IPermissionListener callback = mCallbacks.get(requestCode);
        mCallbacks.remove(requestCode);

        if (callback == null) {
            return;
        }

        boolean allGranted = false;
        int length = grantResults.length;
        for (int i = 0; i < length; i++) {
            int grantResult = grantResults[i];
            if (grantResult != PackageManager.PERMISSION_GRANTED) {
                allGranted = false;
                break;
            }
            allGranted = true;
        }
        if (allGranted) {
            callback.onAccepted(true);
        } else {
            callback.onAccepted(false);
        }
    }

    private void handleEachPermissionCallBack(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        IPermissionListenerWrap.IEachPermissionListener eachCallback = mEachCallbacks.get(requestCode);

        if (eachCallback == null) {
            return;
        }

        mEachCallbacks.remove(requestCode);
        int length = grantResults.length;
        for (int i = 0; i < length; i++) {
            int grantResult = grantResults[i];
            Permission permission;
            String name = permissions[i];
            if (grantResult == PackageManager.PERMISSION_GRANTED) {
                permission = new Permission(name, true);
                eachCallback.onAccepted(permission);
            } else {
                if (ActivityCompat.shouldShowRequestPermissionRationale(mActivity, name)) {
                    permission = new Permission(name, false, true);
                } else {
                    permission = new Permission(name, false, false);
                }
                eachCallback.onAccepted(permission);
            }

        }

    }
    
}

我们先来看一下它的 onCreate 方法，在 onCreate 方法里面，我们调用了 setRetainInstance 方法。

setRetainInstance(boolean retain)

Control whether a fragment instance is retained across Activity re-creation (such as from a configuration change)

表示当 Activity 重新创建的时候， fragment 实例是否会被重新创建（比如横竖屏切换），设置为 true，表示 configuration change 的时候，fragment 实例不会背重新创建，这样，有一个好处，即
configuration 变化的时候，我们不需要再做额外的处理。因此， fragment 该方法也常常被用来处理 Activity re-creation 时候数据的保存，是不是又 get 到了什么？

接着我们来看 requestEachPermissions 方法

  • 在申请权限的时候，即 requestEachPermissions 方法中，我们先生成一个随机的 requestCode，并确保不会重复
  • 第二步：将我们的 callBack 及 requestCode 缓存起来，通过 key 可以查找相应的 requestCode。
  • 第三步：调用 Fragment 的 requestPermissions 方法进行权限申请

然后看 onRequestPermissionsResult 方法

这里我们主要关注 handleEachPermissionCallBack(requestCode, permissions, grantResults); 方法， handlePermissionCallBack 方法思路也是类似的

  • 我们先从我们的 mEachCallbacks 方法中查找，是否有相应的缓存（即根据 requestCode 查找是否有相应的权限申请，有的话进行处理，没有的话，忽略。）
  • 处理完毕之后，我们将权限的信息封装在 Permission 中，并进行相应的回调
public class Permission {
    public final String name;
    public final boolean granted;
    /**
     * false 选择了 Don’t ask again
     */
    public final boolean shouldShowRequestPermissionRationale;
    
}

Permission 含有三个字段，name 表示权限的名字，granted 表示是否授权，shouldShowRequestPermissionRationale 表示是否勾选了 Don’t ask again（即不再询问），通常我们的做法是若勾选了不再询问，我们需要引导用户，跳转到相应的 Setting 页面。

大致代码如下

/**
 * 打开设置页面打开权限
 *
 * @param context
 */
public static void startSettingActivity(@NonNull Activity context) {

    try {
        Intent intent =
                new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse("package:" +
                        context.getPackageName()));
        intent.addCategory(Intent.CATEGORY_DEFAULT);
        context.startActivityForResult(intent, 10); //这里的requestCode和onActivityResult中requestCode要一致
    } catch (Exception e) {
        e.printStackTrace();
    }
}

封装完成之后，我们只需要调用以下方法即可，简单，方便，快捷。

private void requestPermission(final String[] permissions) {
    PermissionsHelper.init(MainActivity.this).requestEachPermissions(permissions, new
 IPermissionListenerWrap.IEachPermissionListener() {
        @Override
        public void onAccepted(Permission permission) {
            show(permission);
        }

        @Override
        public void onException(Throwable throwable) {

        }
    });
}

OK，我们再来梳理一下流程

《Android Fragment 的妙用 - 优雅地申请权限和处理 onActivityResult》

使用 Fragment 优雅处理 onActivityResult

我们先来看一下没封装之前 onActivityresult 的处理方式

我们先来看下正常情况下启动 Activity 和接收回调信息的方式：

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        // 启动Activity
        startActivityForResult(new Intent(this, TestActivity.class), 10);
    }

    @Override
    protected void onActivityResult(int requestCode, int resultCode, Intent data) {
        // 接收Activity回调
        if (requestCode == 10) {
            // 处理回调信息
        }
    }

这样在简单页面下，看起来没什么问题，也简单易懂。但实际上，这种方式会存在一些局限

  • onActivityResult 必须在原始 Activity 中才能接收，如果想在非 Activity 中调用startActivityForResult，那么调用和接收的地方就不在同一个地方了，代码可读性会大大降低。
  • onActivityResult 都在同一个 activity 处理，如果这种方式特别多的话，我们要写一大堆的 if else，代码可读性大大较低，也不是很优雅。

同理，我们也可以跟上面的权限封装一样，用空白的 fragment 进行代理，进行封装。封装后的代码调用如下。

Intent intent = new Intent(MainActivity.this, TestResultActivity.class);
ActivityResultHelper.init(MainActivity.this).startActivityForResult(intent, new ActivityResultHelper.Callback() {
    @Override
    public void onActivityResult(int resultCode, Intent data) {
        String result = data.getStringExtra(TestResultActivity.KEY_RESULT);
        show(" resultCode = " + resultCode + "  result = " + result);
    }
});

思路如下

  1. 当我们想发起 startActivityresult 的时候，使用代理 Fragment 进行代理，调用startActivityForResult 方法，它需要两个参数， intent, 和 requestCode， intent 代表要跳转的动作， requestCode 用来区分是那个动作。这里，为了简化，我们随机生成 requestCode ，并缓存起来，下次申请的时候，再随机申请，确保不会重复。

  2. 在 onActivityresult 里面根据 requestCode 找到相应的 callback,并进行相应的回调。

中转的 Fragment RouterFragment 核心代码如下

public class RouterFragment extends Fragment {

    private SparseArray<ActivityResultHelper.Callback> mCallbacks = new SparseArray<>();
    private Random mCodeGenerator = new Random();

    public RouterFragment() {
        // Required empty public constructor
    }

    public static RouterFragment newInstance() {
        return new RouterFragment();
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setRetainInstance(true);
    }

    public void startActivityForResult(Intent intent, ActivityResultHelper.Callback callback) {
        int requestCode = makeRequestCode();
        mCallbacks.put(requestCode, callback);
        startActivityForResult(intent, requestCode);
    }

    /**
     * 随机生成唯一的requestCode，最多尝试10次
     *
     * @return
     */
    private int makeRequestCode() {
        int requestCode;
        int tryCount = 0;
        do {
            requestCode = mCodeGenerator.nextInt(0x0000FFFF);
            tryCount++;
        } while (mCallbacks.indexOfKey(requestCode) >= 0 && tryCount < 10);
        return requestCode;
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);
        ActivityResultHelper.Callback callback = mCallbacks.get(requestCode);
        mCallbacks.remove(requestCode);
        if (callback != null) {
            callback.onActivityResult(resultCode, data);
        }
    }
}

其他的代码这里就不贴了，有兴趣的可以给我简信咨询

最后给大家分享一份非常系统和全面的Android进阶技术大纲及进阶资料，及面试题集

想学习更多Android知识，请加入Android技术开发企鹅交流 7520 16839

进群与大牛们一起讨论，还可获取Android高级架构资料、源码、笔记、视频

包括 高级UI、Gradle、RxJava、小程序、Hybrid、移动架构、React Native、性能优化等全面的Android高级实践技术讲解性能优化架构思维导图，和BATJ面试题及答案！

群里免费分享给有需要的朋友，希望能够帮助一些在这个行业发展迷茫的，或者想系统深入提升以及困于瓶颈的朋友，在网上博客论坛等地方少花些时间找资料，把有限的时间，真正花在学习上，所以我在这免费分享一些架构资料及给大家。希望在这些资料中都有你需要的内容。

《Android Fragment 的妙用 - 优雅地申请权限和处理 onActivityResult》
《Android Fragment 的妙用 - 优雅地申请权限和处理 onActivityResult》

    原文作者：Android高级架构探索
    原文地址: https://www.jianshu.com/p/4624e5d3b827
    本文转自网络文章，转载此文章仅为分享知识，如有侵权，请联系博主进行删除。
点赞