Come disabilitare Crashlytics durante lo sviluppo

Esiste un modo semplice per disattivare l'SDK Android di Crashlytics durante lo sviluppo?

Non voglio che mandi un crash ogni volta che faccio qualcosa di stupido

D'altra parte non voglio commentare Crashlytics.start()e possibilmente rischiare di dimenticare di decommentarlo e impegnarmi

Marc di Crashlytics qui. Ecco un paio di modi per disabilitare Crashlytics mentre esegui le build di debug!

1. Usa un Android diverso: versionString per il debug e le versioni di rilascio, quindi disabilita la segnalazione degli arresti anomali dal pannello Web di Crashlytics per la versione di debug.

2. Termina la chiamata a Crashlytics.start () in un'istruzione if che controlla un flag di debug. È possibile utilizzare un flag personalizzato o un approccio come quelli proposti qui: Come verificare se APK è firmato o "build di debug"?

Ho trovato la soluzione da Crashlytics (con integrazione Fabric)

Inserisci il seguente codice nella tua classe di applicazione onCreate()

Crashlytics crashlytics = new Crashlytics.Builder().disabled(BuildConfig.DEBUG).build();
Fabric.with(this, crashlytics);

MODIFICARE:

In Crashalitics 2.3 e versioni successive, questo è deprecato. Il codice corretto è:

CrashlyticsCore core = new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build();
Fabric.with(this, new Crashlytics.Builder().core(core).build());

o

Fabric.with(this, new Crashlytics.Builder().core(new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()).build());

(copiato dal metodo obsoleto di Crashlytics disabilitato () )

EDIT2:

Puoi anche aggiungerlo facoltativamente al tuo buildTypein gradle. Questo comando disabilita l'invio del file di mapping crashlytics e la generazione di un ID per ogni build, che accelera le build graduali di tali sapori. (Non disabilita Crashlytics in fase di esecuzione.) Vedi la risposta di Mike B. qui.

buildTypes {
    release {
           ....
    }
    debug {
        ext.enableCrashlytics = false
    }
}

La risposta scelta non è più corretta. Google ha modificato l'integrazione di Crashlytics. La mia versione attuale è 2.9.1e l'unica cosa che dovevo fare è aggiungere implementation 'com.crashlytics.sdk.android:crashlytics:2.9.1'al mio file Gradle. Non sono necessarie altre cose, bello ma questo significa che Crashlytics è sempre in esecuzione.

Soluzione 1

Compila solo Crashlytics nella versione di rilascio:

dependencies {
   ...
   releaseImplementation 'com.crashlytics.sdk.android:crashlytics:2.9.1' // update version
}

Soluzione 2

Se si desidera configurare ulteriormente Crashlytics, la Soluzione 1 non funziona, poiché le classi Crashlytics non si trovano nelle build di debug. Quindi modifica l'implementazione Gradle in:

implementation 'com.crashlytics.sdk.android:crashlytics:2.9.1' // update version

Quindi vai al tuo manifest e aggiungi il seguente meta-datatag all'interno del applicationtag:

<application
        android:name="...>

        <meta-data
            android:name="firebase_crashlytics_collection_enabled"
            android:value="false" />

...

</application>

Aggiungi alla tua attività di lancio (solo una volta, non tutte le attività)

if (!BuildConfig.DEBUG) { // only enable bug tracking in release version
   Fabric.with(this, new Crashlytics());
}

Ciò abiliterà Crashlytics solo nelle versioni di rilascio. Fai attenzione, controlla anche BuildConfig.DEBUG quando configuri Crashlytics, ad esempio:

if (!BuildConfig.DEBUG) {
   Crashlytics.setUserIdentifier("HASH_ID");
}

Se usi Gradle basta aggiungere questo a un sapore:

ext.enableCrashlytics = false

Dai un'occhiata all'ultimo documento. https://docs.fabric.io/android/crashlytics/build-tools.html#gradle-advanced-setup .

Oltre ad aggiungere ext.enableCrashlytics = falsebuild.grade devi fare,

Crashlytics crashlyticsKit = new Crashlytics.Builder()
    .core(new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build())
    .build();

// Initialize Fabric with the debug-disabled crashlytics.
Fabric.with(this, crashlyticsKit);

Ho trovato questa la soluzione più semplice:

    release {
        ...
        buildConfigField 'Boolean', 'enableCrashlytics', 'true'
    }
    debug {
        buildConfigField 'Boolean', 'enableCrashlytics', 'false'
    }

Le righe precedenti creeranno un campo booleano statico chiamato enableCrashlyticsnel BuildConfigfile che è possibile utilizzare per decidere se avviare Fabrico meno:

    if (BuildConfig.enableCrashlytics)
        Fabric.with(this, new Crashlytics());

NOTA: con questo metodo i tessuti vengono inizializzati solo nelle build di rilascio (come indicativo nel codice sopra). Ciò significa che è necessario inserire le chiamate ai metodi statici nella Crashlyticsclasse in un ifblocco che verifica se i tessuti sono stati inizializzati come mostrato di seguito.

if (Fabric.isInitialized())
    Crashlytics.logException(e);

Altrimenti l'app si arresterà in modo anomalo Must Initialize Fabric before using singleton()durante il test sull'emulatore.

Risposta 2019

Ho provato ad abilitare Crashlytics in versione e disabilitare nel debug per 2 ore, controllando la console di Firebase per vedere se le eccezioni sono state caricate o meno.

Ci sono 2 modi possibili per farlo.

OPZIONE 1

Funziona, ma se chiami un Crashlyticsmetodo su build di debug l'app andrà in crash .

app / build.gradle

android {
    buildTypes {
        release {
            manifestPlaceholders = [crashlyticsEnabled: true]
        }
        debug {
            manifestPlaceholders = [crashlyticsEnabled: false]
        }

AndroidManifest.xml

<manifest
    <application
        <meta-data
            android:name="firebase_crashlytics_collection_enabled"
            android:value="${crashlyticsEnabled}" />

OPZIONE 2

Un'alternativa se ciò consente di chiamare i Crashlyticsmetodi senza BuildConfig.DEBUGprima verificare . Con questa configurazione puoi tranquillamente chiamare metodi come Crashlytics.logException(): semplicemente non fanno nulla nelle build di debug. Non vedo i rapporti caricati nel debug.

app / build.gradle

android {
    buildTypes {
        release {
            ext.enableCrashlytics = true
        }
        release {
            ext.enableCrashlytics = false
        }

AndroidManifest.xml

<manifest
    <application
        <meta-data
            android:name="firebase_crashlytics_collection_enabled"
            android:value="false" />

Applicazione onCreate ()

val crashlytics = Crashlytics.Builder()
    .core(CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build())
    .build()
Fabric.with(this, crashlytics)

Usa questo in MyApplication#onCreate()

if (!BuildConfig.DEBUG) Crashlytics.start(this);

MODIFICA Se hai eseguito l'upgrade a Fabric, utilizza questa risposta .

Secondo google usa questo codice per disabilitare Crashlytics e migliorerà anche il processo di compilazione.

reference- https://developer.android.com/studio/build/optimize-your-build

Un'altra soluzione semplice che mi piace, perché non richiede diversi file manifest:

Passaggio 1: definire i segnaposto manifest in build.gradle

android {
    ...
    buildTypes {
        release {
            manifestPlaceholders = [crashlytics:"true"]
        }
        debug {
            manifestPlaceholders = [crashlytics:"false"]
        }
    }
    ...
}

Passaggio 2: utilizzali nel tuo AndroidManifest.xml

<meta-data
        android:name="firebase_crashlytics_collection_enabled"
        android:value="${crashlytics}" />

Nota che puoi anche disabilitare il fastidioso caricamento di simboli nella build di debug:

def crashlyticsUploadStoredDeobsDebug = "crashlyticsUploadStoredDeobsDebug"
def crashlyticsUploadDeobsDebug = "crashlyticsUploadDeobsDebug"
tasks.whenTaskAdded { task ->
    if (crashlyticsUploadStoredDeobsDebug.equals(task.name) ||
            crashlyticsUploadDeobsDebug.equals(task.name)) {

        println "Disabling $task.name."
        task.enabled = false
    }
}

Basta inserirlo nel build.gradlemodulo dell'applicazione.

Se vuoi catturare tutti gli arresti anomali (per build di debug e release) ma vuoi separarli nel Crashlytics Dashboard, puoi aggiungere questa riga di codice a build.gradle:

debug {
    versionNameSuffix "-DEBUG"
}

Ad esempio, se versionName della tua app è 1.0.0, le build di rilascio saranno contrassegnate come 1.0.0 mentre le build di debug saranno 1.0.0-DEBUG

Ci sono molte buone risposte qui, ma per i miei test uso build di debug per beta interni e test fuori dal laboratorio in cui i registri degli arresti anomali sono ancora molto utili e vorrei comunque segnalarli. Come l'OP, tutto ciò che volevo era disabilitarli durante lo sviluppo attivo dove spesso causavo e risolvo rapidamente gli arresti anomali.

Invece di rimuovere TUTTI gli arresti anomali del debug, puoi scegliere di disabilitare i report solo quando un dispositivo è collegato al tuo computer di sviluppo con il seguente codice.

if (!Debug.isDebuggerConnected()) {
    Fabric.with(this, new Crashlytics());
}

Il problema è che nessuna delle soluzioni funziona con l'ultimo crashlytics sdk. (Sto usando 2.9.0)

Non è possibile disabilitarlo tramite il codice poiché si compila nel progetto e viene eseguito anche prima di una chiamata su Crea dell'applicazione. Quindi un'altra soluzione è semplice: non compilare crashlytics quando non sono necessari. Sostituisci la chiamata 'compile' con 'releaseCompile' all'interno del file build.gradle.

 releaseCompile('com.crashlytics.sdk.android:crashlytics:2.9.0@aar') {
        transitive = true
    }

Versione più semplice aggiornata quando si utilizza Gradle per creare:

if (!BuildConfig.DEBUG) {
    Fabric.with(this, new Crashlytics());
}

Utilizza la nuova sintassi integrata di Fabric for Crashlytics e funziona automaticamente con la build a Gradle.

Uno strano problema che ho riscontrato: ho seguito la risposta di xialin (che appare anche sul sito ufficiale) e non ha funzionato. Si è scoperto che stavo facendo riferimento BuildConfignel pacchetto di Fabric che contiene anche una variabile DEBUG statica impostata su false anche in modalità debug.

Quindi, se segui la soluzione di cui sopra e ricevi ancora rapporti di debug, assicurati di fare riferimento a questo:

import com.yourpackagename.BuildConfig;

E non questo:

import io.fabric.sdk.android.BuildConfig;    

Se sei preoccupato di BuildConfig.DEBUGnon essere impostato correttamente, usa ApplicationInfoinvece:

boolean isDebug = ( mAppContext.getApplicationInfo().flags & ApplicationInfo.FLAG_DEBUGGABLE ) != 0;
Crashlytics crashlytics = new Crashlytics.Builder().disabled( isDebug ).build();
Fabric.with( uIContext, crashlytics );

Usa sapori o crea config. Usa un identificatore di build separato per dev build e tutti i tuoi arresti anomali continueranno a passare a un'app separata. Può tornare utile in caso di condivisione della build con peer o utilizzo senza debugger. Qualcosa come questo -

    productFlavors {
    dev {
        applicationId "io.yourapp.developement"
    }
    staging {
        applicationId "io.yourapp.staging"
    }

    production {
        applicationId "io.yourapp.app"
    }

Se si desidera creare una versione di debug, ecco il modo:

buildTypes {
    release {
        signingConfig signingConfigs.config
        debuggable true //-> debuggable release build
        minifyEnabled true
        multiDexEnabled false
        ext.enableCrashlytics = true
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        buildConfigField 'boolean', 'BUILD_TYPE_DEBUG', 'false'
    }
    debug {
        minifyEnabled false
        multiDexEnabled true
        ext.enableCrashlytics = false
        ext.alwaysUpdateBuildId = false
        // Disable fabric build ID generation for debug builds
        proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        buildConfigField 'boolean', 'BUILD_TYPE_DEBUG', 'true'
    }
}

Quando imposti debuggable trueBuildConfig.DEBUG verrà inizializzato con true, ecco perché ho aggiunto quella variabile nella classe BuildConfig.

Tessuto Init:

Crashlytics crashlytics = new Crashlytics.Builder()
            // disable crash reporting in debug build types with custom build type variable
            .core(new CrashlyticsCore.Builder().disabled(BuildConfig.BUILD_TYPE_DEBUG).build())
            .build();

    final Fabric fabric = new Fabric.Builder(this)
            .kits(crashlytics)
            //enable debugging with debuggable flag in build type 
            .debuggable(BuildConfig.DEBUG)
            .build();

    // Initialize Fabric with the debug-disabled crashlytics.
    Fabric.with(fabric);

Possiamo usare il metodo isDebuggable () di fabric.

import static io.fabric.sdk.android.Fabric.isDebuggable;

if(! isDebuggable()){
    // set Crashlytics ... 
}

Buona programmazione :)

Puoi usare un file manifest dedicato per la modalità debug (funziona per me con Crashlytics 2.9.7):

Creare il file app/src/debug/AndroidManifest.xmle aggiungere quanto segue:

<application>

    <meta-data
        android:name="firebase_crashlytics_collection_enabled"
        android:value="false"/>

</application>

Si noti che questo elemento di meta-dati deve essere messo in debug / AndroidManifest.xml solo , e non nella AndroidManifest.xml regolare

La soluzione che utilizza CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()non ha funzionato per me e ho scoperto che crashlytics è inizializzato da CrashlyticsInitProvider prima che venga chiamato Application.onCreate () o che venga avviata un'attività, il che significa che l'inizializzazione manuale del fabric nell'applicazione o un'attività non ha effetto perché il tessuto è già inizializzato.

Passaggio 1: in build.grade

buildTypes {
        debug {
            debuggable true
            manifestPlaceholders = [enableCrashlytic:false]
        }
        release {
            debuggable false
            manifestPlaceholders = [enableCrashlytic:true]
        }
    }

Passaggio 2: in manifest

<meta-data
            android:name="firebase_crashlytics_collection_enabled"
            android:value="${enableCrashlytic}" />

Passaggio 3: nell'applicazione o nella prima attività

private void setupCrashReport() {
        if (BuildConfig.DEBUG) return;
        Fabric.with(this, new Crashlytics());
    }

Non sono sicuro se il passaggio 3 sia necessario, ma per assicurarmi che la versione di rilascio funzioni senza crash. fonte: https://firebase.google.com/docs/crashlytics/customize-crash-reports#enable_opt-in_reporting

Questo lavoro per me:

    releaseCompile  'com.crashlytics.sdk.android:crashlytics:2.9.9'

e in buildTypes:

debug {
ext.enableCrashlytics = false
}

Esistono due opzioni per disabilitare Firebase Crashlytics per la seguente versione com.google.firebase: firebase-crashlytics: 17.0.0:

1. Aggiungi meta-tag al Manifest dell'app

<meta-data android:name="firebase_crashlytics_collection_enabled" android:value="false" />

O

2. Configurare direttamente nell'app (tenere presente che quando impostato su false, il nuovo valore non si applica fino alla prossima esecuzione dell'app)

FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true)

Un altro modo se vuoi solo farlo sul tuo IDE è disconnettersi dal plugin. Apparentemente smetterà di inviare report mentre stai generando build senza accedere di nuovo.

1. Aggiungi questo al build.gradle della tua app:

   android {
       buildTypes {
           debug {
             // Disable fabric build ID generation for debug builds
             ext.enableCrashlytics = false
             ...

2. Disabilita il kit Crashlytics in fase di esecuzione. Altrimenti, il kit Crashlytics genererà l'errore:

   // Set up Crashlytics, disabled for debug builds
   // Add These lines in your app Application class onCreate method
   
   Crashlytics crashlyticsKit = new Crashlytics.Builder()
       .core(new CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build())
       .build();
   
   // Initialize Fabric with the debug-disabled crashlytics.
   Fabric.with(this, crashlyticsKit);

3. In AndroidManifest.xml, aggiungi

   <meta-data
   android:name="firebase_crashlytics_collection_enabled"
   android:value="false" />

2020 Post Fabric Answer

Incolla il codice seguente nella tua classe Applicazione e chiama il metodo setCrashlyticsStatedall'applicazione su Crea. Se lo debugDevicesdesideri, puoi aggiungere gli ID del tuo dispositivo di test a HashSet in modo che i tuoi dispositivi personali possano essere ignorati, anche quando si costruisce in modalità di rilascio.

Nota. L'ID dispositivo restituito da Settings.Secure.getString(getContext().getContentResolver(), Settings.Secure.ANDROID_ID);non è garantito per essere univoco o costante (può cambiare su un ripristino di fabbrica o manualmente su un dispositivo rootato). Ma dovrebbe essere abbastanza buono.

private final HashSet<String> debugDevices = new HashSet<String>(Arrays.asList("6a3d5c2bae3fd32c"));

private boolean isDebugDevice(String deviceId) {
    return debugDevices.contains(deviceId);
}

private void setCrashlyticsState() {
    @SuppressLint("HardwareIds")
    String deviceId = Settings.Secure.getString(getContext().getContentResolver(), Settings.Secure.ANDROID_ID);
    if (BuildConfig.DEBUG || isDebugDevice(deviceId)) {
        Log.v("DeviceId", deviceId);
        FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(false);
    }
}

Controlla che BuildConfig. sta guardando la classe BuildConfig corretta. Esistono spesso diverse opzioni e potrebbe essere trascinata quella sbagliata.

Questa è una risposta sciocca, lo so
Basta commentare Fabric.with(this, new Crashlytics());, lavorare su questo e decommentarlo quando vuoi rilasciarlo.