Watchdog supervisa el uso de la memoria flash haciendo un seguimiento de la cantidad total de escrituras de E/S de disco realizadas por todas las apps y servicios que usan las estadísticas de E/S de disco por UID que expone el kernel en la ubicación `/proc/uid_io/stats`. Cuando una app o un servicio superan el umbral de uso excesivo de E/S de disco, Watchdog toma medidas en relación con la app o el servicio. Los umbrales de uso excesivo de E/S de disco y la acción que se debe realizar en caso de uso excesivo están predefinidos en la configuración de uso excesivo de E/S de disco.
Umbrales de uso excesivo
- Los umbrales de uso excesivo de E/S de disco se aplican a diario, es decir, todas las escrituras realizadas por una app o un servicio se agregan desde el comienzo del día calendario actual en UTC y se verifican con los umbrales definidos en las configuraciones de uso excesivo.
- Cuando un vehículo se enciende varias veces en un día determinado, el módulo Watchdog almacena las estadísticas de uso de E/S de disco en la memoria flash y las agrega desde el comienzo del día natural actual en UTC.
Acciones de uso excesivo
Cuando una app supera repetidamente los umbrales definidos de uso excesivo de E/S de disco, Watchdog realiza las acciones definidas en la configuración de uso excesivo.
- Todas las apps y los servicios del proveedor se consideran fundamentales para la estabilidad general del sistema, por lo que no se finalizan por un uso excesivo de la E/S del disco. Sin embargo, la configuración de uso excesivo puede definir una lista de apps y servicios de proveedores que se pueden finalizar de forma segura.
- Todas las apps de terceros son seguras para finalizar.
Cuando una app o un servicio son seguros para finalizar, Watchdog los inhabilita con el estado del componente de la app
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
.
Configuración de uso excesivo
La configuración de uso excesivo contiene los umbrales y las acciones de uso excesivo de E/S de disco. Las configuraciones predeterminadas de uso excesivo se definen en las imágenes del sistema y del proveedor, y se incluyen en la compilación. De manera opcional, los proveedores pueden incluir la configuración del proveedor en la imagen del proveedor. Cuando no se proporciona la configuración del proveedor, también se usa la configuración del sistema para las apps y los servicios del proveedor.
Watchdog expone las APIs del sistema a través de CarWatchdogManager, lo que permite que las apps o los servicios de los proveedores actualicen la configuración del proveedor en cualquier momento.
Definición de configuración de uso excesivo
La configuración de uso excesivo se divide por tipo de componente, por ejemplo, sistema, proveedor y terceros. Los OEM solo deben actualizar la configuración del componente del proveedor.
Configuración del proveedor
La configuración del proveedor define los umbrales y las acciones de uso excesivo de E/S del disco para todas las apps y servicios del proveedor, y todas las apps de mapas y multimedia. La configuración contiene los siguientes campos de configuración.
- Prefijos de paquetes de proveedores Todos los paquetes instalados en la partición del proveedor se consideran paquetes del proveedor. Además de estos paquetes, los proveedores pueden clasificar los paquetes preinstalados como paquetes de proveedores agregando los prefijos de paquetes a la configuración de prefijos de paquetes de proveedores. Esta configuración no acepta expresiones regulares.
- Paquetes que se pueden detener de forma segura Los proveedores pueden especificar qué paquetes de proveedores se pueden finalizar de forma segura agregando los nombres completos de los paquetes a la configuración de paquetes seguros para finalizar.
- Asignaciones de categorías de aplicaciones Los proveedores pueden asignar cualquier paquete (incluidos los de terceros) a una de las dos categorías de apps admitidas: apps de mapas y apps de medios. Esta asignación se realiza para proporcionar a las apps de mapas y multimedia umbrales más altos de uso excesivo de E/S de disco, ya que estas apps tienden a descargar y escribir más datos en el disco que otros tipos de apps.
- Umbrales a nivel del componente. Define umbrales genéricos para todos los paquetes del proveedor (es decir, los paquetes no cubiertos por los umbrales específicos del paquete o los umbrales específicos de la categoría de la aplicación obtienen estos umbrales). Los proveedores deben definir umbrales a nivel del componente que no sean cero cuando definan la configuración de uso excesivo de E/S de disco.
- Umbrales específicos del paquete. Los proveedores pueden definir umbrales especiales para paquetes específicos. Las asignaciones deben contener los nombres de paquete completos. Los umbrales definidos en esta configuración tienen prioridad sobre los umbrales definidos en otras configuraciones para un paquete determinado.
- Umbrales específicos de la categoría de la aplicación. Los proveedores pueden especificar umbrales especiales para categorías de apps específicas. Las categorías de la app deben ser una de las categorías admitidas: apps de Maps y de contenido multimedia. Los umbrales definidos en esta configuración se asignan a paquetes específicos con Application category mappings.
- Umbrales en todo el sistema: Los proveedores no deben especificar esta configuración.
Los parámetros de configuración de prefijos de paquetes del proveedor, paquetes seguros para finalizar, umbrales a nivel del componente y umbrales específicos del paquete solo se pueden actualizar a través de la configuración del proveedor para las apps y los servicios del proveedor. La configuración de los umbrales específicos de la categoría de la aplicación solo se puede actualizar a través de la configuración del proveedor para todas las apps de mapas y multimedia.
Los umbrales de uso excesivo contienen la cantidad de bytes que se pueden escribir durante los siguientes períodos:
- Modo en primer plano o en segundo plano de una app o un servicio
- Modo de cochera del sistema
Esta clasificación permite que las apps y los servicios en primer plano orientados al usuario escriban más datos que las apps y los servicios en segundo plano. En el modo de garaje, las apps y los servicios suelen descargar actualizaciones, por lo que cada uno necesita un umbral más alto que las apps y los servicios que se ejecutan en otros modos.
Configuraciones del sistema y de terceros
Los OEM no deben actualizar la configuración del sistema ni de terceros.
- La configuración del sistema define los umbrales y las acciones de uso excesivo de E/S para las apps y los servicios del sistema.
- Esta configuración también puede actualizar las asignaciones de categorías de aplicaciones. Por lo tanto, este campo de configuración se comparte entre las configuraciones del sistema y del proveedor.
- La configuración de terceros define los umbrales para todas las apps de terceros. Todas las apps que no están preinstaladas en el sistema son apps de terceros.
- Todas las apps de terceros reciben los mismos umbrales (por ejemplo, ninguna app de terceros recibe umbrales especiales), excepto las apps de mapas y multimedia, cuyos umbrales se definen según la configuración del proveedor.
- Los siguientes umbrales de uso excesivo de E/S de disco son los predeterminados para las apps de terceros. Estos umbrales se incluyen en la imagen del sistema.
- 3 GiB de escritura en el modo de primer plano de la app
- 2 GiB de escritura en el modo en segundo plano de la app
- Escritura de 4 GiB en el modo de garaje del sistema
- Estos son los umbrales básicos. Estos umbrales se actualizan a medida que se aprende más sobre el uso de E/S de disco.
Formato XML de configuración de uso excesivo
La configuración predeterminada del proveedor se puede colocar (esto es opcional) en la ubicación /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml de la imagen de compilación. Cuando no se especifica esta configuración, también se aplica la configuración definida por el sistema para las apps y los servicios del proveedor.
El archivo XML debe contener solo una etiqueta para cada campo de configuración. La configuración de uso excesivo de E/S se debe definir en el archivo XML. Todos los valores de umbral deben especificarse en la unidad MiB.
A continuación, se proporciona un ejemplo de configuración de 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>
Actualiza la configuración de uso excesivo a través de las APIs del sistema de CarWatchdogManager
La configuración de XML anterior solo se puede proporcionar en la imagen de compilación. Si un OEM decide actualizar la configuración del dispositivo después de que se lanza una compilación, puede usar las siguientes APIs para realizar cambios en la configuración del dispositivo.
- Otorga el permiso
Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIGal llamador. - Se deben usar los parámetros de configuración existentes para actualizar y establecer los parámetros de configuración nuevos. Usa la API de
CarWatchdogManager.getResourceOveruseConfigurationspara obtener los parámetros de configuración existentes. Si no se usan las configuraciones existentes, se reemplazarán todas las configuraciones (incluidas las del sistema y las de terceros), lo que no se recomienda. - Actualiza las configuraciones existentes con los cambios delta y establece las nuevas configuraciones. No actualiza la configuración del sistema ni de los componentes de terceros.
- Usa la API de
CarWatchdogManager.setResourceOveruseConfigurationspara establecer los parámetros de configuración nuevos. - Para obtener y establecer la configuración de uso excesivo de E/S de disco, usa la marca
CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO.
A continuación, se muestra un ejemplo de implementación que actualiza la configuración de uso excesivo de recursos:
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(); }
Apps que supervisan el uso excesivo de recursos
Las apps de proveedores y de terceros pueden escuchar las notificaciones de uso excesivo de recursos específicos de la app de Watchdog o sondear CarWatchdogManager para obtener las estadísticas de uso excesivo de recursos específicos de la app de los últimos 30 días.
Cómo escuchar las notificaciones de uso excesivo de recursos
Las apps pueden implementar un objeto de escucha de uso excesivo de recursos y registrarlo con CarWatchdogManager para recibir notificaciones específicas de la app cuando superen el 80% o el 100% de los umbrales de uso excesivo de E/S de disco. Las apps pueden usar estas notificaciones para lo siguiente:
- Registra las estadísticas de uso excesivo de E/S de disco para el análisis sin conexión. Los desarrolladores de apps pueden usar este registro para depurar el problema de uso excesivo de E/S de disco.
- Reduce las escrituras de E/S del disco hasta que se restablezcan los contadores de uso excesivo.
Cliente de Java
- Implementa el objeto de escucha heredando
CarWatchdogManager.ResourceOveruseListener:class ResourceOveruseListenerImpl implements CarWatchdogManager.ResourceOveruseListener { @Override public void onOveruse( @NonNull ResourceOveruseStats resourceOveruseStats) { // 1. Log/Upload resource overuse metrics. // 2. Reduce writes until the counters reset. IoOveruseStats ioOveruseStats = resourceOveruseStats.getIoOveruseStats(); // Stats period - [ioOveruseStats.getStartTime(), ioOveruseStats.getStartTime() // + ioOveruseStats.getDurationInSeconds()] // Total I/O overuses - ioOveruseStats.getTotalOveruses() // Total bytes written - ioOveruseStats.getTotalBytesWritten() // Remaining write bytes for the current UTC calendar day - // ioOveruseStats.getRemainingWriteBytes() } } }
- Registra la instancia del objeto de escucha llamando a
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); } - Cancela el registro de la instancia del objeto de escucha cuando la app haya terminado de escuchar lo siguiente:
private void removeResourceOveruseListener() { CarWatchdogManager manager = (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE); mCarWatchdogManager.removeResourceOveruseListener( mListenerImpl); }
Cliente nativo
- Incluye
carwatchdog_aidl_interface-ndk_platformen la dependenciashared_libsde la regla de compilación.Android.bpcc_binary { name: "sample_native_client", srcs: [ "src/*.cpp" ], shared_libs: [ "carwatchdog_aidl_interface-ndk_platform", "libbinder_ndk", ], vendor: true, } - Agrega la política de SELinux para permitir que el dominio del servicio del proveedor use Binder (macro
binder_user) y agrega el dominio del servicio del proveedor al dominio del clientecarwatchdog(carwatchdog_client_domain macro). Consulta el siguiente código parasample_client.teyfile_contexts.sample_client.tetype sample_client, domain; type sample_client_exec, exec_type, file_type, vendor_file_type; carwatchdog_client_domain(sample_client) init_daemon_domain(sample_client) binder_use(sample_client)
file_contexts/vendor/bin/sample_native_client u:object_r:sample_client_exec:s0
- Implementa el objeto de escucha de uso excesivo de recursos heredando
BnResourceOveruseListener. AnulaBnResourceOveruseListener::onOverusepara controlar las notificaciones de uso excesivo de recursos.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(); }
- Inicia un grupo de subprocesos de Binder y registra el objeto de escucha de uso excesivo de recursos con el servidor de vigilancia. El servidor de supervisión se registra con el nombre de servicio
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); }
Sondea las estadísticas de uso excesivo de recursos
Las apps pueden sondear CarWatchdogManager para obtener las estadísticas de ATS de uso excesivo de E/S específicas de la app para los últimos 30 días.
Cliente de Java
Usa CarWatchdogManager.getResourceOveruseStats para obtener las estadísticas de uso excesivo de recursos. Pasa la marca CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO para obtener las estadísticas de uso excesivo de E/S del disco.
private void getResourceOveruseStats() {
CarWatchdogManager manager =
(CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
// Returns resource overuse stats with I/O overuse stats for the past
// 7 days. Stats are available for up to the past 30 days.
ResourceOveruseStats resourceOveruseStats =
mCarWatchdogManager.getResourceOveruseStats(
CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO,
CarWatchdogManager.STATS_PERIOD_PAST_7_DAYS);
IoOveruseStats ioOveruseStats = resourceOveruseStats.getIoOveruseStats();
// Stats period - [ioOveruseStats.getStartTime(), ioOveruseStats.getStartTime()
// + ioOveruseStats.getDurationInSeconds()]
// Total I/O overuses - ioOveruseStats.getTotalOveruses()
// Total bytes written - ioOveruseStats.getTotalBytesWritten()
// Remaining write bytes for the UTC calendar day -
// ioOveruseStats.getRemainingWriteBytes()
}Cliente nativo
Usa CarWatchdogServer.getResourceOveruseStats para obtener las estadísticas de uso excesivo de recursos. Pasa la enumeración ResourceType.IO para recuperar las estadísticas de uso excesivo de E/S del disco.
void getResourceOveruseStats() { ndk::SpAIBinder binder(AServiceManager_getService( "android.automotive.watchdog.ICarWatchdog/default")); std::shared_ptr<ICarWatchdog> server = ICarWatchdog::fromBinder(binder); // Returns the stats only for the current UTC calendar day. const std::vector<ResourceOveruseStats> resourceOveruseStats; ndk::ScopedAStatus status = server.getResourceOveruseStats( std::vector<int>{ResourceType.IO}, &resourceOveruseStats); if (!status.isOk()) { // Failed to get the resource overuse stats. return; } for (const auto& stats : resourceOveruseStats) { if (stats.getTag() != ResourceOveruseStats::ioOveruseStats) { continue; } const IoOveruseStats& ioOveruseStats = stats.get(); // Stats period - [ioOveruseStats.startTime, // ioOveruseStats.startTime + ioOveruseStats.durationInSeconds] // Total I/O overuses - ioOveruseStats.totalOveruses // Total bytes written - ioOveruseStats.writtenBytes // Remaining write bytes for the current UTC calendar day - // ioOveruseStats.remainingWriteBytes } }
Experiencia del usuario por uso excesivo de recursos
En las siguientes secciones, se describe la experiencia del usuario cuando se produce un uso excesivo de los recursos.
Parámetro de configuración para priorizar el rendimiento de la app
La página de Configuración de la app contiene parámetros de configuración paraPrioritize app performance (consulta la imagen a continuación), lo que permite a los usuarios priorizar el rendimiento de una app por sobre el sistema y el rendimiento del hardware a largo plazo. Este parámetro de configuración solo está disponible para las apps que se pueden finalizar de forma segura en caso de uso excesivo de recursos. De lo contrario, este parámetro de configuración se inhabilita. Cuando este parámetro de configuración está desactivado (el parámetro de configuración predeterminado) para una app, esta se puede cerrar si se usa en exceso.
De lo contrario, la app no se cerrará por uso excesivo de recursos.
Cuando el usuario activa este parámetro de configuración, el siguiente diálogo de confirmación describe las implicaciones de activar el parámetro de configuración:
Después de 90 días, este parámetro de configuración se restablece automáticamente a la configuración predeterminada. El límite de días se puede modificar con una app de superposición de RRO usando watchdogUserPackageSettingsResetDays, hasta un máximo de 180 días. Para obtener más información, consulta Cómo cambiar el valor de los recursos de una app en el tiempo de ejecución. La siguiente etiqueta de superposición de ejemplo se puede incluir en AndroidManifest.xml:
<overlay android:priority="<insert-value>" android:targetPackage="com.android.car.updatable" android:targetName="CarServiceCustomization" android:resourcesMap="@xml/overlays" />
En res/values/config.xml:
<resources> <integer name="watchdogUserPackageSettingsResetDays">value</integer> </resources>
En res/xml/overlays.xml:
<overlay> <item target="integer/watchdogUserPackageSettingsResetDays" value="@integer/watchdogUserPackageSettingsResetDays" /> </overlay>
Parámetro de configuración de las apps que afectan el rendimiento
La app de Configuración contiene una sección de Apps que afectan el rendimiento (ver la figura 1). Cuando se presiona, se muestra una lista de las apps que se restringieron debido al uso excesivo de la memoria flash y que afectan negativamente el rendimiento del sistema. Esto cumple con el requisito 3.5.1 del CDD [C-1-1].
Figura 1: Apps que afectan el rendimiento
Aquí se enumeran las apps que se cerraron debido al uso excesivo de recursos (consulta la Figura 2). Se pueden priorizar las apps que aparecen en la lista. Para obtener más información, consulta Cómo priorizar el parámetro de configuración del rendimiento de la app.
Figura 2: Es la lista de apps que se cerraron debido al uso excesivo de recursos.
Notificación al usuario
Cuando una app o un servicio abusa repetidamente de las E/S de disco (por ejemplo, escribe datos en el disco más allá de los umbrales definidos) dentro de un período determinado y es seguro finalizarlo por abuso de recursos, se notifica al usuario después de que el vehículo ingresa al estado de permitir la distracción del conductor.
La primera notificación al usuario (durante un viaje) se publica como una notificación de alerta, y las demás se publican en el centro de notificaciones.
Por ejemplo, cuando una app usa en exceso la E/S de disco de forma reiterada, el usuario recibe la siguiente notificación:
- Cuando el usuario hace clic en el botón Priorizar app, se inicia la página de configuración de la app, en la que el usuario puede activar o desactivar el parámetro de configuración Priorizar el rendimiento de la app.
- Cuando el usuario hace clic en el botón Inhabilitar app, la app se inhabilita hasta que el usuario la inicie o la habilite en la página de configuración de la app.
- En el caso de las apps que se pueden desinstalar, el botón Inhabilitar app se reemplaza por el botón Desinstalar app. Cuando el usuario hace clic en el botón Desinstalar la app, se inicia la página Configuración de la app, desde la que el usuario puede desinstalarla.
Recomendación para la implementación del selector
Cuando se inhabilitan las apps debido al uso excesivo de recursos, estas desaparecen de la app de selector predeterminada porque CarService actualiza el estado habilitado de las apps como PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED.
Los OEM deben actualizar la implementación del selector integrado para mostrar estas apps como de costumbre, de modo que los usuarios puedan usarlas si es necesario. Consulta las siguientes recomendaciones según la versión de compilación.
Versión 2 de Android SC
- La implementación del selector debe usar la marca
MATCH_DISABLED_UNTIL_USED_COMPONENTScuando recupere la lista de paquetes para mostrar en el selector. - Cuando el usuario hace clic en una app que está en el estado
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED, la app del selector debe habilitar la app estableciendo el estado habilitado de la siguiente manera: