Desativar o Monitoramento de desempenho do Firebase

Durante o desenvolvimento e o teste de apps, pode ser útil desativar o Monitoramento de desempenho.

Por exemplo, ao desativar o Monitoramento de desempenho durante o processo de compilação do seu app, é possível realizar as seguintes funções:

Desativar alguns recursos do Monitoramento de desempenho (como os fornecidos pelo plug-in do Gradle para essa ferramenta) nos seus builds de depuração, mas ativá-los novamente no seu build de lançamento.
Desativar o Monitoramento de desempenho ao criar seu app, mas permitir que ele seja reativado no momento da execução.
Desativar o Monitoramento de desempenho ao criar seu app, mas não permitir que ele seja reativado no momento da execução.

Também é possível criar seu app com o Monitoramento de desempenho ativado, mas usar a Configuração remota do Firebase para dar a você a flexibilidade de desativar (e reativar) o Monitoramento de desempenho no app de produção. Com essa opção, é possível até configurar o app para permitir que os usuários ativem ou desativem o Monitoramento de desempenho.

Desativar o Monitoramento de desempenho durante o processo de compilação do seu app

Para desativar o Monitoramento de desempenho durante o processo de compilação, basta desativar o plug-in do Gradle do Monitoramento de desempenho e/ou desativar a biblioteca Android do Monitoramento de desempenho.

Durante o desenvolvimento e a depuração, a desativação do plug-in é útil porque a instrumentação pelo plug-in pode contribuir para aumentar o tempo de compilação. No entanto, é recomendado manter a biblioteca ativada para que você ainda possa visualizar dados de desempenho da inicialização do app e traces do uso do aplicativo em primeiro e segundo plano, além de traces de código personalizados no seu app.

Desativar o plug-in do Gradle para o Monitoramento de desempenho

É possível desativar o plug-in do Monitoramento de desempenho adicionando uma sinalização instrumentationEnabled usando as seguintes opções:

Propriedade de extensão: desativa o plug-in para uma variante de build específica no tempo de compilação
Propriedade do projeto: desativa o plug-in para todas as variantes de build no tempo de compilação

Desativar o plug-in por meio de uma sinalização de Propriedade de extensão

Ao usar uma sinalização de Propriedade de extensões, é possível desativar o plug-in do Monitoramento de desempenho para uma variante de build específica no tempo de compilação.

No arquivo Gradle no nível raiz (para envolvidos no projeto) (<project>/build.gradle.kts ou <project>/build.gradle), verifique se a dependência do Plug-in do Android para Gradle está especificada como v3.4.0. ou mais tarde.

Para versões anteriores do Plug-in do Android para Gradle, ainda é possível desativar o plug-in do Monitoramento de desempenho para uma variante de build específica, mas a contribuição do tempo de compilação para essa variante não será completamente eliminada.

Adicione a seguinte sinalização ao arquivo do Gradle do módulo (nível do app) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle) e defina-a como false para desativar. plug-in do Monitoramento de desempenho.

Kotlin

import com.google.firebase.perf.plugin.FirebasePerfExtension

// ...

android {
  // ...
  buildTypes {
    getByName("debug") {
      configure<FirebasePerfExtension> {
        // Set this flag to 'false' to disable @AddTrace annotation processing and
        // automatic monitoring of HTTP/S network requests
        // for a specific build variant at compile time.
        setInstrumentationEnabled(false)
      }
    }
  }
}

Groovy

android {
  // ...
  buildTypes {
    debug {
      FirebasePerformance {
        // Set this flag to 'false' to disable @AddTrace annotation processing and
        // automatic monitoring of HTTP/S network requests
        // for a specific build variant at compile time.
        instrumentationEnabled false
      }
    }
  }
}

Desativar o plug-in por meio de uma sinalização de Propriedade do projeto

Ao usar uma sinalização de Propriedade do projeto, é possível desativar o plug-in do Monitoramento de desempenho para todas as variantes de build no tempo de compilação.

Adicione a seguinte sinalização ao arquivo gradle.properties e defina-a como false para desativar o plug-in do Monitoramento de desempenho.

// ...

// Set this flag to 'false' to disable @AddTrace annotation processing and
// automatic monitoring of HTTP/S network requests
// for all build variants at compile time.
firebasePerformanceInstrumentationEnabled=false

Desativar a biblioteca do Monitoramento de desempenho para Android

Se você desativar a biblioteca de Monitoramento de desempenho no momento da compilação, poderá escolher se permitirá que o app ative a biblioteca no momento da execução.

Desativar a biblioteca no momento da compilação, mas permitir que o app seja ativado no momento da execução

Adicione o seguinte elemento <meta-data> ao arquivo AndroidManifest.xml do app:

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

Desativar a biblioteca no momento da compilação, mas não permitir que o app seja ativado no momento da execução

Adicione o seguinte elemento <meta-data> ao arquivo AndroidManifest.xml do app:

  <application>
    <meta-data
      android:name="firebase_performance_collection_deactivated"
      android:value="true" />
  </application>

Desativar seu app no momento da execução usando a Configuração remota

A Configuração remota do Firebase permite fazer alterações no comportamento e na aparência do seu app. Portanto, você pode usá-la para desativar o Monitoramento de desempenho em instâncias implantadas do seu app.

Para desativar a coleta de dados do Monitoramento de desempenho na próxima vez em que seu app Android for iniciado, use o código de exemplo mostrado abaixo. Para mais informações sobre como usar a Configuração remota em um app Android, consulte Usar a Configuração remota do Firebase no Android.

Verifique se o Configuração remota está na seção dependencies do seu arquivo Gradle do módulo (nível do app) (geralmente <project>/<app-module>/build.gradle.kts ou <project>/<app-module>/build.gradle):
Kotlin+KTX
```
  implementation("com.google.firebase:firebase-config-ktx:22.0.0")
```
Java
```
  implementation("com.google.firebase:firebase-config:22.0.0")
```

Configure a Configuração remota e desative o Monitoramento de desempenho se perf_disable estiver definido como true:

Kotlin+KTX

// Setup remote config
val config = Firebase.remoteConfig

// You can uncomment the following two statements to permit more fetches when
// validating your app, but you should comment out or delete these lines before
// distributing your app in production.
// val configSettings = remoteConfigSettings {
//     minimumFetchIntervalInSeconds = 3600
// }
// config.setConfigSettingsAsync(configSettings)
// Load in-app defaults from an XML file that sets perf_disable to false until you update
// values in the Firebase Console

// Observe the remote config parameter "perf_disable" and disable Performance Monitoring if true
config.setDefaultsAsync(R.xml.remote_config_defaults)
    .addOnCompleteListener { task ->
        if (task.isSuccessful) {
            Firebase.performance.isPerformanceCollectionEnabled = !config.getBoolean("perf_disable")
        } else {
            // An error occurred while setting default parameters
        }
    }MainActivity.kt

Java

// Setup remote config
final FirebaseRemoteConfig config = FirebaseRemoteConfig.getInstance();

// You can uncomment the following two statements to permit more fetches when
// validating your app, but you should comment out or delete these lines before
// distributing your app in production.
// FirebaseRemoteConfigSettings configSettings = new FirebaseRemoteConfigSettings.Builder()
//       .setMinimumFetchIntervalInSeconds(3600)
//       .build();
// config.setConfigSettingsAsync(configSettings);
// Load in-app defaults from an XML file that sets perf_disable to false until you update
// values in the Firebase Console

//Observe the remote config parameter "perf_disable" and disable Performance Monitoring if true
config.setDefaultsAsync(R.xml.remote_config_defaults)
        .addOnCompleteListener(new OnCompleteListener<Void>() {
            @Override
            public void onComplete(@NonNull Task<Void> task) {
                if (task.isSuccessful()) {
                    if (config.getBoolean("perf_disable")) {
                        FirebasePerformance.getInstance().setPerformanceCollectionEnabled(false);
                    } else {
                        FirebasePerformance.getInstance().setPerformanceCollectionEnabled(true);
                    }
                } else {
                    // An error occurred while setting default parameters
                }
            }
        });MainActivity.java

Adicione o seguinte código a MainActivity.java para buscar e ativar os valores da Configuração remota:

Kotlin+KTX

// Remote Config fetches and activates parameter values from the service
val config = Firebase.remoteConfig
config.fetch(3600)
    .continueWithTask { task ->
        if (!task.isSuccessful) {
            task.exception?.let {
                throw it
            }
        }
        config.activate()
    }
    .addOnCompleteListener(this) { task ->
        if (task.isSuccessful) {
            // Parameter values successfully activated
            // ...
        } else {
            // Handle errors
        }
    }MainActivity.kt

Java

//Remote Config fetches and activates parameter values from the service
final FirebaseRemoteConfig config = FirebaseRemoteConfig.getInstance();
config.fetch(3600)
        .continueWithTask(new Continuation<Void, Task<Boolean>>() {
            @Override
            public Task<Boolean> then(@NonNull Task<Void> task) throws Exception {
                if (!task.isSuccessful()) {
                    throw task.getException();
                }
                return config.activate();
            }
        })
        .addOnCompleteListener(new OnCompleteListener<Boolean>() {
            @Override
            public void onComplete(@NonNull Task<Boolean> task) {
                if (task.isSuccessful()) {
                    // Parameter values successfully activated
                    // ...
                } else {
                    // Handle errors
                }
            }
        });MainActivity.java

Para desativar o Monitoramento de desempenho no Console do Firebase, crie um parâmetro perf_disable no projeto do app e defina o valor dele como true.

Essa alteração fará chamadas para as chamadas "sem operação" (NOOPs, na sigla em inglês) do SDK do Monitoramento de desempenho, eliminando quaisquer efeitos significativos do uso desse SDK no desempenho do seu app.

Se você definir o valor de perf_disable como false, o Monitoramento de desempenho permanecerá ativado.