Arresti anomali

Un'app per Android si arresta in modo anomalo ogni volta che si verifica un'uscita imprevista causata da un'eccezione o un segnale non gestiti. Un'app scritta utilizzando Java o Kotlin va in arresto anomalo se genera un'eccezione non gestita, rappresentata dalla classe Throwable. Un'app scritta utilizzando il codice macchina o C++ si arresta in modo anomalo se durante l'esecuzione è presente un segnale non gestito, ad esempio SIGSEGV.

Quando un'app si arresta in modo anomalo, Android termina il processo dell'app e visualizza una finestra di dialogo per informare l'utente che l'app è stata interrotta, come mostrato nella figura 1.

Un arresto anomalo dell'app su un dispositivo Android
Figura 1. Un arresto anomalo dell'app su un dispositivo Android.

Un'app non deve essere necessariamente in esecuzione in primo piano per arrestarsi in modo anomalo. Qualsiasi componente dell'app, anche quelli come i broadcast receiver o i provider di contenuti in esecuzione in background, può causare l'arresto anomalo di un'app. Questi arresti anomali spesso confondono gli utenti perché non stavano interagendo attivamente con la tua app.

Se la tua app si arresta in modo anomalo, puoi utilizzare le indicazioni riportate in questa pagina per diagnosticare e risolvere il problema.

Diagnostica gli arresti anomali

Dopo aver identificato che la tua app segnala arresti anomali, il passaggio successivo è diagnosticarli. Risolvere gli arresti anomali può essere difficile. Tuttavia, se riesci a identificare la causa principale dell'arresto anomalo, molto probabilmente potrai trovare una soluzione.

Esistono molte situazioni che possono causare un arresto anomalo nell'app. Alcuni motivi sono ovvi, come il controllo di un valore null o di una stringa vuota, ma altri sono più impercettibili, come il passaggio di argomenti non validi a un'API o persino interazioni multithread complesse.

Gli arresti anomali su Android generano un'analisi dello stack, ovvero un'istantanea della sequenza di chiamate di funzione nidificate nel programma fino al momento in cui si è verificato l'arresto anomalo. Puoi visualizzare le analisi dello stack in caso di arresto anomalo in Android vitals.

Come leggere un'analisi dello stack

Il primo passaggio per correggere un arresto anomalo consiste nell'identificare il punto in cui si verifica. Puoi utilizzare l'analisi dello stack disponibile nei dettagli del report se utilizzi Play Console o l'output dello strumento logcat. Se non hai un'analisi dello stack disponibile, devi riprodurre l'arresto anomalo localmente, testando manualmente l'app o contattando gli utenti interessati, e riprodurlo utilizzando logcat.

La seguente traccia mostra un esempio di arresto anomalo di un'app scritta utilizzando Jetpack Compose:

--------- beginning of crash
AndroidRuntime: FATAL EXCEPTION: main
Process: com.android.developer.crashsample, PID: 3686
java.lang.NullPointerException
    at com.android.developer.crashsample.ComposableSingletons$MainActivityKt.lambda$0(MainActivity.kt:27)
    at androidx.compose.foundation.ClickableNode.handleUpEvent(Clickable.kt:958)
    at androidx.compose.foundation.ClickableNode.onPointerEvent-H0pRuoY(Clickable.kt:895)
    at androidx.compose.ui.input.pointer.Node.dispatchMainEventPass(HitPathTracker.kt:446)
    at androidx.compose.ui.input.pointer.HitPathTracker.dispatchChanges(HitPathTracker.kt:181)
    at androidx.compose.ui.input.pointer.PointerInputEventProcessor.process-BIzXfog(PointerInputEventProcessor.kt:118)
    at androidx.compose.ui.platform.AndroidComposeView.dispatchTouchEvent(AndroidComposeView.android.kt:2650)
    at android.view.ViewGroup.dispatchTouchEvent(ViewGroup.java:2969)
    at android.app.Activity.dispatchTouchEvent(Activity.java:4683)
    at android.os.Looper.loop(Looper.java:398)
    at android.app.ActivityThread.main(ActivityThread.java:9569)
    at java.lang.reflect.Method.invoke(Native Method)
    at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:918)

Un'analisi dello stack mostra due informazioni fondamentali per il debug di un arresto anomalo:

  • Il tipo di eccezione lanciata.
  • La sezione di codice in cui viene generata l'eccezione.

Il tipo di eccezione generata è in genere un indizio molto forte di ciò che è andato storto. Controlla se si tratta di un IOException, un OutOfMemoryError o altro e trova la documentazione relativa alla classe di eccezione.

La classe, il metodo, il file e il numero di riga del file di origine in cui viene generata l'eccezione vengono visualizzati nella seconda riga di un'analisi dello stack. Per ogni funzione chiamata, un'altra riga mostra il sito di chiamata precedente (chiamato frame dello stack).

Esaminando lo stack e il codice, potresti trovare un punto in cui viene passato un valore errato. Se il tuo codice non viene visualizzato nell'analisi dello stack, è probabile che da qualche parte tu abbia passato un parametro non valido a un'operazione asincrona. Spesso puoi capire cosa è successo esaminando ogni riga dell'analisi dello stack, trovando le classi API che hai utilizzato e verificando che i parametri che hai passato siano corretti e che tu abbia chiamato l'API da una posizione consentita.

Le analisi dello stack per le app con codice C e C++ funzionano in modo molto simile.

*** *** *** *** *** *** *** *** *** *** *** *** *** *** *** ***
Build fingerprint: 'google/foo/bar:10/123.456/78910:user/release-keys'
ABI: 'arm64'
Timestamp: 2020-02-16 11:16:31+0100
pid: 8288, tid: 8288, name: com.example.testapp  >>> com.example.testapp <<<
uid: 1010332
signal 11 (SIGSEGV), code 1 (SEGV_MAPERR), fault addr 0x0
Cause: null pointer dereference
    x0  0000007da81396c0  x1  0000007fc91522d4  x2  0000000000000001  x3  000000000000206e
    x4  0000007da8087000  x5  0000007fc9152310  x6  0000007d209c6c68  x7  0000007da8087000
    x8  0000000000000000  x9  0000007cba01b660  x10 0000000000430000  x11 0000007d80000000
    x12 0000000000000060  x13 0000000023fafc10  x14 0000000000000006  x15 ffffffffffffffff
    x16 0000007cba01b618  x17 0000007da44c88c0  x18 0000007da943c000  x19 0000007da8087000
    x20 0000000000000000  x21 0000007da8087000  x22 0000007fc9152540  x23 0000007d17982d6b
    x24 0000000000000004  x25 0000007da823c020  x26 0000007da80870b0  x27 0000000000000001
    x28 0000007fc91522d0  x29 0000007fc91522a0
    sp  0000007fc9152290  lr  0000007d22d4e354  pc  0000007cba01b640

backtrace:
  #00  pc 0000000000042f89  /data/app/com.example.testapp/lib/arm64/libexample.so (com::example::Crasher::crash() const)
  #01  pc 0000000000000640  /data/app/com.example.testapp/lib/arm64/libexample.so (com::example::runCrashThread())
  #02  pc 0000000000065a3b  /system/lib/libc.so (__pthread_start(void*))
  #03  pc 000000000001e4fd  /system/lib/libc.so (__start_thread)

Se non vedi informazioni a livello di classe e funzione nelle analisi dello stack native, potresti dover generare un file di simboli di debug nativi e caricarlo su Google Play Console. Per saperne di più, consulta Deoffusca le analisi dello stack in caso di arresto anomalo. Per informazioni generali sugli arresti anomali nativi, consulta Diagnostica degli arresti anomali nativi.

Suggerimenti per riprodurre un arresto anomalo

È possibile che tu non riesca a riprodurre il problema semplicemente avviando un emulatore o collegando il dispositivo al computer. Gli ambienti di sviluppo tendono ad avere più risorse, come larghezza di banda, memoria e spazio di archiviazione. Utilizza il tipo di eccezione per determinare quale potrebbe essere la risorsa scarsa o trovare una correlazione tra la versione di Android, il tipo di dispositivo o la versione della tua app.

Errori di memoria

Se hai un OutOfMemoryError, puoi creare un emulatore con una capacità di memoria ridotta per eseguire i test. La Figura 2 mostra le impostazioni di Gestione AVD in cui puoi controllare la quantità di memoria sul dispositivo.

Impostazione della memoria in Gestione AVD
Figura 2. Impostazione della memoria in Gestione AVD.

Eccezioni di networking

Poiché gli utenti entrano ed escono spesso dalla copertura della rete mobile o rete Wi-Fi, in un'applicazione le eccezioni di rete di solito non devono essere trattate come errori, ma piuttosto come normali condizioni operative che si verificano in modo imprevisto.

Se devi riprodurre un'eccezione di rete, ad esempio un'eccezione UnknownHostException, prova ad attivare la modalità aereo mentre la tua applicazione tenta di utilizzare la rete.

Un'altra opzione è ridurre la qualità della rete nell'emulatore scegliendo un'emulazione della velocità di rete, un ritardo di rete o entrambi. Puoi utilizzare le impostazioni Velocità e Latenza in Gestione AVD oppure puoi avviare l'emulatore con i flag -netdelay e -netspeed, come mostrato nell'esempio di riga di comando seguente:

emulator -avd [your-avd-image] -netdelay 20000 -netspeed gsm

Questo esempio imposta un ritardo di 20 secondi su tutte le richieste di rete e una velocità di caricamento e download di 14,4 Kbps. Per saperne di più sulle opzioni della riga di comando per l'emulatore, consulta Avvia l'emulatore dalla riga di comando.

Lettura con logcat

Una volta che riesci a riprodurre l'arresto anomalo, puoi utilizzare uno strumento come logcat per ottenere ulteriori informazioni.

L'output di logcat mostrerà gli altri messaggi di log che hai stampato, insieme ad altri provenienti dal sistema. Non dimenticare di disattivare eventuali istruzioni Log aggiuntive che hai aggiunto, perché la loro stampa spreca CPU e batteria mentre l'app è in esecuzione.

Evita gli arresti anomali causati da eccezioni di puntatore nullo

Le eccezioni di puntatore nullo (identificate dal tipo di errore di runtime NullPointerException) si verificano quando provi ad accedere a un oggetto nullo, in genere richiamando i suoi metodi o accedendo ai suoi membri. Le eccezioni di puntatore nullo sono la causa principale degli arresti anomali delle app su Google Play. Lo scopo di null è indicare che l'oggetto non è presente, ad esempio non è stato ancora creato o assegnato.

Per evitare eccezioni di puntatore nullo, devi assicurarti che i riferimenti agli oggetti con cui stai lavorando non siano nulli prima di chiamare i metodi su di essi o di tentare di accedere ai loro membri. Se il riferimento all'oggetto è null, gestisci questo caso in modo appropriato (ad esempio, esci da un metodo prima di eseguire qualsiasi operazione sul riferimento all'oggetto e scrivi le informazioni in un log di debug).

Poiché non vuoi eseguire controlli dei valori null per ogni parametro di ogni metodo chiamato, puoi fare affidamento sull'IDE o sul tipo di oggetto per indicare il supporto di valori null.

Kotlin

In Kotlin, la nullabilità fa parte del sistema di tipi. Ad esempio, una variabile deve essere dichiarata fin dall'inizio come nullable o non nullable. I tipi che ammettono valori null sono contrassegnati con ?:

// non-null
var s: String = "Hello"

// null
var s: String? = "Hello"

Alle variabili non nullable non è possibile assegnare un valore null, mentre le variabili nullable devono essere controllate per il supporto di valori null prima di essere utilizzate come non null.

Se non vuoi verificare esplicitamente la presenza di valori null, puoi utilizzare l'operatore di chiamata sicura ?.:

val length: Int? = string?.length  // length is a nullable int
                                   // if string is null, then length is null

Come best practice, assicurati di gestire il caso null per un oggetto nullable, altrimenti la tua app potrebbe entrare in stati imprevisti. Se l'applicazione non si arresta più in modo anomalo con NullPointerException, non saprai che questi errori esistono.

Di seguito sono riportati alcuni modi per verificare la presenza di valori null:

  • if controlli

    val length = if(string != null) string.length else 0
    

    Grazie allo smart cast e al controllo dei valori null, il compilatore Kotlin sa che il valore della stringa non è null, quindi ti consente di utilizzare direttamente il riferimento, senza dover utilizzare l'operatore di chiamata sicura.

  • ?: Operatore Elvis

    Questo operatore ti consente di indicare "se l'oggetto non è nullo, restituisci l'oggetto; altrimenti, restituisci qualcos'altro".

    val length = string?.length ?: 0
    

Puoi comunque ottenere un NullPointerException in Kotlin. Di seguito sono riportate le situazioni più comuni:

  • Quando generi esplicitamente un NullPointerException.
  • Quando utilizzi l'operatore di asserzione null !!. Questo operatore converte qualsiasi valore in un tipo non null, generando NullPointerException se il valore è null.
  • Quando si accede a un riferimento null di un tipo di piattaforma.

Tipi di piattaforma

I tipi di piattaforma sono dichiarazioni di oggetti provenienti da Java. Questi tipi vengono trattati in modo speciale; i controlli null non vengono applicati in modo rigoroso, quindi la garanzia non null è la stessa di Java. Quando accedi a un riferimento di tipo piattaforma, Kotlin non genera errori in fase di compilazione, ma questi riferimenti possono causare errori di runtime. Guarda il seguente esempio tratto dalla documentazione di Kotlin:

val list = ArrayList<String>() // non-null (constructor result) list.add("Item")
val size = list.size // non-null (primitive int) val item = list[0] // platform
type inferred (ordinary Java object) item.substring(1) // allowed, may throw an
                                                       // exception if item == null

Kotlin si basa sull'inferenza del tipo quando un valore della piattaforma viene assegnato a una variabile Kotlin oppure puoi definire il tipo previsto. Il modo migliore per garantire lo stato di nullabilità corretto di un riferimento proveniente da Java è utilizzare le annotazioni di nullabilità (ad esempio @Nullable) nel codice Java. Il compilatore Kotlin rappresenterà questi riferimenti come tipi effettivi nullable o non nullable, non come tipi di piattaforma.

Le API Java Jetpack sono state annotate con @Nullable o @NonNull, a seconda delle necessità, e un approccio simile è stato adottato nell'SDK Android 11. I tipi provenienti da questo SDK, utilizzati in Kotlin, verranno rappresentati come tipi nullable o non nullable corretti.

Il sistema di tipi di Kotlin riduce notevolmente gli arresti anomali di NullPointerException. Ad esempio, l'app Google Home ha registrato una riduzione del 30% degli arresti anomali causati da eccezioni di puntatore nullo durante l'anno in cui ha eseguito la migrazione dello sviluppo di nuove funzionalità a Kotlin.