Watchdog monitora l'utilizzo della memoria flash tracciando la quantità totale di I/O del disco scritture effettuate da tutte le app e tutti i servizi utilizzando le statistiche di I/O del disco per UID esposto dal kernel nella località "/proc/uid_io/stats". Quando un'app o il servizio supera la soglia di overuse di I/O del disco, il watchdog intraprende azioni un'app o un servizio. Le soglie di utilizzo eccessivo di I/O del disco e l'azione da intraprendere in caso di utilizzo eccessivo è predefinito nella configurazione di uso eccessivo di I/O del disco.
Soglie di utilizzo eccessivo
- Le soglie di sovraccarico di I/O del disco vengono applicate su base giornaliera, ovvero le scritture effettuate da un'app/un servizio vengono aggregate dall'inizio giorno di calendario UTC corrente e verificato in base alle soglie definite dell'uso eccessivo delle configurazioni.
- Quando un veicolo viene avviato più volte in un determinato giorno, il modulo Watchdog memorizza le statistiche sull'utilizzo di I/O del disco sulla memoria flash e le aggrega poiché all'inizio del giorno di calendario UTC corrente.
Azioni di uso eccessivo
Quando un'app supera ripetutamente il limite di utilizzo eccessivo del disco I/O definito soglie, il watchdog intraprende le azioni definite nella configurazione di uso eccessivo.
- Tutti i servizi e le app dei fornitori sono considerati fondamentali per la stabilità complessiva del sistema, in modo che non vengano terminate in caso di uso eccessivo di I/O del disco. Tuttavia, la configurazione di uso eccessivo può definire un elenco di app dei fornitori da terminare in sicurezza e servizi.
- Tutte le app di terze parti possono essere terminate in sicurezza.
Quando un'app o un servizio può essere chiuso in sicurezza, Watchdog disattiva l'app o il servizio con l'app
stato componente
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
.
Utilizzo eccessivo della configurazione
La configurazione di utilizzo eccessivo contiene le soglie di sovraccarico di I/O del disco e azioni. Le configurazioni di utilizzo eccessivo predefinite sono definite nel sistema e nel fornitore e viene fornito con la build. I fornitori possono facoltativamente includere il fornitore configurazione nell'immagine del fornitore. Se la configurazione del fornitore fornita, la configurazione di sistema viene usata per le app del fornitore dei servizi Google Cloud.
Watchdog espone le API di sistema tramite CarWatchdogManager, il che consente
Le app o i servizi dei fornitori aggiornano la configurazione del fornitore
in qualsiasi momento.
Definizione della configurazione per uso eccessivo
La configurazione con un utilizzo eccessivo viene suddivisa per tipo di componente, ad esempio sistema, fornitore, e terze parti. Gli OEM devono aggiornare solo la configurazione dei componenti del fornitore.
Configurazione del fornitore
La configurazione del fornitore definisce le soglie di utilizzo eccessivo di I/O del disco e le azioni per tutte le app e i servizi dei fornitori e tutte le app per mappe e multimediali. La contiene i seguenti campi di configurazione.
- Prefissi del pacchetto del fornitore. Tutti i pacchetti installati la partizione del fornitore è considerata come pacchetti di fornitori. Oltre a questi di pacchetti, i fornitori possono classificare i pacchetti preinstallati come pacchetti del fornitore Aggiungendo i prefissi del pacchetto alla configurazione dei prefissi pacchetto del fornitore. Questa configurazione non accetta espressioni regolari.
- Pacchetti sicuri da terminare. I fornitori possono specificare il fornitore i pacchetti possono essere terminati aggiungendo i nomi completi dei pacchetti alla la configurazione dei pacchetti sicuri da terminare.
- Mappature delle categorie di applicazioni. I fornitori possono mappare qualsiasi pacchetto (inclusi pacchetti di terze parti) a una delle due app supportate categorie - Mappa e App multimediali. Questa mappatura viene eseguita per fornire le mappe e le app multimediali superano le soglie di sovrauso di I/O del disco, le app tendono a scaricare e scrivere più dati su disco rispetto alle altre di testo.
- Soglie a livello di componente. Definisce soglie generiche per tutti pacchetti del fornitore (ovvero quelli non coperti dalla sezione specifici del pacchetto soglie o soglie specifiche per le categorie di applicazione. queste soglie). I fornitori devono definire soglie a livello di componente diverse da zero quando la configurazione dell'uso eccessivo di I/O del disco.
- Soglie specifiche del pacchetto. I fornitori possono definire le soglie per pacchetti di fornitori specifici. Le mappature devono contenere nomi completi dei pacchetti. Le soglie definite in questa configurazione hanno la precedenza sulle soglie definite in altre configurazioni per un determinato pacchetto.
- Soglie specifiche per categoria di applicazione. I fornitori possono specificare soglie speciali per categorie di app specifiche. L'app le categorie devono essere una delle categorie supportate: Mappe e Media app. Le soglie definite in questa configurazione sono mappate a specifiche di pacchetti mediante le mappature delle categorie di applicazione.
- Soglie a livello di sistema. I fornitori non devono specificare questa configurazione.
Prefissi pacchetto del fornitore, pacchetti sicuri da terminare, Soglie a livello di componente e Specifiche del pacchetto le configurazioni delle soglie possono essere aggiornate solo in base alla configurazione del fornitore le app e i servizi dei fornitori. Specifico per categoria di applicazione la configurazione delle soglie può essere aggiornata solo dalla configurazione del fornitore per tutte app di mappe e contenuti multimediali.
Le soglie di utilizzo eccessivo contengono la quantità di byte che possono essere scritti durante:
- Confronto tra la modalità in primo piano o la modalità in background di un'app o un servizio
- Modalità garage di sistema
Questa classificazione consente alle app e ai servizi in primo piano rivolti agli utenti di e scrivere più dati rispetto alle app e ai servizi in background. In modalità garage, app e servizi tendono a scaricare aggiornamenti, quindi ognuno ha bisogno di una soglia più alta rispetto ad app e servizi eseguiti in altre modalità.
Configurazioni di sistema e di terze parti
Gli OEM non devono aggiornare le configurazioni di sistema e di terze parti.
- La configurazione di sistema definisce le soglie di utilizzo eccessivo di I/O e le azioni per
app e servizi di sistema.
- Questa configurazione può anche aggiornare la Categoria applicazione mapping. Di conseguenza, questo campo di configurazione è condiviso tra il sistema e il fornitore configurazioni.
- La configurazione di terze parti definisce le soglie per tutte le terze parti
app. Tutte le app non preinstallate nel sistema vengono
app di terze parti.
- Tutte le app di terze parti ricevono le stesse soglie (ad esempio, nessuna app di terze parti riceve soglie speciali), ad eccezione di mappe e contenuti multimediali le cui soglie sono definite dalla configurazione del fornitore.
- Le seguenti soglie di sovraccarico di I/O del disco sono quelle predefinite per il parametro
app di terze parti. Queste soglie vengono fornite con l'immagine di sistema.
- 3 GiB di scrittura in modalità in primo piano dell'app.
- 2 GiB di scrittura in modalità in background dell'app.
- 4 GiB in scrittura in modalità garage di sistema.
- Queste sono soglie di base. Queste soglie vengono aggiornate man mano che si ottengono altre informazioni sull'I/O del disco all'utilizzo delle risorse.
Utilizzo eccessivo del formato XML della configurazione
La configurazione predefinita del fornitore può essere inserita (facoltativa) nella sede
/vendor/etc/automotive/watchdog/resource_overuse_configuration.xml
nell'immagine build. Se questa configurazione non è specificata, il valore
viene applicata anche alle app e ai servizi dei fornitori.
Il file XML deve contenere un solo tag per ogni campo di configurazione. Uso eccessivo di I/O deve essere definita nel file XML. Tutti i valori di soglia devono essere specificato nell'unità MiB.
Di seguito è riportata una configurazione XML di esempio:
<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>
Aggiorna la configurazione di utilizzo eccessivo tramite le API di sistema CarWatchdogManager
La configurazione XML riportata sopra può essere fornita solo nell'immagine build. Se L'OEM sceglie di aggiornare la configurazione sul dispositivo dopo il rilascio di una build può usare le API seguenti per apportare modifiche alla configurazione sul dispositivo.
- Concedi l'autorizzazione
Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIGall'utente chiamante. - Devi usare le configurazioni esistenti per aggiornare e impostare
nuove configurazioni. Utilizzare l'API
CarWatchdogManager.getResourceOveruseConfigurationsper ottenere configurazioni esistenti. Se non vengono utilizzate le configurazioni esistenti, (incluse quelle di sistema e di terze parti) vengono sovrascritte, cosa sconsigliata. - Aggiornare le configurazioni esistenti con le modifiche delta e impostare il nuovo valore configurazioni. Non aggiornare il sistema e i componenti di terze parti configurazioni.
- Utilizza l'API
CarWatchdogManager.setResourceOveruseConfigurationsper impostare le nuove configurazioni. - Per ottenere e impostare le configurazioni di uso eccessivo di I/O del disco, utilizza il flag
CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO.
Di seguito è riportata un'implementazione di esempio che aggiorna le configurazioni di utilizzo eccessivo delle risorse:
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();
}
App che monitorano l'utilizzo eccessivo delle risorse
Il fornitore e le app di terze parti possono rimanere in ascolto di risorse specifiche per le app
usa le notifiche di Watchdog o sondaggio CarWatchdogManager per l'app
statistiche sull'uso eccessivo di risorse specifiche
fino agli ultimi 30 giorni.
Ascolta le notifiche di utilizzo eccessivo delle risorse
Le app possono implementare un listener che fa uso eccessivo di risorse e registrare il
ascoltatore con CarWatchdogManager per ricevere notifiche specifiche per l'app quando
superino l'80% o il 100% delle soglie di sovrauso di I/O del disco. Le app possono utilizzare
queste notifiche per:
- Registra le statistiche di utilizzo eccessivo di I/O del disco per l'analisi offline. Per app gli sviluppatori possono utilizzare questo logging per eseguire il debug del problema di utilizzo eccessivo di I/O del disco.
- Riduci le scritture di I/O su disco fino a quando i contatori di sovraccarico non vengono reimpostati.
Client Java
- Implementa il listener ereditando
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() } } } - Registra l'istanza listener chiamando
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); } - Annulla la registrazione dell'istanza listener quando l'app ha terminato l'ascolto:
private void removeResourceOveruseListener() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE); mCarWatchdogManager.removeResourceOveruseListener( mListenerImpl); }
Client nativo
- Includi
carwatchdog_aidl_interface-ndk_platformnel Dipendenzashared_libsdella regola di build.Android.bpcc_binary { name: "sample_native_client", srcs: [ "src/*.cpp" ], shared_libs: [ "carwatchdog_aidl_interface-ndk_platform", "libbinder_ndk", ], vendor: true, } - Aggiungi il criterio SELinux per consentire al dominio del servizio del fornitore di utilizzare binder
(macro
binder_user) e aggiungi il dominio del servizio del fornitore alla Dominio clientcarwatchdog(carwatchdog_client_domain macro). Visualizza il codice seguente persample_client.teefile_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
- Implementare il listener in caso di uso eccessivo della risorsa, ereditando
BnResourceOveruseListener. Esegui overrideBnResourceOveruseListener::onOveruseper gestire l'utilizzo eccessivo delle risorse notifiche.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(); } - Avvia un pool di thread binder e registra il listener di utilizzo eccessivo della risorsa
con il server watchdog. Il server watchdog è registrato con il nome del servizio
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); }
Statistiche sull'utilizzo eccessivo delle risorse dei sondaggi
Le app possono interrogare CarWatchdogManager per l'utilizzo eccessivo di I/O specifico dell'app statistiche ATS degli ultimi 30 giorni.
Client Java
Usa CarWatchdogManager.getResourceOveruseStats per ottenere
statistiche sull'uso eccessivo delle risorse. Supera CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO
per ottenere le statistiche di uso eccessivo di I/O del disco.
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()
}
Client nativo
Usa CarWatchdogServer.getResourceOveruseStats per ottenere
statistiche sull'uso eccessivo delle risorse. Passa l'enum ResourceType.IO per recuperare l'utilizzo eccessivo di I/O del disco
statistiche.
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
}
}
L'utilizzo eccessivo delle risorse dell'esperienza utente
Le seguenti sezioni descrivono l'esperienza utente in caso di utilizzo eccessivo delle risorse.
Dai priorità all'impostazione relativa alle prestazioni delle app
La pagina Impostazioni dell'app contiene le impostazioni relative aPrioritize app performance
(vedi l'immagine di seguito), che consente agli utenti di dare la priorità alle prestazioni di un'app rispetto al sistema e
con prestazioni hardware a lungo termine. Questa impostazione è disponibile soltanto per le app sicure
in caso di uso eccessivo delle risorse. In caso contrario, questa impostazione è disattivata. Quando questa impostazione viene
disattivata (impostazione predefinita) per un'app, quest'ultima può essere terminata in caso di uso eccessivo della risorsa.
In caso contrario, l'app non viene terminata in caso di uso eccessivo delle risorse.
Quando l'utente attiva questa impostazione, la seguente finestra di dialogo di conferma descrive implicazioni dell'attivazione/disattivazione dell'impostazione:
Dopo 90 giorni, l'impostazione viene ripristinata automaticamente al valore predefinito. Il limite giornaliero può essere
modificato con un'app overlay RRO utilizzando watchdogUserPackageSettingsResetDays,
per un massimo di 180 giorni. Per saperne di più, vedi
Modificare il valore delle risorse di un'app in fase di runtime. La
il seguente tag overlay di esempio può essere incluso in AndroidManifest.xml:
<overlay android:priority="<insert-value>"
android:targetPackage="com.android.car.updatable"
android:targetName="CarServiceCustomization"
android:resourcesMap="@xml/overlays" />
Tra res/values/config.xml:
<resources> <integer name="watchdogUserPackageSettingsResetDays">value</integer> </resources>
Tra res/xml/overlays.xml:
<overlay> <item target="integer/watchdogUserPackageSettingsResetDays" value="@integer/watchdogUserPackageSettingsResetDays" /> </overlay>
Impostazione delle app che influiscono sulle prestazioni
L'app Impostazioni contiene una sezione App che influiscono sulle prestazioni. (vedi Figura 1). Se toccato, un elenco di app che sono state limitate a causa della memoria flash un uso eccessivo e che influisce negativamente sulle prestazioni del sistema. Segue Requisito CDD 3.5.1 [C-1-1].
Figura 1. App che influiscono sulle prestazioni.
Le app terminate per utilizzo eccessivo di risorse sono elencate qui (vedi Figura 2). Le app elencate possono avere la priorità. Per saperne di più, vedi Dai la priorità all'impostazione relativa alle prestazioni delle app.
Figura 2. Elenco di app terminate a causa dell'utilizzo eccessivo delle risorse.
Notifica per l'utente
Quando un'app o un servizio usa ripetutamente l'I/O del disco (ad esempio, scrive i dati su disco oltre le soglie definite) entro un determinato periodo ed è sicuro in caso di uso eccessivo della risorsa, l'utente viene avvisato quando il veicolo entra lo stato allow-driver-distrazione.
La prima notifica per l'utente (durante un viaggio) viene pubblicata come avviso la notifica e le altre notifiche siano pubblicate sulla notifica Google Cloud.
Ad esempio, quando un'app usa ripetutamente l'I/O del disco, l'utente riceve seguente notifica:
- Quando l'utente fa clic sul pulsante Assegna priorità app, la viene avviata la pagina delle impostazioni dell'app, dove l'utente può attivare o disattivare Impostazione Dai la priorità alle prestazioni delle app.
- Quando l'utente fa clic sul pulsante Disattiva app, l'app è disattivata finché l'utente non avvia l'app o la attiva nella nella pagina delle impostazioni.
- Per le app disinstallabili, il pulsante Disattiva app è
sostituita con il pulsante Disinstalla app. Quando l'utente fa clic sul
pulsante Disinstalla app, viene avviata la pagina Impostazioni dell'app,
da cui l'utente può disinstallare l'app.
Consiglio per l'implementazione di Avvio app
Quando le app vengono disattivate a causa di un uso eccessivo di risorse, scompaiono dalla
app Avvio app predefinita perché CarService aggiorna l'app attivo come
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED.
Gli OEM devono aggiornare l'implementazione di Avvio app integrata per visualizzare queste app come insolite,
in modo che gli utenti possano utilizzarle
se necessario. Consulta i seguenti consigli basati sulla release della build.
Release di Android SC V2
- L'implementazione di Avvio app dovrebbe utilizzare
MATCH_DISABLED_UNTIL_USED_COMPONENTSdurante il recupero dell'elenco dei pacchetti da mostrare in Avvio app. - Quando l'utente fa clic su un'app della
Stato
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, Avvio app l'app deve abilitarla impostando lo stato Attivato come: