Dangerous Permission Android-da: mohiyati, ruxsatlar ro'yxati va runtime so'rovi

Android-da Dangerous Permission nima

Dangerous Permission — Android tizim ruxsatlarining foydalanuvchining maxfiy ma'lumotlariga kirishni ta'minlaydigan toifasidir. Oddiy ruxsatlardan farqli o'laroq, xavfli ruxsatlar o'rnatish vaqtida avtomatik berilmaydi — ilova ularni Android 6.0 Marshmallow (API 23) da joriy qilingan runtime mexanizmi orqali bajarish vaqtida aniq so'rashi kerak.

Aniq so'rovning zarurati bu ruxsatlar himoya qiladigan ma'lumotlarning tabiati bilan bog'liq: foydalanuvchining geolokatsiyasi, shaxsiy kontaktlari, kamera va mikrofon mazmuni, qo'ng'iroqlar tarixi va SMS. Android bu ma'lumotlarni nozik deb hisoblaydi va foydalanuvchining ongli roziligini talab qiladi. Android Privacy Sandbox (2024) ma'lumotlariga ko'ra, foydalanuvchilar o'rtacha runtime so'rovlarining taxminan 30 foizini rad etadi.

Dangerous Permission ning asosiy xususiyati — istalgan vaqtda qaytarib olish imkoniyati. Foydalanuvchi Sozlamalar — Ilovalar — Ruxsatlar bo'limiga o'tib, istalgan xavfli ruxsat uchun kalitni o'zgartirishi mumkin. Ilova berilgan ruxsat istalgan vaqtda qayta ishga tushirilmasdan qaytarib olinishi mumkinligiga tayyor bo'lishi kerak.

ProtectionLevel dangerous

Dangerous himoya darajasi OS darajasida tizim ruxsat ta'riflarida o'rnatiladi. Ilova bunday protectionLevel bilan uses-permission e'lon qilganda, tizim ruxsatni runtime so'rovini talab qiladigan deb belgilaydi. Normal dan farqli o'laroq, dangerous ruxsatlari har doim tizim ruxsatlarni boshqarish interfeysida ko'rsatiladi va qaytarib olinishi mumkin.

Permission Group va Dangerous

Barcha xavfli ruxsatlar funksional belgiga ko'ra Permission Group da guruhlangan. Masalan, CAMERA va CAMERA2 CAMERA guruhida, ACCESS_FINE_LOCATION va ACCESS_COARSE_LOCATION — LOCATION guruhida. Agar foydalanuvchi guruhdan bitta ruxsat bergan bo'lsa, o'sha guruhning qolgan ruxsatlari qo'shimcha dialogsiz avtomatik beriladi.

Runtime so'rovi qanday ishlaydi

Runtime so'rovi — ilova ruxsat so'rovi bilan tizim dialogini ko'rsatish uchun tizim API-ni chaqiradigan mexanizmdir. Foydalanuvchi ruxsat nomi va Allow va Deny tugmalari bilan modal oynani ko'radi. Javobdan so'ng tizim natija bilan onRequestPermissionsResult callback-ni chaqiradi.

To'liq sikl uch bosqichni o'z ichiga oladi: checkSelfPermission orqali statusni tekshirish, ruxsat bo'lmaganda requestPermissions ni chaqirish va natijani onRequestPermissionsResult da qayta ishlash. Statusni tekshirish majburiy, chunki foydalanuvchi ruxsatni istalgan vaqtda sozlamalar orqali qaytarib olishi mumkin va tekshirmasdan funksiyani chaqirish SecurityException ga olib keladi.

fun checkAndRequestCameraPermission() {
    when {
        ContextCompat.checkSelfPermission(
            this,
            Manifest.permission.CAMERA
        ) == PackageManager.PERMISSION_GRANTED -> {
            openCamera()
        }
        else -> {
            ActivityCompat.requestPermissions(
                this,
                arrayOf(Manifest.permission.CAMERA),
                REQUEST_CAMERA_CODE
            )
        }
    }
}

Natijani qayta ishlash ActivityResultLauncher yoki onRequestPermissionsResult da amalga oshiriladi. Tavsiya etilgan zamonaviy yondashuv — ActivityResultContracts.RequestPermission dan foydalanish, bu aniq so'rov kodlarisiz tozaroq API ni ta'minlaydi. Ushbu kontrakt Boolean qaytaradi — ruxsat berilganmi yoki yo'qmi.

So'rov uchun eng yaxshi amaliyotlar

Xavfli ruxsatlarni ilova ishga tushganda emas, balki funksiyadan foydalanish kontekstida so'rang. Agar foydalanuvchi kamera tugmasini bosgan bo'lsa — CAMERA ni so'rang. Agar xaritani ochgan bo'lsa — LOCATION ni so'rang. Kontekstual so'rov birinchi ishga tushirishda barcha ruxsatlarni so'rashdan ikki baravar ko'proq tasdiq oladi. Shuningdek, bir vaqtning o'zida bir nechta ruxsatni so'ramaslik tavsiya etiladi, shunda foydalanuvchi qaysi funksiya kirishni talab qilishini tushunadi.

Android-da xavfli ruxsatlar ro'yxati

Android belgilaydi bir nechta xavfli ruxsat guruhlari, har biri birdan bir nechta konstantagacha o'z ichiga oladi. Eng to'liq ro'yxat Manifest.permission sinfida keltirilgan. Quyida ishlab chiqishda foydalaniladigan asosiy guruhlar va ruxsatlar ko'rsatilgan.

Android 12+ da yangi ruxsatlar

Android 12 dan boshlab, Google ba'zi ruxsatlarga talablarni qattiqlashtirdi. Masalan, BLUETOOTH_CONNECT va BLUETOOTH_SCAN xavfli bo'ldi va runtime so'rovini talab qiladi. Shuningdek, sensorlarga fon kirishi uchun BODY_SENSORS_BACKGROUND ruxsati paydo bo'ldi. Dasturchilar targetSdkVersion ni yangilashlari va so'rovlarni OS ning joriy versiyalarida sinab ko'rishlari kerak.

Android 13+ uchun ruxsatlar

Android 13 (API 33) bildirishnomalar (POST_NOTIFICATIONS) va media fayllar (READ_MEDIA_IMAGES, READ_MEDIA_VIDEO, READ_MEDIA_AUDIO) uchun yangi ruxsatlarni joriy qildi, umumiy READ_EXTERNAL_STORAGE o'rnini bosdi. Endi fotosuratlar, video va audioga kirish yagona dialogsiz alohida ixtisoslashtirilgan ruxsatlar orqali so'raladi.

Dangerous vs Normal Permission

Dangerous va Normal Permission berilish usuli, qaytarib olish imkoniyati va UX jihatidan tubdan farq qiladi. Normal o'rnatish vaqtida avtomatik beriladi, Dangerous aniq runtime dialogini talab qiladi. Normal sozlamalar orqali qaytarib olinmaydi, Dangerous istalgan vaqtda o'chirilishi mumkin. Bu assimetriya turli xil ishlab chiqish naqshlarini belgilaydi.

Kod nuqtai nazaridan, xavfli ruxsatlar ko'proq ish talab qiladi: checkSelfPermission, requestPermissions, rad etishni boshqarish. Normal uchun AndroidManifest.xml da bir satr yetarli. Shu bilan birga, Dangerous Permission foydalanuvchiga nazorat beradi, bu esa ayniqsa kamera yoki geolokatsiya kabi nozik funksiyalar uchun ishonchni oshiradi.

Kategoriyalar o'rtasida tanlov dasturchi oldida turmaydi — u tizim tomonidan belgilanadi. Dasturchi faqat uses-permission e'lon qiladi, tizim esa protectionLevel asosida kategoriyani belgilaydi. Biroq, xavfli ruxsatlarni so'rash strategiyasi foydalanuvchi tajribasiga ta'sir qiladi: tez-tez yoki noo'rin dialoglar ilova reytingini pasaytiradi.

Kotlin-da ruxsatlarni qanday so'rash mumkin

Zamonaviy usul Kotlin-da ruxsatlarni so'rash — ActivityResultContracts.RequestMultiplePermissions yoki RequestPermission dan foydalanish. Ushbu kontraktlar androidx.activity kutubxonasining bir qismidir va onRequestPermissionsResult ni qayta yozishni talab qilmasdan lambdalar asosida toza API ni ta'minlaydi.

class CameraActivity : AppCompatActivity() {
    private val requestPermissionLauncher =
        registerForActivityResult(
            ActivityResultContracts.RequestPermission()
        ) { isGranted: Boolean ->
            if (isGranted) {
                openCamera()
            } else {
                showPermissionDeniedMessage()
            }
        }

    fun requestCamera() {
        when {
            ContextCompat.checkSelfPermission(
                this,
                Manifest.permission.CAMERA
            ) == PackageManager.PERMISSION_GRANTED ->
                openCamera()
            ActivityCompat.shouldShowRequestPermissionRationale(
                this,
                Manifest.permission.CAMERA
            ) ->
                showRationaleDialog()
            else ->
                requestPermissionLauncher.launch(
                    Manifest.permission.CAMERA
                )
        }
    }
}

Bir nechta ruxsatni bir vaqtning o'zida so'rash

Ilovaga bir vaqtning o'zida bir nechta xavfli ruxsat kerak bo'lganda, RequestMultiplePermissions dan foydalaning. Kontrakt Map<String, Boolean> qaytaradi, bu yerda kalit ruxsat nomi, qiymat esa natijadir. Bu video yozish uchun CAMERA va RECORD_AUDIO kerak bo'lganda birinchi ishga tushirishda qulay.

Birinchi rad etishni boshqarish

Agar foydalanuvchi so'rovni rad etgan bo'lsa, shouldShowRequestPermissionRationale metodi true qaytaradi. Bu ruxsat nima uchun kerakligini tushuntirishni ko'rsatish uchun signal. Eng yaxshi amaliyot — tushuntirish va Qayta urinish tugmasi bilan maxsus dialog ko'rsatish. Agar foydalanuvchi Never Ask Again belgisi bilan so'rovni qayta rad etgan bo'lsa, shouldShowRequestPermissionRationale false qaytaradi va Sozlamalarga yo'naltirish kerak.

Rad etish va Never Ask Again ni boshqarish

Never Ask Again — foydalanuvchi runtime dialogini qayta rad etishda o'rnatishi mumkin bo'lgan belgidir. Shundan so'ng standart dialog oynasi ushbu ruxsat uchun endi ko'rsatilmaydi. Kirishni ta'minlashning yagona yo'li — foydalanuvchini tizim ilova sozlamalariga yo'naltirish.

Dasturchi ikkita rad etish stsenariysini farqlashi kerak: birinchi — shouldShowRequestPermissionRationale true qaytarganda (foydalanuvchi rad etdi, lekin dialog hali ko'rsatilishi mumkin) va ikkinchi — metod false qaytarganda (Never Ask Again faol yoki ruxsat siyosat bilan bloklangan). Ikkinchi holatda Sozlamalarni ochish tugmasini ko'rsatish kerak.

fun handlePermissionDenied(permission: String) {
    if (ActivityCompat.shouldShowRequestPermissionRationale(
            this, permission
    )) {
        showRationaleDialog(permission)
    } else {
        showSettingsRedirectDialog(permission)
    }
}

private fun showSettingsRedirectDialog(permission: String) {
    AlertDialog.Builder(this)
        .setTitle("Ruxsat taqiqlangan")
        .setMessage(
            "Ruxsat bloklangan. Sozlamalarni oching."
        )
        .setPositiveButton("Sozlamalar") { _, _ ->
            val intent = Intent(
                Settings.ACTION_APPLICATION_DETAILS_SETTINGS,
                Uri.fromParts(
                    "package", packageName, null
                )
            )
            startActivity(intent)
        }
        .show()
}

shouldShowRequestPermissionRationale false qaytarganda ruxsatni qayta so'ramaslik muhim. Bu holda requestPermissions ni qayta chaqirish dialog ko'rsatmaydi — natija darhol tushuntirishsiz DENIED bilan keladi. Foydalanuvchi tushunarsiz xatti-harakatga duch keladi, bu ilovadan foydalanish tajribasiga salbiy ta'sir qiladi.