Permission Handler ใน Android: วิธีการทำงาน การจัดการคำขอ และการนำไปใช้

Permission Handler ใน Android คืออะไร

Permission Handler คือรูปแบบสถาปัตยกรรมสำหรับการจัดการสิทธิ์ขณะรันไทม์ของ Android แบบรวมศูนย์ แทนที่จะเรียก ContextCompat.checkSelfPermission และ ActivityCompat.requestPermissions กระจัดกระจายทั่วโค้ดแอปพลิเคชัน ตรรกะการขอและการประมวลผลผลลัพธ์ทั้งหมดจะรวมอยู่ในคลาสเดียว ซึ่งช่วยลดการทำซ้ำ ทำให้การบำรุงรักษาง่ายขึ้น และทำให้โค้ดคาดเดาได้มากขึ้น

ความจำเป็นของ Permission Handler เกิดขึ้นพร้อมกับการนำสิทธิ์ขณะรันไทม์มาใช้ใน Android 6.0 ก่อนหน้านั้น สิทธิ์ทั้งหมดจะถูกขอขณะติดตั้ง และโค้ดแอปพลิเคชันสามารถใช้ API ใดก็ได้โดยไม่ต้องตรวจสอบ หลังจากเปลี่ยนมาใช้โมเดลรันไทม์ การใช้สิทธิ์อันตรายแต่ละครั้งต้องมีการตรวจสอบสามขั้นตอน: checkSelfPermission, requestPermissions, onRequestPermissionsResult การกระจายตรรกะนี้ไปทั่ว Activity และ Fragment ทำให้เกิดการทำซ้ำในบรรทัดและข้อผิดพลาด ตาม Google I/O 2019 การรวมศูนย์การจัดการสิทธิ์ช่วยลดจำนวนบักที่เกี่ยวข้องกับ Permission Denial เฉลี่ย 60 เปอร์เซ็นต์

Permission Handler ที่ดีมีอินเทอร์เฟซที่สะอาดสำหรับโค้ดที่เรียกใช้ Activity หรือ Fragment ไม่จำเป็นต้องรู้รายละเอียดของคำขอ — พวกเขาเรียกเมธอดเช่น requestCamera(callback) และตัวจัดการจะจัดการตรวจสอบสถานะ การแสดงเหตุผล การเรียกกล่องโต้ตอบระบบ และการส่งผลลัพธ์ไปยัง callback ด้วยตนเอง ซึ่งใช้หลักการความรับผิดชอบเดียวและแยกตรรกะธุรกิจออกจากโค้ดสิทธิ์ของแพลตฟอร์ม

เมื่อใดที่จำเป็นต้องใช้ Permission Handler

Permission Handler กลายเป็นสิ่งจำเป็นเมื่อแอปพลิเคชันใช้สิทธิ์อันตราย 3 รายการขึ้นไป สำหรับแอปพลิเคชันง่ายๆ ที่มีสิทธิ์เดียว (เช่น กล้องสำหรับเครื่องสแกน QR โค้ด) การเรียกโดยตรงอาจเพียงพอ แต่สำหรับแอปพลิเคชันมือถือทั่วไปที่มีกล้อง ตำแหน่งที่ตั้ง การแจ้งเตือน และพื้นที่จัดเก็บ — ตัวจัดการ แบบรวมศูนย์เป็นสิ่งจำเป็นสำหรับการบำรุงรักษา

สถาปัตยกรรมของ Permission Handler

Permission Handler ทั่วไป ประกอบด้วยสามชั้น: สัญญาอินเทอร์เฟซ การนำไปใช้กับ ActivityResultLauncher และชั้น ViewModel อินเทอร์เฟซกำหนดเมธอดคำขอสำหรับแต่ละสิทธิ์ — requestCamera, requestLocation, requestStorage การนำไปใช้เชื่อมโยงเมธอดเหล่านี้กับสัญญา ActivityResultContracts.RequestPermission ที่เกี่ยวข้อง

คอมโพเนนต์สำคัญของสถาปัตยกรรม:

• PermissionHandlerContract — อินเทอร์เฟซที่มีเมธอดสำหรับแต่ละสิทธิ์
• PermissionHandlerImpl — การนำไปใช้ที่เชื่อมต่อกับ ActivityResultRegistry
• PermissionResult — คลาส sealed ที่มีสถานะ GRANTED, DENIED, NEVER_ASK_AGAIN
• RationaleHandler — คอมโพเนนต์สำหรับแสดงคำอธิบายก่อนคำขอ

สถาปัตยกรรมนี้ช่วยให้สามารถสลับการนำไปใช้ในการทดสอบได้ง่าย: แทนที่จะใช้ ActivityResultLauncher จริง จะใช้ม็อกที่ส่งคืนผลลัพธ์ที่กำหนดไว้ล่วงหน้าโดยไม่ต้องโต้ตอบกับระบบ ซึ่งมีความสำคัญอย่างยิ่งสำหรับการทดสอบหน่วยของตรรกะ UI ที่ไม่สามารถเปิด Activity สำหรับกล่องโต้ตอบสิทธิ์ได้

การจัดการวงจรชีวิต

Permission Handler ต้องคำนึงถึงวงจรชีวิตของ Activity และ Fragment ตัวเรียกใช้งานจะลงทะเบียนใน ActivityResultRegistry ซึ่งจะบันทึกและกู้คืนสถานะโดยอัตโนมัติเมื่อหมุนหน้าจอและสร้าง Activity ใหม่ ตัวจัดการไม่ควรเก็บการอ้างอิงโดยตรงไปยัง Activity หรือ Fragment — ให้ใช้ WeakReference หรือส่ง registry ผ่านคอนสตรัคเตอร์แทน ซึ่งป้องกันการรั่วไหลของหน่วยความจำและการขัดข้องระหว่างการเปลี่ยนแปลงการกำหนดค่า

การนำ Permission Handler ไปใช้ใน Kotlin

การนำไปใช้พื้นฐาน ของ Permission Handler สร้างขึ้นบน ActivityResultContracts.RequestPermission ตัวจัดการได้รับ ActivityResultRegistry จาก ComponentActivity หรือ Fragment และลงทะเบียนตัวเรียกใช้งานสำหรับแต่ละสิทธิ์ ตัวเรียกใช้งานแต่ละตัวยอมรับแลมบ์ดา callback ที่ถูกเรียกหลังจากผู้ใช้ตอบกลับ

sealed class PermissionResult {
    object GRANTED : PermissionResult()
    data class DENIED(
        val shouldShowRationale: Boolean
    ) : PermissionResult()
}

interface PermissionHandler {
    fun requestCamera(
        callback: (PermissionResult) -> Unit
    )
    fun requestLocation(
        callback: (PermissionResult) -> Unit
    )
    fun isPermissionGranted(
        permission: String
    ): Boolean
}

class AndroidPermissionHandler(
    private val registry: ActivityResultRegistry,
    private val context: Context
) : PermissionHandler {

    private var cameraLauncher: ActivityResultLauncher<String>? = null

    fun initialize() {
        cameraLauncher = registry.register(
            "camera_permission",
            ActivityResultContracts.RequestPermission()
        ) { isGranted ->
            if (isGranted) {
                pendingCameraCallback?.invoke(
                    PermissionResult.GRANTED
                )
            } else {
                val rationale = ActivityCompat.shouldShowRequestPermissionRationale(
                    context as Activity,
                    Manifest.permission.CAMERA
                )
                pendingCameraCallback?.invoke(
                    PermissionResult.DENIED(rationale)
                )
            }
        }
    }

    private var pendingCameraCallback:
        ((PermissionResult) -> Unit)? = null

    override fun requestCamera(
        callback: (PermissionResult) -> Unit
    ) {
        if (isPermissionGranted(
                Manifest.permission.CAMERA
        )) {
            callback.invoke(PermissionResult.GRANTED)
            return
        }
        pendingCameraCallback = callback
        cameraLauncher?.launch(
            Manifest.permission.CAMERA
        )
    }

    override fun isPermissionGranted(
        permission: String
    ): Boolean {
        return ContextCompat.checkSelfPermission(
            context, permission
        ) == PackageManager.PERMISSION_GRANTED
    }
}

การเริ่มต้นใน Activity

ตัวจัดการเริ่มต้นใน onCreate ของ Activity ผ่าน registerForActivityResult ซึ่งให้การเข้าถึง ActivityResultRegistry หลังจากการเริ่มต้น ตัวจัดการพร้อมที่จะประมวลผลคำขอตลอดวงจรชีวิตของ Activity สิ่งสำคัญคือต้องเรียก initialize ก่อนคำขอแรก มิฉะนั้นตัวเรียกใช้งานจะไม่ถูกลงทะเบียน

Permission Handler กับ ViewModel

การรวม Permission Handler กับ ViewModel เป็นแนวทางที่ทันสมัยที่สุด ViewModel จัดการสถานะคำขอ ในขณะที่ Handler ดำเนินการเรียกแพลตฟอร์มเท่านั้น ViewModel มี StateFlow<PermissionUiState> โดย UiState อธิบายว่าสิทธิ์ใดกำลังถูกขอและได้รับผลลัพธ์ใด Activity สมัครรับ StateFlow นี้และมอบหมายคำขอให้ Handler

class PermissionsViewModel : ViewModel() {

    private val _uiState =
        MutableStateFlow<PermissionUiState>(
            PermissionUiState.Idle
        )
    val uiState: StateFlow<PermissionUiState> = _uiState.asStateFlow()

    fun onCameraRequested() {
        _uiState.value = PermissionUiState.RequestingCamera
    }

    fun onPermissionResult(
        permission: String,
        result: PermissionResult
    ) {
        when (result) {
            PermissionResult.GRANTED -> {
                _uiState.value = PermissionUiState.Granted(permission)
            }
            is PermissionResult.DENIED -> {
                _uiState.value = PermissionUiState.Denied(
                    permission,
                    result.shouldShowRationale
                )
            }
        }
    }
}

sealed class PermissionUiState {
    object Idle : PermissionUiState()
    object RequestingCamera : PermissionUiState()
    data class Granted(val permission: String) : PermissionUiState()
    data class Denied(
        val permission: String,
        val shouldShowRationale: Boolean
    ) : PermissionUiState()
}

ในโมเดลนี้ Activity ตรวจสอบ isPermissionGranted ผ่าน Handler เมื่อเริ่มต้น ในขณะที่ ViewModel จัดการเฉพาะสถานะ หากสิทธิ์ไม่ได้รับ — Activity สมัครรับ uiState เรียก requestCamera จาก Handler และส่งผลลัพธ์กลับไปยัง ViewModel ผ่าน onPermissionResult การแยกโค้ดแพลตฟอร์มออกจากตรรกะธุรกิจช่วยให้สามารถทดสอบ ViewModel โดยไม่ต้องพึ่งพา Android

การทดสอบ Permission Handler

การทดสอบหน่วย ของ Permission Handler เป็นไปได้ด้วยอินเทอร์เฟซ PermissionHandler ในการทดสอบ จะสร้าง FakePermissionHandler ที่จำลองสถานการณ์ต่างๆ: อนุญาตสิทธิ์ ปฏิเสธ Never Ask Again แต่ละสถานการณ์จะถูกทดสอบอย่างอิสระ ซึ่งสำคัญอย่างยิ่งสำหรับการทดสอบตรรกะ UI ที่ต้องตอบสนองต่อผลลัพธ์ทั้งสามอย่างถูกต้อง

class FakePermissionHandler : PermissionHandler {

    var cameraResult: PermissionResult =
        PermissionResult.GRANTED
    var grantedPermissions: Set<String> =
        setOf(Manifest.permission.CAMERA)

    override fun requestCamera(
        callback: (PermissionResult) -> Unit
    ) {
        callback.invoke(cameraResult)
    }

    override fun isPermissionGranted(
        permission: String
    ): Boolean {
        return permission in grantedPermissions
    }
}

การนำไปใช้แบบจำลองช่วยให้ทดสอบ ViewModel โดยไม่ต้องใช้โปรแกรมจำลอง เพียงตั้งค่า cameraResult เป็นค่าที่ต้องการและตรวจสอบว่า ViewModel อัปเดต UiState อย่างถูกต้อง การทดสอบแบบบูรณาการตรวจสอบ Permission Handler จริงกับ ActivityScenario แต่โดยปกติแล้วจะมีเพียง 2-3 การทดสอบต่อแอปพลิเคชัน — สถานการณ์ที่เหลือครอบคลุมโดยการทดสอบหน่วยด้วย fakes

รูปแบบทั่วไปและข้อผิดพลาด

ข้อผิดพลาดทั่วไป เมื่อทำงานกับ Permission Handler ได้แก่: ไม่ตรวจสอบ checkSelfPermission ก่อนเรียก API แต่ละครั้ง ไม่สนใจ shouldShowRequestPermissionRationale เรียก requestPermissions ซ้ำหลังจาก Never Ask Again และเก็บตัวเรียกใช้งานโดยไม่พิจารณาวงจรชีวิต Activity มาดูปัญหาแต่ละข้อและแนวทางแก้ไข

ข้อผิดพลาดที่พบบ่อยที่สุดคือการเรียก API โดยไม่ตรวจสอบสถานะสิทธิ์ นักพัฒนาเข้าใจว่าหากให้สิทธิ์ครั้งหนึ่งแล้ว สิทธิ์นั้นจะคงอยู่ตลอดไป อย่างไรก็ตาม ผู้ใช้สามารถเพิกถอนได้ผ่านการตั้งค่าได้ทุกเวลา Permission Handler ควรเรียก isPermissionGranted ก่อนดำเนินการที่ละเอียดอ่อนเสมอ ข้อผิดพลาดยอดนิยมอันดับสองคือการไม่สนใจ shouldShowRequestPermissionRationale และขอซ้ำ ซึ่งนำไปสู่การปฏิเสธทันทีโดยไม่มีกล่องโต้ตอบในโหมด Never Ask Again

แนวปฏิบัติที่ดีที่สุดรวมถึง: สร้างอินสแตนซ์ Handler เดียวตลอดวงจรชีวิต Activity ใช้ SharedFlow เพื่อส่งผลลัพธ์ไปยัง ViewModel บันทึกคำขอและการปฏิเสธทั้งหมดเพื่อการวิเคราะห์ และแสดงกล่องโต้ตอบเหตุผลที่กำหนดเองก่อนของระบบเมื่อปฏิเสธครั้งแรก การปฏิบัติตามกฎเหล่านี้รับประกันการจัดการสิทธิ์ที่เสถียรบน Android ทุกเวอร์ชัน