Monitorare l'utilizzo della memoria flash

Watchdog monitora l'utilizzo della memoria flash monitorando la quantità totale di scrittura I/O su disco eseguita 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 I/O su disco, Watchdog esegue azioni sull'app o sul servizio. Le soglie di utilizzo eccessivo dell'I/O del disco e l'azione da intraprendere in caso di utilizzo eccessivo sono predefinite nella configurazione dell'utilizzo eccessivo dell'I/O del disco.

Soglie di utilizzo eccessivo

  • Le soglie di utilizzo eccessivo dell'I/O del disco vengono applicate su base giornaliera, ovvero tutte le scritture effettuate da un'app/un 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 I/O del disco nella memoria flash e le aggrega dall'inizio del giorno di calendario UTC corrente.

Azioni per il sovrautilizzo

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

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

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

Configurazione del sovrautilizzo

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

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

Definizione della configurazione per il sovrautilizzo

La configurazione del sovrautilizzo è suddivisa in base al 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 per l'utilizzo eccessivo di I/O del 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 prefiss pacchetti del fornitore. Questa configurazione non accetta espressioni regolari.
  • Pacchetti che possono essere chiusi in sicurezza. I fornitori possono specificare quali pacchetti del fornitore possono essere chiusi in sicurezza aggiungendo i nomi completi dei pacchetti alla configurazione dei pacchetti che possono essere chiusi in sicurezza.
  • Mappature delle categorie di applicazione. I fornitori possono mappare qualsiasi pacchetto (inclusi i pacchetti di terze parti) a una delle due categorie di app supportate: mappe e media. Questa mappatura viene eseguita per fornire a mappe e app multimediali soglie di utilizzo eccessivo dell'I/O del disco più elevate, in quanto queste app tendono a scaricare e scrivere più dati sul disco rispetto ad altri tipi di app.
  • Soglie a livello di componente. Definisce soglie generiche per tutti i pacchetti del fornitore (ovvero i pacchetti non coperti dalle soglie specifiche per pacchetto o dalle soglie specifiche per categoria di applicazione). I fornitori devono definire soglie a livello di componente diverse da zero quando definiscono la configurazione per l'utilizzo eccessivo dell'I/O del disco.
  • Soglie specifiche per pacchetto. I fornitori possono definire soglie speciali per pacchetti specifici. 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 applicazione. 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 media. Le soglie definite in questa configurazione vengono mappate a pacchetti specifici utilizzando le mappature delle categorie di applicazioni.
  • Soglie a livello di sistema. I fornitori non devono specificare questa configurazione.

Le configurazioni Prefisso del pacchetto del fornitore, Pacchetti sicuri da terminare, Soglie a livello di componente e Soglie specifiche per il pacchetto sono aggiornabili solo dalla configurazione del fornitore per app e servizi del fornitore. La configurazione delle soglie specifiche per la categoria dell'applicazione 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 consentita per la scrittura durante:

  • Modalità in primo piano di un'app o di un servizio rispetto alla modalità in background
  • 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 aggiornamenti, pertanto ognuno richiede una soglia più elevata rispetto alle app e ai servizi in esecuzione in altre modalità.

Configurazioni di sistema e di terze parti

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

  • La configurazione di sistema definisce le soglie e le azioni per l'utilizzo eccessivo di 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 del sistema e del fornitore.
  • 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 media, le cui soglie sono definite dalla configurazione del fornitore.
    • Le seguenti soglie di utilizzo eccessivo dell'I/O del disco sono le soglie predefinite per le app di terze parti. Queste soglie vengono fornite con l'immagine di sistema.
      • Scrittura di 3 GB nella modalità in primo piano dell'app.
      • Scrittura di 2 GB in modalità in background dell'app.
      • Scrittura di 4 GiB in modalità garage del sistema.
    • Si tratta di soglie di base. Queste soglie vengono aggiornate man mano che si apprende di più sull'utilizzo dell'I/O del disco.

Formato XML della configurazione per l'utilizzo eccessivo

La configurazione predefinita del fornitore può essere posizionata (facoltativa) nella posizione /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml nell'immagine di compilazione. Se questa configurazione non è specificata, la configurazione definita dal sistema viene applicata anche per le app e i servizi del fornitore.

Il file XML deve contenere un solo tag per ogni campo di configurazione. La configurazione per l'utilizzo eccessivo di 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>

Aggiorna la configurazione dell'uso eccessivo tramite le API di sistema CarWatchdogManager

La configurazione XML riportata sopra può essere fornita solo nell'immagine di compilazione. 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 recuperare le configurazioni esistenti. Se le configurazioni esistenti non vengono utilizzate, tutte le configurazioni (incluse quelle 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 del sistema e dei componenti 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 del disco, utilizza il flag CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO.

Ecco un esempio di implementazione che aggiorna le configurazioni relative all'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 relative all'utilizzo eccessivo delle risorse specifiche dell'app da Watchdog o eseguire il polling CarWatchdogManager per le statistiche sull'utilizzo eccessivo delle risorse specifiche dell'app fino agli ultimi 30 giorni.

Ascolta le notifiche relative all'utilizzo eccessivo delle risorse

Le app possono implementare un ascoltatore 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 I/O del disco. Le app possono utilizzare queste notifiche per:

  • Registra le statistiche sull'utilizzo eccessivo dell'I/O del disco per l'analisi offline. Gli sviluppatori di app possono utilizzare questo logging per eseguire il debug del problema di utilizzo eccessivo dell'I/O del disco.
  • Riduci le scritture I/O del disco fino al ripristino dei contatori di utilizzo eccessivo.

Client Java

  1. Implementa l'ascoltatore 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 di 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. Annullare la registrazione dell'istanza di listener quando l'app ha terminato 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 dipendenza shared_libs della regola di compilazione.

    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 di servizio del fornitore di utilizzare Binder (macro binder_user) e aggiungi il dominio di servizio del fornitore al dominio client carwatchdog (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 l'ascoltatore per l'utilizzo eccessivo delle risorse ereditando BnResourceOveruseListener. Sostituisci BnResourceOveruseListener::onOveruse per gestire le notifiche relative all'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 del binder e registra l'ascoltatore per l'utilizzo eccessivo delle risorse con il server watchdog. Il server di monitoraggio è 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);
}

Statistiche sul sovrautilizzo delle risorse del sondaggio

Le app possono eseguire il polling di CarWatchdogManager per le statistiche ATS relative all'uso eccessivo I/O specifico dell'app per i 30 giorni più recenti.

Client Java

Utilizza CarWatchdogManager.getResourceOveruseStats per visualizzare le statistiche sull'utilizzo eccessivo delle risorse. Passa il flag CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO per ottenere le statistiche sull'utilizzo eccessivo dell'I/O del disco.

private void getResourceOveruseStats() {
      CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);

      // Returns resource overuse stats with I/O overuse stats for the past
      // 7 days. Stats are available for up to the past 30 days.
      ResourceOveruseStats resourceOveruseStats =
            mCarWatchdogManager.getResourceOveruseStats(
                  CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO,
                  CarWatchdogManager.STATS_PERIOD_PAST_7_DAYS);

      IoOveruseStats ioOveruseStats = resourceOveruseStats.getIoOveruseStats();
      // Stats period - [ioOveruseStats.getStartTime(), ioOveruseStats.getStartTime()
      //   + ioOveruseStats.getDurationInSeconds()]
      // Total I/O overuses - ioOveruseStats.getTotalOveruses()
      // Total bytes written - ioOveruseStats.getTotalBytesWritten()
      // Remaining write bytes for the UTC calendar day -
      //    ioOveruseStats.getRemainingWriteBytes()
}

Client nativo

Utilizza CarWatchdogServer.getResourceOveruseStats per visualizzare le statistiche sull'utilizzo eccessivo delle risorse. Passa l'enum ResourceType.IO per recuperare le statistiche sull'uso eccessivo dell'I/O 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 per l'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à al rendimento di un'app rispetto al sistema e al rendimento hardware a lungo termine. Questa impostazione è disponibile solo per le app che possono essere chiuse in caso di utilizzo eccessivo delle risorse. In caso contrario, questa impostazione è disattivata. Se questa impostazione è disattivata (impostazione predefinita) per un'app, l'app può essere interrotta in caso di utilizzo eccessivo delle risorse. In caso contrario, l'app non viene interrotta 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:

Dopo 90 giorni, questa impostazione viene reimpostata automaticamente su quella predefinita. Il limite di giorni può essere modificato con un'app 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 esecuzione. Il seguente esempio di tag overlay 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>

Impostazioni delle app che influiscono sulle prestazioni

L'app Impostazioni contiene una sezione App che influiscono sul rendimento (vedi Figura 1). Se viene toccato, viene visualizzato un elenco di app che sono state limitate a causa dell'uso eccessivo della memoria flash e che influiscono negativamente sulle prestazioni del sistema. Questo segue 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 di un utilizzo eccessivo delle risorse sono elencate qui (vedi Figura 2). Alle app elencate può essere assegnata una priorità. Per scoprire di più, consulta Impostare la priorità al rendimento dell'app.

Elenco di app interrotte a causa di un utilizzo eccessivo delle risorse

Figura 2. Elenco di app interrotte a causa di un utilizzo eccessivo delle risorse.

Notifica all'utente

Quando un'app o un servizio fa un uso eccessivo dell'I/O del disco (ad esempio, scrive dati sul disco oltre le soglie definite) in un determinato periodo ed è sicuro che venga interrotto in caso di utilizzo eccessivo delle risorse, l'utente riceve una notifica dopo che il veicolo entra nello stato di distrazione del conducente consentita.

La prima notifica utente (durante la guida) viene pubblicata come notifica di avviso, mentre le altre notifiche vengono pubblicate nel centro notifiche.

Ad esempio, quando un'app utilizza ripetutamente in modo eccessivo l'I/O del disco, 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à al rendimento 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 disinstallabili, il pulsante Disattiva app è sostituita dal pulsante Disinstalla app. Quando l'utente fa clic sul pulsante Disinstalla app, viene avviata la pagina Impostazioni dell'app, da cui può disinstallarla.

Consiglio per l'implementazione del programma di avvio

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

Release di Android SC V2