Monitorar o uso de memória flash

O watchdog monitora o uso da memória flash rastreando a quantidade total de E/S do disco. gravações feitas por todos os apps e serviços usando as estatísticas de E/S do disco por UID expostos pelo kernel no local `/proc/uid_io/stats`. Quando um app ou serviço exceder o limite de uso excessivo de E/S do disco, o watchdog age app ou serviço. Os limites de uso excessivo de E/S de disco e a ação a ser tomada sobre o uso excessivo é predefinido 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, gravações feitas por um aplicativo/serviço são agregadas desde o início do dia do calendário UTC atual e verificado em relação aos limites definidos no 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 do disco na memória flash e as agrega, uma vez que o início do dia atual em UTC.

Ações por uso excessivo

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

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

Quando é seguro encerrar um app ou serviço, o watchdog desativa o app ou serviço com o app estado do componente PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED :

Configuração de uso excessivo

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

O Watchdog expõe APIs do sistema pelo CarWatchdogManager, que permite os apps ou serviços dos fornecedores atualizam a configuração do fornecedor a qualquer momento.

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

A configuração de uso excessivo é dividida pelo tipo de componente, por exemplo, sistema, fornecedor, e por 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 do disco para todos os apps e serviços do fornecedor e todos os apps de mapas e mídia. A contém os campos de configuração abaixo.

  • Prefixos dos pacotes de fornecedores: Todos os pacotes instalados no são considerados pacotes de fornecedor. Além dessas pacotes, os fornecedores podem classificar pacotes pré-instalados como pacotes de fornecedor adicionando os prefixos de pacote à configuração de prefixos de pacote do fornecedor; Esta configuração não aceita expressões regulares.
  • Pacotes com segurança para encerrar. Os fornecedores podem especificar qual fornecedor pacotes são seguros para serem encerrados adicionando os nomes completos dos pacotes ao safe-to-terminate packages.
  • Mapeamentos de categorias de aplicativos. Os fornecedores podem mapear qualquer pacote (incluindo pacotes de terceiros) para um dos dois apps compatíveis categorias: apps de mapas e mídia. Esse mapeamento é feito para fornecer mapas e apps de mídia maiores limites de uso excessivo de E/S de disco porque esses os apps tendem a fazer o download e gravar mais dados em disco do que outros apps. tipos
  • Limites no nível do componente. Define limites genéricos para todos pacotes de fornecedores (ou seja, pacotes não cobertos pelos Termos de Serviço específicos limites ou Limites específicos de categorias de aplicativo esses limites. Os fornecedores precisam definir limites de componente diferentes de zero quando que define a configuração de uso excessivo de E/S do disco.
  • Limites específicos de pacote. Os fornecedores podem definir limites para pacotes de fornecedores específicos. Os mapeamentos devem conter o de pacotes completos. Os limites definidos nesta configuração têm precedência acima dos limites definidos em outras configurações para um determinado pacote.
  • Limites específicos de categorias de aplicativos. Os fornecedores podem especificar limites especiais para categorias específicas de aplicativos. O app As categorias precisam ser uma das opções aceitas: mapas e mídia apps. Os limites definidos nessa configuração são mapeados para determinados pacotes usando mapeamentos de categoria de aplicativo.
  • Limites do sistema. Os fornecedores não podem especificar essa configuração.

Prefixos de pacotes de fornecedores, Pacotes com segurança para encerrar Limites no nível do componente e Específico do pacote de limite são atualizáveis apenas pela configuração do fornecedor para aplicativos e serviços de fornecedores. Específico para categoria do aplicativo limites pode ser atualizada apenas pela configuração do fornecedor para todos mapas e mídia.

Os limites de uso excessivo contêm a quantidade de bytes permitidos para gravação durante:

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

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

Configurações do sistema e de terceiros

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

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

Uso excessivo do formato XML de configuração

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

O arquivo XML precisa conter apenas uma tag para cada campo de configuração. Uso excessivo de E/S precisa ser definida no arquivo XML. Todos os valores de limite devem ser especificado 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 com as APIs do sistema CarWatchdogManager

A configuração XML acima só pode ser fornecida na imagem do build. Se um O OEM decide atualizar a configuração no dispositivo após o lançamento de um build, eles podem 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 os para criar novas configurações. Usar a API CarWatchdogManager.getResourceOveruseConfigurations para acessar as configurações atuais. Se as configurações atuais não forem usadas, todas (incluindo configurações do sistema e de terceiros) são substituído, o que não é recomendado.
  • Atualizar as configurações atuais com as alterações delta e definir as novas personalizadas. Não atualize o sistema e os componentes de terceiros. personalizadas.
  • Usar a API CarWatchdogManager.setResourceOveruseConfigurations para definir as novas configurações.
  • Para receber e definir as configurações de uso excessivo de E/S do 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 que monitoram o uso excessivo de recursos

Os apps dos fornecedores e de terceiros podem detectar recursos específicos do app usar notificações excessivas do Watchdog ou fazer enquetes com CarWatchdogManager sobre o app estatísticas específicas de uso excessivo de recursos dos últimos 30 dias.

Detectar notificações de uso excessivo de recursos

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

  • Registrar as estatísticas de uso excessivo de E/S do disco para análise off-line. Aplicativo os desenvolvedores podem usar esse registro para depurar o problema de uso excessivo de E/S de disco.
  • Reduza as gravações de E/S do 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 detectar: 
    private void removeResourceOveruseListener() {
    CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
    mCarWatchdogManager.removeResourceOveruseListener(
          mListenerImpl);
}

Cliente nativo

  1. Inclua carwatchdog_aidl_interface-ndk_platform no 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. Adicionar uma política de SELinux para permitir que o domínio de serviço do fornecedor use o binder (macro binder_user) e adicione o domínio de serviço do fornecedor ao carwatchdog domínio do cliente (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 ao herdar BnResourceOveruseListener: Substituir BnResourceOveruseListener::onOveruse para lidar com o uso excessivo de recursos notificações.

    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. Iniciar um pool de linhas de execução de vinculação e registrar o listener de uso excessivo de recursos com o servidor de watchdog. O servidor de watchdog está registrado sob o nome do 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 pesquisar o CarWatchdogManager quanto ao uso excessivo de E/S específico do app ATS de estatísticas dos últimos 30 dias.

Cliente Java

Use CarWatchdogManager.getResourceOveruseStats para receber estatísticas de uso excessivo de recursos. Transmita o 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 estatísticas de uso excessivo de recursos. Transmitir o tipo enumerado ResourceType.IO para buscar o uso excessivo de E/S do disco estatí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
      }
}

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

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

Configuração "Priorizar o desempenho do app"

A página Configurações do app contém as configurações do Prioritize app performance (veja a imagem abaixo), o que permite que os usuários priorizem o desempenho de um app em relação ao sistema e o desempenho de hardware a longo prazo. Essa configuração está disponível apenas para apps seguros são encerrados por uso excessivo de recursos. Caso contrário, a configuração será desativada. Quando essa configuração é desativado (configuração padrão) para um app, ele poderá ser encerrado se houver 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 a implicações da ativação da 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 de RRO usando watchdogUserPackageSettingsResetDays. em até 180 dias. Para saber mais, consulte Mudar o valor dos recursos de um app no momento da execução. A a seguir, é possível incluir uma tag de sobreposição 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. (veja a Figura 1). Quando tocado, uma lista de apps que foram restritos devido à memória flash em excesso e que impactem negativamente o desempenho do sistema. Isso segue Requisito do C-1-1]do C-1-1.

Apps que afetam o desempenho

Figura 1. Apps que afetam o desempenho

Os apps encerrados por uso excessivo de recursos estão listados aqui (veja a Figura 2). Os apps listados podem ser priorizados. Para saber mais, consulte Priorize 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 (por exemplo, gravações dados para o disco além dos limites definidos) dentro de um determinado período e é seguro seja encerrado por uso excessivo de recursos, o usuário será notificado quando o veículo entrar o estado allow-driver-distraction.

A primeira notificação ao usuário (durante uma viagem) é postada como um alerta e as outras notificações serão postadas nela. de eventos.

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

  • Quando o usuário clica no botão Priorizar app, o página de configurações do app é aberta, onde o usuário pode ativar ou desativar 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 inicie o aplicativo ou o ative no na página de configurações.
.
  • No caso de apps desinstaláveis, o botão Desativar app estará substituído pelo botão Desinstalar app. Quando o usuário clica Botão Desinstalar app, a página "Configurações" do app é aberta. do qual o usuário pode desinstalar o app.

Recomendação para implementação da tela de início

Quando os aplicativos são desativados devido ao uso excessivo de recursos, eles desaparecem do padrão da tela de início porque o CarService atualiza ativado como PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED: Os OEMs precisam atualizar a implementação da tela de início integrada para exibir esses apps como incomuns, 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 SC V2 do Android

.