Watchdog monitoruje wykorzystanie pamięci flash, śledząc łączną liczbę operacji zapisu na dysku wykonywanych przez wszystkie aplikacje i usługi przy użyciu statystyk operacji wejścia/wyjścia na dysku dla UID udostępnianych przez jądro w lokalizacji /proc/uid_io/stats. Gdy aplikacja lub usługa przekroczy próg nadużywania operacji wejścia/wyjścia na dysku, Watchdog podejmuje działania w odniesieniu do tej aplikacji lub usługi. Próg nadużywania operacji wejścia/wyjścia dysku i działanie w przypadku nadużywania są wstępnie zdefiniowane w konfiguracji nadużywania operacji wejścia/wyjścia dysku.
Progi nadużywania
- Próg nadużywania we/wy dysku jest egzekwowany codziennie, co oznacza, że wszystkie zapisy dokonane przez aplikację lub usługę są agregowane od początku bieżącego dnia kalendarzowego według uniwersalnego czasu koordynowanego (UTC) i porównywane z wartościami progowymi określonymi w konfiguracji nadużywania.
- Jeśli pojazd jest uruchamiany wielokrotnie w danym dniu, moduł Watchdog przechowuje statystyki wykorzystania wejść/wyjść dysku w pamięci flash i zbiera je od początku bieżącego dnia kalendarzowego według czasu UTC.
Nadmierne używanie
Gdy aplikacja wielokrotnie przekracza określone progi nadużywania operacji wejścia/wyjścia na dysku, Watchdog podejmuje działania określone w konfiguracji nadużywania.
- Wszystkie aplikacje i usługi dostawców są uważane za kluczowe dla ogólnej stabilności systemu, dlatego nie są przerywane z powodu nadmiernego wykorzystania operacji wejścia/wyjścia z dysku. Konfiguracja nadużywania może jednak określać listę aplikacji i usług dostawców, które można bezpiecznie zakończyć.
- Możesz bezpiecznie zamknąć wszystkie aplikacje innych firm.
Gdy aplikacja lub usługa może zostać bezpiecznie zamknięta, Watchdog wyłącza ją za pomocą stanu komponentu aplikacji
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
.
Konfiguracja nadużywania
Konfiguracja nadużywania zawiera progi i działania nadmiarowego obciążenia dysku. Domyślne konfiguracje nadużywania są zdefiniowane w obrazach systemu i dostawcy oraz są dostarczane z kompilacją. Dostawcy mogą opcjonalnie uwzględnić konfigurację dostawcy w obrazie dostawcy. Jeśli konfiguracja dostawcy nie została podana, do aplikacji i usług dostawcy jest używana konfiguracja systemu.
Watchdog udostępnia systemowe interfejsy API za pomocą interfejsu CarWatchdogManager, co umożliwia aplikacjom i usługom dostawców aktualizowanie konfiguracji dostawcy w dowolnym momencie.
Definicja konfiguracji nadwyrężenia
Konfiguracja nadużywania jest podzielona według typu komponentu, np. system, dostawca i inne firmy. Producenci OEM muszą zaktualizować tylko konfigurację komponentu dostawcy.
Konfiguracja dostawcy
Konfiguracja dostawcy definiuje progi nadmiarowego wykorzystania 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 poniższe pola konfiguracji.
- Prefiksy pakietów dostawców. Wszystkie pakiety zainstalowane na partycji dostawcy są uznawane za pakiety dostawcy. Oprócz tych pakietów dostawcy mogą klasyfikować wstępnie zainstalowane pakiety jako pakiety dostawcy, dodając prefiksy pakietów do konfiguracji prefiksów pakietów dostawcy. Ta konfiguracja nie akceptuje wyrażeń regularnych.
- Pakiety bezpieczne do zakończenia. Dostawcy mogą określić, które pakiety mogą być bezpiecznie zamykane, dodając pełne nazwy pakietów do konfiguracji pakietów bezpiecznych do zamknięcia.
- Mapowania kategorii aplikacji. Dostawcy mogą zmapować dowolny pakiet (w tym pakiety innych firm) do jednej z 2 obsługiwanych kategorii aplikacji: Mapy i Media. Mapowanie to ma na celu zapewnienie aplikacjom do map i multimediów wyższych progów nadmiernego użycia wejścia-wyjścia na dysku, ponieważ te aplikacje mają tendencję do pobierania i zapisywania na dysku więcej danych niż inne typy aplikacji.
- Progi na poziomie komponentu. Określa ogólne progi dla wszystkich pakietów dostawców (czyli dla pakietów, których nie uwzględniają progi dla konkretnego pakietu lub progi dla konkretnej kategorii aplikacji). Definiując konfigurację nadużywania wejścia-wyjścia dysku, dostawcy muszą zdefiniować progi na poziomie niezerowym na poziomie komponentów.
- Progi dotyczące poszczególnych pakietów. Dostawcy mogą definiować specjalne progi dla konkretnych pakietów. Mapowania powinny zawierać pełne nazwy pakietów. Próg określony w tej konfiguracji ma pierwszeństwo przed progami określonymi w innych konfiguracjach danego pakietu.
- Progi dla poszczególnych kategorii aplikacji. Dostawcy mogą określać specjalne progi dla określonych kategorii aplikacji. Kategorie aplikacji muszą należeć do jednej z obsługiwanych kategorii – mapy i multimedia. Prógowe wartości zdefiniowane w tej konfiguracji są mapowane na konkretne pakiety za pomocą mapowania kategorii aplikacji.
- Progi w całym systemie. Dostawcy nie muszą określać tej konfiguracji.
Konfiguracje prefiksów pakietów dostawców, pakietów bezpiecznych do zamykania, progów na poziomie komponentu i progów dla poszczególnych pakietów można zaktualizować tylko przez konfigurację dostawcy w przypadku aplikacji i usług dostawcy. Konfiguracja progów określonych dla kategorii aplikacji w przypadku wszystkich map i aplikacji multimedialnych może być aktualizowana tylko przez konfigurację dostawcy.
Progi przeciążenia określają liczbę bajtów, które można zapisać podczas:
- tryb aplikacji lub usługi na pierwszym planie a w tle;
- Tryb garażu systemu
Ta klasyfikacja umożliwia aplikacjom i usługom działającym na pierwszym planie większej liczbie danych niż aplikacje i usługi działające w tle. W trybie Garaż aplikacje i usługi zwykle pobierają aktualizacje, więc każda 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 określa progi i działania dotyczące nadużywania wejść/wyjść w przypadku aplikacji i usług systemowych.
- Ta konfiguracja może też zaktualizować mapowania kategorii aplikacji. Dlatego to pole konfiguracji jest wspólne dla konfiguracji systemu i dostawcy.
- Konfiguracja aplikacji innych firm określa wartości progowe dla wszystkich aplikacji innych firm. Wszystkie aplikacje, które nie są zainstalowane fabrycznie w systemie, są aplikacjami innych firm.
- Wszystkie aplikacje innych firm mają te same wartości progowe (np. żadna aplikacja innej firmy nie ma specjalnych wartości progowych), z wyjątkiem aplikacji do map i multimediów, których wartości progowe są definiowane przez konfigurację dostawcy.
- Podane poniżej progi nadużywania operacji wejścia/wyjścia na dysku są domyślnymi wartościami progowymi dla aplikacji innych firm. Te progi są dostarczane z obrazem systemu.
- 3 GB w trybie aplikacji na pierwszym planie.
- 2 GB w trybie działania w tle aplikacji.
- 4 GB zapisu w trybie garażu systemu.
- To są progi podstawowe. Te wartości graniczne są aktualizowane w miarę zdobywania informacji o wykorzystaniu we/wy dysku.
Format XML konfiguracji nadużywania
Domyślną konfigurację dostawcy można umieścić (jest to opcjonalne) w miejscu /vendor/etc/automotive/watchdog/resource_overuse_configuration.xmlw pliku obrazu kompilacji. Jeśli ta konfiguracja nie jest określona, konfiguracja zdefiniowana przez system jest również stosowana do aplikacji i usług dostawcy.
Plik XML powinien zawierać tylko 1 tag dla każdego pola konfiguracji. Konfiguracja dotycząca nadużywania wejść i wyjść musi być zdefiniowana w pliku XML. Wszystkie wartości progów należy podawać w jednostce MiB.
Poniżej znajduje się 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 pliku obrazu kompilacji. Jeśli 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 uprawnienia
Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIGrozmówcy. - Aby zaktualizować i ustawić nowe konfiguracje, musisz użyć istniejących konfiguracji. Użyj interfejsu API
CarWatchdogManager.getResourceOveruseConfigurations, aby pobrać istniejące konfiguracje. Jeśli nie użyjesz istniejących konfiguracji, wszystkie konfiguracje (w tym systemowe i konfiguracje innych firm) zostaną zastąpione, co nie jest zalecane. - Zaktualizuj istniejące konfiguracje, stosując zmiany delta, i ustaw nowe konfiguracje. Nie aktualizuj konfiguracji systemu i komponentów innych firm.
- Użyj interfejsu API
CarWatchdogManager.setResourceOveruseConfigurations, aby ustawić nowe konfiguracje. - Aby pobrać i ustawić konfiguracje nadużywania we/wy 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 nadmierne wykorzystanie zasobów
Aplikacje dostawców i aplikacje innych firm mogą odbierać powiadomienia o nadużywaniu zasobów przez aplikację z Watchdoga lub odczytywać statystyki dotyczące nadużywania zasobów przez aplikację z poziomu CarWatchdogManager za ostatnie 30 dni.
Wykrywaj powiadomienia o nadmiarowym wykorzystaniu zasobów
Aplikacje mogą stosować odbiornik nadużywania zasobów i rejestrować go w CarWatchdogManager, aby otrzymywać powiadomienia dotyczące aplikacji, gdy przekroczy ona 80% lub 100% progów nadużywania operacji wejścia/wyjścia z dysku. Aplikacje mogą używać tych powiadomień do:
- rejestrowanie statystyk nadużywania operacji wejścia/wyjścia na dysku do analizy offline; Deweloperzy aplikacji mogą używać tego rejestrowania do debugowania problemu nadużywania operacji wejścia/wyjścia na dysku.
- Zmniejsz liczbę operacji zapisu na dysku, aż liczniki nadużywania zostaną zresetowane.
Klient Java
- Zaimplementuj listenera, 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() } } } - Zarejestruj instancję listenera, wywołując funkcję
CarWatchdogManager.addResourceOveruseListenerprivate 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); } - Wyrejestruj instancję listenera, gdy aplikacja skończy słuchać:
private void removeResourceOveruseListener() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE); mCarWatchdogManager.removeResourceOveruseListener( mListenerImpl); }
Klient natywny
- Uwzględnij
carwatchdog_aidl_interface-ndk_platformw zależnościshared_libsreguły kompilacji.Android.bpcc_binary { name: "sample_native_client", srcs: [ "src/*.cpp" ], shared_libs: [ "carwatchdog_aidl_interface-ndk_platform", "libbinder_ndk", ], vendor: true, } - Dodaj zasadę SELinux, aby domena usługi dostawcy mogła używać bindera (makro
binder_user) i dodaj domenę usługi dostawcy do domeny klientacarwatchdog((carwatchdog_client_domain macro)). Poniżej znajdziesz kod dotyczący funkcjisample_client.teifile_contexts.sample_client.tetype 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
- Zaimplementuj listenera nadużywania zasobów, dziedzicząc go z poziomu
BnResourceOveruseListener. ZastąpićBnResourceOveruseListener::onOveruse, aby zarządzać powiadomieniami o nadużywaniu zasobów.ResourceOveruseListenerImpl.hclass 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.cppndk::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(); } - Uruchom pulę wątków bindera i zarejestruj nasłuchiwanie nadużywania zasobów na serwerze watchdog. Serwer watchdog jest zarejestrowany pod nazwą usługi
android.automotive.watchdog.ICarWatchdog/default.main.cppint 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.cppvoid 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 dotyczące nadmiernego wykorzystania zasobów ankiety
Aplikacje mogą prosić CarWatchdogManagera o statystyki dotyczące nadużywania operacji wejścia/wyjścia (ATS) w przypadku konkretnej aplikacji z ostatnich 30 dni.
Klient Java
Aby uzyskać statystyki dotyczące nadużywania zasobów, użyj CarWatchdogManager.getResourceOveruseStats. Przekaż flagę CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO, aby uzyskać statystyki nadużywania 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
Aby uzyskać statystyki dotyczące nadużywania zasobów, użyj CarWatchdogServer.getResourceOveruseStats. Przekaż typ danych ResourceType.IO, aby pobrać statystyki nadużywania I/O 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 – wrażenia użytkowników
W kolejnych sekcjach opisano, jak wygląda sytuacja, gdy dochodzi do nadużywania zasobów.
Ustawienie priorytetu wydajności aplikacji
Strona Ustawienia aplikacji zawiera ustawieniaPrioritize app performance (patrz obrazek poniżej), które umożliwiają użytkownikom nadawanie priorytetów wydajności aplikacji nad systemem i długoterminową 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 wyłączone. Jeśli to ustawienie jest wyłączone (ustawienie domyślne) dla aplikacji, aplikacja może zostać zamknięta z powodu nadmiernego wykorzystania zasobów.
W przeciwnym razie aplikacja nie zostanie zamknięta z powodu nadużywania zasobów.
Gdy użytkownik włączy to ustawienie, pojawi się okno potwierdzenia z opisem 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ładki RRO za pomocą funkcji watchdogUserPackageSettingsResetDays do maksymalnie 180 dni. Więcej informacji znajdziesz w artykule Zmienianie wartości zasobów aplikacji w czasie wykonywania. W pliku AndroidManifest.xml możesz 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 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ść (patrz rys. 1). Po kliknięciu wyświetli się lista aplikacji, które zostały ograniczone z powodu nadużywania pamięci flash i mają negatywny wpływ na działanie systemu. Jest to zgodne z wymogiem CDD 3.5.1 [C-1-1].
Rysunek 1. Aplikacje wpływające na wydajność.
Aplikacje zakończone z powodu nadużywania zasobów są wymienione tutaj (patrz rys. 2). Wymienione aplikacje można ustawić w kolejności. Więcej informacji znajdziesz w sekcji Ustawienie priorytetu wydajności aplikacji.
Rysunek 2. Lista aplikacji zakończonych z powodu nadmiernego wykorzystania zasobów.
Powiadomienie użytkownika
Gdy aplikacja lub usługa wielokrotnie w określonym czasie nadużywa wejść/wyjść dyskowych (np. zapisuje dane na dysku poza zdefiniowane progi) i można ją bezpiecznie zamknąć z powodu nadużywania zasobów, użytkownik jest powiadamiany, gdy pojazd wejdzie w stan zezwalający na rozproszenie uwagi kierowcy.
Pierwsze powiadomienie dla użytkownika (podczas jazdy) jest wyświetlane jako powiadomienie z uprzedzeniem, a pozostałe powiadomienia są wyświetlane w centrum powiadomień.
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 Daj pierwszeństwo aplikacji, otworzy się strona ustawień aplikacji, na której może włączyć lub wyłączyć ustawienie Daj pierwszeństwo wydajności aplikacji.
- Gdy użytkownik kliknie przycisk Wyłącz aplikację, aplikacja jest wyłączona, dopóki użytkownik nie uruchomi jej lub nie włączy na stronie ustawień.
- W przypadku aplikacji, które można odinstalować, przycisk Wyłącz aplikację jest zastąpiony przyciskiem Odinstaluj aplikację. Gdy użytkownik kliknie przycisk Odinstaluj aplikację, otworzy się strona Ustawienia aplikacji, na której użytkownik może odinstalować aplikację.
Rekomendacja dotycząca implementacji menu
Gdy aplikacje są wyłączone z powodu nadużywania zasobów, znikają z domyślnego menu aplikacji, ponieważ usługa CarService aktualizuje stan włączenia aplikacji na PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED.
Producenci OEM muszą zaktualizować implementację wbudowanego programu uruchamiającego, aby wyświetlać te aplikacje jako nietypowe, dzięki czemu użytkownicy będą mogli z nich korzystać w razie potrzeby. Zobacz te rekomendacje na podstawie wersji kompilacji.
Wersja Androida SC V2
- Implementacja programu uruchamiającego powinna używać flagi
MATCH_DISABLED_UNTIL_USED_COMPONENTSpodczas pobierania listy pakietów do wyświetlenia w programie uruchamiającym. - Gdy użytkownik kliknie aplikację w stanie
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, aplikacja uruchamiająca musi ją włączyć, ustawiając stan włączenia jako: