Android 运行时权限_20220416

安卓权限分为一般权限和危险权限，危险权限除了要在manifest 中声明外，程序运行时还必须动态申请。

动态申请权限的代码基本上时固定的，先check 有没有权限，然后再申请权限，最后对申请权限的结果进行处理。

Manifest.xml

    <uses-permission android:name="android.permission.RECORD_AUDIO" />
    <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
    <uses-permission android:name="android.permission.CAMERA" />

MainActivity.java

public class MainActivity extends AppCompatActivity {
    private static final String TAG = "GetPermission";
    private static final int REQUEST_CODE = 1;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main_layout);
        List<String> deniedPermissionList = new ArrayList<>();
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            //如果权限没有申请
            Log.d(TAG, "没有相机权限，申请中。。。");
            //ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, CAMERM_CODE);
            deniedPermissionList.add(Manifest.permission.CAMERA);
        }
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.RECORD_AUDIO) != PackageManager.PERMISSION_GRANTED) {
            //如果权限没有申请
            Log.d(TAG, "没有Audio权限，申请中。。。");
            deniedPermissionList.add(Manifest.permission.RECORD_AUDIO);
        }
        if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
            //如果权限没有申请
            Log.d(TAG, "没有Local权限，申请中。。。");
            deniedPermissionList.add(Manifest.permission.ACCESS_COARSE_LOCATION);
        }

        if (!deniedPermissionList.isEmpty()) {
            ActivityCompat.requestPermissions(this, deniedPermissionList.toArray(new String[0]), REQUEST_CODE);
        }
    }

    @Override
    public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
        if (permissions.length != 0) {
            for (int i = 0; i < permissions.length; i++) {
                if (permissions[i].equals(Manifest.permission.CAMERA) && grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                    Log.d(TAG, "相机权限申请通过了");
                }
                if (permissions[i].equals(Manifest.permission.RECORD_AUDIO) && grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                    Log.d(TAG, "Audio权限申请通过了");
                }
                if (permissions[i].equals(Manifest.permission.ACCESS_COARSE_LOCATION) && grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                    Log.d(TAG, "Local权限申请通过了");
                }
            }
        }
    }
}

高级写法：PermissionsUtil

public class PermissionUtil {
    private static final int REQUEST_CODE = 1;
    private PermissionUtil() {}

    public static void request(FragmentActivity activity, Callback callback, String... checkPermissions) {
        if (checkPermissions == null) {
           return;
        }
        List<String> deniedPermissionList = new ArrayList<>();
        for (String checkPermission: checkPermissions) {
            if (ContextCompat.checkSelfPermission(activity, checkPermission) != PackageManager.PERMISSION_GRANTED) {
                deniedPermissionList.add(checkPermission);
            }
        }
        if (!deniedPermissionList.isEmpty()) {
            FragmentManager fm = activity.getSupportFragmentManager();
            PermissionFragment fragment = (PermissionFragment) fm.findFragmentByTag(PermissionFragment.TAG);
            if (fragment == null) {
                fragment = new PermissionFragment();
                fm.beginTransaction().
                        add(fragment, PermissionFragment.TAG)
                        .commitNowAllowingStateLoss();
            }
			fragment.mCallback = callback;
            fragment.requestPermissions(deniedPermissionList.toArray(new String[0]), REQUEST_CODE);
        } else if (callback != null) {
            callback.onResult(true, deniedPermissionList);
        }
    }

    public static class PermissionFragment extends Fragment {
        private static final String TAG = "PermissionFragment";
        private Callback mCallback;

        @Override
        public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
            super.onRequestPermissionsResult(requestCode, permissions, grantResults);
            int length = grantResults.length;
            List<String> deniedPermissionList = new ArrayList<>();
            for (int i = 0; i < length; i++) {
                if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                    continue;
                }
                deniedPermissionList.add(permissions[i]);
            }

            if (mCallback != null) {
                mCallback.onResult(deniedPermissionList.isEmpty(), deniedPermissionList);
            }
        }
    }

    public interface Callback {
        void onResult(boolean allGranted, List<String> deniedPermissionList);
    }
}

我自己的写法：

package com.wangpeng.permissiontest;

import android.Manifest;
import android.content.pm.PackageManager;
import android.util.Log;

import androidx.annotation.NonNull;
import androidx.core.content.ContextCompat;
import androidx.fragment.app.Fragment;
import androidx.fragment.app.FragmentActivity;
import androidx.fragment.app.FragmentManager;

import java.util.ArrayList;
import java.util.List;

public class PermissionsUtil {
    //作为Util 类，其构造方法应该私有，不允许外界去new 它
    private PermissionsUtil() {
    }

    private static final int REQUEST_CODE = 1;
    private static final String TAG = "PermissionsUtil";
    private static Permisssioncallback mPermisssioncallback;

    public static void request(FragmentActivity activity, Permisssioncallback callback, String... checkPermissions) {
        mPermisssioncallback = callback;
        List<String> deniedPermissionList = new ArrayList<>();
        for (int i = 0; i < checkPermissions.length; i++) {
            if (ContextCompat.checkSelfPermission(activity, checkPermissions[i]) != PackageManager.PERMISSION_GRANTED) {
                //如果权限没有申请
                //ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.CAMERA}, CAMERM_CODE);
                deniedPermissionList.add(checkPermissions[i]);
            }
        }
        if (!deniedPermissionList.isEmpty()) {
            FragmentManager fragmentManager = activity.getSupportFragmentManager();
            Fragment fragment = fragmentManager.findFragmentByTag(PermissionFragment.myTag);
            if (fragment == null) {
                fragment = new PermissionFragment();
                activity.getSupportFragmentManager()
                        .beginTransaction()
                        .add(fragment, PermissionFragment.myTag)
                        .commitNowAllowingStateLoss();
            }
            fragment.requestPermissions(deniedPermissionList.toArray(new String[0]), REQUEST_CODE);
        }
    }

    public static class PermissionFragment extends Fragment {
        public static final String myTag = "PermissionFragmentTag";
        private List<String> deniedPermissionList = new ArrayList<>();

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

            if (permissions.length != 0) {
                for (int i = 0; i < permissions.length; i++) {
                    if (grantResults[i] == PackageManager.PERMISSION_GRANTED) {
                        if (permissions[i].equals(Manifest.permission.WRITE_SETTINGS)) {
                            Log.d(TAG, "WRITE_SETTINGS权限申请通过了");
                        }
                        if (permissions[i].equals(Manifest.permission.RECORD_AUDIO)) {
                            Log.d(TAG, "Audio权限申请通过了");
                        }
                        if (permissions[i].equals(Manifest.permission.ACCESS_COARSE_LOCATION)) {
                            Log.d(TAG, "Local权限申请通过了");
                        }
                    } else {
                        deniedPermissionList.add(permissions[i]);
                        if (permissions[i].equals(Manifest.permission.WRITE_SETTINGS)) {
                            Log.d(TAG, "WRITE_SETTINGS权限被拒绝了");
                        }
                        if (permissions[i].equals(Manifest.permission.RECORD_AUDIO)) {
                            Log.d(TAG, "Audio权限被拒绝了");
                        }
                        if (permissions[i].equals(Manifest.permission.ACCESS_COARSE_LOCATION)) {
                            Log.d(TAG, "Local权限被拒绝了");
                        }
                    }
                }
            }
            if (deniedPermissionList.isEmpty()) {
                mPermisssioncallback.onSeccess(true, deniedPermissionList);
            } else {
                mPermisssioncallback.onSeccess(false, deniedPermissionList);
            }
        }
    }

    public interface Permisssioncallback {
        public void onSeccess(boolean allGranted, List<String> deniedPermissionList);
    }
}