Watchdog supervisa el uso de memoria flash mediante el 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 servicio supera el umbral de uso excesivo de E/S del disco, Watchdog realiza acciones en la app o el servicio. Los umbrales de uso excesivo de E/S del disco y la acción que se debe realizar están predefinidos en la configuración del uso excesivo de E/S del disco.
Umbrales de uso excesivo
- Los umbrales de uso excesivo de E/S del disco se aplican a diario, es decir, todas las escrituras realizadas por una app o servicio se agregan desde el comienzo del día calendario UTC actual y se verifican con los umbrales definidos en las configuraciones de uso excesivo.
- Cuando un vehículo se inicia 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 calendario UTC actual.
Acciones de uso excesivo
Cuando una app supera de forma reiterada los umbrales de uso excesivo de E/S del disco definidos, Watchdog realiza las acciones definidas en la configuración de uso excesivo.
- Todas las apps y los servicios de los proveedores se consideran fundamentales para la estabilidad general del sistema, por lo que no se cancelan por el 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 se pueden cerrar de manera segura.
Cuando una app o servicio es segura para finalizar, Watchdog la inhabilita con el estado del componente de la app
PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED
.
Configuración de sobrecarga
La configuración de uso excesivo contiene los umbrales y las acciones de uso excesivo de la E/S del disco. Las configuraciones predeterminadas de uso excesivo se definen en las imágenes del sistema y del proveedor, y se envían con 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, la configuración del sistema también se usa 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 el tipo de componente, por ejemplo, sistema, proveedor y tercero. 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 todos los servicios y apps del proveedor, así como para todas las apps de mapas y contenido 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 si agregan 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 finalizar de forma segura. Los proveedores pueden especificar qué paquetes del proveedor son seguros para finalizar. Para ello, deben agregar los nombres de los paquetes completos 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 multimedia. Esta asignación se realiza para proporcionar mapas y apps de música más altos umbrales de uso excesivo de E/S en el disco, ya que estas apps tienden a descargar y escribir más datos en el disco que otros tipos de apps.
- Umbrales a nivel de componente. Define umbrales genéricos para todos los paquetes de proveedores (es decir, los paquetes que no están 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.
- Límites específicos del paquete. Los proveedores pueden definir umbrales especiales para paquetes específicos. Las asignaciones deben contener los nombres de los paquetes completos. Los umbrales definidos en esta configuración tienen prioridad sobre los umbrales definidos en otras configuraciones para un paquete determinado.
- Umbral específico 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 app deben ser una de las categorías admitidas: apps de Maps y Media. Los umbrales definidos en esta configuración se asignan a paquetes específicos con las asignaciones de categorías de aplicaciones.
- Umbrales en todo el sistema: Los proveedores no deben especificar esta configuración.
Solo la configuración del proveedor puede actualizar las configuraciones de prefijos de paquetes del proveedor, paquetes seguros para finalizar, umbrales a nivel del componente y umbrales específicos del paquete para las apps y los servicios del proveedor. Solo la configuración del proveedor puede actualizar la configuración de los umbrales específicos de la categoría de la aplicación para todos los mapas y las apps multimedia.
Los umbrales de uso excesivo contienen la cantidad de bytes que se pueden escribir durante los siguientes eventos:
- Modo en primer plano de una app o servicio en comparación con el modo en segundo plano
- Modo de cochera del sistema
Esta clasificación permite que las apps y los servicios en primer plano que se orientan al usuario escriban más datos que las apps y los servicios en segundo plano. En el modo Garage, 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.
Configuración del sistema y de terceros
Los OEMs no deben actualizar el sistema ni la configuración 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.
- Con esta configuración, también se pueden 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 umbrales predeterminados para las apps de terceros. Estos umbrales se envían con la imagen del sistema.
- Escritura de 3 GiB en el modo en primer plano de la app
- Escritura de 2 GiB en el modo en segundo plano de la app
- 4 GiB de escritura en el modo de cochera del sistema
- Estos son umbrales básicos. Estos umbrales se actualizan a medida que se obtiene más información sobre el uso de la E/S del disco.
Formato XML de configuración de uso excesivo
La configuración predeterminada del proveedor se puede colocar (es opcional) en la ubicación /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml en la imagen de compilación. Cuando no se especifica esta configuración, la configuración definida por el sistema también se aplica a las apps y los servicios del proveedor.
El archivo en formato 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 en formato XML. Todos los valores de umbral deben especificarse en la unidad de MiB.
A continuación, se proporciona una configuración XML de muestra:
<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 con las APIs del sistema de CarWatchdogManager.
La configuración XML anterior solo se puede proporcionar en la imagen de compilación. Si un OEM elige actualizar la configuración integrada en el dispositivo después de que se lanza una compilación, puede usar las siguientes APIs para realizar cambios en la configuración integrada en el dispositivo.
- Otorga el permiso
Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIGal llamador. - Debes usar las configuraciones existentes para actualizar y establecer las configuraciones nuevas. Usa la API de
CarWatchdogManager.getResourceOveruseConfigurationspara obtener las configuraciones existentes. Si no se usan las configuraciones existentes, se reemplazan todas las configuraciones (incluidas las del sistema y de terceros), lo que no se recomienda. - Actualiza la configuración existente con los cambios delta y establece la nueva configuración. No actualices la configuración del sistema ni de los componentes de terceros.
- Usa la API de
CarWatchdogManager.setResourceOveruseConfigurationspara establecer las configuraciones nuevas. - Para obtener y establecer los parámetros de configuración del uso excesivo de E/S del disco, usa la marca
CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO.
Esta es una implementación de ejemplo que actualiza las configuraciones 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 detectar las notificaciones de uso excesivo de recursos específicos de la app desde Watchdog o la encuesta CarWatchdogManager de las estadísticas de uso excesivo de recursos específicos de la app durante los últimos 30 días.
Escucha 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 sus 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 del 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 operaciones de escritura 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() } } } - Llama a
CarWatchdogManager.addResourceOveruseListenerpara registrar la instancia del objeto de escucha.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 termine 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 de servicio del proveedor use Binder (macro
binder_user) y agrega el dominio de servicio del proveedor al dominio de 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
- Para implementar el objeto de escucha de uso excesivo de recursos, hereda
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 perro guardián. 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); }
Cómo consultar estadísticas de uso excesivo de recursos
Las apps pueden consultar CarWatchdogManager para conocer la ATS de estadísticas de uso excesivo de E/S específicas de la app durante los últimos 30 días.
Cliente 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 del recurso. Pasa la enumeración ResourceType.IO para recuperar las estadísticas del 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
}
}
Uso excesivo de recursos en la experiencia del usuario
En las siguientes secciones, se describe la experiencia del usuario cuando se produce un uso excesivo de recursos.
Prioriza la configuración del rendimiento de la app
La página Configuración de la app contiene la configuración dePrioritize app performance (consulta la imagen a continuación), que permite a los usuarios priorizar el rendimiento de una app sobre el del sistema y el rendimiento de hardware a largo plazo. Este parámetro de configuración solo está disponible para las apps que se pueden finalizar de forma segura cuando se usa en exceso los recursos. De lo contrario, este parámetro de configuración está inhabilitado. Cuando este parámetro de configuración está desactivado (el parámetro de configuración predeterminado) para una app, esta puede finalizarse por el uso excesivo de recursos.
De lo contrario, la app no se finalizará por el uso excesivo de recursos.
Cuando el usuario activa este parámetro de configuración, en el siguiente diálogo de confirmación se describen las implicaciones de activar este parámetro:
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 que use 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. El siguiente ejemplo de etiqueta de superposición 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>
Configuración de apps que afectan el rendimiento
La app de Configuración contiene una sección Apps que afectan el rendimiento (consulta 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 [C-1-1]del CDD 3.5.1.
Figura 1: Aplicaciones que tienen un impacto en el rendimiento
Las apps que se cancelaron debido al uso excesivo de recursos se enumeran aquí (consulta la Figura 2). Se pueden priorizar las apps que se incluyen en la lista. Para obtener más información, consulta Cómo priorizar la configuración de rendimiento de la app.
Figura 2: Lista de apps que se cerraron debido al uso excesivo de los recursos.
Notificación al usuario
Cuando una app o servicio usa en exceso varias veces la E/S del disco (por ejemplo, escribe datos en el disco más allá de los umbrales definidos) dentro de un período determinado y es seguro que se cierre por uso excesivo de recursos, el usuario recibe una notificación una vez que el vehículo ingresa en el estado allow-driver-distraction.
La primera notificación al usuario (durante un viaje) se publica como una notificación de atención, y las demás notificaciones se publican en el centro de notificaciones.
Por ejemplo, cuando una app abusa de manera reiterada de la E/S de disco, 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 la opció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 inicia o la habilita en la página de configuración de la app.
- En el caso de las apps desinstalables, el botón Inhabilitar app se reemplaza por el botón Desinstalar app. Cuando el usuario hace clic en el botón Desinstalar app, se inicia la página Configuración de la app y la puede desinstalar.
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 OEMs deben actualizar la implementación del selector integrado para mostrar estas apps como inusuales, 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 se recupera la lista de paquetes que se mostrarán 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 habilitarla configurando el estado habilitado de la siguiente manera: