Como desativar o Crashlytics durante o desenvolvimento

Existe alguma maneira simples de desativar o Crashlytics Android SDK durante o desenvolvimento?

Não quero que ele acerte toda vez que faço algo estúpido

Por outro lado, não quero comentar Crashlytics.start()e, possivelmente, correr o risco de esquecer de descomentar e comprometer

Marc de Crashlytics aqui. Aqui estão algumas maneiras de desativar o Crashlytics enquanto você faz suas compilações de depuração!

1. Use um andróide diferente: versionString para compilações de depuração e lançamento e desative o relatório de falhas no painel da web do Crashlytics para a versão de depuração.

2. Quebre a chamada para Crashlytics.start () em uma instrução if que verifique um sinalizador de depuração. Você pode usar um sinalizador personalizado ou uma abordagem como as propostas aqui: Como verificar se o APK está assinado ou "compilação de depuração"?

Encontrei a solução da Crashlytics (com integração de malha)

Coloque o seguinte código dentro da sua classe Application onCreate()

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

EDITAR:

No Crashalitics 2.3 e acima, isso foi preterido. O código correto é:

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

ou

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

(copiado do método reprovado Crashlytics desativado () )

EDIT2:

Opcionalmente, você também pode adicioná-lo ao seu buildTypeem gradle. Esse comando desativa o envio do arquivo de mapeamento crashlytics e a geração de um ID para cada build, o que acelera a criação de gradles desses tipos. (Não desativa o Crashlytics em tempo de execução.) Veja a resposta de Mike B aqui.

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

A resposta escolhida não está mais correta. O Google mudou a integração do Crashlytics. Minha versão atual é 2.9.1e a única coisa que eu tenho que fazer é adicionar implementation 'com.crashlytics.sdk.android:crashlytics:2.9.1'ao meu arquivo Gradle. Não é necessário mais nada, é bom, mas isso significa que o Crashlytics está sempre em execução.

Solução 1

Apenas compile o Crashlytics na versão:

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

Solução 2

Se você deseja configurar adicionalmente o Crashlytics , a Solução 1 não está funcionando, pois as classes do Crashlytics não serão encontradas nas Construções de Depuração. Então, mude a implementação Gradle de volta para:

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

Em seguida, vá para o seu manifesto e adicione a seguinte meta-datatag dentro doapplication tag:

<application
        android:name="...>

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

...

</application>

Adicione à sua Atividade de Lançamento (apenas uma vez necessária, nem todas as Atividades)

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

Isso ativará apenas o Crashlytics nas versões de lançamento. Cuidado, verifique também o BuildConfig.DEBUG ao configurar o Crashlytics, por exemplo:

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

Se você usa Gradle, basta adicionar isso a um sabor:

ext.enableCrashlytics = false

Confira o documento mais recente. https://docs.fabric.io/android/crashlytics/build-tools.html#gradle-advanced-setup .

Além de adicionar o ext.enableCrashlytics = falsebuild.grade que você precisa,

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

Eu achei que essa era a solução mais fácil:

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

As linhas acima criarão um campo boolean estático chamado enableCrashlyticsno BuildConfigarquivo que você pode usar para decidir se deve iniciar Fabricou não:

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

OBSERVAÇÃO: Com esse método, o Fabrics é inicializado apenas nas versões da versão (como indicativo no código acima). Isso significa que você precisa colocar chamadas para métodos estáticos na Crashlyticsclasse em um ifbloco que verifica se o Fabrics foi inicializado como mostrado abaixo.

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

Caso contrário, o aplicativo falhará com Must Initialize Fabric before using singleton()erro ao testar no emulador.

2019 Resposta

Eu tenho tentado ativar apenas o Crashlytics na versão e desativado na depuração por 2 horas, verificando o console do Firebase para ver se as exceções foram carregadas ou não.

Existem 2 maneiras possíveis de fazer isso.

OPÇÃO 1

Funciona, mas se você chamar qualquer Crashlyticsmétodo na compilação de depuração, o aplicativo falhará .

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

OPÇÃO 2

Uma alternativa, se isso permitir que você chame Crashlyticsmétodos sem verificar BuildConfig.DEBUGprimeiro. Com essa configuração, você pode chamar métodos com segurança Crashlytics.logException()- eles simplesmente não fazem nada nas versões de depuração. Não vejo os relatórios sendo carregados na depuração.

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

Aplicativo onCreate ()

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

Use isso em MyApplication#onCreate()

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

EDITAR Se você atualizou para o Fabric, use esta resposta .

De acordo com o Google, use este código para desativar o Crashlytics e também irá melhorar o processo de compilação.

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

Outra solução simples que eu gosto, porque não requer diferentes arquivos de manifesto:

Etapa 1 - defina espaços reservados manifestos em build.gradle

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

Etapa 2 - use-os no seu AndroidManifest.xml

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

Observe que você também pode desativar o carregamento irritante de símbolos na compilação de depuração:

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 colocá-lo no build.gradlemódulo do seu aplicativo.

Se você deseja capturar todas as falhas (para compilações de depuração e lançamento), mas deseja separá-las no Crashlytics Dashboard, é possível adicionar esta linha de código ao build.gradle:

debug {
    versionNameSuffix "-DEBUG"
}

Por exemplo, se versionName do seu aplicativo for 1.0.0, as versões do seu lançamento serão marcadas como 1.0.0 enquanto as versões de depuração serão 1.0.0-DEBUG

Há muitas respostas boas aqui, mas, para meus testes, utilizo compilações de depuração para betas internos e testes fora do laboratório, onde os logs de falhas ainda são muito úteis e eu ainda gostaria de relatá-los. Como o OP, tudo que eu queria era desativá-los durante o desenvolvimento ativo, onde estou causando e resolvendo rapidamente falhas.

Em vez de remover TODAS as falhas de depuração, você pode optar por desativar apenas os relatórios enquanto um dispositivo estiver conectado à sua máquina de desenvolvimento com o código a seguir.

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

O problema é que nenhuma das soluções funciona para os mais recentes crashlytics sdk. (Estou usando 2.9.0)

Você não pode desabilitá-lo por código, pois ele é compilado em seu projeto e executado antes mesmo de uma chamada em Criar seu aplicativo. Portanto, outra solução é simples - não compile crashlytics quando não for necessário. Substitua a chamada 'compilar' por 'releaseCompile' no arquivo build.gradle.

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

Versão mais fácil atualizada ao usar o Gradle para criar:

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

Ele usa a nova sintaxe interna do Fabric for Crashlytics e trabalha automaticamente com a compilação Gradle.

Um problema estranho que encontrei: segui a resposta do xialin (que também aparece no site oficial) e não funcionou. Acabou que eu estava referenciandoBuildConfig no pacote do Fabric, que também contém uma variável estática DEBUG que foi definida como false, mesmo no modo de depuração.

Portanto, se você seguir a solução mencionada acima e ainda receber relatórios de depuração, verifique se está fazendo referência a isso:

import com.yourpackagename.BuildConfig;

E não é isso:

import io.fabric.sdk.android.BuildConfig;    

Se você estiver preocupado em BuildConfig.DEBUGnão ser configurado corretamente, use ApplicationInfo:

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

Use sabores ou crie configurações. Use um identificador de compilação separado para compilação de desenvolvedores e todas as suas falhas continuarão em um aplicativo separado. Pode ser útil no caso de compartilhar a compilação com colegas ou usá-la sem um depurador. Algo assim -

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

    production {
        applicationId "io.yourapp.app"
    }

Se você deseja criar uma versão depurável, eis o seguinte:

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 você define debuggable trueseu BuildConfig.DEBUG será inicializado com true, é por isso que adicionei essa variável na classe BuildConfig.

Init Fabric:

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

Podemos usar o método isDebuggable () da tela.

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

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

Feliz codificação :)

Você pode usar um arquivo de manifesto dedicado para o modo de depuração (funciona para mim com o Crashlytics 2.9.7):

Crie o arquivo app/src/debug/AndroidManifest.xmle adicione o seguinte:

<application>

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

</application>

Note-se que este elemento meta-dados deve ser colocado em debug / AndroidManifest.xml única , e não para o AndroidManifest.xml regulares

A solução usada CrashlyticsCore.Builder().disabled(BuildConfig.DEBUG).build()não funcionou para mim e descobri que o crashlytics é inicializado pelo CrashlyticsInitProvider antes que Application.onCreate () seja chamado ou qualquer atividade seja iniciada, o que significa que a inicialização manual da malha no aplicativo ou em uma atividade não tem efeito porque o tecido já foi inicializado.

Etapa 1: no build.grade

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

Etapa 2: no manifesto

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

Etapa 3: no aplicativo ou na primeira atividade

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

Não tenho certeza se a etapa 3 é necessária, mas para garantir que a versão de lançamento funcione sem falhas. fonte: https://firebase.google.com/docs/crashlytics/customize-crash-reports#enable_opt-in_reporting

Este trabalho para mim:

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

e em buildTypes:

debug {
ext.enableCrashlytics = false
}

Há duas opções para desativar o Firebase Crashlytics para a seguinte versão com.google.firebase: firebase-crashlytics: 17.0.0:

1. Adicionar metatag ao manifesto do aplicativo

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

OU

2. Configure diretamente no aplicativo (lembre-se de que quando definido como false, o novo valor não se aplica até a próxima execução do aplicativo)

FirebaseCrashlytics.getInstance().setCrashlyticsCollectionEnabled(true)

Outra maneira, se você deseja apenas fazer isso no seu IDE, é sair do plug-in. Aparentemente, ele irá parar de enviar relatórios enquanto você estiver gerando builds sem fazer login novamente.

1. Adicione isso ao build.gradle do seu aplicativo:

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

2. Desative o kit Crashlytics em tempo de execução. Caso contrário, o kit Crashlytics lançará o erro:

   // 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. No AndroidManifest.xml, adicione

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

Resposta do Fabric 2020

Cole o código abaixo na sua classe Application e chame o método setCrashlyticsStatedo seu aplicativo onCreate. Como opção, você pode adicionar os IDs do seu dispositivo de teste aodebugDevices HashSet para que seus dispositivos pessoais possam ser ignorados, mesmo quando construídos no modo de liberação.

Nota. Settings.Secure.getString(getContext().getContentResolver(), Settings.Secure.ANDROID_ID);Não é garantido que a identificação do dispositivo retornada por seja única ou constante (pode ser alterada em uma redefinição de fábrica ou manualmente em um dispositivo raiz). Mas deve ser bom o suficiente.

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

Verifique se BuildConfig. está olhando para a classe BuildConfig correta. Muitas vezes, existem várias opções e a errada pode ser arrastada.

Esta é uma resposta boba, eu sei.
Apenas comente Fabric.with(this, new Crashlytics());, trabalhe nisso e remova o comentário quando quiser lançá-lo.