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

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

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

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

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

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

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

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

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

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

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

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

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

เกรเดิล

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

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

เอกภาพ

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

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

หากใช้ Gradle

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

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

...
.../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/ ที่ไม่มีการแก้ไขโพสต์)

หากใช้ 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 สำหรับตัวละครในระดับรายละเอียดที่แตกต่างกัน

หากต้องการแมป 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

เกรเดิล

ในไฟล์ 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 ถ้ายังอยู่ ที่ใช้ไลบรารี Play Core แบบโมโนลิธ ให้อัปเดตเป็นเวอร์ชัน 1.8.3 ขึ้นไป คำแนะนำจากเรา เปลี่ยนไปใช้ไลบรารีการนำส่งเนื้อหา Play และอัปเดตเป็นเวอร์ชันล่าสุด หากเป็นไปได้

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,
        }
      }],
    }
  }
}

เอกภาพ

เมื่อกำหนดค่า 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 ซึ่งหมายความว่า สามารถทดสอบ Asset Pack แบบรวดเร็วหรือออนดีมานด์ได้

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

เอกภาพ

ฟังก์ชัน Google -> ตัวเลือกเมนูสร้างและเรียกใช้จะสร้างและเรียกใช้เกมด้วย เปิดใช้การตั้งค่าสถานะ --local-testing แล้ว อย่างไรก็ตาม คุณไม่สามารถระบุ ระดับของอุปกรณ์ที่ส่งผ่านไปยังคำสั่ง install-apks

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

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

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

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

เพื่อกำหนดค่าการกำหนดเป้าหมายระดับอุปกรณ์ (เช่น การกำหนดข้อกำหนดสำหรับแต่ละรายการ ) คุณจะต้องใช้ API ผู้เผยแพร่โฆษณา Android เพื่ออัปโหลดการกำหนดค่าไปยัง 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_id ต่อกลุ่ม) ต้องมีอุปกรณ์ ที่จะอยู่ในรายการนี้ เพื่อให้ตรงกับตัวเลือก ขั้นตอนนี้จำเป็น แต่ เงื่อนไขไม่เพียงพอที่จะจับคู่กับตัวเลือกทั้งหมด (ดูหมายเหตุด้านบน เกี่ยวกับการรวมข้อกำหนดในตัวเลือก)
  - build_brand (สตริง): ผู้ผลิตอุปกรณ์
  - build_device (สตริง): รหัสรุ่นอุปกรณ์
- excluded_device_ids (ออบเจ็กต์): รุ่นอุปกรณ์ที่จะยกเว้น ตัวเลือกนี้ (สูงสุด 10000 device_ids ต่อกลุ่ม) อุปกรณ์จาก รายการนี้จะตรงกับตัวเลือกแม้ว่าจะตรงกับรายการอื่นๆ ทั้งหมด ในตัวเลือก
  - build_brand (สตริง): ผู้ผลิตอุปกรณ์
  - build_device (สตริง): รหัสรุ่นอุปกรณ์
- required_system_features (ออบเจ็กต์): ฟีเจอร์ที่อุปกรณ์ต้องการ จะต้องรวมอยู่ในตัวเลือกนี้ (สูงสุด 100 แห่ง ต่อกลุ่ม) อุปกรณ์ต้องมีฟีเจอร์ระบบทั้งหมดในส่วนนี้ ให้ตรงกับตัวเลือก ขั้นตอนนี้จำเป็นแต่ไม่เพียงพอ ให้ตรงกับตัวเลือกทั้งหมด (ดูหมายเหตุด้านบนเกี่ยวกับ ที่รวมข้อกำหนดไว้ในตัวเลือก)
  
  การอ้างอิงฟีเจอร์ของระบบ
  - name (สตริง): ฟีเจอร์ของระบบ
- forbidden_system_features (ออบเจ็กต์): ฟีเจอร์ที่อุปกรณ์ต้องไม่ จะต้องรวมอยู่ในตัวเลือกนี้ (สูงสุด 100 รายการต่อกลุ่ม) หากอุปกรณ์มีฟีเจอร์ของระบบในรายการนี้ ระบบจะไม่ ตรงกับตัวเลือก แม้ว่าตัวเลือก จะตรงกับข้อกำหนดอื่นๆ ทั้งหมดใน ตัวเลือก
  
  การอ้างอิงฟีเจอร์ของระบบ
  - name (สตริง): ฟีเจอร์ของระบบ
device_tiers (ออบเจ็กต์): คําจํากัดความของระดับ
- level (int): ระดับของระดับ
- group_name (อาร์เรย์สตริง): ชื่อกลุ่มอุปกรณ์ที่เป็น ไปยังระดับนี้

หมายเหตุ

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

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

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

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

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

  {
    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 ของอุปกรณ์ที่รองรับและใช้ Manufacturer และ รหัสรุ่น สำหรับช่อง build_brand และ build_device ตามลำดับ

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

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

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 ที่มีคุณสมบัติของอุปกรณ์ด้วยตนเองและระบุผ่าน การแจ้งว่าไม่เหมาะสม --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 เช่น

{
  "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

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

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