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 à l'encontre de l'application ou du service. Les seuils de surutilisation des E/S de disque et l'action à entreprendre en cas de surutilisation sont prédéfinis dans la configuration de surutilisation des E/S de disque.
Seuils de sollicitation excessive
- Les seuils d'utilisation excessive des E/S de disque sont appliqués quotidiennement. Autrement dit, toutes les écritures effectuées par une application ou un service sont agrégées depuis le début du jour calendaire UTC en cours et comparées aux seuils définis dans les configurations d'utilisation excessive.
- Lorsqu'un véhicule est démarré plusieurs fois au cours d'une même journée, le module Watchdog stocke les statistiques d'utilisation des E/S du disque dans la mémoire flash et les agrège depuis le début du jour calendaire UTC en cours.
Actions en cas de sollicitation excessive
Lorsqu'une application dépasse à plusieurs reprises les seuils de surutilisation des E/S de disque définis, Watchdog effectue les actions définies dans la configuration de surutilisation.
- Toutes les applications et tous les services du fournisseur 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 de disque. Toutefois, la configuration de surutilisation 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é sans risque, Watchdog le désactive avec l'état du composant d'application
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
.
Configuration de l'utilisation excessive
La configuration de surutilisation contient les seuils et les actions de surutilisation des E/S de disque. Les configurations par défaut pour l'utilisation excessive sont définies dans les images système et fournisseur, et sont 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 du 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 services des fournisseurs de mettre à jour la configuration du fournisseur à tout moment.
Définition de la configuration de l'utilisation excessive
La configuration de l'utilisation excessive est divisée par type de composant (système, fournisseur et tiers, par exemple). Les OEM ne doivent mettre à jour que la configuration du composant fournisseur.
Configuration du fournisseur
La configuration du fournisseur définit les seuils et les actions en cas de surutilisation des E/S de disque pour toutes les applications et tous les services du fournisseur, ainsi que pour toutes les applications de cartes 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 du fournisseur sont considérés comme des packages du fournisseur. En plus de ces packages, les fournisseurs peuvent classer les packages préinstallés comme packages de fournisseur en ajoutant les préfixes de package à la configuration vendor package prefixes. Cette configuration n'accepte pas les expressions régulières.
- Packages pouvant être arrêtés sans risque. Les fournisseurs peuvent spécifier les packages de fournisseur qui peuvent être arrêtés sans risque en ajoutant les noms de package complets à la configuration safe-to-terminate packages.
- Mappages des catégories d'applications Les fournisseurs peuvent mapper n'importe quel package (y compris les packages tiers) à l'une des deux catégories d'applications compatibles : applications de cartographie et applications multimédias. Ce mappage est effectué pour fournir aux applications de cartographie et multimédias des seuils de surutilisation 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 aux packages ou les seuils spécifiques aux catégories d'applications obtiennent ces seuils). Les fournisseurs doivent définir des seuils non nuls au niveau des composants lorsqu'ils définissent la configuration de l'utilisation excessive des E/S de disque.
- Seuils spécifiques aux packages : 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 ont la priorité sur ceux définis dans d'autres configurations pour un package donné.
- Seuils spécifiques aux catégories d'applications. Les fournisseurs peuvent spécifier des seuils spéciaux pour des catégories d'applications spécifiques. Les catégories d'applications doivent être l'une des catégories compatibles : applications Cartes et applications 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 Préfixes de package du fournisseur, Packages pouvant être arrêtés sans risque, Seuils au niveau des composants et Seuils spécifiques aux packages 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 mise à jour que par la configuration du fournisseur pour toutes les applications de cartes et multimédias.
Les seuils de surutilisation indiquent le nombre d'octets pouvant être écrits pendant :
- Mode Premier plan ou mode Arrière-plan d'une application ou d'un service
- Mode garage du système
Cette classification permet aux applications et services de premier plan destinés aux utilisateurs d'écrire plus de données que les applications et services en arrière-plan. En mode Garage, les applications et services ont tendance à télécharger des mises à jour. Ils ont donc besoin d'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 les configurations système et tierces.
- La configuration du système définit les seuils de surutilisation des E/S et les actions pour les applications et services système.
- Cette configuration peut également mettre à jour les mappages des catégories d'applications. Par conséquent, ce champ de configuration est partagé entre les configurations système et fournisseur.
- La configuration tierce définit des seuils pour toutes les applications tierces. Toutes les applications qui ne sont pas préinstallées dans 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 de cartographie et multimédias, dont les seuils sont définis par la configuration du fournisseur.
- Les seuils de surutilisation 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 Gio en écriture en mode premier plan de l'application.
- 2 Gio d'écriture en mode arrière-plan de l'application.
- Écriture de 4 Gio en mode garage système.
- Il s'agit de seuils de base. Ces seuils sont mis à jour à mesure que nous en apprenons davantage sur l'utilisation des E/S disque.
Format XML de configuration de l'utilisation excessive
La configuration du fournisseur par défaut peut être placée (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'un seul tag pour chaque champ de configuration. La configuration de l'utilisation excessive des E/S doit être définie dans le fichier XML. Toutes les valeurs de seuil doivent être spécifiées en MiB.
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 l'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 version, il peut utiliser les API suivantes pour modifier la configuration sur l'appareil.
- 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 les 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 de disque, utilisez l'indicateur
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 tierces et de fournisseurs peuvent écouter les notifications de surutilisation des ressources spécifiques aux applications provenant de Watchdog ou interroger CarWatchdogManager pour obtenir les statistiques de surutilisation des ressources spécifiques aux applications pour les 30 derniers jours maximum.
Écouter les notifications de surutilisation des ressources
Les applications peuvent implémenter un écouteur de surutilisation des ressources et l'enregistrer avec CarWatchdogManager pour recevoir des notifications spécifiques à l'application lorsqu'elles dépassent 80 % ou 100 % de leurs seuils de surutilisation des E/S de disque. Les applications peuvent utiliser ces notifications pour :
- Enregistrez les statistiques de surutilisation des E/S de disque pour une analyse hors connexion. Les développeurs d'applications peuvent utiliser cette journalisation pour déboguer le problème de surutilisation 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é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.addResourceOveruseListener.private 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ésenregistrez 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); }
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 règle SELinux pour autoriser le domaine de service du fournisseur à utiliser le binder (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. RemplacezBnResourceOveruseListener::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 Binder et enregistrez l'écouteur de surutilisation des ressources auprès du serveur Watchdog. Le serveur Watchdog 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); }
Interroger les statistiques de surutilisation des ressources
Les applications peuvent interroger CarWatchdogManager pour obtenir les statistiques ATS sur la surutilisation des E/S spécifiques à l'application pour les 30 derniers jours.
Client Java
Utilisez CarWatchdogManager.getResourceOveruseStats pour obtenir les statistiques sur l'utilisation excessive des ressources. Transmettez l'indicateur CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO pour obtenir les statistiques sur la surutilisation des E/S de 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 sur l'utilisation excessive des ressources. Transmettez l'énumération ResourceType.IO pour récupérer les statistiques sur la surutilisation des E/S du 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 en cas de surutilisation des ressources
Les sections suivantes décrivent l'expérience utilisateur en cas de surutilisation des ressources.
Paramètre "Prioriser les performances de l'appli"
La page Paramètres de l'application contient des paramètres pourPrioritize app performance (voir l'image ci-dessous), qui permettent aux utilisateurs de privilégier les performances d'une application par rapport à celles du système et aux performances matérielles à long terme. Ce paramètre n'est disponible que pour les applications dont l'arrêt est sans danger en cas de surutilisation 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 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 les implications de l'activation du paramètre :
Au bout de 90 jours, ce paramètre est automatiquement rétabli sur la valeur par défaut. La limite de jours peut être modifiée avec une application de superposition RRO à l'aide de watchdogUserPackageSettingsResetDays, jusqu'à un maximum de 180 jours. Pour en savoir plus, consultez Modifier la valeur des ressources d'une application au moment de l'exécution. La balise de superposition d'exemple suivante peut être incluse 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 "Applis ayant un impact sur les performances"
L'application Paramètres contient une section Applications ayant un impact sur les performances (voir figure 1). Lorsque vous appuyez dessus, une liste des applications qui ont été restreintes 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 [C-1-1]de la section 3.5.1 du CDD.
Figure 1 : Applis ayant un impact sur les performances.
Les applications arrêtées en raison d'une surutilisation des ressources sont listées ici (voir figure 2). Vous pouvez définir une priorité pour les applications listées. Pour en savoir plus, consultez Paramètre "Prioriser les performances de l'appli".
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 et excessive les E/S de disque (par exemple, en écrivant des données sur le disque au-delà des seuils définis) au cours d'une période donnée et qu'il peut être arrêté en cas de surutilisation des ressources, l'utilisateur est averti une fois que le véhicule passe en mode "Autoriser la distraction du conducteur".
La première notification utilisateur (pendant un trajet) est publiée en tant que notification d'information, et les autres sont publiées dans le centre de notifications.
Par exemple, lorsqu'une application utilise de manière répétée trop d'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. L'utilisateur peut alors 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 désinstallables, 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, à partir de laquelle l'utilisateur peut désinstaller l'application.
Recommandation pour l'implémentation du lanceur
Lorsque des applications sont désactivées en raison d'une utilisation excessive des ressources, elles disparaissent de l'application de lanceur d'applications par défaut, car CarService met à jour leur état d'activation sur PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED.
Les OEM doivent mettre à jour l'implémentation du lanceur d'applications intégré pour afficher ces applications comme d'habitude, 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 doit utiliser l'indicateur
MATCH_DISABLED_UNTIL_USED_COMPONENTSlors de la récupération de la liste des packages à afficher sur le lanceur. - Lorsque l'utilisateur clique sur une application dont l'état est
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, l'application de lanceur d'applications doit activer l'application en définissant l'état activé comme suit :