0Pricing
Android Academy · Aula

Permissões e Solicitações em Tempo de Execução

Declare e solicite permissões perigosas em tempo de execução usando ActivityResultContracts, mostre diálogos explicativos e trate recusas permanentes.

Permissões e Solicitações em Tempo de Execução é uma aula grátis de Android Academy no CoddyKit. Esta é a aula 7 de 7. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Android Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Android Academy inclui 7 aulas no total.

Visão geral das permissões do Android

Os aplicativos Android devem declarar quais recursos do dispositivo precisam. As permissões protegem a privacidade do usuário:

  • Permissões normais — baixo risco, concedidas automaticamente (INTERNET, VIBRATE)
  • Permissões perigosas — dão acesso a dados sensíveis e devem ser solicitadas durante a execução (CAMERA, LOCATION, READ_CONTACTS)
  • Permissões de assinatura — apenas para aplicativos assinados com o mesmo certificado

Declaração no Manifesto

Todas as permissões devem primeiro ser declaradas em 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>

Verificando se a permissão foi concedida

Antes de usar um recurso perigoso, verifique sempre se a permissão já foi concedida:

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
}

Solicitando permissão com ActivityResultLauncher

Use ActivityResultContracts.RequestPermission() — a forma moderna (sem o onRequestPermissionsResult obsoleto):

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

Várias permissões de uma vez

Solicite várias permissões com 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
    ))
}

Justificativa: quando explicar o motivo

shouldShowRequestPermissionRationale() retorna true quando o usuário negou a permissão anteriormente. Mostre uma explicação antes de solicitá-la novamente:

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

Negada permanentemente — enviar para as configurações

Se o usuário tocar em "Não perguntar novamente", shouldShowRequestPermissionRationale retornará false e você não poderá solicitar a permissão novamente. Direcione-o para as configurações do app:

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

Permissão de localização

A localização tem dois níveis — escolha o mais adequado ao seu caso de uso:

  • ACCESS_COARSE_LOCATION — precisão no nível da cidade (WiFi/torres de celular)
  • ACCESS_FINE_LOCATION — precisão do GPS
  • ACCESS_BACKGROUND_LOCATION — necessária separadamente no Android 10 ou superior para acessar a localização em segundo plano

Exemplo completo de permissão da câmera

Fluxo completo combinando verificação → justificativa → solicitação:

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

Boas práticas para permissões

Regras essenciais para uma experiência tranquila com permissões:

  • Solicite permissões somente quando forem necessárias (não ao iniciar o app)
  • Solicite apenas o mínimo de permissões necessárias
  • Sempre trate o caso de negação de forma adequada
  • Não solicite repetidamente após "Não perguntar novamente"
  • Explique o motivo antes da caixa de diálogo do sistema, não depois da negação

Permissões de mídia granulares no Android 13 ou superior

Desde o Android 13 (API 33), READ_EXTERNAL_STORAGE foi dividido em permissões granulares:

  • READ_MEDIA_IMAGES
  • READ_MEDIA_VIDEO
  • READ_MEDIA_AUDIO

Verifique sempre Build.VERSION.SDK_INT e solicite a permissão adequada para a versão do OS.

Verificação rápida

Quando você deve mostrar uma caixa de diálogo de justificativa antes de solicitar uma permissão perigosa?

Recapitulação: permissões

Permissões em tempo de execução feitas da maneira correta:

  • Declare em AndroidManifest.xml
  • Verifique com ContextCompat.checkSelfPermission()
  • Solicite por meio de registerForActivityResult(RequestPermission())
  • Mostre uma justificativa quando shouldShowRequestPermissionRationale() for true
  • Em caso de negação permanente, oriente os usuários até as configurações
  • Nunca solicite permissões antes de o usuário precisar delas

A seguir: salve dados localmente com DataStore.

Perguntas Frequentes

A aula “Permissões e Solicitações em Tempo de Execução” é grátis?

Sim — o texto completo de “Permissões e Solicitações em Tempo de Execução” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Android Academy, atualize para CoddyKit PRO. O curso de Android Academy inclui 7 aulas no total.

O que vou aprender em “Permissões e Solicitações em Tempo de Execução”?

Declare e solicite permissões perigosas em tempo de execução usando ActivityResultContracts, mostre diálogos explicativos e trate recusas permanentes. Você pratica Android Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Android Academy?

Nenhuma experiência prévia é necessária. Android Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 7 de 7.

Quanto tempo leva a aula “Permissões e Solicitações em Tempo de Execução”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Android Academy?

Sim. Cada aula de Android Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Estrutura do Projeto e Manifesto
  2. Activities e Ciclo de Vida
  3. Layouts e Views
  4. Tratamento da Entrada do Usuário
  5. Intents e Navegação
  6. Fragments
  7. Permissões e Solicitações em Tempo de Execução
← Voltar para Android Academy