Play สำหรับ AI ในอุปกรณ์ (เบต้า)

บทนำ

Play สำหรับ AI ในอุปกรณ์จะนำประโยชน์ของ Android App Bundle และการนำส่งของ Google Play มาใช้กับการเผยแพร่โมเดล ML ที่กำหนดเอง เพื่อให้คุณปรับปรุงประสิทธิภาพของโมเดลได้โดยมีความซับซ้อนของระบบนิเวศอุปกรณ์น้อยลงและไม่มีค่าใช้จ่ายเพิ่มเติม ซึ่งช่วยให้คุณเผยแพร่อาร์ติแฟกต์เดียวไปยัง Play ที่มีโค้ด ชิ้นงาน และโมเดล ML ของคุณ รวมถึงเลือกจากโหมดการนำส่งและตัวเลือกการกำหนดเป้าหมายที่หลากหลายได้

ประโยชน์

  • อัปโหลดอาร์ติแฟกต์การเผยแพร่รายการเดียวไปยัง Google Play และมอบสิทธิ์การโฮสต์ การนำส่ง การอัปเดต และการกำหนดเป้าหมายให้กับ Play โดยไม่มีค่าใช้จ่ายเพิ่มเติม
  • นำส่งโมเดล ML แบบติดตั้งทันที ดาวน์โหลดอัตโนมัติ หรือออนดีมานด์
    • การนำส่งขณะติดตั้งจะรับประกันได้ว่าโมเดลขนาดใหญ่มากจะพร้อมใช้งานเมื่อเปิดแอป ระบบจะติดตั้งโมเดลของคุณเป็น APK
    • การนำส่งแบบติดตามอย่างรวดเร็วจะเกิดขึ้นโดยอัตโนมัติในเบื้องหลังหลังจากติดตั้งแอปแล้ว ผู้ใช้อาจเปิดแอปก่อนที่โมเดลจะดาวน์โหลดเสร็จสมบูรณ์ ระบบจะดาวน์โหลดโมเดลไปยังพื้นที่เก็บข้อมูลภายในของแอป
    • การนำส่งแบบออนดีมานด์ช่วยให้คุณขอโมเดลได้ที่รันไทม์ ซึ่งมีประโยชน์ในกรณีที่จำเป็นต้องใช้โมเดลสำหรับโฟลว์ผู้ใช้บางรายการเท่านั้น ระบบจะดาวน์โหลดโมเดลลงในพื้นที่เก็บข้อมูลภายในของแอป
  • นำส่งตัวแปรของโมเดล ML ที่กำหนดเป้าหมายไปยังอุปกรณ์ที่เฉพาะเจาะจงตามรุ่นอุปกรณ์ พร็อพเพอร์ตี้ของระบบ หรือ RAM
  • ทำให้การอัปเดตแอปมีขนาดเล็กและได้รับการเพิ่มประสิทธิภาพด้วยการแพตช์อัตโนมัติของ Play ซึ่งหมายความว่าผู้ใช้จะดาวน์โหลดเฉพาะส่วนที่แตกต่างกันในไฟล์เท่านั้น

ข้อควรพิจารณา

วิธีใช้ Play สำหรับ AI ในอุปกรณ์

Play สำหรับ AI ในอุปกรณ์ใช้แพ็ก AI คุณจัดแพ็กเกจโมเดลที่กำหนดเองซึ่งพร้อมสำหรับการเผยแพร่ในแพ็ก AI ใน App Bundle คุณเลือกได้ว่าจะนำส่งแพ็ก AI ในระหว่างการติดตั้ง, นำส่งแบบติดตามอย่างรวดเร็ว หรือนำส่งแบบออนดีมานด์

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

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

แพ็ก AI มีเฉพาะโมเดลเท่านั้น ไม่อนุญาตให้ใช้ Java/Kotlin และไลบรารีแบบเนทีฟ หากต้องการจัดส่งไลบรารีหรือโค้ดเพื่อเรียกใช้โมเดล ML ให้ย้ายไลบรารีหรือโค้ดดังกล่าวไปยังโมดูลพื้นฐานหรือโมดูลฟีเจอร์ คุณสามารถกำหนดค่าโมดูลฟีเจอร์ให้มีการตั้งค่าการดาวน์โหลดและการกำหนดเป้าหมายเหมือนกับแพ็ก AI

ใช้ LiteRT และ MediaPipe กับแพ็ก AI

คุณสามารถใช้ LiteRT และ MediaPipe กับแพ็ก AI ได้ แพ็กเกจโมเดลของคุณในแพ็ก AI แล้วเข้าถึงโดยใช้คำแนะนำสำหรับแพ็กที่ติดตั้งพร้อมแอปหรือแพ็กที่ดาวน์โหลดอัตโนมัติและแพ็กแบบออนดีมานด์

อ่านเพิ่มเติม:

เริ่มต้นใช้งานแพ็ก AI

โดยภาพรวมแล้ว คุณสามารถเริ่มใช้ Play สำหรับ AI ในอุปกรณ์ได้ดังนี้

  1. รวมโมเดลของคุณเป็นแพ็ก AI ใน Android App Bundle และระบุวิธีนำส่งแพ็ก AI
  2. [ไม่บังคับ] หากต้องการนำส่งโมเดลที่แตกต่างกันไปยังอุปกรณ์ต่างๆ คุณสามารถกำหนดค่าการกำหนดอุปกรณ์เป้าหมายสำหรับแพ็ก AI ได้ ตัวอย่างเช่น คุณสามารถส่งแพ็ก AI A ไปยังอุปกรณ์รุ่นที่เฉพาะเจาะจง ส่งแพ็ก AI B ไปยังอุปกรณ์ที่มี RAM อย่างน้อย 6 GB และอุปกรณ์อื่นๆ ทั้งหมดอาจไม่ได้รับโมเดลใดๆ เลย
  3. [ไม่บังคับ] หากคุณใช้การนำส่งแบบออนดีมานด์หรือแบบติดตามอย่างรวดเร็ว ให้ผสานรวมไลบรารีการนำส่ง AI ของ Play เข้ากับแอปเพื่อดาวน์โหลดแพ็ก AI ตามต้องการ
  4. ทดสอบและเผยแพร่ App Bundle ของคุณไปยัง Google Play

ตรวจสอบเวอร์ชันปลั๊กอิน Android Gradle

หากต้องการใช้แพ็ก AI โปรดตรวจสอบว่าปลั๊กอิน Android Gradle (AGP) เป็นเวอร์ชัน 8.8 ขึ้นไป เวอร์ชันนี้มาพร้อมกับ Android Studio Ladybug 2

แตกโมเดลของคุณลงในแพ็ก AI

คุณไม่จำเป็นต้องใช้ Android Studio สำหรับขั้นตอนต่อไปนี้

  1. ในไดเรกทอรีระดับบนสุดของโปรเจ็กต์ ให้สร้างไดเรกทอรีสำหรับแพ็ก AI ระบบจะใช้ชื่อไดเรกทอรีนี้เป็นชื่อแพ็ก AI ชื่อแพ็ก AI ต้องขึ้นต้นด้วยตัวอักษรและมีได้เฉพาะตัวอักษร ตัวเลข และขีดล่างเท่านั้น

  2. ในไดเรกทอรีแพ็ก AI ให้สร้างไฟล์ build.gradle แล้วเพิ่มโค้ดต่อไปนี้ ตรวจสอบว่าได้ระบุชื่อแพ็ก AI และประเภทการนำส่งเพียงประเภทเดียว ดังนี้

    // In the AI pack's build.gradle file:
plugins {
  id 'com.android.ai-pack'
}

aiPack {
    packName = "ai-pack-name" // Directory name for the AI pack
    dynamicDelivery {
        deliveryType = "[ install-time | fast-follow | on-demand ]"
    }
}

  3. ในไฟล์ build.gradle ของแอปโปรเจ็กต์ ให้เพิ่มชื่อแพ็ก AI ทุกแพ็กในโปรเจ็กต์ตามที่แสดงด้านล่าง

    // In the app build.gradle file:
android {
    ...
    assetPacks = [":ai-pack-name", ":ai-pack2-name"]
}

  4. ในไฟล์ settings.gradle ของโปรเจ็กต์ ให้รวมแพ็ก AI ทั้งหมดในโปรเจ็กต์ดังที่แสดงด้านล่าง

    // In the settings.gradle file:
include ':app'
include ':ai-pack-name'
include ':ai-pack2-name'

  5. สร้างไดเรกทอรี src/main/assets/ ภายในแพ็ก AI

  6. วางโมเดลในไดเรกทอรี src/main/assets คุณสร้างไดเรกทอรีย่อยในนี้ได้ด้วย ตอนนี้โครงสร้างไดเรกทอรีของแอปควรมีลักษณะดังนี้

    • build.gradle
    • settings.gradle
    • app/
    • ai-pack-name/build.gradle
    • ai-pack-name/src/main/assets/your-model-directories

  7. เพิ่มโค้ดเพื่อโหลดและเรียกใช้โมเดล ซึ่งวิธีดำเนินการจะขึ้นอยู่กับโหมดการนำส่งของแพ็ก AI ดูวิธีการสำหรับเวลาติดตั้งและการดาวน์โหลดแบบ Fast Follow/ออนดีมานด์ด้านล่าง

  8. [ไม่บังคับ] กำหนดค่าการกำหนดอุปกรณ์เป้าหมายเพื่อนำส่งโมเดลที่แตกต่างกันไปยังอุปกรณ์ต่างๆ

  9. สร้าง Android App Bundle ด้วย Gradle ใน App Bundle ที่สร้างขึ้น ไดเรกทอรีระดับรูทจะมีสิ่งต่อไปนี้รวมอยู่ด้วย

    • ai-pack-name/manifest/AndroidManifest.xml: กำหนดค่าตัวระบุและโหมดการนำส่งของแพ็ก AI
    • ai-pack-name/assets/your-model-directories: ไดเรกทอรีที่มีชิ้นงานทั้งหมดที่ส่งเป็นส่วนหนึ่งของแพ็ก AI

    Gradle จะสร้างไฟล์ Manifest สำหรับแพ็ก AI แต่ละแพ็กและแสดงผลไดเรกทอรี assets/ ให้คุณ

กำหนดค่าการนำส่งขณะติดตั้ง

แพ็ก AI ที่กำหนดค่าเป็นแบบติดตั้งทันทีจะพร้อมใช้งานทันทีที่เปิดแอป ใช้ Java AssetManager API เพื่อเข้าถึงแพ็ก AI ที่แสดงในโหมดนี้

import android.content.res.AssetManager;
...
Context context = createPackageContext("com.example.app", 0);
AssetManager assetManager = context.getAssets();
InputStream is = assetManager.open("model-name");

กำหนดค่าการแสดงโฆษณาแบบติดตามอย่างรวดเร็วและแบบออนดีมานด์

หากต้องการดาวน์โหลดแพ็ก AI ด้วยการนำส่งแบบ Fast Follow หรือแบบออนดีมานด์ ให้ใช้ Play AI Delivery Library

ประกาศทรัพยากร Dependency ใน Play AI Delivery Library

ในไฟล์ build.gradle ของแอป ให้ประกาศทรัพยากร Dependency ใน Play AI Delivery Library ดังนี้

dependencies {
  ...
  implementation "com.google.android.play:ai-delivery:0.1.1-alpha01"
}

ตรวจสอบสถานะ

แพ็ก AI แต่ละแพ็กจะจัดเก็บไว้ในโฟลเดอร์แยกต่างหากในที่จัดเก็บข้อมูลภายในของแอป ใช้เมธอด getPackLocation() เพื่อระบุโฟลเดอร์รูทของแพ็ก AI เมธอดนี้จะแสดงผลค่าต่อไปนี้

แสดงผลค่า สถานะ
ออบเจ็กต์ AiPackLocation ที่ถูกต้อง โฟลเดอร์รูทของแพ็ก AI พร้อมให้เข้าถึงได้ทันทีที่ assetsPath()
null ไม่รู้จักแพ็ก AI หรือแพ็ก AI ไม่พร้อมใช้งาน

ดูข้อมูลการดาวน์โหลดเกี่ยวกับแพ็ก AI

ใช้เมธอด
getPackStates() เพื่อกำหนดขนาดของการดาวน์โหลดและดูว่าแพ็กกำลังดาวน์โหลดอยู่หรือไม่

Task<AiPackStates> getPackStates(List<String> packNames)

getPackStates() เป็นเมธอดแบบอะซิงโครนัสที่แสดงผล Task<AiPackStates> เมธอด packStates() ของออบเจ็กต์ AiPackStates จะแสดงผล Map<String, AiPackState> แผนที่นี้มีสถานะของแพ็ก AI ที่ขอแต่ละรายการ โดยมีคีย์เป็นชื่อ

Map<String, AiPackState> AiPackStates#packStates()

คำขอสุดท้ายจะแสดงดังต่อไปนี้

final String aiPackName = "myAiPackName";

aiPackManager
    .getPackStates(Collections.singletonList(aiPackName))
    .addOnCompleteListener(new OnCompleteListener<AiPackStates>() {
        @Override
        public void onComplete(Task<AiPackStates> task) {
            AiPackStates aiPackStates;
            try {
                aiPackStates = task.getResult();
                AiPackState aiPackState =
                    aiPackStates.packStates().get(aiPackName);
            } catch (RuntimeExecutionException e) {
                Log.d("MainActivity", e.getMessage());
                return;
            });

เมธอด AiPackState ต่อไปนี้จะระบุขนาดของแพ็ก AI, จำนวนที่ดาวน์โหลดจนถึงตอนนี้ (หากมีการขอ) และจำนวนที่โอนไปยังแอปแล้ว

หากต้องการดูสถานะของแพ็ก AI ให้ใช้เมธอด status() ซึ่งจะแสดงสถานะเป็นจำนวนเต็มที่สอดคล้องกับช่องค่าคงที่ในคลาส AiPackStatus แพ็ก AI ที่ยังไม่ได้ติดตั้งจะมีสถานะเป็นAiPackStatus.NOT_INSTALLED

หากคำขอล้มเหลว ให้ใช้เมธอด errorCode() ซึ่งค่าที่แสดงผลจะสอดคล้องกับช่องค่าคงที่ในคลาส AiPackErrorCode

ติดตั้ง

ใช้เมธอด fetch() เพื่อดาวน์โหลดแพ็ก AI เป็นครั้งแรกหรือเรียกใช้การอัปเดตแพ็ก AI ให้เสร็จสมบูรณ์

Task<AiPackStates> fetch(List<String> packNames)

เมธอดนี้จะแสดงผลออบเจ็กต์ AiPackStates ที่มีรายการแพ็กเกจ รวมถึงสถานะและขนาดการดาวน์โหลดเริ่มต้น หากแพ็ก AI ที่ขอผ่าน fetch() กำลังดาวน์โหลดอยู่ ระบบจะแสดงสถานะการดาวน์โหลดและจะไม่เริ่มการดาวน์โหลดเพิ่มเติม

ตรวจสอบสถานะการดาวน์โหลด

คุณควรใช้ AiPackStateUpdateListener เพื่อติดตามความคืบหน้าในการติดตั้งแพ็ก AI การอัปเดตสถานะจะแบ่งตามแพ็กเพื่อรองรับการติดตามสถานะของแพ็ก AI แต่ละแพ็ก คุณสามารถเริ่มใช้แพ็ก AI ที่พร้อมใช้งานก่อนที่การดาวน์โหลดอื่นๆ ทั้งหมดสำหรับคำขอของคุณจะเสร็จสมบูรณ์

void registerListener(AiPackStateUpdateListener listener)
void unregisterListener(AiPackStateUpdateListener listener)
การดาวน์โหลดขนาดใหญ่

หากการดาวน์โหลดมีขนาดใหญ่กว่า 200 MB และผู้ใช้ไม่ได้ใช้ Wi-Fi การดาวน์โหลดจะไม่เริ่มจนกว่าผู้ใช้จะให้ความยินยอมอย่างชัดแจ้งเพื่อดำเนินการดาวน์โหลดต่อโดยใช้การเชื่อมต่ออินเทอร์เน็ตมือถือ ในทำนองเดียวกัน หากการดาวน์โหลดมีขนาดใหญ่และผู้ใช้สูญเสียการเชื่อมต่อ Wi-Fi การดาวน์โหลดจะหยุดชั่วคราวและต้องได้รับความยินยอมอย่างชัดแจ้งเพื่อดำเนินการต่อโดยใช้การเชื่อมต่ออินเทอร์เน็ตมือถือ แพ็กที่หยุดชั่วคราวมีสถานะเป็น WAITING_FOR_WIFI หากต้องการเรียกใช้ขั้นตอน UI เพื่อแจ้งให้ผู้ใช้ให้ความยินยอม ให้ใช้เมธอด showConfirmationDialog()

โปรดทราบว่าหากแอปไม่เรียกใช้เมธอดนี้ การดาวน์โหลดจะหยุดชั่วคราวและจะกลับมาทำงานอีกครั้งโดยอัตโนมัติเมื่อผู้ใช้กลับมาเชื่อมต่อ Wi-Fi เท่านั้น

ต้องมีการยืนยันจากผู้ใช้

หากแพ็กมีสถานะ REQUIRES_USER_CONFIRMATION การดาวน์โหลดจะไม่ดำเนินการต่อจนกว่าผู้ใช้จะยอมรับกล่องโต้ตอบที่แสดงพร้อมกับ showConfirmationDialog() สถานะนี้อาจเกิดขึ้นเมื่อ Play ไม่รู้จักแอป เช่น หากแอปเป็นแบบไซด์โหลด โปรดทราบว่าการเรียกใช้ showConfirmationDialog() ในกรณีนี้จะทำให้แอปได้รับการอัปเดต หลังจากอัปเดตแล้ว คุณจะต้องขอแพ็ก AI อีกครั้ง

ตัวอย่างการใช้งาน Listener มีดังนี้

AiPackStateUpdateListener aiPackStateUpdateListener = new AiPackStateUpdateListener() {
    private final ActivityResultLauncher<IntentSenderRequest> activityResultLauncher =
      registerForActivityResult(
          new ActivityResultContracts.StartIntentSenderForResult(),
          new ActivityResultCallback<ActivityResult>() {
            @Override
            public void onActivityResult(ActivityResult result) {
              if (result.getResultCode() == RESULT_OK) {
                Log.d(TAG, "Confirmation dialog has been accepted.");
              } else if (result.getResultCode() == RESULT_CANCELED) {
                Log.d(TAG, "Confirmation dialog has been denied by the user.");
              }
            }
          });

    @Override
    public void onStateUpdate(AiPackState aiPackState) {
      switch (aiPackState.status()) {
        case AiPackStatus.PENDING:
          Log.i(TAG, "Pending");
          break;

        case AiPackStatus.DOWNLOADING:
          long downloaded = aiPackState.bytesDownloaded();
          long totalSize = aiPackState.totalBytesToDownload();
          double percent = 100.0 * downloaded / totalSize;

          Log.i(TAG, "PercentDone=" + String.format("%.2f", percent));
          break;

        case AiPackStatus.TRANSFERRING:
          // 100% downloaded and assets are being transferred.
          // Notify user to wait until transfer is complete.
          break;

        case AiPackStatus.COMPLETED:
          // AI pack is ready to use. Run the model.
          break;

        case AiPackStatus.FAILED:
          // Request failed. Notify user.
          Log.e(TAG, aiPackState.errorCode());
          break;

        case AiPackStatus.CANCELED:
          // Request canceled. Notify user.
          break;

        case AiPackStatus.WAITING_FOR_WIFI:
        case AiPackStatus.REQUIRES_USER_CONFIRMATION:
          if (!confirmationDialogShown) {
            aiPackManager.showConfirmationDialog(activityResultLauncher);
            confirmationDialogShown = true;
          }
          break;

        case AiPackStatus.NOT_INSTALLED:
          // AI pack is not downloaded yet.
          break;
        case AiPackStatus.UNKNOWN:
          Log.wtf(TAG, "AI pack status unknown")
          break;
      }
    }
}

หรือจะใช้เมธอด getPackStates() เพื่อดูสถานะการดาวน์โหลดปัจจุบันก็ได้ AiPackStates มีข้อมูลความคืบหน้าในการดาวน์โหลด สถานะการดาวน์โหลด และรหัสข้อผิดพลาดที่ทำให้ดาวน์โหลดไม่สำเร็จ

เข้าถึงแพ็ก AI

คุณสามารถเข้าถึงแพ็ก AI โดยใช้การเรียกใช้ระบบไฟล์หลังจากคำขอดาวน์โหลดถึงสถานะ COMPLETED ใช้เมธอด getPackLocation() เพื่อรับโฟลเดอร์รูทของแพ็ก AI

แพ็ก AI จะจัดเก็บไว้ในไดเรกทอรี assets ภายในไดเรกทอรีรากของแพ็ก AI คุณดูเส้นทางไปยังไดเรกทอรี assets ได้โดยใช้วิธีที่สะดวกอย่าง assetsPath() ใช้วิธีการต่อไปนี้เพื่อดูเส้นทางไปยังชิ้นงานที่เฉพาะเจาะจง

private String getAbsoluteAiAssetPath(String aiPack, String relativeAiAssetPath) {
    AiPackLocation aiPackPath = aiPackManager.getPackLocation(aiPack);

    if (aiPackPath == null) {
        // AI pack is not ready
        return null;
    }

    String aiAssetsFolderPath = aiPackPath.assetsPath();
    // equivalent to: FilenameUtils.concat(aiPackPath.path(), "assets");
    String aiAssetPath = FilenameUtils.concat(aiAssetsFolderPath, relativeAiAssetPath);
    return aiAssetPath;
}

กำหนดค่าการกำหนดอุปกรณ์เป้าหมาย

คุณสามารถทำตามวิธีการกำหนดอุปกรณ์เป้าหมายเพื่อระบุอุปกรณ์หรือกลุ่มอุปกรณ์ที่ควรได้รับแพ็ก AI

เมธอดอื่นๆ ของ Play AI Delivery API

ต่อไปนี้คือเมธอด API เพิ่มเติมบางส่วนที่คุณอาจต้องการใช้ในแอป

ยกเลิกคำขอ

ใช้ cancel() เพื่อยกเลิกคำขอแพ็กเกจ AI ที่ใช้งานอยู่ โปรดทราบว่าคำขอนี้เป็นการดำเนินการที่พยายามอย่างเต็มที่

นำแพ็ก AI ออก

ใช้ removePack() เพื่อกำหนดเวลาการนำแพ็ก AI ออก

ดูตำแหน่งของแพ็ก AI หลายแพ็ก

ใช้ getPackLocations() เพื่อค้นหาสถานะของแพ็ก AI หลายรายการพร้อมกัน ซึ่งจะแสดงแผนที่ของแพ็ก AI และตำแหน่งของแพ็ก AI แผนที่ที่ getPackLocations() แสดงผลจะมีรายการสำหรับแต่ละแพ็กที่ดาวน์โหลดไว้และเป็นเวอร์ชันล่าสุดในปัจจุบัน

การกำหนดอุปกรณ์เป้าหมาย

การกำหนดอุปกรณ์เป้าหมายช่วยให้คุณควบคุมได้ละเอียดยิ่งขึ้นว่าส่วนใดของ App Bundle จะส่งไปยังอุปกรณ์ที่เฉพาะเจาะจง เช่น คุณสามารถตรวจสอบว่าโมเดลขนาดใหญ่จะส่งไปยังอุปกรณ์ที่มี RAM สูงเท่านั้น หรือจะส่งโมเดลเวอร์ชันต่างๆ ไปยังอุปกรณ์ที่ต่างกันก็ได้

คุณสามารถกำหนดเป้าหมายพร็อพเพอร์ตี้ของอุปกรณ์ได้ เช่น

ภาพรวมของขั้นตอนที่ต้องทำ

คุณต้องทำตามขั้นตอนต่อไปนี้เพื่อเปิดใช้การกำหนดอุปกรณ์เป้าหมาย

  1. กำหนดกลุ่มอุปกรณ์ในไฟล์ XML
  2. ระบุว่าส่วนใดของแพ็กเกจควรส่งไปยังกลุ่มอุปกรณ์ใด
  3. [ไม่บังคับ] ทดสอบการกำหนดค่าในเครื่อง
  4. อัปโหลดแพ็กเกจ (ที่มีไฟล์ XML) ไปยัง Google Play

ตรวจสอบเวอร์ชันปลั๊กอิน Android Gradle

หากต้องการใช้การกำหนดอุปกรณ์เป้าหมาย ให้ตรวจสอบว่าปลั๊กอิน Android Gradle (AGP) เป็นเวอร์ชัน 8.10.0 ขึ้นไป ซึ่งมาพร้อมกับ Android Studio (Meerkat 2 ขึ้นไป) ดาวน์โหลด Android Studio เวอร์ชันเสถียรล่าสุด

เปิดใช้ฟีเจอร์นี้ในปลั๊กอิน Android Gradle

คุณต้องเปิดใช้การกำหนดอุปกรณ์เป้าหมายอย่างชัดเจนในไฟล์ gradle.properties ดังนี้

android.experimental.enableDeviceTargetingConfigApi=true

สร้างไฟล์ XML การกำหนดค่าการกำหนดอุปกรณ์เป้าหมาย

ไฟล์การกำหนดค่าการกำหนดอุปกรณ์เป้าหมายคือไฟล์ XML ที่คุณใช้กำหนดกลุ่มอุปกรณ์ที่กำหนดเอง ตัวอย่างเช่น คุณสามารถกำหนดกลุ่มอุปกรณ์ชื่อ qti_v79 ซึ่งมีอุปกรณ์ทั้งหมดที่มีระบบวงจรรวมบนชิป Qualcomm SM8750 ดังนี้

<config:device-targeting-config
    xmlns:config="http://schemas.android.com/apk/config">

    <config:device-group name="qti_v79">
        <config:device-selector>
            <config:system-on-chip manufacturer="QTI" model="SM8750"/>
        </config:device-selector>
    </config:device-group>

</config:device-targeting-config>

กลุ่มอุปกรณ์ประกอบด้วยตัวเลือกอุปกรณ์สูงสุด 5 รายการ อุปกรณ์จะรวมอยู่ในกลุ่มอุปกรณ์หากตรงตามตัวเลือกอุปกรณ์ใดๆ

ตัวเลือกอุปกรณ์มีพร็อพเพอร์ตี้อุปกรณ์ได้มากกว่า 1 รายการ ระบบจะเลือกอุปกรณ์หากตรงกับพร็อพเพอร์ตี้อุปกรณ์ทั้งหมดของตัวเลือก

หากอุปกรณ์ตรงกับหลายกลุ่ม ระบบจะแสดงเนื้อหาสำหรับกลุ่มที่กำหนดไว้ก่อนในไฟล์ XML ลำดับที่คุณกำหนดกลุ่มในไฟล์ XML คือลำดับความสำคัญ

หากอุปกรณ์ไม่ตรงกับกลุ่มใดเลย อุปกรณ์จะได้รับกลุ่ม "อื่นๆ" เริ่มต้น ระบบจะสร้างกลุ่มนี้โดยอัตโนมัติและไม่ควรกำหนดไว้อย่างชัดแจ้ง

คุณสมบัติของอุปกรณ์ที่ใช้ได้

  • device_ram: ข้อกำหนด RAM ของอุปกรณ์
    • min_bytes (รวม): RAM ขั้นต่ำที่จำเป็น (เป็นไบต์)
    • max_bytes (exclusive): RAM สูงสุดที่จำเป็น (เป็นไบต์)
  • included_device_ids: รุ่นอุปกรณ์ที่จะรวมไว้ในตัวเลือกนี้ (สูงสุด 10,000 device_ids ต่อกลุ่ม) พร็อพเพอร์ตี้นี้จะเป็นไปตามเงื่อนไขหากอุปกรณ์ตรงกับ device_id ใดก็ตามในรายการ
    • build_brand: ผู้ผลิตอุปกรณ์
    • build_device: รหัสรุ่นอุปกรณ์
  • excluded_device_ids: รุ่นอุปกรณ์ที่จะยกเว้นในตัวเลือกนี้ (สูงสุด 10,000 device_ids ต่อกลุ่ม) พร็อพเพอร์ตี้นี้จะถือว่าตรงตามเงื่อนไขหากอุปกรณ์ไม่ตรงกับ device_id ใดๆ ในรายการ
    • build_brand: ผู้ผลิตอุปกรณ์
    • build_device: รหัสรุ่นอุปกรณ์

  • required_system_features: ฟีเจอร์ที่อุปกรณ์ต้องมีเพื่อให้ตัวเลือกนี้รวมไว้ (สูงสุด 100 ฟีเจอร์ต่อกลุ่ม) อุปกรณ์ต้องมีฟีเจอร์ทั้งหมดของระบบในรายการนี้เพื่อให้เป็นไปตามพร็อพเพอร์ตี้นี้

    ข้อมูลอ้างอิงฟีเจอร์ของระบบ

    • name: ฟีเจอร์ของระบบ

  • forbidden_system_features: ฟีเจอร์ที่อุปกรณ์ต้องไม่มีเพื่อให้ตัวเลือกนี้รวมไว้ (สูงสุด 100 ฟีเจอร์ต่อกลุ่ม) หากอุปกรณ์มีฟีเจอร์ระบบใดๆ ในรายการนี้ แสดงว่าอุปกรณ์ไม่เป็นไปตามพร็อพเพอร์ตี้นี้

    ข้อมูลอ้างอิงฟีเจอร์ของระบบ

    • name: ฟีเจอร์ของระบบ

  • system-on-chip: ระบบวงจรรวมบนชิปที่จะรวมไว้ในตัวเลือกนี้ อุปกรณ์ต้องมีชิปในรายการนี้เพื่อให้เป็นไปตามพร็อพเพอร์ตี้นี้

ต่อไปนี้คือตัวอย่างที่แสดงพร็อพเพอร์ตี้อุปกรณ์ที่เป็นไปได้ทั้งหมด

<config:device-targeting-config
    xmlns:config="http://schemas.android.com/apk/config">

    <config:device-group name="myCustomGroup1">
      <config:device-selector ram-min-bytes="8000000000">
        <config:included-device-id brand="google" device="redfin"/>
        <config:included-device-id brand="google" device="sailfish"/>
        <config:included-device-id brand="good-brand"/>
        <config:excluded-device-id brand="google" device="caiman"/>
        <config:system-on-chip manufacturer="Sinclair" model="ZX80"/>
        <config:system-on-chip manufacturer="Commodore" model="C64"/>
      </config:device-selector>
      <config:device-selector ram-min-bytes="16000000000"/>
    </config:device-group>

    <config:device-group name="myCustomGroup2">
      <config:device-selector ram-min-bytes="4000000000" ram-max-bytes="8000000000">
        <config:required-system-feature name="android.hardware.bluetooth"/>
        <config:required-system-feature name="android.hardware.location"/>
        <config:forbidden-system-feature name="android.hardware.camera"/>
        <config:forbidden-system-feature name="mindcontrol.laser"/>
      </config:device-selector>
    </config:device-group>

</config:device-targeting-config>

รหัสผู้ผลิตอุปกรณ์และรหัสรุ่นอุปกรณ์อย่างเป็นทางการ

คุณดูรูปแบบที่ถูกต้องสำหรับผู้ผลิตอุปกรณ์และรหัสรุ่นได้โดยใช้แคตตาล็อกอุปกรณ์ใน Google Play Console โดยทำอย่างใดอย่างหนึ่งต่อไปนี้

  • ตรวจสอบอุปกรณ์แต่ละเครื่องโดยใช้แคตตาล็อกอุปกรณ์ และค้นหาผู้ผลิตและรหัสรุ่นในตำแหน่งที่แสดงในตัวอย่างด้านล่าง (สำหรับ Google Pixel 4a ผู้ผลิตคือ "Google" และรหัสรุ่นคือ "sunfish")

    หน้า Pixel 4a ในแคตตาล็อกอุปกรณ์

    หน้า Pixel 4a ในแคตตาล็อกอุปกรณ์

  • ดาวน์โหลดไฟล์ CSV ของอุปกรณ์ที่รองรับ และใช้ผู้ผลิตและรหัสรุ่นสำหรับช่อง build_brand และ build_device ตามลำดับ

รวมไฟล์การกำหนดค่าการกำหนดอุปกรณ์เป้าหมายไว้ใน App Bundle

เพิ่มโค้ดต่อไปนี้ในไฟล์ build.gradle ของโมดูลหลัก

android {
  ...
  bundle {
    deviceTargetingConfig = file('device_targeting_config.xml')
    deviceGroup {
      enableSplit = true   // split bundle by #group
      defaultGroup = "other"  // group used for standalone APKs
    }
  }
  ...
}

device_targeting_config.xml คือเส้นทางของไฟล์การกำหนดค่าที่สัมพันธ์กับโมดูลหลัก ซึ่งจะช่วยให้มั่นใจได้ว่าไฟล์การกำหนดค่าจะรวมอยู่ใน App Bundle ของคุณ

ส่วนคำสั่ง deviceGroup ช่วยให้มั่นใจได้ว่า APK ที่สร้างจากแพ็กเกจจะแยกตามกลุ่มอุปกรณ์

ใช้การกำหนดอุปกรณ์เป้าหมายสำหรับแพ็ก AI

คุณสามารถเพิ่มประสิทธิภาพขนาดในอุปกรณ์ได้โดยการส่งโมเดลขนาดใหญ่ไปยังอุปกรณ์ที่เรียกใช้โมเดลเหล่านั้นได้เท่านั้น

แบ่งย่อยแพ็ก AI ตามกลุ่มอุปกรณ์โดยใช้ไดเรกทอรีแพ็ก AI ที่มีอยู่ซึ่งสร้างขึ้นในขั้นตอนสุดท้าย และใส่คำต่อท้ายโฟลเดอร์ที่เหมาะสม (ตามที่อธิบายไว้ด้านล่าง) ด้วย #group_myCustomGroup1, #group_myCustomGroup2 เป็นต้น เมื่อใช้แพ็ก AI ในแอป คุณไม่จำเป็นต้องระบุโฟลเดอร์ด้วยคำต่อท้าย (กล่าวคือ ระบบจะตัดคำต่อท้ายออกโดยอัตโนมัติในระหว่างกระบวนการบิลด์)

หลังจากขั้นตอนก่อนหน้า การดำเนินการนี้อาจมีลักษณะดังนี้

...
.../ai-pack-name/src/main/assets/image-classifier#group_myCustomGroup1/
.../ai-pack-name/src/main/assets/image-classifier#group_myCustomGroup2/
...

ในตัวอย่างนี้ คุณจะอ้างอิง ai-pack-name/assets/image-classifier/ โดยไม่มีคำต่อท้าย

อุปกรณ์ใน myCustomGroup1 จะได้รับเนื้อหาทั้งหมดใน image-classifier#group_myCustomGroup1/ ส่วนอุปกรณ์ใน myCustomGroup2 จะได้รับเนื้อหาทั้งหมดใน image-classifier#group_myCustomGroup2/

อุปกรณ์ที่ไม่ได้เป็นของ myCustomGroup1 หรือ myCustomGroup2 จะได้รับแพ็ก ai-pack-name เปล่า

เนื่องจากอุปกรณ์ที่ไม่ตรงกับกลุ่มอุปกรณ์ใดๆ จะได้รับแพ็ก AI ตัวแปรเริ่มต้น ซึ่งรวมถึงทุกอย่างที่ไม่ได้อยู่ในไดเรกทอรีที่มี #group_suffix

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

ใช้การกำหนดอุปกรณ์เป้าหมายสำหรับโมดูลฟีเจอร์

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

หากต้องการส่งโมดูลฟีเจอร์ไปยังอุปกรณ์ที่อยู่ใน myCustomGroup1 หรือ myCustomGroup2 ให้แก้ไข AndroidManifest.xml ดังนี้

<manifest ...>
  ...
  <dist:module dist:title="...">
    <dist:delivery>
      <dist:install-time>
        <dist:conditions>
          <dist:device-groups>
            <dist:device-group dist:name="myCustomGroup1"/>
            <dist:device-group dist:name="myCustomGroup2"/>
          </dist:device-groups>
          ...
        </dist:conditions>
      </dist:install-time>
    </dist:delivery>
  </dist:module>
  ...
</manifest>

ทดสอบในเครื่อง

ก่อนสร้างรุ่นสำหรับแพ็กเกจใหม่ คุณสามารถทดสอบในเครื่องได้โดยใช้การแชร์แอปภายในหรือ Bundletool

การแชร์แอปภายใน

การแชร์แอปภายในช่วยให้คุณใช้ App Bundle เพื่อสร้าง URL ได้อย่างรวดเร็ว ซึ่งคุณสามารถแตะในอุปกรณ์ที่ใช้เพื่อติดตั้งสิ่งที่ Google Play จะติดตั้งสำหรับอุปกรณ์นั้นหากแอปเวอร์ชันดังกล่าวเผยแพร่อยู่ในแทร็กทดสอบหรือแทร็กเวอร์ชันที่ใช้งานจริง

ดูวิธีการแชร์แอปภายใน

Bundletool

หรือจะสร้าง APK โดยใช้ bundletool (1.18.0 ขึ้นไป) แล้วไซด์โหลดลงในอุปกรณ์ก็ได้ ทำตามขั้นตอนต่อไปนี้เพื่อทดสอบแอปในเครื่องโดยใช้ bundletool

  1. สร้าง App Bundle ด้วย Android Studio หรือ bundletool

  2. สร้าง APK ด้วยแฟล็ก --local-testing ดังนี้

    java -jar bundletool-all.jar build-apks --bundle=path/to/your/bundle.aab \
  --output=output.apks --local-testing

  3. เชื่อมต่ออุปกรณ์และเรียกใช้ bundletool เพื่อไซด์โหลด APK ดังนี้

    # Example without Device Targeting Configuration
java -jar bundletool.jar install-apks --apks=output.apks

    # Example with Device Targeting Configuration (you must specify which groups the connected device belongs to)
java -jar bundletool.jar install-apks --apks=output.apks --device-groups=myCustomGroup1,myCustomGroup2

ข้อจำกัดของการทดสอบในเครื่องด้วย bundletool

ข้อจำกัดของการทดสอบในเครื่องด้วย bundletool มีดังนี้

  • แพ็ก fast-follow ทำงานเหมือนแพ็ก on-demand กล่าวคือ ระบบจะไม่ดึงข้อมูลโดยอัตโนมัติเมื่อมีการไซด์โหลดแอป นักพัฒนาแอปต้องขอสิทธิ์ด้วยตนเองเมื่อแอปเริ่มทำงาน ซึ่งไม่จำเป็นต้องเปลี่ยนแปลงโค้ดใดๆ ในแอป
  • แพ็กจะดึงข้อมูลจากพื้นที่เก็บข้อมูลภายนอกแทน Play คุณจึงทดสอบลักษณะการทำงานของโค้ดในกรณีที่เกิดข้อผิดพลาดเกี่ยวกับเครือข่ายไม่ได้
  • การทดสอบในเครื่องไม่ครอบคลุมสถานการณ์รอ Wi-Fi
  • ไม่รองรับการอัปเดต ก่อนติดตั้งบิลด์เวอร์ชันใหม่ ให้ถอนการติดตั้งเวอร์ชันก่อนหน้าด้วยตนเอง

ยืนยันว่ามีการติดตั้ง APK ที่ถูกต้อง

ใช้วิธีการต่อไปนี้เพื่อให้แน่ใจว่ามีการติดตั้งเฉพาะ APK ที่ถูกต้องในอุปกรณ์

adb shell pm path {packageName}

คุณควรเห็นข้อความในลักษณะนี้

package:{...}/base.apk
package:{...}/split_config.en.apk
package:{...}/split_config.xxhdpi.apk
package:{...}/split_main_ai-pack-name.apk
package:{...}/split_main_ai-pack-name.config.group_myCustomGroup1.apk

โปรดทราบว่าคุณจะเห็นเฉพาะ APK ในรายการนี้ ซึ่งสร้างขึ้นจากโมดูลฟีเจอร์และแพ็ก AI สำหรับเวลาติดตั้ง แพ็ก AI แบบออนดีมานด์และแบบ Fast-Follow จะไม่ติดตั้งเป็น APK

ทดสอบและเผยแพร่ใน Google Play

เราขอแนะนำให้ทดสอบแอปตั้งแต่ต้นจนจบใน Google Play ด้วยแทร็กทดสอบภายใน

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

แอปตัวอย่างที่ใช้ Play สำหรับ AI ในอุปกรณ์

ดาวน์โหลดแอปตัวอย่าง

โดยจะสาธิตวิธีใช้โหมดการแสดงโฆษณาแต่ละโหมด รวมถึงการกำหนดค่าการกำหนดอุปกรณ์เป้าหมาย ดูส่วนการทดสอบในเครื่องเพื่อเริ่มต้นใช้งาน

เนื้อหาที่เกี่ยวข้อง

ดูข้อมูลเพิ่มเติมเกี่ยวกับ Android App Bundle และอ่านข้อมูลอ้างอิงสำหรับ AI Delivery SDK