api

  1. checkPermission        :检测权限是否授予
  2. isOpenGPS            :是否打开gps
  3. isNotifyEnabled        :获取是否有通知权限
  4. isNotifyEnabled2    :获取是否有通知权限
  6. startSetting        :跳转设置（应用信息），会开启一个新的进程（点回退会回到桌面），使用startActivityForResult不可靠，跳转就会触发onActivityResult
  7. startSettingActivity:打开设置页面（应用信息），和App在同一个进程
  8. startNotifySetting    :跳转到通知设置界面

utils

  1. package com.kiwilss.lutils.utils.permission
  3. import android.annotation.SuppressLint
  4. import android.app.Activity
  5. import android.app.AppOpsManager
  6. import android.app.NotificationManager
  7. import android.content.Context
  8. import android.content.Intent
  9. import android.content.pm.ApplicationInfo
  10. import android.content.pm.PackageManager
  11. import android.location.LocationManager
  12. import android.net.Uri
  13. import android.os.Build
  14. import android.provider.Settings
  15. import androidx.core.app.NotificationManagerCompat
  16. import androidx.core.content.ContextCompat
  17. import androidx.fragment.app.Fragment
  18. import java.lang.reflect.Field
  19. import java.lang.reflect.Method
  21. /**
  22.  *@author kiwilss
  23.  * @email   kiwilss@163.com
  24.  * @time     2022/7/1
  25.  * @desc     {权限相关工具类}
  26.  */
  27. object PermissionUtils {
  29.     const val SETTING_REQUESTCODE = 6666
  30.     private const val CHECK_OP_NO_THROW = "checkOpNoThrow"
  31.     private const val OP_POST_NOTIFICATION = "OP_POST_NOTIFICATION"
  33.     /**
  34.      * 检测是否有权限
  35.      * @param context
  36.      * @param permissions
  37.      * @return
  38.      */
  39.     fun checkPermission(context: Context?, vararg permissions: String?): Boolean {
  40.         if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
  41.             return true
  42.         } else {
  43.             if (context == null || permissions.isEmpty()) return false
  44.             for (permisson in permissions) {
  45.                 permisson?.run {
  46.                     if (ContextCompat.checkSelfPermission(
  47.                             context,
  48.                             this
  49.                         ) != PackageManager.PERMISSION_GRANTED
  50.                     ) {
  51.                         return false
  52.                     }
  53.                 }
  54.             }
  55.         }
  56.         return true
  57.     }
  59.     /**
  60.      * 判断GPS是否开启，GPS或者AGPS开启一个就认为是开启的
  61.      *
  62.      * @param context
  63.      * @return true 表示开启
  64.      */
  65.     fun isOpenGPS(context: Context?): Boolean {
  66.         if (context == null) return false
  67.         val locationManager: LocationManager =
  68.             context.getSystemService(Context.LOCATION_SERVICE) as LocationManager
  69.         // 通过GPS卫星定位，定位级别可以精确到街（通过24颗卫星定位，在室外和空旷的地方定位准确、速度快）
  70.         var gps = locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)
  71.         // 通过WLAN或移动网络(3G/2G)确定的位置（也称作AGPS，辅助GPS定位。主要用于在室内或遮盖物（建筑群或茂密的深林等）密集的地方定位）
  72. //        boolean network = false;
  73. //        if (locationManager != null) {
  74. //            network = locationManager.isProviderEnabled(LocationManager.NETWORK_PROVIDER);
  75. //        }
  76.         return gps
  77.     }
  79.     /**
  80.      * 跳转设置（应用信息），会开启一个新的进程（点回退会回到桌面），使用startActivityForResult不可靠，跳转就会触发onActivityResult
  81.      *
  82.      * @param context
  83.      */
  84.     fun startSetting(context: Context?) {
  85.         context?.run {
  86.             try {
  87.                 val intent = Intent()
  88.                 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
  89.                 intent.action = "android.settings.APPLICATION_DETAILS_SETTINGS"
  90.                 intent.data = Uri.fromParts("package", packageName, null)
  91.                 startActivity(intent)
  92.             } catch (e: Exception) {
  93.                 e.printStackTrace()
  94.             }
  95.         }
  96.     }
  98.     /**
  99.      * 打开设置页面（应用信息），和App在同一个进程
  100.      *
  101.      * @param context
  102.      */
  103.     fun startSettingActivity(context: Activity?, requestCode: Int = SETTING_REQUESTCODE) {
  104.         if (context == null) return
  105.         try {
  106.             val intent = Intent(
  107.                 Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse(
  108.                     "package:" +
  109.                             context.packageName
  110.                 )
  111.             )
  112.             intent.addCategory(Intent.CATEGORY_DEFAULT)
  113.             context.startActivityForResult(
  114.                 intent,
  115.                 requestCode
  116.             ) //这里的requestCode和onActivityResult中requestCode要一致
  117.         } catch (e: Exception) {
  118.             e.printStackTrace()
  119.         }
  120.     }
  122.     /**
  123.      * 打开设置页面（应用信息），和App在同一个进程
  124.      *
  125.      * @param context
  126.      */
  127.     fun startSettingActivity(fragment: Fragment?, requestCode: Int = SETTING_REQUESTCODE) {
  128.         if (fragment == null) return
  129.         val context = fragment.context ?: return
  130.         try {
  131.             val intent = Intent(
  132.                 Settings.ACTION_APPLICATION_DETAILS_SETTINGS, Uri.parse(
  133.                     "package:" +
  134.                             context.packageName
  135.                 )
  136.             )
  137.             intent.addCategory(Intent.CATEGORY_DEFAULT)
  138.             fragment.startActivityForResult(
  139.                 intent,
  140.                 requestCode
  141.             ) //这里的requestCode和onActivityResult中requestCode要一致
  142.         } catch (e: Exception) {
  143.             e.printStackTrace()
  144.         }
  145.     }
  147.     /**
  148.      * 跳转到通知设置界面
  149.      */
  150.     @SuppressLint("ObsoleteSdkInt")
  151.     fun startNotifySetting(context: Context?) {
  152.         if (context == null) return
  153.         // vivo 点击设置图标>加速白名单>我的app
  154.         //      点击软件管理>软件管理权限>软件>我的app>信任该软件
  155.         var appIntent = context.packageManager.getLaunchIntentForPackage("com.iqoo.secure")
  156.         if (appIntent != null) {
  157.             context.startActivity(appIntent)
  158.             return
  159.         }
  160.         // oppo 点击设置图标>应用权限管理>按应用程序管理>我的app>我信任该应用
  161.         //      点击权限隐私>自启动管理>我的app
  162.         appIntent = context.packageManager.getLaunchIntentForPackage("com.oppo.safe")
  163.         if (appIntent != null) {
  164.             context.startActivity(appIntent)
  165.             return
  166.         }
  167.         val intent = Intent()
  168.         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
  169.             intent.action = Settings.ACTION_APP_NOTIFICATION_SETTINGS
  170.             intent.putExtra(Settings.EXTRA_APP_PACKAGE, context.packageName)
  171.         } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
  172.             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
  173.                 intent.action = Settings.ACTION_APP_NOTIFICATION_SETTINGS
  174.             }
  175.             intent.putExtra("app_package", context.packageName)
  176.             intent.putExtra("app_uid", context.applicationInfo.uid)
  177.         } else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD) {
  178.             intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
  179.             intent.action = Settings.ACTION_APPLICATION_DETAILS_SETTINGS
  180.             intent.data = Uri.fromParts("package", context.packageName, null)
  181.         } else {
  182.             intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
  183.             intent.action = Intent.ACTION_VIEW
  184.             intent.setClassName("com.android.settings", "com.android.settings.InstalledAppDetails")
  185.             intent.putExtra("com.android.settings.ApplicationPkgName", context.packageName)
  186.         }
  187.         context.startActivity(intent)
  188.     }
  190.     /**
  191.      * 获取是否有通知权限
  192.      *
  193.      * @param context
  194.      * @return
  195.      */
  196.     fun isNotifyEnabled(context: Context?): Boolean {
  197.         if (context == null) return false
  198.         return NotificationManagerCompat.from(context).areNotificationsEnabled()
  199.     }
  201.     /**
  202.      * 获取是否有通知权限
  203.      *
  204.      * @param context
  205.      * @return
  206.      */
  207.     fun isNotifyEnabled2(context: Context): Boolean {
  208.         return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
  209.             isEnableV26(context)
  210.         } else {
  211.             isEnabledV19(context)
  212.         }
  213.     }
  215.     /**
  216.      * 8.0以下判断
  217.      *
  218.      * @param context api19  4.4及以上判断
  219.      * @return
  220.      */
  221.     private fun isEnabledV19(context: Context): Boolean {
  222.         val mAppOps: AppOpsManager =
  223.             context.getSystemService(Context.APP_OPS_SERVICE) as AppOpsManager
  224.         val appInfo: ApplicationInfo = context.applicationInfo
  225.         val pkg = context.applicationContext.packageName
  226.         val uid: Int = appInfo.uid
  227.         var appOpsClass: Class<*>? = null
  228.         try {
  229.             appOpsClass = Class.forName(AppOpsManager::class.java.name)
  230.             val checkOpNoThrowMethod: Method = appOpsClass.getMethod(
  231.                 CHECK_OP_NO_THROW,
  232.                 Integer.TYPE, Integer.TYPE, String::class.java
  233.             )
  234.             val opPostNotificationValue: Field = appOpsClass.getDeclaredField(OP_POST_NOTIFICATION)
  235.             val value = opPostNotificationValue.get(Int::class.java) as Int
  236.             return checkOpNoThrowMethod.invoke(mAppOps, value, uid, pkg) as Int ===
  237.                     AppOpsManager.MODE_ALLOWED
  238.         } catch (e: java.lang.Exception) {
  239.             e.printStackTrace()
  240.         }
  241.         return false
  242.     }
  245.     /**
  246.      * 8.0及以上通知权限判断
  247.      *
  248.      * @param context
  249.      * @return
  250.      */
  251.     private fun isEnableV26(context: Context): Boolean {
  252.         val appInfo: ApplicationInfo = context.applicationInfo
  253.         val pkg = context.applicationContext.packageName
  254.         val uid: Int = appInfo.uid
  255.         return try {
  256.             val notificationManager: NotificationManager =
  257.                 context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
  258.             val sServiceField: Method =
  259.                 notificationManager.javaClass.getDeclaredMethod("getService")
  260.             sServiceField.setAccessible(true)
  261.             val sService: Any = sServiceField.invoke(notificationManager)
  262.             val method: Method = sService.javaClass.getDeclaredMethod(
  263.                 "areNotificationsEnabledForPackage",
  264.                 String::class.java,
  265.                 Integer.TYPE
  266.             )
  267.             method.setAccessible(true)
  268.             method.invoke(sService, pkg, uid) as Boolean
  269.         } catch (e: java.lang.Exception) {
  270.             true
  271.         }
  272.     }
  275. }

ktx

  1. package com.kiwilss.lutils.utils.permission
  3. import android.app.Activity
  4. import android.content.Context
  5. import androidx.fragment.app.Fragment
  7. /**
  8.  *@author kiwilss
  9.  * @email   kiwilss@163.com
  10.  * @time     2022/7/1
  11.  * @desc     {权限扩展工具类}
  12.  */
  14. /**
  15.  * 检测是否有权限
  16.  *
  17.  * @param permission
  18.  * @return
  19.  */
  20. fun Context?.checkPermission(vararg permission: String?) = PermissionUtils.checkPermission(
  21.     this,
  22.     *permission
  23. )
  25. /**
  26.  * 是否打开gps
  27.  *
  28.  * @return
  29.  */
  30. fun Context?.isOpenGPS() = PermissionUtils.isOpenGPS(this)
  32. /**
  33.  *跳转设置（应用信息），会开启一个新的进程（点回退会回到桌面），使用startActivityForResult不可靠，跳转就会触发onActivityResult
  34.  */
  35. fun Context?.startSetting() = PermissionUtils.startSetting(this)
  37. /**
  38.  * 打开设置页面（应用信息），和App在同一个进程
  39.  *
  40.  * @param requestCode
  41.  */
  42. fun Activity?.startSettingActivity(requestCode: Int = PermissionUtils.SETTING_REQUESTCODE) =
  43.     PermissionUtils.startSettingActivity(this, requestCode)
  45. /**
  46.  * 打开设置页面（应用信息），和App在同一个进程
  47.  *
  48.  * @param requestCode
  49.  */
  50. fun Fragment?.startSettingActivity(requestCode: Int = PermissionUtils.SETTING_REQUESTCODE) =
  51.     PermissionUtils.startSettingActivity(this, requestCode)
  52. /**
  53. *打开通知设置界面
  54. */
  55. fun Context?.startNotifySetting() = PermissionUtils.startNotifySetting(this)
  56. /**
  57. *获取通知权限是否打开
  58. */
  59. fun Context?.isNotifyEnabled() = PermissionUtils.isNotifyEnabled(this)

申请权限

  1. 申请单个权限

    1. PermissionsHelper.init(this)
    2.              .requestEachPermissions(ACCESS_FINE_LOCATION, new IPermissionListenerWrap.IEachPermissionListener() {
    3.                  @Override
    4.                  public void onAccepted(Permission permission) {
    5.                      if (permission.granted){
    6.                          //同意
    7.                          ALog.i(LUtils.tag(this),"grant");
    8.                      }else if (permission.shouldShowRequestPermissionRationale){
    9.                          //拒绝
    10.                          ALog.i(LUtils.tag(this),"reject");
    11.                      }else {
    12.                          //拒绝并不再显示
    13.                          ALog.i(LUtils.tag(this),"reject and not show");
    14.                      }
    15.                  }
    16.              });

  2. 申请多个权限

  1. PermissionsHelper.init(this)
  2.            .requestPermissions(new String[]{ACCESS_FINE_LOCATION, RECORD_AUDIO}, new IPermissionListenerWrap.IPermissionListener() {
  3.                @Override
  4.                public void onAccepted(boolean isGranted, boolean allShould, List<String> rejects, List<String> shoulds) {
  5.                    if (isGranted){
  6.                        //全部同意
  7.                        ALog.i(LUtils.tag(this),"grant");
  8.                    }else if (allShould){
  9.                        //有权限不同意
  10.                        ALog.i(LUtils.tag(this),"reject：" + rejects);
  11.                    }else {
  12.                        //有权限不同意，并且设置了不再显示
  13.                        ALog.i(LUtils.tag(this),"reject and not show : " + shoulds);
  14.                    }
  15.                }
  16.            });