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

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

การกำหนดเป้าหมายระดับอุปกรณ์คืออะไร

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

เช่นเดียวกับ Play Asset Delivery การกำหนดเป้าหมายระดับอุปกรณ์รองรับ API 16 (Jelly Bean 4.1) ขึ้นไป แต่อุปกรณ์ที่ใช้ API 19 (KitKat 4.4.X) และต่ำกว่าจะแสดงระดับเริ่มต้นโดยไม่คำนึงถึงบิลด์ของอุปกรณ์

เส้นทางของนักพัฒนาซอฟต์แวร์

ในระดับสูง หากต้องการผสานรวม DTT เข้ากับเกมที่มีอยู่ คุณจะต้องทําตามขั้นตอนต่อไปนี้

ผสานรวมการกำหนดเป้าหมายตามระดับอุปกรณ์ (และ Play Asset Delivery โดยส่วนขยาย) ภายในเกม
- ผสานรวม Play Asset Delivery เข้ากับเกม (หากยังไม่ได้ดำเนินการ)
- แบ่งชิ้นงานออกเป็น Asset Pack
- แพ็กเกจโค้ดและเนื้อหาเข้าด้วยกันสำหรับอาร์ติแฟกต์ Android App Bundle เวอร์ชันสุดท้ายที่จะอัปโหลดไปยัง Play
สร้างการกำหนดค่าการกำหนดเป้าหมายระดับอุปกรณ์เพื่อให้ Play ทราบวิธีแสดงชิ้นงานในอุปกรณ์ของผู้ใช้
- ตั้งค่า Google Play Developer API (หากยังไม่ได้ดำเนินการ) ซึ่งจะใช้เพื่อส่งการกำหนดค่า DTT ไปยัง Play
- ทำตามขั้นตอนในการสร้างการกำหนดค่า DTT
อัปโหลด AAB ไปยัง Play และทดสอบเพื่อให้แน่ใจว่ามีการกำหนดค่าทุกอย่างอย่างถูกต้อง

คุณจะเห็นส่วนแรกจะมี Fork ในคู่มือ ซึ่งขึ้นอยู่กับระบบบิลด์ที่คุณใช้ ระบบที่เลือกจะขึ้นอยู่กับเครื่องมือที่คุณใช้และการตั้งค่าที่มีอยู่

Gradle (แนะนำสำหรับเกม Java และเกมเนทีฟ): สำหรับเกมที่สร้างโดยใช้ Gradle ให้ทำตามขั้นตอนเหล่านี้เพื่อกำหนดค่าระบบบิลด์เพื่อสร้าง AAB ที่รองรับ DTT
- หากส่งออกเกมไปยัง Gradle แล้วทำบิลด์ให้เสร็จที่นั่น เราขอแนะนำให้ทำตามวิธีการเหล่านี้ (เช่น เกม Unity ที่ส่งออกไปยัง Gradle))
ปลั๊กอิน Unity: เราจะให้แพ็กเกจ Unity แก่คุณเพื่อนำเข้าในโปรเจ็กต์ Unity ซึ่งจะช่วยให้คุณกำหนดค่าและสร้าง AAB ที่รองรับ DTT ได้

การตั้งค่าการกำหนดเป้าหมายระดับอุปกรณ์ภายในแอป

การผสานรวม Play Asset Delivery เข้ากับเกม (หากยังไม่ได้ดำเนินการ)

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

เกรเดิล

สำหรับเกมที่สร้างด้วย Gradle ให้ใช้วิธีการเหล่านี้เพื่อสร้าง Asset Pack ด้วย Gradle จากนั้นทำตามวิธีการในการผสานรวมการดึงข้อมูล Asset Pack ภายในเกม

Java
เนทีฟ
เกม Unity ที่ส่งออกไปยัง Gradle
- ใช้ไลบรารี Java ผ่าน JNI (เช่น ไลบรารีที่สร้างไว้ใน Unity)

เอกภาพ

สำหรับเกมที่สร้างใน Unity คุณจะกำหนดค่าแพ็กเกจเนื้อหาโดยใช้คลาส AssetPackConfig ตามที่ระบุไว้ในวิธีการเหล่านี้

การสร้างไดเรกทอรีเฉพาะระดับอุปกรณ์

หากใช้ Gradle

ตอนนี้คุณจะต้องแยกชิ้นงานออกเป็น N ระดับ (สูงสุด 5 ระดับ) ซึ่งจะกําหนดในภายหลัง สร้างไดเรกทอรี DTT โดยนำไดเรกทอรีกลุ่มชิ้นงานที่มีอยู่ซึ่งสร้างขึ้นในขั้นตอนสุดท้าย และแก้ไขโฟลเดอร์ที่เหมาะสม (ตามที่อธิบายไว้ด้านล่าง) ด้วย #tier_0, #tier_1, #tier_2 เป็นต้น เมื่อใช้ชุดชิ้นงานในเกม คุณไม่จําเป็นต้องระบุโฟลเดอร์ด้วยส่วนต่อท้าย (กล่าวคือ ระบบจะตัดส่วนต่อท้ายออกโดยอัตโนมัติในระหว่างกระบวนการบิลด์)

หลังจากขั้นตอนก่อนหน้า ข้อมูลอาจมีลักษณะดังนี้

...
.../level1/src/main/assets/character-textures#tier_2/
.../level1/src/main/assets/character-textures#tier_1/
.../level1/src/main/assets/character-textures#tier_0/
...

เมื่อเข้าถึงไฟล์ในโฟลเดอร์นั้น คุณก็ใช้เส้นทางเดิมได้โดยไม่ต้องแก้ไขโพสต์ (ในตัวอย่างนี้เราจะอ้างอิงเป็น level1/assets/character-textures/ โดยไม่ต้องมี Postfixes)

หากใช้ Unity

หากต้องการเพิ่ม Asset Pack ที่ใช้ DTT ให้ใช้วิธีการ AssetPackConfig ด้านล่าง

/// Package the specified raw assets in the specified folders,
/// keyed by DeviceTier, in an AssetPack with the specified delivery mode.
public void AddAssetsFolders(
    string assetPackName,
    IDictionary<DeviceTier, string> deviceTierToAssetPackDirectoryPath,
    AssetPackDeliveryMode deliveryMode)

/// Package the specified AssetBundle files, which vary only by DeviceTier,
/// in an AssetPack with the specified delivery mode.
public void AddAssetBundles(
    IDictionary<DeviceTier, string> deviceTierToAssetBundleFilePath,
    AssetPackDeliveryMode deliveryMode)

ตัวอย่างเช่น สมมติว่าคุณมี AssetBundles 3 รายการสำหรับตัวละครที่มีรายละเอียดในระดับต่างๆ

หากต้องการจับคู่ AssetBundles เหล่านี้กับระดับอุปกรณ์ที่เกี่ยวข้อง ให้ใช้ข้อมูลโค้ดต่อไปนี้

var assetPackConfig = new AssetPackConfig();
var tiers = new Dictionary<DeviceTier, string>
{
    {0, "Assets/LowPoly/Character"},
    {1, "Assets/Mid/Character"},
    {2, "Assets/Detailed/Character"}
};
assetPackConfig.AddAssetBundles(tiers, AssetPackDeliveryMode.OnDemand);

การสร้าง Android App Bundle

Gradle

ในไฟล์ build.gradle ของโปรเจ็กต์ ให้กำหนดค่าทรัพยากร Dependency ให้มีเวอร์ชันด้านล่าง (หรือสูงกว่า) สำหรับปลั๊กอิน Android Gradle และ bundletool

buildscript {
  dependencies {
    classpath 'com.android.tools.build:gradle:4.2.0'
    classpath "com.android.tools.build:bundletool:1.7.1"
    ...
  }
  ...
}

และจะต้องอัปเดตเวอร์ชัน Gradle เป็นเวอร์ชัน 6.7.1 ขึ้นไปด้วย คุณอัปเดตข้อมูลนี้ได้ในgradle/wrapper/gradle-wrapper.propertiesภายในโปรเจ็กต์

distributionUrl=https://services.gradle.org/distributions/gradle-6.7.1-all.zip

สุดท้าย คุณจะต้องใช้งานไลบรารี Play Asset Delivery หากยังใช้ไลบรารี Play Core แบบโมโนลิธิกอยู่ ให้อัปเดตเป็น 1.8.3 ขึ้นไป เราขอแนะนำให้เปลี่ยนไปใช้ Play Asset Delivery Library และอัปเดตเป็นเวอร์ชันล่าสุดหากเป็นไปได้

dependencies {
  implementation 'com.google.android.play:asset-delivery:2.0.1'
  ...
}

ในไฟล์ build.gradle ของโมดูลแอปหลัก ให้เปิดใช้การแยก DTT โดยทำดังนี้

android {
  bundle {
    deviceTier {
      enableSplit true
    }
    ...
  }
  ...
}

สุดท้าย คุณสามารถสร้าง Android App Bundle (AAB)

Bundletool

สร้างแพ็กเกจด้วย Bundletool และขณะอยู่ในขั้นตอนปรับแต่ง AAB ให้เพิ่มค่าต่อไปนี้ลงในไฟล์ BundleConfig.pb

{
  ...
  "optimizations": {
    "splitsConfig": {
      "splitDimension": [
      ...
      {
        "value": "DEVICE_TIER",
        "negate": false,
        "suffixStripping": {
          "enabled": true,
        }
      }],
    }
  }
}

Unity

เมื่อกำหนดค่า AssetPackConfig ให้รวมแพ็ก DTT แล้ว คุณสามารถส่งการกำหนดค่านั้นไปยังวิธีใดวิธีหนึ่งด้านล่างเพื่อสร้าง AAB

// Configures the build system to use the newly created assetPackConfig when
// calling Google > Build and Run or Google > Build Android App
Bundle.AssetPackConfigSerializer.SaveConfig(assetPackConfig);
// Alternatively, use BundleTool.BuildBundle to build an App Bundle from script
BuildBundle(new buildPlayerOptions(), assetPackConfig)

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

ก่อนดำเนินการต่อ เราขอแนะนำให้ทดสอบ App Bundle ในเครื่องเพื่อให้แน่ใจว่าทุกอย่างได้รับการตั้งค่าอย่างถูกต้อง เมื่อใช้ bundletool (1.8.0 ขึ้นไป) คุณจะสร้างและทดสอบแอปในเครื่องได้ โดยระบุระดับอุปกรณ์ที่ถูกต้องอย่างชัดเจน ก่อนอื่น คุณจะใช้ build-apks เพื่อสร้างชุดไฟล์ .apks จากนั้นจึงติดตั้งใช้งานแอปในอุปกรณ์ที่เชื่อมต่อโดยใช้ install-apks คุณยังระบุระดับที่ต้องการติดตั้งผ่านแฟล็กระดับอุปกรณ์ได้อีกด้วย ดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีการทดสอบในเครื่องนี้ได้ที่นี่ (โปรดทราบว่าหน้านี้ยังไม่ได้อัปเดตสำหรับ DTT จึงไม่มีธง device-tier)

bundletool build-apks --bundle=/path/to/app.aab --output=/path/to/app.apks --local-testing
bundletool install-apks --apks=/path/to/app.apks --device-tier=1

อีกวิธีหนึ่ง: คุณสามารถใช้ extract-apks เพื่อดึงชุด APK สำหรับอุปกรณ์ที่ต้องการได้ด้วย อย่างไรก็ตาม การใช้ get-device-spec พร้อมกับระบุระดับอุปกรณ์สำหรับอุปกรณ์นี้จะไม่ทำงานร่วมกับ Flag --local-testing ซึ่งหมายความว่าคุณจะทดสอบแพ็กเนื้อหาแบบติดตามผลอย่างรวดเร็วหรือแบบออนดีมานด์ไม่ได้

bundletool get-device-spec --output=/path/to/device-spec.json --device-tier=1
bundletool extract-apks --apks=/path/to/existing_APK_set.apks --output-dir=/path/to/device_specific_APK_set.apks --device-spec=/path/to/device-spec.json

Unity

ตัวเลือกเมนู Google -> บิลด์และเรียกใช้จะสร้างและเรียกใช้เกมโดยเปิดใช้ Flag --local-testing แต่จะไม่อนุญาตให้คุณระบุระดับอุปกรณ์ที่ส่งไปยังคําสั่ง install-apks

หากต้องการระบุระดับอุปกรณ์ที่ไม่ใช่ 0 คุณควรทำดังนี้

สร้าง AAB โดยใช้ตัวเลือกเมนู Google -> Build Android App Bundle
ทําตามวิธีการในส่วนก่อนหน้าเพื่อเรียกใช้ bundletool, build-apks และ install-apks ใน AAB ที่สร้างขึ้น

การสร้างการกำหนดค่าระดับอุปกรณ์ผ่าน Google Play Developer API

เริ่มต้นใช้งาน Google Play Developer API (หากยังไม่ได้ดำเนินการ)

หากต้องการกำหนดค่าการกำหนดเป้าหมายระดับอุปกรณ์ (เช่น การกำหนดข้อกำหนดสำหรับแต่ละระดับ) คุณจะต้องใช้ Android Publisher API เพื่ออัปโหลดการกำหนดค่าไปยัง Google Play อ่านข้อมูลเพิ่มเติมเกี่ยวกับ API ได้ที่ลิงก์ด้านบน โดยคุณจะต้องทําตามขั้นตอนต่อไปนี้เพื่อเริ่มต้นใช้งาน

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

การใช้ Device Tier Configuration API

คุณสามารถใช้การเรียก API ต่อไปนี้เพื่อสร้างการกำหนดค่าระดับอุปกรณ์

สร้างการกำหนดค่าระดับอุปกรณ์

คำขอ HTTP	`POST https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs`
พารามิเตอร์เส้นทาง	ไม่มี
เนื้อหาคำขอ	การกำหนดค่าระดับอุปกรณ์
เนื้อหาการตอบกลับ	การกำหนดค่าระดับอุปกรณ์

ออบเจ็กต์การกําหนดค่าระดับอุปกรณ์

การกําหนดระดับของอุปกรณ์ประกอบด้วย 2 ขั้นตอน ดังนี้

กําหนดชุดกลุ่มอุปกรณ์
กำหนดชุดระดับของอุปกรณ์โดยกำหนดระดับให้กับกลุ่มอุปกรณ์

กลุ่มอุปกรณ์คือชุดอุปกรณ์ที่ตรงกับตัวเลือกที่คุณกำหนดในการกําหนดค่า

ตัวเลือกสามารถกำหนดข้อกำหนดเกี่ยวกับ RAM ของอุปกรณ์และรุ่นอุปกรณ์

กลุ่มจะระบุด้วยชื่อที่คุณเลือก และกลุ่มต่างๆ สามารถซ้อนทับกันได้

ถัดไป คุณสามารถกําหนดชุดระดับอุปกรณ์โดยการจัดอันดับกลุ่ม โดยระดับอุปกรณ์แต่ละระดับจะกําหนดโดยระดับและกลุ่มอุปกรณ์

หากอุปกรณ์ตรงกับหลายระดับ ระบบจะแสดงเนื้อหาสำหรับระดับที่ตรงกันสูงสุด

  {
    device_groups: [
      {
        name: string,
        device_selectors: [
          {
            device_ram: {
              min_bytes: integer
              max_bytes: integer
            },
            included_device_ids: [
              {
                build_brand: string,
                build_device: string
              }
            ],
            excluded_device_ids: [
              {
                build_brand: string,
                build_device: string
              }
            ],
            required_system_features: [
              {
                name: string
              }
            ],
            forbidden_system_features: [
              {
                name: string
              }
            ]
          }
        ]
      }
    ],
    device_tier_set: {
      device_tiers: [
        {
          level: int,
          device_group_names: [string]
        }
      ]
    }
  }

ฟิลด์

device_confid_id (จำนวนเต็ม): รหัสที่สอดคล้องกับการกำหนดค่าระดับของอุปกรณ์นี้
device_groups (ออบเจ็กต์): คําจํากัดความของกลุ่ม
- name (สตริง): ชื่อของกลุ่มอุปกรณ์ (รหัสสตริงที่คุณกำหนด)
- device_selectors (ออบเจ็กต์): ข้อกำหนดของอุปกรณ์เพื่อให้อุปกรณ์อยู่ในกลุ่มนี้
- device_ram (ออบเจ็กต์): ข้อกำหนดของ RAM ของอุปกรณ์
  - min_bytes (จำนวนเต็ม รวม): RAM ขั้นต่ำที่จำเป็น (เป็นไบต์)
  - max_bytes (จำนวนเต็ม ไม่รวม): RAM สูงสุดที่จําเป็น (เป็นไบต์)
- included_device_ids (ออบเจ็กต์): รุ่นอุปกรณ์ที่จะรวมอยู่ในตัวเลือกนี้ (สูงสุด 10,000 device_ids ต่อกลุ่ม) อุปกรณ์ต้องอยู่ในรายการนี้เพื่อให้ตรงกับตัวเลือก เงื่อนไขนี้เป็นสิ่งที่จําเป็นแต่ไม่เพียงพอที่จะจับคู่กับตัวเลือกแบบเต็ม (ดูหมายเหตุด้านบนเกี่ยวกับการรวมข้อกําหนดในตัวเลือก)
  - build_brand (สตริง): ผู้ผลิตอุปกรณ์
  - build_device (สตริง): รหัสรุ่นอุปกรณ์
- excluded_device_ids (ออบเจ็กต์): รุ่นอุปกรณ์ที่จะยกเว้นในตัวเลือกนี้ (device_ids สูงสุด 10,000 รายการต่อกลุ่ม) อุปกรณ์จากรายการนี้จะไม่ตรงกับตัวเลือกแม้ว่าจะตรงกับข้อกําหนดอื่นๆ ทั้งหมดในตัวเลือกก็ตาม
  - build_brand (สตริง): ผู้ผลิตอุปกรณ์
  - build_device (สตริง): รหัสรุ่นอุปกรณ์
- required_system_features (ออบเจ็กต์): ตัวเลือกนี้ต้องมี ฟีเจอร์ที่อุปกรณ์ต้องมีโดยตัวเลือกนี้ (สูงสุด 100 ฟีเจอร์ต่อกลุ่ม) อุปกรณ์จะต้องมีฟีเจอร์ของระบบทั้งหมดในรายการนี้ เพื่อให้ตรงกับตัวเลือก เงื่อนไขนี้เป็นสิ่งที่จําเป็นแต่ไม่เพียงพอที่จะจับคู่กับตัวเลือกแบบเต็ม (ดูหมายเหตุด้านบนเกี่ยวกับการรวมข้อกําหนดในตัวเลือก)
  
  ข้อมูลอ้างอิงฟีเจอร์ของระบบ
  - name (สตริง): ฟีเจอร์ของระบบ
- forbidden_system_features (ออบเจ็กต์): ฟีเจอร์ที่ตัวเลือกนี้ต้องไม่รวมไว้ในอุปกรณ์ (สูงสุด 100 ฟีเจอร์ต่อกลุ่ม) หากอุปกรณ์มีฟีเจอร์ระบบใดก็ตามในรายการนี้ อุปกรณ์จะไม่ตรงกับตัวเลือก แม้ว่าจะตรงกับข้อกำหนดอื่นๆ ทั้งหมดในตัวเลือกก็ตาม
  
  การอ้างอิงฟีเจอร์ของระบบ
  - name (สตริง): ฟีเจอร์ของระบบ
device_tiers (ออบเจ็กต์): คำจำกัดความของระดับ
- level (int): ระดับของลำดับชั้น
- group_name (อาร์เรย์สตริง): ชื่อกลุ่มอุปกรณ์ที่อยู่ในระดับนี้

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

หมายเหตุ

กลุ่มหนึ่งระบุตัวเลือกอุปกรณ์ได้หลายรายการ โดยอุปกรณ์จะอยู่ในกลุ่มหากตรงกับตัวเลือกกลุ่มอย่างน้อย 1 รายการ (OR เชิงตรรกะ)
อุปกรณ์หนึ่งๆ จะอยู่ในกลุ่มได้หลายกลุ่ม
ตัวเลือกสามารถระบุเงื่อนไขเกี่ยวกับ RAM, การรวมและการยกเว้นรุ่นอุปกรณ์ และฟีเจอร์ของระบบที่จําเป็น/ต้องห้าม หากตัวเลือกระบุเงื่อนไขหลายรายการ อุปกรณ์จะจับคู่กับตัวเลือกก็ต่อเมื่อตรงกับเงื่อนไขทั้งหมด (ตรรกะ "และ")

คำเตือน: การรวมกฎหลายข้อไว้ในตัวเลือกเดียวกันจะเป็นการสร้างตรรกะ AND ตัวอย่างเช่น

  {
    device_ram: {
        min_bytes: 7516192768
    },
    included_device_ids: [
          {
               build_brand: ‘google',
               build_device: ‘flame'
          }
    ],
  }

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

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

  {
    device_ram: {
        min_bytes: 7516192768
    },
  },
  {
    included_device_ids: [
          {
               build_brand: ‘google',
               build_device: ‘flame'
          }
    ],
  }

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

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

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

ต่อไปนี้เป็นตัวอย่างการกำหนดค่าที่มี 3 ระดับ ได้แก่ ระดับ 2 ใช้กลุ่มอุปกรณ์สูง (ซึ่งรวมถึงอุปกรณ์ทั้งหมดที่มีพื้นที่เก็บข้อมูลมากกว่า 7 GB และ Pixel 4) ระดับ 1 ใช้กลุ่มอุปกรณ์กลาง (ซึ่งรวมถึงอุปกรณ์ทั้งหมดที่มีพื้นที่เก็บข้อมูล 4-7 GB) และระดับ 0 ซึ่งกำหนดโดยนัยว่าเป็นกลุ่มที่ครอบคลุมทั้งหมด

{
  device_groups: [
    {
      name: 'high',
      device_selectors: [
        {
          device_ram: {
            min_bytes: 7516192768
          },
        },
        {
          included_device_ids: [
            {
              build_brand: 'google',
              build_device: 'flame'
            }
          ],
        }
      ]
    },
    {
      name: 'medium',
      device_selectors: [
        {
          device_ram: {
            min_bytes: 4294967296,
            max_bytes: 7516192768
          },
        }
      ]
    }
  ],
  device_tier_set: {
    device_tiers: [
      {
        level: 1,
        device_group_names: [
          'medium'
        ]
      },
      {
        level: 2,
        device_group_names: [
          'high'
        ]
      }
    ]
  }
}

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

รับการกำหนดค่าระดับอุปกรณ์ตามรหัส

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

คำขอ HTTP	`GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs/{deviceTierConfigId}`
พารามิเตอร์เส้นทาง	ไม่มี
เนื้อหาคำขอ	ไม่มี
เนื้อหาการตอบกลับ	การกำหนดค่าระดับอุปกรณ์

รับรายการการกำหนดค่าระดับอุปกรณ์

คุณดูการกำหนดค่าระดับอุปกรณ์ 10 รายการล่าสุดได้จากคอลต่อไปนี้ (หรือระบุชุด 10 รายการโดยใช้พารามิเตอร์การค้นหา page_token ในลักษณะที่เหมาะสมที่สุด)

คำขอ HTTP	`GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs`
พารามิเตอร์เส้นทาง	ไม่มี
พารามิเตอร์การค้นหา	page_token (ไม่บังคับ) - ใช้เพื่อระบุกลุ่ม DTC 10 รายการที่เฉพาะเจาะจง ซึ่งจะมีประโยชน์หากคุณสร้าง DTC มากกว่า 10 รายการ และต้องการดู DTC ที่สร้างขึ้นก่อน 10 รายการล่าสุด
เนื้อหาคำขอ	ไม่มี
เนื้อหาการตอบกลับ	รายการการกำหนดค่าระดับอุปกรณ์ page_token

การตรวจสอบการกําหนดค่าการกําหนดอุปกรณ์เป้าหมาย

bundletool มีคำสั่ง 2 รายการที่จะช่วยคุณตรวจสอบว่าการกำหนดค่าการกำหนดเป้าหมายอุปกรณ์ทำงานตามที่ตั้งใจไว้ก่อนอัปโหลดไปยัง Play

bundletool print-device-targeting-config ช่วยให้คุณตรวจสอบได้ว่าไฟล์ JSON ถูกต้องตามไวยากรณ์ และแสดงภาพกลุ่มอุปกรณ์และระดับต่างๆ ในรูปแบบที่อ่านง่ายขึ้น

bundletool print-device-targeting-config --config=mydtc.json

bundletool evaluate-device-targeting-config ช่วยให้คุณประเมินได้ว่ากลุ่มและระดับใดที่ตรงกับอุปกรณ์หนึ่งๆ คุณสามารถเชื่อมต่ออุปกรณ์เป้าหมายกับเวิร์กสเตชันและใช้ Flag --connected-device หรือจะคอมไพล์ไฟล์ JSON ด้วยพร็อพเพอร์ตี้ของอุปกรณ์ด้วยตนเองและระบุผ่าน Flag --device-properties ก็ได้

bundletool evaluate-device-targeting-config --config=mydtc.json --connected-device
bundletool evaluate-device-targeting-config --config=mydtc.json --device-properties=deviceproperties.json

ไฟล์พร็อพเพอร์ตี้อุปกรณ์ควรเป็นไฟล์ JSON ที่เป็นไปตามโครงสร้าง protobuf ของ DeviceProperties เช่น

{
  "ram": 2057072640,
  "device_id": {
    "build_brand":"google",
    "build_device":"redfin"
  },
  "system_features": [
    {
      "name":"android.hardware.bluetooth"
    },
    {
      "name":"android.hardware.camera"
    }
  ]
}

การอัปโหลด Android App Bundle ไปยัง Google Play

ผ่าน API

คุณสามารถใช้ Google Play Developer API เพื่ออัปโหลด Android App Bundle ไปยัง Google Play และลิงก์การกำหนดค่าการกําหนดเป้าหมายระดับอุปกรณ์ที่เฉพาะเจาะจงกับบิลด์ได้

โปรดดูภาพรวมทั่วไปของวิธีการแก้ไขที่นี่ พร้อมด้วยตัวอย่างที่เจาะลึกมากขึ้นเกี่ยวกับการเผยแพร่ไปยังแทร็กต่างๆ ใน Google Play Console (สำหรับลิงก์สุดท้าย คุณจะต้องใช้ API ที่เหมาะสำหรับ AAB แทน API ที่เหมาะสำหรับ APK ซึ่งแสดงอยู่ในหน้า) หากต้องการระบุการกําหนดค่าระดับอุปกรณ์สําหรับบิลด์ ให้เพิ่มรหัสการกําหนดค่าลงในพารามิเตอร์การค้นหา deviceTierConfigIdขณะเรียกใช้เมธอด edits.bundle.upload ดังนี้

https://androidpublisher.googleapis.com/upload/androidpublisher/v3/applications/{packageName}/edits/{editId}/bundles?deviceTierConfigId="{deviceTierConfigId}

ผ่าน Google Play Console

คุณสามารถทำตามวิธีการที่นี่เพื่ออัปโหลด App Bundle ของ Android ระบบจะใช้การกำหนดค่า DTC ล่าสุดกับ App Bundle

คุณสามารถตรวจสอบว่าสร้าง App Bundle ได้อย่างถูกต้องโดยไปที่ App Bundle Explorer (โดยเลือกบิลด์ที่ถูกต้อง) > การนำส่ง แล้วคลิกแพ็กเกจชิ้นงานแต่ละรายการ ซึ่งควรแสดงว่าคุณมีระดับ N ที่คุณสร้างขึ้น ในตัวอย่างนี้ แสดงว่ามี 3 ระดับ ได้แก่ 0, 1 และ 2 สำหรับแพ็กเกจชิ้นงาน main_asset

Asset Pack ที่มี 3 ระดับ

ยืนยันว่ามีการนำส่งระดับที่ถูกต้อง

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

adb shell pm path {packageName}

คุณควรเห็นข้อมูลประมาณนี้

package:{...}/base.apk
package:{...}/split_config.en.apk
package:{...}/split_config.xxhdpi.apk
package:{...}/split_main_asset.apk
package:{...}/split_main_asset.config.tier_2.apk

ตัวช่วย

เริ่มต้นอย่างรวดเร็วโดยใช้ Curl

ด้านล่างคือตัวอย่าง (การใช้ Curl ของเครื่องมือบรรทัดคำสั่ง) ของการสร้างการกำหนดค่าระดับของอุปกรณ์ใหม่ และใช้ Edits API เพื่อสร้างการแก้ไขใหม่ อัปโหลด AAB ใหม่ (เชื่อมโยงกับการกำหนดค่าระดับของอุปกรณ์ที่เฉพาะเจาะจง) ตั้งค่าการกำหนดค่าแทร็ก/เผยแพร่ และแก้ไข (จึงทำให้การเปลี่ยนแปลงเป็นสาธารณะ) อย่าลืมใส่ตำแหน่งของ

คีย์ที่สอดคล้องกับไคลเอ็นต์ API
ชื่อแพ็กเกจของแอป

ก่อนอื่น ให้สร้างการกำหนดค่าระดับอุปกรณ์และจดบันทึกdeviceTierConfigIdที่คุณจะได้รับเมื่อการเรียกใช้สำเร็จ

curl -H "$(oauth2l header --json $HOME/{apiKey} androidpublisher)" -XPOST -H "Content-Type: application/json" -d "{ device_groups: [ { name: 'high', device_selectors: [ { device_ram: { min_bytes: 7516192768 }, }, { included_device_ids: [ { build_brand: 'google', build_device: 'flame' } ], } ] }, { name: 'medium', device_selectors: [ { device_ram: { min_bytes: 4294967296, max_bytes: 7516192768 }, } ] } ], device_tier_set: { device_tiers: [ { level: 1, device_group_names: [ 'medium' ] }, { level: 2, device_group_names: [ 'high' ] } ] } }" https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs

เริ่มการแก้ไข - คุณจะได้รับรหัสและเวลาหมดอายุของการแก้ไข บันทึกรหัสไว้สําหรับการโทรครั้งถัดไป

curl -H "$(oauth2l header --json $HOME/{apiKey} androidpublisher)" -XPOST https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/edits

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

curl -H "$(oauth2l header --json $HOME/{apiKey} androidpublisher)" --data-binary @$HOME/{aabFile} -H "Content-Type: application/octet-stream" -XPOST https://androidpublisher.googleapis.com/upload/androidpublisher/v3/applications/{packageName}/edits/{editID}/bundles?deviceTierConfigId="{dttConfigID}"

กำหนด AAB ให้กับแทร็กที่ต้องการ (สำหรับการทดสอบ เราขอแนะนำให้ใช้แทร็กทดสอบภายใน แต่คุณสามารถอ่านเพิ่มเติมเกี่ยวกับแทร็กต่างๆ ได้ที่นี่) เราจะทำการเปิดตัวแบบง่ายโดยไม่มีหมายเหตุประจำรุ่น แต่คุณสามารถอ่านหน้านี้เพื่อดูข้อมูลเพิ่มเติมเกี่ยวกับวิธีเปิดตัวแบบเป็นขั้นๆ ไป รุ่นฉบับร่าง และหมายเหตุประจำรุ่น หากคุณใช้ Publisher API เป็นครั้งแรก เราขอแนะนำให้สร้างรุ่นนี้เป็นรุ่นฉบับร่าง และทำการเปิดตัวใน Google Play Console ให้เสร็จสมบูรณ์เพื่อให้แน่ใจว่ามีการกำหนดค่าทุกอย่างอย่างถูกต้อง

curl -H "$(oauth2l header --json $HOME/{apiKey} androidpublisher)" -XPUT -H "Content-Type: application/json" -d "{ releases: [{status: '{status}'</code>, <code><strong>versionCodes</strong></code>: <code>['{versionCode}']</code> <code><strong>}]}</strong></code>" <code>https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/edits/{editID}/tracks/{track}

บันทึกการเปลี่ยนแปลง (โปรดดำเนินการด้วยความระมัดระวัง เนื่องจากการดำเนินการนี้จะเผยแพร่การเปลี่ยนแปลงทั้งหมดใน Play ไปยังแทร็กที่ต้องการ)

curl -H "$(oauth2l header --json $HOME/{apiKey} androidpublisher)" -XPOST https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/edits/{editID}:commit