Wyłącz Monitorowanie wydajności Firebase

Podczas tworzenia i testowania aplikacji warto wyłączyć Monitorowanie wydajności.

Na przykład: wyłączyć Monitorowanie wydajności podczas tworzenia aplikacji, możesz:

  • wyłączyć niektóre funkcje Monitorowania wydajności (np. te udostępniane przez wtyczka do monitorowania wydajności do Gradle) w kompilacjach do debugowania, ale ponownie włączyć funkcje kompilację do publikacji.

  • Wyłącz Monitorowanie wydajności podczas tworzenia aplikacji i pozwól aplikacji na jej ponowne włączenie w czasie działania aplikacji.

  • Wyłącz Monitorowanie wydajności podczas tworzenia aplikacji i nie zezwalaj aplikacji na: włącz ją ponownie w czasie działania aplikacji.

Możesz też utworzyć aplikację z włączonym Monitorem wydajności, ale użyj Zdalnej konfiguracji Firebase, możliwość wyłączenia (i ponownego włączenia) monitorowania wydajności w aplikacji produkcyjnej. Na tę opcję, możesz nawet skonfigurować aplikację tak, aby zezwalała użytkownikom za pomocą Monitorowania wydajności.

Wyłączanie monitorowania wydajności podczas kompilacji aplikacji

Monitorowanie wydajności możesz wyłączyć podczas procesu kompilacji przez wyłączenie wtyczki do monitorowania wydajności lub wyłączeniu biblioteki monitorowania wydajności na Androida.

Podczas programowania i debugowania warto wyłączyć wtyczkę, ponieważ instrumentacja utworzona przez wtyczkę może się przyczynić do wydłużenia czasu kompilacji. Warto jednak rozważyć Biblioteka, dzięki czemu możesz nadal wyświetlać dane o skuteczności uruchamianie aplikacji, śledzenie aplikacji na pierwszym planie i śledzenie aplikacji w tle jak i żadnych niestandardowe ślady kodu w aplikacji.

Wyłącz wtyczkę Gradle Monitoringu wydajności

Możesz wyłączyć wtyczkę Monitorowanie wydajności, dodając instrumentationEnabled flagą, korzystając z tych opcji:

  • Extension Property – wyłącza wtyczkę dla: konkretny wariant kompilacji w czasie kompilacji;

  • Project Property – wyłącza wtyczkę dla: wszystkie warianty kompilacji podczas kompilowania

Wyłącz wtyczkę za pomocą flagi właściwości rozszerzenia

Za pomocą flagi Extensions Property możesz wyłączyć wtyczkę do monitorowania wydajności dla konkretnego wariantu kompilacji podczas kompilowania.

  1. w pliku Gradle na poziomie głównym (na poziomie projektu); (<project>/build.gradle.kts lub <project>/build.gradle), upewnij się, Zależność wtyczki Androida do obsługi Gradle jest określona jako wersja 3.4.0 lub nowsza.

    We wcześniejszych wersjach wtyczki Android do obsługi Gradle nadal możesz ją wyłączyć wtyczki Monitorowanie wydajności dla określonego wariantu kompilacji, ale czas kompilacji będzie wpływ na ten wariant nie zostanie całkowicie wyeliminowany.

  2. Dodaj poniższą flagę do pliku Gradle modułu (na poziomie aplikacji) (zwykle <project>/<app-module>/build.gradle.kts lub <project>/<app-module>/build.gradle), a następnie ustaw ją na false, aby wyłączyć do monitorowania wydajności.

    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łącz wtyczkę za pomocą flagi właściwości projektu

Używając flagi Project Property, możesz wyłączyć wtyczkę do monitorowania wydajności wszystkich wariantów kompilacji podczas kompilowania.

Dodaj poniższą flagę do pliku gradle.properties, a następnie ustaw ją na false , aby wyłączyć wtyczkę Performance Monitoring.

// ...

// 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 monitorowania wydajności na urządzeniach z Androidem

Jeśli wyłączysz bibliotekę Monitorowania wydajności podczas kompilowania, możesz określić, czy aby umożliwić aplikacji włączanie biblioteki w czasie działania.

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

Dodaj ten element <meta-data> do tagu AndroidManifest.xml aplikacji plik:

  <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 ten element <meta-data> do tagu AndroidManifest.xml aplikacji plik:

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

Wyłączaj aplikację w czasie działania za pomocą Zdalnej konfiguracji

Zdalna konfiguracja Firebase umożliwia zmianę działania i wyglądu jest idealnym sposobem na wyłączenie Monitorowania wydajności instancji wdrożonych aplikacji.

Aby wyłączyć zbieranie danych w Monitorowaniu wydajności, gdy następnym razem Twoja aplikacja na Androida użyj przykładowego kodu widocznego poniżej. Więcej informacji o korzystaniu z Zdalna konfiguracja w aplikacji na Androida – zobacz Użyj Zdalnej konfiguracji Firebase na Androidzie.

  1. Upewnij się, że Zdalna konfiguracja znajduje się w sekcji dependencies moduł (na poziomie aplikacji) Gradle (zwykle <project>/<app-module>/build.gradle.kts lub <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")

  2. Skonfiguruj Zdalną konfigurację i wyłącz Monitorowanie wydajności, jeśli zasada perf_disable ma wartość ustaw jako 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

  3. Dodaj do pliku MainActivity.java ten kod, aby pobrać i aktywować ten kod Wartości Zdalnej konfiguracji:

    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

  4. Aby wyłączyć Monitorowanie wydajności w konsoli Firebase, utwórz perf_disable, w projekcie aplikacji, a potem ustaw jego wartość na true.

    Ta zmiana spowoduje brak operacji w pakiecie SDK Performance Monitoring połączeń (NOOPs), eliminując wpływ używania pakietu SDK do monitorowania wydajności w aplikacji.

    Jeśli ustawisz wartość perf_disable na false, monitorowanie wydajności pozostanie bez zmian. .