หน้านี้ได้รับการแปลโดย Cloud Translation API

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

ข้อมูลเบื้องต้น

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

ประโยชน์

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

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

การใช้ Play สำหรับ AI ในอุปกรณ์หมายความว่าคุณยอมรับข้อกำหนดในข้อตกลงการจัดจำหน่ายสำหรับนักพัฒนาแอปของ Google Play และข้อกำหนดในการให้บริการของชุดพัฒนาซอฟต์แวร์ Play Core
นักพัฒนาแอปที่เข้าร่วมโปรแกรมทดลองใช้ก่อนเปิดตัวจะต้องประเมิน Play สำหรับ AI ในอุปกรณ์และแสดงความคิดเห็นต่อ Google Play
โมเดลที่ Play ดาวน์โหลดไว้สำหรับ AI ในอุปกรณ์จะใช้ได้เฉพาะในแอปที่ดาวน์โหลดโมเดลนั้น ไม่ควรเสนอโมเดลให้กับแอปอื่นๆ เช่น ผ่านการเชื่อมต่อบริการ
แพ็กเกจ AI แต่ละรายการจะมีขนาดได้สูงสุด 1.5 GB โดยอิงตามขนาดการดาวน์โหลดแบบบีบอัด ขนาดแอปสะสมสูงสุดของแอปทุกเวอร์ชันที่สร้างขึ้นจาก App Bundle คือ 4 GB
แอปที่มีขนาดมากกว่า 1 GB ต้องตั้งค่าระดับ SDK ขั้นต่ำเป็น 21 ขึ้นไป
ในระหว่างโปรแกรมทดลองใช้ก่อนเปิดตัว Play สำหรับ AI ในอุปกรณ์อาจมีการเปลี่ยนแปลง

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

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

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

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

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

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

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

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

การเริ่มต้นใช้งาน LiteRT
- แอปตัวอย่างแสดงวิธีแพ็กเกจโมเดล LiteRT ในแพ็กเกจ AI และโหลดขณะรันไทม์
- มีโมเดล LiteRT ที่ผ่านการฝึกล่วงหน้ามากมายที่คุณใช้ในแพ็กเกจ AI เพื่อเริ่มต้นใช้งานได้
เริ่มต้นใช้งาน MediaPipe
- สำหรับแพ็กเกจติดตามอย่างรวดเร็วและแบบออนดีมานด์ คุณสามารถใช้ AssetCache.java เพื่อโหลดชิ้นงาน (เช่น .binarypb) ตามเส้นทางไฟล์
- สำหรับแพ็กเกจสำหรับเวลาติดตั้ง คุณสามารถใช้ AndroidAssetUtil.java

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

วิธีการเริ่มต้นใช้งาน Play สำหรับ AI ในอุปกรณ์โดยสังเขปมีดังนี้

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

ระบุรหัสบัญชีนักพัฒนาแอป Play

เนื่องจากฟีเจอร์นี้อยู่ในช่วงทดลองใช้ก่อนเปิดตัว บัญชีนักพัฒนาแอปของคุณจึงต้องอยู่ในรายการที่อนุญาตจึงจะมีสิทธิ์เข้าถึง Play สำหรับ AI ในอุปกรณ์ ยืนยันรหัสบัญชีนักพัฒนาแอป Play และชื่อแพ็กเกจแอปกับผู้จัดการพาร์ทเนอร์ Google Play หรือสมาชิกทีม Play for On-device AI ระบุว่าคุณจะกําหนดเป้าหมายโมเดลไปยังอุปกรณ์ที่เฉพาะเจาะจงหรือไม่ (ขั้นตอนที่ 3 จากส่วนก่อนหน้า) ขณะนี้เรากําลังเชิญพาร์ทเนอร์ Play บางรายให้ทดสอบฟีเจอร์นี้

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

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

แตกไฟล์โมเดลเป็นแพ็ก AI

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

ในไดเรกทอรีระดับบนสุดของโปรเจ็กต์ ให้สร้างไดเรกทอรีสำหรับ AI Package ระบบจะใช้ชื่อไดเรกทอรีนี้เป็นชื่อแพ็ก AI ชื่อแพ็ก AI ต้องขึ้นต้นด้วยตัวอักษรและมีได้เฉพาะตัวอักษร ตัวเลข และขีดล่างเท่านั้น
ในไดเรกทอรีแพ็กเกจ 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 ]"
    }
}
```
ในไฟล์ build.gradle ของแอปโปรเจ็กต์ ให้เพิ่มชื่อแพ็กเกจ AI ทั้งหมดในโปรเจ็กต์ดังที่แสดงด้านล่าง
```
// In the app build.gradle file:
android {
    ...
    assetPacks = [":ai-pack-name", ":ai-pack2-name"]
}
```
ในไฟล์ settings.gradle ของโปรเจ็กต์ ให้รวมแพ็กเกจ AI ทั้งหมดไว้ในโปรเจ็กต์ดังที่แสดงด้านล่าง
```
// In the settings.gradle file:
include ':app'
include ':ai-pack-name'
include ':ai-pack2-name'
```
สร้างไดเรกทอรี src/main/assets/ ในแพ็กเกจ AI
วางโมเดลในไดเรกทอรี src/main/assets คุณสามารถสร้างไดเรกทอรีย่อยที่นี่ได้ด้วย ตอนนี้โครงสร้างไดเรกทอรีสําหรับแอปของคุณควรมีลักษณะดังนี้
- build.gradle
- settings.gradle
- app/
- ai-pack-name/build.gradle
- ai-pack-name/src/main/assets/your-model-directories
เพิ่มโค้ดเพื่อโหลดและเรียกใช้โมเดล โดยวิธีการจะขึ้นอยู่กับรูปแบบการนำส่งของแพ็กเกจ AI ดูวิธีการสำหรับเมื่อติดตั้งและตามอย่างรวดเร็ว/ตามคําขอด้านล่าง
[ไม่บังคับ] กําหนดค่าการกําหนดอุปกรณ์เป้าหมายเพื่อแสดงโมเดลที่แตกต่างกันในอุปกรณ์ต่างๆ
สร้าง 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 ไม่พร้อมใช้งาน

ดูข้อมูลการดาวน์โหลดเกี่ยวกับแพ็ก 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)

หมายเหตุ: Play Store จะเรียกให้ดาวน์โหลดfast-followแพ็กต่างๆ โดยอัตโนมัติหลังจากที่ผู้ใช้ติดตั้งหรืออัปเดตแอป อย่างไรก็ตาม แพ็กเหล่านี้อาจยังไม่พร้อมใช้งานในทันที คุณต้องตรวจสอบสถานะของfast-follow แพ็กทุกครั้งที่เปิดแอป หากการดาวน์โหลดอยู่ระหว่างดำเนินการ ให้ตรวจสอบด้วยโปรแกรมรับฟัง หากการดาวน์โหลดถูกยกเลิกหรือหยุดชั่วคราว คุณสามารถกลับมาดาวน์โหลดต่อได้โดยใช้วิธี fetch() ตามที่อธิบายไว้ในส่วนติดตั้ง

การดาวน์โหลดขนาดใหญ่

หากการดาวน์โหลดมีขนาดใหญ่กว่า 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() แสดงจะมีรายการสำหรับแต่ละแพ็กที่ดาวน์โหลดและอัปเดตแล้วในปัจจุบัน

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

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

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

ระบบวงจรรวมบนชิป (SoC)
รุ่นของอุปกรณ์
RAM ของอุปกรณ์
ฟีเจอร์ของระบบ

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

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

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

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

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

เปิดใช้ฟีเจอร์นี้ในปลั๊กอิน 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: รุ่นอุปกรณ์ที่จะรวมไว้ในตัวเลือกนี้ (device_ids สูงสุด 10,000 รายการต่อกลุ่ม) พร็อพเพอร์ตี้นี้จะตรงตามเงื่อนไขหาก device ตรงกับ device_id ใดก็ได้ในรายการ
- build_brand: ผู้ผลิตอุปกรณ์
- build_device: รหัสรุ่นอุปกรณ์
excluded_device_ids: รุ่นอุปกรณ์ที่จะยกเว้นในตัวเลือกนี้ (device_ids สูงสุด 10,000 รายการต่อกลุ่ม) พร็อพเพอร์ตี้นี้จะตรงตามเงื่อนไขหาก device ไม่ตรงกับ device_id ในรายการ
- build_brand: ผู้ผลิตอุปกรณ์
- build_device: รหัสรุ่นอุปกรณ์
required_system_features: ฟีเจอร์ที่อุปกรณ์ต้องมีเพื่อที่จะรวมอยู่ในตัวเลือกนี้ (สูงสุด 100 ฟีเจอร์ต่อกลุ่ม) อุปกรณ์ต้องมีฟีเจอร์ของระบบทั้งหมดในรายการนี้จึงจะตรงตามพร็อพเพอร์ตี้นี้

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

ข้อมูลอ้างอิงฟีเจอร์ของระบบ
- name: ฟีเจอร์ของระบบ
System-on-chip: ระบบวงจรรวมบนชิปที่จะรวมอยู่ในตัวเลือกนี้ อุปกรณ์ต้องมีชิปในรายการนี้จึงจะตรงกับพร็อพเพอร์ตี้นี้
- manufacturer: ผู้ผลิตระบบวงจรรวมบนชิป
- model: System on chip model

เคล็ดลับ: การรวมพร็อพเพอร์ตี้หลายรายการในตัวเลือกเดียวจะสร้างตรรกะ AND เช่น

    <config:device-selector ram-min-bytes="7000000000">
        <config:included-device-id brand="google" device="flame"/>
    </config:device-selector>

จะสร้างเงื่อนไขสำหรับอุปกรณ์ทั้งหมดที่มี RAM มากกว่า 7 GB และ Pixel 4 ซึ่งเขียนได้ดังนี้

หากต้องการเงื่อนไข "หรือ" ให้สร้างตัวเลือกแยกต่างหากในกลุ่มอุปกรณ์เดียว เช่น

    <config:device-selector ram-min-bytes="7000000000"/>
    <config:device-selector>
          <config:included-device-id brand="google" device="flame"/>
    </config:device-selector>

จะสร้างเงื่อนไขสำหรับอุปกรณ์ทั้งหมดที่มี RAM มากกว่า 7 GB หรือเป็น Pixel 4 ซึ่งเขียนได้ดังนี้

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

<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")'
ดาวน์โหลด 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 ที่สร้างขึ้นจาก App 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>

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

ก่อนที่จะสร้างรุ่นสำหรับ App Bundle ใหม่ คุณสามารถทดสอบในเครื่องด้วยเครื่องมือแชร์แอปภายในหรือ Bundletool

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

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

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

Bundletool

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

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

สร้าง APK ที่มี Flag --local-testing

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

เชื่อมต่ออุปกรณ์และเรียกใช้ bundletool เพื่อโหลด APK ลงในอุปกรณ์โดยไม่ได้ผ่าน Google Play

# 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 ในอุปกรณ์

โปรดติดต่อผู้จัดการพาร์ทเนอร์ Google Play เพื่อรับสิทธิ์เข้าถึงแอปตัวอย่าง

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

แสดงความคิดเห็น

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

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

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