Android Academy · Lektion

Behörigheter och begäranden under körning

Deklarera och begär känsliga behörigheter under körning med ActivityResultContracts, visa dialogrutor med motiveringar och hantera permanent nekade behörigheter.

Lektion 7 av 713 steg

Behörigheter och begäranden under körning är en gratis lektion i Android Academy på CoddyKit. Detta är lektion 7 av 7. Du kan läsa vilka 3 lektioner som helst i den här lärvägen kostnadsfritt i sin helhet – därefter låser CoddyKit PRO upp alla lektioner, plus praktisk övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Den ingår i lärvägen för Android Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Android Academy innehåller totalt 7 lektioner.

Översikt över Android-behörigheter

Android-appar måste deklarera vilka enhetsfunktioner de behöver. Behörigheter skyddar användarens integritet:

Normala behörigheter – låg risk, beviljas automatiskt (INTERNET, VIBRATE)
Känsliga behörigheter – ger åtkomst till känsliga data och måste begäras under körning (CAMERA, LOCATION, READ_CONTACTS)
Signaturbehörigheter – endast för appar som signerats med samma certifikat

Deklarera i manifestet

Alla behörigheter måste först deklareras i AndroidManifest.xml:

<!-- AndroidManifest.xml -->
<manifest ...>

    <!-- Normal: granted automatically -->
    <uses-permission android:name="android.permission.INTERNET" />
    <uses-permission android:name="android.permission.VIBRATE" />

    <!-- Dangerous: must request at runtime -->
    <uses-permission android:name="android.permission.CAMERA" />
    <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
    <uses-permission android:name="android.permission.READ_CONTACTS" />

    <application ...>
        ...
    </application>
</manifest>

Kontrollera om behörigheten har beviljats

Innan Ni använder en känslig funktion ska Ni alltid kontrollera om behörigheten redan har beviljats:

import androidx.core.content.ContextCompat
import android.content.pm.PackageManager

fun isCameraPermissionGranted(): Boolean {
    return ContextCompat.checkSelfPermission(
        this,   // Context
        android.Manifest.permission.CAMERA
    ) == PackageManager.PERMISSION_GRANTED
}

Begära behörighet med ActivityResultLauncher

Använd ActivityResultContracts.RequestPermission() — det moderna sättet (utan det föråldrade onRequestPermissionsResult):

class CameraActivity : AppCompatActivity() {

    private val requestCameraPermission = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { isGranted ->
        if (isGranted) {
            openCamera()
        } else {
            showPermissionDeniedMessage()
        }
    }

    fun onTakePhotoClick(view: View) {
        if (isCameraPermissionGranted()) {
            openCamera()
        } else {
            requestCameraPermission.launch(android.Manifest.permission.CAMERA)
        }
    }
}

Flera behörigheter samtidigt

Begär flera behörigheter med RequestMultiplePermissions:

private val requestMultiple = registerForActivityResult(
    ActivityResultContracts.RequestMultiplePermissions()
) { permissions ->
    val cameraGranted   = permissions[android.Manifest.permission.CAMERA] ?: false
    val locationGranted = permissions[android.Manifest.permission.ACCESS_FINE_LOCATION] ?: false

    if (cameraGranted && locationGranted) {
        startFeature()
    } else {
        showWhichPermissionsDenied(cameraGranted, locationGranted)
    }
}

fun requestPermissions() {
    requestMultiple.launch(arrayOf(
        android.Manifest.permission.CAMERA,
        android.Manifest.permission.ACCESS_FINE_LOCATION
    ))
}

Motivering: när ska Ni förklara varför?

shouldShowRequestPermissionRationale() returnerar true när användaren tidigare har nekat behörigheten. Visa en förklaring innan Ni begär den igen:

fun requestCameraWithRationale() {
    when {
        isCameraPermissionGranted() -> {
            openCamera()
        }
        shouldShowRequestPermissionRationale(android.Manifest.permission.CAMERA) -> {
            // Explain why we need it, then request
            AlertDialog.Builder(this)
                .setTitle("Camera needed")
                .setMessage("We use the camera to take profile photos.")
                .setPositiveButton("OK") { _, _ ->
                    requestCameraPermission.launch(android.Manifest.permission.CAMERA)
                }
                .show()
        }
        else -> {
            requestCameraPermission.launch(android.Manifest.permission.CAMERA)
        }
    }
}

Permanent nekad — skicka användaren till inställningarna

Om användaren trycker på "Fråga inte igen" returnerar shouldShowRequestPermissionRationale false, och Ni kan inte begära behörigheten igen. Hänvisa användaren till appens inställningar:

fun openAppSettings() {
    val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS).apply {
        data = Uri.fromParts("package", packageName, null)
    }
    startActivity(intent)
}

Platsbehörighet

Platsbehörighet finns på två nivåer — välj rätt nivå för Ert användningsfall:

ACCESS_COARSE_LOCATION — noggrannhet på stadsnivå (WiFi/mobilmaster)
ACCESS_FINE_LOCATION — GPS-noggrannhet
ACCESS_BACKGROUND_LOCATION — krävs separat från och med Android 10 för att få åtkomst till plats i bakgrunden

Fullständigt exempel på kamerabehörighet

Komplett flöde som kombinerar kontroll → motivering → begäran:

class PhotoActivity : AppCompatActivity() {

    private val cameraLauncher = registerForActivityResult(
        ActivityResultContracts.RequestPermission()
    ) { granted ->
        if (granted) openCamera() else showDenied()
    }

    private fun handleCameraClick() {
        val permission = android.Manifest.permission.CAMERA
        when {
            ContextCompat.checkSelfPermission(this, permission) ==
                    PackageManager.PERMISSION_GRANTED -> openCamera()
            shouldShowRequestPermissionRationale(permission) ->
                showRationaleDialog()
            else -> cameraLauncher.launch(permission)
        }
    }

    private fun showDenied() {
        Snackbar.make(binding.root, "Camera permission required", Snackbar.LENGTH_LONG)
            .setAction("Settings") { openAppSettings() }.show()
    }
}

Bästa praxis för behörigheter

Viktiga regler för en smidig hantering av behörigheter:

Begär behörigheter endast när de behövs (inte när appen startar)
Begär endast de behörigheter som krävs
Hantera alltid ett nekande på ett bra sätt
Fråga inte upprepade gånger efter "Fråga inte igen"
Förklara varför innan systemdialogrutan visas, inte efter ett nekande

Finkorniga mediebehörigheter i Android 13+

Sedan Android 13 (API 33) har READ_EXTERNAL_STORAGE delats upp i mer specifika behörigheter:

READ_MEDIA_IMAGES
READ_MEDIA_VIDEO
READ_MEDIA_AUDIO

Kontrollera alltid Build.VERSION.SDK_INT och begär rätt behörighet för operativsystemets version.

Snabb kontroll

När ska Ni visa en motiveringsdialog innan Ni begär en känslig behörighet?

Besvara frågan i den interaktiva lektionen

Sammanfattning: behörigheter

Korrekt hantering av körtidsbehörigheter:

Deklarera i AndroidManifest.xml
Kontrollera med ContextCompat.checkSelfPermission()
Begär via registerForActivityResult(RequestPermission())
Visa en motivering när shouldShowRequestPermissionRationale() är true
Hänvisa användaren till Inställningar vid ett permanent nekande
Begär aldrig behörigheter innan användaren behöver dem

Nästa steg: spara data lokalt med DataStore.

Gratis att börja

Lär dig Kotlin med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 36
Lektioner: 152

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Behörigheter och begäranden under körning” gratis?

Ja – du kan läsa vilka 3 lektioner som helst i lärvägen Android Academy, inklusive ”Behörigheter och begäranden under körning”, kostnadsfritt i sin helhet här på webben. Därefter låser CoddyKit PRO upp alla lektioner, plus interaktiv övning med en inbyggd kodredigerare och en AI-lärare dygnet runt. Kursen i Android Academy innehåller totalt 7 lektioner.

Vad lär jag mig i ”Behörigheter och begäranden under körning”?

Deklarera och begär känsliga behörigheter under körning med ActivityResultContracts, visa dialogrutor med motiveringar och hantera permanent nekade behörigheter. Ni övar på Android Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Android Academy?

Du behöver inga förkunskaper. Utbildningen i Android Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 7 av 7.

Hur lång tid tar lektionen ”Behörigheter och begäranden under körning”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Android Academy-lektionen?

Ja. Varje Android Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

Projektstruktur och manifest
Aktiviteter och livscykel
Layouter och vyer
Hantera användarinmatning
Intents och navigering
Fragments
Behörigheter och begäranden under körning

← Tillbaka till Android Academy