Watchdog surveille l'utilisation de la mémoire flash en suivant la quantité totale d'écritures d'E/S sur le disque effectuées par toutes les applications et tous les services à l'aide des statistiques d'E/S sur le disque par UID exposées par le noyau à l'emplacement "/proc/uid_io/stats". Lorsqu'une application ou un service dépasse le seuil d'utilisation excessive des E/S sur le disque, Watchdog prend des mesures sur l'application ou le service. Les seuils de surutilisation des E/S de disque et l'action à effectuer en cas de surutilisation sont prédéfinis dans la configuration de la surutilisation des E/S de disque.
Seuils de surutilisation
- Les seuils de surutilisation des E/S sur le disque sont appliqués quotidiennement, c'est-à-dire que toutes les écritures effectuées par une application ou un service sont agrégées depuis le début de la journée UTC actuelle et comparées aux seuils définis dans les configurations de surutilisation.
- Lorsqu'un véhicule est démarré plusieurs fois un jour donné, le module Watchdog stocke les statistiques d'utilisation des E/S de disque dans la mémoire flash et les agrège depuis le début du jour calendaire UTC en cours.
Actions en cas de surutilisation
Lorsqu'une application dépasse à plusieurs reprises les seuils d'utilisation excessive des E/S de disque définis, Watchdog effectue les actions définies dans la configuration d'utilisation excessive.
- Tous les services et applications des fournisseurs sont considérés comme essentiels à la stabilité globale du système. Ils ne sont donc pas arrêtés en cas de surutilisation des E/S du disque. Toutefois, la configuration d'utilisation excessive peut définir une liste d'applications et de services de fournisseurs pouvant être arrêtés sans risque.
- Toutes les applications tierces peuvent être arrêtées sans risque.
Lorsqu'une application ou un service peut être arrêté, Watchdog la désactive avec l'état du composant de l'application
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
.
Surutilisation de la configuration
La configuration de surutilisation contient les seuils et les actions de surutilisation des E/S du disque. Les configurations par défaut d'utilisation abusive sont définies dans les images du système et du fournisseur, et fournies avec la compilation. Les fournisseurs peuvent éventuellement inclure la configuration du fournisseur dans l'image du fournisseur. Lorsque la configuration du fournisseur n'est pas fournie, la configuration système est également utilisée pour les applications et services du fournisseur.
Watchdog expose les API système via CarWatchdogManager, ce qui permet aux applications ou aux services du fournisseur de mettre à jour la configuration du fournisseur à tout moment.
Utilisation excessive de la définition de la configuration
La configuration d'utilisation excessive est divisée par type de composant, par exemple, système, fournisseur et tiers. Les OEM ne doivent mettre à jour que la configuration du composant du fournisseur.
Configuration du fournisseur
La configuration du fournisseur définit les seuils de surutilisation des E/S du disque et les actions pour l'ensemble des applications et services des fournisseurs, ainsi que des applications de cartographie et multimédias. La configuration contient les champs de configuration ci-dessous.
- Préfixes de package du fournisseur Tous les packages installés dans la partition de 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 en ajoutant les préfixes de package à la configuration des préfixes de package de 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 qu'ils peuvent arrêter en toute sécurité en ajoutant les noms complets des packages à la configuration des packages pouvant être arrêtés en toute sécurité.
- Mappages de catégories d'applications. Les fournisseurs peuvent mapper n'importe quel package (y compris les packages tiers) sur l'une des deux catégories d'applications compatibles : les applications Maps et multimédias. Ce mappage permet de fournir aux applications cartographiques et multimédias des seuils d'utilisation excessive des E/S disque plus élevés, car ces applications ont tendance à télécharger et à écrire plus de données sur le disque que les autres types d'applications.
- Seuils au niveau des composants. Définit des seuils génériques pour tous les packages du fournisseur (c'est-à-dire que les packages non couverts par les seuils spécifiques au package ou les seuils spécifiques à la catégorie d'applications obtiennent ces seuils). Les fournisseurs doivent définir des seuils non nuls au niveau des composants lorsqu'ils définissent la configuration d'utilisation excessive des E/S de disque.
- Seuils spécifiques au package Les fournisseurs peuvent définir des seuils spéciaux pour des packages de fournisseurs spécifiques. Les mappages doivent contenir les noms de package complets. Les seuils définis dans cette configuration prévalent sur les seuils définis dans d'autres configurations pour un package donné.
- Seuils spécifiques à la catégorie d'application Les fournisseurs peuvent spécifier des seuils spéciaux pour des catégories d'applications spécifiques. Les catégories d'applications doivent correspondre à l'une des catégories compatibles : applications Maps et multimédias. Les seuils définis dans cette configuration sont mappés à des packages spécifiques à l'aide des mappages de catégories d'applications.
- Seuils à l'échelle du système. Les fournisseurs ne doivent pas spécifier cette configuration.
Les configurations des préfixes de package du fournisseur, des packages pouvant être arrêtés, des seuils au niveau des composants et des seuils spécifiques au package ne peuvent être mises à jour que par la configuration du fournisseur pour les applications et services du fournisseur. La configuration des seuils spécifiques à la catégorie d'application ne peut être modifiée que par la configuration du fournisseur pour toutes les applications cartographiques et multimédias.
Les seuils d'utilisation abusive contiennent la quantité d'octets autorisés à être écrite 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 d'é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. Par conséquent, chacun d'eux nécessite un seuil plus élevé que les applications et services exécutés dans d'autres modes.
Configurations système et tierces
Les OEM ne doivent pas mettre à jour le système et les configurations 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 les mappages de catégories d'applications. Par conséquent, ce champ de configuration est partagé entre les configurations du système et du fournisseur.
- La configuration tierce définit des seuils pour toutes les applications tierces. Toutes les applications qui ne sont pas préinstallées sur le système sont des applications tierces.
- Toutes les applications tierces reçoivent les mêmes seuils (par exemple, aucune application tierce ne reçoit de seuils spéciaux), à l'exception des applications cartographiques et multimédias, dont les seuils sont définis par la configuration du fournisseur.
- Les seuils d'utilisation excessive des E/S de disque ci-dessous sont les seuils par défaut pour les applications tierces. Ces seuils sont fournis avec l'image système.
- 3 Go d'é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 de seuils de base. Ces seuils sont mis à jour à mesure que l'on apprend sur l'utilisation des E/S disque.
Utilisation excessive du format XML de configuration
La configuration par défaut du fournisseur peut être placée (c'est facultatif) à l'emplacement /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml dans l'image de compilation. Lorsque cette configuration n'est pas spécifiée, la configuration définie par le système s'applique également aux applications et services du fournisseur.
Le fichier XML ne doit contenir qu'une seule balise pour chaque champ de configuration. La configuration d'une utilisation excessive des E/S doit être définie dans le fichier XML. Toutes les valeurs de seuil doivent être spécifiées dans l'unité MiB.
Voici 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 d'utilisation excessive via les API système CarWatchdogManager
La configuration XML ci-dessus ne peut être fournie que dans l'image de compilation. Si un OEM choisit de mettre à jour la configuration sur l'appareil après la publication d'une compilation, il peut utiliser les API suivantes pour la modifier.
- Accordez l'autorisation
Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIGà l'appelant. - Vous devez utiliser les configurations existantes pour mettre à jour et définir les nouvelles configurations. Utilisez l'API
CarWatchdogManager.getResourceOveruseConfigurationspour obtenir les configurations existantes. Si des configurations existantes ne sont pas utilisées, toutes les configurations (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 les nouvelles configurations. Ne mettez pas à jour les configurations du système et des composants tiers.
- Utilisez 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 d'utilisation excessive 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 utilisation excessive des ressources
Les applications du fournisseur et les applications tierces peuvent écouter les notifications de surutilisation des ressources spécifiques à l'application de Watchdog ou interroger CarWatchdogManager pour obtenir les statistiques de surutilisation des ressources spécifiques à l'application au cours des 30 derniers jours.
Écouter les notifications d'utilisation excessive des ressources
Les applications peuvent implémenter un écouteur de surutilisation des ressources et enregistrer l'écouteur avec CarWatchdogManager pour recevoir des notifications spécifiques à l'application lorsqu'elles dépassent 80% ou 100% des seuils de surutilisation des E/S du disque. Les applications peuvent utiliser ces notifications pour:
- Consignez les statistiques de surutilisation des E/S du disque pour l'analyse hors connexion. Les développeurs d'applications peuvent utiliser cette journalisation pour déboguer le problème d'utilisation excessive des E/S de disque.
- Réduisez les écritures d'E/S disque jusqu'à ce que les compteurs d'utilisation excessive soient réinitialisés.
Client Java
- Implémenter un é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 de l'écouteur en appelant
CarWatchdogManager.addResourceOveruseListeneretprivate 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); }. - Désinscrivez l'instance de l'écouteur lorsque l'application a terminé d'écouter :
private void removeResourceOveruseListener() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE); mCarWatchdogManager.removeResourceOveruseListener( mListenerImpl); }
Client natif
- Incluez
carwatchdog_aidl_interface-ndk_platformdans la 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, } - Ajoutez une stratégie SELinux pour autoriser le domaine de service du fournisseur à utiliser le liaison (macro
binder_user) et ajoutez le domaine de service du fournisseur au domaine clientcarwatchdog(carwatchdog_client_domain macro). Consultez le code ci-dessous poursample_client.teetfile_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
- Implémentez l'écouteur d'utilisation excessive des ressources en héritant de
BnResourceOveruseListener. ForcerBnResourceOveruseListener::onOverusepour gérer les notifications d'utilisation excessive des ressources.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émarrez un pool de threads de liaison et enregistrez l'écouteur d'utilisation excessive des ressources auprès du serveur de surveillance. Le serveur de surveillance est enregistré sous le nom de service
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); }
Interrogez les statistiques sur la surutilisation des ressources
Les applications peuvent interroger CarWatchdogManager pour obtenir les statistiques ATS sur l'utilisation excessive des E/S spécifiques à l'application pour les 30 derniers jours.
Client Java
Utilisez CarWatchdogManager.getResourceOveruseStats pour obtenir les statistiques de surutilisation des ressources. Transmettez l'option 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()
}
Client natif
Utilisez CarWatchdogServer.getResourceOveruseStats pour obtenir les statistiques de surutilisation des ressources. Transmettez l'énumération ResourceType.IO pour extraire les statistiques d'utilisation excessive des E/S de disque.
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.
Paramètre Prioriser les performances de l'application
La page Settings (Paramètres) de l'application contient des paramètres pourPrioritize app performance (voir l'image ci-dessous), qui permettent aux utilisateurs de donner la priorité aux performances d'une application par rapport au système et aux performances matérielles à long terme. Ce paramètre n'est disponible que pour les applications pouvant être arrêtées en cas d'utilisation excessive des ressources. Dans le cas contraire, ce paramètre est désactivé. Lorsque ce paramètre est désactivé (paramètre par défaut) pour une application, celle-ci peut être arrêtée en cas d'utilisation excessive des ressources.
Sinon, l'application n'est pas arrêtée en cas d'utilisation excessive des ressources.
Lorsque l'utilisateur active ce paramètre, la boîte de dialogue de confirmation suivante décrit les conséquences de cette action:
Après 90 jours, ce paramètre est automatiquement rétabli par défaut. La limite de jours peut être modifiée avec une application de superposition RRO à l'aide de watchdogUserPackageSettingsResetDays, jusqu'à 180 jours maximum. Pour en savoir plus, consultez la section Modifier la valeur des ressources d'une application au moment de l'exécution. 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 des applis ayant un impact sur les performances
L'application Paramètres contient une section Applications affectant les performances (voir figure 1). Lorsque vous appuyez sur cette option, une liste d'applications qui ont été limitées en raison d'une utilisation excessive de la mémoire flash et qui ont un impact négatif sur les performances du système s'affiche. Cela respecte l'exigence 3.5.1 du CRDD [C-1-1].
Figure 1 : Applications ayant un impact sur les performances.
Les applications arrêtées en raison d'une utilisation excessive des ressources sont listées ici (voir figure 2). Les applications listées peuvent être hiérarchisées. Pour en savoir plus, consultez la section Prioriser le paramètre de performances de l'application.
Figure 2. Liste des applications arrêtées en raison d'une surutilisation des ressources.
Notification à l'utilisateur
Lorsqu'une application ou un service utilise de manière répétée les E/S de disque (par exemple, écrit des données sur le disque au-delà des seuils définis) pendant une certaine période et qu'il peut être arrêté en cas d'utilisation excessive des ressources, l'utilisateur est averti une fois que le véhicule est entré dans l'état "permettre la distraction du conducteur".
La première notification utilisateur (pendant un trajet) est publiée en tant que notification prioritaire, et les autres notifications sont publiées dans le centre de notifications.
Par exemple, lorsqu'une application utilise de manière répétée l'E/S de disque, l'utilisateur reçoit la notification suivante:
- Lorsque l'utilisateur clique sur le bouton Prioriser l'application, la page des paramètres de l'application s'ouvre, où l'utilisateur peut activer ou désactiver le paramètre Prioriser les performances de l'application.
- Lorsque l'utilisateur clique sur le bouton Désactiver l'application, l'application est désactivée jusqu'à ce que l'utilisateur la lance ou l'active sur la page des paramètres de l'application.
- Pour les applications pouvant être désinstallées, le bouton Désactiver l'application est remplacé par le bouton Désinstaller l'application. Lorsque l'utilisateur clique sur le bouton Désinstaller l'application, la page des paramètres de l'application s'ouvre, depuis laquelle il peut la désinstaller.
Recommandations concernant l'implémentation du lanceur
Lorsque des applications sont désactivées en raison d'un suremploi des ressources, elles disparaissent de l'application de lanceur par défaut, car CarService met à jour l'état d'activation des applications sur PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED.
Les OEM doivent mettre à jour l'implémentation du lanceur intégré pour afficher ces applications comme inhabituelles afin que les utilisateurs puissent les utiliser si nécessaire. Consultez les recommandations suivantes en fonction de la version du build.
Version 2 de la solution de certification Android
- L'implémentation du lanceur doit utiliser l'indicateur
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 est dans l'état
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, l'application du lanceur doit l'activer en définissant l'état activé sur: