Monitorare l'utilizzo della memoria flash

Watchdog monitora l'utilizzo della memoria flash monitorando la quantità totale di scritture I/O su disco eseguite da tutte le app e i servizi utilizzando le statistiche I/O su disco per UID esposte dal kernel nella posizione `/proc/uid_io/stats`. Quando un'app o un servizio supera la soglia di utilizzo eccessivo dell'I/O su disco, Watchdog esegue azioni sull' app o sul servizio. Le soglie di utilizzo eccessivo dell'I/O su disco e l'azione da intraprendere in caso di utilizzo eccessivo sono predefinite nella configurazione di utilizzo eccessivo dell'I/O su disco.

Soglie di utilizzo eccessivo

  • Le soglie di utilizzo eccessivo dell'I/O su disco vengono applicate quotidianamente, ovvero tutte le scritture eseguite da un'app/servizio vengono aggregate dall'inizio del giorno di calendario UTC corrente e confrontate con le soglie definite nelle configurazioni di utilizzo eccessivo.
  • Quando un veicolo viene avviato più volte in un determinato giorno, il modulo Watchdog memorizza le statistiche di utilizzo dell'I/O su disco nella memoria flash e le aggrega dall' inizio del giorno di calendario UTC corrente.

Azioni in caso di utilizzo eccessivo

Quando un'app supera ripetutamente le soglie di utilizzo eccessivo dell'I/O su disco definite, Watchdog esegue le azioni definite nella configurazione di utilizzo eccessivo.

  • Tutte le app e i servizi del fornitore sono considerati fondamentali per la stabilità complessiva del sistema, pertanto non vengono terminati in caso di utilizzo eccessivo dell'I/O su disco. Tuttavia, la configurazione di utilizzo eccessivo può definire un elenco di app e servizi del fornitore che possono essere terminati in sicurezza.
  • Tutte le app di terze parti possono essere terminate in sicurezza.

Quando un'app o un servizio può essere terminato in sicurezza, Watchdog disattiva l'app o il servizio con lo stato del componente dell'app PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED .

Configurazione di utilizzo eccessivo

La configurazione di utilizzo eccessivo contiene le soglie e le azioni di utilizzo eccessivo dell'I/O su disco. Le configurazioni di utilizzo eccessivo predefinite sono definite nelle immagini di sistema e del fornitore e vengono fornite con la build. I fornitori possono includere facoltativamente la configurazione del fornitore nell'immagine del fornitore. Se la configurazione del fornitore non viene fornita, viene utilizzata anche la configurazione di sistema per le app e i servizi del fornitore.

Watchdog espone le API di sistema tramite CarWatchdogManager, che consente alle app o ai servizi dei fornitori di aggiornare la configurazione del fornitore in qualsiasi momento.

Definizione della configurazione di utilizzo eccessivo

La configurazione di utilizzo eccessivo è suddivisa per tipo di componente, ad esempio sistema, fornitore e terze parti. Gli OEM devono aggiornare solo la configurazione del componente del fornitore.

Configurazione del fornitore

La configurazione del fornitore definisce le soglie e le azioni di utilizzo eccessivo dell'I/O su disco per tutte le app e i servizi del fornitore, nonché per tutte le app di mappe e multimediali. La configurazione contiene i seguenti campi di configurazione.

  • Prefissi dei pacchetti del fornitore. Tutti i pacchetti installati nella partizione del fornitore sono considerati pacchetti del fornitore. Oltre a questi pacchetti, i fornitori possono classificare i pacchetti preinstallati come pacchetti del fornitore aggiungendo i prefissi dei pacchetti alla configurazione Prefissi dei pacchetti del fornitore. Questa configurazione non accetta espressioni regolari.
  • Pacchetti che possono essere terminati in sicurezza. I fornitori possono specificare quali pacchetti del fornitore possono essere terminati in sicurezza aggiungendo i nomi completi dei pacchetti alla configurazione Pacchetti che possono essere terminati in sicurezza.
  • Mappature delle categorie di applicazioni. I fornitori possono mappare qualsiasi pacchetto (inclusi i pacchetti di terze parti) a una delle due categorie di app supportate: app di mappe e app multimediali. Questa mappatura viene eseguita per fornire alle app di mappe e multimediali soglie di utilizzo eccessivo dell'I/O su disco più elevate, perché queste app tendono a scaricare e scrivere più dati su disco rispetto ad altri tipi di app.
  • Soglie a livello di componente. Definisce le soglie generiche per tutti i pacchetti del fornitore (ovvero i pacchetti non coperti da Soglie specifiche per pacchetto o Soglie specifiche per categoria di applicazioni ricevono queste soglie). I fornitori devono definire soglie a livello di componente diverse da zero quando definiscono la configurazione di utilizzo eccessivo dell'I/O su disco.
  • Soglie specifiche per pacchetto. I fornitori possono definire soglie speciali per pacchetti specifici del fornitore. Le mappature devono contenere i nomi completi dei pacchetti. Le soglie definite in questa configurazione hanno la precedenza sulle soglie definite in altre configurazioni per un determinato pacchetto.
  • Soglie specifiche per categoria di applicazioni. I fornitori possono specificare soglie speciali per categorie di app specifiche. Le categorie di app devono essere una delle categorie supportate: app di mappe e app multimediali. Le soglie definite in questa configurazione vengono mappate a pacchetti specifici utilizzando Mappature delle categorie di applicazioni.
  • Soglie a livello di sistema. I fornitori non devono specificare questa configurazione.

Le configurazioni Prefissi dei pacchetti del fornitore, Pacchetti che possono essere terminati in sicurezza, Soglie a livello di componente e Soglie specifiche per pacchetto possono essere aggiornate solo dalla configurazione del fornitore per le app e i servizi del fornitore. La configurazione Soglie specifiche per categoria di applicazioni può essere aggiornata solo dalla configurazione del fornitore per tutte le app di mappe e multimediali.

Le soglie di utilizzo eccessivo contengono la quantità di byte che possono essere scritti durante:

  • La modalità in primo piano o in background di un'app o di un servizio
  • La modalità garage del sistema

Questa classificazione consente alle app e ai servizi in primo piano rivolti agli utenti di scrivere più dati rispetto alle app e ai servizi in background. In modalità garage, le app e i servizi tendono a scaricare gli aggiornamenti, quindi ognuno ha bisogno di una soglia più alta rispetto alle app e ai servizi in esecuzione in altre modalità.

Configurazioni di sistema e di terze parti

Gli OEM non devono aggiornare le configurazioni di sistema e di terze parti.

  • La configurazione di sistema definisce le soglie e le azioni di utilizzo eccessivo dell'I/O per le app e i servizi di sistema.
    • Questa configurazione può anche aggiornare le Mappature delle categorie di applicazioni. Pertanto, questo campo di configurazione è condiviso tra le configurazioni di sistema e del fornitore configurazioni.
  • La configurazione di terze parti definisce le soglie per tutte le app di terze parti. Tutte le app non preinstallate nel sistema sono app di terze parti.
    • Tutte le app di terze parti ricevono le stesse soglie (ad esempio, nessuna app di terze parti riceve soglie speciali), ad eccezione delle app di mappe e multimediali, le cui soglie sono definite dalla configurazione del fornitore.
    • Le soglie di utilizzo eccessivo dell'I/O su disco riportate di seguito sono le soglie predefinite per le app di terze parti. Queste soglie vengono fornite con l'immagine di sistema.
      • 3 GiB di scrittura in modalità in primo piano dell'app.
      • 2 GiB di scrittura in modalità in background dell'app.
      • 4 GiB di scrittura in modalità garage del sistema.
    • Queste sono le soglie di base. Queste soglie vengono aggiornate man mano che vengono acquisite maggiori informazioni sull'utilizzo dell'I/O su disco.

Formato XML della configurazione di utilizzo eccessivo

(Facoltativo) In Android 16 e versioni successive, puoi inserire la configurazione predefinita del fornitore in /vendor/etc/io-watchdog/resource_overuse_configuration.xml nell'immagine della build.

In Android 15 e versioni precedenti, puoi inserire la configurazione predefinita del fornitore in /vendor/etc/watchdog/resource_overuse_configuration.xml nell'immagine della build. Se questa configurazione non viene specificata, viene applicata anche la configurazione definita dal sistema per le app e i servizi del fornitore.

Il file XML deve contenere un solo tag per ogni campo di configurazione. La configurazione di utilizzo eccessivo dell'I/O deve essere definita nel file XML. Tutti i valori di soglia devono essere specificati in MiB.

Di seguito è riportata una configurazione XML di esempio:

<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>

Aggiornare la configurazione di utilizzo eccessivo tramite le API di sistema CarWatchdogManager

La configurazione XML riportata sopra può essere fornita solo nell'immagine della build. Se un OEM sceglie di aggiornare la configurazione sul dispositivo dopo il rilascio di una build, può utilizzare le seguenti API per apportare modifiche alla configurazione sul dispositivo.

  • Concedi l'autorizzazione Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG al chiamante.
  • Devi utilizzare le configurazioni esistenti per aggiornare e impostare le nuove configurazioni. Utilizza l'API CarWatchdogManager.getResourceOveruseConfigurations per ottenere le configurazioni esistenti. Se non vengono utilizzate le configurazioni esistenti, tutte le configurazioni (incluse le configurazioni di sistema e di terze parti) vengono sovrascritte, il che non è consigliabile.
  • Aggiorna le configurazioni esistenti con le modifiche delta e imposta le nuove configurazioni. Non aggiornare le configurazioni dei componenti di sistema e di terze parti.
  • Utilizza l'API CarWatchdogManager.setResourceOveruseConfigurations per impostare le nuove configurazioni.
  • Per ottenere e impostare le configurazioni di utilizzo eccessivo dell'I/O su disco, utilizza il flag CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO.

Ecco un'implementazione di esempio che aggiorna le configurazioni di utilizzo eccessivo delle risorse:

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

App che monitorano l'utilizzo eccessivo delle risorse

Le app di fornitori e di terze parti possono ascoltare le notifiche di utilizzo eccessivo delle risorse specifiche dell'app da Watchdog o eseguire il polling di CarWatchdogManager per le statistiche di utilizzo eccessivo delle risorse specifiche dell'app per un massimo di 30 giorni.

Ascoltare le notifiche di utilizzo eccessivo delle risorse

Le app possono implementare un listener di utilizzo eccessivo delle risorse e registrarlo con CarWatchdogManager per ricevere notifiche specifiche dell'app quando superano l'80% o il 100% delle soglie di utilizzo eccessivo dell'I/O su disco. Le app possono utilizzare queste notifiche per:

  • Registrare le statistiche di utilizzo eccessivo dell'I/O su disco per l'analisi offline. Gli sviluppatori di app possono utilizzare questa registrazione per eseguire il debug del problema di utilizzo eccessivo dell'I/O su disco.
  • Ridurre le scritture I/O su disco fino al ripristino dei contatori di utilizzo eccessivo.

Client Java

  1. Implementa il listener ereditando CarWatchdogManager.ResourceOveruseListener: 
    class ResourceOveruseListenerImpl implements
      CarWatchdogManager.ResourceOveruseListener {
            @Override
            public void onOveruse(
                  @NonNull ResourceOveruseStats resourceOveruseStats) {
                  // 1. Log/Upload resource overuse metrics.
                  // 2. Reduce writes until the counters reset.

                  IoOveruseStats ioOveruseStats = resourceOveruseStats.getIoOveruseStats();
                  // Stats period - [ioOveruseStats.getStartTime(), ioOveruseStats.getStartTime()
                  //   + ioOveruseStats.getDurationInSeconds()]
                  // Total I/O overuses - ioOveruseStats.getTotalOveruses()
                  // Total bytes written - ioOveruseStats.getTotalBytesWritten()
                  // Remaining write bytes for the current UTC calendar day -
                  //    ioOveruseStats.getRemainingWriteBytes()
            }
      }
}
  2. Registra l'istanza del listener chiamando 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. Annulla la registrazione dell'istanza del listener quando l'app ha finito di ascoltare: 
    private void removeResourceOveruseListener() {
    CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
    mCarWatchdogManager.removeResourceOveruseListener(
          mListenerImpl);
}

Client nativo

  1. Includi carwatchdog_aidl_interface-ndk_platform nella shared_libs dipendenza della regola di build.

    Android.bp

    cc_binary {
    name: "sample_native_client",
    srcs: [
        "src/*.cpp"
    ],
    shared_libs: [
        "carwatchdog_aidl_interface-ndk_platform",
        "libbinder_ndk",
    ],
    vendor: true,
}
  2. Aggiungi il criterio SELinux per consentire al dominio del servizio del fornitore di utilizzare il binder (binder_user macro) e aggiungi il dominio del servizio del fornitore al carwatchdog dominio client (carwatchdog_client_domain macro). Consulta il codice riportato di seguito per 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. Implementa il listener di utilizzo eccessivo delle risorse ereditando BnResourceOveruseListener. Esegui l'override di BnResourceOveruseListener::onOveruse per gestire le notifiche di utilizzo eccessivo delle risorse.

    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. Avvia un pool di thread binder e registra il listener di utilizzo eccessivo delle risorse con il server watchdog. Il server watchdog è registrato con il nome del servizio 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);
}

Eseguire il polling delle statistiche di utilizzo eccessivo delle risorse

Le app possono eseguire il polling di CarWatchdogManager per le statistiche di utilizzo eccessivo dell'I/O specifiche dell'app per gli ultimi 30 giorni.

Client Java

Utilizza CarWatchdogManager.getResourceOveruseStats per ottenere le statistiche di utilizzo eccessivo delle risorse. Passa il flag CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO per ottenere le statistiche di utilizzo eccessivo dell'I/O su 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()
}

Client nativo

Utilizza CarWatchdogServer.getResourceOveruseStats per ottenere le statistiche di utilizzo eccessivo delle risorse. Passa l'enumerazione ResourceType.IO per recuperare le statistiche di utilizzo eccessivo dell'I/O su 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
      }
}

Esperienza utente di utilizzo eccessivo delle risorse

Le sezioni seguenti descrivono l'esperienza utente quando si verifica un utilizzo eccessivo delle risorse.

Impostazione Priorità a prestazioni dell'app

La pagina Impostazioni dell'app contiene le impostazioni perPrioritize app performance (vedi l'immagine di seguito), che consente agli utenti di dare la priorità alle prestazioni di un'app rispetto alle prestazioni del sistema e dell'hardware a lungo termine. Questa impostazione è disponibile solo per le app che possono essere terminate in sicurezza in caso di utilizzo eccessivo delle risorse. In caso contrario, questa impostazione è disattivata. Quando questa impostazione è disattivata (impostazione predefinita) per un'app, l'app può essere terminata in caso di utilizzo eccessivo delle risorse. In caso contrario, l'app non viene terminata in caso di utilizzo eccessivo delle risorse.

Quando l'utente attiva questa impostazione, la seguente finestra di dialogo di conferma descrive le implicazioni dell'attivazione dell'impostazione:

Dopo 90 giorni, questa impostazione viene reimpostata automaticamente sul valore predefinito. Il limite giornaliero può essere modificato con un'app di overlay RRO utilizzando watchdogUserPackageSettingsResetDays, fino a un massimo di 180 giorni. Per scoprire di più, consulta Modificare il valore delle risorse di un'app in fase di runtime. Il seguente tag di overlay di esempio può essere incluso in AndroidManifest.xml:

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

In res/values/config.xml:

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

In res/xml/overlays.xml:

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

Impostazione App che influiscono sulle prestazioni

L'app Impostazioni contiene una sezione App che influiscono sulle prestazioni (vedi la Figura 1). Quando viene toccata, viene visualizzato un elenco di app che sono state limitate a causa dell'utilizzo eccessivo della memoria flash e che influiscono negativamente sulle prestazioni del sistema. Questo soddisfa il requisito CDD 3.5.1 [C-1-1].

App che influiscono sulle prestazioni

Figura 1. App che influiscono sulle prestazioni.

Le app terminate a causa dell'utilizzo eccessivo delle risorse sono elencate qui (vedi la Figura 2). È possibile dare la priorità alle app elencate. Per scoprire di più, consulta Impostazione Priorità a prestazioni dell'app.

Elenco delle app terminate a causa dell&#39;uso eccessivo delle risorse

Figura 2. Elenco delle app terminate a causa dell'utilizzo eccessivo delle risorse.

Notifica all'utente

Quando un'app o un servizio utilizza ripetutamente l'I/O su disco in modo eccessivo (ad esempio, scrive dati su disco oltre le soglie definite) entro un determinato periodo e può essere terminato in sicurezza in caso di utilizzo eccessivo delle risorse, l'utente riceve una notifica dopo che il veicolo entra nello stato allow-driver-distraction.

La prima notifica all'utente (durante la guida) viene pubblicata come notifica heads-up, mentre le altre notifiche vengono pubblicate nel Centro notifiche.

Ad esempio, quando un'app utilizza ripetutamente l'I/O su disco in modo eccessivo, l'utente riceve la seguente notifica:

  • Quando l'utente fa clic sul pulsante Dai la priorità all'app, viene avviata la pagina delle impostazioni dell'app, in cui l'utente può attivare o disattivare l'impostazione Dai la priorità alle prestazioni dell'app.
  • Quando l'utente fa clic sul pulsante Disattiva app, l'app viene disattivata finché l'utente non la avvia o la attiva nella pagina delle impostazioni dell'app.
  • Per le app non disinstallabili, il pulsante Disattiva app viene sostituito dal pulsante Disinstalla app. Quando l'utente fa clic sul Disinstalla app pulsante, viene avviata la pagina delle impostazioni dell'app, da cui l'utente può disinstallare l'app.

Consigli per l'implementazione dell'avvio app

Quando le app vengono disattivate a causa dell'utilizzo eccessivo delle risorse, scompaiono dall' app di avvio predefinita perché CarService aggiorna lo stato di attivazione delle app come PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED. Gli OEM devono aggiornare l'implementazione dell'avvio app integrato per visualizzare queste app come di consueto, in modo che gli utenti possano utilizzarle se necessario. Consulta i seguenti consigli in base alla release della build.

Release di Android SC V2