ตรวจสอบการใช้งานหน่วยความจำแฟลช

Watchdog จะตรวจสอบการใช้งานหน่วยความจำแฟลชโดยการติดตามจำนวนการเขียน I/O ของดิสก์ทั้งหมด ที่ทำโดยแอปและบริการทั้งหมดที่ใช้สถิติ I/O ของดิสก์ต่อ UID ที่เคอร์เนลเปิดเผยในตำแหน่ง `/proc/uid_io/stats` เมื่อแอป หรือบริการใดเกินเกณฑ์การใช้งาน I/O ของดิสก์มากเกินไป Watchdog จะดำเนินการกับแอป หรือบริการนั้น เกณฑ์การใช้งาน I/O ของดิสก์มากเกินไปและการดำเนินการที่ต้องทำ เมื่อใช้งานมากเกินไปจะได้รับการกำหนดไว้ล่วงหน้าในการกำหนดค่าการใช้งาน I/O ของดิสก์มากเกินไป

เกณฑ์การใช้งานมากเกินไป

  • ระบบจะบังคับใช้เกณฑ์การใช้ I/O ของดิสก์มากเกินไปทุกวัน กล่าวคือ ระบบจะรวบรวมการเขียนทั้งหมดที่แอป/บริการทำตั้งแต่ต้นวันตามปฏิทิน UTC ปัจจุบัน และตรวจสอบเทียบกับเกณฑ์ที่กำหนดไว้ในการกำหนดค่าการใช้งานมากเกินไป
  • เมื่อสตาร์ตรถหลายครั้งในวันหนึ่งๆ โมดูล Watchdog จะจัดเก็บสถิติการใช้งาน I/O ของดิสก์ในหน่วยความจำแฟลชและรวบรวมสถิติดังกล่าวตั้งแต่ ต้นวันตามปฏิทิน UTC ปัจจุบัน

การดำเนินการเมื่อใช้มากเกินไป

เมื่อแอปใช้ดิสก์ I/O มากเกินไปซ้ำๆ ตามเกณฑ์ที่กำหนด Watchdog จะดำเนินการตามที่กำหนดไว้ในการกำหนดค่าการใช้งานมากเกินไป

  • แอปและบริการของผู้ให้บริการทั้งหมดถือว่ามีความสำคัญต่อ ความเสถียรของระบบโดยรวม จึงจะไม่มีการสิ้นสุดการทำงานเมื่อมีการใช้ I/O ของดิสก์มากเกินไป อย่างไรก็ตาม การกำหนดค่าการใช้งานมากเกินไปจะกำหนดรายการแอปของผู้ให้บริการที่ปลอดภัยในการสิ้นสุด และบริการได้
  • แอปของบุคคลที่สามทั้งหมดสามารถหยุดการทำงานได้อย่างปลอดภัย

เมื่อแอปหรือบริการปลอดภัยที่จะสิ้นสุด Watchdog จะปิดใช้แอปหรือบริการที่มีสถานะคอมโพเนนต์ของแอป PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED

การกำหนดค่าการใช้งานมากเกินไป

การกำหนดค่าการใช้งานมากเกินไปประกอบด้วยเกณฑ์การใช้งาน I/O ของดิสก์มากเกินไปและ การดำเนินการ การกำหนดค่าการใช้งานมากเกินไปเริ่มต้นจะกำหนดไว้ในรูปภาพของระบบและผู้ให้บริการ และจัดส่งพร้อมกับบิลด์ ผู้ให้บริการจะรวมการกำหนดค่าของผู้ให้บริการไว้ในรูปภาพของผู้ให้บริการหรือไม่ก็ได้ เมื่อไม่ได้ระบุการกำหนดค่าของผู้ให้บริการ ระบบจะใช้การกำหนดค่าของระบบกับแอปและบริการของผู้ให้บริการด้วย

Watchdog แสดง API ของระบบผ่าน CarWatchdogManager ซึ่งช่วยให้ แอปหรือบริการของผู้ให้บริการอัปเดตการกำหนดค่าของผู้ให้บริการ ได้ทุกเมื่อ

คำจำกัดความของการกำหนดค่าการใช้งานมากเกินไป

การกำหนดค่าการใช้งานเกินโควต้าจะแยกตามประเภทคอมโพเนนต์ เช่น ระบบ ผู้ให้บริการ และบุคคลที่สาม OEM ต้องอัปเดตเฉพาะการกำหนดค่าคอมโพเนนต์ของผู้ให้บริการ

การกำหนดค่าผู้ให้บริการ

การกำหนดค่าของผู้ให้บริการจะกำหนดเกณฑ์การใช้งาน I/O ของดิสก์มากเกินไปและการดำเนินการสำหรับ แอปและบริการของผู้ให้บริการทั้งหมด รวมถึงแอปแผนที่และสื่อทั้งหมด การกำหนดค่าประกอบด้วยฟิลด์การกำหนดค่าด้านล่าง

  • คำนำหน้าแพ็กเกจของผู้ให้บริการ แพ็กเกจทั้งหมดที่ติดตั้งในพาร์ติชันของผู้ให้บริการจะถือว่าเป็นแพ็กเกจของผู้ให้บริการ นอกจากแพ็กเกจเหล่านี้แล้ว ผู้ให้บริการยังจัดประเภทแพ็กเกจที่ติดตั้งไว้ล่วงหน้าเป็นแพ็กเกจของผู้ให้บริการได้โดยการเพิ่มคำนำหน้าแพ็กเกจลงในการกำหนดค่าคำนำหน้าแพ็กเกจของผู้ให้บริการ การกำหนดค่านี้ไม่ยอมรับนิพจน์ทั่วไป
  • แพ็กเกจที่ยกเลิกได้อย่างปลอดภัย ผู้ให้บริการสามารถระบุแพ็กเกจของผู้ให้บริการ ที่สามารถสิ้นสุดได้อย่างปลอดภัยโดยการเพิ่มชื่อแพ็กเกจที่สมบูรณ์ลงในการกำหนดค่าแพ็กเกจที่สิ้นสุดได้อย่างปลอดภัย
  • การแมปหมวดหมู่แอปพลิเคชัน ผู้ให้บริการสามารถแมปแพ็กเกจใดก็ได้ (รวมถึงแพ็กเกจของบุคคลที่สาม) กับหมวดหมู่แอปที่รองรับ 2 หมวดหมู่ ได้แก่ แอปแผนที่และแอปสื่อ การแมปนี้ดำเนินการเพื่อให้แอปแผนที่ และแอปสื่อมีเกณฑ์การใช้งาน I/O ของดิสก์มากเกินไปสูงขึ้น เนื่องจากแอปเหล่านี้ มีแนวโน้มที่จะดาวน์โหลดและเขียนข้อมูลลงในดิสก์มากกว่าแอปประเภทอื่นๆ
  • เกณฑ์ระดับคอมโพเนนต์ กำหนดเกณฑ์ทั่วไปสำหรับแพ็กเกจของผู้ให้บริการทั้งหมด (กล่าวคือ แพ็กเกจที่ไม่ได้อยู่ภายใต้เกณฑ์เฉพาะของแพ็กเกจหรือเกณฑ์เฉพาะของหมวดหมู่แอปพลิเคชันจะได้รับ เกณฑ์เหล่านี้) ผู้ให้บริการต้องกำหนดเกณฑ์ระดับคอมโพเนนต์ที่ไม่ใช่ 0 เมื่อ กำหนดค่าการใช้งาน I/O ของดิสก์มากเกินไป
  • เกณฑ์เฉพาะของแพ็กเกจ ผู้ให้บริการสามารถกำหนดเกณฑ์พิเศษ สำหรับแพ็กเกจผู้ให้บริการที่เฉพาะเจาะจงได้ การแมปควรมีชื่อแพ็กเกจที่สมบูรณ์ เกณฑ์ที่กำหนดในการกำหนดค่านี้จะมีความสำคัญเหนือกว่าเกณฑ์ที่กำหนดในการกำหนดค่าอื่นๆ สำหรับแพ็กเกจที่ระบุ
  • เกณฑ์เฉพาะหมวดหมู่แอปพลิเคชัน ผู้ให้บริการสามารถระบุเกณฑ์พิเศษสำหรับหมวดหมู่แอปที่เฉพาะเจาะจงได้ หมวดหมู่แอปต้องเป็นหมวดหมู่ใดหมวดหมู่หนึ่งที่รองรับ ซึ่งได้แก่ แอปแผนที่และแอปสื่อ ระบบจะแมปเกณฑ์ที่กำหนดไว้ในการกำหนดค่านี้กับแพ็กเกจที่เฉพาะเจาะจงโดยใช้การแมปหมวดหมู่แอปพลิเคชัน
  • เกณฑ์ทั่วทั้งระบบ ผู้ให้บริการต้องไม่ระบุการกำหนดค่านี้

คำนำหน้าแพ็กเกจของผู้ให้บริการ แพ็กเกจที่หยุดทำงานได้อย่างปลอดภัย เกณฑ์ระดับคอมโพเนนต์ และการกำหนดค่าเกณฑ์เฉพาะแพ็กเกจ จะอัปเดตได้โดยการกำหนดค่าของผู้ให้บริการสำหรับ แอปและบริการของผู้ให้บริการเท่านั้น ผู้จำหน่ายจะอัปเดตการกำหนดค่าเกณฑ์ที่เฉพาะเจาะจงสำหรับหมวดหมู่แอปพลิเคชันได้เท่านั้นสำหรับแอปแผนที่และแอปสื่อทั้งหมด

เกณฑ์การใช้งานมากเกินไปประกอบด้วยจำนวนไบต์ที่อนุญาตให้เขียนในระหว่างช่วงเวลาต่อไปนี้

  • โหมดเบื้องหน้าเทียบกับโหมดเบื้องหลังของแอปหรือบริการ
  • โหมดโรงรถของระบบ

การจัดประเภทนี้ช่วยให้แอปและบริการที่ใช้งานอยู่เบื้องหน้าซึ่งผู้ใช้มองเห็นสามารถ เขียนข้อมูลได้มากกว่าแอปและบริการที่ทำงานอยู่เบื้องหลัง ในโหมดโรงรถ แอปและบริการมักจะดาวน์โหลดการอัปเดต ดังนั้นแต่ละรายการจึงต้องมีเกณฑ์ที่สูงกว่า แอปและบริการที่ทำงานในโหมดอื่นๆ

การกำหนดค่าระบบและของบุคคลที่สาม

OEM ไม่ควรอัปเดตการกำหนดค่าระบบและของบุคคลที่สาม

  • การกำหนดค่าระบบจะกำหนดเกณฑ์การใช้งาน I/O มากเกินไปและการดำเนินการสำหรับ แอปและบริการของระบบ
    • การกำหนดค่านี้ยังอัปเดตการแมปหมวดหมู่แอปพลิเคชันได้ด้วย ดังนั้น ฟิลด์การกำหนดค่านี้จึงแชร์ระหว่างการกำหนดค่าระบบและผู้ให้บริการ
  • การกำหนดค่าของบุคคลที่สามจะกำหนดเกณฑ์สำหรับแอปของบุคคลที่สามทั้งหมด แอปทั้งหมดที่ไม่ได้ติดตั้งไว้ล่วงหน้าในระบบถือเป็นแอปของบุคคลที่สาม
    • แอปของบุคคลที่สามทั้งหมดจะได้รับเกณฑ์เดียวกัน (เช่น ไม่มี แอปของบุคคลที่สามใดได้รับเกณฑ์พิเศษ) ยกเว้นแอปแผนที่และสื่อ ซึ่งเกณฑ์จะกำหนดโดยการกำหนดค่าของผู้ให้บริการ
    • เกณฑ์การใช้งาน I/O ของดิสก์มากเกินไปด้านล่างนี้เป็นเกณฑ์เริ่มต้นสำหรับ แอปของบุคคลที่สาม เกณฑ์เหล่านี้จะมาพร้อมกับอิมเมจระบบ
      • เขียน 3 GB ในโหมดเบื้องหน้าของแอป
      • เขียน 2 GiB ในโหมดพื้นหลังของแอป
      • เขียน 4 GiB ในโหมดโรงรถของระบบ
    • นี่คือเกณฑ์พื้นฐาน เราจะอัปเดตเกณฑ์เหล่านี้เมื่อทราบข้อมูลเพิ่มเติมเกี่ยวกับการใช้งาน I/O ของดิสก์

รูปแบบ XML การกำหนดค่าการใช้งานมากเกินไป

คุณวางการกำหนดค่าของผู้ให้บริการเริ่มต้นได้ (ไม่บังคับ) ที่ตำแหน่ง /vendor/etc/automotive/watchdog/resource_overuse_configuration.xml ในอิมเมจบิลด์ เมื่อไม่ได้ระบุการกำหนดค่านี้ ระบบจะใช้การกำหนดค่าที่ระบบกำหนด สำหรับแอปและบริการของผู้ให้บริการด้วย

ไฟล์ XML ควรมีแท็กเพียงแท็กเดียวสำหรับช่องการกำหนดค่าแต่ละช่อง ต้องกำหนดค่าการใช้งาน I/O มากเกินไปในไฟล์ 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>

อัปเดตการกำหนดค่าการใช้งานมากเกินไปผ่าน API ของระบบ CarWatchdogManager

การกำหนดค่า XML ข้างต้นจะระบุได้ในอิมเมจบิลด์เท่านั้น หาก OEM เลือกที่จะอัปเดตการกำหนดค่าในอุปกรณ์หลังจากเผยแพร่บิลด์ OEM จะใช้ API ต่อไปนี้เพื่อทำการเปลี่ยนแปลงการกำหนดค่าในอุปกรณ์ได้

  • ให้สิทธิ์ Car.PERMISSION_CONTROL_CAR_WATCHDOG_CONFIG แก่ ผู้โทร
  • ต้องใช้การกำหนดค่าที่มีอยู่เพื่ออัปเดตและตั้งค่าการกำหนดค่าใหม่ ใช้ API CarWatchdogManager.getResourceOveruseConfigurations เพื่อรับ การกำหนดค่าที่มีอยู่ หากไม่ได้ใช้การกำหนดค่าที่มีอยู่ ระบบจะเขียนทับการกำหนดค่าทั้งหมด (รวมถึงการกำหนดค่าของระบบและของบุคคลที่สาม) ซึ่งไม่แนะนำ
  • อัปเดตการกำหนดค่าที่มีอยู่ด้วยการเปลี่ยนแปลงส่วนต่างและตั้งค่าการกำหนดค่าใหม่ อย่าอัปเดตการกำหนดค่าระบบและคอมโพเนนต์ของบุคคลที่สาม
  • ใช้ API CarWatchdogManager.setResourceOveruseConfigurations เพื่อตั้งค่ากำหนดค่าใหม่
  • หากต้องการรับและตั้งค่าการกำหนดค่าการใช้งาน I/O ของดิสก์มากเกินไป ให้ใช้แฟล็ก 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% ของเกณฑ์การใช้ I/O ของดิสก์มากเกินไป แอปสามารถใช้ การแจ้งเตือนเหล่านี้เพื่อทำสิ่งต่อไปนี้

  • บันทึกสถิติการใช้งาน I/O ของดิสก์มากเกินไปเพื่อการวิเคราะห์แบบออฟไลน์ นักพัฒนาแอป สามารถใช้การบันทึกนี้เพื่อแก้ไขข้อบกพร่องของปัญหาการใช้ I/O ของดิสก์มากเกินไป
  • ลดการเขียน I/O ของดิสก์จนกว่าตัวนับการใช้งานมากเกินไปจะรีเซ็ต

ไคลเอ็นต์ 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. ลงทะเบียนอินสแตนซ์ Listener โดยการเรียกใช้ 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 และลงทะเบียน Listener การใช้งานทรัพยากรมากเกินไป กับเซิร์ฟเวอร์ 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 เพื่อดูสถิติการใช้งาน I/O มากเกินไปของแอป ATS ในช่วง 30 วันล่าสุด

ไคลเอ็นต์ Java

ใช้ CarWatchdogManager.getResourceOveruseStats เพื่อดู สถิติการใช้ทรัพยากรมากเกินไป ส่งผ่านแฟล็ก CarWatchdogManager.FLAG_RESOURCE_OVERUSE_IO เพื่อดูสถิติการใช้งาน I/O ของดิสก์มากเกินไป

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 เพื่อดึงข้อมูลสถิติการใช้งาน I/O ของดิสก์มากเกินไป

เท่านั้น 
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 ของดิสก์มากเกินไปซ้ำๆ (เช่น เขียนข้อมูลลงในดิสก์เกินเกณฑ์ที่กำหนด) ภายในระยะเวลาหนึ่งและปลอดภัยที่จะสิ้นสุดเมื่อมีการใช้ทรัพยากรมากเกินไป ผู้ใช้จะได้รับการแจ้งเตือนหลังจากที่รถเข้าสู่สถานะอนุญาตให้ผู้ขับขวานได้

การแจ้งเตือนผู้ใช้ครั้งแรก (ขณะขับรถ) จะโพสต์เป็นการแจ้งเตือนล่วงหน้า และการแจ้งเตือนอื่นๆ จะโพสต์ในศูนย์ การแจ้งเตือน

เช่น เมื่อแอปใช้ I/O ของดิสก์มากเกินไปซ้ำๆ ผู้ใช้จะได้รับการแจ้งเตือนต่อไปนี้

  • เมื่อผู้ใช้คลิกปุ่มจัดลําดับความสําคัญของแอป ระบบจะเปิดหน้าการตั้งค่าของแอป ซึ่งผู้ใช้สามารถเปิดหรือปิดการตั้งค่าจัดลําดับความสําคัญของประสิทธิภาพแอปได้
  • เมื่อผู้ใช้คลิกปุ่มปิดใช้แอป ระบบจะปิดใช้แอป จนกว่าผู้ใช้จะเปิดแอปหรือเปิดใช้ในการตั้งค่า ของแอป
  • สำหรับแอปที่ถอนการติดตั้งไม่ได้ ปุ่มปิดใช้แอปจะ แทนที่ด้วยปุ่มถอนการติดตั้งแอป เมื่อผู้ใช้คลิกปุ่มถอนการติดตั้งแอป ระบบจะเปิดหน้าการตั้งค่าของแอป ซึ่งผู้ใช้สามารถถอนการติดตั้งแอปได้

คำแนะนำสำหรับการติดตั้งใช้งานตัวเรียกโปรแกรม

เมื่อแอปถูกปิดใช้เนื่องจากใช้ทรัพยากรมากเกินไป แอปจะหายไปจาก แอปตัวเรียกใช้เริ่มต้นเนื่องจาก CarService อัปเดตสถานะที่เปิดใช้ของแอปเป็น PackageManager.COMPONENT_ENABLED_STATE_DISABLED_UNTIL_USED OEM ต้องอัปเดตการใช้งาน Launcher ในตัวเพื่อแสดงแอปเหล่านี้ตามปกติ เพื่อให้ผู้ใช้ใช้งานได้หากต้องการ ดูคำแนะนำต่อไปนี้ตามรุ่นที่สร้าง

การเปิดตัว Android SC V2