Google utilizza la tecnologia AI per tradurre i contenuti nella tua lingua preferita. Le traduzioni generate dall'AI potrebbero contenere errori.

Inizia a utilizzare Crashlytics per Android NDK

Seleziona la piattaforma:

iOS+ Android Android NDK Flutter Unity

Se utilizzi librerie native nella tua app per Android, puoi attivare analisi dello stack complete e Crash Reporting dettagliati per il tuo codice nativo da Firebase Crashlytics con alcuni piccoli aggiornamenti alla configurazione di compilazione dell'app.

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

Se vuoi scoprire come iniziare a utilizzare Crashlytics nei tuoi progetti Unity, consulta la Guida introduttiva di Unity.

Prima di iniziare

Se non l'hai già fatto, aggiungi Firebase al tuo progetto Android. Se non hai un'app per Android, puoi scaricare un'app di esempio.
Consigliato: per ricevere automaticamente i log dei breadcrumb per comprendere le azioni degli utenti che hanno portato a un evento di arresto anomalo, non irreversibile o ANR, devi attivare Google Analytics nel tuo progetto Firebase.
- Se generi un nuovo progetto Firebase, abilita Google Analytics durante il flusso di lavoro di creazione del progetto.
- Se utilizzi un progetto Firebase esistente in cui non è abilitato Google Analytics, puoi attivarlo nella pagina Impostazioni > Integrazioni della console Firebase.
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 per i 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 la Firebase Android BoM per controllare il controllo delle versioni della libreria.

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:35.0.2"))

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

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

(Alternativa) Aggiungi le dipendenze della libreria Firebase senza utilizzare BoM

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

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

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:21.0.0")
    implementation("com.google.firebase:firebase-analytics:24.0.0")
}

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

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

Kotlin

Stai ancora utilizzando la sintassi buildscript? Scopri come aggiungere 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.5.0" apply false

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

Groovy

Stai ancora utilizzando la sintassi buildscript? Scopri come aggiungere 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.5.0' apply false

    // Add the dependency for the Crashlytics Gradle plugin
    id 'com.google.firebase.crashlytics' version '3.0.8' 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 Gradle Crashlytics:

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 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 produrre analisi dello stack leggibili dagli arresti anomali dell'NDK, Crashlytics deve conoscere i simboli nei tuoi file binari nativi. Il plug-in Gradle Crashlytics include l'attività 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 file Gradle del modulo (a livello di app).
Affinché i nomi dei metodi vengano visualizzati nelle analisi dello stack, devi richiamare esplicitamente l'attività 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 condivisi nativi.

Puoi verificare la presenza di questo ID eseguendo readelf -n su ogni programma binario. Se l'ID build non è presente, aggiungi -Wl,--build-id ai flag del sistema di build 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 nella dashboard Crashlytics della console Firebase, devi forzare un arresto anomalo di test.

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

Puoi utilizzare il seguente codice nel file MainActivity della tua app per aggiungere un pulsante che, se premuto, causa un arresto anomalo. Il pulsante è etichettato "Test Crash".

Kotlin

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 Crash" che hai aggiunto utilizzando il codice riportato sopra.
3. Dopo l'arresto anomalo, riavvia l'app in modo che possa inviare il report sugli arresti anomali a Firebase.
Nella console Firebase, vai alla dashboard DevOps e coinvolgimento > Crashlytics per verificare la presenza del report sugli arresti anomali di test.

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

E questo è tutto. Crashlytics ora monitora la tua app per rilevare eventuali arresti anomali e puoi visualizzare ed esaminare i report e le statistiche sugli arresti anomali nella dashboard di Crashlytics.

Passaggi successivi

(Consigliato) Ricevi assistenza per il debug degli arresti anomali causati da errori di memoria nativi raccogliendo i report GWP-ASan. Questi errori relativi alla memoria possono essere associati al danneggiamento della memoria all'interno della tua app, che è la causa principale delle vulnerabilità di sicurezza delle app. Per usufruire di questa funzionalità di debug, assicurati che la tua app abbia GWP-ASan abilitato esplicitamente e utilizzi l'SDK Crashlytics più recente per NDK (v18.3.6+ o Firebase BoM v31.3.0+).
Personalizza la configurazione dei report sugli arresti anomali aggiungendo report con attivazione, log, chiavi e monitoraggio degli errori non irreversibili.
Esegui l'integrazione con Google Play per poter filtrare i report sugli arresti anomali della tua app per Android in base al canale Google Play direttamente nella dashboard di Crashlytics. In questo modo, puoi concentrare meglio la dashboard su build specifiche.

Risoluzione dei problemi

Se vedi analisi dello stack diverse nella console Firebase e in logcat, consulta la guida alla risoluzione dei problemi.

Opzioni alternative per il caricamento dei 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 un processo di build diverso da Gradle). In queste situazioni, le seguenti opzioni potrebbero essere utili 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 build NDK personalizzato all'interno di Gradle
Se le tue librerie native sono integrate in un modulo della funzionalità/libreria o fornite da una terza parte
Se l'attività di caricamento automatico dei simboli non va a buon fine o se visualizzi arresti anomali non simbolizzati nella dashboard di Crashlytics

Visualizza le istruzioni per questa opzione

L'attività di caricamento dei simboli Crashlytics standard presuppone che tu stia creando le tue librerie native nell'ambito della build Gradle del modulo dell'app, utilizzando strumenti di build NDK standard come CMake.

Tuttavia, se utilizzi un processo di build NDK personalizzato all'interno di Gradle o se le tue librerie native sono create in un modulo della funzionalità/libreria o fornite da una terza parte, potresti dover specificare esplicitamente il percorso delle librerie non sottoposte a stripping. Per farlo, puoi aggiungere la proprietà unstrippedNativeLibsDir all'interno dell'estensione Crashlytics nel file di build Gradle.

Assicurati di aver completato le seguenti attività iniziali del flusso di lavoro principale descritte in precedenza in questa pagina:

Per consentire all'attività di caricamento automatico dei simboli di trovare le informazioni sui simboli, 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 cercherà in modo ricorsivo nella directory specificata le librerie native con un'estensione .so. Crashlytics estrae quindi i simboli di debug da tutte queste librerie e li carica sui server Firebase.

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 o org.gradle.api.file.FileCollection
Più directory per una singola versione di build fornendo un elenco o un'istanza FileCollection
(A partire dal plug-in Gradle Crashlytics v3.0.0) Accumula più directory in singoli prodotti e versioni di build.

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 i simboli in MY/NATIVE/LIBS, mentre uploadCrashlyticsSymbolFilesFeatureXRelease caricherà i simboli sia in MY/NATIVE/LIBS sia in MY/FEATURE_X/LIBS.

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

Opzione: carica i simboli per build non Gradle o librerie native non sottoposte a stripping inaccessibili

Questa opzione può essere utile nelle seguenti situazioni:

Se utilizzi un processo di build diverso da Gradle
Se le librerie native non sottoposte a stripping ti vengono fornite in un modo che non le rende accessibili durante le build di Gradle

Visualizza le istruzioni per questa opzione

Questa opzione richiede l'esecuzione di un comando dell'interfaccia a riga di comando Firebase quando crei una build di release o qualsiasi build per cui vuoi visualizzare analisi dello stack con simboli nella console Firebase.

Assicurati di aver completato le seguenti attività iniziali del flusso di lavoro principale descritte in precedenza in questa pagina:
1. Abilitato Crashlytics nella console Firebase.
2. Aggiunto l'SDK Crashlytics per NDK e il plug-in Gradle Crashlytics.
Tieni presente che con questa opzione non è necessario aggiungere l'estensione firebaseCrashlytics o configurare il caricamento automatico dei simboli, perché utilizzerai l'interfaccia a riga di comando Firebase (passaggi successivi di seguito) per generare e caricare i file dei simboli.
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 eseguire l'aggiornamento all'ultima versione.
  
  Nota: puoi anche eseguire i comandi dell'interfaccia a riga di comando Firebase in Cloud Shell. Cloud Shell è un ambiente a riga di comando pre-autenticato basato su browser, accessibile dalla console Firebase e dotato dell'interfaccia a riga di comando Firebase preinstallata. Questo lo rende un'opzione pratica per iniziare rapidamente, a condizione che tu aggiunga i file di progetto all'ambiente Cloud Shell.
2. (Solo per le app che utilizzano il livello API Android 30 e versioni successive) Aggiorna il template AndroidManifest.xml della tua app per disattivare il tagging dei puntatori:
  1. Seleziona la casella Android Player Settings > Publishing Settings > Build > Custom Main Manifest (Impostazioni del player Android > Impostazioni di pubblicazione > Build > Manifest principale personalizzato).
  2. Apri il modello di manifest disponibile all'indirizzo Assets/Plugins/Android/AndroidManifest.xml.
  3. Aggiungi il seguente attributo al tag dell'applicazione: <application android:allowNativeHeapPointerTagging="false" ... />
Crea il progetto.

Carica le informazioni sui simboli.

Al termine della build, genera un file dei simboli compatibile con Crashlytics e caricalo sui server Firebase eseguendo il seguente comando dell'interfaccia a riga di comando Firebase:

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

FIREBASE_APP_ID: l'ID app Firebase per Android (non il nome del pacchetto)
Esempio di ID app Firebase per Android: 1:567383003300:android:17104a2ced0c9b9b
Hai bisogno di trovare l'ID app Firebase?
Ecco due modi per trovare l'ID app Firebase:
- Nel file google-services.json, l'ID app è il valore mobilesdk_app_id; oppure
- Nella console Firebase, vai alle Impostazioni progetto. Vai alla scheda Le tue app, poi fai clic sull'app Firebase prevista per trovare il relativo ID app.
PATH/TO/SYMBOLS: il percorso del file dei simboli generato dall'interfaccia a riga di comando
- Esportato in un progetto Android Studio: PATH/TO/SYMBOLS può essere qualsiasi directory. L'interfaccia a riga di comando Firebase eseguirà una ricerca ricorsiva nella directory specificata per trovare librerie native con un'estensione .so.
- Hai creato l'APK direttamente da Unity: PATH/TO/SYMBOLS è il percorso del file dei simboli compresso generato nella directory root 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 dei file dei simboli

Flag	Descrizione
`--generator=csym`	Utilizza il generatore di file dei simboli cSYM precedente anziché il generatore Breakpad predefinito Opzione sconsigliata per l'utilizzo. Ti consigliamo di utilizzare il generatore di file di simboli Breakpad predefinito.
`--generator=breakpad`	Utilizza il generatore di file di simboli Breakpad Tieni presente che l'impostazione predefinita per la generazione dei file dei simboli è Breakpad. Utilizza questo flag solo se hai aggiunto `symbolGenerator { csym() }` nella configurazione di compilazione e vuoi eseguire l'override per utilizzare Breakpad.
`--dry-run`	Genera i file dei simboli, ma non li carica Questo flag è utile se vuoi ispezionare i contenuti dei file inviati.
`--debug`	Fornisce informazioni di debug aggiuntive

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

Dopo aver creato l'app nell'ambito della forzatura di un arresto anomalo, assicurati di eseguire il comando crashlytics:symbols:upload dell'interfaccia a riga di comando Firebase per caricare il file dei simboli.

Inizia a utilizzare Crashlytics per Android NDK Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Prima di iniziare

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

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

Kotlin

Groovy

Kotlin

Groovy

Passaggio 3: aggiungi l'estensione Crashlytics alla build

Kotlin

Groovy

Passaggio 4: configura il caricamento automatico dei simboli nativi

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

Kotlin

Java

Passaggi successivi

Risoluzione dei problemi

Opzioni alternative per il caricamento dei simboli

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

Kotlin

Groovy

Opzione: carica i simboli per build non Gradle o librerie native non sottoposte a stripping inaccessibili

Inizia a utilizzare Crashlytics per Android NDK