Jak wyłączyć Crashlytics podczas programowania

Czy jest jakiś prosty sposób na wyłączenie Crashlytics Android SDK podczas programowania?

Nie chcę, żeby wysyła awarię za każdym razem, gdy robię coś głupiego

Z drugiej strony nie chcę komentować Crashlytics.start()i być może zaryzykuję zapomnienie o odkomentowaniu i popełnieniu błędu

Marc z Crashlytics tutaj. Oto kilka sposobów na wyłączenie Crashlytics podczas tworzenia kompilacji debugowania!

1. Użyj innego Androida: versionString do kompilacji debugowania i wydania, a następnie wyłącz raportowanie awarii z pulpitu internetowego Crashlytics dla wersji debugowania.

2. Zawiń wywołanie Crashlytics.start () w instrukcji if, która sprawdza flagę debugowania. Możesz użyć niestandardowej flagi lub podejścia podobnego do proponowanego tutaj: Jak sprawdzić, czy plik APK jest podpisany lub „kompilacja debugowania”?

Znalazłem rozwiązanie od Crashlytics (z integracją Fabric)

Umieść następujący kod w swojej klasie aplikacji onCreate()

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

EDYTOWAĆ:

W Crashalitics 2.3 i nowszych wersjach jest to przestarzałe. Prawidłowy kod to:

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

lub

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

(skopiowane z przestarzałej metody Crashlytics wyłączone () )

EDYCJA 2:

Możesz również opcjonalnie dodać to do swojego buildTypestopnia. To polecenie wyłącza wysyłanie pliku mapowania awaryjnego i generowanie identyfikatora dla każdej kompilacji, co przyspiesza kompilacje stopniowe tych smaków. (Nie wyłącza Crashlytics w czasie wykonywania.) Zobacz odpowiedź Mike B. tutaj.

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

Wybrana odpowiedź nie jest już poprawna. Google zmieniło integrację Crashlytics. Moja obecna wersja jest 2.9.1i jedyne, co musiałem zrobić, to dodać implementation 'com.crashlytics.sdk.android:crashlytics:2.9.1'do mojego pliku Gradle. Nic więcej nie jest wymagane, ale to oznacza, że ​​Crashlytics zawsze działa.

Rozwiązanie 1

Kompiluj Crashlytics tylko w wersji wydanej:

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

Rozwiązanie 2

Jeśli chcesz dodatkowo skonfigurować Crashlytics, wówczas Rozwiązanie 1 nie działa, ponieważ klasy Crashlytics nie będą znajdować się w kompilacjach debugowania. Zmień więc implementację Gradle z powrotem na:

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

Następnie przejdź do oczywistego i dodać następujące meta-dataznacznika wewnątrz applicationtagu:

<application
        android:name="...>

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

...

</application>

Dodaj do swojej działalności związanej z uruchomieniem (wymagany tylko raz, nie każda aktywność)

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

Pozwoli to włączyć Crashlytics tylko w wersjach wydania. Zachowaj ostrożność, sprawdź także BuildConfig.DEBUG podczas konfigurowania Crashlytics, np .:

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

Jeśli używasz Gradle, po prostu dodaj to do smaku:

ext.enableCrashlytics = false

Sprawdź najnowszy dokument. https://docs.fabric.io/android/crashlytics/build-tools.html#gradle-advanced-setup .

Oprócz dodania ext.enableCrashlytics = falsew build.grade musisz zrobić,

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

Znalazłem to być najprostszym rozwiązaniem:

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

Powyższe wiersze utworzą statyczne pole boolean wywoływane enableCrashlyticsw BuildConfigpliku, którego możesz użyć, aby zdecydować, czy zainicjować, Fabricczy nie:

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

UWAGA: Za pomocą tej metody tkaniny są inicjowane tylko w kompilacjach wersji (jak wskazano w powyższym kodzie). Oznacza to, że musisz umieścić wywołania metod statycznych w Crashlyticsklasie w ifbloku, który sprawdza, czy Tkaniny zostały zainicjowane, jak pokazano poniżej.

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

W przeciwnym razie aplikacja ulegnie awarii z Must Initialize Fabric before using singleton()błędem podczas testowania na emulatorze.

Odpowiedź na 2019 r

Próbowałem włączyć Crashlytics tylko w wydaniu i wyłączyć w debugowaniu przez 2 godziny, sprawdzając konsolę Firebase, aby sprawdzić, czy wyjątki zostały przesłane, czy nie.

Można to zrobić na 2 sposoby.

OPCJA 1

Działa, ale jeśli wywołasz dowolną Crashlyticsmetodę podczas kompilacji debugowania, aplikacja się zawiesi .

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

OPCJA 2

Alternatywą, jeśli pozwala to wywoływać Crashlyticsmetody bez uprzedniego sprawdzania BuildConfig.DEBUG. Dzięki tej konfiguracji możesz bezpiecznie wywoływać metody takie jak Crashlytics.logException()- po prostu nie robią nic w kompilacjach debugowania. Nie widzę raportów przesyłanych podczas debugowania.

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

Aplikacja onCreate ()

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

Użyj tego w MyApplication#onCreate()

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

EDYCJA W przypadku uaktualnienia do wersji Fabric użyj tej odpowiedzi .

Zgodnie z Google użyj tego kodu, aby wyłączyć Crashlytics, a także usprawni proces kompilacji.

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

Kolejne proste rozwiązanie, które lubię, ponieważ nie wymaga różnych plików manifestu:

Krok 1 - Zdefiniuj symbole zastępcze w build.gradle

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

Krok 2 - użyj ich w pliku AndroidManifest.xml

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

Zauważ, że możesz także wyłączyć irytujące przesyłanie symboli w kompilacji debugowania:

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

Wystarczy umieścić go w build.gradlemodule aplikacji.

Jeśli chcesz przechwycić wszystkie awarie (w przypadku kompilacji debugowania i wydania), ale chcesz je rozdzielić w aplikacji Crashlytics Dashboard, możesz dodać ten wiersz kodu do build.gradle:

debug {
    versionNameSuffix "-DEBUG"
}

Na przykład jeśli nazwa wersji aplikacji to 1.0.0, kompilacje wersji zostaną oznaczone jako 1.0.0, a kompilacje debugowania będą miały wersję 1.0.0-DEBUG

Istnieje wiele dobrych odpowiedzi, ale do moich testów używam kompilacji debugowania do wewnętrznych testów beta i testów poza laboratorium, w których dzienniki awarii są nadal bardzo przydatne i nadal chciałbym je zgłaszać. Podobnie jak PO, chciałem tylko wyłączyć je podczas aktywnego programowania, w którym często powoduję i szybko usuwam awarie.

Zamiast usuwać WSZYSTKIE awarie debugowania, możesz wyłączyć raporty tylko wtedy, gdy urządzenie jest podłączone do komputera programistycznego za pomocą następującego kodu.

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

Problem polega na tym, że żadne z rozwiązań nie działa w przypadku najnowszego pakietu SDK Crashlytics. (Używam 2.9.0)

Nie można go wyłączyć za pomocą kodu, ponieważ kompiluje się on w projekcie i działa nawet przed wywołaniem funkcji Utwórz aplikację. Inne rozwiązanie jest proste - nie kompiluj crashlytyków, gdy nie są potrzebne. Zamień wywołanie „compile” na „releaseCompile” w pliku build.gradle.

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

Najłatwiejsza wersja przy użyciu Gradle do kompilacji:

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

Wykorzystuje nową wbudowaną składnię z Fabric dla Crashlytics i działa automatycznie z kompilacją Gradle.

Dziwny problem, który napotkałem: podążyłem za odpowiedzią xialin (która pojawia się również na oficjalnej stronie) i nie zadziałało. Okazało się, że odwoływałem się BuildConfigdo pakietu Fabric, który zawiera również statyczną zmienną DEBUG, która została ustawiona na false nawet w trybie debugowania.

Jeśli więc postępujesz zgodnie z powyższym rozwiązaniem i nadal otrzymujesz raporty debugowania, upewnij się, że odwołujesz się do tego:

import com.yourpackagename.BuildConfig;

I nie to:

import io.fabric.sdk.android.BuildConfig;    

Jeśli martwisz BuildConfig.DEBUGsię nieprawidłową konfiguracją, użyj ApplicationInfozamiast tego:

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

Używaj smaków lub buduj konfiguracje. Użyj osobnego identyfikatora kompilacji dla kompilacji programisty, a wszystkie awarie będą przechodzić do osobnej aplikacji. Może się przydać w przypadku udostępniania kompilacji rówieśnikom lub używania jej bez debugera. Coś takiego -

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

    production {
        applicationId "io.yourapp.app"
    }

Jeśli chcesz mieć wersję do debugowania, oto sposób:

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

Po ustawieniu debuggable trueBuildConfig.DEBUG zostanie zainicjowany true, dlatego dodałem tę zmienną do klasy BuildConfig.

Materiał początkowy:

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

Możemy użyć metody isDebuggable () tkaniny.

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

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

Miłego kodowania :)

Możesz użyć dedykowanego pliku manifestu dla trybu debugowania (działa dla mnie z Crashlytics 2.9.7):

Utwórz plik app/src/debug/AndroidManifest.xmli dodaj następujące elementy:

<application>

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

</application>

Zauważ, że ten element meta-dane muszą być wprowadzone do debugowania / AndroidManifest.xml tylko , nie i na regularne AndroidManifest.xml

Rozwiązanie, które wykorzystuje, CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()nie działało dla mnie, i dowiedziałem się, że CrashlyticsInitProvider jest inicjowany przed wywołaniem Application.onCreate () lub uruchomieniem jakiejkolwiek aktywności, co oznacza, że ​​ręczne inicjowanie struktury w aplikacji lub działaniu nie ma efekt, ponieważ tkanina jest już zainicjowana.

Krok 1: W wersji build.grade

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

Krok 2: W manifeście

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

Krok 3: W aplikacji lub pierwszej aktywności

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

Nie jestem pewien, czy krok 3 jest konieczny, ale aby upewnić się, że wersja wydania powinna działać bez awarii. źródło: https://firebase.google.com/docs/crashlytics/customize-crash-reports#enable_opt-in_reporting

Ta praca dla mnie:

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

oraz w buildTypes:

debug {
ext.enableCrashlytics = false
}

Istnieją dwie opcje, aby wyłączyć Firebase Crashlytics dla następującej wersji com.google.firebase: firebase-crashlytics: 17.0.0:

1. Dodaj metatag do Manifestu aplikacji

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

LUB

2. Skonfiguruj bezpośrednio w aplikacji (pamiętaj o ustawieniu wartości false, nowa wartość nie będzie obowiązywać do następnego uruchomienia aplikacji)

FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true)

Innym sposobem, jeśli chcesz to zrobić tylko na swoim IDE, jest wylogowanie się z wtyczki. Najwyraźniej przestanie wysyłać raporty podczas generowania kompilacji bez ponownego logowania.

1. Dodaj to do build.gradle aplikacji:

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

2. Wyłącz zestaw Crashlytics w czasie wykonywania. W przeciwnym razie zestaw Crashlytics zgłosi błąd:

   // 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. W AndroidManifest.xml dodaj

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

2020 Post Fabric Answer

Wklej poniższy kod do klasy Application i wywołaj metodę setCrashlyticsStatez aplikacji onCreate. Możesz opcjonalnie dodać swoje ID urządzenia testowego dodebugDevices HashSet, aby Twoje urządzenia osobiste mogły zostać zignorowane, nawet podczas budowania w trybie zwolnienia.

Uwaga. Zwrócony identyfikator urządzenia Settings.Secure.getString(getContext().getContentResolver(), Settings.Secure.ANDROID_ID);nie jest gwarantowany, że jest unikalny lub stały (można go zmienić po przywróceniu ustawień fabrycznych lub ręcznie na zrootowanym urządzeniu). Ale powinno być wystarczająco dobre.

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

Sprawdź, czy BuildConfig. szuka poprawnej klasy BuildConfig. Często istnieje kilka opcji, a niewłaściwa może zostać wciągnięta.

To głupia odpowiedź, wiem.
Po prostu komentuj Fabric.with(this, new Crashlytics());, pracuj nad tym i odkomentuj to, kiedy chcesz go opublikować.