Monitore o uso de memória flash

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

Limites de uso excessivo

  • Os limites de uso excessivo de E/S do disco são aplicados diariamente, ou seja, todas as gravações feitas por um aplicativo/serviço são agregadas desde o início do dia atual do calendário UTC 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 do 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 aplicativo excede repetidamente os limites de uso excessivo de E/S de disco definidos, o Watchdog executa ações definidas na configuração de uso excessivo.

  • Todos os aplicativos e serviços do fornecedor são considerados críticos para a estabilidade geral do sistema, portanto, não são encerrados devido ao uso excessivo de E/S do disco. No entanto, a configuração de uso excessivo pode definir uma lista de aplicativos e serviços de fornecedores que podem ser encerrados com segurança.
  • Todos os aplicativos de terceiros podem ser encerrados com segurança.

Quando um aplicativo ou serviço é seguro para encerrar, o Watchdog desativa o aplicativo ou serviço com o estado do componente do aplicativo PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED .

Configuração de uso excessivo

A configuração de uso excessivo contém os limites e 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 a compilação. Os fornecedores podem incluir opcionalmente a configuração do fornecedor na imagem do fornecedor. Quando a configuração do fornecedor não é fornecida, a configuração do sistema também é usada para os aplicativos e serviços do fornecedor.

Watchdog expõe APIs do sistema por meio de CarWatchdogManager , que permite que aplicativos 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 pelo tipo de componente, por exemplo, sistema, fornecedor e terceiro. Os OEMs devem atualizar apenas a configuração dos componentes do fornecedor.

Configuração do fornecedor

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

  • Vendor package prefixes . Todos os pacotes instalados na partição do fornecedor são considerados pacotes do fornecedor. Além desses pacotes, os fornecedores podem classificar pacotes pré-instalados como pacotes de fornecedores adicionando os prefixos de pacote à configuração vendor package prefixes . Esta configuração não aceita expressões regulares.
  • Safe-to-terminate packages . Os fornecedores podem especificar quais pacotes de fornecedores podem ser encerrados com segurança, adicionando os nomes completos dos pacotes à configuração safe-to-terminate packages .
  • Application category mappings . Os fornecedores podem mapear qualquer pacote (incluindo pacotes de terceiros) para uma das duas categorias de aplicativos suportadas: aplicativos de mapas e de mídia. Esse mapeamento é feito para fornecer limites mais altos de uso excessivo de E/S de disco para mapas e aplicativos de mídia, porque esses aplicativos tendem a baixar e gravar mais dados no disco do que outros tipos de aplicativos.
  • Component level thresholds . Define limites genéricos para todos os pacotes do fornecedor (ou seja, pacotes não cobertos por Package specific thresholds ou Application category specific thresholds obtêm esses limites). Os fornecedores devem definir limites diferentes de zero em nível de componente ao definir a configuração de uso excessivo de E/S de disco.
  • Package specific thresholds . Os fornecedores podem definir limites especiais para pacotes de fornecedores específicos. Os mapeamentos devem conter os nomes completos dos pacotes. Os limites definidos nesta configuração têm precedência sobre os limites definidos em outras configurações para um determinado pacote.
  • Application category specific thresholds . Os fornecedores podem especificar limites especiais para categorias específicas de aplicativos. As categorias de aplicativos devem ser uma das categorias suportadas: aplicativos de mapas e mídia. Os limites definidos nesta configuração são mapeados para pacotes específicos usando Application category mappings .
  • System-wide thresholds . Os fornecedores não devem especificar esta configuração.

Vendor package prefixes , Safe-to-terminate packages , Component level thresholds e Package specific thresholds são atualizáveis ​​apenas pela configuração do fornecedor para aplicativos e serviços do fornecedor. A configuração Application category specific thresholds pode ser atualizada somente pela configuração do fornecedor para todos os mapas e aplicativos de mídia.

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

  • Um modo de primeiro plano de aplicativo/serviço versus modo de segundo plano
  • e modo de garagem do sistema.

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

Configurações de sistema e de terceiros

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

  • A configuração do sistema define limites e ações de uso excessivo de E/S para aplicativos e serviços do sistema.
    • Essa configuração também pode atualizar os Application category mappings . Assim, este campo de configuração é compartilhado entre as configurações do sistema e do fornecedor.
  • A configuração de terceiros define limites para todos os aplicativos de terceiros. Todos os aplicativos que não estão pré-instalados no sistema são aplicativos de terceiros.
    • Todos os aplicativos de terceiros recebem os mesmos limites (por exemplo, nenhum aplicativo de terceiros recebe limites especiais), exceto mapas e aplicativos de 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 limites padrão para aplicativos de terceiros. Esses limites são enviados com a imagem do sistema.
      • Gravação de 3 GiB no modo de primeiro plano do aplicativo.
      • Gravação de 2 GiB no modo de segundo plano do aplicativo.
      • Gravação de 4 GiB no modo garagem do sistema.
    • Estes são limites básicos. Esses limites são atualizados à medida que entendemos melhor o uso de E/S do disco.

Uso excessivo do formato XML de configuração

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

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

Um exemplo de configuração XML é fornecido abaixo:

<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 configuração de uso excessivo por meio de APIs do sistema CarWatchdogManager

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

  • Conceda a permissão Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG ao chamador.
  • Deve usar as configurações existentes para atualizar e definir as novas configurações. Use a API CarWatchdogManager.getResourceOveruseConfigurations para obter as configurações existentes. Se as configurações existentes não forem usadas, todas as configurações (incluindo configurações de sistema e de terceiros) serão substituídas, o que não é recomendado.
  • Atualize as configurações existentes com as alterações delta e defina as novas configurações. Não atualize as configurações do sistema e de componentes de terceiros.
  • Use a API CarWatchdogManager.setResourceOveruseConfigurations para definir as novas configurações.
  • Para obter e definir as configurações de uso excessivo de E/S do disco, use o sinalizador CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO .

Aqui está 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();
}

Aplicativos monitorando o uso excessivo de recursos

Aplicativos de fornecedores e de terceiros podem ouvir notificações de uso excessivo de recursos específicos do aplicativo do Watchdog ou pesquisar no CarWatchdogManager as estatísticas de uso excessivo de recursos específicos do aplicativo nos últimos 30 dias.

Ouça notificações de uso excessivo de recursos

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

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

Cliente Java

  1. Implemente o ouvinte 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 ouvinte 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 ouvinte quando o aplicativo 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 construção.

    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 SELinux para permitir que o domínio de serviço do fornecedor use o fichário ( macro binder_user ) e adicione o domínio de serviço do fornecedor ao domínio do cliente carwatchdog (carwatchdog_client_domain macro) . Veja 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 ouvinte de uso excessivo de recursos herdando BnResourceOveruseListener . Substitua BnResourceOveruseListener::onOveruse para lidar com 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 conjunto de encadeamentos do binder e registre o ouvinte de uso excessivo de recursos no servidor watchdog. O servidor Watchdog está 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 aplicativos podem pesquisar o CarWatchdogManager para obter as estatísticas de uso excessivo de E/S específicas do aplicativo ATS nos últimos 30 dias.

Cliente Java

Use CarWatchdogManager.getResourceOveruseStats para obter as estatísticas de uso excessivo de recursos. Passe o sinalizador CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO para obter 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 obter as estatísticas de uso excessivo de recursos. Passe o enum 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
      }
}

UX de uso excessivo de recursos

Priorize a configuração de desempenho do aplicativo

A página de configurações do aplicativo tem as configurações Prioritize app performance (veja a imagem abaixo), que permitem ao usuário priorizar o desempenho de um aplicativo em relação ao sistema e ao desempenho do hardware a longo prazo. Essa configuração está disponível apenas para aplicativos que podem ser encerrados com segurança em caso de uso excessivo de recursos. Caso contrário, esta configuração ficará esmaecida. Quando essa configuração é desativada (configuração padrão) para um aplicativo, o aplicativo pode ser encerrado devido ao uso excessivo de recursos. Caso contrário, o aplicativo não será encerrado devido ao uso excessivo de recursos.

Quando o usuário ativa essa configuração, a caixa de diálogo de confirmação a seguir descreve as implicações da ativação da configuração.

Após 90 dias, essa configuração será redefinida automaticamente para o padrão. O limite de dias pode ser modificado com um aplicativo de sobreposição RRO usando watchdogUserPackageSettingsResetDays , até um máximo de 180 dias. Para saber mais, consulte Alterar o valor dos recursos de um aplicativo em tempo de execução . O exemplo de tag de sobreposição a seguir pode ser incluído 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>

Notificação do usuário

Quando um aplicativo ou serviço usa repetidamente a E/S do disco (por exemplo, grava dados no disco além dos limites definidos) dentro de um determinado período e é seguro para ser encerrado em caso de uso excessivo de recursos, o usuário é notificado depois que o veículo entra no driver de permissão. -estado de distração.

A primeira notificação do usuário (durante uma viagem) é publicada como uma notificação de alerta e as outras notificações são publicadas na central de notificações.

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

  • Quando o usuário clica no botão Priorizar aplicativo , a página de configurações do aplicativo é iniciada, onde o usuário pode ativar ou desativar a configuração Priorizar desempenho do aplicativo .
  • Quando o usuário clica no botão Desativar aplicativo , o aplicativo é desativado até que o usuário o inicie ou o ative na página de configurações do aplicativo.
  • Para aplicativos desinstaláveis, o botão Desativar aplicativo é substituído pelo botão Desinstalar aplicativo . Quando o usuário clica no botão Desinstalar aplicativo , a página Configurações do aplicativo é iniciada, na qual o usuário pode desinstalar o aplicativo.

Recomendação para implementação do lançador

Quando os aplicativos são desabilitados devido ao uso excessivo de recursos, eles desaparecem do aplicativo inicializador padrão porque o CarService atualiza o estado habilitado dos aplicativos como PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED . Os OEMs devem atualizar a implementação do iniciador integrado para exibir esses aplicativos como incomuns, para que os usuários possam usá-los se necessário. Consulte as recomendações a seguir com base na versão do build.

Lançamento do Android SC V2