Flash-Speichernutzung überwachen

Watchdog überwacht die Nutzung des Flash-Speichers, indem die Gesamtzahl der von allen Apps und Diensten ausgeführten Disk-I/O-Schreibvorgänge anhand der vom Kernel unter `/proc/uid_io/stats` bereitgestellten Disk-I/O-Statistiken pro UID erfasst wird. Wenn eine App oder ein Dienst den Grenzwert für die übermäßige Nutzung von Disk-I/O überschreitet, ergreift Watchdog Maßnahmen für die App oder den Dienst. Die Grenzwerte für die Überbeanspruchung der Laufwerks-E/A und die Maßnahmen, die bei Überbeanspruchung ergriffen werden, sind in der Konfiguration für die Überbeanspruchung der Laufwerks-E/A vordefiniert.

Grenzwerte für die Überbeanspruchung

  • Die Grenzwerte für die übermäßige Nutzung von Festplatten-I/O werden täglich durchgesetzt. Das bedeutet, dass alle Schreibvorgänge einer App/eines Dienstes seit Beginn des aktuellen UTC-Kalendertags zusammengefasst und mit den in den Konfigurationen für die übermäßige Nutzung definierten Grenzwerten verglichen werden.
  • Wenn ein Fahrzeug an einem bestimmten Tag mehrmals gestartet wird, speichert das Watchdog-Modul die Statistiken zur Laufwerk-E/A-Nutzung im Flash-Speicher und fasst sie seit Beginn des aktuellen UTC-Kalendertags zusammen.

Aktionen bei Überbeanspruchung

Wenn eine App die definierten Grenzwerte für die übermäßige Nutzung von Festplatten-E/A wiederholt überschreitet, ergreift Watchdog die in der Konfiguration für die übermäßige Nutzung definierten Maßnahmen.

  • Alle Anbieter-Apps und ‑Dienste gelten als kritisch für die allgemeine Systemstabilität und werden daher bei übermäßiger Nutzung von Festplatten-E/A nicht beendet. In der Konfiguration für übermäßige Nutzung kann jedoch eine Liste von Anbieter-Apps und ‑Diensten definiert werden, die sicher beendet werden können.
  • Alle Drittanbieter-Apps können sicher beendet werden.

Wenn eine App oder ein Dienst sicher beendet werden kann, wird die App oder der Dienst von Watchdog mit dem App-Komponentenzustand PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED deaktiviert.

Konfiguration für Überbeanspruchung

Die Konfiguration für die übermäßige Nutzung enthält die Grenzwerte und Aktionen für die übermäßige Nutzung von Festplatten-E/A. Standardkonfigurationen für die übermäßige Nutzung werden im System- und Anbieter-Image definiert und mit dem Build ausgeliefert. Anbieter können die Anbieterkonfiguration optional in das Anbieter-Image einfügen. Wenn die Anbieterkonfiguration nicht bereitgestellt wird, wird die Systemkonfiguration auch für die Anbieter-Apps und ‑Dienste verwendet.

Watchdog stellt System-APIs über CarWatchdogManager zur Verfügung, sodass Anbieter-Apps oder ‑Dienste die Anbieterkonfiguration jederzeit aktualisieren können.

Definition der Konfiguration für übermäßige Nutzung

Die Konfiguration für die übermäßige Nutzung ist nach Komponententyp unterteilt, z. B. System, Anbieter und Drittanbieter. OEMs müssen nur die Konfiguration der Anbieterkomponente aktualisieren.

Anbieterkonfiguration

In der Anbieterkonfiguration werden die Grenzwerte für die übermäßige Nutzung von Festplatten-E/A und die Aktionen für alle Anbieter-Apps und ‑Dienste sowie alle Karten- und Media-Apps definiert. Die Konfiguration enthält die folgenden Konfigurationsfelder.

  • Anbieterpaketpräfixe: Alle in der Anbieterpartition installierten Pakete gelten als Anbieterpakete. Zusätzlich zu diesen Paketen können Anbieter vorinstallierte Pakete als Anbieterpakete klassifizieren, indem sie die Paketpräfixe der Konfiguration vendor package prefixes hinzufügen. In dieser Konfiguration werden keine regulären Ausdrücke akzeptiert.
  • Pakete, die sicher beendet werden können: Anbieter können angeben, welche Anbieterpakete sicher beendet werden können, indem sie die vollständigen Paketnamen der Konfiguration safe-to-terminate packages hinzufügen.
  • Zuordnungen von Anwendungskategorien Anbieter können jedes Paket (einschließlich Drittanbieterpakete) einer der beiden unterstützten App-Kategorien zuordnen: Karten- und Media-Apps. Diese Zuordnung erfolgt, um Karten- und Media-Apps höhere Grenzwerte für die übermäßige Nutzung von Laufwerk-E/A-Vorgängen zu ermöglichen, da diese Apps in der Regel mehr Daten auf das Laufwerk herunterladen und schreiben als andere App-Typen.
  • Grenzwerte auf Komponentenebene: Definiert allgemeine Grenzwerte für alle Anbieterpakete (d. h. Pakete, die nicht von Paketspezifische Grenzwerte oder Grenzwerte für bestimmte Anwendungskategorien abgedeckt werden, erhalten diese Grenzwerte). Anbieter müssen beim Definieren der Konfiguration für die übermäßige Nutzung von Festplatten-I/O-Vorgängen Schwellenwerte auf Komponentenebene definieren, die nicht null sind.
  • Paketspezifische Grenzwerte Anbieter können spezielle Grenzwerte für bestimmte Anbieterpakete definieren. Die Zuordnungen sollten die vollständigen Paketnamen enthalten. Die in dieser Konfiguration definierten Grenzwerte haben Vorrang vor Grenzwerten, die in anderen Konfigurationen für ein bestimmtes Paket definiert sind.
  • Anwendungskategoriespezifische Grenzwerte: Anbieter können spezielle Grenzwerte für bestimmte App-Kategorien festlegen. Die App-Kategorien müssen zu den unterstützten Kategorien gehören: Karten- und Media-Apps. Die in dieser Konfiguration definierten Grenzwerte werden mithilfe von Zuordnungen von Anwendungskategorien bestimmten Paketen zugeordnet.
  • Systemweite Grenzwerte: Anbieter dürfen diese Konfiguration nicht angeben.

Herstellerpaketpräfixe, Pakete, die sicher beendet werden können, Schwellenwerte auf Komponentenebene und Paketspezifische Schwellenwerte können nur über die Herstellerkonfiguration für Hersteller-Apps und ‑Dienste aktualisiert werden. Die Konfiguration Anwendungskategoriespezifische Grenzwerte kann nur über die Anbieterkonfiguration für alle Karten- und Media-Apps aktualisiert werden.

Die Grenzwerte für die Überbeanspruchung enthalten die Anzahl der Byte, die während der folgenden Zeiträume geschrieben werden dürfen:

  • Vordergrund- und Hintergrundmodus einer App oder eines Dienstes
  • System-Garagenmodus

Diese Klassifizierung ermöglicht es Vordergrund-Apps und ‑Diensten, die für Nutzer sichtbar sind, mehr Daten zu schreiben als Hintergrund-Apps und ‑Dienste. Im Garagenmodus werden Updates für Apps und Dienste heruntergeladen. Daher ist für jede App und jeden Dienst ein höherer Schwellenwert erforderlich als für Apps und Dienste, die in anderen Modi ausgeführt werden.

System- und Drittanbieterkonfigurationen

OEMs sollten die System- und Drittanbieterkonfigurationen nicht aktualisieren.

  • In der Systemkonfiguration werden Grenzwerte für die E/A-Überlastung und Aktionen für System-Apps und ‑Dienste definiert.
    • Mit dieser Konfiguration können auch die Zuordnungen von Anwendungskategorien aktualisiert werden. Dieses Konfigurationsfeld wird also von System- und Anbieterkonfigurationen gemeinsam genutzt.
  • In der Drittanbieterkonfiguration werden Grenzwerte für alle Drittanbieter-Apps definiert. Alle Apps, die nicht im System vorinstalliert sind, sind Drittanbieter-Apps.
    • Alle Drittanbieter-Apps erhalten dieselben Grenzwerte (z. B. keine speziellen Grenzwerte für Drittanbieter-Apps), mit Ausnahme von Karten- und Media-Apps, deren Grenzwerte durch die Anbieterkonfiguration definiert werden.
    • Die folgenden Grenzwerte für die übermäßige Nutzung von Festplatten-I/O sind die Standardgrenzwerte für Drittanbieter-Apps. Diese Grenzwerte werden mit dem System-Image ausgeliefert.
      • 3 GiB im Vordergrundmodus der App schreiben.
      • 2 GiB im Hintergrundmodus der App schreiben.
      • 4 GiB im Systemgaragenmodus schreiben.
    • Dies sind die Basisgrenzwerte. Diese Grenzwerte werden aktualisiert, wenn mehr über die Nutzung von Festplatten-I/O bekannt wird.

XML-Format für die Konfiguration bei übermäßiger Nutzung

Die Standardkonfiguration des Anbieters kann (optional) im Build-Image unter /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml platziert werden. Wenn diese Konfiguration nicht angegeben ist, wird die vom System definierte Konfiguration auch für Anbieter-Apps und ‑Dienste angewendet.

Die XML-Datei sollte für jedes Konfigurationsfeld nur ein Tag enthalten. Die Konfiguration für die übermäßige Nutzung von Ein-/Ausgabe muss in der XML-Datei definiert werden. Alle Grenzwerte sollten in MiB angegeben werden.

Unten sehen Sie eine Beispielkonfiguration in 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>

Konfiguration für übermäßige Nutzung über CarWatchdogManager-System-APIs aktualisieren

Die oben genannte XML-Konfiguration kann nur im Build-Image angegeben werden. Wenn ein OEM die On-Device-Konfiguration nach der Veröffentlichung eines Builds aktualisieren möchte, kann er die folgenden APIs verwenden, um Änderungen an der On-Device-Konfiguration vorzunehmen.

  • Erteilen Sie dem Anrufer die Berechtigung Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG.
  • Sie müssen die vorhandenen Konfigurationen verwenden, um die neuen Konfigurationen zu aktualisieren und festzulegen. Verwenden Sie die API CarWatchdogManager.getResourceOveruseConfigurations, um die vorhandenen Konfigurationen abzurufen. Wenn vorhandene Konfigurationen nicht verwendet werden, werden alle Konfigurationen (einschließlich System- und Drittanbieterkonfigurationen) überschrieben. Das wird nicht empfohlen.
  • Aktualisieren Sie die vorhandenen Konfigurationen mit den Delta-Änderungen und legen Sie die neuen Konfigurationen fest. Die Konfigurationen von System- und Drittanbieterkomponenten werden nicht aktualisiert.
  • Verwenden Sie die API CarWatchdogManager.setResourceOveruseConfigurations, um die neuen Konfigurationen festzulegen.
  • Verwenden Sie das Flag CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO, um die Konfigurationen für die übermäßige Nutzung von Laufwerk-E/A abzurufen und festzulegen.

Hier sehen Sie ein Beispiel für die Implementierung, mit der die Konfigurationen für die Ressourcenübernutzung aktualisiert werden:

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, die übermäßigen Ressourcenverbrauch überwachen

Anbieter- und Drittanbieter-Apps können auf benachrichtigungsspezifische Benachrichtigungen zur Ressourcenübernutzung von Watchdog warten oder CarWatchdogManager nach den benachrichtigungsspezifischen Statistiken zur Ressourcenübernutzung der letzten 30 Tage abfragen.

Benachrichtigungen über die Überschreitung von Ressourcenlimits abrufen

Apps können einen Listener für die Ressourcenüberbeanspruchung implementieren und ihn mit CarWatchdogManager registrieren, um appspezifische Benachrichtigungen zu erhalten, wenn sie 80% oder 100% ihrer Grenzwerte für die Überbeanspruchung von Festplatten-I/O überschreiten. Apps können diese Benachrichtigungen für Folgendes verwenden:

  • Statistiken zur übermäßigen Nutzung von Festplatten-E/A für die Offlineanalyse protokollieren. App-Entwickler können diese Protokollierung verwenden, um das Problem der übermäßigen Festplatten-E/A zu beheben.
  • Reduzieren Sie die Anzahl der Laufwerk-E/A-Schreibvorgänge, bis die Zähler für die Überbeanspruchung zurückgesetzt werden.

Java-Client

  1. Implementieren Sie den Listener durch Vererben von 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. Registrieren Sie die Listener-Instanz, indem Sie CarWatchdogManager.addResourceOveruseListener aufrufen. 
    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. Heben Sie die Registrierung der Listener-Instanz auf, wenn die App Folgendes nicht mehr abhört: 
    private void removeResourceOveruseListener() {
    CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
    mCarWatchdogManager.removeResourceOveruseListener(
          mListenerImpl);
}

Nativer Client

  1. Fügen Sie carwatchdog_aidl_interface-ndk_platform in die shared_libs-Abhängigkeit der Build-Regel ein.

    Android.bp

    cc_binary {
    name: "sample_native_client",
    srcs: [
        "src/*.cpp"
    ],
    shared_libs: [
        "carwatchdog_aidl_interface-ndk_platform",
        "libbinder_ndk",
    ],
    vendor: true,
}
  2. Fügen Sie eine SELinux-Richtlinie hinzu, damit die Anbieterdienstdomain Binder verwenden kann (binder_user-Makro), und fügen Sie die Anbieterdienstdomain der carwatchdog-Clientdomain (carwatchdog_client_domain macro) hinzu. Unten finden Sie den Code für sample_client.te und 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. Implementieren Sie den Listener für die Ressourcenüberbeanspruchung, indem Sie BnResourceOveruseListener übernehmen. Überschreiben Sie BnResourceOveruseListener::onOveruse, um Benachrichtigungen zur Ressourcenüberlastung zu verarbeiten.

    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. Starten Sie einen Binder-Threadpool und registrieren Sie den Listener für die Ressourcenüberlastung beim Watchdog-Server. Der Watchdog-Server ist unter dem Dienstnamen android.automotive.watchdog.ICarWatchdog/default registriert.

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

Statistiken zur Ressourcenübernutzung abrufen

Apps können CarWatchdogManager nach den app-spezifischen ATS-Statistiken zum I/O-Überverbrauch für die letzten 30 Tage abfragen.

Java-Client

Verwenden Sie CarWatchdogManager.getResourceOveruseStats, um Statistiken zur Ressourcenüberlastung abzurufen. Übergeben Sie das Flag CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO, um die Statistiken zur Überbeanspruchung der Festplatten-E/A zu erhalten.

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

Nativer Client

Verwenden Sie CarWatchdogServer.getResourceOveruseStats, um Statistiken zur Ressourcenüberlastung abzurufen. Übergeben Sie das ResourceType.IO-Enum, um Statistiken zur Überbeanspruchung der Laufwerk-E/A abzurufen.

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

Nutzerfreundlichkeit bei übermäßiger Ressourcennutzung

In den folgenden Abschnitten wird beschrieben, wie sich eine Ressourcenüberlastung auf die Nutzer auswirkt.

Einstellung „App-Leistung priorisieren“

Die Seite Einstellungen der App enthält Einstellungen fürPrioritize app performance (siehe Abbildung unten). Damit können Nutzer die Leistung einer App gegenüber der System- und langfristigen Hardwareleistung priorisieren. Diese Einstellung ist nur für Apps verfügbar, die bei Ressourcenüberlastung sicher beendet werden können. Andernfalls ist diese Einstellung deaktiviert. Wenn diese Einstellung für eine App deaktiviert ist (Standardeinstellung), kann die App bei übermäßiger Ressourcennutzung beendet werden. Andernfalls wird die App bei übermäßiger Ressourcennutzung nicht beendet.

Wenn der Nutzer diese Einstellung aktiviert, wird das folgende Bestätigungsdialogfeld mit den Auswirkungen der Aktivierung der Einstellung angezeigt:

Nach 90 Tagen wird diese Einstellung automatisch auf die Standardeinstellung zurückgesetzt. Das Tageslimit kann mit einer RRO-Overlay-App über watchdogUserPackageSettingsResetDays auf maximal 180 Tage geändert werden. Weitere Informationen finden Sie unter Wert der Ressourcen einer App zur Laufzeit ändern. Das folgende Beispiel für ein Overlay-Tag kann in AndroidManifest.xml eingefügt werden:

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

Einstellung für Apps mit Einfluss auf die Systemleistung

Die App Einstellungen enthält den Bereich Leistungsbeeinträchtigende Apps (siehe Abbildung 1). Wenn Sie darauf tippen, wird eine Liste der Apps angezeigt, die aufgrund von übermäßigem Flash-Speicherverbrauch eingeschränkt wurden und die Systemleistung negativ beeinflussen. Dies entspricht CDD 3.5.1, Anforderung [C-1-1].

Apps mit Einfluss auf die Systemleistung

Abbildung 1: Apps mit Einfluss auf die Systemleistung.

Hier werden Apps aufgeführt, die aufgrund von Ressourcenüberlastung beendet wurden (siehe Abbildung 2). Die aufgeführten Apps können priorisiert werden. Weitere Informationen finden Sie unter Einstellung zur Priorisierung der App-Leistung.

Liste der Apps, die wegen übermäßiger Ressourcennutzung beendet wurden

Abbildung 2: Liste der Apps, die aufgrund von Ressourcenüberlastung beendet wurden.

Benachrichtigung des Nutzers

Wenn eine App oder ein Dienst innerhalb eines bestimmten Zeitraums wiederholt die Festplatten-I/O überlastet (z. B. Daten über die definierten Grenzwerte hinaus auf die Festplatte schreibt) und bei Ressourcenüberlastung sicher beendet werden kann, wird der Nutzer benachrichtigt, nachdem das Fahrzeug in den Zustand „Fahrerablenkung zulassen“ wechselt.

Die erste Nutzerbenachrichtigung (während einer Fahrt) wird als Hinweisbenachrichtigung und die anderen Benachrichtigungen in der Benachrichtigungszentrale angezeigt.

Wenn eine App beispielsweise wiederholt zu viel Festplatten-I/O verwendet, erhält der Nutzer die folgende Benachrichtigung:

  • Wenn der Nutzer auf die Schaltfläche App priorisieren klickt, wird die Einstellungsseite der App geöffnet, auf der der Nutzer die Einstellung App-Leistung priorisieren aktivieren oder deaktivieren kann.
  • Wenn der Nutzer auf die Schaltfläche App deaktivieren klickt, wird die App deaktiviert, bis der Nutzer sie startet oder auf der Einstellungsseite der App aktiviert.
  • Bei Apps, die deinstalliert werden können, wird die Schaltfläche App deaktivieren durch die Schaltfläche App deinstallieren ersetzt. Wenn der Nutzer auf die Schaltfläche App deinstallieren klickt, wird die Einstellungsseite der App aufgerufen, über die der Nutzer die App deinstallieren kann.

Empfehlung für die Launcher-Implementierung

Wenn Apps aufgrund von Ressourcenüberlastung deaktiviert werden, verschwinden sie aus der Standard-Launcher-App, da CarService den aktivierten Status der Apps als PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED aktualisiert. OEMs müssen die integrierte Launcher-Implementierung aktualisieren, damit diese Apps wie gewohnt angezeigt werden und Nutzer sie bei Bedarf verwenden können. Hier finden Sie Empfehlungen für die einzelnen Build-Releases.

Veröffentlichung von Android SC V2