Monitorowanie wykorzystania pamięci flash

Watchdog monitoruje wykorzystanie pamięci flash, śledząc łączną ilość operacji wejścia-wyjścia dysku zapisy generowane przez wszystkie aplikacje i usługi korzystające ze statystyk wejścia-wyjścia dla poszczególnych dysków UID ujawnione przez jądro w lokalizacji `/proc/uid_io/stats`. Gdy aplikacja lub usługa przekroczy próg przeciążenia dysku wejścia-wyjścia, Watchdog podejmuje działania aplikacji lub usługi. Progi przeciążenia dysku wejścia-wyjścia oraz działania, jakie należy podjąć, w przypadku przeciążenia jest wstępnie zdefiniowany w konfiguracji wejścia-wyjścia dysku.

Progi przeciążenia

  • Progi przeciążenia dysku I/O są egzekwowane codziennie, czyli wszystkie zapisy dokonane przez aplikację/usługę są agregowane od początku bieżącego dnia kalendarzowego UTC i sprawdzić pod kątem progów zdefiniowanych w nadużywania konfiguracji.
  • Jeśli pojazd zostanie uruchomiony wiele razy w danym dniu, moduł Watchdog przechowuje statystyki wykorzystania wejścia-wyjścia dysku w pamięci flash i agreguje je od momentu, od początku bieżącego dnia kalendarzowego w strefie czasowej UTC.

Nadużywanie działań

Gdy aplikacja wielokrotnie przekracza zdefiniowane nadużycie wejścia/wyjścia dysku progów, Watchdog podejmuje działania zdefiniowane w konfiguracji nadużywania.

  • Wszystkie aplikacje i usługi dostawców są uznawane za krytyczne ogólną stabilność systemu, dzięki czemu nie są przerywane w przypadku nadmiernego obciążenia dysku. Pamiętaj jednak: konfiguracja nadużywania może zdefiniować listę bezpiecznych do zamknięcia aplikacji dostawcy i usług.
  • Możesz bezpiecznie zamknąć wszystkie aplikacje innych firm.

Gdy można bezpiecznie zamknąć aplikację lub usługę, Watchdog wyłącza ją wraz z nią. stan komponentu PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED

Konfiguracja nadużywania

Konfiguracja przeciążenia zawiera progi nadmiarowego obciążenia dysku I/O oraz . Domyślne konfiguracje nadużywania są zdefiniowane w systemie i dostawcy które są wysyłane razem z kompilacją. Dostawcy mogą opcjonalnie dodać dostawcę konfiguracji w obrazie dostawcy. Gdy konfiguracja dostawcy jest inna niż jeśli zostanie udostępniony, konfiguracja systemu będzie używana na potrzeby aplikacji dostawcy, usług Google.

Watchdog ujawnia systemowe interfejsy API za pomocą interfejsu CarWatchdogManager, co pozwala aplikacje lub usługi dostawców aktualizują konfigurację dostawcy, w każdej chwili.

Definicja konfiguracji nadużywania

Konfiguracja nadużywania jest dzielona według typu komponentu, np. system, dostawca, i firm zewnętrznych. OEM może aktualizować tylko konfigurację komponentu dostawcy.

Konfiguracja dostawcy

Konfiguracja dostawcy określa progi nadużywania wejścia/wyjścia dysku i działania dla wszystkie aplikacje i usługi dostawców oraz wszystkie aplikacje z mapami i multimediami. Konfiguracja zawiera poniższe pola konfiguracji.

  • Prefiksy pakietu dostawców. Wszystkie pakiety zainstalowane w partycja dostawcy jest uznawana za pakiety dostawców. Oprócz tego Dostawcy mogą klasyfikować wstępnie zainstalowane pakiety jako pakiety dostawcy, dodając prefiksy pakietu do konfiguracji prefiksów pakietów dostawców. Ta konfiguracja nie akceptuje wyrażeń regularnych.
  • Bezpieczne zamykanie przesyłek. Dostawcy mogą określić, pakiety można bezpiecznie zakończyć, dodając ich pełne nazwy do safe-to-terminate.
  • Mapowanie kategorii aplikacji. Dostawcy mogą mapować dowolne pakiety (w tym pakietów innych firm) na jedną z dwóch obsługiwanych aplikacji. kategorie – Mapy i multimedia. Odwzorowanie to ma na celu udostępnienie map aplikacji do multimediów i aplikacji do multimediów wyższe progi przeciążenia dysku aplikacje pobierają i zapisują na dysku więcej danych niż inne .
  • Progi na poziomie komponentu. Określa ogólne progi dla wszystkich pakiety dostawcy (czyli pakiety, których nie obejmuje pakiet wartości progowe lub progi dla kategorii aplikacji, te progi). Gdy dostawcy muszą zdefiniować progi na poziomie niezerowym, przez zdefiniowanie konfiguracji nadmiarowego wykorzystania operacji wejścia-wyjścia dysku.
  • Progi dla konkretnego pakietu. Dostawcy mogą określić specjalne dla określonych pakietów dostawców. Mapowanie powinno zawierać parametr i pełnych nazw pakietów. Progi określone w tej konfiguracji mają pierwszeństwo przekracza progi zdefiniowane w innych konfiguracjach danego pakietu.
  • Progi dla poszczególnych kategorii aplikacji. Dostawcy mogą określić specjalne progi dla określonych kategorii aplikacji. Aplikacja Należy wybrać jedną z obsługiwanych kategorii – Mapy i Media aplikacji. Progi określone w tej konfiguracji są zmapowane na określone pakietów za pomocą mapowań kategorii aplikacji.
  • Progi w całym systemie. Dostawcy nie mogą określać tej konfiguracji.

Prefiksy pakietów dostawców, Bezpieczne zamykanie pakietów, Progi na poziomie komponentu i Progi dla poszczególnych pakietów konfiguracji progów można zaktualizować tylko przez konfigurację dostawcy dla aplikacje i usługi dostawców. Zależnie od kategorii aplikacji konfigurację progów można zaktualizować tylko przez konfigurację dostawcy dla wszystkich aplikacje z mapami i multimediami.

Progi przeciążenia określają liczbę bajtów, które można zapisać podczas:

  • Aplikacja lub usługa w trybie na pierwszym planie a tryb w tle
  • Tryb garażu systemowego

Ta klasyfikacja umożliwia aplikacjom i usługom skierowanym do użytkowników na pierwszym planie zapisywać więcej 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żde z nich wymaga wyższego progu niż aplikacje i usługi działające w innych trybach.

Konfiguracje systemu i innych firm

OEM nie powinien aktualizować konfiguracji systemu ani innych firm.

  • Konfiguracja systemu definiuje progi nadużywania wejścia-wyjścia i działania dla aplikacji i usług systemowych.
    • Ta konfiguracja może również zaktualizować kategorię aplikacji . Dzięki temu to pole konfiguracji jest wspólne dla systemu i dostawcy konfiguracji.
  • Konfiguracja firmy zewnętrznej definiuje progi dla wszystkich aplikacji. Wszystkie aplikacje, które nie są wstępnie zainstalowane w systemie, aplikacje innych firm.
    • Wszystkie aplikacje innych firm otrzymują te same progi (np. brak aplikacja innej firmy otrzymuje specjalne progi), z wyjątkiem map i multimediów aplikacji, których progi są określone w konfiguracji dostawcy.
    • Poniższe progi przeciążenia dysku wejścia-wyjścia to domyślne progi dla aplikacje innych firm. Progi te są wysyłane z obrazem systemu.
      • 3 GiB zapisu w trybie pierwszego planu aplikacji.
      • 2 GiB zapisu w trybie aplikacji w tle.
      • 4 GiB zapisu w trybie garażu systemu.
    • To są progi podstawowe. Te progi są aktualizowane w miarę uzyskiwania coraz większej ilości informacji o operacjach wejścia-wyjścia dysku i ich wykorzystaniu.

Nadużywanie formatu XML konfiguracji

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

Plik XML powinien zawierać tylko 1 tag na każde pole konfiguracji. Nadużywanie wejścia/wyjścia konfigurację należy zdefiniować w pliku XML. Wszystkie wartości progowe powinny określona 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>

Zaktualizuj konfigurację nadmiarowego wykorzystania za pomocą systemowych interfejsów API CarWatchdogManager

Powyższą konfigurację XML można podać tylko w obrazie kompilacji. Jeśli OEM decyduje się zaktualizować konfigurację na urządzeniu po opublikowaniu kompilacji. mogą używać poniższych interfejsów API, aby wprowadzać zmiany w konfiguracji na urządzeniu.

  • Przyznaj uprawnienie Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG .
  • Musi użyć istniejących konfiguracji, aby zaktualizować i ustawić nowe konfiguracje. Korzystanie z interfejsu API CarWatchdogManager.getResourceOveruseConfigurations, aby uzyskać istniejące konfiguracje. Jeśli istniejące konfiguracje nie są używane, wszystkie konfiguracje (w tym konfiguracje systemu i innych firm) są co nie jest zalecane.
  • Zaktualizuj istniejące konfiguracje o zmiany delta i ustaw nowe konfiguracji. Nie aktualizuj systemu ani komponentu innej firmy. konfiguracji.
  • Użyj interfejsu API CarWatchdogManager.setResourceOveruseConfigurations aby ustawić nowe konfiguracje.
  • Aby pobrać i ustawić nadmiarowe operacje wejścia-wyjścia dysku, użyj flagi CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO

Oto przykładowa implementacja, która aktualizuje konfiguracje nadużywania 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 nadmiarowe zasoby

Aplikacje dostawcy i innych firm mogą nasłuchiwać zasobów związanych z aplikacją nadużywanie powiadomień z usługi Watchdog lub ankiety CarWatchdogManager dotyczącej aplikacji statystyki nadużywania określonych zasobów z ostatnich 30 dni.

Wykrywaj powiadomienia o nadmiarowym wykorzystaniu zasobów

Aplikacje mogą implementować detektor nadmiarowego wykorzystania zasobów i rejestrować detektor z CarWatchdogManager, aby otrzymywać powiadomienia z określonej aplikacji, przekroczenie 80% lub 100% progów przeciążenia dysku. Aplikacje mogą używać: te powiadomienia, aby:

  • Rejestruj statystyki nadużywania wejścia/wyjścia dysku na potrzeby analizy offline. Promująca aplikację deweloperzy mogą korzystać z tego rejestrowania do debugowania problemu z nadużywaniem wejścia/wyjścia dysku.
  • Ogranicz liczbę operacji wejścia-wyjścia dysku, dopóki liczniki nadużywania nie zostaną zresetowane.

Klient Java

  1. Zaimplementuj detektor, stosując dziedziczenie 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. Rejestrowanie instancji odbiornika przez wywołanie 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, gdy aplikacja zakończy nasłuchiwanie: 
    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 shared_libs zależność 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 umożliwić domenie usługi dostawcy używanie segregatora (makro binder_user) i dodaj domenę usługi dostawcy do pola carwatchdog domena klienta (carwatchdog_client_domain macro). Zobacz poniższy kod dla sample_client.te oraz 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. Wdróż detektor nadmiarowego wykorzystania zasobów przez dziedziczenie BnResourceOveruseListener Zastąp BnResourceOveruseListener::onOveruse, aby zapobiec nadużywaniu zasobów powiadomienia.

    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 Binder i zarejestruj detektor nadmiarowego wykorzystania zasobów z serwerem watchdoga. 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);
}

Statystyki przeciążenia zasobów ankiety

Aplikacje mogą sondować usługę CarWatchdogManager pod kątem przeciążenia wejścia-wyjścia w danej aplikacji. statystyki ATS z ostatnich 30 dni.

Klient Java

Użyj kodu CarWatchdogManager.getResourceOveruseStats, aby uzyskać statystyki nadużywania zasobów. Miń CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO flagę, aby pobrać statystyki przeciążenia 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 kodu CarWatchdogServer.getResourceOveruseStats, aby uzyskać statystyki nadużywania zasobów. Przekaż enum ResourceType.IO, aby pobrać nadużywanie wejścia/wyjścia dysku statystyk.

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

Nadużywanie zasobów – wrażenia użytkowników

W sekcjach poniżej opisano wrażenia użytkowników w przypadku nadużywania zasobów.

Ustawienie priorytetu wydajności aplikacji

Strona Ustawienia aplikacji zawiera ustawienia aplikacji Prioritize app performance (zobacz ilustrację poniżej), która pozwala użytkownikom priorytetowo traktować wydajność aplikacji względem działania systemu długoterminową wydajność sprzętu. To ustawienie jest dostępne tylko w przypadku aplikacji, które można bezpiecznie zakończone w przypadku nadmiarowego wykorzystania zasobów. W przeciwnym razie ustawienie jest wyłączone. Gdy to ustawienie jest wyłączone (ustawienie domyślne) dla aplikacji, aplikacja może zostać zamknięta w przypadku nadużywania zasobów. W przeciwnym razie aplikacja nie zostanie zamknięta w przypadku nadużywania zasobów.

Gdy użytkownik włączy to ustawienie, w oknie potwierdzenia zobaczysz opis konsekwencje przełączenia ustawienia:

Po 90 dniach to ustawienie jest automatycznie resetowane do wartości domyślnych. Limit dzienny może być zmodyfikowane za pomocą nakładki RRO za pomocą watchdogUserPackageSettingsResetDays, maksymalnie 180 dni. Więcej informacji: Zmień wartość zasobów aplikacji w czasie działania w AndroidManifest.xml można umieścić następujący przykładowy tag nakładki:

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

W aplikacji res/values/config.xml:

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

W aplikacji 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ść. (zobacz ilustrację 1). Po kliknięciu pojawi się lista aplikacji, które zostały zablokowane ze względu na pamięć flash które mają negatywny wpływ na wydajność systemu. Te informacje są następujące Wymagania CD 3.5.1 [C-1-1].

Aplikacje wpływające na wydajność

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

Tutaj znajdziesz listę aplikacji zamkniętych z powodu nadużywania zasobów (zobacz ilustrację 2). Wymienione aplikacje mogą być traktowane priorytetowo. Więcej informacji: Nadawanie priorytetów ustawieniom wydajności aplikacji.

Lista aplikacji zamkniętych z powodu nadużywania zasobów

Rysunek 2. Lista aplikacji zamkniętych z powodu nadużywania zasobów.

Powiadomienie użytkownika

Gdy aplikacja lub usługa wielokrotnie nadużywa operacji wejścia-wyjścia dysku (np. zapisuje danych na dysk powyżej zdefiniowanych progów) w określonym czasie i jest bezpieczny zostanie zakończone w przypadku nadmiernego wykorzystania zasobów, użytkownik zostanie powiadomiony, gdy pojazd wjedzie na stan allow-driver-distraction.

Pierwsze powiadomienie dla użytkownika (podczas jazdy) jest publikowane jako ostrzeżenie. i pozostałe powiadomienia znajdziesz na nim pomocy.

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

  • Gdy użytkownik kliknie przycisk Nadaj priorytet aplikacji, otwiera stronę ustawień aplikacji, gdzie użytkownik może włączyć lub wyłączyć Nadaj priorytet wydajności aplikacji.
  • Gdy użytkownik kliknie przycisk Wyłącz aplikację, jest wyłączona, dopóki użytkownik nie uruchomi aplikacji lub nie włączy jej ustawień.
.
  • W przypadku aplikacji, które można odinstalować, przycisk Wyłącz aplikację jest zastąpiono przyciskiem Odinstaluj aplikację. Gdy użytkownik kliknie Odinstaluj aplikację, otworzy się strona Ustawienia aplikacji, z którego użytkownik może odinstalować aplikację.

Zalecenie dotyczące implementacji programu uruchamiającego

Gdy aplikacje są wyłączane z powodu nadużywania zasobów, aplikacje znikają domyślną aplikacją uruchamiającą, bo CarService aktualizuje stan włączenia: PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED OEM musi zaktualizować implementację wbudowanego programu uruchamiającego, by wyświetlać te aplikacje jako nietypowe, aby użytkownicy mogli w razie potrzeby korzystać z nich. Zapoznaj się z zaleceniami przedstawionymi poniżej w zależności od wersji kompilacji.

Wersja Androida SC V2

.