Monitoruj wykorzystanie pamięci flash

Watchdog monitoruje wykorzystanie pamięci flash, śledząc całkowitą liczbę zapisów we/wy dysku wykonanych przez wszystkie aplikacje i usługi, korzystając ze statystyk we/wy dysku według UID udostępnianych przez jądro w lokalizacji `/proc/uid_io/stats`. Gdy aplikacja lub usługa przekracza próg nadmiernego wykorzystania operacji we/wy dysku, Watchdog podejmuje działania w stosunku do aplikacji lub usługi. Progi nadmiernego użycia we/wy dysku i działania podejmowane w przypadku nadużycia są wstępnie zdefiniowane w konfiguracji nadmiernego użycia we/wy dysku.

Progi nadużywania

  • Progi nadużycia we/wy dysku są egzekwowane codziennie, co oznacza, że ​​wszystkie zapisy wykonane przez aplikację/usługę są agregowane od początku bieżącego dnia kalendarzowego UTC i sprawdzane z progami zdefiniowanymi w konfiguracjach nadużyć.
  • Gdy danego dnia pojazd jest uruchamiany wielokrotnie, moduł Watchdog przechowuje statystyki wykorzystania wejść/wyjść dysku w pamięci flash i agreguje je od początku bieżącego dnia kalendarzowego UTC.

Nadużywanie działań

Gdy aplikacja wielokrotnie przekracza zdefiniowane progi nadużycia we/wy dysku, Watchdog podejmuje działania określone w konfiguracji nadużycia.

  • Wszystkie aplikacje i usługi dostawców są uważane za krytyczne dla ogólnej stabilności systemu, więc nie kończą się w przypadku nadmiernego użycia operacji we/wy dysku. Jednak konfiguracja nadużywana może zdefiniować listę aplikacji i usług dostawców, które można bezpiecznie zakończyć.
  • Wszystkie aplikacje innych firm można bezpiecznie zakończyć.

Gdy aplikację lub usługę można bezpiecznie zakończyć, Watchdog wyłącza aplikację lub usługę ze stanem komponentu aplikacji PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED .

Nadużywanie konfiguracji

Konfiguracja nadużycia zawiera progi i działania dotyczące nadużycia we/wy dysku. Domyślne konfiguracje nadużywania są zdefiniowane w obrazach systemu i dostawcy oraz dostarczane wraz z kompilacją. Dostawcy mogą opcjonalnie uwzględnić konfigurację dostawcy w obrazie dostawcy. Jeśli konfiguracja dostawcy nie jest dostępna, konfiguracja systemu jest używana również w przypadku aplikacji i usług dostawcy.

Watchdog udostępnia interfejsy API systemu za pośrednictwem CarWatchdogManager , który umożliwia aplikacjom lub usługom dostawców aktualizację konfiguracji dostawcy w dowolnym momencie.

Nadużywanie definicji konfiguracji

Konfiguracja nadużywania jest podzielona według typu komponentu, na przykład systemu, dostawcy i strony trzeciej. Producenci OEM muszą aktualizować jedynie konfigurację komponentów dostawcy.

Konfiguracja dostawcy

Konfiguracja dostawcy definiuje progi nadmiernego wykorzystania we/wy dysku oraz działania dla wszystkich aplikacji i usług dostawców, a także wszystkich map i aplikacji multimedialnych. Konfiguracja zawiera poniższe pola konfiguracyjne.

  • Vendor package prefixes . Wszystkie pakiety zainstalowane na partycji dostawcy są uważane za pakiety dostawcy. Oprócz tych pakietów dostawcy mogą klasyfikować pakiety preinstalowane jako pakiety dostawców, dodając przedrostki pakietów do konfiguracji vendor package prefixes . Ta konfiguracja nie akceptuje wyrażeń regularnych.
  • Safe-to-terminate packages . Dostawcy mogą określić, których pakietów dostawców można bezpiecznie zakończyć, dodając pełne nazwy pakietów do konfiguracji safe-to-terminate packages .
  • Application category mappings . Dostawcy mogą przypisać dowolny pakiet (w tym pakiety innych firm) do jednej z dwóch obsługiwanych kategorii aplikacji — aplikacji mapowych i multimedialnych. To mapowanie ma na celu zapewnienie mapom i aplikacjom multimedialnym wyższych progów nadużycia operacji we/wy dysku, ponieważ te aplikacje mają tendencję do pobierania i zapisywania na dysku większej ilości danych niż inne typy aplikacji.
  • Component level thresholds . Definiuje ogólne progi dla wszystkich pakietów dostawców (tzn. pakiety nieobjęte Package specific thresholds lub Application category specific thresholds otrzymują te progi). Dostawcy muszą zdefiniować niezerowe progi na poziomie komponentów podczas definiowania konfiguracji nadmiernego wykorzystania we/wy dysku.
  • Package specific thresholds . Dostawcy mogą definiować specjalne progi dla określonych 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.
  • Application category specific thresholds . Dostawcy mogą określić specjalne progi dla określonych kategorii aplikacji. Kategorie aplikacji muszą należeć do jednej z obsługiwanych kategorii — aplikacje Mapy i multimedia. Progi zdefiniowane w tej konfiguracji są mapowane na określone pakiety przy użyciu Application category mappings .
  • System-wide thresholds . Dostawcy nie mogą określać tej konfiguracji.

Vendor package prefixes , Safe-to-terminate packages , Component level thresholds i konfiguracji Package specific thresholds można aktualizować wyłącznie za pomocą konfiguracji dostawcy dla aplikacji i usług dostawcy. Konfiguracja Application category specific thresholds może zostać zaktualizowana wyłącznie przez konfigurację dostawcy dla wszystkich map i aplikacji multimedialnych.

Progi nadużycia zawierają liczbę bajtów, które można zapisać podczas

  • Tryb pierwszego planu aplikacji/usługi a tryb tła
  • i systemowy tryb garażu.

Ta klasyfikacja umożliwia aplikacjom/usługom dostępnym na pierwszym planie zapisywanie większej ilości danych niż aplikacjom/usługom działającym w tle. W trybie garażu aplikacje i usługi mają tendencję do pobierania aktualizacji, dlatego każda z nich wymaga wyższego progu niż aplikacje i usługi działające w innych trybach.

Konfiguracje systemu i innych firm

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

  • Konfiguracja systemu definiuje progi nadużycia we/wy oraz działania dla aplikacji i usług systemowych.
    • Ta konfiguracja może również aktualizować Application category mappings . Dlatego to pole konfiguracyjne jest współdzielone przez konfiguracje systemu i dostawcy.
  • Konfiguracja innej firmy definiuje 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 (na przykład żadna aplikacja innych firm nie otrzymuje specjalnych progów), z wyjątkiem map i aplikacji multimedialnych, których progi są zdefiniowane w konfiguracji dostawcy.
    • Poniższe progi nadmiernego wykorzystania we/wy dysku są domyślnymi progami dla aplikacji innych firm. Progi te są dostarczane z obrazem systemu.
      • 3 GiB zapisuj w trybie pierwszego planu aplikacji.
      • 2 GiB zapisuj w trybie tła aplikacji.
      • 4 GiB zapis w trybie garażu systemowego.
    • Są to progi podstawowe. Progi te są aktualizowane w miarę lepszego zrozumienia użycia operacji we/wy dysku.

Nadużywanie formatu XML konfiguracji

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, ​​konfiguracja zdefiniowana przez system jest stosowana również w przypadku aplikacji i usług dostawców.

Plik XML powinien zawierać tylko jeden znacznik dla każdego pola konfiguracyjnego. Konfiguracja nadmiernego użycia we/wy musi zostać zdefiniowana w pliku XML. Wszystkie wartości progowe należy podać w jednostce MiB.

Przykładowa konfiguracja XML znajduje się poniżej:

<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ę dotyczącą nadużywania 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ć następujących interfejsów API, aby wprowadzić zmiany w konfiguracji na urządzeniu.

  • Przyznaj dzwoniącemu pozwolenie Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG .
  • Należy użyć istniejących konfiguracji , aby zaktualizować i ustawić nowe konfiguracje. Użyj API CarWatchdogManager.getResourceOveruseConfigurations , aby uzyskać istniejące konfiguracje. Jeśli istniejące konfiguracje nie zostaną wykorzystane, wszystkie konfiguracje (w tym konfiguracje systemowe i konfiguracje innych firm) zostaną nadpisane, co nie jest zalecane.
  • Zaktualizuj istniejące konfiguracje, wprowadzając zmiany delta i ustaw nowe konfiguracje. Nie aktualizuj konfiguracji systemu ani komponentów innych firm.
  • Użyj API CarWatchdogManager.setResourceOveruseConfigurations , aby ustawić nowe konfiguracje.
  • Aby uzyskać i ustawić konfiguracje nadmiernego użycia we/wy dysku, użyj flagi CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO .

Oto przykładowa implementacja aktualizująca 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 nadmierne wykorzystanie zasobów

Aplikacje dostawców i innych firm mogą nasłuchiwać powiadomień o nadużyciu zasobów specyficznych dla aplikacji od Watchdog lub sondować CarWatchdogManager w celu uzyskania statystyk nadużycia zasobów specyficznych dla aplikacji za ostatnie 30 dni.

Słuchaj powiadomień o nadużyciu zasobów

Aplikacje mogą zaimplementować moduł nasłuchujący nadużywania zasobów i zarejestrować go w CarWatchdogManager , aby otrzymywać powiadomienia specyficzne dla aplikacji, gdy przekroczą one 80% lub 100% progów przeciążenia we/wy dysku. Aplikacje mogą używać tych powiadomień do:

  • Rejestruj statystyki nadużycia we/wy dysku w celu analizy w trybie offline. Twórcy aplikacji mogą używać tego rejestrowania do debugowania problemu związanego z nadużywaniem operacji we/wy dysku.
  • Zmniejsz liczbę zapisów we/wy dysku, aż do zresetowania liczników nadużywania.

Klient Javy

  1. Zaimplementuj detektor, dziedzicząc 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ę odbiornika, 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ę odbiornika, 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 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 politykę SELinux, aby umożliwić domenie usługi dostawcy korzystanie z segregatora (makro binder_user ) i dodaj domenę usługi dostawcy do domeny klienta carwatchdog (carwatchdog_client_domain macro) . Zobacz poniższy 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 nadużywania zasobów, dziedzicząc BnResourceOveruseListener . Zastąp BnResourceOveruseListener::onOveruse , aby obsługiwać powiadomienia o nadużyciu 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 spoiwa i zarejestruj detektor nadużywania zasobów na serwerze nadzorującym. Serwer Watchdog zarejestrowany jest 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 nadużycia zasobów ankiety

Aplikacje mogą odpytywać CarWatchdogManager pod kątem statystyk ATS dotyczących nadużycia wejść/wyjść specyficznych dla aplikacji z ostatnich 30 dni.

Klient Javy

Użyj CarWatchdogManager.getResourceOveruseStats , aby uzyskać statystyki dotyczące nadużycia zasobów. Przekaż flagę CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO , aby uzyskać statystyki nadużywania we/wy 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 dotyczące nadużywania zasobów. Przekaż wyliczenie ResourceType.IO , aby pobrać statystyki dotyczące nadużywania operacji we/wy 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
      }
}

Nadużywanie zasobów UX

Nadaj priorytet ustawieniom wydajności aplikacji

Na stronie ustawień aplikacji znajduje się opcja Prioritize app performance (patrz ilustracja poniżej), która umożliwia użytkownikowi nadanie priorytetu wydajności aplikacji w stosunku do wydajności 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 nadużywania zasobów. W przeciwnym razie to ustawienie jest wyszarzone. Jeśli 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 zakończona w przypadku nadużywania zasobów.

Gdy użytkownik włączy to ustawienie, poniższe okno dialogowe potwierdzenia opisuje konsekwencje włączenia tego ustawienia.

Po 90 dniach to ustawienie zostanie automatycznie przywrócone do wartości domyślnych. Limit dzienny można modyfikować za pomocą aplikacji nakładkowej RRO za pomocą watchdogUserPackageSettingsResetDays , maksymalnie do 180 dni. Aby dowiedzieć się więcej, zobacz Zmienianie wartości zasobów aplikacji w czasie jej wykonywania . Poniższy przykładowy tag nakładki można umieścić w AndroidManifest.xml :

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

Powiadomienie użytkownika

Jeśli aplikacja lub usługa wielokrotnie nadmiernie wykorzystuje operacje we/wy dysku (na przykład zapisuje dane na dysk powyżej zdefiniowanych progów) w określonym czasie i można ją bezpiecznie zakończyć w przypadku nadużywania zasobów, użytkownik zostaje powiadomiony, gdy pojazd wejdzie do strefy zezwolenia dla kierowcy -stan rozproszenia.

Pierwsze powiadomienie użytkownika (podczas jazdy) jest wysyłane jako powiadomienie od razu, a pozostałe powiadomienia są publikowane w centrum powiadomień.

Na przykład, gdy aplikacja wielokrotnie nadużywa operacji we/wy dysku, użytkownik otrzymuje następujące powiadomienie:

  • Gdy użytkownik kliknie przycisk Nadaj priorytet aplikacji , zostanie uruchomiona 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 do czasu jej uruchomienia lub włączenia na stronie ustawień aplikacji.
  • W przypadku aplikacji, które można odinstalować, przycisk Wyłącz aplikację zostaje zastąpiony przyciskiem Odinstaluj aplikację . Gdy użytkownik kliknie przycisk Odinstaluj aplikację , zostanie uruchomiona strona Ustawienia aplikacji, z której użytkownik może odinstalować aplikację.

Zalecenie dotyczące wdrożenia programu uruchamiającego

Gdy aplikacje zostaną wyłączone z powodu nadmiernego użycia zasobów, znikają one 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ć implementację wbudowanego programu uruchamiającego, aby wyświetlać te aplikacje jako nietypowe, aby użytkownicy mogli z nich korzystać w razie potrzeby. Zapoznaj się z poniższymi zaleceniami na podstawie wersji kompilacji.

Wersja Androida SC V2