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

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

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

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

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

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

เริ่มต้นใช้งานแพ็ก 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 pack ในไดเรกทอรีระดับบนสุดของโปรเจ็กต์ ระบบจะใช้ชื่อไดเรกทอรีนี้เป็นชื่อแพ็ก AI ชื่อแพ็ก AI ต้องขึ้นต้นด้วยตัวอักษรและมีได้เฉพาะตัวอักษร ตัวเลข และขีดล่างเท่านั้น

  2. สร้างไฟล์ build.gradle ในไดเรกทอรีแพ็ก AI แล้วเพิ่มโค้ดต่อไปนี้ โปรดระบุชื่อแพ็ก 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 ดูวิธีการสำหรับเมื่อติดตั้งและตามอย่างรวดเร็ว/ตามคำขอด้านล่าง

  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 ด้วยการนำส่งแบบติดตามอย่างรวดเร็วหรือตามต้องการ ให้ใช้คลังการนำส่ง AI ของ Play

ประกาศการขึ้นต่อกันในไลบรารีการนำส่ง AI ของ Play

ในไฟล์ build.gradle ของแอป ให้ประกาศการอ้างอิงในไลบรารีการนำส่ง AI ของ Play 

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

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

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

ค่าที่แสดงผล สถานะ
ออบเจ็กต์ AiPackLocation ที่ถูกต้อง โฟลเดอร์รูทของแพ็ก AI พร้อมให้เข้าถึงได้ทันทีที่ assetsPath()
null แพ็ก 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 และตำแหน่งของแพ็ก แผนที่ที่ 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 (ยกเว้น): RAM สูงสุดที่จำเป็น (เป็นไบต์)
  • included_device_ids: รุ่นอุปกรณ์ที่จะรวมไว้ในตัวเลือกนี้ (สูงสุด 10000 device_ids ต่อกลุ่ม) พร็อพเพอร์ตี้นี้จะตรงตามเงื่อนไขหาก อุปกรณ์ตรงกับ device_id ใดก็ตามในรายการ
    • build_brand: ผู้ผลิตอุปกรณ์
    • build_device: รหัสรุ่นอุปกรณ์
  • excluded_device_ids: รุ่นอุปกรณ์ที่จะยกเว้นในตัวเลือกนี้ (สูงสุด 10000 device_ids ต่อกลุ่ม) พร็อพเพอร์ตี้นี้จะตรงตามเงื่อนไขหาก อุปกรณ์ไม่ตรงกับ device_id ใดๆ ในรายการ
    • build_brand: ผู้ผลิตอุปกรณ์
    • build_device: รหัสรุ่นอุปกรณ์

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

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

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

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

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

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

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

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

<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 ที่สร้างจาก Bundle จะ แยกตามกลุ่มอุปกรณ์

ใช้การกำหนดเป้าหมายอุปกรณ์สำหรับแพ็ก 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>

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

ก่อนสร้างรุ่นสำหรับ Bundle ใหม่ คุณสามารถทดสอบในเครื่องได้โดยใช้การแชร์แอปภายในหรือ 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 แบบออนดีมานด์และแบบติดตามอย่างรวดเร็วเป็น APK

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

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

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

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

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

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

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

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