Cómo supervisar el uso de la memoria flash

Watchdog supervisa el uso de la memoria flash mediante el seguimiento de la cantidad total de E/S de disco. escrituras realizadas por todos los servicios y apps con 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 excede el umbral de uso excesivo de E/S del disco, app o servicio. Los umbrales de uso excesivo de E/S del disco y la acción que se debe tomar 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, las escrituras realizadas por una aplicación o servicio se agregan desde el principio del día calendario actual (UTC) y se comparan con los umbrales definidos en el usar configuraciones en exceso.
  • Cuando se enciende un vehículo varias veces durante un día determinado, el módulo de perro guardián almacena las estadísticas de uso de E/S del disco en la memoria flash y las agrega a principios del día calendario actual (UTC).

Acciones de uso excesivo

Cuando una app supera repetidamente el uso excesivo de E/S del disco definido de supervisión, el perro guardián realiza acciones definidas en la configuración del uso excesivo.

  • Todas las apps y servicios de los proveedores se consideran fundamentales para el la estabilidad general del sistema, de modo que no se finalicen ante el uso excesivo de E/S. Sin embargo, la configuración de uso excesivo puede definir una lista de apps de proveedores seguras y servicios.
  • Todas las apps de terceros se pueden cerrar de manera segura.

Cuando una app o un servicio pueden finalizar de manera segura, Watchdog inhabilita la app o el servicio con ella estado del componente PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED

Configuración excesiva

La configuración de uso excesivo contiene los umbrales de uso excesivo de E/S del disco y acciones. Los parámetros de configuración predeterminados sobre el uso excesivo se definen en el sistema y el proveedor. y se envían con la compilación. Los proveedores pueden incluir de forma opcional al proveedor actual en la imagen del proveedor. Cuando la configuración del proveedor no está se proporciona, la configuración del sistema se usa para las apps del proveedor y y servicios de Google.

El perro guardián expone las APIs del sistema a través de CarWatchdogManager, lo que permite las apps o los servicios de los proveedores actualizan la configuración de los proveedores en cualquier momento.

Usar la definición de configuración en exceso

La configuración de uso excesivo se divide por el tipo de componente, por ejemplo, sistema, proveedor, y de terceros. Los OEM solo deben actualizar la configuración de los componentes del proveedor.

Configuración del proveedor

La configuración del proveedor define el umbral de uso excesivo de E/S del disco y las acciones para las apps y servicios de los proveedores, y las apps de mapas y contenido multimedia. El configuración contiene los siguientes campos de configuración.

  • Prefijos de paquetes de proveedores. Todos los paquetes instalados en el se consideran paquetes de proveedores. Además de estos paquetes, los proveedores pueden clasificar los paquetes preinstalados como paquetes de proveedores Agregar los prefijos del paquete a la configuración de prefijos del paquete del proveedor Esta configuración no acepta expresiones regulares.
  • Paquetes seguros para finalizar: Los proveedores pueden especificar qué proveedor los paquetes pueden finalizarse agregando los nombres completos de los paquetes al safe-to-terminate packages.
  • Asignaciones de categorías de aplicación. Los proveedores pueden asignar cualquier paquete (incluidos paquetes de terceros) a una de las dos aplicaciones compatibles. categorías: apps de mapas y multimedia. Esta asignación se realiza para proporcionar mapas y apps multimedia más altos umbrales de uso excesivo de E/S de disco porque estos Las apps tienden a descargar y escribir más datos en el disco que otras apps. de tipos de datos.
  • Umbrales a nivel de componente. Define umbrales genéricos para todos paquetes de distintos proveedores (es decir, aquellos que no se incluyen en la sección Información límites o los umbrales específicos de la categoría de aplicación obtienen estos umbrales). Los proveedores deben definir umbrales a nivel de componente distintos de cero cuando definir la configuración de uso excesivo de E/S del disco.
  • Umbrales específicos del paquete. Los proveedores pueden definir parámetros umbrales para paquetes de proveedores específicos. Las asignaciones deben contener la los nombres completos de los paquetes. Los umbrales definidos en esta configuración tienen prioridad por sobre los umbrales definidos en otros parámetros de configuración para un paquete determinado.
  • Umbrales específicos de la categoría de aplicación. Los proveedores pueden especificar umbrales especiales para categorías de apps específicas. La app Las categorías deben ser una de las categorías admitidas: Maps y Media. de Google Chat. Los umbrales definidos en esta configuración se asignan a paquetes con asignaciones de categorías de aplicaciones.
  • Umbrales de todo el sistema. Los proveedores no deben especificar esta configuración.

Prefijos de paquetes de proveedores, Paquetes seguros para finalizar Umbrales de nivel de componente y Específico de paquetes de umbrales solo se pueden actualizar por la configuración del proveedor para apps y servicios de proveedores. Específica de la categoría de aplicación de umbrales solo se puede actualizar con la configuración del proveedor para todos de Google Maps y contenido multimedia.

Los umbrales de uso excesivo contienen la cantidad de bytes que se pueden escribir en los siguientes casos:

  • El modo en primer plano de una app o servicio frente al modo en segundo plano
  • Modo de cochera del sistema

Esta clasificación permite que las apps y los servicios en primer plano para el usuario realicen lo siguiente: escribir más datos que las apps y servicios en segundo plano. En el modo 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.

Parámetros de configuración 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 apps y servicios del sistema.
    • Esta configuración también puede actualizar el campo Application category mapeos. Por lo tanto, este campo de configuración se comparte entre el sistema y el proveedor. parámetros de configuración.
  • La configuración de terceros define los umbrales para todas de Google Chat. Todas las apps que no están preinstaladas en el sistema aplicaciones de terceros.
    • Todas las apps de terceros reciben los mismos umbrales (por ejemplo, ninguna una app de terceros recibe umbrales especiales), excepto los mapas y el contenido multimedia y apps, 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 el aplicaciones de terceros. Estos umbrales se envían con la imagen del sistema.
      • 3 GiB de escritura en el modo de primer plano de la app
      • 2 GiB de escritura en el modo de segundo plano de la app
      • 4 GiB de escritura en el modo de cochera del sistema
    • Estos son umbrales base. Estos umbrales se actualizan a medida que se aprende más sobre la E/S del disco. de uso de la nube.

Demasiado uso del formato XML de configuración

Es posible establecer la configuración predeterminada del proveedor (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, el sistema definido de la configuración de seguridad también se aplica a las apps y servicios del proveedor.

El archivo en formato XML debe contener solo una etiqueta para cada campo de configuración. Uso excesivo de E/S debe definirse en el archivo en formato XML. Todos los valores de umbral deben ser especificada en la unidad de MiB.

A continuación, se proporciona un ejemplo de configuración 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 con las APIs del sistema de CarWatchdogManager.

La configuración XML anterior solo se puede proporcionar en la imagen de compilación. Si un El OEM decide actualizar la configuración en el dispositivo luego del lanzamiento de 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_CONFIG al 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 CarWatchdogManager.getResourceOveruseConfigurations para obtener los parámetros de configuración existentes. Si no se usan los parámetros de configuración existentes, de configuración de seguridad (incluidas las configuraciones de sistema y de terceros) se sobrescriba, lo cual no se recomienda.
  • Actualiza la configuración existente con los cambios delta y establece la nueva parámetros de configuración. No actualices el sistema ni los componentes de terceros. parámetros de configuración.
  • Usa la API CarWatchdogManager.setResourceOveruseConfigurations. para establecer los nuevos parámetros de configuración.
  • Para obtener y establecer la configuración de uso excesivo de E/S del disco, usa el parámetro CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO

Esta es una implementación de ejemplo que actualiza los parámetros de 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 su uso excesivo de recursos

Las apps de proveedores y de terceros pueden detectar recursos específicos de la app hacer un uso excesivo de las notificaciones de Perro guardián o de la encuesta CarWatchdogManager para la app estadísticas de uso excesivo de un recurso específico durante los últimos 30 días.

Detecta notificaciones de uso excesivo de recursos

Las apps pueden implementar un objeto de escucha de recursos excesivos y registrar de objetos 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:

  • Registra las estadísticas de uso excesivo de E/S del disco para el análisis sin conexión. Aplicación los desarrolladores pueden usar este registro para depurar el problema de uso excesivo de E/S del disco.
  • Reduce las operaciones de escritura de E/S en el disco hasta que se restablezcan los contadores de uso excesivo.

Cliente Java

  1. Implementa el objeto de escucha mediante la herencia de CarWatchdogManager.ResourceOveruseListener: 
    class ResourceOveruseListenerImpl implements
      CarWatchdogManager.ResourceOveruseListener {
            @Override
            public void onOveruse(
                  @NonNull ResourceOveruseStats resourceOveruseStats) {
                  // 1. Log/Upload resource overuse metrics.
                  // 2. Reduce writes until the counters reset.

                  IoOveruseStats ioOveruseStats = resourceOveruseStats.getIoOveruseStats();
                  // Stats period - [ioOveruseStats.getStartTime(), ioOveruseStats.getStartTime()
                  //   + ioOveruseStats.getDurationInSeconds()]
                  // Total I/O overuses - ioOveruseStats.getTotalOveruses()
                  // Total bytes written - ioOveruseStats.getTotalBytesWritten()
                  // Remaining write bytes for the current UTC calendar day -
                  //    ioOveruseStats.getRemainingWriteBytes()
            }
      }
}
  2. Registra la instancia del objeto de escucha mediante una llamada 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. Cancela el registro de la instancia del objeto de escucha cuando la app termine de escuchar: 
    private void removeResourceOveruseListener() {
    CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
    mCarWatchdogManager.removeResourceOveruseListener(
          mListenerImpl);
}

Cliente nativo

  1. Incluye carwatchdog_aidl_interface-ndk_platform en el Dependencia 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. Agrega la política SELinux para permitir que el dominio del servicio del proveedor use Binder (macro binder_user) y agrega el dominio de servicio del proveedor al carwatchdog dominio de cliente (carwatchdog_client_domain macro). Consulta el siguiente código 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. Implementa el objeto de escucha sobre uso excesivo de recursos heredando BnResourceOveruseListener Anular BnResourceOveruseListener::onOveruse para manejar el uso excesivo de recursos notificaciones.

    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. 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 perro guardián está registrado con el nombre del 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 los recursos de la encuesta

Las apps pueden consultar CarWatchdogManager sobre el uso excesivo de E/S específico de la app. estadísticas de ATS de los últimos 30 días.

Cliente Java

Usa CarWatchdogManager.getResourceOveruseStats para obtener las estadísticas de uso excesivo de los recursos. Pasa el 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 los recursos. Pasa la enumeración ResourceType.IO para recuperar el uso excesivo de E/S del disco estadísticas.

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 los recursos.

Configuración para priorizar el rendimiento de la app

La página Configuración de la app contiene los parámetros de configuración de Prioritize app performance (consulta la imagen a continuación), que permite a los usuarios priorizar el rendimiento de una app sobre el sistema y rendimiento del hardware a largo plazo. Este parámetro de configuración solo está disponible para apps o finalizar por el uso excesivo de recursos. De lo contrario, este parámetro de configuración se inhabilitará. Cuando este parámetro de configuración se desactivada (la configuración predeterminada) para una app, esta puede finalizarse por el uso excesivo de recursos. De lo contrario, la app no se finalizará por un uso excesivo de los recursos.

Cuando el usuario activa este parámetro de configuración, el siguiente diálogo de confirmación describe las consecuencias de activar o desactivar 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 puede ser se modificó con una app de superposición de RRO a través de watchdogUserPackageSettingsResetDays hasta un máximo de 180 días. Para obtener más información, consulta Cambia el valor de los recursos de una app en el tiempo de ejecución. El 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>

Parámetro de configuración de Aplicaciones que tienen un impacto en el rendimiento

La app de Configuración contiene la sección Apps que afectan el rendimiento. (consulta la Figura 1). Cuando se presiona, aparece una lista de apps que se restringieron por la memoria flash y que afectan negativamente el rendimiento del sistema. Esto sigue Requisito del CDD 3.5.1 [C-1-1].

Apps que afectan el rendimiento

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). Las apps incluidas en la lista pueden priorizarse. Para obtener más información, consulta Establece la prioridad del parámetro de configuración de rendimiento de las apps.

Lista de apps que se cerraron por un uso excesivo de los recursos

Figura 2: Lista de apps que se cerraron debido al uso excesivo de los recursos.

Notificación al usuario

Ocurre cuando una app o servicio usa en exceso E/S del disco de forma reiterada (por ejemplo, escribe al disco más allá de los umbrales definidos) en un período determinado y se cancela por uso excesivo de recursos, se notifica al usuario luego de que el vehículo ingresa el estado allow-driver-distraction.

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

Por ejemplo, cuando una app usa demasiadas veces la E/S del disco, el usuario recibe siguiente notificación:

  • Cuando el usuario hace clic en el botón Priorizar app, la la página de configuración de la app, donde el usuario puede activar o desactivar la Configura 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 inicia la app o la habilita en el página de configuración.
  • En el caso de las apps desinstalables, el botón Inhabilitar app es se reemplazará por el botón Desinstalar app. Cuando el usuario hace clic en Desinstalar la aplicación, se abre la página Configuración de la aplicación. desde la cual el usuario puede desinstalar la aplicación.

Recomendación para la implementación del selector

Cuando las aplicaciones se inhabilitan debido al uso excesivo de recursos, las aplicaciones desaparecen de la selector predeterminado, ya que CarService actualiza las apps habilitado como PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED Los OEMs deben actualizar la implementación del selector integrado para que se muestren estas apps como inusuales. para que los usuarios puedan usarlos si fuera necesario. Consulta las siguientes recomendaciones según el lanzamiento de la compilación.

Versión de Android SC V2