Monitorowanie wykorzystania pamięci flash

Usługa Watchdog monitoruje wykorzystanie pamięci flash, śledząc łączną liczbę operacji zapisu na dysku wykonywanych przez wszystkie aplikacje i usługi za pomocą statystyk operacji wejścia/wyjścia na dysku dla każdego identyfikatora UID udostępnianych przez jądro w lokalizacji `/proc/uid_io/stats`. Gdy aplikacja lub usługa przekroczy próg nadmiernego wykorzystania operacji wejścia/wyjścia na dysku, usługa Watchdog podejmuje działania w odniesieniu do tej aplikacji lub usługi. Progi nadmiernego wykorzystania operacji wejścia/wyjścia dysku i działanie, które należy podjąć w przypadku nadmiernego wykorzystania, są wstępnie zdefiniowane w konfiguracji nadmiernego wykorzystania operacji wejścia/wyjścia dysku.

Progi nadużywania

  • Progi nadmiernego wykorzystania operacji wejścia/wyjścia na dysku są egzekwowane codziennie, tzn. wszystkie zapisy wykonane przez aplikację lub usługę są agregowane od początku bieżącego dnia kalendarzowego UTC i sprawdzane pod kątem progów zdefiniowanych w konfiguracjach nadmiernego wykorzystania.
  • Jeśli pojazd jest uruchamiany kilka razy w ciągu dnia, moduł Watchdog zapisuje statystyki wykorzystania wejścia/wyjścia dysku w pamięci flash i agreguje je od początku bieżącego dnia kalendarzowego UTC.

Działania związane z nadmiernym wykorzystaniem

Gdy aplikacja wielokrotnie przekracza zdefiniowane progi nadmiernego wykorzystania operacji wejścia/wyjścia na dysku, Watchdog podejmuje działania określone w konfiguracji nadmiernego wykorzystania.

  • Wszystkie aplikacje i usługi dostawców są uważane za kluczowe dla ogólnej stabilności systemu, więc nie są zamykane z powodu nadmiernego wykorzystania operacji wejścia/wyjścia na dysku. Konfiguracja nadmiernego użycia może jednak zawierać listę aplikacji i usług dostawców, które można bezpiecznie zakończyć.
  • Wszystkie aplikacje innych firm można bezpiecznie zamknąć.

Gdy aplikacja lub usługa jest bezpieczna do zakończenia, Watchdog wyłącza ją, a stan komponentu aplikacji zmienia się na PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED .

Konfiguracja nadużywania

Konfiguracja nadmiernego wykorzystania zawiera progi nadmiernego wykorzystania operacji wejścia/wyjścia dysku i działania. Domyślne konfiguracje nadmiernego użycia są zdefiniowane w obrazach systemu i dostawcy oraz dostarczane z kompilacją. Dostawcy mogą opcjonalnie uwzględnić konfigurację dostawcy w obrazie dostawcy. Jeśli konfiguracja dostawcy nie jest dostępna, w przypadku aplikacji i usług dostawcy używana jest konfiguracja systemu.

Usługa Watchdog udostępnia interfejsy API systemu za pomocą CarWatchdogManager, co umożliwia dostawcom aplikacji lub usług aktualizowanie konfiguracji dostawcy w dowolnym momencie.

Definicja konfiguracji nadużywania

Konfiguracja nadmiernego wykorzystania jest podzielona według typu komponentu, np. system, dostawca i firma zewnętrzna. Producenci OEM muszą aktualizować tylko konfigurację komponentu dostawcy.

Konfiguracja dostawcy

Konfiguracja dostawcy określa progi nadmiernego wykorzystania operacji wejścia/wyjścia dysku i działania dla wszystkich aplikacji i usług dostawcy oraz wszystkich aplikacji do map i multimediów. Konfiguracja zawiera te pola:

  • Prefiksy pakietów dostawców. Wszystkie pakiety zainstalowane w partycji dostawcy są uznawane za pakiety dostawcy. Oprócz tych pakietów dostawcy mogą klasyfikować preinstalowane pakiety jako pakiety dostawcy, dodając prefiksy pakietów do konfiguracji Prefiksy pakietów dostawcy. Ta konfiguracja nie akceptuje wyrażeń regularnych.
  • Pakiety, które można bezpiecznie zakończyć. Dostawcy mogą określić, które pakiety dostawców można bezpiecznie zakończyć, dodając pełne nazwy pakietów do konfiguracji safe-to-terminate packages.
  • Mapowania kategorii aplikacji Dostawcy mogą zmapować dowolny pakiet (w tym pakiety innych firm) na jedną z 2 obsługiwanych kategorii aplikacji: Mapy i aplikacje multimedialne. Mapowanie to jest wykonywane, aby zapewnić aplikacjom do map i multimediów wyższe progi nadmiernego wykorzystania operacji wejścia/wyjścia dysku, ponieważ aplikacje te zwykle pobierają i zapisują na dysku więcej danych niż inne typy aplikacji.
  • Limity na poziomie komponentu Określa ogólne progi dla wszystkich pakietów dostawców (czyli pakietów, które nie są objęte progami dla konkretnych pakietów ani progami dla konkretnych kategorii aplikacji). Podczas definiowania konfiguracji nadmiernego wykorzystania wejścia/wyjścia dysku dostawcy muszą określić progi na poziomie komponentu, które są różne od zera.
  • Progi dla poszczególnych pakietów Dostawcy mogą określać specjalne progi dla konkretnych pakietów dostawców. Mapowania powinny zawierać pełne nazwy pakietów. Progi zdefiniowane w tej konfiguracji mają pierwszeństwo przed progami zdefiniowanymi w innych konfiguracjach dla danego pakietu.
  • Progi dla poszczególnych kategorii aplikacji. Dostawcy mogą określać specjalne progi dla poszczególnych kategorii aplikacji. Kategorie aplikacji muszą być jednymi z obsługiwanych kategorii – Mapy i multimedia. Progi zdefiniowane w tej konfiguracji są mapowane na konkretne pakiety za pomocą mapowań kategorii aplikacji.
  • Progi w całym systemie Dostawcy nie mogą określać tej konfiguracji.

Konfiguracje prefiksów pakietów dostawcy, pakietów, które można bezpiecznie zakończyć, progów na poziomie komponentu i progów specyficznych dla pakietu można aktualizować tylko za pomocą konfiguracji dostawcy w przypadku aplikacji i usług dostawcy. Konfigurację progów specyficznych dla kategorii aplikacji może aktualizować tylko konfiguracja dostawcy dla wszystkich aplikacji do map i multimediów.

Progi nadmiernego wykorzystania zawierają liczbę bajtów, które można zapisać w ciągu:

  • Tryb działania aplikacji lub usługi na pierwszym planie a tryb działania w tle
  • Systemowy tryb garażowy

Ta klasyfikacja umożliwia aplikacjom i usługom na pierwszym planie, z których korzystają użytkownicy, zapisywanie większej ilości danych niż aplikacje i usługi działające w tle. W trybie garażowym aplikacje i usługi zwykle pobierają aktualizacje, więc każda z nich potrzebuje wyższego progu niż aplikacje i usługi działające w innych trybach.

Konfiguracje systemowe i konfiguracje innych firm

Producenci OEM nie powinni aktualizować konfiguracji systemu ani konfiguracji innych firm.

  • Konfiguracja systemu określa progi nadmiernego wykorzystania wejścia/wyjścia i działania w przypadku aplikacji i usług systemowych.
    • Ta konfiguracja może też aktualizować mapowania kategorii aplikacji. Dlatego to pole konfiguracji jest wspólne dla konfiguracji systemowych i konfiguracji dostawcy.
  • Konfiguracja zewnętrzna określa progi dla wszystkich aplikacji innych firm. Wszystkie aplikacje, które nie są zainstalowane fabrycznie w systemie, to aplikacje innych firm.
    • Wszystkie aplikacje innych firm mają te same progi (np. żadna aplikacja innej firmy nie ma specjalnych progów) z wyjątkiem aplikacji do map i multimediów, których progi są zdefiniowane przez konfigurację dostawcy.
    • Poniższe progi nadmiernego wykorzystania operacji wejścia/wyjścia na dysku to domyślne progi dla aplikacji innych firm. Te progi są dostarczane z obrazem systemu.
      • 3 GiB zapisu w trybie pierwszego planu aplikacji.
      • 2 GiB zapisu w trybie tła aplikacji.
      • 4 GiB zapisu w trybie garażowym systemu.
    • Są to podstawowe progi. Te progi są aktualizowane w miarę zdobywania większej ilości informacji o wykorzystaniu operacji wejścia/wyjścia na dysku.

Format XML konfiguracji nadmiernego wykorzystania

Domyślną konfigurację dostawcy można umieścić (jest to opcjonalne) w lokalizacji /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml w obrazie kompilacji. Jeśli ta konfiguracja nie jest określona, w przypadku aplikacji i usług dostawcy stosowana jest konfiguracja zdefiniowana przez system.

Plik XML powinien zawierać tylko 1 tag dla każdego pola konfiguracji. Konfiguracja nadmiernego wykorzystania operacji wejścia/wyjścia musi być zdefiniowana w pliku XML. Wszystkie wartości progowe należy podać w jednostce MiB.

Przykładowa konfiguracja XML:

<resourceOveruseConfiguration version="1.0">
      <componentType>VENDOR</componentType>

      <!-- List of safe to kill vendor packages. -->
      <safeToKillPackages>
            <package>com.vendor.package.A</package>
            <package>com.vendor.package.B</package>
      </safeToKillPackages>

      <!-- List of vendor package prefixes. -->
      <vendorPackagePrefixes>
            <packagePrefix>com.vendor.package</packagePrefix>
      </vendorPackagePrefixes>

      <!-- List of unique package names to app category mappings. -->
      <packagesToAppCategoryTypes>
            <packageAppCategory type="MEDIA">com.vendor.package.A</packageAppCategory>
            <packageAppCategory type="MAPS">com.google.package.B</packageAppCategory>
            <packageAppCategory type="MEDIA">com.third.party.package.C</packageAppCategory>
      </packagesToAppCategoryTypes>

      <ioOveruseConfiguration>
        <!-- Thresholds in MiB for all vendor packages that don't have package specific thresholds. -->
            <componentLevelThresholds>
                  <state id="foreground_mode">1024</state>
                  <state id="background_mode">512</state>
                  <state id="garage_mode">3072</state>
            </componentLevelThresholds>

            <packageSpecificThresholds>
                  <!-- IDs must be unique -->
                  <perStateThreshold id="com.vendor.package.C">
                    <state id="foreground_mode">400</state>
                    <state id="background_mode">100</state>
                    <state id="garage_mode">200</state>
                  </perStateThreshold>

                  <perStateThreshold id="com.vendor.package.D">
                    <state id="foreground_mode">1024</state>
                    <state id="background_mode">500</state>
                    <state id="garage_mode">2048</state>
                  </perStateThreshold>
            </packageSpecificThresholds>

            <!-- Application category specific thresholds. -->
            <appCategorySpecificThresholds>
                  <!-- One entry per supported application category -->
                  <perStateThreshold id="MEDIA">
                    <state id="foreground_mode">600</state>
                    <state id="background_mode">700</state>
                    <state id="garage_mode">1024</state>
                  </perStateThreshold>

                  <perStateThreshold id="MAPS">
                    <state id="foreground_mode">800</state>
                    <state id="background_mode">900</state>
                    <state id="garage_mode">2048</state>
                  </perStateThreshold>
            </appCategorySpecificThresholds>
      </ioOveruseConfiguration>
</resourceOveruseConfiguration>

Aktualizowanie konfiguracji nadmiernego użycia za pomocą interfejsów API systemu CarWatchdogManager

Powyższą konfigurację XML można podać tylko w obrazie kompilacji. Jeśli producent OEM zdecyduje się zaktualizować konfigurację na urządzeniu po wydaniu kompilacji, może użyć tych interfejsów API, aby wprowadzić zmiany w konfiguracji na urządzeniu.

  • Przyznaj rozmówcy uprawnienia Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG.
  • Musisz użyć istniejących konfiguracji, aby zaktualizować i ustawić nowe konfiguracje. Użyj interfejsu APICarWatchdogManager.getResourceOveruseConfigurations, aby uzyskać istniejące konfiguracje. Jeśli istniejące konfiguracje nie są używane, wszystkie konfiguracje (w tym systemowe i pochodzące od innych firm) są zastępowane, co nie jest zalecane.
  • Zaktualizuj istniejące konfiguracje o zmiany różnicowe i ustaw nowe konfiguracje. Nie aktualizuj konfiguracji systemu ani komponentów innych firm.
  • Użyj interfejsu APICarWatchdogManager.setResourceOveruseConfigurations, aby ustawić nowe konfiguracje.
  • Aby pobrać i ustawić konfiguracje nadmiernego wykorzystania operacji wejścia/wyjścia dysku, użyj flagi CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO.

Oto przykładowa implementacja, która aktualizuje konfiguracje nadmiernego wykorzystania zasobów:

void updateResourceOveruseConfigurations() {
    CarWatchdogManager manager =
        (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);

    List<ResourceOveruseConfiguration> resourceOveruseConfigurations =
        manager.getResourceOveruseConfigurations(
            CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO);

    List<ResourceOveruseConfiguration> newResourceOveruseConfigurations =
            new List<>();
    ResourceOveruseConfiguration vendorConfiguration;
    for(ResourceOveruseConfiguration config : resourceOveruseConfigurations) {
        // Do not update the configurations of the system and third-party component types.
        if (config.getComponentType()
            != ResourceOveruseConfiguration.COMPONENT_TYPE_VENDOR) {
            newResourceOveruseConfigurations.add(config);
            continue;
        }
        vendorConfiguration = config;
    }

    if (vendorConfiguration == null) {
        ResourceOveruseConfiguration.Builder vendorConfigBuilder =
            new ResourceOveruseConfiguration.Builder();
        initializeConfig(vendorConfigBuilder);
        newResourceOveruseConfigurations.add(vendorConfigBuilder.build());
    } else {
        ResourceOveruseConfiguration newVendorConfig =
            updateConfig(vendorConfiguration);
        newResourceOveruseConfigurations.add(newVendorConfig);
    }
    int result = manager.setResourceOveruseConfigurations(
        newResourceOveruseConfigurations,

    if (result != CarWatchdogManager.RETURN_CODE_SUCCESS) {
        // Failed to set the resource overuse configurations.
    }
}

/** Sets the delta between the old configuration and the new configuration. */
ResourceOveruseConfiguration updateConfig(
    ResourceOveruseConfiguration oldConfiguration) {
    // Replace com.vendor.package.A with com.vendor.package.B in the safe-to-kill list.
    List<String> safeToKillPackages = oldConfiguration.getSafeToKillPackages();
    safeToKillPackages.remove("com.vendor.package.A");
    safeToKillPackages.add("com.vendor.package.B");

    ResourceOveruseConfiguration.Builder configBuilder =
        new ResourceOveruseConfiguration.Builder(
            oldConfiguration.getComponentType(),
            safeToKillPackages,
            oldConfiguration.getVendorPackagePrefixes(),
            oldConfiguration.getPackagesToAppCategoryTypes());

    configBuilder.addVendorPackagePrefixes("com.vendor.");
    configBuilder.addPackagesToAppCategoryTypes("com.vendor.package.B",
        ResourceOveruseConfiguration.APPLICATION_CATEGORY_TYPE_MAPS);

    IoOveruseConfiguration oldIoConfiguration = oldConfiguration.getIoOveruseConfiguration();
    IoOveruseConfiguration.Builder ioConfigBuilder =
        new IoOveruseConfiguration.Builder(
            oldIoConfiguration.getComponentLevelThresholds(),
            oldIoConfiguration.getPackageSpecificThresholds(),
            oldIoConfiguration.getAppCategorySpecificThresholds(),
            oldIoConfiguration.getSystemWideThresholds());

    // Define the amount of bytes based on the flash memory specification, expected lifetime,
    // and estimated average amount of bytes written by a package during different modes.
    ioConfigBuilder.addPackageSpecificThresholds("com.vendor.package.B",
        new PerStateBytes(/* foregroundModeBytes= */ 2 * 1024 * 1024 * 1024,
                          /* backgroundModeBytes= */ 500 * 1024 * 1024,
                          /* garageModeBytes= */ 3 * 1024 * 1024 * 1024));


    return configBuilder.setIoOveruseConfiguration(ioConfigBuilder.build()).build();
}

Aplikacje monitorujące nadmierne wykorzystanie zasobów

Aplikacje dostawców i innych firm mogą nasłuchiwać powiadomień o nadmiernym wykorzystaniu zasobów przez aplikację z usługi Watchdog lub odpytywać CarWatchdogManager o statystyki nadmiernego wykorzystania zasobów przez aplikację z okresu do 30 dni.

Odsłuchiwanie powiadomień o nadmiernym wykorzystaniu zasobów

Aplikacje mogą wdrożyć odbiornik nadmiernego wykorzystania zasobów i zarejestrować go w CarWatchdogManager, aby otrzymywać powiadomienia dotyczące aplikacji, gdy przekroczą 80% lub 100% progów nadmiernego wykorzystania operacji wejścia/wyjścia na dysku. Aplikacje mogą używać tych powiadomień do:

  • Rejestruj statystyki nadmiernego wykorzystania operacji wejścia/wyjścia na dysku do analizy offline. Deweloperzy aplikacji mogą używać tych logów do debugowania problemu nadmiernego wykorzystania operacji wejścia/wyjścia na dysku.
  • Zmniejsz liczbę operacji zapisu wejścia/wyjścia na dysku, dopóki liczniki nadmiernego wykorzystania nie zostaną zresetowane.

Klient Java

  1. Zaimplementuj odbiornik, dziedzicząc po CarWatchdogManager.ResourceOveruseListener: 
    class ResourceOveruseListenerImpl implements
      CarWatchdogManager.ResourceOveruseListener {
            @Override
            public void onOveruse(
                  @NonNull ResourceOveruseStats resourceOveruseStats) {
                  // 1. Log/Upload resource overuse metrics.
                  // 2. Reduce writes until the counters reset.

                  IoOveruseStats ioOveruseStats = resourceOveruseStats.getIoOveruseStats();
                  // Stats period - [ioOveruseStats.getStartTime(), ioOveruseStats.getStartTime()
                  //   + ioOveruseStats.getDurationInSeconds()]
                  // Total I/O overuses - ioOveruseStats.getTotalOveruses()
                  // Total bytes written - ioOveruseStats.getTotalBytesWritten()
                  // Remaining write bytes for the current UTC calendar day -
                  //    ioOveruseStats.getRemainingWriteBytes()
            }
      }
}
  2. Zarejestruj instancję detektora zdarzeń, wywołując CarWatchdogManager.addResourceOveruseListener 
    private void addResourceOveruseListener() {
      CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
      // Choose a proper executor to handle resource overuse notifications.
      Executor executor = mContext.getMainExecutor();
      manager.addResourceOveruseListener(
            executor, CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO,
            mListenerImpl);
}
  3. Wyrejestrowanie instancji detektora po zakończeniu nasłuchiwania przez aplikację: 
    private void removeResourceOveruseListener() {
    CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
    mCarWatchdogManager.removeResourceOveruseListener(
          mListenerImpl);
}

Klient natywny

  1. Uwzględnij carwatchdog_aidl_interface-ndk_platform w zależności shared_libs reguły kompilacji.

    Android.bp

    cc_binary {
    name: "sample_native_client",
    srcs: [
        "src/*.cpp"
    ],
    shared_libs: [
        "carwatchdog_aidl_interface-ndk_platform",
        "libbinder_ndk",
    ],
    vendor: true,
}
  2. Dodaj zasadę SELinux, aby zezwolić domenie usługi dostawcy na używanie bindera (makro binder_user), i dodaj domenę usługi dostawcy do carwatchdogdomeny klienta(carwatchdog_client_domain macro). Poniżej znajdziesz kod dla sample_client.te i file_contexts.

    sample_client.te

    type sample_client, domain;
type sample_client_exec, exec_type, file_type, vendor_file_type;

carwatchdog_client_domain(sample_client)

init_daemon_domain(sample_client)
binder_use(sample_client)

    file_contexts

    /vendor/bin/sample_native_client  u:object_r:sample_client_exec:s0
  3. Zaimplementuj odbiornik nadmiernego wykorzystania zasobów, dziedzicząc po klasie BnResourceOveruseListener. Zastąp BnResourceOveruseListener::onOveruse, aby obsługiwać powiadomienia o nadmiernym wykorzystaniu zasobów.

    ResourceOveruseListenerImpl.h

    class ResourceOveruseListenerImpl : public BnResourceOveruseListener {
public:
    ndk::ScopedAStatus onOveruse(
        ResourceOveruseStats resourceOveruseStats) override;

private:
    void initialize();
    void terminate();

    std::shared_ptr<ICarWatchdog> mWatchdogServer;
    std::shared_ptr<IResourceOveruseListener> mListener;
}

    ResourceOveruseListenerImpl.cpp

    ndk::ScopedAStatus ResourceOveruseListenerImpl::onOveruse(
      ResourceOveruseStats resourceOveruseStats) {

      // 1. Log/Upload resource overuse metrics.
      // 2. Reduce writes until the counters reset.

      if (stats.getTag() != ResourceOveruseStats::ioOveruseStats) {
            // Received resourceOveruseStats doesn't contain I/O overuse stats.
      }

      const IoOveruseStats& ioOveruseStats = stats.get();
      // Stats period - [ioOveruseStats.startTime,
      //   ioOveruseStats.startTime + ioOveruseStats.durationInSeconds]
      // Total I/O overuses - ioOveruseStats.totalOveruses
      // Total bytes written - ioOveruseStats.writtenBytes
      // Remaining write bytes for the current UTC calendar day -
      //    ioOveruseStats.remainingWriteBytes

      return ndk::ScopedAStatus::ok();
}
  4. Uruchom pulę wątków powiązań i zarejestruj odbiorcę nadmiernego wykorzystania zasobów na serwerze nadzorującym. Serwer nadzorujący jest zarejestrowany pod nazwą usługi android.automotive.watchdog.ICarWatchdog/default.

    main.cpp

    int main(int argc, char** argv) {
    ABinderProcess_setThreadPoolMaxThreadCount(1);
    ABinderProcess_startThreadPool();
    std::shared_ptr<ResourceOveruseListenerImpl> listener =
        ndk::SharedRefBase::make<ResourceOveruseListenerImpl>();

    // The listener is added in initialize().
    listener->initialize();

    ... Run service ...

    // The listener is removed in terminate().
    listener->terminate();
}

    ResourceOveruseListenerImpl.cpp

    void ResourceOveruseListener::initialize() {
    ndk::SpAIBinder binder(AServiceManager_getService(
            "android.automotive.watchdog.ICarWatchdog/default"));
    std::shared_ptr<ICarWatchdog> server = ICarWatchdog::fromBinder(binder);
    mWatchdogServer = server;

    std::shared_ptr<IResourceOveruseListener> listener =
        IResourceOveruseListener::fromBinder(this->asBinder());
    mWatchdogServer->addResourceOveruseListener(
      std::vector<int>{ResourceType.IO}, listener);
    mListener = listener;
}

void ResourceOveruseListener::terminate() {
    mWatchdogServer->removeResourceOveruseListener(mListener);
}

Sprawdzanie statystyk nadmiernego wykorzystania zasobów

Aplikacje mogą odpytywać CarWatchdogManager o statystyki ATS dotyczące nadmiernego wykorzystania wejścia/wyjścia przez aplikację z ostatnich 30 dni.

Klient Java

Użyj CarWatchdogManager.getResourceOveruseStats, aby uzyskać statystyki nadmiernego wykorzystania zasobów. Przekaż flagę CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO, aby uzyskać statystyki nadmiernego wykorzystania operacji wejścia/wyjścia na dysku.

private void getResourceOveruseStats() {
      CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);

      // Returns resource overuse stats with I/O overuse stats for the past
      // 7 days. Stats are available for up to the past 30 days.
      ResourceOveruseStats resourceOveruseStats =
            mCarWatchdogManager.getResourceOveruseStats(
                  CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO,
                  CarWatchdogManager.STATS_PERIOD_PAST_7_DAYS);

      IoOveruseStats ioOveruseStats = resourceOveruseStats.getIoOveruseStats();
      // Stats period - [ioOveruseStats.getStartTime(), ioOveruseStats.getStartTime()
      //   + ioOveruseStats.getDurationInSeconds()]
      // Total I/O overuses - ioOveruseStats.getTotalOveruses()
      // Total bytes written - ioOveruseStats.getTotalBytesWritten()
      // Remaining write bytes for the UTC calendar day -
      //    ioOveruseStats.getRemainingWriteBytes()
}

Klient natywny

Użyj CarWatchdogServer.getResourceOveruseStats, aby uzyskać statystyki nadmiernego wykorzystania zasobów. Przekaż wyliczenie ResourceType.IO, aby pobrać statystyki nadmiernego wykorzystania operacji wejścia/wyjścia dysku.

void getResourceOveruseStats() {
      ndk::SpAIBinder binder(AServiceManager_getService(
            "android.automotive.watchdog.ICarWatchdog/default"));
      std::shared_ptr<ICarWatchdog> server = ICarWatchdog::fromBinder(binder);
      // Returns the stats only for the current UTC calendar day.
      const std::vector<ResourceOveruseStats> resourceOveruseStats;
      ndk::ScopedAStatus status = server.getResourceOveruseStats(
            std::vector<int>{ResourceType.IO}, &resourceOveruseStats);
      if (!status.isOk()) {
            // Failed to get the resource overuse stats.
            return;
      }

      for (const auto& stats : resourceOveruseStats) {
            if (stats.getTag() != ResourceOveruseStats::ioOveruseStats) {
                  continue;
            }
            const IoOveruseStats& ioOveruseStats = stats.get();
            // Stats period - [ioOveruseStats.startTime,
            //   ioOveruseStats.startTime + ioOveruseStats.durationInSeconds]
            // Total I/O overuses - ioOveruseStats.totalOveruses
            // Total bytes written - ioOveruseStats.writtenBytes
            // Remaining write bytes for the current UTC calendar day -
            //   ioOveruseStats.remainingWriteBytes
      }
}

Wrażenia użytkowników w przypadku nadmiernego zużycia zasobów

W sekcjach poniżej opisujemy, co się dzieje, gdy zasoby są nadmiernie wykorzystywane.

Ustawienie zwiększonej wydajności aplikacji

Strona Ustawienia aplikacji zawiera ustawieniaPrioritize app performance (patrz obraz poniżej), które pozwalają użytkownikom priorytetowo traktować wydajność aplikacji w stosunku do systemu i długoterminowej wydajności sprzętu. To ustawienie jest dostępne tylko w przypadku aplikacji, które można bezpiecznie zakończyć w przypadku nadmiernego wykorzystania zasobów. W przeciwnym razie to ustawienie jest wyłączone. Gdy to ustawienie jest wyłączone (domyślnie) w przypadku aplikacji, może ona zostać zamknięta z powodu nadmiernego wykorzystania zasobów. W przeciwnym razie aplikacja nie zostanie zamknięta z powodu nadmiernego wykorzystania zasobów.

Gdy użytkownik włączy to ustawienie, w oknie potwierdzenia pojawi się opis konsekwencji włączenia tego ustawienia:

Po 90 dniach to ustawienie zostanie automatycznie przywrócone do wartości domyślnej. Limit dni można zmienić za pomocą aplikacji nakładkowej RRO, używając watchdogUserPackageSettingsResetDays, do maksymalnie 180 dni. Więcej informacji znajdziesz w artykule Zmiana wartości zasobów aplikacji w czasie działania. W pliku AndroidManifest.xml można umieścić ten przykładowy tag nakładki:

<overlay android:priority="<insert-value>"
      android:targetPackage="com.android.car.updatable"
      android:targetName="CarServiceCustomization"
      android:resourcesMap="@xml/overlays" />

W res/values/config.xml:

<resources>
  <integer name="watchdogUserPackageSettingsResetDays">value</integer>
</resources>

W res/xml/overlays.xml:

<overlay>
  <item target="integer/watchdogUserPackageSettingsResetDays" value="@integer/watchdogUserPackageSettingsResetDays" />
</overlay>

Ustawienie aplikacji wpływających na wydajność

Aplikacja Ustawienia zawiera sekcję Aplikacje wpływające na wydajność (patrz rysunek 1). Po kliknięciu wyświetli się lista aplikacji, które zostały ograniczone z powodu nadmiernego wykorzystania pamięci flash i negatywnie wpływają na wydajność systemu. Jest to zgodne z wymaganiem CDD 3.5.1 [C-1-1].

Aplikacje wpływające na wydajność

Rysunek 1. Aplikacje wpływające na wydajność.

Aplikacje zakończone z powodu nadmiernego wykorzystania zasobów są wymienione tutaj (patrz rysunek 2). Wymienione aplikacje mogą być traktowane priorytetowo. Więcej informacji znajdziesz w sekcji Ustawienie nadawania priorytetu działaniu aplikacji.

Lista aplikacji, które zostały zakończone z powodu nadmiernego wykorzystania zasobów

Rysunek 2. Lista aplikacji, które zostały zamknięte z powodu nadmiernego wykorzystania zasobów.

Powiadomienie użytkownika

Gdy aplikacja lub usługa wielokrotnie nadużywa operacji wejścia/wyjścia na dysku (np. zapisuje dane na dysku powyżej określonych progów) w określonym czasie i można ją bezpiecznie zakończyć z powodu nadmiernego wykorzystania zasobów, użytkownik otrzymuje powiadomienie po tym, jak pojazd przejdzie w stan, w którym kierowca może się rozpraszać.

Pierwsze powiadomienie dla użytkownika (podczas jazdy) jest wyświetlane jako powiadomienie z wyprzedzeniem, a pozostałe powiadomienia są wyświetlane w centrum powiadomień.

Jeśli na przykład aplikacja wielokrotnie nadużywa operacji wejścia/wyjścia na dysku, użytkownik otrzyma to powiadomienie:

  • Gdy użytkownik kliknie przycisk Priorytet dla aplikacji, otworzy się strona ustawień aplikacji, na której może włączyć lub wyłączyć ustawienie Priorytet dla wydajności aplikacji.
  • Gdy użytkownik kliknie przycisk Wyłącz aplikację, aplikacja zostanie wyłączona, dopóki użytkownik nie uruchomi jej lub nie włączy na stronie ustawień aplikacji.
  • W przypadku aplikacji, których nie można odinstalować, przycisk Wyłącz aplikację jest zastępowany przyciskiem Odinstaluj aplikację. Gdy użytkownik kliknie przycisk Odinstaluj aplikację, otworzy się strona Ustawienia aplikacji, z której może ją odinstalować.

Zalecenia dotyczące implementacji programu uruchamiającego

Gdy aplikacje zostaną wyłączone z powodu nadmiernego wykorzystania zasobów, znikną z domyślnej aplikacji uruchamiającej, ponieważ CarService aktualizuje stan włączenia aplikacji jako PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED. Producenci OEM muszą zaktualizować wbudowany program uruchamiający, aby te aplikacje były wyświetlane jak zwykle, dzięki czemu użytkownicy będą mogli z nich korzystać w razie potrzeby. Zapoznaj się z tymi rekomendacjami dotyczącymi wersji kompilacji.

Wprowadzenie Androida SC V2