Watchdog surveille l'utilisation de la mémoire flash en suivant la quantité totale d'écritures d'E/S disque effectuées par toutes les applications et services à l'aide des statistiques d'E/S disque par UID exposées par le noyau à l'emplacement « /proc/uid_io/stats ». Lorsqu'une application ou un service dépasse le seuil de surutilisation des E/S du disque, Watchdog prend des mesures sur l'application ou le service. Les seuils de surutilisation des E/S de disque et les mesures à prendre en cas de surutilisation sont prédéfinis dans la configuration de surutilisation des E/S de disque.
Seuils de surutilisation
- Les seuils de surutilisation des E/S de disque sont appliqués quotidiennement, c'est-à-dire que toutes les écritures effectuées par une application/un service sont regroupées depuis le début du jour calendaire UTC en cours et vérifiées par rapport aux seuils définis dans les configurations de surutilisation.
- Lorsqu'un véhicule démarre plusieurs fois au cours d'une journée donnée, le module Watchdog stocke les statistiques d'utilisation des E/S disque sur la mémoire flash et les regroupe depuis le début du jour calendaire UTC en cours.
Actions de surutilisation
Lorsqu'une application dépasse à plusieurs reprises les seuils de surutilisation des E/S de disque définis, Watchdog prend les actions définies dans la configuration de surutilisation.
- Toutes les applications et services des fournisseurs sont considérés comme essentiels à la stabilité globale du système. Ils ne sont donc pas interrompus en cas de surutilisation des E/S disque. Cependant, la configuration de surutilisation peut définir une liste d’applications et de services du fournisseur pouvant être terminés en toute sécurité.
- Toutes les applications tierces peuvent être fermées en toute sécurité.
Lorsqu'une application ou un service peut être terminé en toute sécurité, Watchdog désactive l'application ou le service avec l'état du composant d'application PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED .
Configuration de surutilisation
La configuration de surutilisation contient les seuils et les actions de surutilisation des E/S de disque. Les configurations de surutilisation par défaut sont définies dans les images du système et du fournisseur et livrées avec la version. 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 , qui permet aux applications ou services des fournisseurs de mettre à jour la configuration du fournisseur à tout moment.
Définition de la configuration de surutilisation
La configuration de surutilisation est divisée par type de composant, par exemple système, fournisseur et tiers. Les OEM doivent mettre à jour uniquement 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 de disque pour toutes les applications et services du fournisseur, ainsi que pour toutes les applications cartographiques et multimédias. La configuration contient les champs de configuration ci-dessous.
-
Vendor package prefixes. Tous les packages installés dans la partition fournisseur sont considérés comme des packages fournisseur. En plus de ces packages, les fournisseurs peuvent classer les packages préinstallés en tant que packages de fournisseur en ajoutant les préfixes de package à la configurationvendor package prefixes. Cette configuration n'accepte pas les expressions régulières. -
Safe-to-terminate packages. Les fournisseurs peuvent spécifier quels packages de fournisseurs peuvent être résiliés en toute sécurité en ajoutant les noms complets des packages à la configurationsafe-to-terminate packages. -
Application category mappings. Les fournisseurs peuvent mapper n'importe quel package (y compris les packages tiers) à l'une des deux catégories d'applications prises en charge : les applications cartographiques et multimédia. Ce mappage est effectué pour fournir des cartes et des applications multimédias avec des seuils de surutilisation d'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. -
Component level thresholds. Définit des seuils génériques pour tous les packages de fournisseurs (c'est-à-dire que les packages non couverts parPackage specific thresholdsouApplication category specific thresholdsobtiennent ces seuils). Les fournisseurs doivent définir des seuils non nuls au niveau des composants lors de la définition de la configuration de surutilisation des E/S disque. -
Package specific thresholds. Les fournisseurs peuvent définir des seuils spéciaux pour des packages de fournisseurs spécifiques. Les mappages doivent contenir les noms complets des packages. Les seuils définis dans cette configuration sont prioritaires sur les seuils définis dans d'autres configurations pour un package donné. -
Application category specific thresholds. Les fournisseurs peuvent spécifier des seuils spéciaux pour des catégories d'applications spécifiques. Les catégories d'applications doivent appartenir à l'une des catégories prises en charge : applications Cartes et Médias. Les seuils définis dans cette configuration sont mappés à des packages spécifiques à l'aideApplication category mappings. -
System-wide thresholds. Les fournisseurs ne doivent pas spécifier cette configuration.
Vendor package prefixes , Safe-to-terminate packages , Component level thresholds et les configurations Package specific thresholds peuvent être mis à jour uniquement par la configuration du fournisseur pour les applications et services du fournisseur. La configuration Application category specific thresholds peut être mise à jour uniquement par la configuration du fournisseur pour toutes les cartes et applications multimédias.
Les seuils de surutilisation contiennent la quantité d'octets autorisés à être écrits pendant
- Un mode premier plan d'application/service par rapport au mode arrière-plan
- et le mode garage du système.
Cette classification permet aux applications/services de premier plan destinés aux utilisateurs d’écrire plus de données que les applications/services d’arrière-plan. En mode Garage, les applications et les services ont tendance à télécharger des mises à jour, chacun nécessite donc 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 du système et des tiers.
- La configuration du système définit les seuils et les actions de surutilisation des E/S pour les applications et services système.
- Cette configuration peut également mettre à jour les
Application category mappings. Ainsi, ce champ de configuration est partagé entre les configurations du système et du fournisseur.
- Cette configuration peut également mettre à jour les
- 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 de surutilisation des E/S de disque ci-dessous sont les seuils par défaut pour les applications tierces. Ces seuils sont livrés avec l'image système.
- 3 Gio écrivent 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 système.
- Ce sont des seuils de base. Ces seuils sont mis à jour à mesure que nous comprenons mieux l'utilisation des E/S disque.
Utilisation excessive du format XML de configuration
La configuration du fournisseur par défaut peut être placée (ceci est facultatif ) à l'emplacement /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml dans l'image de construction. Lorsque cette configuration n'est pas spécifiée, la configuration définie par le système est également appliquée aux applications et services du fournisseur.
Le fichier XML ne doit contenir qu'une seule balise pour chaque champ de configuration. La configuration de la surutilisation 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.
Un exemple de configuration XML est fourni ci-dessous :
<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 du système CarWatchdogManager
La configuration XML ci-dessus peut être fournie uniquement dans l'image de construction. 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 apporter des modifications à la configuration sur l'appareil.
- Accordez l'autorisation
Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIGà l'appelant. - Doit 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 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();
}
Les applications surveillent la surutilisation de leurs ressources
Les applications des fournisseurs et des tiers peuvent écouter les notifications de surutilisation des ressources spécifiques à l'application de Watchdog ou interroger CarWatchdogManager pour connaître les statistiques de surutilisation des ressources spécifiques à l'application pour les 30 derniers jours.
Écoutez les notifications de surutilisation des ressources
Les applications peuvent implémenter un écouteur de surutilisation des ressources et enregistrer l'écouteur auprès de CarWatchdogManager pour recevoir des notifications spécifiques à l'application lorsqu'elles dépassent 80 % ou 100 % de leurs seuils de surutilisation d'E/S disque. Les applications peuvent utiliser ces notifications pour :
- Enregistrez les statistiques de surutilisation des E/S du disque pour une analyse hors ligne. Les développeurs d'applications peuvent utiliser cette journalisation pour déboguer le problème de surutilisation des E/S du disque.
- Réduisez les écritures d’E/S sur disque jusqu’à ce que les compteurs de surutilisation soient réinitialisés.
Client Java
- Implémentez l'écouteur en héritant
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'écoute 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); } - Désenregistrez l'instance d'écoute 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 construction.Android.bpcc_binary { name: "sample_native_client", srcs: [ "src/*.cpp" ], shared_libs: [ "carwatchdog_aidl_interface-ndk_platform", "libbinder_ndk", ], vendor: true, } - Ajoutez la politique SELinux pour permettre au domaine de service du fournisseur d'utiliser le classeur (macro
binder_user) et ajoutez le domaine de service du fournisseur au domaine clientcarwatchdog(carwatchdog_client_domain macro). Voir 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 de surutilisation des ressources en héritant
BnResourceOveruseListener. RemplacezBnResourceOveruseListener::onOverusepour gérer les notifications de surutilisation 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 de surutilisation des ressources auprès du serveur de surveillance. 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 connaître les statistiques ATS de surutilisation 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'indicateur 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 récupérer les statistiques de 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
}
}
Surutilisation des ressources UX
Prioriser les paramètres de performances des applications
La page Paramètres de l'application contient les paramètres Prioritize app performance (voir l'image ci-dessous), qui permettent à l'utilisateur de donner la priorité aux performances d'une application par rapport aux performances du système et du matériel à long terme. Ce paramètre est disponible uniquement pour les applications qui peuvent être fermées en toute sécurité en cas de surutilisation des ressources. Sinon, ce paramètre est grisé. Lorsque ce paramètre est désactivé (paramètre par défaut) pour une application, celle-ci peut être fermée en cas de surutilisation des ressources. Sinon, l'application ne se termine pas 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.
Après 90 jours, ce paramètre est automatiquement réinitialisé à sa valeur par défaut. La limite quotidienne 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 . 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>
Notification utilisateur
Lorsqu'une application ou un service utilise de manière répétée les E/S du disque (par exemple, écrit des données sur le disque au-delà des seuils définis) au cours d'une certaine période et peut être interrompu en toute sécurité en cas de surutilisation des ressources, l'utilisateur est averti une fois que le véhicule entre dans la zone d'autorisation du conducteur. -état de distraction.
La première notification utilisateur (lors d'un trajet) est publiée sous forme de notification tête haute et les autres notifications sont publiées sur le centre de notification.
Par exemple, lorsqu'une application abuse de manière répétée des E/S 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 est lancée, 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 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 Paramètres de l'application est lancée, à partir de laquelle l'utilisateur peut désinstaller l'application.
Recommandation pour la mise en œuvre du lanceur
Lorsque les applications sont désactivées en raison d'une surutilisation des ressources, les applications disparaissent de l'application de lancement par défaut car CarService met à jour l'état activé des applications 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 applications comme inhabituelles, afin que les utilisateurs puissent les utiliser si nécessaire. Consultez les recommandations suivantes basées sur la version de build.
Version Android SC V2
- 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 qui se trouve dans l'état
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, l'application de lancement doit activer l'application en définissant l'état activé comme :