判断通知权限状态

一、背景

做啥事肯定是有原因的，最近在做和H5那边交互，那边申请某个权限之前，需要知道该权限状态，其中一个状态，就是判断用户是否永久拒绝了此权限(拒绝且不在提醒)，这个就比较坑，iOS那边是有方法直接获取的，但是Android这边貌似没有直接获取此状态的方法（有找到此方法的小伙伴请留言）。我们最熟悉的权限检测方法ActivityCompat.checkSelfPermission(activity, permission)，但是此方法只返回true和false，true是已授权，false是用户拒绝了此权限，无法应付需求

二、实现逻辑

1.不会的当然是百度，百度中找到了一个方法ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)，此方法也只返回true和false。以下是每种情况返回值

未请求权限，返回false
请求了权限，用户选择了拒绝权限，但不是永久拒绝，下次申请权限还会弹窗，这时候返回值为true
请求了权限，用户决绝了权限，并且是永久拒绝（选择了拒绝且不在提示），此时返回值为false
用户同意了权限，此时返回值为false

2.找到了此方法，离成功就不远了。现在来说下具体判断逻辑，我们先总结下，一共会出现的几种状态，第一种就是还没申请过此权限，第二种是用户已同意权限，第三种就是申请了权限，被用户拒绝，但下次申请还会弹窗提醒，第四种就是我们要找的，用户拒绝了权限，并且下次不会再提示

第一种状态，无法用提供的两个方法判断，需要做一个本地存储，判断是否申请过此权限，可以用SharedPreferences，以权限名为key，当申请此权限，就记录一下。
第二种状态就比较好判断，直接用ActivityCompat.checkSelfPermission(activity, permission)判断为true就行
第三种状态，直接用ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)判断为true就行
第四种状态就不用判断了，else就行

三、具体代码

不单独获取状态，包含了申请权限，做了个简单的权限申请封装，目前只做申请单个权限功能，自己可以加多权限处理。说了这么多废话，现在具体上代码( ˘•ω•˘ )

object PermissionUtils {
    //获取权限成功
    const val STATUS_SUCCESS = 0
    //申请权限拒绝, 但是下次申请权限还会弹窗
    const val STATUS_REFUSE = 1
    //申请权限拒绝，并且是永久，不会再弹窗
    const val STATUS_REFUSE_PERMANENT = 2
    //默认未请求授权状态
    const val STATUS_DEFAULT = 3

    private const val REQUEST_CODE = 10000
    private lateinit var permissions: Array<out String>
    private var listener: PermissionListener?= null

    /**
     * 判断是否已授权
     */
    fun isAuthorized(activity: Activity, authorize: String): Boolean{
        val isShow = ActivityCompat.shouldShowRequestPermissionRationale(activity, authorize)
        LogUtils.d("print","$isShow")
        val flag = ActivityCompat.checkSelfPermission(activity, authorize)
        if (flag!= PackageManager.PERMISSION_GRANTED){
            return false
        }
        return true
    }

    /**
     * 获取权限状态
     */
    fun getAuthorizeStaus(activity: Activity,authorize: String): Int{
        val flag = ActivityCompat.checkSelfPermission(activity, authorize)
        val isShould = ActivityCompat.shouldShowRequestPermissionRationale(activity, authorize)
        if (isShould){
            return STATUS_REFUSE
        }
        if (flag == PackageManager.PERMISSION_GRANTED){
            //获取到权限
            return STATUS_SUCCESS
        }
        if (!SharedUtils.contains(authorize)){
            return STATUS_DEFAULT
        }
        return STATUS_REFUSE_PERMANENT
    }

    /**
     * 申请单个权限权限
     */
    fun requestPermission(activity: Activity,authorize: String,listener: PermissionListener){
        this.listener = listener
        permissions = arrayOf(authorize)
        val flag = ActivityCompat.checkSelfPermission(activity, authorize)
        if (flag!= PackageManager.PERMISSION_GRANTED){
            ActivityCompat.requestPermissions(activity, permissions,REQUEST_CODE)
        }else{
            this.listener?.requestResult(true)
        }
    }

    /**
     * 返回结果
     */
    fun onRequestPermissionsResult(activity: Activity,requestCode: Int, permissions: Array<out String>,  grantResults: IntArray){
        if (requestCode != REQUEST_CODE){
            return
        }
        permissions.forEach {
            val isShould = ActivityCompat.shouldShowRequestPermissionRationale(activity, it)
            SharedUtils.putBoolean(it,isShould)
        }
        grantResults.forEach {

            if (it != PackageManager.PERMISSION_GRANTED){
                listener?.requestResult(false)
                return
            }
        }
        listener?.requestResult(true)
    }
}

interface PermissionListener {
    /**
     * 授权结果
     */
    fun requestResult(isFlog: Boolean)
}

SharedUtils工具类，需要先SharedUtils.init(context)初始化，不然会报错

object SharedUtils {
    const val FILE_NAME = "JsLibrary"
    lateinit var sp: SharedPreferences

    fun init(context: Context){
        sp = context.applicationContext.getSharedPreferences(FILE_NAME, Context.MODE_PRIVATE)
    }
    /**
     * 添加boolean值
     */
    fun putBoolean(key: String,value: Boolean){
        sp.edit().putBoolean(key,value).apply()
    }
    /**
     * 获取boolean值
     */
    fun getBoolean(key: String,default: Boolean): Boolean{
        return sp.getBoolean(key,default)
    }

    /**
     * 判断是否存在
     */
    fun contains(key: String): Boolean{
        return sp.contains(key)
    }
}

具体调用方法

在申请权限的activity中需要加上一下代码

/**
     * 权限返回结果
     */
    override fun onRequestPermissionsResult(
        requestCode: Int,
        permissions: Array<out String>,
        grantResults: IntArray
    ) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        PermissionUtils.onRequestPermissionsResult(this,requestCode,permissions,grantResults)
    }

获取状态代码

val status = PermissionUtils.getAuthorizeStaus(activity,xxx权限)

status就是返回的那四种状态

额外权限申请方法

PermissionUtils.requestPermission(activity, xx权限, object : PermissionListener{
                    override fun requestResult(isFlog: Boolean) {
                        Log.d("print","$isFlog")
                    }
                })

申请权限回调结果isFlog，true同意权限，false为拒绝权限

转自 Android权限状态判断

我的实现方案

private fun Context.hasNotificationPermission(): Boolean {
    // 低于 Android 13 的版本不需要运行时权限
    return Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU ||
            ContextCompat.checkSelfPermission(
                this,
                Manifest.permission.POST_NOTIFICATIONS
            ) == PackageManager.PERMISSION_GRANTED
}

// 检查通知权限是否永久拒绝
fun isNotificationPermissionPermanentlyDenied(activity: Activity): Boolean {
    return Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
            && ContextCompat.checkSelfPermission(activity, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_DENIED
            && !ActivityCompat.shouldShowRequestPermissionRationale(activity, Manifest.permission.POST_NOTIFICATIONS)
}

// 打开应用设置页面
private fun Context.openAppSettings() {
    val intent = Intent(ACTION_APPLICATION_DETAILS_SETTINGS).apply {
        data = Uri.fromParts("package", this@openAppSettings.packageName, null)
        addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
    }
    startActivity(intent)
}

@Composable
fun MainScreen(modifier: Modifier = Modifier) {
    Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
        Column(
            modifier = Modifier
                .padding(innerPadding)
                .verticalScroll(rememberScrollState())
        ) {
            val context = LocalContext.current
            val requestPermission = rememberLauncherForActivityResult(
                ActivityResultContracts.RequestPermission()
            ) {
                if (isNotificationPermissionPermanentlyDenied(context as Activity)) {
                    Toast.makeText(context, "请开启通知权限", Toast.LENGTH_LONG).show()
                    context.openAppSettings()
                }
            }

            Button(
                onClick = {
                    NotificationManagerCompat.from(context).areNotificationsEnabled()
                    if (!context.hasNotificationPermission()) {
                        requestPermission.launch(Manifest.permission.POST_NOTIFICATIONS)
                        return@Button
                    }
                    // 已被授予通知权限
                }
            ) {
                Text(text = "启动")
            }
        }
    }
}

#判断通知权限状态

#一、背景

#二、实现逻辑

#三、具体代码

#我的实现方案

判断通知权限状态

一、背景

二、实现逻辑

三、具体代码

我的实现方案