Kotlin动态权限请求最佳实践

一、Android 权限概述

在 Android 系统中，权限是保障用户隐私和系统安全的重要机制。应用在访问某些敏感资源（如摄像头、麦克风、位置信息等）时，需要声明并获取相应的权限。Android 的权限分为两类：

普通权限：这类权限不会直接威胁用户的隐私和安全，系统在应用安装时会自动授予，例如 ACCESS_NETWORK_STATE 权限，用于获取网络连接状态。
危险权限：涉及用户敏感信息或可能影响用户隐私安全的权限，例如 CAMERA（摄像头）、READ_CONTACTS（读取联系人）等权限。对于危险权限，在 Android 6.0（API 级别 23）及以上，应用需要在运行时动态请求权限。

二、Kotlin 中动态权限请求基础

在 Kotlin 中进行动态权限请求，主要依赖 Android 系统提供的 ActivityCompat 和 PermissionsChecker 等类。以下是一个简单的动态权限请求示例，以请求 CAMERA 权限为例：

import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {

    private val REQUEST_CAMERA_PERMISSION = 1

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        if (ContextCompat.checkSelfPermission(this, Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, Manifest.permission.CAMERA)) {
                Toast.makeText(this, "摄像头权限是必要的，用于拍照功能", Toast.LENGTH_SHORT).show()
            }
            ActivityCompat.requestPermissions(this, arrayOf(Manifest.permission.CAMERA), REQUEST_CAMERA_PERMISSION)
        } else {
            // 权限已授予，执行相关操作
            Toast.makeText(this, "摄像头权限已授予", Toast.LENGTH_SHORT).show()
        }
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == REQUEST_CAMERA_PERMISSION) {
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(this, "摄像头权限授予成功", Toast.LENGTH_SHORT).show()
            } else {
                Toast.makeText(this, "摄像头权限授予失败", Toast.LENGTH_SHORT).show()
            }
        }
    }
}

在上述代码中：

首先使用 ContextCompat.checkSelfPermission 方法检查应用是否已经拥有 CAMERA 权限。
如果没有权限，通过 ActivityCompat.shouldShowRequestPermissionRationale 方法判断是否需要向用户解释为什么需要该权限。如果返回 true，说明用户之前拒绝过该权限请求，此时可以给用户一个解释。
调用 ActivityCompat.requestPermissions 方法请求权限，传入权限数组和请求码。
在 onRequestPermissionsResult 方法中，根据请求码和授权结果处理权限授予情况。

三、封装权限请求工具类

虽然上述代码实现了基本的动态权限请求功能，但如果在多个地方都需要请求权限，代码会显得冗长且重复。为了提高代码的复用性和可维护性，可以封装一个权限请求工具类。

import android.app.Activity
import android.content.pm.PackageManager
import android.widget.Toast
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class PermissionUtils(private val activity: Activity) {

    private val permissionCallbacks = mutableMapOf<Int, PermissionCallback>()

    fun requestPermission(permission: String, requestCode: Int, callback: PermissionCallback) {
        permissionCallbacks[requestCode] = callback
        if (ContextCompat.checkSelfPermission(activity, permission) != PackageManager.PERMISSION_GRANTED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
                Toast.makeText(activity, "该权限是必要的，请授予", Toast.LENGTH_SHORT).show()
            }
            ActivityCompat.requestPermissions(activity, arrayOf(permission), requestCode)
        } else {
            callback.onPermissionGranted()
        }
    }

    fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        val callback = permissionCallbacks[requestCode]
        if (callback != null) {
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                callback.onPermissionGranted()
            } else {
                callback.onPermissionDenied()
            }
            permissionCallbacks.remove(requestCode)
        }
    }

    interface PermissionCallback {
        fun onPermissionGranted()
        fun onPermissionDenied()
    }
}

在 MainActivity 中使用这个工具类：

class MainActivity : AppCompatActivity() {

    private val REQUEST_CAMERA_PERMISSION = 1
    private lateinit var permissionUtils: PermissionUtils

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        permissionUtils = PermissionUtils(this)
        permissionUtils.requestPermission(Manifest.permission.CAMERA, REQUEST_CAMERA_PERMISSION, object : PermissionUtils.PermissionCallback {
            override fun onPermissionGranted() {
                Toast.makeText(this@MainActivity, "摄像头权限授予成功", Toast.LENGTH_SHORT).show()
            }

            override fun onPermissionDenied() {
                Toast.makeText(this@MainActivity, "摄像头权限授予失败", Toast.LENGTH_SHORT).show()
            }
        })
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        permissionUtils.onRequestPermissionsResult(requestCode, permissions, grantResults)
    }
}

通过封装工具类，使得权限请求代码更加简洁，并且易于在不同的地方复用。

四、请求多个权限

在实际应用中，经常需要请求多个权限。例如，一个社交应用可能需要同时获取摄像头、麦克风和联系人权限。以下是请求多个权限的示例：

class MainActivity : AppCompatActivity() {

    private val REQUEST_MULTIPLE_PERMISSIONS = 2
    private lateinit var permissionUtils: PermissionUtils

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        permissionUtils = PermissionUtils(this)
        val permissions = arrayOf(
            Manifest.permission.CAMERA,
            Manifest.permission.RECORD_AUDIO,
            Manifest.permission.READ_CONTACTS
        )
        requestMultiplePermissions(permissions, REQUEST_MULTIPLE_PERMISSIONS)
    }

    private fun requestMultiplePermissions(permissions: Array<String>, requestCode: Int) {
        var allGranted = true
        for (permission in permissions) {
            if (ContextCompat.checkSelfPermission(this, permission) != PackageManager.PERMISSION_GRANTED) {
                allGranted = false
                break
            }
        }
        if (allGranted) {
            Toast.makeText(this, "所有权限已授予", Toast.LENGTH_SHORT).show()
        } else {
            permissionUtils.requestPermission(permissions, requestCode, object : PermissionUtils.PermissionCallback {
                override fun onPermissionGranted() {
                    Toast.makeText(this@MainActivity, "所有权限授予成功", Toast.LENGTH_SHORT).show()
                }

                override fun onPermissionDenied() {
                    Toast.makeText(this@MainActivity, "部分权限授予失败", Toast.LENGTH_SHORT).show()
                }
            })
        }
    }
}

// 修改 PermissionUtils 类以支持多个权限请求
class PermissionUtils(private val activity: Activity) {

    private val permissionCallbacks = mutableMapOf<Int, PermissionCallback>()

    fun requestPermission(permissions: Array<String>, requestCode: Int, callback: PermissionCallback) {
        permissionCallbacks[requestCode] = callback
        var shouldShowRationale = false
        for (permission in permissions) {
            if (ContextCompat.checkSelfPermission(activity, permission) != PackageManager.PERMISSION_GRANTED) {
                if (ActivityCompat.shouldShowRequestPermissionRationale(activity, permission)) {
                    shouldShowRationale = true
                    break
                }
            }
        }
        if (shouldShowRationale) {
            Toast.makeText(activity, "这些权限是必要的，请授予", Toast.LENGTH_SHORT).show()
        }
        ActivityCompat.requestPermissions(activity, permissions, requestCode)
    }

    fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        val callback = permissionCallbacks[requestCode]
        if (callback != null) {
            var allGranted = true
            for (result in grantResults) {
                if (result != PackageManager.PERMISSION_GRANTED) {
                    allGranted = false
                    break
                }
            }
            if (allGranted) {
                callback.onPermissionGranted()
            } else {
                callback.onPermissionDenied()
            }
            permissionCallbacks.remove(requestCode)
        }
    }

    interface PermissionCallback {
        fun onPermissionGranted()
        fun onPermissionDenied()
    }
}

在上述代码中：

首先检查所有需要的权限是否都已授予，如果是，则直接提示用户所有权限已授予。
如果有任何一个权限未授予，则调用 PermissionUtils 的新方法 requestPermission，该方法支持传入多个权限数组。
在 PermissionUtils 类中，requestPermission 方法检查是否有任何权限需要向用户解释，并根据结果决定是否显示提示信息。
onRequestPermissionsResult 方法检查所有权限的授予结果，只有当所有权限都授予时，才调用 onPermissionGranted 回调。

五、处理权限被拒绝且不再询问

有时候，用户在拒绝权限请求时勾选了“不再询问”选项，这时候再次请求权限将不会弹出系统的权限请求对话框。为了处理这种情况，可以引导用户到应用设置页面手动授予权限。

import android.content.Intent
import android.net.Uri
import android.os.Bundle
import android.provider.Settings
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat

class MainActivity : AppCompatActivity() {

    private val REQUEST_CAMERA_PERMISSION = 1

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        if (ContextCompat.checkSelfPermission(this, android.Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            if (ActivityCompat.shouldShowRequestPermissionRationale(this, android.Manifest.permission.CAMERA)) {
                Toast.makeText(this, "摄像头权限是必要的，用于拍照功能", Toast.LENGTH_SHORT).show()
            } else {
                Toast.makeText(this, "请手动到设置中授予摄像头权限", Toast.LENGTH_SHORT).show()
                val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
                val uri: Uri = Uri.fromParts("package", packageName, null)
                intent.data = uri
                startActivity(intent)
            }
            ActivityCompat.requestPermissions(this, arrayOf(android.Manifest.permission.CAMERA), REQUEST_CAMERA_PERMISSION)
        } else {
            // 权限已授予，执行相关操作
            Toast.makeText(this, "摄像头权限已授予", Toast.LENGTH_SHORT).show()
        }
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == REQUEST_CAMERA_PERMISSION) {
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(this, "摄像头权限授予成功", Toast.LENGTH_SHORT).show()
            } else {
                if (!ActivityCompat.shouldShowRequestPermissionRationale(this, android.Manifest.permission.CAMERA)) {
                    Toast.makeText(this, "请手动到设置中授予摄像头权限", Toast.LENGTH_SHORT).show()
                    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
                    val uri: Uri = Uri.fromParts("package", packageName, null)
                    intent.data = uri
                    startActivity(intent)
                } else {
                    Toast.makeText(this, "摄像头权限授予失败", Toast.LENGTH_SHORT).show()
                }
            }
        }
    }
}

在上述代码中：

在 onCreate 方法中，当检查到权限未授予且 shouldShowRequestPermissionRationale 返回 false 时，说明用户勾选了“不再询问”，此时弹出提示并引导用户到应用设置页面。
在 onRequestPermissionsResult 方法中，如果权限授予失败且 shouldShowRequestPermissionRationale 返回 false，同样引导用户到应用设置页面。

六、使用 RxPermissions 库简化权限请求

除了手动实现权限请求逻辑，还可以使用一些第三方库来简化操作。RxPermissions 是一个基于 RxJava 的 Android 权限请求库，它可以使权限请求代码更加简洁和易于管理。

首先，在 build.gradle 文件中添加依赖：

implementation 'com.tbruyelle.rxpermissions2:rxpermissions:0.10.2'

然后在 MainActivity 中使用 RxPermissions：

import android.os.Bundle
import android.widget.Toast
import androidx.appcompat.app.AppCompatActivity
import com.tbruyelle.rxpermissions2.RxPermissions

class MainActivity : AppCompatActivity() {

    private val rxPermissions by lazy { RxPermissions(this) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        rxPermissions.request(android.Manifest.permission.CAMERA)
           .subscribe { isGranted ->
                if (isGranted) {
                    Toast.makeText(this, "摄像头权限授予成功", Toast.LENGTH_SHORT).show()
                } else {
                    Toast.makeText(this, "摄像头权限授予失败", Toast.LENGTH_SHORT).show()
                }
            }
    }
}

上述代码中：

通过 RxPermissions 的 request 方法请求权限，该方法返回一个 Observable<Boolean>，其中 true 表示权限授予成功，false 表示失败。
使用 subscribe 方法订阅 Observable，并在回调中处理权限授予结果。

如果需要请求多个权限，可以传入多个权限参数：

rxPermissions.request(
    android.Manifest.permission.CAMERA,
    android.Manifest.permission.RECORD_AUDIO
).subscribe { allGranted ->
    if (allGranted) {
        Toast.makeText(this, "所有权限授予成功", Toast.LENGTH_SHORT).show()
    } else {
        Toast.makeText(this, "部分权限授予失败", Toast.LENGTH_SHORT).show()
    }
}

七、动态权限请求与 Fragment

在 Android 应用开发中，经常会使用到 Fragment。在 Fragment 中请求权限与在 Activity 中类似，但有一些细微的差别。

import android.Manifest
import android.content.pm.PackageManager
import android.os.Bundle
import android.widget.Toast
import androidx.core.app.ActivityCompat
import androidx.core.content.ContextCompat
import androidx.fragment.app.Fragment

class MyFragment : Fragment() {

    private val REQUEST_CAMERA_PERMISSION = 1

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        if (ContextCompat.checkSelfPermission(requireContext(), Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) {
            if (shouldShowRequestPermissionRationale(Manifest.permission.CAMERA)) {
                Toast.makeText(requireContext(), "摄像头权限是必要的，用于拍照功能", Toast.LENGTH_SHORT).show()
            }
            requestPermissions(arrayOf(Manifest.permission.CAMERA), REQUEST_CAMERA_PERMISSION)
        } else {
            // 权限已授予，执行相关操作
            Toast.makeText(requireContext(), "摄像头权限已授予", Toast.LENGTH_SHORT).show()
        }
    }

    override fun onRequestPermissionsResult(requestCode: Int, permissions: Array<String>, grantResults: IntArray) {
        super.onRequestPermissionsResult(requestCode, permissions, grantResults)
        if (requestCode == REQUEST_CAMERA_PERMISSION) {
            if (grantResults.isNotEmpty() && grantResults[0] == PackageManager.PERMISSION_GRANTED) {
                Toast.makeText(requireContext(), "摄像头权限授予成功", Toast.LENGTH_SHORT).show()
            } else {
                Toast.makeText(requireContext(), "摄像头权限授予失败", Toast.LENGTH_SHORT).show()
            }
        }
    }
}

在 Fragment 中：

使用 requireContext() 获取上下文来检查权限。
使用 shouldShowRequestPermissionRationale 方法时，直接在 Fragment 中调用，而不是像在 Activity 中那样使用 ActivityCompat。
使用 requestPermissions 方法请求权限，该方法在 Fragment 类中定义。

同样，也可以在 Fragment 中封装权限请求工具类，原理与在 Activity 中类似，只是在获取上下文和调用相关方法时需要注意使用 Fragment 自身的方法。

八、权限请求的 UI 设计与用户体验优化

合理的时机请求权限：不要在应用启动时就一股脑地请求所有权限，这样会给用户造成不好的体验。应该在真正需要使用某个功能时，再请求相应的权限。例如，一个图片编辑应用，只有当用户点击拍照功能时，才请求摄像头权限。
提供清晰的解释：当用户拒绝权限请求时，应该给用户一个清晰的解释，说明为什么应用需要这个权限。可以在 shouldShowRequestPermissionRationale 返回 true 时，弹出一个对话框或 Toast 提示，告知用户权限的用途。
友好的引导到设置页面：如果用户勾选了“不再询问”并拒绝权限，引导用户到应用设置页面时，应该提供一些简单的操作指引，帮助用户快速找到权限设置的位置。例如，可以在提示信息中说明“请在设置 - 应用 - [应用名称] - 权限中授予摄像头权限”。
权限请求的动画与交互：在请求权限时，可以添加一些动画效果，使整个过程更加流畅和自然。例如，在弹出权限请求对话框时，可以添加一个淡入动画，让用户感觉更加舒适。

九、动态权限请求的测试

手动测试：在开发过程中，手动测试权限请求是最基本的方法。可以在不同的 Android 版本设备上，多次请求权限，测试权限授予、拒绝以及“不再询问”等各种情况。同时，还可以模拟不同的网络环境和设备状态下的权限请求。
自动化测试：使用 Espresso 或 UI Automator 等自动化测试框架，可以编写测试用例来自动测试权限请求流程。例如，可以编写测试用例检查权限请求对话框是否弹出，权限授予或拒绝后的操作是否正确等。以下是一个使用 Espresso 测试权限请求的简单示例：

import android.Manifest
import android.content.pm.PackageManager
import androidx.test.espresso.Espresso.onView
import androidx.test.espresso.action.ViewActions.click
import androidx.test.espresso.matcher.ViewMatchers.withId
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.rule.GrantPermissionRule
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith

@RunWith(AndroidJUnit4::class)
class PermissionTest {

    @get:Rule
    val cameraPermissionRule: GrantPermissionRule = GrantPermissionRule.grant(Manifest.permission.CAMERA)

    @Test
    fun testCameraPermission() {
        // 假设应用中有一个按钮，点击后请求摄像头权限
        onView(withId(R.id.request_camera_permission_button)).perform(click())
        // 这里可以添加断言，检查权限请求后的操作是否正确
    }
}

在上述代码中：

使用 GrantPermissionRule 来授予 CAMERA 权限，这样在测试过程中可以避免手动授予权限的麻烦。
通过 Espresso 找到应用中请求权限的按钮，并模拟点击操作，然后可以添加断言来验证权限请求后的结果是否符合预期。

通过手动测试和自动化测试相结合，可以确保动态权限请求功能的稳定性和可靠性。

十、动态权限请求在不同场景下的应用

地图应用：地图应用通常需要获取位置权限，以便实时显示用户的位置。在应用启动时，可以先请求粗略位置权限，如果用户需要更精确的位置信息，再请求精确位置权限。同时，地图应用可能还需要获取存储权限，以便缓存地图数据，提高使用体验。
社交应用：社交应用可能需要摄像头权限用于拍照和录制视频，麦克风权限用于语音消息和视频通话，联系人权限用于查找和添加好友等。这些权限应该在用户真正使用相关功能时请求，而不是在应用启动时全部请求。
文件管理应用：文件管理应用需要存储权限来访问和操作文件。在应用启动时，可以请求存储权限，并且要处理好权限被拒绝的情况，例如提示用户授予权限，否则无法正常使用文件管理功能。

不同类型的应用根据其功能需求，在动态权限请求的时机、方式和处理上都有不同的特点，需要根据具体情况进行优化和调整。

通过以上内容，我们全面深入地探讨了 Kotlin 中动态权限请求的最佳实践，包括基础实现、封装工具类、请求多个权限、处理特殊情况、使用第三方库、在 Fragment 中的应用、UI 设计优化、测试以及不同场景下的应用等方面。希望这些内容能帮助开发者更好地实现应用的权限管理功能，提供更优质的用户体验。