Wyłącz Monitorowanie wydajności Firebase

Podczas tworzenia i testowania aplikacji możesz wyłączyć Performance Monitoring.

Na przykład wyłączenie Performance Monitoring podczas procesu kompilacji aplikacji pozwala:

Wyłącz w kompilacji debugowania niektóre funkcje Performance Monitoring (np. te udostępniane przez Performance Monitoring w pluginie Gradle), ale ponownie włącz je w kompilacji wersji.
Wyłącz Performance Monitoring podczas tworzenia aplikacji, ale zezwól jej na ponowne włączenie w czasie działania.
Podczas tworzenia aplikacji wyłącz opcję Performance Monitoring i nie zezwalaj na jej ponowne włączanie w czasie działania aplikacji.

Możesz też utworzyć aplikację z włączoną usługą Performance Monitoring, ale użyć Firebase Remote Config, aby móc ją wyłączyć (i ponownie włączyć) w wersji produkcyjnej. Dzięki tej opcji możesz nawet skonfigurować aplikację tak, aby użytkownicy mogli wyrazić zgodę na korzystanie z usługi Performance Monitoring lub zrezygnować z tego.Performance Monitoring

Wyłącz Performance Monitoring podczas procesu kompilacji aplikacji

Możesz wyłączyć Performance Monitoring podczas procesu kompilacji, wyłączając wtyczkę Gradle Performance Monitoring lub wyłączając bibliotekę Androida Performance Monitoring.

Wyłączenie wtyczki może być przydatne podczas tworzenia i debugowania, ponieważ jej użycie może wydłużać czas kompilacji. Możesz jednak pozostawić bibliotekę włączoną, aby nadal wyświetlać dane o skuteczności z logów czasu uruchamiania aplikacji, logów aplikacji na pierwszym planie i logów aplikacji na drugim planie, a także logów kodu niestandardowego w aplikacji.

Wyłączanie wtyczki Performance Monitoring Gradle

Możesz wyłączyć wtyczkę Performance Monitoring, dodając flagę instrumentationEnabled za pomocą tych opcji:

Właściwość rozszerzenia – wyłącza wtyczkę w określonym wariancie kompilacji w momencie kompilacji.
Właściwość projektu – wyłącza wtyczkę w wszystkich wariantach kompilacji w czasie kompilacji.

Wyłączanie wtyczki za pomocą flagi usługi rozszerzenia

Za pomocą flagi Właściwość rozszerzeń możesz wyłączyć wtyczkę Performance Monitoring w określonym wariancie kompilacji.

W pliku Gradle na poziomie katalogu głównego (na poziomie projektu) (<project>/build.gradle.kts lub <project>/build.gradle) sprawdź, czy zależność wtyczki Androida do obsługi Gradle jest określona jako wersja 3.4.0 lub nowsza.

W przypadku starszych wersji wtyczki Gradle na Androida nadal możesz wyłączyć wtyczkę Performance Monitoring w przypadku konkretnej wersji kompilacji, ale czas kompilacji dla tej wersji nie zostanie całkowicie wyeliminowany.

Dodaj ten parametr do pliku Gradle modułu (na poziomie aplikacji) (zazwyczaj <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle), a następnie ustaw go na false, aby wyłączyć wtyczkę Performance Monitoring.

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

Wyłączanie wtyczki za pomocą flagi usługi w projekcie

Za pomocą flagi Właściwość projektu możesz wyłączyć wtyczkę Performance Monitoring dla wszystkich wariantów kompilacji.

Aby wyłączyć wtyczkę Performance Monitoring, dodaj do pliku gradle.properties ten parametr i ustaw go na false.

// ...

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

Wyłączanie biblioteki Performance Monitoring na Androida

Jeśli biblioteka Performance Monitoring zostanie wyłączona w czasie kompilacji, możesz zdecydować, czy aplikacja ma ją włączyć w czasie działania.

Wyłącz bibliotekę w czasie kompilacji, ale zezwól aplikacji na jej włączenie w czasie działania

Dodaj do pliku AndroidManifest.xml aplikacji element <meta-data>:

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

Wyłącz bibliotekę w czasie kompilacji, ale nie zezwalaj aplikacji na jej włączanie w czasie działania

Dodaj do pliku AndroidManifest.xml aplikacji element <meta-data>:

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

Wyłączanie aplikacji w czasie działania za pomocą funkcji Remote Config

Firebase Remote Config umożliwia wprowadzanie zmian w zachowaniu i wyglądzie aplikacji, dzięki czemu stanowi idealny sposób na wyłączenie Performance Monitoring w wdrożonych instancjach aplikacji.

Aby wyłączyć zbieranie danych Performance Monitoring przy następnym uruchomieniu aplikacji na Androida, użyj przykładowego kodu pokazanego poniżej. Więcej informacji o używaniu funkcji Remote Config w aplikacji na Androida znajdziesz w artykule Korzystanie z funkcji Firebase Remote Config na Androidzie.

Upewnij się, że Remote Config znajduje się w sekcji dependencies w pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle):
Kotlin+KTX
```
  implementation("com.google.firebase:firebase-config-ktx:22.0.1")
```
Java
```
  implementation("com.google.firebase:firebase-config:22.0.1")
```

Skonfiguruj Remote Config i wyłącz Performance Monitoring, jeśli perf_disable jest ustawiony na 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

Dodaj do pliku MainActivity.java ten kod, aby pobrać i aktywować wartości Remote Config:

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

Aby wyłączyć Performance Monitoring w konsoli Firebase, utwórz w projekcie aplikacji parametr perf_disable, a następnie ustaw jego wartość na true.

Ta zmiana spowoduje, że wywołania pakietu SDK Performance Monitoring będą wywołaniami „no operation” (NOOP), co wyeliminuje wpływ na wydajność aplikacji wynikający z korzystania z pakietu SDK Performance Monitoring w aplikacji.

Jeśli ustawisz wartość parametru perf_disable na false, parametr Performance Monitoring pozostanie włączony.