Watchdog surveille l'utilisation de la mémoire flash en suivant la quantité totale d'E/S disque écritures effectuées par l'ensemble des applications et services à l'aide des statistiques d'E/S sur disque par UID exposé par le noyau à l'emplacement "/proc/uid_io/stats". Lorsqu'une application ou le service dépasse le seuil de surutilisation des E/S du disque, Watchdog prend des mesures sur le application ou service. Les seuils de surutilisation des E/S du disque et les mesures à prendre en cas d'utilisation excessive est prédéfinie dans la configuration de surutilisation des E/S du disque.
Seuils de surutilisation
- Les seuils de surutilisation des E/S disque sont appliqués quotidiennement, c'est-à-dire les écritures effectuées par une application ou un service sont agrégées jour calendaire UTC actuel et vérifié si les seuils définis dans le les configurations de surutilisation.
- Lorsqu'un véhicule démarre plusieurs fois au cours d'une même journée, le module Watchdog stocke les statistiques d'utilisation des E/S disque dans la mémoire flash et les agrège depuis le début du jour calendaire UTC actuel.
Actions d'abus
Lorsqu'une application dépasse de manière répétée la surutilisation des E/S du disque définie de surveillance, le Watchdog prend les mesures définies dans la configuration de surutilisation.
- Toutes les applications et tous les services des fournisseurs sont considérés comme essentiels pour la la stabilité globale du système, de sorte qu'ils ne sont pas arrêtés en cas de surutilisation des E/S disque. Toutefois, la configuration de surutilisation peut définir une liste d'applications des fournisseurs dont l'arrêt peut être sécurisé et services Google Cloud.
- Toutes les applications tierces peuvent être arrêtées sans risque.
Lorsqu'une application ou un service peut s'arrêter sans risque, Watchdog le désactive avec l'application
état du composant
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
Surutilisation de la configuration
La configuration de surutilisation contient les seuils de surutilisation des E/S du disque et actions. Les configurations d'utilisation abusive par défaut sont définies dans le système et le fournisseur et fournies avec le build. Les fournisseurs peuvent éventuellement inclure le fournisseur dans l'image du fournisseur. Lorsque la configuration du fournisseur n'est pas fournie, la configuration système est utilisée pour les applications du fournisseur et services.
Watchdog expose les API système via CarWatchdogManager, ce qui permet
les applications ou services du fournisseur mettent à jour la configuration du fournisseur ;
à tout moment.
Définition de la configuration de surutilisation
La configuration de surutilisation est divisée en fonction du type de composant (par exemple, système, fournisseur, et tiers. Les OEM ne doivent mettre à jour que la configuration des composants du fournisseur.
Configuration du fournisseur
La configuration du fournisseur définit les seuils et les actions de surutilisation des E/S du disque pour tous les services et applications de fournisseurs, ainsi que toutes les applications cartographiques et multimédias. La configuration contient les champs de configuration ci-dessous.
- Préfixes de package de fournisseur. Tous les packages installés dans la partition des fournisseurs sont considérés comme des packages de fournisseurs. En plus de ces packages, les fournisseurs peuvent classer les packages préinstallés en tant que packages de fournisseurs par en ajoutant les préfixes de package à la configuration des préfixes de package du fournisseur. Cette configuration n'accepte pas les expressions régulières.
- Les packages peuvent être arrêtés de manière sécurisée. Les fournisseurs peuvent spécifier les packages peuvent être arrêtés en toute sécurité en ajoutant les noms de package complets au packages avec arrêt sécurisé.
- Mappages de catégories d'applications. Les fournisseurs peuvent mapper n'importe quel package (y compris les packages tiers) vers l'une des deux applications compatibles catégories : applications cartographiques et multimédias. Cette cartographie permet de fournir des cartes et les applications multimédias, les seuils de surutilisation des E/S disque sont plus élevés, car ces les applications ont tendance à télécharger et à écrire plus de données sur le disque que les autres de données.
- Seuils au niveau des composants. Il définit des seuils génériques pour toutes les packages de fournisseurs (c'est-à-dire les packages non couverts par l'option ou Les seuils spécifiques à une catégorie d'applications obtiennent ces seuils). Les fournisseurs doivent définir des seuils non nuls au niveau des composants lorsque définir la configuration de surutilisation des E/S du disque.
- Seuils spécifiques au package. Les fournisseurs peuvent définir des règles pour des packages de fournisseurs spécifiques. Les mappages doivent contenir le paramètre les noms de package complets. Les seuils définis dans cette configuration sont prioritaires au-delà des seuils définis dans d'autres configurations pour un package donné.
- Seuils spécifiques à une catégorie d'applications. Les fournisseurs peuvent spécifier des seuils spéciaux pour des catégories d'applications spécifiques L'application Les catégories doivent correspondre à l'une des catégories acceptées ("Cartes" et "Médias") applications. Les seuils définis dans cette configuration sont mappés à des Packages à l'aide de mappages de catégories d'applications
- Seuils à l'échelle du système. Les fournisseurs ne doivent pas spécifier cette configuration.
Préfixes de package de fournisseur, Packages pouvant être arrêtés sans risque, Seuils au niveau des composants et Seuils spécifiques au package de seuil ne peuvent être mises à jour que par la configuration du fournisseur les applications et services de fournisseurs. Spécifique à une catégorie d'applications de seuil ne peut être modifiée que par la configuration du fournisseur pour toutes de cartes et d'applications multimédias.
Les seuils de surutilisation indiquent la quantité d'octets autorisés à être écrits pendant:
- Mode premier plan d'une application ou d'un service ou mode arrière-plan
- Mode garage du système
Cette classification permet aux applications et services de premier plan visibles par l'utilisateur de : écrire plus de données que les applications et services en arrière-plan. En mode garage, les applications et les services ont tendance à télécharger des mises à jour. Chacun d'entre eux nécessite donc un seuil plus élevé que les applications et services s'exécutant dans d'autres modes.
Configurations système et tierces
Les OEM ne doivent pas mettre à jour les configurations système et tierces.
- La configuration système définit des seuils et des actions de surutilisation des E/S pour
les applications et services système.
- Cette configuration peut également mettre à jour la catégorie d'application de mise en correspondance. Ainsi, ce champ de configuration est partagé entre le système et le fournisseur. de configuration.
- La configuration tierce définit des seuils pour tous les environnements
applications. Toutes les applications non préinstallées sur le système
des applications tierces.
- Toutes les applications tierces reçoivent les mêmes seuils (par exemple, aucun l'application tierce reçoit des seuils spéciaux), sauf pour les cartes et les contenus multimédias applications, dont les seuils sont définis par la configuration du fournisseur.
- Les seuils de surutilisation des E/S disque ci-dessous sont les seuils par défaut pour
des applications tierces. Ces seuils sont fournis avec l'image système.
- 3 Gio en écriture en mode premier plan de l'application.
- 2 Gio en écriture en mode arrière-plan de l'application.
- 4 Gio en écriture en mode garage du système
- Il s'agit des seuils de base. Ces seuils sont mis à jour à mesure que l'on apprend sur les E/S disque. sur l'utilisation de l'IA générative.
Utiliser le format XML de configuration excessive
La configuration de fournisseur par défaut peut être placée (facultatif) à l'emplacement
/vendor/etc/automotive/watchdog/resource_overuse_configuration.xml
dans l'image de compilation. Si cette configuration n'est pas spécifiée, la bibliothèque
est également appliquée aux applications et services des fournisseurs.
Le fichier XML ne doit contenir qu'une seule balise pour chaque champ de configuration. Surutilisation des E/S doit être définie dans le fichier XML. Toutes les valeurs de seuil doivent être spécifié dans l'unité Mio.
Vous trouverez ci-dessous un exemple de configuration 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>
Mettre à jour la configuration de surutilisation via les API système CarWatchdogManager
La configuration XML ci-dessus ne peut être fournie que dans l'image de compilation. Si un L'OEM choisit de mettre à jour la configuration sur l'appareil après la publication d'un build, il peut utiliser les API suivantes pour modifier la configuration sur l'appareil.
- Accordez l'autorisation
Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIGà appelant. - Vous devez utiliser les configurations existantes pour mettre à jour et définir
de nouvelles configurations. Utiliser l'API
CarWatchdogManager.getResourceOveruseConfigurationspour obtenir la configurations existantes. Si les configurations existantes ne sont pas utilisées, toutes (y compris les configurations système et tierces) sont écrasées, ce qui n'est pas recommandé. - Mettez à jour les configurations existantes avec les modifications delta et définissez le nouveau de configuration. Ne mettez pas à jour le système ni les composants tiers. de configuration.
- Utiliser l'API
CarWatchdogManager.setResourceOveruseConfigurationspour définir les nouvelles configurations. - Pour obtenir et définir les configurations de surutilisation des E/S du disque, utilisez l'option
CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO
Voici un exemple d'implémentation qui met à jour les configurations de surutilisation des ressources:
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();
}
Applications surveillant leur surutilisation des ressources
Les applications de fournisseurs et les applications tierces peuvent écouter une ressource spécifique à l'application.
abuser des notifications de Watchdog ou sonder CarWatchdogManager pour connaître l'application ;
des statistiques sur l'utilisation excessive de ressources spécifiques pour les 30 derniers jours.
Écouter les notifications d'utilisation excessive des ressources
Les applications peuvent implémenter un écouteur de surutilisation des ressources et enregistrer le
l'écouteur avec CarWatchdogManager pour recevoir des notifications spécifiques à l'application lorsqu'il
dépasser 80% ou 100% de leurs seuils de surutilisation des E/S disque. Les applications peuvent utiliser
ces notifications à:
- Consignez les statistiques de surutilisation des E/S du disque pour l'analyse hors connexion. Application les développeurs peuvent utiliser cette journalisation pour déboguer le problème de surutilisation des E/S disque.
- Réduisez les écritures d'E/S sur le disque jusqu'à ce que les compteurs de surutilisation soient réinitialisés.
Client Java
- Implémentez l'écouteur en héritant de
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() } } } - Enregistrez l'instance d'écouteur en appelant
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); } - Annulez l'enregistrement de l'instance d'écouteur lorsque l'application a fini d'écouter:
private void removeResourceOveruseListener() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE); mCarWatchdogManager.removeResourceOveruseListener( mListenerImpl); }
Native Client
- Inclure
carwatchdog_aidl_interface-ndk_platformdans Dépendanceshared_libsde la règle de compilation.Android.bpcc_binary { name: "sample_native_client", srcs: [ "src/*.cpp" ], shared_libs: [ "carwatchdog_aidl_interface-ndk_platform", "libbinder_ndk", ], vendor: true, } - Ajouter une règle SELinux pour autoriser le domaine du service du fournisseur à utiliser la liaison
(macro
binder_user), puis ajoutez le domaine du service fournisseur au Le domaine clientcarwatchdog(carwatchdog_client_domain macro). Consultez le code ci-dessous poursample_client.teetfile_contextssample_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
- Implémentez l'écouteur de surutilisation des ressources en héritant
BnResourceOveruseListenerRemplacementBnResourceOveruseListener::onOverusepour gérer la surutilisation des ressources les notifications.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(); } - Démarrer un pool de threads de liaison et enregistrer l'écouteur de surutilisation des ressources
avec le serveur watchdog. Le serveur Watchdog est enregistré sous le nom de service
android.automotive.watchdog.ICarWatchdog/defaultmain.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); }
Interrogez les statistiques sur la surutilisation des ressources
Les applications peuvent interroger CarWatchdogManager pour connaître l'utilisation excessive des E/S spécifiques à l'application. ATS des 30 derniers jours.
Client Java
Utilisez CarWatchdogManager.getResourceOveruseStats pour obtenir
les statistiques sur la surutilisation des ressources. Transmettre CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO
pour obtenir les statistiques de surutilisation
des E/S du disque.
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()
}
Native Client
Utilisez CarWatchdogServer.getResourceOveruseStats pour obtenir
les statistiques sur la surutilisation des ressources. Transmettez l'énumération ResourceType.IO pour récupérer la surutilisation des E/S du disque.
statistiques.
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
}
}
Expérience utilisateur excessive des ressources
Les sections suivantes décrivent l'expérience utilisateur en cas d'utilisation excessive des ressources.
Prioriser les paramètres de performances de l'appli
La page Paramètres de l'application contient les paramètres pour Prioritize app performance
(voir l'image ci-dessous), qui permet aux utilisateurs de donner la priorité aux performances d'une application par rapport à celles du système.
des performances matérielles à long terme. Ce paramètre n'est disponible que pour les applications pouvant être installées en toute sécurité
et arrêté en cas de surutilisation des ressources. Sinon, ce paramètre est désactivé. Lorsque ce paramètre est
(paramètre par défaut) pour une application, celle-ci peut être arrêtée en cas de surutilisation des ressources.
Sinon, l'application n'est pas arrêtée en cas de surutilisation des ressources.
Lorsque l'utilisateur active ce paramètre, la boîte de dialogue de confirmation suivante décrit le conséquences de l'activation/de désactivation du paramètre:
Au bout de 90 jours, la valeur par défaut de ce paramètre est automatiquement rétablie. La limite quotidienne peut être
modifié avec une application de superposition RRO à l'aide de watchdogUserPackageSettingsResetDays ;
jusqu'à 180 jours. Pour en savoir plus, consultez
Modifiez la valeur des ressources d'une application au moment de l'exécution. La
L'exemple de balise de superposition suivant peut être inclus dans AndroidManifest.xml:
<overlay android:priority="<insert-value>"
android:targetPackage="com.android.car.updatable"
android:targetName="CarServiceCustomization"
android:resourcesMap="@xml/overlays" />
Dans res/values/config.xml :
<resources> <integer name="watchdogUserPackageSettingsResetDays">value</integer> </resources>
Dans res/xml/overlays.xml :
<overlay> <item target="integer/watchdogUserPackageSettingsResetDays" value="@integer/watchdogUserPackageSettingsResetDays" /> </overlay>
Paramètre pour les applications ayant un impact sur les performances
L'application Paramètres contient une section Applications ayant un impact sur les performances. (voir la figure 1). Liste des applications dont l'accès a été limité en raison de la mémoire flash une surutilisation abusive et qui a un impact négatif sur les performances du système. Cela suit Exigence du CDD 3.5.1 [C-1-1]
Figure 1 : Applications ayant un impact sur les performances.
Les applications qui ont été arrêtées en raison d'une surutilisation des ressources sont listées ici (voir la figure 2). Les applications listées peuvent être priorisé. Pour en savoir plus, consultez Hiérarchiser les paramètres de performances de l'application
Figure 2. Liste des applications arrêtées en raison d'une surutilisation des ressources.
Notification utilisateur
Lorsqu'une application ou un service surutilise de façon répétée les E/S du disque (par exemple, en écrivant des au-delà des seuils définis) dans un certain délai doit être résilié en cas d'utilisation excessive des ressources, l'utilisateur est averti une fois que le véhicule est entré l'état allow-driver-distraction.
La première notification utilisateur (pendant un trajet) est publiée sous forme d'avertissement notification et les autres sont publiées sur la notification de sécurité.
Par exemple, lorsqu'une application surutilise de façon répétée les E/S disque, l'utilisateur reçoit l'erreur notification suivante:
- Lorsque l'utilisateur clique sur le bouton Donner priorité à l'appli, la page des paramètres de l'application s'ouvre, et l'utilisateur peut activer ou désactiver Paramètre Hiérarchiser les performances de l'application.
- Lorsque l'utilisateur clique sur le bouton Désactiver l'application, l'application est désactivé jusqu'à ce que l'utilisateur lance l'application ou l'active sur le .
- Pour les applications désactivables, le bouton Désactiver l'application est
remplacé par le bouton Désinstaller l'application. Lorsque l'utilisateur clique sur le
le bouton Désinstaller l'application, la page "Paramètres" de l'application s'ouvre ;
à partir duquel l'utilisateur peut désinstaller l'application.
Recommandation pour l'implémentation du lanceur d'applications
Lorsque des applications sont désactivées en raison d'une utilisation excessive des ressources, elles disparaissent du
l'application de lancement par défaut, car CarService met à jour activé en tant que
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
Les OEM doivent mettre à jour l'implémentation du
lanceur intégré pour afficher ces applis comme inhabituelle,
afin que les utilisateurs puissent
les utiliser si nécessaire. Consultez les recommandations suivantes en fonction de la version de compilation.
Version 2 d'Android SC
- L'implémentation du lanceur d'applications doit utiliser la
MATCH_DISABLED_UNTIL_USED_COMPONENTSlors de la récupération de la liste des packages à afficher dans le lanceur. - Lorsque l'utilisateur clique sur une application qui se trouve dans
État
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, le lanceur d'applications l'application doit l'activer en définissant l'état d'activation comme suit: