Android6.0 動態權限(Runtime Permission)

Android6.0 動態權限

Android 6.0中將Runtime Permission分成了普通權限(Normal Permission)以及危險權限(Dangerous Permission)，普通權限在AndroidManifest.xml中註冊的時候是默認打開的，而被認爲危險的權限在註冊的時候是關閉的，需要用戶去打開或者在代碼裏動態申請。當APP的API < 23時，危險權限還是默認打開的，只有當APP的API >= 23的時候，新的Runtime Permission的套路纔會有效果。

危險權限(Dangerous Permission)

危險權限一共有以下幾種:

身體傳感器,日曆,攝像頭,通訊錄,地理位置,麥克風,電話,短信,存儲空間.

在Framework中默認打開Dangerous Permission

有些系統程序他申請了危險權限，但是很多情況下他是默認打開的，比如原生Camera的Camera,Storage等權限是默認打開的，不需要用戶去動態打開它或者在代碼裏申請打開它。那麼他是怎麼做到的？其實在framework中有一個配置文件可以默認去爲系統APP打開危險權限。
這個文件的全路徑：
/myandroid/frameworks/base/services/core/java/com/android/server/pm/DefaultPermissionGrantPolicy.java

 // Camera
  Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
  PackageParser.Package cameraPackage = getDefaultSystemHandlerActivityPackageLPr(
          cameraIntent, userId);
  if (cameraPackage != null
          && doesPackageSupportRuntimePermissions(cameraPackage)) {
      grantRuntimePermissionsLPw(cameraPackage, CAMERA_PERMISSIONS, userId);
      grantRuntimePermissionsLPw(cameraPackage, MICROPHONE_PERMISSIONS, userId);
      grantRuntimePermissionsLPw(cameraPackage, STORAGE_PERMISSIONS, userId);
  }

從上面這段代碼就可以看到Camera中默認打開了CAMERA_PERMISSIONS, MICROPHONE_PERMISSIONS, STORAGE_PERMISSIONS這三個Dangerous Permission。

//在系統APP Browser中加入默認Sotrage權限。
grantRuntimePermissionsLPw(browserPackage, STORAGE_PERMISSIONS, userId);

在APP中動態申請Dangerous Permission

這些關於權限的API都是在Activity中調用的。我這裏使用的API是23，在support包裏也有一套一樣的API。

檢查權限是否Grant

if(checkSelfPermission(Manifest.permission.RECORD_AUDIO)
               != PackageManager.PERMISSION_GRANTED){
       mNumPermissionsToRequest++;
       mShouldRequestSoundPermission = true;
   }

申請權限

if(mShouldRequestStoragePermission){
       permissionToRequest[permissionRequestIndex] =   Manifest.permission.WRITE_EXTERNAL_STORAGE;
       mIndexPermissionRequestStorage= permissionRequestIndex;
       permissionRequestIndex++;
   }
    //關鍵是這句,調用這個API之後會出現如下的對話框，這個對話框是系統UI，不需要APP來寫
   if(permissionToRequest.length > 0){
       requestPermissions(permissionToRequest, PERMISSION_REQUEST_CODE);
   }

授權(Allow)或拒絕授權(Deny)後會在Activity回調這個方法

@Override
public void onRequestPermissionsResult(int requestCode,
      String permissions[], int[] grantResults) {
       switch (requestCode) {
       case PERMISSION_REQUEST_CODE:
           if (grantResults.length > 0
                   && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
               Log.v(TAG, "Grant permission successfully");
           } else {
               Log.v(TAG, "Grant permission unsuccessfully");
           }
           break;
       default:
           break;
   }
}

爲了使用方便，我自己封裝了一個小工具，貼出代碼

import java.util.List;
import java.util.LinkedList;
import android.app.Activity;
import android.Manifest;
import android.util.Log;
import android.content.pm.PackageManager;
import android.app.AlertDialog;
import android.app.Dialog;
import android.content.DialogInterface;
import com.freescale.cactusplayer.R;

public class PermissionChecker {

    private Activity mActivity;
    private String[] mPermissions;
    private PermissionCheckCallback mCallback;
    private static final String TAG = "PermissionChecker";
    private static final int REQUST_CODE = 0;
    private boolean isDefaultDialog = false;

    public PermissionChecker setActivity(Activity activity) {
        this.mActivity = activity;
        return this;
    }

    public PermissionChecker setPermissions(String[] permissions) {
        this.mPermissions = permissions;
        return this;
    }

    public PermissionChecker setCallback(PermissionCheckCallback callback) {
        this.mCallback = callback;
        return this;
    }

    public PermissionChecker setDefaultDialog(boolean isDefaultDialog) {
        this.isDefaultDialog = isDefaultDialog;
        return this;
    }

    public boolean isPermissionGrant(String permission) {
        return mActivity.checkSelfPermission(permission) == PackageManager.PERMISSION_GRANTED;
    }

    public void checkPermission() {

        if (mPermissions == null || mActivity == null || mPermissions == null)
            return;

        List<String> permissionToRequestList = new LinkedList<String>();
        for (String permission : mPermissions) {
            if(mActivity.checkSelfPermission(permission) != PackageManager.PERMISSION_GRANTED)
                permissionToRequestList.add(permission);
        }
        String[] permissionToRequest = (String[])permissionToRequestList.toArray(new String[permissionToRequestList.size()]);
        if(permissionToRequest.length > 0){
            mActivity.requestPermissions(permissionToRequest, REQUST_CODE);
            if (mCallback != null)
                mCallback.onRequest();
        } else {
            if (mCallback != null) {
                mCallback.onGranted();
            }
        }
    }

    public interface PermissionCheckCallback {
        void onRequest();
        void onGranted();
        void onGrantSuccess();
        void onGrantFail();
    }

    public void onRequestPermissionsResult(int requestCode,
            String permissions[], int[] grantResults) {
        switch (requestCode) {
        case REQUST_CODE:
            if (grantResults.length > 0
                    && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Log.v(TAG, "Grant permission successfully");
                if (mCallback != null)
                    mCallback.onGrantSuccess();
            } else {
                if (isDefaultDialog) {
                    popupWarningDialog();
                    return;
                }
                if (mCallback != null) {
                    mCallback.onGrantFail();
                }
            }
            break;
        default:
            break;
        }
    }

    private void popupWarningDialog(){

        DialogInterface.OnClickListener dialogOnclicListener=new DialogInterface.OnClickListener(){

            @Override
            public void onClick(DialogInterface dialog, int which) {
                switch(which){
                case Dialog.BUTTON_POSITIVE:
                    if (mCallback != null) 
                        mCallback.onGranted();
                    break;
                case Dialog.BUTTON_NEGATIVE:
                    mActivity.finish();
                    break;
                default:
                    break;
                }
            }
        };

        AlertDialog.Builder builder=new AlertDialog.Builder(mActivity);
        builder.setTitle(R.string.Warning);
        builder.setMessage(R.string.PermissionNotGrant);
        builder.setPositiveButton(R.string.OK,dialogOnclicListener);
        builder.setNegativeButton(R.string.Cancel, dialogOnclicListener);
        builder.create().show();
    }   
}

使用的方法

//new一個PermissionChecker然後填入相應的權限和Callback
mPermissionChecker = new PermissionChecker();
mPermissionChecker.setActivity(this)
                       .setDefaultDialog(true)
                       .setPermissions(new String[]{Manifest.permission.WRITE_EXTERNAL_STORAGE})
                       .setCallback(new PermissionCheckCallback() {
                           @Override
                           public void onRequest() {
                           }

                           @Override
                           public void onGranted() {
                               initView();
                           }

                           @Override
                           public void onGrantSuccess() {
                               initView();
                           }

                           @Override
                           public void onGrantFail() {
                           }
                       }).checkPermission();

//回調的時候調用PermissionChecker的onRequestPermissionsResult方法
@Override
public void onRequestPermissionsResult(int requestCode,
        String permissions[], int[] grantResults) {
       mPermissionChecker.onRequestPermissionsResult(requestCode, permissions, grantResults);
}