Questa pagina è stata tradotta dall'API Cloud Translation.

Ricevi report sugli arresti anomali NDK di Android

Se la tua app per Android contiene librerie native: puoi abilitare analisi complete dello stack e report dettagliati sugli arresti anomali per il codice nativo da Firebase Crashlytics con alcuni piccoli aggiornamenti alla build della tua app configurazione.

Questa guida descrive come configurare i report sugli arresti anomali con SDK Firebase Crashlytics per NDK.

Se stai cercando come iniziare a utilizzare Crashlytics nel tuo account Unity per i tuoi progetti, consulta Guida introduttiva di Unity.

Prima di iniziare

Se non l'hai già fatto, aggiungi Firebase al tuo account Android. progetto. Se non hai un'app Android, puoi scaricare Un'app di esempio.
Consigliato: per visualizzare automaticamente log breadcrumb per comprendere le azioni degli utenti che hanno portato a un evento di arresto anomalo, non irreversibile o ANR. devi abilitare Google Analytics nel tuo progetto Firebase.
- Se il tuo progetto Firebase esistente non ha Google Analytics attivata, puoi attivare Google Analytics dalla Integrazioni dei tuoi > Impostazioni progetto nella console Firebase.
- Se stai creando un nuovo progetto Firebase, abilita Google Analytics durante il flusso di lavoro di creazione del progetto.
Assicurati che la tua app abbia le seguenti versioni minime richieste:
- Gradle 8.0
- Plug-in Android per Gradle 8.1.0
- Plug-in Gradle dei servizi Google 4.4.1

Passaggio 1: aggiungi l'SDK Crashlytics per NDK alla tua app

Nel file Gradle del modulo (a livello di app) (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi la dipendenza per la libreria NDK Crashlytics per Android. Ti consigliamo di utilizzare Firebase Android BoM per controllare la gestione delle versioni delle librerie.

Per un'esperienza ottimale con Crashlytics, ti consigliamo di attivare Google Analytics nel tuo progetto Firebase e di aggiungere l'SDK Firebase per Google Analytics alla tua app.

dependencies {
    // Import the BoM for the Firebase platform
    implementation(platform("com.google.firebase:firebase-bom:33.3.0"))

    // Add the dependencies for the Crashlytics NDK and Analytics libraries
    // When using the BoM, you don't specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-crashlytics-ndk")
    implementation("com.google.firebase:firebase-analytics")
}

Se utilizzi Firebase Android BoM, la tua app utilizzerà sempre versioni compatibili delle librerie Firebase Android.

(alternativa) Aggiungi dipendenze della libreria Firebase senza utilizzare il BoM

Se scegli di non utilizzare Firebase BoM, devi specificare ogni versione della libreria Firebase nella sua linea di dipendenza.

Tieni presente che se nella tua app utilizzi più librerie Firebase, ti consigliamo vivamente di utilizzare BoM per gestire le versioni delle librerie, in modo da garantire la compatibilità di tutte le versioni.

dependencies {
    // Add the dependencies for the Crashlytics NDK and Analytics libraries
    // When NOT using the BoM, you must specify versions in Firebase library dependencies
    implementation("com.google.firebase:firebase-crashlytics-ndk:19.1.0")
    implementation("com.google.firebase:firebase-analytics:22.1.0")
}

Cerchi un modulo della libreria specifico per Kotlin? A partire da ottobre 2023 (Firebase BoM 32.5.0), sia gli sviluppatori Kotlin sia quelli Java possono fare affidamento sul modulo della libreria principale (per maggiori dettagli, consulta le domande frequenti su questa iniziativa).

Passaggio 2: aggiungi il plug-in Crashlytics Gradle alla tua app

Nel file Gradle a livello principale (a livello di progetto) (<project>/build.gradle.kts o <project>/build.gradle), aggiungi il Plug-in Crashlytics Gradle per il blocco plugins:

Kotlin

Stai ancora utilizzando buildscript la sintassi? Scopri come aggiungi plug-in Firebase utilizzando questa sintassi.

plugins {
    // Make sure that you have the AGP plugin 8.1+ dependency
    id("com.android.application") version "8.1.4" apply false
    // ...

    // Make sure that you have the Google services Gradle plugin 4.4.1+ dependency
    id("com.google.gms.google-services") version "4.4.2" apply false

    // Add the dependency for the Crashlytics Gradle plugin
    id("com.google.firebase.crashlytics") version "3.0.2" apply false
}

Groovy

Stai ancora utilizzando buildscript la sintassi? Scopri come aggiungi plug-in Firebase utilizzando questa sintassi.

plugins {
    // Make sure that you have the AGP plugin 8.1+ dependency
    id 'com.android.application' version '8.1.4' apply false
    // ...

    // Make sure that you have the Google services Gradle plugin 4.4.1+ dependency
    id 'com.google.gms.google-services' version '4.4.2' apply false

    // Add the dependency for the Crashlytics Gradle plugin
    id 'com.google.firebase.crashlytics' version '3.0.2' apply false
}

Nel file Gradle del modulo (a livello di app) (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), aggiungi il plug-in Crashlytics Gradle:

Kotlin

plugins {
  id("com.android.application")
  // ...

  // Make sure that you have the Google services Gradle plugin
  id("com.google.gms.google-services")

  // Add the Crashlytics Gradle plugin
  id("com.google.firebase.crashlytics")
}

Groovy

plugins {
  id 'com.android.application'
  // ...

  // Make sure that you have the Google services Gradle plugin
  id 'com.google.gms.google-services'

  // Add the Crashlytics Gradle plugin
  id 'com.google.firebase.crashlytics'
}

Passaggio 3: aggiungi l'estensione Crashlytics alla tua build

Nel file Gradle del modulo (a livello di app) (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle), configura l'estensione Crashlytics.

Kotlin

import com.google.firebase.crashlytics.buildtools.gradle.CrashlyticsExtension

// ...

android {
  // ...
  buildTypes {
      getByName("release") {
          // Add this extension
          configure<CrashlyticsExtension> {
              // Enable processing and uploading of native symbols to Firebase servers.
              // By default, this is disabled to improve build speeds.
              // This flag must be enabled to see properly-symbolicated native
              // stack traces in the Crashlytics dashboard.
              nativeSymbolUploadEnabled = true
          }
      }
  }
}

Groovy

// ...

android {
  // ...
  buildTypes {
      release {
          // Add this extension
          firebaseCrashlytics {
              // Enable processing and uploading of native symbols to Firebase servers.
              // By default, this is disabled to improve build speeds.
              // This flag must be enabled to see properly-symbolicated native
              // stack traces in the Crashlytics dashboard.
              nativeSymbolUploadEnabled true
          }
      }
  }
}

Passaggio 4: configura il caricamento automatico dei simboli nativi

Per generare analisi dello stack leggibili dagli arresti anomali NDK, Crashlytics deve conoscere sui simboli nei tuoi file binari nativi. Il Crashlytics plug-in Gradle include il compito uploadCrashlyticsSymbolFileBUILD_VARIANT per automatizzare questo processo.

Per poter accedere all'attività per il caricamento automatico dei simboli, assicurati che nativeSymbolUploadEnabled sia impostato su true nel tuo modulo (a livello di app) file Gradle.
Affinché i nomi dei metodi vengano visualizzati nelle analisi dello stack, devi richiamare esplicitamente uploadCrashlyticsSymbolFileBUILD_VARIANT dopo ogni build della libreria NDK. Ad esempio:
```
>./gradlew app:assembleBUILD_VARIANT\
           app:uploadCrashlyticsSymbolFileBUILD_VARIANT
```
Sia l'SDK Crashlytics per NDK sia il plug-in Gradle Crashlytics dipendono dalla presenza dell'ID build GNU all'interno degli oggetti nativi condivisi.

Puoi verificare la presenza di questo ID eseguendo readelf -n su ogni programma binario. Se l'ID build è assente, aggiungi -Wl,--build-id alla riga del sistema di compilazione per risolvere il problema.

Passaggio 5: forza un arresto anomalo di test per completare la configurazione

Per completare la configurazione di Crashlytics e visualizzare i dati iniziali nel Dashboard Crashlytics della console Firebase, devi forzare un test in modo anomalo.

Aggiungi alla tua app del codice che puoi utilizzare per forzare un arresto anomalo del test.

Puoi utilizzare il seguente codice in MainActivity dell'app per aggiungere un pulsante all'app che, se premuto, causa un arresto anomalo. Il pulsante è etichettato come "Test di arresto anomalo".

Kotlin+KTX

val crashButton = Button(this)
crashButton.text = "Test Crash"
crashButton.setOnClickListener {
   throw RuntimeException("Test Crash") // Force a crash
}

addContentView(crashButton, ViewGroup.LayoutParams(
       ViewGroup.LayoutParams.MATCH_PARENT,
       ViewGroup.LayoutParams.WRAP_CONTENT))

Java

Button crashButton = new Button(this);
crashButton.setText("Test Crash");
crashButton.setOnClickListener(new View.OnClickListener() {
   public void onClick(View view) {
       throw new RuntimeException("Test Crash"); // Force a crash
   }
});

addContentView(crashButton, new ViewGroup.LayoutParams(
       ViewGroup.LayoutParams.MATCH_PARENT,
       ViewGroup.LayoutParams.WRAP_CONTENT));

Crea ed esegui la tua app.
Forza l'arresto anomalo di test per inviare il primo report sugli arresti anomali della tua app:
1. Apri l'app dal dispositivo di test o dall'emulatore.
2. Nell'app, premi il pulsante "Test arresto anomalo" che hai aggiunto utilizzando il codice in alto.
3. Dopo l'arresto anomalo dell'app, riavviala in modo che possa inviare l'arresto anomalo a Firebase.
Vai alla dashboard di Crashlytics del Console Firebase per vedere l'arresto anomalo del test.

Se hai aggiornato la console e ancora non vedi l'arresto anomalo del test dopo cinque minuti, attivare il logging di debug per controllare se la tua app invia report sugli arresti anomali.

E questo è tutto. Crashlytics sta ora monitorando la tua app per verificare la presenza di arresti anomali e tu possono visualizzare ed esaminare i report sugli arresti anomali e le statistiche nel dashboard Crashlytics.

Passaggi successivi

(Consigliato) Assistenza per il debug degli arresti anomali causati da errori di memoria nativi di raccolta Report GWP-ASan. Questi errori relativi alla memoria possono essere associati a un danneggiamento della memoria dell'app, che è la causa principale di vulnerabilità di sicurezza delle app. Per sfruttare questa funzione di debug, assicurati che la tua app abbia GWP-ASan esplicitamente abilitato e utilizza l'SDK Crashlytics più recente per NDK (v18.3.6+ o Firebase BoM versione 31.3.0 e successive).
Personalizza configurazione dei report sugli arresti anomali aggiungendo report di attivazione, log, chiavi il monitoraggio di errori non irreversibili.
Eseguire l'integrazione con Google Play in modo che puoi filtrare i report sugli arresti anomali della tua app per Android per Google Play traccia direttamente nel dashboard Crashlytics. In questo modo, puoi concentrare meglio la dashboard su build specifiche.

Risoluzione dei problemi

Se visualizzi analisi dello stack diverse nella console Firebase e del logcat, consulta la Guida alla risoluzione dei problemi.

Opzioni alternative per il caricamento di simboli

Il flusso di lavoro principale in questa pagina è applicabile alle build Gradle standard. Tuttavia, alcune app utilizzano una configurazione o strumenti diversi (ad esempio diverso da Gradle). In questi casi, è possibile che le seguenti opzioni siano utile per caricare correttamente i simboli.

Opzione: carica i simboli per i moduli della libreria e le dipendenze esterne

Questa opzione può essere utile nelle seguenti situazioni:

Se utilizzi un processo di compilazione NDK personalizzato all'interno di Gradle
Se le tue librerie native sono create in un modulo libreria/funzionalità o fornite da una terza parte
Se l'attività di caricamento automatico del simbolo non funziona o nella dashboard vengono visualizzati arresti anomali non simbolizzati

Visualizza le istruzioni per questa opzione

L'attività di caricamento di simboli Crashlytics standard presuppone che tu stia creando le tue librerie native come parte della build Gradle del modulo della tua app, utilizzando di sviluppo NDK come CMake.

Tuttavia, se utilizzi un processo di compilazione NDK personalizzato all'interno di Gradle, Le librerie native sono create in un modulo libreria/funzionalità o fornite da un terze parti, è possibile che tu debba specificare in modo esplicito il percorso del file librerie. A questo scopo, puoi aggiungere unstrippedNativeLibsDir all'interno dell'estensione Crashlytics del file di build Gradle.

Assicurati di aver completato le seguenti attività iniziali dal questo flusso di lavoro.

Affinché l'attività di caricamento automatico dei simboli possa trovare il tuo simbolo informazioni, aggiungi quanto segue al file Gradle del modulo (a livello di app) (di solito <project>/<app-module>/build.gradle.kts o <project>/<app-module>/build.gradle):

Kotlin

import com.google.firebase.crashlytics.buildtools.gradle.CrashlyticsExtension

// ...

android {
    // ...
    buildTypes {
        release {
            configure<CrashlyticsExtension> {
                nativeSymbolUploadEnabled = true
                unstrippedNativeLibsDir = file("PATH/TO/UNSTRIPPED/DIRECTORY")
            }
        }
    }
}

Groovy

// ...

android {
    // ...
    buildTypes {
        release {
            firebaseCrashlytics {
                nativeSymbolUploadEnabled true
                unstrippedNativeLibsDir file("PATH/TO/UNSTRIPPED/DIRECTORY")
            }
        }
    }
}

Il plug-in Crashlytics eseguirà una ricerca ricorsiva nella directory specificata per le librerie native con estensione .so. Crashlytics poi estrae eseguire il debug dei simboli da tutte queste librerie e caricarli in Firebase server web.

Ecco cosa puoi specificare nella proprietà unstrippedNativeLibsDir:

Qualsiasi argomento consentito per org.gradle.api.Project#files(Object...), tra cui: java.lang.String, java.io.File, oppure org.gradle.api.file.FileCollection
Più directory per una singola versione di build fornendo un elenco o FileCollection istanza
(A partire dal plug-in Gradle Crashlytics v3.0.0) Accumula più in singoli prodotti e creare versioni.

Visualizza un esempio con più directory

  buildTypes {
    release {
      configure<CrashlyticsExtension> {
        nativeSymbolUploadEnabled = true
        unstrippedNativeLibsDir = file("MY/NATIVE/LIBS")
      }
    }
    productFlavors {
      flavorDimensions += "feature"
      create("basic") {
        dimension = "feature"
        // ...
      }
      create("featureX") {
        dimension = "feature"
        configure<CrashlyticsExtension> {
          unstrippedNativeLibsDir = file("MY/FEATURE_X/LIBS")
        }
      }
    }
  }

L'attività uploadCrashlyticsSymbolFilesBasicRelease caricherà solo simboli in MY/NATIVE/LIBS, ma uploadCrashlyticsSymbolFilesFeatureXRelease caricherà simboli in entrambi MY/NATIVE/LIBS e MY/FEATURE_X/LIBS.

Infine, forza un arresto anomalo di test per completare la configurazione. Crashlytics e per visualizzare i dati iniziali nella dashboard Crashlytics di nella console Firebase.

Opzione: carica simboli per build non di Gradle o librerie native inaccessibili senza striping

Questa opzione può essere utile nelle seguenti situazioni:

Se utilizzi un processo di compilazione diverso da Gradle
Se le librerie native con cui è stato eseguito il debug ti vengono fornite in qualche modo non sono accessibili durante le build di Gradle

Visualizza le istruzioni per questa opzione

Questa opzione richiede l'esecuzione di un comando Firebase CLI quando crei una release build o qualsiasi build per la quale vuoi visualizzare le tracce dello stack simboliche nella console Firebase.

Assicurati di aver completato le seguenti attività iniziali del flusso di lavoro principale all'inizio di questa pagina:
1. Crashlytics abilitato nella console Firebase.
2. È stato aggiunto il SDK Crashlytics per NDK e Crashlytics Plug-in Gradle.
Tieni presente che con questa opzione non è necessario aggiungere firebaseCrashlytics o configurare il caricamento automatico di simboli perché utilizzerai invece l'interfaccia a riga di comando Firebase (passaggi successivi di seguito) per generare e caricare il tuo simbolo .
Configura l'ambiente e il progetto per il caricamento dei simboli:
1. Segui le istruzioni per installare l'interfaccia a riga di comando Firebase.
  
  Se hai già installato l'interfaccia a riga di comando, assicurati di esegui l'aggiornamento all'ultima versione.
2. (solo per le app che utilizzano il livello API Android 30 o versioni successive) Aggiorna la versione dell'app AndroidManifest.xml modello per disattivare il tagging dei puntatore:
  1. Seleziona la casella per Impostazioni di Android Player > Impostazioni di pubblicazione > Crea > Manifest principale personalizzato.
  2. Apri il modello manifest in Assets/Plugins/Android/AndroidManifest.xml.
  3. Aggiungi il seguente attributo al tag dell'applicazione: <application android:allowNativeHeapPointerTagging="false" ... />
Crea il tuo progetto.

Carica le informazioni sui simboli.

Al termine della compilazione, genera un file di simboli compatibile con Crashlytics e caricalo sui server Firebase eseguendo il seguente comando Firebase CLI:

firebase crashlytics:symbols:upload --app=FIREBASE_APP_ID PATH/TO/SYMBOLS

FIREBASE_APP_ID: il tuo ID app Firebase per Android (non il nome del pacchetto)
Esempio di ID app Firebase per Android: 1:567383003300:android:17104a2ced0c9b9b
Devi trovare il tuo ID app Firebase?
Ecco due modi per trovare il tuo ID app Firebase:
- Nel file google-services.json, l'ID app è il valore mobilesdk_app_id.
- Nella console Firebase, vai a Impostazioni progetto. Scorri verso il basso fino alla scheda Le tue app, quindi fai clic sull'elemento Firebase che ti interessa. per trovare il relativo ID.
PATH/TO/SYMBOLS: il percorso del file di simboli generato dall'interfaccia a riga di comando
- Esportato in un progetto Android Studio: PATH/TO/SYMBOLS può essere qualsiasi directory. Interfaccia a riga di comando Firebase cercherà in modo ricorsivo le librerie native nella directory specificata con un'estensione .so.
- Hai creato l'APK direttamente all'interno di Unity: PATH/TO/SYMBOLS è il percorso del file di simboli compresso generati nella directory radice del progetto al termine della build (ad esempio: myproject/myapp-1.0-v100.symbols.zip).

Visualizza le opzioni avanzate per l'utilizzo del Comando dell'interfaccia a riga di comando Firebase per la generazione e il caricamento del file di simboli

Bandiera	Descrizione
`--generator=csym`	Utilizza il generatore di file di simboli cSYM legacy al posto del Generatore di Breakpad predefinito Non consigliato per l'uso. Ti consigliamo di utilizzare il valore predefinito Generatore di file di simboli di blocco di emergenza.
`--generator=breakpad`	Utilizza il generatore di file di simboli di Breakpad Tieni presente che l'impostazione predefinita per la generazione dei file di simboli è Breakpad. Utilizza questo flag solo se hai aggiunto `symbolGenerator { csym() }` nella configurazione di compilazione e vuoi sostituirlo per utilizzare Breakpad.
`--dry-run`	Genera i file di simboli ma non li carica Questo flag è utile se vuoi esaminare i contenuti che vengono inviati.
`--debug`	Fornisce ulteriori informazioni di debug

Infine, forza un arresto anomalo di test per completare la configurazione. Crashlytics e per visualizzare i dati iniziali nella dashboard Crashlytics di nella console Firebase.

Dopo aver creato l'app per forzare un arresto anomalo, assicurati di eseguire Comando crashlytics:symbols:upload dell'interfaccia a riga di comando Firebase per caricare il simbolo .