Monitorar o uso da memória flash

O Watchdog monitora o uso da memória flash rastreando a quantidade total de gravações de E/S do disco feitas por todos os apps e serviços usando as estatísticas de E/S do disco por UID expostas pelo kernel no local `/proc/uid_io/stats`. Quando um app ou serviço excede o limite de uso excessivo de E/S do disco, o Watchdog toma medidas no app ou serviço. Os limites de uso excessivo de E/S do disco e a ação a ser tomada em caso de uso excessivo são predefinidos na configuração de uso excessivo de E/S do disco.

Limites de uso excessivo

  • Os limites de uso excessivo de E/S de disco são aplicados diariamente. Ou seja, todas as gravações feitas por um app/serviço são agregadas desde o início do dia civil UTC atual e verificadas em relação aos limites definidos nas configurações de uso excessivo.
  • Quando um veículo é ligado várias vezes em um determinado dia, o módulo Watchdog armazena as estatísticas de uso de E/S de disco na memória flash e as agrega desde o início do dia atual do calendário UTC.

Ações de uso excessivo

Quando um app excede repetidamente os limites definidos de uso excessivo de E/S de disco, o Watchdog realiza as ações definidas na configuração de uso excessivo.

  • Todos os apps e serviços de fornecedores são considerados essenciais para a estabilidade geral do sistema. Por isso, eles não são encerrados por uso excessivo de E/S de disco. No entanto, a configuração de uso excessivo pode definir uma lista de apps e serviços de fornecedores que podem ser encerrados com segurança.
  • Todos os apps de terceiros podem ser encerrados com segurança.

Quando um app ou serviço pode ser encerrado com segurança, o Watchdog desativa o app ou serviço com o estado do componente do app PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED .

Configuração de uso excessivo

A configuração de uso excessivo contém os limites e as ações de uso excessivo de E/S do disco. As configurações padrão de uso excessivo são definidas nas imagens do sistema e do fornecedor e enviadas com o build. Os fornecedores podem incluir a configuração na imagem. Quando a configuração do fornecedor não é fornecida, a configuração do sistema também é usada para os apps e serviços do fornecedor.

O Watchdog expõe APIs do sistema por meio do CarWatchdogManager, que permite que apps ou serviços de fornecedores atualizem a configuração do fornecedor a qualquer momento.

Definição de configuração de uso excessivo

A configuração de uso excessivo é dividida por tipo de componente, por exemplo, sistema, fornecedor e terceiros. Os OEMs precisam atualizar apenas a configuração do componente do fornecedor.

Configuração do fornecedor

A configuração do fornecedor define os limites e as ações de uso excessivo de E/S de disco para todos os apps e serviços do fornecedor, além de todos os apps de mapas e mídia. A configuração contém os campos abaixo.

  • Prefixos de pacotes de fornecedores. Todos os pacotes instalados na partição do fornecedor são considerados pacotes do fornecedor. Além desses pacotes, os fornecedores podem classificar os pacotes pré-instalados como pacotes do fornecedor adicionando os prefixos de pacote à configuração prefixos de pacote do fornecedor. Essa configuração não aceita expressões regulares.
  • Pacotes que podem ser encerrados com segurança. Os fornecedores podem especificar quais pacotes deles podem ser encerrados adicionando os nomes completos à configuração pacotes seguros para encerramento.
  • Mapeamentos de categorias de aplicativos. Os fornecedores podem mapear qualquer pacote (incluindo pacotes de terceiros) para uma das duas categorias de apps compatíveis: apps de mapa e de mídia. Esse mapeamento é feito para fornecer aos apps de mapas e mídia limites mais altos de uso excessivo de E/S de disco, já que eles tendem a baixar e gravar mais dados no disco do que outros tipos de apps.
  • Limites no nível do componente. Define limites genéricos para todos os pacotes do fornecedor. Ou seja, pacotes não cobertos por Limites específicos do pacote ou Limites específicos da categoria do aplicativo recebem esses limites. Os fornecedores precisam definir limites não nulos no nível do componente ao definir a configuração de uso excessivo de E/S de disco.
  • Limites específicos do pacote. Os fornecedores podem definir limites especiais para pacotes específicos. Os mapeamentos precisam conter os nomes completos dos pacotes. Os limites definidos nesta configuração têm precedência sobre os definidos em outras configurações para um determinado pacote.
  • Limiares específicos da categoria do aplicativo. Os fornecedores podem especificar limites especiais para categorias de apps específicas. As categorias de apps precisam ser uma das categorias compatíveis: apps de mapas e mídia. Os limites definidos nessa configuração são mapeados para pacotes específicos usando Mapeamentos de categoria de aplicativo.
  • Limites em todo o sistema. Os fornecedores não podem especificar essa configuração.

Prefixos de pacotes de fornecedores, Pacotes seguros para encerramento, Limiares no nível do componente e Limiares específicos do pacote só podem ser atualizados pela configuração do fornecedor para apps e serviços dele. A configuração de limiares específicos da categoria do aplicativo só pode ser atualizada pela configuração do fornecedor para todos os apps de mapas e mídia.

Os limites de uso excessivo contêm a quantidade de bytes que podem ser gravados durante:

  • Um app ou serviço em primeiro plano versus segundo plano
  • Modo garagem do sistema

Essa classificação permite que apps e serviços em primeiro plano voltados ao usuário gravem mais dados do que apps e serviços em segundo plano. No modo Garagem, os apps e serviços tendem a baixar atualizações, então cada um precisa de um limite maior do que os apps e serviços executados em outros modos.

Configurações do sistema e de terceiros

Os OEMs não devem atualizar as configurações do sistema e de terceiros.

  • A configuração do sistema define limites e ações de uso excessivo de E/S para apps e serviços do sistema.
    • Essa configuração também pode atualizar os mapeamentos de categoria de aplicativo. Assim, esse campo de configuração é compartilhado entre as configurações do sistema e do fornecedor.
  • A configuração de terceiros define limites para todos os apps de terceiros. Todos os apps que não são pré-instalados no sistema são de terceiros.
    • Todos os apps de terceiros recebem os mesmos limites (por exemplo, nenhum app de terceiros recebe limites especiais), exceto os de mapas e mídia, cujos limites são definidos pela configuração do fornecedor.
    • Os limites de uso excessivo de E/S de disco abaixo são os padrões para apps de terceiros. Esses limites são enviados com a imagem do sistema.
      • Gravação de 3 GiB no modo de primeiro plano do app.
      • Gravação de 2 GiB no modo em segundo plano do app.
      • Gravação de 4 GiB no modo garagem do sistema.
    • Esses são limites básicos. Esses limites são atualizados à medida que aprendemos mais sobre o uso de E/S de disco.

Formato XML de configuração de uso excessivo

A configuração padrão do fornecedor pode ser colocada (opcional) no local /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml na imagem de build. Quando essa configuração não é especificada, a configuração definida pelo sistema também é aplicada a apps e serviços de fornecedores.

O arquivo XML deve conter apenas uma tag para cada campo de configuração. A configuração de uso excessivo de E/S precisa ser definida no arquivo XML. Todos os valores de limite precisam ser especificados na unidade MiB.

Confira abaixo um exemplo de configuração 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>

Atualizar a configuração de uso excessivo usando as APIs do sistema CarWatchdogManager

A configuração XML acima só pode ser fornecida na imagem de build. Se um OEM optar por atualizar a configuração no dispositivo após o lançamento de um build, ele poderá usar as seguintes APIs para fazer mudanças na configuração no dispositivo.

  • Conceda a permissão Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG ao autor da chamada.
  • É necessário usar as configurações atuais para atualizar e definir as novas configurações. Use a API CarWatchdogManager.getResourceOveruseConfigurations para receber as configurações atuais. Se as configurações atuais não forem usadas, todas as configurações (incluindo as do sistema e de terceiros) serão substituídas, o que não é recomendado.
  • Atualize as configurações atuais com as mudanças delta e defina as novas configurações. Não atualize as configurações do sistema e dos componentes de terceiros.
  • Use a API CarWatchdogManager.setResourceOveruseConfigurations para definir as novas configurações.
  • Para receber e definir as configurações de uso excessivo de E/S de disco, use a flag CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO.

Confira um exemplo de implementação que atualiza as configurações de uso excessivo 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 monitorando o uso excessivo de recursos

Apps de fornecedores e terceiros podem ficar atentos a notificações de uso excessivo de recursos específicos do app do Watchdog ou pesquisar CarWatchdogManager para ver as estatísticas de uso excessivo de recursos específicos do app nos últimos 30 dias.

Receber notificações de uso excessivo de recursos

Os apps podem implementar um listener de uso excessivo de recursos e registrar o listener com CarWatchdogManager para receber notificações específicas do app quando ele exceder 80% ou 100% dos limites de uso excessivo de E/S de disco. Os apps podem usar essas notificações para:

  • Registre as estatísticas de uso excessivo de E/S de disco para análise off-line. Os desenvolvedores de apps podem usar esse registro para depurar o problema de uso excessivo de E/S de disco.
  • Reduza as gravações de E/S de disco até que os contadores de uso excessivo sejam redefinidos.

Cliente Java

  1. Implemente o listener herdando 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 a instância do listener chamando 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 o registro da instância do listener quando o app terminar de ouvir: 
    private void removeResourceOveruseListener() {
    CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
    mCarWatchdogManager.removeResourceOveruseListener(
          mListenerImpl);
}

Cliente nativo

  1. Inclua carwatchdog_aidl_interface-ndk_platform na dependência shared_libs da regra de build.

    Android.bp

    cc_binary {
    name: "sample_native_client",
    srcs: [
        "src/*.cpp"
    ],
    shared_libs: [
        "carwatchdog_aidl_interface-ndk_platform",
        "libbinder_ndk",
    ],
    vendor: true,
}
  2. Adicione a política do SELinux para permitir que o domínio do serviço do fornecedor use o binder (macro binder_user) e adicione o domínio do serviço do fornecedor ao domínio do cliente carwatchdog (carwatchdog_client_domain macro). Confira o código abaixo para sample_client.te e 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 o listener de uso excessivo de recursos herdando BnResourceOveruseListener. Substitua BnResourceOveruseListener::onOveruse para processar notificações de uso excessivo 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 um pool de linhas de execução do binder e registre o listener de uso excessivo de recursos com o servidor watchdog. O servidor watchdog é registrado com o nome de serviço 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);
}

Pesquisar estatísticas de uso excessivo de recursos

Os apps podem consultar o CarWatchdogManager para ver as estatísticas de uso excessivo de E/S específicas do app ATS dos últimos 30 dias.

Cliente Java

Use CarWatchdogManager.getResourceOveruseStats para receber as estatísticas de uso excessivo de recursos. Transmita a flag CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO para receber as estatísticas de uso excessivo de E/S do 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

Use CarWatchdogServer.getResourceOveruseStats para receber as estatísticas de uso excessivo de recursos. Transmita a enumeração ResourceType.IO para buscar estatísticas de uso excessivo de E/S do 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
      }
}

Experiência do usuário de uso excessivo de recursos

As seções a seguir descrevem a experiência do usuário quando ocorre uso excessivo de recursos.

Configuração "Priorizar o desempenho do app"

A página do app Configurações contém configurações paraPrioritize app performance (consulte a imagem abaixo), que permite aos usuários priorizar o desempenho de um app em vez do sistema e do desempenho de hardware a longo prazo. Essa configuração só está disponível para apps que podem ser encerrados em caso de uso excessivo de recursos. Caso contrário, essa configuração será desativada. Quando essa configuração está desativada (a padrão) para um app, ele pode ser encerrado por uso excessivo de recursos. Caso contrário, o app não será encerrado por uso excessivo de recursos.

Quando o usuário ativa essa configuração, a seguinte caixa de diálogo de confirmação descreve as implicações de ativar a configuração:

Após 90 dias, essa configuração é redefinida automaticamente para o padrão. O limite de dias pode ser modificado com um app de sobreposição RRO usando watchdogUserPackageSettingsResetDays, até um máximo de 180 dias. Para saber mais, consulte Mudar o valor dos recursos de um app durante a execução. A tag de sobreposição de exemplo a seguir pode ser incluída em AndroidManifest.xml:

<overlay android:priority="<insert-value>"
      android:targetPackage="com.android.car.updatable"
      android:targetName="CarServiceCustomization"
      android:resourcesMap="@xml/overlays" />

Em res/values/config.xml:

<resources>
  <integer name="watchdogUserPackageSettingsResetDays">value</integer>
</resources>

Em res/xml/overlays.xml:

<overlay>
  <item target="integer/watchdogUserPackageSettingsResetDays" value="@integer/watchdogUserPackageSettingsResetDays" />
</overlay>

Configuração de apps que afetam o desempenho

O app Configurações tem uma seção Apps que afetam o desempenho (consulte a Figura 1). Ao tocar, uma lista de apps que foram restritos devido ao uso excessivo da memória flash e que afetam negativamente o desempenho do sistema é exibida. Isso segue o requisito CDD 3.5.1 [C-1-1].

Apps que afetam o desempenho

Figura 1. Apps que afetam o desempenho.

Os apps encerrados devido ao uso excessivo de recursos são listados aqui (consulte a Figura 2). Os apps listados podem ser priorizados. Para saber mais, consulte Priorizar a configuração de desempenho do app.

Lista de apps encerrados devido ao uso excessivo de recursos

Figura 2. Lista de apps encerrados devido ao uso excessivo de recursos.

Notificação ao usuário

Quando um app ou serviço usa repetidamente E/S de disco em excesso (por exemplo, grava dados no disco além dos limites definidos) em um determinado período e pode ser encerrado por uso excessivo de recursos, o usuário recebe uma notificação depois que o veículo entra no estado "permitir distração do motorista".

A primeira notificação do usuário (durante um trajeto) é postada como um aviso e as outras são postadas na central de notificações.

Por exemplo, quando um app usa demais a E/S de disco, o usuário recebe a seguinte notificação:

  • Quando o usuário clica no botão Priorizar app, a página de configurações do app é aberta, e o usuário pode ativar ou desativar a configuração Priorizar o desempenho do app.
  • Quando o usuário clica no botão Desativar app, o app fica desativado até que o usuário o inicie ou ative na página de configurações do app.
  • Para apps que podem ser desinstalados, o botão Desativar app é substituído pelo botão Desinstalar app. Quando o usuário clica no botão Desinstalar app, a página de configurações do app é aberta, e o usuário pode desinstalar o app.

Recomendação para implementação do acesso rápido

Quando os apps são desativados devido ao uso excessivo de recursos, eles desaparecem do app de início padrão porque o CarService atualiza o estado ativado dos apps como PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED. Os OEMs precisam atualizar a implementação do iniciador integrado para mostrar esses apps como de costume, para que os usuários possam usá-los se necessário. Confira as recomendações a seguir com base na versão do build.

Versão do Android SC V2