Monitorear el uso de la memoria flash

Watchdog monitorea el uso de la memoria flash mediante el seguimiento de la cantidad total de escrituras de E/S de disco realizadas por todas las aplicaciones y servicios utilizando las estadísticas de E/S de disco por UID expuestas por el kernel en la ubicación `/proc/uid_io/stats`. Cuando una aplicación o servicio excede el umbral de uso excesivo de E/S del disco, Watchdog toma medidas en la aplicación o servicio. Los umbrales de uso excesivo de E/S del disco y la acción a realizar en caso de uso excesivo están predefinidos en la configuración de uso excesivo de E/S del disco.

Umbrales de uso excesivo

  • Los umbrales de uso excesivo de E/S del disco se aplican diariamente, es decir, todas las escrituras realizadas por una aplicación/servicio se agregan desde el comienzo del día calendario UTC actual y se comparan con los umbrales definidos en las configuraciones de uso excesivo.
  • Cuando un vehículo arranca varias veces en un día determinado, el módulo Watchdog almacena las estadísticas de uso de E/S del disco en la memoria flash y las agrega desde el comienzo del día calendario UTC actual.

Acciones de uso excesivo

Cuando una aplicación excede repetidamente los umbrales de uso excesivo de E/S del disco definidos, Watchdog toma las acciones definidas en la configuración de uso excesivo.

  • Todas las aplicaciones y servicios de los proveedores se consideran críticos para la estabilidad general del sistema, por lo que no finalizan por el uso excesivo de E/S del disco. Sin embargo, la configuración de uso excesivo puede definir una lista de aplicaciones y servicios de proveedores seguros de finalizar.
  • Todas las aplicaciones de terceros son seguras para finalizar.

Cuando es seguro finalizar una aplicación o servicio, Watchdog deshabilita la aplicación o servicio con el estado del componente de la aplicación PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED .

Configuración de uso excesivo

La configuración de uso excesivo contiene las acciones y los umbrales de uso excesivo de E/S del disco. Las configuraciones de uso excesivo predeterminadas se definen en las imágenes del sistema y del proveedor y se envían con la compilación. Los proveedores pueden incluir opcionalmente 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 utiliza para las aplicaciones y servicios del proveedor.

Watchdog expone las API del sistema a través de CarWatchdogManager , que permite que las aplicaciones o 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 tercero. Los OEM deben actualizar únicamente la configuración de los componentes 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 aplicaciones y servicios del proveedor, y todos los mapas y aplicaciones multimedia. La configuración contiene los siguientes campos de configuración.

  • Vendor package prefixes . Todos los paquetes instalados en la partición del proveedor se consideran paquetes de proveedor. Además de estos paquetes, los proveedores pueden clasificar los paquetes preinstalados como paquetes de proveedor agregando los prefijos de paquete a la configuración vendor package prefixes . Esta configuración no acepta expresiones regulares.
  • Safe-to-terminate packages . Los proveedores pueden especificar qué paquetes de proveedores se pueden cancelar de forma segura agregando los nombres completos de los paquetes a la configuración safe-to-terminate packages .
  • Application category mappings . Los proveedores pueden asignar cualquier paquete (incluidos los paquetes de terceros) a una de las dos categorías de aplicaciones admitidas: aplicaciones de mapas y multimedia. Esta asignación se realiza para proporcionar a mapas y aplicaciones multimedia umbrales de uso excesivo de E/S de disco más altos porque estas aplicaciones tienden a descargar y escribir más datos en el disco que otros tipos de aplicaciones.
  • Component level thresholds . Define umbrales genéricos para todos los paquetes de proveedores (es decir, los paquetes no cubiertos por Package specific thresholds o Application category specific thresholds obtienen estos umbrales). Los proveedores deben definir umbrales a nivel de componente distintos de cero al definir la configuración de uso excesivo de E/S del disco.
  • Package specific thresholds . Los proveedores pueden definir umbrales especiales para paquetes de proveedores específicos. Las asignaciones deben contener los nombres completos de los paquetes. Los umbrales definidos en esta configuración tienen prioridad sobre los umbrales definidos en otras configuraciones para un paquete determinado.
  • Application category specific thresholds . Los proveedores pueden especificar umbrales especiales para categorías de aplicaciones específicas. Las categorías de aplicaciones deben ser una de las categorías admitidas: aplicaciones de mapas y medios. Los umbrales definidos en esta configuración se asignan a paquetes específicos mediante Application category mappings .
  • System-wide thresholds . Los proveedores no deben especificar esta configuración.

Vendor package prefixes , Safe-to-terminate packages , Component level thresholds y Package specific thresholds solo se pueden actualizar mediante la configuración del proveedor para aplicaciones y servicios del proveedor. La configuración Application category specific thresholds solo se puede actualizar mediante la configuración del proveedor para todos los mapas y aplicaciones multimedia.

Los umbrales de uso excesivo contienen la cantidad de bytes que se permite escribir durante

  • Modo de primer plano de una aplicación/servicio versus modo de fondo
  • y modo garaje del sistema.

Esta clasificación permite que las aplicaciones/servicios en primer plano del usuario escriban más datos que las aplicaciones/servicios en segundo plano. En el modo Garaje, las aplicaciones y servicios tienden a descargar actualizaciones, por lo que cada uno necesita un umbral más alto que las aplicaciones y servicios que se ejecutan en otros modos.

Configuraciones del sistema y de terceros

Los OEM no deben actualizar el sistema ni las configuraciones de terceros.

  • La configuración del sistema define umbrales y acciones de uso excesivo de E/S para aplicaciones y servicios del sistema.
    • Esta configuración también puede actualizar las Application category mappings . Por lo tanto, este campo de configuración se comparte entre las configuraciones del sistema y del proveedor.
  • La configuración de terceros define umbrales para todas las aplicaciones de terceros. Todas las aplicaciones que no están preinstaladas en el sistema son aplicaciones de terceros.
    • Todas las aplicaciones de terceros reciben los mismos umbrales (por ejemplo, ninguna aplicación de terceros recibe umbrales especiales), excepto mapas y aplicaciones multimedia, cuyos umbrales están definidos por la configuración del proveedor.
    • Los siguientes umbrales de uso excesivo de E/S del disco son los umbrales predeterminados para las aplicaciones de terceros. Estos umbrales se envían con la imagen del sistema.
      • Escritura de 3 GiB en el modo de primer plano de la aplicación.
      • Escritura de 2 GiB en el modo de fondo de la aplicación.
      • Escritura de 4 GiB en el modo garaje del sistema.
    • Estos son umbrales básicos. Estos umbrales se actualizan a medida que entendemos mejor el uso de E/S del disco.

Uso excesivo del formato XML de configuración

La configuración predeterminada del proveedor se puede colocar (esto 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 aplicaciones y 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 debe definirse en el archivo XML. Todos los valores de umbral deben especificarse en la unidad MiB.

A continuación se proporciona una configuración XML de ejemplo:

<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>

Actualizar la configuración de uso excesivo a través de las API del sistema CarWatchdogManager

La configuración XML anterior solo se puede proporcionar en la imagen de compilación. Si un OEM elige actualizar la configuración del dispositivo después del lanzamiento de una compilación, puede usar las siguientes API para realizar cambios en la configuración del dispositivo.

  • Otorgue el permiso Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG a la persona que llama.
  • Debe utilizar las configuraciones existentes para actualizar y establecer las nuevas configuraciones. Utilice la API CarWatchdogManager.getResourceOveruseConfigurations para obtener las configuraciones existentes. Si no se utilizan las configuraciones existentes, se sobrescriben todas las configuraciones (incluidas las del sistema y de terceros), lo cual no se recomienda.
  • Actualice las configuraciones existentes con los cambios delta y establezca las nuevas configuraciones. No actualice las configuraciones del sistema ni de los componentes de terceros.
  • Utilice la API CarWatchdogManager.setResourceOveruseConfigurations para establecer las nuevas configuraciones.
  • Para obtener y establecer las configuraciones de uso excesivo de E/S del disco, utilice el indicador CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO .

Aquí hay una implementación de muestra 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();
}

Aplicaciones que monitorean el uso excesivo de sus recursos

Las aplicaciones de proveedores y de terceros pueden escuchar las notificaciones de uso excesivo de recursos específicos de la aplicación desde Watchdog o sondear CarWatchdogManager para obtener estadísticas de uso excesivo de recursos específicos de la aplicación durante hasta los últimos 30 días.

Escuche las notificaciones de uso excesivo de recursos

Las aplicaciones pueden implementar un detector de uso excesivo de recursos y registrarlo con CarWatchdogManager para recibir notificaciones específicas de la aplicación cuando superen el 80 % o el 100 % de los umbrales de uso excesivo de E/S del disco. Las aplicaciones pueden usar estas notificaciones para:

  • Registre las estadísticas de uso excesivo de E/S del disco para realizar análisis fuera de línea. Los desarrolladores de aplicaciones pueden utilizar este registro para depurar el problema de uso excesivo de E/S del disco.
  • Reduzca las escrituras de E/S del disco hasta que se restablezcan los contadores de uso excesivo.

cliente java

  1. Implemente el oyente 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()
            }
      }
}
  2. Registre la instancia del oyente 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);
}
  3. Cancelar el registro de la instancia del oyente cuando la aplicación haya terminado de escuchar:
    private void removeResourceOveruseListener() {
    CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
    mCarWatchdogManager.removeResourceOveruseListener(
          mListenerImpl);
}

Cliente nativo

  1. Incluya carwatchdog_aidl_interface-ndk_platform en la shared_libs de la regla de compilación.

    Android.bp

    cc_binary {
    name: "sample_native_client",
    srcs: [
        "src/*.cpp"
    ],
    shared_libs: [
        "carwatchdog_aidl_interface-ndk_platform",
        "libbinder_ndk",
    ],
    vendor: true,
}
  2. Agregue la política SELinux para permitir que el dominio de servicio del proveedor use Binder (macro binder_user ) y agregue el dominio de servicio del proveedor al dominio del cliente carwatchdog (carwatchdog_client_domain macro) . Consulte el código a continuación para sample_client.te y file_contexts .

    sample_client.te

    type 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
  3. Implemente el detector de uso excesivo de recursos heredando BnResourceOveruseListener . Anule BnResourceOveruseListener::onOveruse para controlar las notificaciones de uso excesivo de recursos.

    ResourceOveruseListenerImpl.h

    class 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.cpp

    ndk::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();
}
  4. Inicie un grupo de subprocesos de carpeta y registre el detector de uso excesivo de recursos en el servidor de vigilancia. El servidor de vigilancia está registrado con el nombre de servicio android.automotive.watchdog.ICarWatchdog/default .

    main.cpp

    int 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.cpp

    void 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);
}

Estadísticas de uso excesivo de recursos de encuestas

Las aplicaciones pueden sondear CarWatchdogManager para conocer las estadísticas ATS de uso excesivo de E/S específicas de la aplicación durante los últimos 30 días.

cliente java

Utilice CarWatchdogManager.getResourceOveruseStats para obtener las estadísticas de uso excesivo de recursos. Pase el indicador 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

Utilice CarWatchdogServer.getResourceOveruseStats para obtener las estadísticas de uso excesivo de recursos. Pase la enumeración ResourceType.IO para obtener 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
      }
}

Uso excesivo de recursos UX

Priorizar la configuración de rendimiento de la aplicación

La página de configuración de la aplicación tiene la configuración Prioritize app performance (consulte la imagen a continuación), que permite al usuario priorizar el rendimiento de una aplicación sobre el sistema y el rendimiento del hardware a largo plazo. Esta configuración está disponible solo para aplicaciones que se pueden cerrar de forma segura por uso excesivo de recursos. De lo contrario, esta configuración aparece atenuada. Cuando esta configuración está desactivada (configuración predeterminada) para una aplicación, la aplicación se puede finalizar por uso excesivo de recursos. De lo contrario, la aplicación no finaliza por uso excesivo de recursos.

Cuando el usuario activa esta configuración, el siguiente cuadro de diálogo de confirmación describe las implicaciones de activar la configuración.

Después de 90 días, esta configuración se restablece automáticamente a su valor predeterminado. El límite de días se puede modificar con una aplicación de superposición RRO usando watchdogUserPackageSettingsResetDays , hasta un máximo de 180 días. Para obtener más información, consulte Cambiar el valor de los recursos de una aplicación en 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>

Notificación de usuario

Cuando una aplicación o servicio abusa repetidamente de 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 cancelarlo por uso excesivo de recursos, se notifica al usuario después de que el vehículo ingresa al permiso de conductor. -estado de distracción.

La primera notificación del usuario (durante un viaje) se publica como una notificación de aviso y las demás notificaciones se publican en el centro de notificaciones.

Por ejemplo, cuando una aplicación abusa repetidamente de la E/S del disco, el usuario recibe la siguiente notificación:

  • Cuando el usuario hace clic en el botón Priorizar la aplicación , se inicia la página de configuración de la aplicación, donde el usuario puede activar o desactivar la configuración Priorizar el rendimiento de la aplicación .
  • Cuando el usuario hace clic en el botón Deshabilitar aplicación , la aplicación se deshabilita hasta que el usuario la inicia o la habilita en la página de configuración de la aplicación.
  • Para aplicaciones desinstalables, el botón Desactivar aplicación se reemplaza por el botón Desinstalar aplicación . Cuando el usuario hace clic en el botón Desinstalar aplicación , se inicia la página de Configuración de la aplicación, desde donde el usuario puede desinstalar la aplicación.

Recomendación para la implementación del lanzador

Cuando las aplicaciones se deshabilitan debido al uso excesivo de recursos, las aplicaciones desaparecen de la aplicación de inicio predeterminada porque CarService actualiza el estado habilitado de las aplicaciones como PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED . Los OEM deben actualizar la implementación del iniciador integrado para mostrar estas aplicaciones como inusuales, de modo que los usuarios puedan usarlas si es necesario. Consulte las siguientes recomendaciones basadas en la versión de compilación.

Lanzamiento de Android SC V2