מעקב אחר השימוש בזיכרון flash

השירות Watchdog עוקב אחרי השימוש בזיכרון הפלאש על ידי מעקב אחרי הכמות הכוללת של פעולות קלט/פלט (I/O) בדיסק שבוצעו על ידי כל האפליקציות והשירותים באמצעות נתוני הקלט/פלט (I/O) בדיסק לכל UID שנחשפים על ידי הליבה במיקום ‎/proc/uid_io/stats. כששימוש באפליקציה או בשירות חורג מסף השימוש המוגזם בקלט/פלט (I/O) בדיסק, השירות Watchdog מבצע פעולות באפליקציה או בשירות. ערכי הסף לשימוש יתר בקלט/פלט בדיסק והפעולה שיש לבצע במקרה של שימוש יתר מוגדרים מראש בהגדרות של שימוש יתר בקלט/פלט בדיסק.

ערכי סף לשימוש יתר

  • האכיפה של ספי השימוש המוגזם בקלט/פלט של הדיסק מתבצעת על בסיס יומי, כלומר, כל פעולות הכתיבה שבוצעו על ידי אפליקציה או שירות מסוימים מצטברות מתחילת היום הקלנדרי הנוכחי לפי שעון UTC, ונבדקות מול ספי השימוש המוגזם שהוגדרו בהגדרות.
  • כשמפעילים רכב כמה פעמים ביום מסוים, מודול Watchdog מאחסן את נתוני השימוש בקלט/פלט בדיסק בזיכרון פלאש, ומצטבר אותם מתחילת היום הנוכחי בלוח השנה לפי שעון UTC.

פעולות במקרה של שימוש יתר

כשאפליקציה חורגת שוב ושוב מספי השימוש המוגזם ב-I/O בדיסק שהוגדרו, Watchdog מבצע פעולות שמוגדרות בהגדרות השימוש המוגזם.

  • כל האפליקציות והשירותים של הספקים נחשבים קריטיים ליציבות הכוללת של המערכת, ולכן הם לא מסתיימים בשימוש יתר בקלט/פלט בדיסק. עם זאת, בהגדרות של שימוש יתר אפשר להגדיר רשימה של אפליקציות ושירותים של ספקים שאפשר להפסיק את השימוש בהם בבטחה.
  • כל האפליקציות של צד שלישי בטוחות לסגירה.

כשמזוהה שאפשר להפסיק אפליקציה או שירות, Watchdog משבית את האפליקציה או השירות עם מצב רכיב האפליקציה PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED .

הגדרת שימוש יתר

ההגדרה של שימוש יתר כוללת את ערכי הסף של שימוש יתר בקלט/פלט בדיסק ואת הפעולות שמתבצעות במקרה כזה. הגדרות ברירת המחדל של שימוש יתר מוגדרות בתמונות של המערכת והספק, ונשלחות עם הגרסה. ספקים יכולים לכלול את הגדרות הספק בתמונה של הספק. אם לא מספקים הגדרות של ספק, המערכת משתמשת בהגדרות שלה גם עבור האפליקציות והשירותים של הספק.

‫Watchdog חושף ממשקי API של המערכת דרך CarWatchdogManager, וכך מאפשר לספקי אפליקציות או שירותים לעדכן את הגדרות הספק בכל שלב.

הגדרה של שימוש יתר

הגדרות השימוש המוגזם מחולקות לפי סוג הרכיב, למשל מערכת, ספק וצד שלישי. יצרני ציוד מקורי צריכים לעדכן רק את ההגדרה של רכיב הספק.

הגדרות ספק

הגדרת הספק מגדירה את ספי הפעולה והפעולות במקרה של שימוש יתר בקלט/פלט בדיסק עבור כל האפליקציות והשירותים של הספק, וכל אפליקציות המפות והמדיה. ההגדרה מכילה את שדות ההגדרה הבאים.

  • קידומות של חבילות ספקים. כל החבילות שמותקנות במחיצת הספק נחשבות לחבילות ספק. בנוסף לחבילות האלה, ספקים יכולים לסווג חבילות שהותקנו מראש כחבילות ספק על ידי הוספת קידומות החבילות להגדרה vendor package prefixes. ההגדרה הזו לא מקבלת ביטויים רגולריים.
  • חבילות שאפשר להפסיק את השימוש בהן בבטחה. ספקים יכולים לציין אילו חבילות של ספקים בטוחות לסיום על ידי הוספת שמות החבילות המלאים להגדרה safe-to-terminate packages.
  • מיפוי של קטגוריות אפליקציות. ספקים יכולים למפות כל חבילה (כולל חבילות של צד שלישי) לאחת משתי קטגוריות האפליקציות הנתמכות – אפליקציות של מפות ואפליקציות של מדיה. המיפוי הזה מתבצע כדי לספק לאפליקציות של מפות ומדיה ספי צריכת קלט/פלט גבוהים יותר בדיסק, כי האפליקציות האלה נוטות להוריד ולכתוב יותר נתונים בדיסק מאשר סוגים אחרים של אפליקציות.
  • מגבלות סף ברמת הרכיב. הגדרה של ערכי סף גנריים לכל חבילות הספקים (כלומר, חבילות שלא נכללות בערכי סף ספציפיים לחבילה או בערכי סף ספציפיים לקטגוריית אפליקציה מקבלות את ערכי הסף האלה). ספקים צריכים להגדיר ספי שימוש יתר ברמת הרכיב שאינם אפס, כשהם מגדירים את התצורה של שימוש יתר בקלט/פלט של הדיסק.
  • מגבלות סף ספציפיות לחבילה. ספקים יכולים להגדיר ספים מיוחדים לחבילות ספציפיות של ספקים. המיפויים צריכים לכלול את השמות המלאים של החבילות. לערכי הסף שמוגדרים בהגדרה הזו יש עדיפות על פני ערכי סף שמוגדרים בהגדרות אחרות עבור חבילה נתונה.
  • סף ספציפי לקטגוריית אפליקציה. ספקים יכולים לציין ספים מיוחדים לקטגוריות ספציפיות של אפליקציות. קטגוריות האפליקציות צריכות להיות אחת מהקטגוריות הנתמכות – אפליקציות של מפות ומדיה. הסף שמוגדר בהגדרה הזו ממופה לחבילות ספציפיות באמצעות מיפויי קטגוריות של אפליקציות.
  • ערכי סף בכל המערכת. ספקים לא יכולים לציין את ההגדרה הזו.

הגדרות של קידומות של חבילות ספקים, חבילות שאפשר להפסיק בבטחה, סף ברמת הרכיב וסף ספציפי לחבילה ניתנות לעדכון רק על ידי הגדרת הספק עבור אפליקציות ושירותים של ספקים. אפשר לעדכן את ההגדרה Application category specific thresholds רק באמצעות הגדרת הספק לכל האפליקציות של מפות ומדיה.

הסף לשימוש יתר כולל את מספר הבייטים שמותר לכתוב במהלך:

  • מצב חזית לעומת מצב רקע באפליקציה או בשירות
  • מצב חנייה של המערכת

הסיווג הזה מאפשר לאפליקציות ולשירותים שפועלים בחזית ומיועדים למשתמשים לכתוב יותר נתונים מאשר אפליקציות ושירותים שפועלים ברקע. במצב Garage, אפליקציות ושירותים נוטים להוריד עדכונים, ולכן כל אחד מהם צריך סף גבוה יותר מאפליקציות ושירותים שפועלים במצבים אחרים.

הגדרות מערכת והגדרות של צד שלישי

יצרני ציוד מקורי לא צריכים לעדכן את הגדרות המערכת והגדרות צד שלישי.

  • הגדרת המערכת מגדירה את ספי הפעולה ואת הפעולות במקרה של שימוש יתר בקלט/פלט באפליקציות ובשירותים של המערכת.
    • ההגדרה הזו יכולה גם לעדכן את מיפויים של קטגוריות אפליקציות. לכן, שדה ההגדרה הזה משותף בין הגדרות המערכת והספק.
  • ההגדרה של צד שלישי מגדירה ספי גישה לכל האפליקציות של צד שלישי. כל האפליקציות שלא מותקנות מראש במערכת הן אפליקציות צד שלישי.
    • כל האפליקציות של צד שלישי מקבלות את אותם ערכי סף (לדוגמה, אף אפליקציה של צד שלישי לא מקבלת ערכי סף מיוחדים), למעט אפליקציות של מפות ומדיה, שערכי הסף שלהן מוגדרים בהגדרות הספק.
    • סף השימוש המוגזם ב-I/O בדיסק שמופיע בהמשך הוא סף ברירת המחדל עבור אפליקציות של צד שלישי. ערכי הסף האלה נשלחים עם תמונת המערכת.
      • 3 GiB כתיבה במצב קדמי של האפליקציה.
      • ‫2 GiB כתיבה במצב רקע של האפליקציה.
      • ‫4 GiB כתיבה במצב חנייה של המערכת.
    • אלה ספי בסיס. הסף הזה מתעדכן ככל שלומדים יותר על השימוש בקלט/פלט בדיסק.

פורמט XML של הגדרות שימוש יתר

אפשר להציב הגדרות ברירת מחדל של ספק (אופציונלי) במיקום /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml בקובץ האימג' של ה-build. אם ההגדרה הזו לא מצוינת, ההגדרה שמוגדרת על ידי המערכת חלה גם על אפליקציות ושירותים של ספקים.

קובץ ה-XML צריך להכיל רק תג אחד לכל שדה הגדרה. הגדרת שימוש יתר בקלט/פלט חייבת להיות מוגדרת בקובץ ה-XML. כל ערכי הסף צריכים להיות מוגדרים ביחידה MiB.

למטה מופיעה דוגמה להגדרת 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>

עדכון ההגדרה של שימוש יתר באמצעות ממשקי מערכת של CarWatchdogManager API

אפשר לספק את הגדרות ה-XML שלמעלה רק בתמונת ה-build. אם יצרן ציוד מקורי (OEM) בוחר לעדכן את ההגדרה במכשיר אחרי שגרסת ה-build יוצאת, הוא יכול להשתמש בממשקי ה-API הבאים כדי לבצע שינויים בהגדרה במכשיר.

  • נותנים למבצע הקריאה החוזרת את ההרשאה Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG.
  • צריך להשתמש בהגדרות הקיימות כדי לעדכן ולהגדיר את ההגדרות החדשות. משתמשים ב-API CarWatchdogManager.getResourceOveruseConfigurations כדי לקבל את ההגדרות הקיימות. אם לא משתמשים בהגדרות קיימות, כל ההגדרות (כולל הגדרות מערכת והגדרות של צד שלישי) נדרסות, וזה לא מומלץ.
  • מעדכנים את ההגדרות הקיימות עם השינויים החדשים ומגדירים את ההגדרות החדשות. לא לעדכן את ההגדרות של המערכת ושל רכיבי צד שלישי.
  • משתמשים ב-API‏ CarWatchdogManager.setResourceOveruseConfigurations כדי להגדיר את התצורות החדשות.
  • כדי לקבל ולהגדיר את ההגדרות של שימוש יתר בקלט/פלט של הדיסק, משתמשים בדגל CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO.

הנה דוגמה להטמעה שמעדכנת את ההגדרות של שימוש יתר במשאבים:

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

אפליקציות שמתבצע מעקב אחרי שימוש יתר במשאבים שלהן

ספקים ואפליקציות של צד שלישי יכולים להאזין להתראות על שימוש יתר במשאבים ספציפיים לאפליקציה מ-Watchdog או לשלוח בקשות ל-CarWatchdogManager כדי לקבל נתונים סטטיסטיים על שימוש יתר במשאבים ספציפיים לאפליקציה מ-30 הימים האחרונים.

האזנה להתראות על שימוש יתר במשאבים

אפליקציות יכולות להטמיע מאזין לשימוש יתר במשאבים ולרשום את המאזין ב-CarWatchdogManager כדי לקבל התראות ספציפיות לאפליקציה כשהן חורגות מ-80% או מ-100% מספי השימוש המרביים שלהן בזיכרון הדיסק. אפליקציות יכולות להשתמש בהתראות האלה כדי:

  • רישום ביומן של נתוני השימוש המוגזם בקלט/פלט של הדיסק לצורך ניתוח אופליין. מפתחי אפליקציות יכולים להשתמש ברישום הזה ביומן כדי לנפות באגים בבעיה של שימוש יתר בקלט/פלט בדיסק.
  • צריך להקטין את מספר פעולות הכתיבה של קלט/פלט בדיסק עד שהמונים של השימוש העודף יתאפסו.

לקוח Java

  1. מטמיעים listener על ידי ירושה של 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. רושמים את מופע מעבד האירוע באמצעות הקריאה ל-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. ביטול הרישום של מופע ה-listener כשהאפליקציה מסיימת להאזין ל: 
    private void removeResourceOveruseListener() {
    CarWatchdogManager manager =
            (CarWatchdogManager) car.getCarManager(Car.CAR_WATCHDOG_SERVICE);
    mCarWatchdogManager.removeResourceOveruseListener(
          mListenerImpl);
}

אפליקציית-לקוח מותאמת

  1. כוללים את carwatchdog_aidl_interface-ndk_platform בהסתמכות של shared_libs על כלל הבנייה.

    Android.bp

    cc_binary {
    name: "sample_native_client",
    srcs: [
        "src/*.cpp"
    ],
    shared_libs: [
        "carwatchdog_aidl_interface-ndk_platform",
        "libbinder_ndk",
    ],
    vendor: true,
}
  2. מוסיפים מדיניות SELinux כדי לאפשר לדומיין של שירות הספק להשתמש ב-binder (מאקרו binder_user) ומוסיפים את הדומיין של שירות הספק לcarwatchdog דומיין הלקוח (carwatchdog_client_domain macro). הקוד שלמטה הוא עבור sample_client.te ו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. מטמיעים את מאזין השימוש העודף במשאבים על ידי ירושה של BnResourceOveruseListener. מחליפים את הפונקציה BnResourceOveruseListener::onOveruse כדי לטפל בהתראות על שימוש יתר במשאבים.

    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. מפעילים מאגר שרשורים של binder ורושמים את מאזין השימוש המוגזם במשאבים בשרת watchdog. שרת Watchdog רשום בשם השירות 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);
}

קבלת נתונים סטטיסטיים על שימוש יתר במשאבים

אפליקציות יכולות לשלוח שאילתות ל-CarWatchdogManager כדי לקבל את נתוני ה-ATS הספציפיים לאפליקציה לגבי שימוש יתר בקלט/פלט ב-30 הימים האחרונים.

לקוח Java

משתמשים ב-CarWatchdogManager.getResourceOveruseStats כדי לקבל את נתוני השימוש המוגזם במשאבים. מעבירים את הדגל CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO כדי לקבל את נתוני השימוש העודף בקלט/פלט של הדיסק.

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

אפליקציית-לקוח מותאמת

משתמשים ב-CarWatchdogServer.getResourceOveruseStats כדי לקבל את נתוני השימוש המוגזם במשאבים. מעבירים את הערך ResourceType.IO enum כדי לאחזר נתונים סטטיסטיים על שימוש יתר בקלט/פלט של הדיסק.

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

חוויית משתמש במקרה של שימוש יתר במשאבים

בקטעים הבאים מתוארת חוויית המשתמש במקרה של שימוש יתר במשאבים.

ההגדרה 'עדיפות לביצועי אפליקציות'

בדף הגדרות של האפליקציה יש הגדרות לPrioritize app performance (ראו את התמונה שלמטה), שמאפשרות למשתמשים לתת עדיפות לביצועים של האפליקציה על פני המערכת ועל פני הביצועים של החומרה לטווח ארוך. ההגדרה הזו זמינה רק לאפליקציות שאפשר להפסיק את הפעולה שלהן בבטחה אם הן צורכות יותר מדי משאבים. אחרת, ההגדרה הזו מושבתת. כשההגדרה הזו מושבתת (הגדרת ברירת המחדל) עבור אפליקציה, המערכת יכולה להפסיק את פעולת האפליקציה אם היא צורכת יותר מדי משאבים. אחרת, האפליקציה לא תופסק בגלל שימוש מוגזם במשאבים.

כשמשתמשים מפעילים את ההגדרה הזו, מוצגת להם תיבת דו-שיח לאישור עם הסבר על ההשלכות של הפעלת ההגדרה:

אחרי 90 ימים, ההגדרה הזו מאופסת אוטומטית לברירת המחדל. אפשר לשנות את המגבלה היומית באמצעות אפליקציית שכבת-על של RRO, עם watchdogUserPackageSettingsResetDays, עד למקסימום של 180 ימים. מידע נוסף זמין במאמר בנושא שינוי הערך של משאבי אפליקציה בזמן ריצה. אפשר לכלול את תג השכבת-העל הבא בדוגמה AndroidManifest.xml:

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

בres/values/config.xml:

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

בres/xml/overlays.xml:

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

ההגדרה 'אפליקציות שמשפיעות על הביצועים'

אפליקציית ההגדרות כוללת את הקטע אפליקציות שמשפיעות על הביצועים (ראו איור 1). כשמקישים על ההודעה, מוצגת רשימה של אפליקציות שהשימוש בהן הוגבל בגלל שימוש יתר בזיכרון הפלאש, ושהן משפיעות לרעה על ביצועי המערכת. הדרישה הזו תואמת לדרישה CDD 3.5.1 [C-1-1].

אפליקציות שמשפיעות על הביצועים

איור 1. אפליקציות שמשפיעות על הביצועים.

אפליקציות שהופסק השימוש בהן בגלל שימוש יתר במשאבים מופיעות כאן (ראו איור 2). אפשר לתת עדיפות לאפליקציות שמופיעות ברשימה. מידע נוסף זמין במאמר בנושא הגדרת עדיפות לביצועי האפליקציה.

רשימת האפליקציות שהשימוש בהן הופסק בגלל שימוש מוגזם במשאבים

איור 2. רשימת האפליקציות שהופסק השימוש בהן בגלל שימוש יתר במשאבים.

הודעה למשתמש

אם אפליקציה או שירות משתמשים שוב ושוב בצורה מוגזמת בקלט/פלט של הדיסק (לדוגמה, כותבים נתונים לדיסק מעבר לסף המוגדר) בתוך תקופה מסוימת, ואפשר להפסיק את הפעולה שלהם בבטחה בגלל שימוש מוגזם במשאבים, המשתמש מקבל הודעה אחרי שהרכב עובר למצב 'הסחת דעת מותרת לנהג'.

ההתראה הראשונה למשתמש (במהלך נסיעה) מוצגת כהתראה קופצת, וההתראות האחרות מוצגות במרכז ההתראות.

לדוגמה, אם אפליקציה משתמשת שוב ושוב ב-I/O של הדיסק בצורה מוגזמת, המשתמש מקבל את ההתראה הבאה:

  • כשהמשתמש לוחץ על הלחצן העדיפות לביצועי האפליקציות, נפתח דף ההגדרות של האפליקציה, שבו המשתמש יכול להפעיל או להשבית את ההגדרה העדיפות לביצועי האפליקציות.
  • כשהמשתמש לוחץ על הלחצן השבתת האפליקציה, האפליקציה מושבתת עד שהמשתמש מפעיל אותה או מאפשר אותה בדף ההגדרות של האפליקציה.
  • באפליקציות שלא ניתן להסיר, הלחצן השבתת האפליקציה מוחלף בלחצן הסרת האפליקציה. כשהמשתמש לוחץ על הלחצן הסרת האפליקציה, נפתח דף ההגדרות של האפליקציה, שממנו המשתמש יכול להסיר את האפליקציה.

המלצה להטמעה של מרכז האפליקציות

כשמשביתים אפליקציות בגלל שימוש מוגזם במשאבים, האפליקציות נעלמות מאפליקציית מרכז האפליקציות שמוגדרת כברירת מחדל, כי CarService מעדכן את מצב ההפעלה של האפליקציות לPackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED. יצרני ציוד מקורי (OEM) צריכים לעדכן את ההטמעה של מרכז האפליקציות המובנה כדי שהאפליקציות האלה יוצגו כרגיל, כך שהמשתמשים יוכלו להשתמש בהן אם הם צריכים. בהמשך מפורטות המלצות על סמך גרסת ה-build.

השקת Android SC V2