android动态权限问题

普通权限(只需要在清单文件里声明即可)

ACCESS_LOCATION_EXTRA_COMMANDS 定位权限

ACCESS_NETWORK_STATE 网络状态权限

ACCESS_NOTIFICATION_POLICY 通知 APP通知显示在状态栏

ACCESS_WIFI_STATE WiFi状态权限

BLUETOOTH 使用蓝牙权限

BLUETOOTH_ADMIN 控制蓝牙开关

BROADCAST_STICKY 粘性广播

CHANGE_NETWORK_STATE 改变网络状态

CHANGE_WIFI_MULTICAST_STATE 改变WiFi多播状态，应该是控制手机热点（猜测）

CHANGE_WIFI_STATE 控制WiFi开关，改变WiFi状态

DISABLE_KEYGUARD 改变键盘为不可用

EXPAND_STATUS_BAR 扩展bar的状态

GET_PACKAGE_SIZE 获取应用安装包大小

INTERNET 网络权限

KILL_BACKGROUND_PROCESSES 杀死后台进程

MODIFY_AUDIO_SETTINGS 改变音频输出设置

NFC 支付

READ_SYNC_SETTINGS 获取手机设置信息

READ_SYNC_STATS 数据统计

RECEIVE_BOOT_COMPLETED 监听启动广播

REORDER_TASKS 创建新栈

REQUEST_INSTALL_PACKAGES 安装应用程序

SET_TIME_ZONE 允许应用程序设置系统时间区域

SET_WALLPAPER 设置壁纸

SET_WALLPAPER_HINTS 设置壁纸上的提示信息，个性化语言

TRANSMIT_IR 红外发射

USE_FINGERPRINT 指纹识别

VIBRATE 震动

WAKE_LOCK 锁屏

WRITE_SYNC_SETTINGS 改变设置

SET_ALARM 设置警告提示

INSTALL_SHORTCUT 创建快捷方式

UNINSTALL_SHORTCUT 删除快捷方式

需要运行时申请的权限

CALENDAR（日历） 
 READ_CALENDAR
 WRITE_CALENDAR
CAMERA（相机） 
 CAMERA
CONTACTS（联系人） 
 READ_CONTACTS
 WRITE_CONTACTS
 GET_ACCOUNTS
LOCATION（位置） 
 ACCESS_FINE_LOCATION
 ACCESS_COARSE_LOCATION
MICROPHONE（麦克风） 
 RECORD_AUDIO
PHONE（手机） 
 READ_PHONE_STATE
 CALL_PHONE
 READ_CALL_LOG
 WRITE_CALL_LOG
 ADD_VOICEMAIL
 USE_SIP
 PROCESS_OUTGOING_CALLS
SENSORS（传感器） 
 BODY_SENSORS
SMS（短信） 
 SEND_SMS
 RECEIVE_SMS
 READ_SMS
 RECEIVE_WAP_PUSH
 RECEIVE_MMS
STORAGE（存储卡） 
 READ_EXTERNAL_STORAGE
 WRITE_EXTERNAL_STORAGE

动态权限使用

private void requestReadSd() {
        PermissionHelper.Agency.commit(this,
                new String[]{Manifest.permission.READ_EXTERNAL_STORAGE},
                new PermissionHelper.Callback() {
                    // 申请前权限已经授权
                    @Override
                    public void onGranted(int requestCode, String[] permission) {
                        //TODO
                    }

                    // 申请前权限已经被拒绝
                    @Override
                    public void onDenied(int requestCode, String[] permission) {
                        //TODO
                    }

                    // 权限授权
                    @Override
                    public void onGrant(int requestCode, String[] permission) {
                        //TODO
                    }

                    // 权限禁止
                    @Override
                    public void onDeny(int requestCode, String[] permission) {
                        //TODO
                    }

                    // 权限拒绝
                    @Override
                    public void onRational(int requestCode, String[] permission) {
                        //TODO
                    }

                    @Override
                    public void onErrorint requestCode,(Exception e) {
                        //TODO
                    }
                }, 0, true);
}

动态权限工具类：

import android.app.Activity;
import android.content.pm.PackageManager;
import android.os.Build;
import android.os.Bundle;
import android.os.Looper;
import android.support.annotation.NonNull;
import android.support.annotation.RequiresApi;
import android.support.v4.app.ActivityCompat;
import android.support.v4.app.Fragment;

import java.util.ArrayList;
import java.util.HashMap;

/*
 *  1、对要申请权限的Manifest.xxx 先进行分类（Accepted,Denied,Rational)
 *  2、launchRequestPermission(...) 实现发送请求
 *  handlerResultPermission(...) 实现解析请求结果
 *  实际让是通过自定义一个Fragment，来发送请求，接收结果。
 *  3、在处理权限申请过程中，调用接口。
 *  onGranted(...),onDenied(...) 在解析权限状态时调用，
 *  onGrant(...),onDeny(...),onRational(...) 在接收请求结果时调用
 */
public class PermissionHelper {

    //Fragment.setArguments(...) 用
    private final static String PERMISSION_REQUEST_LIST = "PERMISSION_REQUEST_LIST";
    private final static String PERMISSION_REQUEST_RECODE = "PERMISSION_REQUEST_RECODE";

    //权限状态区别用
    private final static int PERMISSION_STATUE_GRANTED = 1;
    private final static int PERMISSION_STATUE_RATIONAL = 2;
    private final static int PERMISSION_STATUE_DENIED = 3;

    //用HaspMap来注册PermissionHelper, request(...)时注册, 申请流程结束后注销注册
    private static HashMap<Integer, PermissionHelper> sMap = new HashMap<>();

    //要求权限Activity
    private Activity mActivity;

    //已经授权的权限
    private ArrayList<String> mPermissionAccepted;
    //被拒绝的权限
    private ArrayList<String> mPermissionDenied;
    //被拒绝但没永久禁止的权限
    private ArrayList<String> mPermissionRational;

    //就是requestCode
    private int mRecognition;
    //应用刚刚安装时，ActivityCompat.shouldShowRequestPermissionRationale(...)总放回false,
    //设置true 用于第一次申请该权限
    private boolean mIsRequestDenied = false;

    private Callback mCallback;

    private PermissionHelper() {

    }

    private void request(
            @NonNull Activity activity, @NonNull String[] permissions) {
        if (!this.checkLegalRequest(permissions))
            return;
        if (register(this)) {
            this.mActivity = activity;
            mPermissionAccepted = new ArrayList<>();
            mPermissionDenied = new ArrayList<>();
            mPermissionRational = new ArrayList<>();
            startRequest(permissions);
        }
    }

    private boolean checkLegalRequest(String[] permissions) {
        if (Looper.myLooper() != Looper.getMainLooper()) {
            onError(mRecognition, new RuntimeException("request permission only can run in MainThread"));
            return false;
        }
        if (permissions.length == 0) {
            onError(mRecognition, new Exception("request permission none"));
            return false;
        }
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            onGranted(mRecognition, permissions);
            return false;
        }
        return true;
    }

    private void startRequest(String[] permissions) {
        classifyPermissions(permissions);
        if (!mPermissionDenied.isEmpty())
            onDenied(mRecognition, mPermissionAccepted.toArray(new String[0]));
        if (!mPermissionAccepted.isEmpty())
            onGranted(mRecognition, mPermissionAccepted.toArray(new String[0]));
        if (mPermissionRational.isEmpty())
            unregister(this);
        else
            launchPermissionRequest();
    }

    private void classifyPermissions(String[] permissions) {
        for (String permission : permissions) {
            switch (classifyPermission(permission)) {
                case PERMISSION_STATUE_GRANTED:
                    mPermissionAccepted.add(permission);
                    break;
                case PERMISSION_STATUE_DENIED:
                    mPermissionDenied.add(permission);
                    break;
                case PERMISSION_STATUE_RATIONAL:
                    mPermissionRational.add(permission);
                    break;
            }
        }
    }

    private int classifyPermission(String permission) {
        if (ActivityCompat.checkSelfPermission(mActivity, permission)
                == PackageManager.PERMISSION_GRANTED)
            return PERMISSION_STATUE_GRANTED;
        else if (mIsRequestDenied ||
                ActivityCompat.shouldShowRequestPermissionRationale(mActivity, permission))
            return PERMISSION_STATUE_RATIONAL;
        else
            return PERMISSION_STATUE_DENIED;
    }

    private void launchPermissionRequest() {
        Bundle arg = new Bundle();
        arg.putInt(PERMISSION_REQUEST_RECODE, mRecognition);
        arg.putStringArrayList(PERMISSION_REQUEST_LIST, mPermissionRational);
        PERMISSION_CHECK_FRAGMENT requester = new PERMISSION_CHECK_FRAGMENT();
        requester.setArguments(arg);
        mActivity.getFragmentManager().beginTransaction().add(
            requester, PERMISSION_REQUEST_RECODE + mRecognition).commit();
    }

    private void handlerPermissionResult(String[] permissions, int[] grantResults) {
        mPermissionAccepted.clear();
        mPermissionDenied.clear();
        mPermissionRational.clear();
        classifyPermissions(permissions);
        if (!mPermissionRational.isEmpty())
            onRational(mRecognition, mPermissionRational.toArray(new String[0]));
        if (!mPermissionDenied.isEmpty())
            onDeny(mRecognition, mPermissionDenied.toArray(new String[0]));
        if (!mPermissionAccepted.isEmpty())
            onGrant(mRecognition, mPermissionAccepted.toArray(new String[0]));
        unregister(this);
    }

    private void onError(Exception e) {
        if (mCallback != null)
            mCallback.onError(e);
    }

    private void onGranted(int requestCode, String[] permission) {
        if (mCallback != null)
            mCallback.onGranted(requestCode, permission);
    }

    private void onDenied(int requestCode, String[] permission) {
        if (mCallback != null)
            mCallback.onDenied(requestCode, permission);
    }

    private void onGrant(int requestCode, String[] permission) {
        if (mCallback != null)
            mCallback.onGrant(requestCode, permission);
    }

    private void onDeny(int requestCode, String[] permission) {
        if (mCallback != null)
            mCallback.onDeny(requestCode, permission);
    }

    private void onRational(int requestCode, String[] permission) {
        if (mCallback != null)
            mCallback.onRational(requestCode, permission);
    }

    private static boolean register(PermissionHelper agency) {
        synchronized (sMap) {
            if (sMap.containsKey(agency.mRecognition)) {
                agency.onError(mRecognition, new Exception("request existed"));
                return false;
            }
            sMap.put(agency.mRecognition, agency);
            return true;
        }
    }

    private static boolean unregister(PermissionHelper agency) {
        synchronized (sMap) {
            if (!sMap.containsKey(agency.mRecognition)) {
                agency.onError(mRecognition, new Exception("remove non-existent request"));
                return false;
            }
            sMap.remove(agency.mRecognition);
            return true;
        }
    }

    public interface Callback {

        void onGranted(int requestCode, String[] permission);

        void onDenied(int requestCode, String[] permission);

        void onGrant(int requestCode, String[] permission);

        void onDeny(int requestCode, String[] permission);

        void onRational(int requestCode, String[] permission);

        void onError(int requestCode, Exception e);
    }

    public static class PERMISSION_CHECK_FRAGMENT extends Fragment {
        private Integer requestCode;
        ArrayList<String> requestPermission;

        @Override
        public void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            try {
                Bundle arg = getArguments();
                requestCode = arg.getInt(PERMISSION_REQUEST_RECODE, 0);
                requestPermission = arg.getStringArrayList(PERMISSION_REQUEST_LIST);
            } catch (NullPointerException e) {
                Log.e("PERMISSION_CHECK_FRAGMENT: Receive non-operator request; " + e.getMessage());
                getActivity().getFragmentManager().beginTransaction().remove(this).commit();
                return;
            }
            requestPermissions(requestPermission.toArray(new String[0]), requestCode);
        }

        @Override
        public void onRequestPermissionsResult(
                int requestCode, String[] permissions, int[] grantResults) {
            try {
                PermissionHelper
                        .sMap
                        .get(requestCode)
                        .handlerPermissionResult(permissions, grantResults);
            } catch (NullPointerException e) {
                Log.e("PERMISSION_CHECK_FRAGMENT: Receive discarded-request; " + e.getMessage());
            }
            getActivity().getFragmentManager().beginTransaction().remove(this).commit();
        }

    }

    public static class Agency {

        private static Callback sGlobalCallback = null;

        public static Agency setCallback(Callback callback) {
            sGlobalCallback = callback;
            return this;
        }

        public static void commit(
                Activity activity, String[] permissions, Callback callback, int requestCode) {
            requestPermission(activity, permissions, callback, requestCode, false);
        }

        public static void commit(
                Activity activity, String[] permissions, Callback callback,
                int requestCode, boolean isFirstRequest) {
            PermissionHelper agency = new PermissionHelper();
            agency.mCallback = callback != null ? callback : sGlobalCallback;
            agency.mRecognition = requestCode;
            agency.mIsRequestDenied = isFirstRequest;
            agency.request(activity, permissions);
        }

    }

}