Supervisar el uso de la memoria flash

Watchdog monitorea el uso de la memoria flash rastreando 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 supera el umbral de uso excesivo de E/S del disco, Watchdog toma medidas en la aplicación o el servicio. Los umbrales de uso excesivo de E/S de 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 de 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 de disco definidos, Watchdog toma las medidas 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 terminan debido al 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 de terminación segura.
  • Todas las aplicaciones de terceros son seguras para terminar.

Cuando es seguro terminar una aplicación o un servicio, Watchdog deshabilita la aplicación o el 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 los servicios del proveedor.

Watchdog expone las API del sistema a través de CarWatchdogManager , que permite que las aplicaciones 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 deben actualizar solo la configuración del componente del proveedor.

Configuración del proveedor

La configuración del proveedor define los umbrales de uso excesivo de E/S del disco y las acciones para todas las aplicaciones y servicios del proveedor, y todas las aplicaciones de mapas y medios. La configuración contiene los siguientes campos de configuración.

  • Vendor package prefixes . Todos los paquetes instalados en la partición de proveedor se consideran paquetes de 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 vendor package prefixes . Esta configuración no acepta expresiones regulares.
  • Safe-to-terminate packages . Los proveedores pueden especificar qué paquetes de proveedores son seguros para terminar 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 mapas y aplicaciones multimedia con umbrales de sobreuso 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 de nivel de componente distintos de cero al definir la configuración de uso excesivo de E/S de 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 multimedia. Los umbrales definidos en esta configuración se asignan a paquetes específicos utilizando las 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 las configuraciones Package specific thresholds son actualizables solo por la configuración del proveedor para las aplicaciones y los servicios del proveedor. La configuración Application category specific thresholds solo puede ser actualizada por la configuración del proveedor para todas las aplicaciones de mapas y medios.

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

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

Esta clasificación permite que las aplicaciones/servicios en primer plano que enfrentan los usuarios escriban más datos que las aplicaciones/servicios en segundo plano. En el modo Garaje, las aplicaciones y los servicios tienden a descargar actualizaciones, por lo que cada uno necesita un umbral más alto que las aplicaciones y los 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 de uso excesivo de E/S y acciones 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 las aplicaciones de mapas y multimedia, cuyos umbrales están definidos por la configuración del proveedor.
    • Los umbrales de uso excesivo de E/S de disco a continuación son los umbrales predeterminados para las aplicaciones de terceros. Estos umbrales se envían con la imagen del sistema.
      • Escritura de 3GiB en el modo de primer plano de la aplicación.
      • Escritura de 2GiB en el modo de fondo de la aplicación.
      • Escritura de 4GiB en el modo garaje del sistema.
    • Los umbrales antes mencionados son umbrales base. Estos umbrales se actualizarán a medida que comprendamos mejor el uso de E/S del disco.

Uso excesivo del formato XML de configuración

La configuración del proveedor predeterminado 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 aplicará 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 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>

Actualice 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 en el dispositivo después de que se lanza una compilación, puede usar las siguientes API para realizar cambios en la configuración en el dispositivo.

  • Otorgue el permiso Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG a la persona que llama.
  • Debe usar 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 sobrescribirán todas las configuraciones (incluidas las configuraciones del sistema y de terceros), lo que no se recomienda.
  • Actualice las configuraciones existentes con los cambios delta y configure las nuevas configuraciones. No actualice las configuraciones del sistema y 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, use la marca CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO .

A continuación se muestra 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 su uso excesivo de recursos

Las aplicaciones de proveedores y de terceros pueden escuchar notificaciones de uso excesivo de recursos específicos de la aplicación de Watchdog o sondear CarWatchdogManager para conocer las estadísticas de uso excesivo de recursos específicos de la aplicación durante 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 registrar el detector 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 el análisis fuera de línea. Los desarrolladores de aplicaciones pueden usar 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 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);
}
  3. Cancele el registro de la instancia de escucha 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 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. Agregue la política de 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 manejar 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 enlace y registre el agente de escucha de uso excesivo de recursos con 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);
}

Sondear estadísticas de uso excesivo de recursos

Las aplicaciones pueden sondear a CarWatchdogManager para conocer las estadísticas de uso excesivo de E/S específicas de la aplicación ATS 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 (ver la imagen a continuación), que permite al usuario priorizar el rendimiento de una aplicación sobre el rendimiento del sistema y del hardware a largo plazo. Esta configuración está disponible solo para aplicaciones que son seguras para ser terminadas 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 puede cancelarse debido al 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.

Notificación de usuario

Cuando una aplicación o un 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 el uso excesivo de recursos, se notifica al usuario después de que el vehículo ingresa al permiso de controlador. -Estado de distracción.

La primera notificación de usuario (durante un viaje) se publica como una notificación de advertencia 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 aplicación , se abre la página de configuración de la aplicación, donde el usuario puede activar o desactivar la configuración de rendimiento de Priorizar aplicación .
  • Cuando el usuario hace clic en el botón Deshabilitar aplicación , la aplicación se deshabilita hasta que el usuario inicia la aplicación o la habilita en la página de configuración de la aplicación.
  • Para aplicaciones desinstalables, el botón Deshabilitar aplicación se reemplaza con el botón Desinstalar aplicación . Cuando el usuario hace clic en el botón Desinstalar aplicación , se inicia 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 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 incorporado para mostrar estas aplicaciones como inusuales, para 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