Watchdog monitora l'utilizzo della memoria flash monitorando la quantità totale di scrittura I/O su disco eseguita da tutte le app e i servizi utilizzando le statistiche I/O su disco per UID esposte dal kernel nella posizione "/proc/uid_io/stats". Quando un'app o un servizio supera la soglia di utilizzo eccessivo I/O su disco, Watchdog esegue azioni sull'app o sul servizio. Le soglie di utilizzo eccessivo dell'I/O del disco e l'azione da intraprendere in caso di utilizzo eccessivo sono predefinite nella configurazione dell'utilizzo eccessivo dell'I/O del disco.
Soglie di utilizzo eccessivo
- Le soglie di utilizzo eccessivo di I/O del disco vengono applicate ogni giorno, ovvero tutte le scritture effettuate da un'app o un servizio vengono aggregate dall'inizio del giorno di calendario UTC attuale e verificate in base alle soglie definite nelle configurazioni di utilizzo eccessivo.
- Quando un veicolo viene avviato più volte in un determinato giorno, il modulo Watchdog memorizza le statistiche di utilizzo I/O del disco nella memoria flash e le aggrega dall'inizio del giorno di calendario UTC corrente.
Azioni per il sovrautilizzo
Quando un'app supera ripetutamente le soglie di sovraccarico di I/O del disco definite, il watchdog esegue le azioni definite nella configurazione di utilizzo eccessivo.
- Tutti i servizi e le app del fornitore sono considerati critici per la stabilità complessiva del sistema, quindi non vengono terminati con un uso eccessivo di I/O del disco. Tuttavia, la configurazione per l'utilizzo eccessivo può definire un elenco di app e servizi del fornitore che possono essere chiusi in sicurezza.
- Tutte le app di terze parti possono essere chiuse in sicurezza.
Quando un'app o un servizio può essere interrotto in sicurezza, Watchdog lo disattiva con lo stato del componente dell'app
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
.
Configurazione del sovrautilizzo
La configurazione dell'uso eccessivo contiene le soglie e le azioni per l'uso eccessivo dell'I/O del disco. Le configurazioni di utilizzo eccessivo predefinite sono definite nelle immagini del sistema e del fornitore e vengono fornite con la build. I fornitori possono includere la configurazione del fornitore nell'immagine del fornitore. Se non viene fornita la configurazione del fornitore, viene utilizzata anche la configurazione di sistema per le app e i servizi del fornitore.
Watchdog espone le API di sistema tramite CarWatchdogManager, che consente ai fornitori di app o servizi di aggiornare la configurazione del fornitore in qualsiasi momento.
Definizione della configurazione per il sovrautilizzo
La configurazione del sovrautilizzo è suddivisa in base al tipo di componente, ad esempio sistema, fornitore e terze parti. Gli OEM devono aggiornare solo la configurazione del componente del fornitore.
Configurazione del fornitore
La configurazione del fornitore definisce le soglie e le azioni per l'utilizzo eccessivo di I/O del disco per tutte le app e i servizi del fornitore, nonché per tutte le app di mappe e multimediali. La configurazione contiene i seguenti campi di configurazione.
- Prefissi dei pacchetti del fornitore. Tutti i pacchetti installati nella partizione del fornitore sono considerati pacchetti del fornitore. Oltre a questi pacchetti, i fornitori possono classificare i pacchetti preinstallati come pacchetti del fornitore aggiungendo i prefissi dei pacchetti alla configurazione prefiss pacchetti fornitore. Questa configurazione non accetta espressioni regolari.
- Pacchetti che possono essere chiusi in sicurezza. I fornitori possono specificare quali pacchetti del fornitore possono essere chiusi in sicurezza aggiungendo i nomi completi dei pacchetti alla configurazione dei pacchetti che possono essere chiusi in sicurezza.
- Mappature delle categorie di applicazioni. I fornitori possono mappare qualsiasi pacchetto (inclusi i pacchetti di terze parti) a una delle due categorie di app supportate: mappe e app multimediali. Questa mappatura viene eseguita per fornire a mappe e app multimediali soglie di utilizzo eccessivo dell'I/O del disco più elevate, in quanto queste app tendono a scaricare e scrivere più dati sul disco rispetto ad altri tipi di app.
- Soglie a livello di componente. Definisce soglie generiche per tutti i pacchetti del fornitore (ovvero, i pacchetti non coperti da Soglie specifiche del pacchetto o Soglie specifiche per categoria di applicazione ricevono queste soglie). I fornitori devono definire soglie a livello di componente diverse da zero quando definiscono la configurazione per l'utilizzo eccessivo dell'I/O del disco.
- Soglie specifiche per pacchetto. I fornitori possono definire soglie speciali per pacchetti specifici. Le mappature devono contenere i 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. Le categorie di app devono essere una delle categorie supportate: Maps e App multimediali. Le soglie definite in questa configurazione vengono mappate a pacchetti specifici utilizzando le mappature delle categorie di applicazioni.
- Soglie a livello di sistema. I fornitori non devono specificare questa configurazione.
Le configurazioni Prefisso del pacchetto del fornitore, Pacchetti che possono essere terminati in sicurezza, Soglie a livello di componente e Soglie specifiche per il pacchetto sono aggiornabili solo dalla configurazione del fornitore per app e servizi del fornitore. La configurazione delle soglie specifiche per categoria di applicazione può essere aggiornata solo tramite la configurazione del fornitore per tutte le mappe e le app multimediali.
Le soglie di utilizzo eccessivo contengono la quantità di byte consentita per la scrittura durante:
- Confronto tra la modalità in primo piano o la modalità in background di un'app o un servizio
- Modalità garage del sistema
Questa classificazione consente alle app e ai servizi in primo piano rivolti agli utenti di scrivere più dati rispetto alle app e ai servizi in background. In modalità Garage, le app e i servizi tendono a scaricare aggiornamenti, pertanto ognuno richiede una soglia più elevata rispetto alle app e ai servizi in esecuzione 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 soglie di utilizzo eccessivo di I/O e azioni per
app e servizi di sistema.
- Questa configurazione può anche aggiornare le mappature delle categorie di applicazioni. Pertanto, questo campo di configurazione viene condiviso tra le configurazioni di sistema e del fornitore.
- La configurazione di terze parti definisce le soglie per tutte le app di terze parti. Tutte le app non preinstallate nel sistema sono
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 app multimediali, le cui soglie sono definite dalla configurazione del fornitore.
- Le seguenti soglie di utilizzo eccessivo dell'I/O del disco sono le soglie predefinite per le 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.
- Si tratta di soglie di base. Queste soglie vengono aggiornate man mano che si apprende di più sull'utilizzo dell'I/O del disco.
Formato XML della configurazione per l'utilizzo eccessivo
La configurazione predefinita del fornitore può essere posizionata (facoltativa) nella posizione
/vendor/etc/automotive/watchdog/resource_overuse_configuration.xml
nell'immagine di compilazione. Se questa configurazione non è specificata, la configurazione definita dal sistema viene applicata anche per le app e i servizi del fornitore.
Il file XML deve contenere un solo tag per ogni campo di configurazione. La configurazione dell'uso eccessivo di I/O deve essere definita nel file XML. Tutti i valori di soglia devono essere specificati in 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>
Aggiornare la configurazione dell'uso eccessivo tramite le API di sistema CarWatchdogManager
La configurazione XML riportata sopra può essere fornita solo nell'immagine di compilazione. Se un OEM sceglie di aggiornare la configurazione on-device dopo il rilascio di una build, può utilizzare le seguenti API per apportare modifiche alla configurazione on-device.
- Concedi l'autorizzazione
Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIGal chiamante. - Devi utilizzare le configurazioni esistenti per aggiornare e impostare le nuove configurazioni. Utilizza l'API
CarWatchdogManager.getResourceOveruseConfigurationsper recuperare le configurazioni esistenti. Se le configurazioni esistenti non vengono utilizzate, tutte le configurazioni (incluse quelle di sistema e di terze parti) vengono sovrascritte, il che non è consigliabile. - Aggiorna le configurazioni esistenti con le modifiche delta e imposta le nuove configurazioni. Non aggiornare le configurazioni del sistema e dei componenti di terze parti.
- Utilizza l'API
CarWatchdogManager.setResourceOveruseConfigurationsper impostare le nuove configurazioni. - Per ottenere e impostare le configurazioni di utilizzo eccessivo dell'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
Le app di fornitori e di terze parti possono ascoltare le notifiche relative all'utilizzo eccessivo delle risorse specifiche dell'app da Watchdog o eseguire il polling CarWatchdogManager per le statistiche sull'utilizzo eccessivo delle risorse specifiche dell'app fino agli ultimi 30 giorni.
Ascoltare le notifiche relative all'utilizzo eccessivo delle risorse
Le app possono implementare un ascoltatore di utilizzo eccessivo delle risorse e registrarlo con CarWatchdogManager per ricevere notifiche specifiche dell'app quando superano l'80% o il 100% delle soglie di utilizzo eccessivo I/O del disco. Le app possono utilizzare queste notifiche per:
- Registra le statistiche sull'utilizzo eccessivo dell'I/O del disco per l'analisi offline. Gli sviluppatori di app possono utilizzare questo logging per eseguire il debug del problema di utilizzo eccessivo dell'I/O del disco.
- Riduci le scritture I/O del disco fino al ripristino dei contatori di utilizzo eccessivo.
Client Java
- Implementa l'ascoltatore 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 di 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); } - Annullare la registrazione dell'istanza di listener quando l'app ha terminato di ascoltare:
private void removeResourceOveruseListener() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE); mCarWatchdogManager.removeResourceOveruseListener( mListenerImpl); }
Client nativo
- Includi
carwatchdog_aidl_interface-ndk_platformnella dipendenzashared_libsdella regola di compilazione.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 di servizio del fornitore di utilizzare Binder
(macro
binder_user) e aggiungi il dominio di servizio del fornitore al dominio clientcarwatchdog(carwatchdog_client_domain macro). Consulta il codice riportato di seguito 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
- Implementa l'ascoltatore per l'utilizzo eccessivo delle risorse ereditando
BnResourceOveruseListener. SostituisciBnResourceOveruseListener::onOveruseper gestire le notifiche relative all'utilizzo eccessivo delle risorse.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 del binder e registra l'ascoltatore per l'utilizzo eccessivo delle risorse con il server di monitoraggio. Il server di monitoraggio è 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 eseguire il polling di CarWatchdogManager per le statistiche ATS relative all'uso eccessivo I/O specifico dell'app per i 30 giorni più recenti.
Client Java
Utilizza CarWatchdogManager.getResourceOveruseStats per visualizzare le statistiche sull'utilizzo eccessivo delle risorse. Passa il flag CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO
per ottenere le statistiche sull'utilizzo eccessivo dell'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
Utilizza CarWatchdogServer.getResourceOveruseStats per visualizzare le statistiche sull'utilizzo eccessivo delle risorse. Passa l'enum ResourceType.IO per recuperare le statistiche sull'uso eccessivo dell'I/O disco.
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
}
}
Esperienza utente per l'utilizzo eccessivo delle risorse
Le seguenti sezioni descrivono l'esperienza utente quando si verifica un utilizzo eccessivo delle risorse.
Dai priorità all'impostazione relativa alle prestazioni delle app
La pagina Impostazioni dell'app contiene le impostazioni perPrioritize app performance
(vedi l'immagine di seguito), che consentono agli utenti di dare la priorità alle prestazioni di un'app rispetto alle
prestazioni dell'hardware e di sistema a lungo termine. Questa impostazione è disponibile solo per le app che possono essere terminate in caso di utilizzo eccessivo di risorse. In caso contrario, questa impostazione è disattivata. Se questa impostazione è disattivata (impostazione predefinita) per un'app, l'app può essere interrotta in caso di utilizzo eccessivo delle risorse.
In caso contrario, l'app non viene interrotta in caso di utilizzo eccessivo delle risorse.
Quando l'utente attiva questa impostazione, la seguente finestra di dialogo di conferma descrive le implicazioni dell'attivazione dell'impostazione:
Dopo 90 giorni, questa impostazione viene reimpostata automaticamente su quella predefinita. Il limite di giorni può essere modi
ficado con un'app overlay RRO che utilizza watchdogUserPackageSettingsResetDays,
fino a un massimo di 180 giorni. Per scoprire di più, consulta
Modificare il valore delle risorse di un'app in fase di esecuzione. Il
seguente esempio di tag overlay 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>
In res/xml/overlays.xml:
<overlay> <item target="integer/watchdogUserPackageSettingsResetDays" value="@integer/watchdogUserPackageSettingsResetDays" /> </overlay>
Impostazioni delle app che influiscono sulle prestazioni
L'app Impostazioni contiene una sezione App che influiscono sul rendimento (vedi Figura 1). Se viene toccato, viene visualizzato un elenco di app che sono state limitate a causa dell'uso eccessivo della memoria flash e che influiscono negativamente sulle prestazioni del sistema. Ciò soddisfa il 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). Alle app elencate può essere assegnata una priorità. Per scoprire di più, consulta Impostare la priorità al rendimento dell'app.
Figura 2. Elenco di app interrotte a causa di un utilizzo eccessivo delle risorse.
Notifica all'utente
Quando un'app o un servizio fa un uso eccessivo dell'I/O del disco (ad esempio, scrive dati sul disco oltre le soglie definite) in un determinato periodo ed è sicuro che venga interrotto in caso di utilizzo eccessivo delle risorse, l'utente riceve una notifica dopo che il veicolo entra nello stato di distrazione del conducente consentita.
La prima notifica utente (durante la guida) viene pubblicata come notifica di avviso, mentre le altre notifiche vengono pubblicate nel centro notifiche.
Ad esempio, quando un'app utilizza ripetutamente in modo eccessivo l'I/O del disco, l'utente riceve la seguente notifica:
- Quando l'utente fa clic sul pulsante Assegna priorità app, viene avviata la pagina delle impostazioni dell'app, in cui l'utente può attivare o disattivare l'impostazione Assegna priorità alle prestazioni dell'app.
- Quando l'utente fa clic sul pulsante Disattiva app, l'app viene disattivata fino a quando l'utente non la avvia o la attiva nella pagina delle impostazioni dell'app.
- Per le app disinstallabili, il pulsante Disattiva app è
sostituito dal 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 del programma di avvio
Quando le app vengono disattivate a causa di un utilizzo eccessivo delle risorse, scompaiono dall'app Avvio app predefinita perché CarService aggiorna lo stato di attivazione delle app su 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 in base alla versione della build.
Release di Android SC V2
- L'implementazione di Avvio app dovrebbe usare il flag
MATCH_DISABLED_UNTIL_USED_COMPONENTSdurante il recupero dell'elenco di pacchetti da mostrare in Avvio app. - Quando l'utente fa clic su un'app in stato
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, l'app Avvio applicazioni deve attivarla impostando lo stato attivo su: