一些常用的工具类（不定期更新）

CommonUtils工具类，主要包含子布局的禁用与选择，时间与时间戳之间的互转，获取资源文件

package com.kjplusapp.utils;

import android.content.Context;
import android.content.res.Resources;
import android.graphics.drawable.Drawable;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.Spinner;
import android.widget.TextView;

import com.kjplusapp.app.BaseApplication;
import com.kjplusapp.view.ItemListViewPatient;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

import static android.content.ContentValues.TAG;

/**
 * @author xiaoyao
 * @time 2017/12/5 18:18
 * @classname CommonUtils
 * @desc 工具类
 * 1. 判断是否为手机号
 * 2. dip--> px
 * 3. px --> dip
 * 4. px --> sp
 * 5. sp --> px
 * 6. 获取Resource对象
 * 7.获取Drawable资源
 * 8.获取字符串资源
 * 9.获取color资源
 * 10.获取dimens资源
 * 11.获取字符串数组资源
 * 12.禁用子布局中的所有控件
 * 13.启用子布局中的所有控件
 * 14.字符串转时间戳
 * 15.时间戳转字符串
 */
public class CommonUtils {
    
    /***
     * 判断是否为手机号码
     *
     */
    
    public static boolean isMobileNum(String mobiles) {
        return mobiles.matches("^(13|15|18)\\d{9}$");
    }
    
    /**
     * 设置背景颜色
     */
    public static void setBgColor(View v, int bgColorValue) {
        if (v instanceof TextView) {
            ((TextView) v).setBackgroundColor(bgColorValue);
        } else if (v instanceof EditText) {
            ((EditText) v).setBackgroundColor(bgColorValue);
        } else if (v instanceof Button) {
            ((Button) v).setBackgroundColor(bgColorValue);
        } else {
            int vChildCount = ((ViewGroup) v).getChildCount();
            for (int i = 0; i < vChildCount; i++) {
                View v1 = ((ViewGroup) v).getChildAt(i);
                setBgColor(v1, bgColorValue);
            }
        }
    }
    
    /**
     * dip转化成px
     */
    public static int dip2px(Context context, float dpValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (dpValue * scale + 0.5f);
    }
    
    /**
     * px转化成dip
     */
    public static int px2dip(Context context, float pxValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (pxValue / scale + 0.5f);
    }
    
    /**
     * px转化成sp
     */
    public static int px2sp(Context context, float pxValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (pxValue / scale + 0.5f);
    }
    
    /**
     * sp转化成px
     */
    public static int sp2px(Context context, float spValue) {
        final float scale = context.getResources().getDisplayMetrics().density;
        return (int) (spValue * scale + 0.5f);
    }
    
    /**
     * 获取Resource对象
     */
    public static Resources getResources() {
        return BaseApplication.getContext().getResources();
    }
    
    /**
     * 获取Drawable资源
     */
    public static Drawable getDrawable(int resId) {
        return getResources().getDrawable(resId);
    }
    
    /**
     * 获取字符串资源
     */
    public static String getString(int resId) {
        return getResources().getString(resId);
    }
    
    /**
     * 获取color资源
     */
    public static int getColor(int resId) {
        return getResources().getColor(resId);
    }
    
    /**
     * 获取dimens资源
     */
    public static float getDimens(int resId) {
        return getResources().getDimension(resId);
    }
    
    /**
     * 获取字符串数组资源
     */
    public static String[] getStringArray(int resId) {
        return getResources().getStringArray(resId);
    }
    
    /***
     *禁用子布局中的所有控件
     *
     */
    
    public static void disableSubControls(ViewGroup disableViewGroup) {
        for (int i = 0; i < disableViewGroup.getChildCount(); i++) {
            View disableView = disableViewGroup.getChildAt(i);
            if (disableView instanceof ViewGroup) {
                if (disableView instanceof Spinner) {
                    Spinner spinner = (Spinner) disableView;
                    spinner.setClickable(false);
                    spinner.setEnabled(false);
                    Log.i(TAG, "A Spinner is unabled");
                } else if (disableView instanceof ListView) {
                    ((ListView) disableView).setClickable(false);
                    ((ListView) disableView).setEnabled(false);
                    Log.i(TAG, "A ListView is unabled");
                } else if (disableView instanceof ItemListViewPatient) {
                    ((ItemListViewPatient) disableView).setClickable(false);
                    ((ItemListViewPatient) disableView).setEnabled(false);
                } else {
                    disableSubControls((ViewGroup) disableView);
                }
            } else if (disableView instanceof EditText) {
                ((EditText) disableView).setEnabled(false);
                ((EditText) disableView).setClickable(false);
                Log.i(TAG, "A EditText is unabled");
            } else if (disableView instanceof Button) {
                ((Button) disableView).setEnabled(false);
                Log.i(TAG, "A Button is unabled");
            } else if (disableView instanceof TextView) {
                ((TextView) disableView).setEnabled(false);
                ((TextView) disableView).setClickable(false);
                Log.i(TAG, "A TextView is unabled");
            }
        }
    }
    
    /***
     *启用子布局中的所有控件
     *
     */
    public static void enableSubControls(ViewGroup enableViewGroups) {
        for (int i = 0; i < enableViewGroups.getChildCount(); i++) {
            View enableView = enableViewGroups.getChildAt(i);
            if (enableView instanceof ViewGroup) {
                if (enableView instanceof Spinner) {
                    Spinner spinner = (Spinner) enableView;
                    spinner.setClickable(true);
                    spinner.setEnabled(true);
                    //Log.i(TAG, "A Spinner is abled");
                } else if (enableView instanceof ListView) {
                    ((ListView) enableView).setClickable(true);
                    ((ListView) enableView).setEnabled(true);
                    //Log.i(TAG, "A ListView is abled");
                } else if (enableView instanceof ItemListViewPatient) {
                    ((ItemListViewPatient) enableView).setClickable(true);
                    ((ItemListViewPatient) enableView).setEnabled(true);
                } else {
                    enableSubControls((ViewGroup) enableView);
                }
            } else if (enableView instanceof EditText) {
                ((EditText) enableView).setEnabled(true);
                ((EditText) enableView).setClickable(true);
                //Log.i(TAG, "A EditText is abled");
            } else if (enableView instanceof Button) {
                ((Button) enableView).setEnabled(true);
                //Log.i(TAG, "A Button is abled");
            } else if (enableView instanceof TextView) {
                ((TextView) enableView).setEnabled(true);
                ((TextView) enableView).setClickable(true);
                // Log.i(TAG, "A TextView is abled");
            }
        }
    }
    
    //字符串转时间戳
    public static String getTime(String timeString){
        String timeStamp = null;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm");
        Date d;
        try{
            d = sdf.parse(timeString);
            long l = d.getTime();
            timeStamp = String.valueOf(l);
        } catch(ParseException e){
            e.printStackTrace();
        }
        return timeStamp;
    }
    
    //时间戳转字符串
    public static String getStrTime(String timeStamp){
        String timeString = null;
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy年MM月dd日 hh:mm");
        long  l = Long.valueOf(timeStamp);
        timeString = sdf.format(new Date(l));//单位秒
        return timeString;
    }
}

FileUtils 获取文件的路径，检测SD是否可用

import android.content.ContentUris;
import android.content.Context;
import android.database.Cursor;
import android.net.Uri;
import android.os.Build;
import android.os.Environment;
import android.provider.DocumentsContract;
import android.provider.MediaStore;

import java.io.File;

/**
 * @author xiaoyao
 * @time 2017/12/5 18:22
 * @classname FilePathUtil
 * @desc 获取文件路径工具类
 * 1.检测当前设备SD是否可用
 * 2.获得SD卡根目录路径
 * 3.获得存储 录音文件的文件夹
 * 4.获得存储 下载而来的录音文件的文件夹
 * 5.获取此Uri的数据列的值
 * 6.Uri authority is ExternalStorageProvider外部存储提供商
 * 7.Uri authority is DownloadsProvider下载提供者
 * 8.Uri authority is MediaProvider媒体存储
 */
public class FilePathUtil {
    
    
    // 存放录音文件夹的名称
    static String AUDIO_RECORD = "/AudioRecord";
    // 存放下载而来的录音文件夹名称
    static String DOWNLOAD_AUDIO_RECORD = "/AudioRecord/downLoad";
    
    /**
     * 检测当前设备SD是否可用
     *
     * @return 返回"true"表示可用，否则不可用
     */
    public static boolean haveSdCard() {
        return Environment.getExternalStorageState().equals(Environment.MEDIA_MOUNTED);
    }
    
    /**
     * 获得SD卡根目录路径
     *
     * @return String类型  SD卡根目录路径
     */
    public static String getSdCardAbsolutePath() {
        return Environment.getExternalStorageDirectory().getAbsolutePath();
    }
    
    /**
     * 获得存储 录音文件的文件夹
     *
     * @return File类型
     * 存储 录音文件的文件夹 .AUDIO_RECORD是一个文件夹
     */
    public static File getAudioRecordDir() {
        //把String再转换为一个file对象
        File audioRecordFile = new File(FilePathUtil.getSdCardAbsolutePath() + AUDIO_RECORD);
        if (!audioRecordFile.exists()) {
            // 此处可能会创建失败，暂不考虑
            audioRecordFile.mkdir();
        }
        return audioRecordFile;
    }
    
    /**
     * 获得存储 下载而来的录音文件的文件夹
     *
     * @return File类型
     * 存储 下载而来的 录音文件的文件夹
     */
    public static File getDownAudioRecordDir() {
        File audioRecordFile = new File(FilePathUtil.getSdCardAbsolutePath() + DOWNLOAD_AUDIO_RECORD);
        if (!audioRecordFile.exists()) {
            // 此处可能会创建失败，暂不考虑
            audioRecordFile.mkdir();
        }
        return audioRecordFile;
    }
    
    
    /**
     * Get the value of the data column for this Uri. This is useful for
     * MediaStore Uris, and other file-based ContentProviders.
     *
     * @param context      The context.
     * @param uri          The Uri to query.
     * @param //URI的URI查询。
     * @return The value of the _data column, which is typically a file path.
     * *获取此Uri的数据列的值。这是有用的
     * mediastore URI，和基于内容提供商的其他文件。
     * @param上下文语境。
     * @返回的_data列的值，这是一个典型的文件路径。
     */
    public static String getFilePathFromUri(final Context context, final Uri uri) {
        // DocumentProvider
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT && DocumentsContract.isDocumentUri(context, uri)) {
            // ExternalStorageProvider
            if (isExternalStorageDocument(uri)) {
                final String docId = DocumentsContract.getDocumentId(uri);
                final String[] split = docId.split(":");
                final String type = split[0];
                
                if ("primary".equalsIgnoreCase(type)) {
                    return Environment.getExternalStorageDirectory() + "/" + split[1];
                }
            }
            // DownloadsProvider
            else if (isDownloadsDocument(uri)) {
                
                final String id = DocumentsContract.getDocumentId(uri);
                final Uri contentUri = ContentUris.withAppendedId(
                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
                
                return getDataColumn(context, contentUri, null, null);
            }
            // MediaProvider
            else if (isMediaDocument(uri)) {
                final String docId = DocumentsContract.getDocumentId(uri);
                final String[] split = docId.split(":");
                final String type = split[0];
                
                Uri contentUri = null;
                if ("image".equals(type)) {
                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
                } else if ("video".equals(type)) {
                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
                } else if ("audio".equals(type)) {
                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
                }
                final String selection = "_id=?";
                final String[] selectionArgs = new String[]{
                        split[1]
                };
                return getDataColumn(context, contentUri, selection, selectionArgs);
            }
        }
        // MediaStore (and general)
        else if ("content".equalsIgnoreCase(uri.getScheme())) {
            return getDataColumn(context, uri, null, null);
        }
        // File
        else if ("file".equalsIgnoreCase(uri.getScheme())) {
            return uri.getPath();
        }
        return null;
    }
    
    /**
     * Get the value of the data column for this Uri. This is useful for
     * MediaStore Uris, and other file-based ContentProviders.
     *
     * @param context       The context.
     * @param uri           The Uri to query.
     * @param selection     (Optional) Filter used in the query.
     * @param selectionArgs (Optional) Selection arguments used in the query.
     * @param //URI的URI查询。
     * @return The value of the _data column, which is typically a file path.3
     * *获取此Uri的数据列的值。这是有用的
     * * mediastore URI，和基于内容提供商的其他文件。
     * @param上下文语境。
     * @param选择（可选）查询中使用的过滤器。
     * @param在selection中（可选）选择参数查询中使用。
     * @返回的_data列的值，这是一个典型的文件路径。
     */
    public static String getDataColumn(Context context, Uri uri, String selection,
                                       String[] selectionArgs) {
        Cursor cursor = null;
        final String column = "_data";
        final String[] projection = {
                column
        };
        try {
            cursor = context.getContentResolver().query(uri, projection, selection, selectionArgs,
                    null);
            if (cursor != null && cursor.moveToFirst()) {
                final int column_index = cursor.getColumnIndexOrThrow(column);
                return cursor.getString(column_index);
            }
        } finally {
            if (cursor != null)
                cursor.close();
        }
        return null;
    }
    
    
    /**
     * @param uri The Uri to check.
     * @return Whether the Uri authority is ExternalStorageProvider.
     */
    public static boolean isExternalStorageDocument(Uri uri) {
        return "com.android.externalstorage.documents".equals(uri.getAuthority());
    }
    
    /**
     * @param uri The Uri to check.
     * @return Whether the Uri authority is DownloadsProvider.
     */
    public static boolean isDownloadsDocument(Uri uri) {
        return "com.android.providers.downloads.documents".equals(uri.getAuthority());
    }
    
    /**
     * @param uri The Uri to check.
     * @return Whether the Uri authority is MediaProvider.
     */
    public static boolean isMediaDocument(Uri uri) {
        return "com.android.providers.media.documents".equals(uri.getAuthority());
    }
    
    
}

打印LogUtils

package com.kjplusapp.utils;

import android.util.Log;

/**
 * @author xiaoyao
 * @time 2017/12/5 18:31
 * @classname LogUtil
 * @desc 文件的log工具类
 * 1.是否开启debug模式
 * 2.错误   e
 * 3.信息   i
 * 4.警告   w
 * 5.测试   d
 */
public class LogUtil {
    
    /**
     * 是否开启debug模式
     */
    public static boolean isDebug = true;
    
    public LogUtil() {
    }
    
    /**
     * 错误
     */
    public static void e(Class<?> clazz, String msg) {
        if (isDebug) {
            Log.e(clazz.getSimpleName(), msg);
        }
    }
    
    public static void e(String clazzName, String msg) {
        if (isDebug) {
            Log.e(clazzName, msg);
        }
    }
    
    /**
     * 信息
     */
    public static void i(Class<?> clazz, String msg) {
        if (isDebug) {
            Log.i(clazz.getSimpleName(), msg);
        }
    }
    
    public static void i(String clazzName, String msg) {
        if (isDebug) {
            Log.i(clazzName, msg);
        }
    }
    
    /**
     * 警告
     */
    public static void w(Class<?> clazz, String msg) {
        if (isDebug) {
            Log.w(clazz.getSimpleName(), msg);
        }
    }
    
    public static void w(String clazzName, String msg) {
        if (isDebug) {
            Log.w(clazzName, msg);
        }
    }
    
    /**
     * 测试
     */
    public static void d(Class<?> clazz, String msg) {
        if (isDebug) {
            Log.d(clazz.getSimpleName(), msg);
        }
    }
    
    public static void d(String clazzName, String msg) {
        if (isDebug) {
            Log.d(clazzName, msg);
        }
    }
}

NetWorkUil 网络状态工具  1、是否为WIFI  2、网络是否可用 3、网络是否为2G

package com.kjplusapp.utils;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.telephony.TelephonyManager;

/**
 * @author xiaoyao
 * @time 2017/12/5 18:33
 * @classname NetWorkUtil
 * @desc 网络状态工具类
 * 1.是否为wifi
 * 2.网络是否可用
 * 3.网络是否为2G
 */
public class NetWorkUtil {
    
    public static boolean isWifi(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        final NetworkInfo ni = cm.getActiveNetworkInfo();
        if (ni != null && ni.getType() == ConnectivityManager.TYPE_WIFI) {
            return true;
        }
        return false;
    }
    
    public static boolean isNetworkAvailable(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        final NetworkInfo ni = cm.getActiveNetworkInfo();
        if (ni != null && ni.getState() == NetworkInfo.State.CONNECTED) {
            return true;
        }
        return false;
    }
    
    public static boolean isNetwork2G(Context context) {
        ConnectivityManager cm = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        final NetworkInfo ni = cm.getActiveNetworkInfo();
        if (ni != null && ni.getType() == ConnectivityManager.TYPE_MOBILE) {// 手否是手机网络
            //移动联通电信2g
            if (ni.getSubtype() == TelephonyManager.NETWORK_TYPE_GPRS
                    || ni.getSubtype() == TelephonyManager.NETWORK_TYPE_EDGE
                    || ni.getSubtype() == TelephonyManager.NETWORK_TYPE_CDMA) {
                return true;
            } else {
                return false;
            }
        }
        return false;
    }
    
    
}

android 6.0 的动态权限管理类

public class PermissionUtils {
    
    private static final String TAG = PermissionUtils.class.getSimpleName();
    public static final int CODE_RECORD_AUDIO = 0;
    public static final int CODE_READ_PHONE_STATE = 1;
    public static final int CODE_ACCESS_FINE_LOCATION = 2;
    public static final int CODE_ACCESS_COARSE_LOCATION = 3;
    public static final int CODE_WRITE_EXTERNAL_STORAGE = 4;
    public static final int CODE_MULTI_PERMISSION = 100;
    
    public static final String PERMISSION_RECORD_AUDIO = Manifest.permission.RECORD_AUDIO;
    public static final String PERMISSION_READ_PHONE_STATE = Manifest.permission.READ_PHONE_STATE;
    public static final String PERMISSION_ACCESS_FINE_LOCATION = Manifest.permission.ACCESS_FINE_LOCATION;
    public static final String PERMISSION_ACCESS_COARSE_LOCATION = Manifest.permission.ACCESS_COARSE_LOCATION;
    public static final String PERMISSION_WRITE_EXTERNAL_STORAGE = Manifest.permission.WRITE_EXTERNAL_STORAGE;
    
    private static final String[] requestPermissions = {
            PERMISSION_RECORD_AUDIO,
            PERMISSION_READ_PHONE_STATE,
            PERMISSION_ACCESS_FINE_LOCATION,
            PERMISSION_ACCESS_COARSE_LOCATION,
            PERMISSION_WRITE_EXTERNAL_STORAGE
    };
    
    public interface PermissionGrant {
        void onPermissionGranted(int requestCode);
    }
    
    /**
     * Requests permission.
     *
     * @param context
     * @param requestCode request code, e.g. if you need request CAMERA permission,parameters is PermissionUtils.CODE_CAMERA
     */
    public static void requestPermission(final Context context, final int requestCode, PermissionGrant permissionGrant) {
        if (context == null) {
            return;
        }
        
        Log.i(TAG, "requestPermission requestCode:" + requestCode);
        if (requestCode < 0 || requestCode >= requestPermissions.length) {
            Log.w(TAG, "requestPermission illegal requestCode:" + requestCode);
            return;
        }
        
        final String requestPermission = requestPermissions[requestCode];
        
        //如果是6.0以下的手机，ActivityCompat.checkSelfPermission()会始终等于PERMISSION_GRANTED，
        // 但是，如果用户关闭了你申请的权限，ActivityCompat.checkSelfPermission(),会导致程序崩溃(java.lang.RuntimeException: Unknown exception code: 1 msg null)，
        // 你可以使用try{}catch(){},处理异常，也可以判断系统版本，低于23就不申请权限，直接做你想做的。permissionGrant.onPermissionGranted(requestCode);
//        if (Build.VERSION.SDK_INT < 23) {
//            permissionGrant.onPermissionGranted(requestCode);
//            return;
//        }
        
        int checkSelfPermission;
        try {
            checkSelfPermission = ActivityCompat.checkSelfPermission(context, requestPermission);
        } catch (RuntimeException e) {
            Toast.makeText(context, "请打开这些权限", Toast.LENGTH_SHORT)
                    .show();
            Log.e(TAG, "RuntimeException:" + e.getMessage());
            return;
        }
        
        if (checkSelfPermission != PackageManager.PERMISSION_GRANTED) {
            Log.i(TAG, "ActivityCompat.checkSelfPermission != PackageManager.PERMISSION_GRANTED");
            BaseActivity activity = (BaseActivity) context;
            
            if (ActivityCompat.shouldShowRequestPermissionRationale(activity, requestPermission)) {
                Log.i(TAG, "requestPermission shouldShowRequestPermissionRationale");
                shouldShowRationale(activity, requestCode, requestPermission);
                
            } else {
                Log.d(TAG, "requestCameraPermission else");
                ActivityCompat.requestPermissions(activity, new String[]{requestPermission}, requestCode);
            }
            
        } else {
            Log.d(TAG, "ActivityCompat.checkSelfPermission ==== PackageManager.PERMISSION_GRANTED");
            permissionGrant.onPermissionGranted(requestCode);
        }
    }
    
    private static void requestMultiResult(Context context, String[] permissions, int[] grantResults, PermissionGrant permissionGrant) {
        
        if (context == null) {
            return;
        }
        
        Map<String, Integer> perms = new HashMap<>();
        
        ArrayList<String> notGranted = new ArrayList<>();
        for (int i = 0; i < permissions.length; i++) {
            perms.put(permissions[i], grantResults[i]);
            if (grantResults[i] != PackageManager.PERMISSION_GRANTED) {
                notGranted.add(permissions[i]);
            }
        }
        
        if (notGranted.size() == 0) {
            //所有权限都已获取
            //Toast.makeText(activity, "all permission success" + notGranted, Toast.LENGTH_SHORT).show();
            permissionGrant.onPermissionGranted(CODE_MULTI_PERMISSION);
        } else {
            openSettingActivity(context, "需要给予这些权限！");
        }
        
    }
    
    
    /**
     * 一次申请多个权限
     */
    public static void requestMultiPermissions(final Context context, PermissionGrant grant) {
        
        final List<String> permissionsList = getNoGrantedPermission(context, false);
        final List<String> shouldRationalePermissionsList = getNoGrantedPermission(context, true);
        
        //TODO checkSelfPermission
        if (permissionsList == null || shouldRationalePermissionsList == null) {
            return;
        }
        BaseActivity activity = (BaseActivity) context;
        if (permissionsList.size() > 0) {
            ActivityCompat.requestPermissions(activity, permissionsList.toArray(new String[permissionsList.size()]),
                    CODE_MULTI_PERMISSION);
            
        } else if (shouldRationalePermissionsList.size() > 0) {
            showMessageOKCancel(context, "请打开权限,点击确认选择权限",
                    new DialogInterface.OnClickListener() {
                        @Override
                        public void onClick(DialogInterface dialog, int which) {
                            BaseActivity activity = (BaseActivity) context;
                            ActivityCompat.requestPermissions(activity, shouldRationalePermissionsList.toArray(new String[shouldRationalePermissionsList.size()]),
                                    CODE_MULTI_PERMISSION);
                        }
                    });
        } else {
            grant.onPermissionGranted(CODE_MULTI_PERMISSION);
        }
        
    }
    
    
    private static void shouldShowRationale(final Activity context, final int requestCode, final String requestPermission) {
        //TODO
        BaseActivity activity = (BaseActivity) context;
        String[] permissionsHint = activity.getResources().getStringArray(R.array.permissions);
        showMessageOKCancel(activity, "Rationale: " + permissionsHint[requestCode], new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                BaseActivity activity = (BaseActivity) context;
                ActivityCompat.requestPermissions(activity,
                        new String[]{requestPermission},
                        requestCode);
            }
        });
    }
    
    private static void showMessageOKCancel(final Context context, String message, DialogInterface.OnClickListener okListener) {
        new AlertDialog.Builder(context)
                .setMessage(message)
                .setPositiveButton("OK", okListener)
                .setNegativeButton("Cancel", null)
                .create()
                .show();
        
    }
    
    /**
     * @param context
     * @param requestCode  Need consistent with requestPermission
     * @param permissions
     * @param grantResults
     */
    public static void requestPermissionsResult(final Context context, final int requestCode, String[] permissions,
                                                int[] grantResults, PermissionGrant permissionGrant) {
        
        if (context == null) {
            return;
        }
        Log.d(TAG, "requestPermissionsResult requestCode:" + requestCode);
        
        if (requestCode == CODE_MULTI_PERMISSION) {
            requestMultiResult(context, permissions, grantResults, permissionGrant);
            return;
        }
        
        if (requestCode < 0 || requestCode >= requestPermissions.length) {
//            Toast.makeText(context, "illegal requestCode:" + requestCode, Toast.LENGTH_SHORT).show();
            return;
        }
        
        
        if (grantResults.length == 1 && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
            //TODO success, do something, can use callback
            permissionGrant.onPermissionGranted(requestCode);
            
        } else {
            //TODO hint user this permission function
            Log.i(TAG, "onRequestPermissionsResult PERMISSION NOT GRANTED");
            //TODO
            String[] permissionsHint = context.getResources().getStringArray(R.array.permissions);
            openSettingActivity(context, "Result" + permissionsHint[requestCode]);
        }
        
    }
    
    private static void openSettingActivity(final Context context, String message) {
        
        showMessageOKCancel(context, message, new DialogInterface.OnClickListener() {
            @Override
            public void onClick(DialogInterface dialog, int which) {
                Intent intent = new Intent();
                intent.setAction(Settings.ACTION_APPLICATION_DETAILS_SETTINGS);
                Log.d(TAG, "getPackageName(): " + context.getPackageName());
                Uri uri = Uri.fromParts("package", context.getPackageName(), null);
                intent.setData(uri);
                context.startActivity(intent);
            }
        });
    }
    
    
    /**
     * @param context
     * @param isShouldRationale true: return no granted and shouldShowRequestPermissionRationale permissions, false:return no granted and !shouldShowRequestPermissionRationale
     * @return
     */
    public static ArrayList<String> getNoGrantedPermission(Context context, boolean isShouldRationale) {
        
        ArrayList<String> permissions = new ArrayList<>();
        
        for (int i = 0; i < requestPermissions.length; i++) {
            String requestPermission = requestPermissions[i];
            
            
            //TODO checkSelfPermission
            int checkSelfPermission = -1;
            try {
                checkSelfPermission = ActivityCompat.checkSelfPermission(context, requestPermission);
            } catch (RuntimeException e) {
                Toast.makeText(context, "请打开权限，点击确认选择权限", Toast.LENGTH_SHORT)
                        .show();
                Log.e(TAG, "RuntimeException:" + e.getMessage());
                return null;
            }
            
            if (checkSelfPermission != PackageManager.PERMISSION_GRANTED) {
                Log.i(TAG, "getNoGrantedPermission ActivityCompat.checkSelfPermission != PackageManager.PERMISSION_GRANTED:" + requestPermission);
                BaseActivity activity = (BaseActivity) context;
                if (ActivityCompat.shouldShowRequestPermissionRationale(activity, requestPermission)) {
                    Log.d(TAG, "shouldShowRequestPermissionRationale if");
                    if (isShouldRationale) {
                        permissions.add(requestPermission);
                    }
                    
                } else {
                    
                    if (!isShouldRationale) {
                        permissions.add(requestPermission);
                    }
                    Log.d(TAG, "shouldShowRequestPermissionRationale else");
                }
                
            }
        }
        
        return permissions;
    }