Android Academy · Lektion

Berechtigungen und Laufzeitanfragen

Deklarieren und beantragen Sie gefährliche Berechtigungen zur Laufzeit mit ActivityResultContracts, zeigen Sie Begründungsdialoge an und behandeln Sie dauerhafte Ablehnungen.

Berechtigungen und Laufzeitanfragen ist eine kostenlose Android Academy-Lektion auf CoddyKit. Dies ist Lektion 7 von 7. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Android Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Android Academy-Kurs umfasst insgesamt 7 Lektionen.

Überblick über Android-Berechtigungen

Android-Apps müssen angeben, welche Gerätefunktionen sie benötigen. Berechtigungen schützen die Privatsphäre der Benutzer:

Normale Berechtigungen – geringes Risiko, werden automatisch erteilt (INTERNET, VIBRATE)
Gefährliche Berechtigungen – ermöglichen den Zugriff auf sensible Daten und müssen zur Laufzeit angefordert werden (CAMERA, LOCATION, READ_CONTACTS)
Signaturberechtigungen – nur für Apps, die mit demselben Zertifikat signiert sind

Deklaration im Manifest

Alle Berechtigungen müssen zunächst in AndroidManifest.xml deklariert werden:

<!-- 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>

Prüfen, ob eine Berechtigung erteilt wurde

Bevor Sie eine geschützte Funktion verwenden, prüfen Sie immer, ob die Berechtigung bereits erteilt wurde:

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
}

Berechtigung mit ActivityResultLauncher anfordern

Verwenden Sie ActivityResultContracts.RequestPermission() – die moderne Variante (ohne die veraltete Methode 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)
        }
    }
}

Mehrere Berechtigungen gleichzeitig

Fordern Sie mehrere Berechtigungen mit RequestMultiplePermissions an:

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
    ))
}

Begründung: Wann Sie den Grund erklären sollten

shouldShowRequestPermissionRationale() gibt true zurück, wenn der Benutzer die Berechtigung zuvor abgelehnt hat. Zeigen Sie eine Erklärung an, bevor Sie die Berechtigung erneut anfordern:

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)
        }
    }
}

Dauerhaft abgelehnt – zu den Einstellungen weiterleiten

Wenn der Benutzer auf „Nicht mehr fragen“ tippt, gibt shouldShowRequestPermissionRationale false zurück und Sie können die Berechtigung nicht erneut anfordern. Leiten Sie den Benutzer zu den App-Einstellungen weiter:

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

Standortberechtigung

Für den Standort gibt es zwei Genauigkeitsstufen – wählen Sie die passende für Ihren Anwendungsfall:

ACCESS_COARSE_LOCATION – Genauigkeit auf Stadtebene (WLAN/Mobilfunkmasten)
ACCESS_FINE_LOCATION – GPS-Genauigkeit
ACCESS_BACKGROUND_LOCATION – ab Android 10 separat erforderlich, um im Hintergrund auf den Standort zuzugreifen

Vollständiges Beispiel für eine Kameraberechtigung

Vollständiger Ablauf mit Prüfung → Begründung → Anforderung:

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()
    }
}

Bewährte Vorgehensweisen für Berechtigungen

Wichtige Regeln für einen reibungslosen Umgang mit Berechtigungen:

Fordern Sie Berechtigungen nur an, wenn sie benötigt werden (nicht beim Start der App)
Fordern Sie nur die mindestens erforderlichen Berechtigungen an
Behandeln Sie eine Ablehnung immer angemessen
Fragen Sie nach „Nicht mehr fragen“ nicht wiederholt nach
Erklären Sie den Grund vor dem Systemdialog, nicht erst nach der Ablehnung

Feingranulare Medienberechtigungen ab Android 13

Seit Android 13 (API 33) ist READ_EXTERNAL_STORAGE in detaillierte Berechtigungen aufgeteilt:

READ_MEDIA_IMAGES
READ_MEDIA_VIDEO
READ_MEDIA_AUDIO

Prüfen Sie immer Build.VERSION.SDK_INT und fordern Sie die für die jeweilige Betriebssystemversion passende Berechtigung an.

Kurze Überprüfung

Wann sollten Sie vor dem Anfordern einer geschützten Berechtigung einen Begründungsdialog anzeigen?

Zusammenfassung: Berechtigungen

Laufzeitberechtigungen richtig verwenden:

In AndroidManifest.xml deklarieren
Mit ContextCompat.checkSelfPermission() prüfen
Über registerForActivityResult(RequestPermission()) anfordern
Eine Begründung anzeigen, wenn shouldShowRequestPermissionRationale() true ist
Bei einer dauerhaften Ablehnung den Benutzer zu den Einstellungen führen
Berechtigungen niemals anfordern, bevor der Benutzer sie benötigt

Als Nächstes: Daten mit DataStore lokal speichern.

Häufig gestellte Fragen

Ist die Lektion „Berechtigungen und Laufzeitanfragen“ kostenlos?

Ja — der vollständige Text von „Berechtigungen und Laufzeitanfragen“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Android Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Android Academy-Kurs umfasst insgesamt 7 Lektionen.

Was lerne ich in „Berechtigungen und Laufzeitanfragen“?

Deklarieren und beantragen Sie gefährliche Berechtigungen zur Laufzeit mit ActivityResultContracts, zeigen Sie Begründungsdialoge an und behandeln Sie dauerhafte Ablehnungen. Du übst Android Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Android Academy zu starten?

Keine Vorkenntnisse erforderlich. Android Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 7 von 7.

Wie lange dauert die Lektion „Berechtigungen und Laufzeitanfragen“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Android Academy-Lektion Code schreiben und ausführen?

Ja. Jede Android Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu Android Academy