Monitorowanie wykorzystania pamięci flash

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

Progi nadmiernego wykorzystania

  • Progi nadmiernego wykorzystania wejścia/wyjścia na dysku są egzekwowane codziennie. Oznacza to, że wszystkie zapisy wykonywane 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.
  • Gdy pojazd jest uruchamiany kilka razy w ciągu dnia, moduł Watchdog zapisuje statystyki wykorzystania wejścia/wyjścia na dysku w pamięci flash i agreguje je od początku bieżącego dnia kalendarzowego UTC.

Działania w przypadku nadmiernego wykorzystania

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

  • Wszystkie aplikacje i usługi dostawcy są uważane za krytyczne dla ogólnej stabilności systemu, dlatego nie są zamykane w przypadku nadmiernego wykorzystania wejścia/wyjścia na dysku. Konfiguracja nadmiernego wykorzystania może jednak zawierać listę aplikacji i usług dostawcy, które można bezpiecznie zamknąć.
  • Wszystkie aplikacje innych firm można bezpiecznie zamknąć.

Gdy aplikację lub usługę można bezpiecznie zamknąć, usługa Watchdog wyłącza ją, ustawiając stan komponentu aplikacji na PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED .

Konfiguracja nadmiernego wykorzystania

Konfiguracja nadmiernego wykorzystania zawiera progi nadmiernego wykorzystania wejścia/wyjścia na dysku oraz działania. Domyślne konfiguracje nadmiernego wykorzystania są zdefiniowane w obrazach systemu i dostawcy oraz dostarczane z kompilacją. Opcjonalnie dostawcy mogą 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ą interfejsu CarWatchdogManager, który umożliwia aplikacjom i usługom dostawcy aktualizowanie konfiguracji dostawcy w dowolnym momencie.

Definicja konfiguracji nadmiernego wykorzystania

Konfiguracja nadmiernego wykorzystania jest podzielona według typu komponentu, np. systemowego, dostawcy i innej firmy. Producenci OEM muszą aktualizować tylko konfigurację komponentu dostawcy.

Konfiguracja dostawcy

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

  • Prefiksy pakietów dostawcy. Wszystkie pakiety zainstalowane w partycji dostawcy są uważane 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 zamknąć. Dostawcy mogą określić, które pakiety dostawcy można bezpiecznie zamknąć, dodając pełne nazwy pakietów do konfiguracji Pakiety, które można bezpiecznie zamknąć.
  • Mapowania kategorii aplikacji. Dostawcy mogą mapować dowolny pakiet (w tym pakiety innych firm) na jedną z 2 obsługiwanych kategorii aplikacji – Mapy i Aplikacje multimedialne. To mapowanie jest wykonywane, aby zapewnić aplikacjom map i multimediów wyższe progi nadmiernego wykorzystania wejścia/wyjścia na dysku, ponieważ te aplikacje zwykle pobierają i zapisują na dysku więcej danych niż inne typy aplikacji.
  • Progi na poziomie komponentu. Określa ogólne progi dla wszystkich pakietów dostawcy (czyli pakiety, 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 na dysku dostawcy muszą określić progi na poziomie komponentu, które nie są równe 0, gdy definiują konfigurację nadmiernego wykorzystania wejścia/wyjścia na dysku.
  • Progi dla konkretnych pakietów. Dostawcy mogą określić specjalne progi dla konkretnych pakietów dostawcy. 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 konkretnych kategorii aplikacji. Dostawcy mogą określić specjalne progi dla konkretnych kategorii aplikacji. Kategorie aplikacji muszą być jedną z obsługiwanych kategorii – Mapy i Aplikacje multimedialne. Progi zdefiniowane w tej konfiguracji są mapowane na konkretne pakiety za pomocą Mapowania kategorii aplikacji.
  • Progi systemowe. Dostawcy nie mogą określać tej konfiguracji.

Prefiksy pakietów dostawcy, Pakiety, które można bezpiecznie zamknąć, Progi na poziomie komponentu i Progi dla konkretnych pakietów można aktualizować tylko za pomocą konfiguracji dostawcy w przypadku aplikacji i usług dostawcy. Konfigurację Progi dla konkretnych kategorii aplikacji można aktualizować tylko za pomocą konfiguracji dostawcy w przypadku wszystkich aplikacji map i multimediów.

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

  • działania aplikacji lub usługi na pierwszym planie w porównaniu z działaniem w tle;
  • trybu garażowego systemu.

Ta klasyfikacja umożliwia aplikacjom i usługom działającym 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, dlatego każda z nich potrzebuje wyższego progu niż aplikacje i usługi działające w innych trybach.

Konfiguracje systemu i innych firm

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

  • Konfiguracja systemu określa progi nadmiernego wykorzystania wejścia/wyjścia oraz działania w przypadku aplikacji i usług systemowych.
    • Ta konfiguracja może też aktualizować Mapowania kategorii aplikacji. Dlatego to pole konfiguracji jest współdzielone przez konfiguracje systemu i dostawcy.
  • Konfiguracja innej firmy określa progi dla wszystkich aplikacji innych firm. Wszystkie aplikacje, które nie są preinstalowane w systemie, są aplikacjami innych firm.
    • Wszystkie aplikacje innych firm otrzymują te same progi (np. żadna aplikacja innej firmy nie otrzymuje specjalnych progów) z wyjątkiem aplikacji map i multimediów których progi są określane przez konfigurację dostawcy.
    • Poniższe progi nadmiernego wykorzystania wejścia/wyjścia na dysku są domyślnymi progami dla aplikacji innych firm. Te progi są dostarczane z obrazem systemu.
      • 3 GiB zapisu w trybie działania aplikacji na pierwszym planie.
      • 2 GiB zapisu w trybie działania aplikacji w tle.
      • 4 GiB zapisu w trybie garażowym systemu.
    • Są to progi podstawowe. Te progi są aktualizowane w miarę zdobywania wiedzy o wykorzystaniu wejścia/wyjścia na dysku.

Format XML konfiguracji nadmiernego wykorzystania

Opcjonalnie: w Androidzie 16 i nowszych wersjach możesz umieścić domyślną konfigurację dostawcy w pliku /vendor/etc/io-watchdog/resource_overuse_configuration.xml w obrazie kompilacji.

W Androidzie 15 i starszych wersjach możesz umieścić domyślną konfigurację dostawcy w pliku /vendor/etc/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 w systemie.

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

Poniżej znajdziesz przykładową konfigurację 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 wykorzystania 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 uprawnienie Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG wywołującemu.
  • Aby zaktualizować i ustawić nowe konfiguracje , musisz użyć dotychczasowych konfiguracji. Aby uzyskać dotychczasowe konfiguracje, użyj interfejsu API CarWatchdogManager.getResourceOveruseConfigurations Jeśli nie użyjesz dotychczasowych konfiguracji, wszystkie konfiguracje (w tym konfiguracje systemu i innych firm) zostaną zastąpione, co nie jest zalecane.
  • Zaktualizuj dotychczasowe konfiguracje o zmiany i ustaw nowe konfiguracje. Nie aktualizuj konfiguracji komponentów systemu i innych firm.
  • Aby ustawić nowe konfiguracje, użyj interfejsu API CarWatchdogManager.setResourceOveruseConfigurations.
  • Aby uzyskać i ustawić konfiguracje nadmiernego wykorzystania wejścia/wyjścia na 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 dostawcy i innych firm mogą nasłuchiwać powiadomienia o nadmiernym wykorzystaniu zasobów przez aplikację z usługi Watchdog lub odpytywać interfejs CarWatchdogManager o statystyki nadmiernego wykorzystania zasobów przez aplikację z ostatnich 30 dni.

Nasłuchiwanie powiadomień o nadmiernym wykorzystaniu zasobów

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

  • rejestrowania statystyk nadmiernego wykorzystania wejścia/wyjścia na dysku na potrzeby analizy offline; deweloperzy aplikacji mogą używać tego rejestrowania do debugowania problemu nadmiernego wykorzystania wejścia/wyjścia na dysku;
  • zmniejszania liczby zapisów wejścia/wyjścia na dysku do momentu zresetowania liczników nadmiernego wykorzystania.

Klient Java

  1. Zaimplementuj detektor zdarzeń, 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. Wyrejestruj instancję detektora zdarzeń, gdy aplikacja przestanie nasłuchiwać: 
    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 (binder_user makro) i dodaj domenę usługi dostawcy do carwatchdog domeny klienta (carwatchdog_client_domain macro). Więcej informacji znajdziesz w kodzie poniżej w plikach 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 detektor nadmiernego wykorzystania zasobów, dziedzicząc po 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 bindera i zarejestruj detektor nadmiernego wykorzystania zasobów na serwerze Watchdog. Serwer Watchdog 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);
}

Odpytywanie statystyk nadmiernego wykorzystania zasobów

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

Klient Java

Aby uzyskać statystyki nadmiernego wykorzystania zasobów, użyj CarWatchdogManager.getResourceOveruseStats. Aby uzyskać statystyki nadmiernego wykorzystania wejścia/wyjścia na dysku, przekaż flagę CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO.

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

Aby uzyskać statystyki nadmiernego wykorzystania zasobów, użyj CarWatchdogServer.getResourceOveruseStats. Aby pobrać statystyki nadmiernego wykorzystania wejścia/wyjścia na dysku, przekaż wyliczenie ResourceType.IO.

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żytkownika związane z nadmiernym wykorzystaniem zasobów

W sekcjach poniżej opisujemy wrażenia użytkownika w przypadku nadmiernego wykorzystania zasobów.

Ustawienie „Nadaj priorytet wydajności aplikacji”

Strona Ustawienia aplikacji zawiera ustawienie Prioritize app performance (patrz obraz poniżej), które umożliwia użytkownikom nadanie priorytetu działaniu aplikacji przed działaniem systemu i długoterminowym działaniem sprzętu. To ustawienie jest dostępne tylko w przypadku aplikacji, które można bezpiecznie zamknąć w przypadku nadmiernego wykorzystania zasobów. W przeciwnym razie to ustawienie jest wyłączone. Gdy to ustawienie jest wyłączone (ustawienie domyślne) w przypadku aplikacji, aplikacja może zostać zamknięta w przypadku nadmiernego wykorzystania zasobów. W przeciwnym razie aplikacja nie zostanie zamknięta w przypadku nadmiernego wykorzystania zasobów.

Gdy użytkownik włączy to ustawienie, pojawi się to okno dialogowe z prośbą o potwierdzenie, które opisuje konsekwencje włączenia tego ustawienia:

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

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

W pliku res/values/config.xml:

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

W pliku res/xml/overlays.xml:

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

Ustawienie „Aplikacje wpływające na wydajność”

Aplikacja Ustawienia zawiera sekcję Aplikacje wpływające na wydajność (patrz rysunek 1). Po kliknięciu wyświetla się lista aplikacji, które zostały ograniczone z powodu nadmiernego wykorzystania pamięci flash i które 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 zamknięte z powodu nadmiernego wykorzystania zasobów są wymienione tutaj (patrz rysunek 2). Wymienionym aplikacjom można nadać priorytet. Więcej informacji znajdziesz w sekcji Ustawienie „Nadaj priorytet wydajności aplikacji”.

Lista aplikacji zakończonych z powodu nadmiernego wykorzystania zasobów

Rysunek 2. Lista aplikacji zamkniętych z powodu nadmiernego wykorzystania zasobów.

Powiadomienie dla użytkownika

Gdy aplikacja lub usługa wielokrotnie nadmiernie wykorzystuje wejście/wyjście na dysku (np. zapisuje dane na dysku poza zdefiniowanymi progami) w określonym czasie i można ją bezpiecznie zamknąć w przypadku nadmiernego wykorzystania zasobów, użytkownik otrzymuje powiadomienie po tym, jak pojazd przejdzie w stan, w którym kierowca może się rozproszyć.

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

Gdy na przykład aplikacja wielokrotnie nadmiernie wykorzystuje wejście/wyjście na dysku, użytkownik otrzymuje to powiadomienie:

  • Gdy użytkownik kliknie przycisk Nadaj priorytet aplikacji, otworzy się strona ustawień aplikacji, na której użytkownik może włączyć lub wyłączyć ustawienie Nadaj priorytet 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 ustawień aplikacji, z której użytkownik może odinstalować aplikację.

Zalecenia dotyczące implementacji aplikacji uruchamiającej

Gdy aplikacje są wyłączane z powodu nadmiernego wykorzystania zasobów, znikają z domyślnej aplikacji uruchamiającej, ponieważ usługa CarService aktualizuje stan włączenia aplikacji jako PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED. Producenci OEM muszą zaktualizować wbudowaną implementację aplikacji uruchamiającej, aby wyświetlać te aplikacje jak zwykle, dzięki czemu użytkownicy będą mogli ich używać w razie potrzeby. Zapoznaj się z tymi zaleceniami na podstawie wersji kompilacji.

Wprowadzenie Androida SC V2