דף זה תורגם על ידי Cloud Translation API.

טירגוט לפי רמת המכשיר

מהו טירגוט לפי רמת המכשיר?

טירגוט קבוצת מכשירים מאפשר להציג גרסאות שונות (למשל, רזולוציות וכו') של אותו נכס למכשירים שונים על סמך החומרה שלהם. לדוגמה, תוכלו להעביר נכסים ברזולוציה נמוכה למכשירים פשוטים יותר כדי לשפר את הביצועים, ולהעביר נכסים ברזולוציה גבוהה למכשירים מתקדמים יותר כדי לשפר את איכות הגרפיקה של המשחק, בלי להגדיל את הגודל הכולל של המשחק על-ידי העברת הנכסים הנחוצים למכשירים של המשתמשים בלבד. האפשרות הזו מבוססת על המושג של חבילות נכסים ב-Play Asset Delivery. כפי שיפורט בהמשך, אתם יכולים להגדיר את הקריטריונים של הרמות (כרגע על סמך זיכרון RAM, דגמי מכשירים ספציפיים או תכונות מערכת זמינות), ולהשתמש בעד 5 רמות.

בדומה להעברת נכסים ב-Play, הטירגוט לפי רמת המכשיר תומך ב-API 16 (Jelly Bean 4.1) ואילך, אבל במכשירים API 19 (KitKat 4.4.X) ורמת ברירת המחדל נמוכה יותר, רמת ברירת המחדל ניתנת ללא קשר לגרסת ה-build של המכשיר.

התהליך למפתחים

באופן כללי, כדי לשלב DTT במשחק הקיים, צריך לבצע את השלבים הבאים:

שילוב של טירגוט לפי רמת מכשיר (וכתוצאה מכך, Play Asset Delivery) במשחק
- משלבים את Play Asset Delivery במשחק (אם עדיין לא עשיתם זאת)
- כדאי לחלק את הנכסים לחבילות נכסים
- מארזים את הקוד והנכסים יחד כדי ליצור את קובץ ה-Artifact הסופי של Android App Bundle שאותו תעלו ל-Play.
יוצרים את הגדרת הטירגוט ברמת המכשיר כדי ש-Play ידע איך להעביר את הנכסים שלכם למכשירים של המשתמשים.
- מגדירים את Google Play Developer API (אם עוד לא עשיתם זאת). זהו ה-API שבו תשתמשו כדי לשלוח את הגדרות ה-DTT ל-Play.
- מבצעים את השלבים ליצירת הגדרת ה-DTT.
מעלים את קובץ ה-AAB ל-Play ובודקים שכל ההגדרות נכונות

בקטע הראשון תבחינו שהמדריך כולל מספר גרסאות, בהתאם למערכת ה-build שבה אתם משתמשים. המערכת שבוחרים תלויה במנוע שבו משתמשים ובהגדרות הקיימות.

Gradle (מומלץ למשחקים ב-Java ובשפות מקומיות): במשחקים שנוצרו באמצעות Gradle, פועלים לפי השלבים הבאים כדי להגדיר את מערכת ה-build כך שתוכל ליצור קובץ AAB עם תמיכה ב-DTT.
- אם אתם מייצאים את המשחק ל-Gradle ומסיימים את ה-build שם, מומלץ לפעול לפי ההוראות הבאות (למשל: משחקי Unity שמיוצאים ל-Gradle)
פלאגין של Unity: נספק לכם חבילות אחדות לייבוא לפרויקט Unity, שיאפשרו לכם להגדיר ולבנות את ה-AAB עם תמיכת DTT.

הגדרת טירגוט לפי רמת המכשיר באפליקציה

שילוב Play Asset Delivery במשחק (אם עדיין לא ביצעתם זאת)

Play Asset Delivery‏ (PAD) מאפשר לכם להעביר את הנכסים של המשחק באופן דינמי בזמן ההתקנה או בזמן הריצה. כאן תוכלו לקרוא סקירה כללית על הנושא. באמצעות טירגוט לפי קבוצת מכשירים, מערכת Play תספק חבילות נכסים על סמך ההגדרות של קבוצות המכשירים שתגדירו לקבוצות שונות של מכשירים. מומלץ לפעול לפי ההנחיות שבהמשך ולשלב את PAD במשחק (למשל, ליצור חבילות נכסים, להטמיע אחזור במשחק) ולאחר מכן לשנות את קוד הפרויקט כדי להפעיל טירגוט ברמת המכשיר.

Gradle

במשחקים שנוצרו באמצעות Gradle, צריך לפעול לפי ההוראות הבאות כדי לפתח את חבילות הנכסים באמצעות Gradle, ואז לפעול לפי ההוראות לשילוב האחזור של חבילות הנכסים במשחק:

Java
מודעות מותאמות
משחקי Unity שמיוצאים ל-Gradle
- שימוש בספריות Java דרך ה-JNI (למשל הספרייה המובנית ב-Unity).

Unity

במשחקים שנוצרו ב-Unity, צריך להגדיר את חבילות הנכסים באמצעות הכיתה AssetPackConfig, כפי שמתואר בהוראות האלה.

יצירת ספריות ספציפיות לרמת מכשיר

אם משתמשים ב-Gradle

עכשיו תצטרכו לפצל את הנכסים בין N רמות (5 לכל היותר) שתגדירו בהמשך. כדי ליצור את הספריות של DTT, צריך לקחת את הספריות הקיימות של חבילות הנכסים שנוצרו בשלב האחרון, ולהוסיף לספרייה המתאימה את הסיומת #tier_0,‏ #tier_1,‏ #tier_2 וכו' (כפי שמתואר בהמשך). כשמשתמשים בחבילות הנכסים במשחק, לא צריך להתייחס לספריות לפי הסיומת (כלומר, הסיומת מוסרת באופן אוטומטי במהלך תהליך ה-build).

אחרי השלב הקודם, זה עשוי להיראות כך:

...
.../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

כדי להוסיף חבילת נכסים שמשתמשת ב-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

Gradle

בקובץ build.gradle של הפרויקט, מגדירים את הגרסאות הבאות (או גרסאות מתקדמות יותר) של פלאגין 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. אם אתם עדיין משתמשים בספריית הליבה המונוליטית של Google Play, עליכם לעדכן אותה לגרסה 1.8.3 ואילך. אם אפשר, מומלץ לעבור לספרייה ב-Play Asset Delivery ולעדכן לגרסה העדכנית.

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 יחד עם ציון סוג המכשיר של המכשיר לא יפעל בשילוב עם הדגל --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

אחדות

בעזרת האפשרות Google -> Build and Run שבתפריט תבנה ותפעיל את המשחק כשהדגל --local-testing מופעל. עם זאת, לא ניתן לציין את רמת המכשיר שמועברת לפקודה install-apks.

אם רוצים לציין רמת מכשיר שאינה 0, צריך:

יוצרים את ה-AAB באמצעות האפשרות Google -> Build Android App Bundle.
פועלים לפי ההוראות בקטע הקודם כדי להריץ את bundletool, build-apks ו-install-apks ב-AAB המובנה.

יצירת הגדרה של רמת מכשיר באמצעות Google Play Developer API

תחילת העבודה עם ממשק ה-API של Google Play למפתחים (אם עדיין לא השלמתם אותו)

כדי להגדיר טירגוט לפי רמת מכשיר (למשל, הגדרת הדרישות לכל רמה), תצטרכו להשתמש ב-Android Publisher API כדי להעלות את ההגדרות ל-Google Play. אפשר לקרוא מידע נוסף על ה-API בקישור שלמעלה. יש כמה שלבים שצריך לבצע כדי להתחיל:

חומר העזר בנושא API זמין כאן. בהמשך, אם תבחרו להעלות את ה-build דרך ה-API, תצטרכו להשתמש בשיטות העריכה. בנוסף, מומלץ לעיין בדף הזה לפני שמשתמשים ב-API.

שימוש ב-Device Tier Configuration API

אפשר להשתמש בקריאת ה-API הבאה כדי ליצור את ההגדרה של רמת המכשיר:

יצירת הגדרה של רמת המכשיר

בקשת HTTP	`POST https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs`
פרמטרים של נתיב	לא רלוונטי
גוף הבקשה	Device Tier Config
גוף התשובה	Device Tier Config

אובייקט של הגדרת רמת המכשיר

ההגדרה של רמות מכשירים מורכבת מ-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 (אובייקט): דגמי המכשירים שרוצים להחריג מהבורר הזה (עד 10,000 מזהי device_id לכל קבוצה). מכשיר מהרשימה הזו לא יתאים לבורר גם אם הוא עומד בכל הדרישות האחרות בבורר.
  - build_brand (מחרוזת): יצרן המכשיר
  - build_device (מחרוזת): קוד דגם המכשיר
- required_system_features (אובייקט): התכונות שחייבות להיכלל במכשיר על ידי הבורר הזה (עד 100 תכונות לכל קבוצה). כדי שהמכשיר יתאים לבורר, צריכות להיות בו כל תכונות המערכת שמפורטות ברשימה הזו. זהו תנאי הכרחי, אבל לא מספיק, כדי להתאים לבורר המלא (ראו הערה למעלה לגבי שילוב דרישות בבורר).
  
  הפניה לתכונות המערכת
  - name (מחרוזת): תכונת מערכת
- forbidden_system_features (אובייקט): תכונות שאסור שיהיו במכשיר לפי הבורר הזה (עד 100 תכונות לכל קבוצה). אם במכשיר יש אחת מתכונות המערכת שמפורטות ברשימה הזו, הוא לא תואם לבורר, גם אם הוא עומד בכל הדרישות האחרות בבורר.
  
  הפניה לתכונות המערכת
  - name (מחרוזת): תכונת מערכת
device_tiers (אובייקט): הגדרות רמה
- level (int): הרמה של הרמה
- group_name (מערך מחרוזות): השם של קבוצות המכשירים ששייכות לרמה הזו

הערה:

אפשר לציין בקבוצה כמה בוררי מכשירים. מכשיר שייך לקבוצה אם הוא תואם לבורר קבוצה אחד לפחות (OR לוגי).
מכשיר יכול להשתייך לכמה קבוצות.
בבורר אפשר לציין תנאים לגבי זיכרון RAM, הכללה והחרגה של דגמי מכשירים ותכונות מערכת נדרשות או אסורות. אם בבורר מצוינים כמה תנאים, מכשיר יתאים לבורר אם הוא יעמוד בכל התנאים שלו (AND לוגי).

אזהרה: הוספה של מספר כללים כחלק מאותו בורר תיצור AND לוגי, לדוגמה:

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

תיצור את התנאי לכל המכשירים עם זיכרון RAM בנפח של יותר מ-7GB וגם מכשיר Pixel 4. אפשר לכתוב את זה גם כך:

אחרת, אם רוצים תנאי OR, צריך לקבץ אותם כבוררים נפרדים, לדוגמה:

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

יוצר את התנאי לכל המכשירים עם זיכרון RAM בנפח של יותר מ-7GB או שהוא מכשיר Pixel 4 – אפשר לכתוב אותו גם כך:

כדי למצוא את הפורמט הנכון של קוד היצרן והדגם של המכשיר, אפשר להשתמש בקטלוג המכשירים ב-Google Play Console באחת מהדרכים הבאות:

בודקים מכשירים ספציפיים באמצעות קטלוג המכשירים ומאתרים את היצרן ואת קוד הדגם במיקומים שמוצגים בדוגמה שבהמשך (במכשיר Google Pixel 4a, היצרן הוא 'Google' וקוד הדגם הוא 'sunfish')'
הורדת קובץ CSV של מכשירים נתמכים, ושימוש ביצרן ובקוד הדגם בשדות build_brand ו-build_device, בהתאמה.

דוגמה להגדרה עם 3 רמות – רמה 2 משתמשת בקבוצת מכשירים גבוהה (שכוללת את כל המכשירים מעל 7GB ו-Pixel 4), רמה 1 משתמשת בקבוצת מכשירים medium (כולל כל המכשירים בין 4 ל-7GB) ורמה 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}`
פרמטרים של נתיב	לא רלוונטי
גוף הבקשה	לא רלוונטי
גוף התשובה	Device Tier Config

קבלת רשימה של הגדרות ברמת המכשיר

אפשר לקבל את 10 ההגדרות האחרונות של רמת המכשיר באמצעות הקריאה הבאה (או לציין באופן אופטימלי עשר באמצעות פרמטר השאילתה page_token):

בקשת HTTP	`GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs`
פרמטרים של נתיב	לא רלוונטי
פרמטרים של שאילתה	page_token (אופציונלי) – משמש לציון קבוצה ספציפית של 10 DTC. האפשרות הזו שימושית אם יצרת יותר מ-10 המרות DTC, וברצונך לראות אותן שנוצרו לפני 10 ההמרות האחרונות.
גוף הבקשה	לא רלוונטי
גוף התשובה	רשימת הגדרות של רמת המכשיר page_token

אימות ההגדרות של טירגוט המכשירים

bundletool כוללת שתי פקודות שעוזרות לוודא שהגדרות הטירגוט לפי מכשיר פועלות כמצופה לפני ההעלאה ל-Play.

באמצעות bundletool print-device-targeting-config תוכלו לוודא שקובץ ה-JSON תקין מבחינה תחבירית ומציג את קבוצות המכשירים ורמות המכשירים בפורמט קריא יותר.

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

בעזרת bundletool evaluate-device-targeting-config תוכלו להעריך אילו קבוצות ורמות יתאימו למכשיר ספציפי. תוכלו לחבר את מכשיר היעד לתחנת העבודה ולהשתמש בדגל --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 לפי המבנה של DeviceProperties ב-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, ולקשר הגדרה ספציפית של טירגוט ברמת המכשיר לגרסה שלכם.

כאן תוכלו למצוא סקירה כללית על השיטות של Edits, וגם דוגמאות מפורטות יותר לפרסום במסלולים השונים ב-Google Play Console (בקישור האחרון, מומלץ להשתמש ב-ממשקי ה-API התואמים ל-AAB במקום ב-ממשק ה-API התומך ב-APK, שמפורטים בדף). כדי לציין את ההגדרה של רמת המכשיר ב-build, מוסיפים את מזהה ההגדרה לפרמטר של השאילתה deviceTierConfigId תוך כדי קריאה ל-method edits.bundle.upload, כך:

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

דרך Google Play Console

תוכלו לפעול לפי ההוראות שמפורטות כאן כדי להעלות את קובץ Android App Bundle. הגדרת ה-DTC העדכנית תוחל על חבילת האפליקציות.

כדי לוודא שה-bundle נוצר בצורה תקינה, עוברים אל App Bundle Explorer (עם ה-build הנכון שנבחר) > Delivery ולוחצים על כל חבילת נכסים. אמור להופיע בהן שהגדרתם N רמות. בדוגמה הזו, הוא מראה שיש לי 3 רמות – 0, 1 ו-2 עבור חבילת הנכסים main_asset.

חבילת נכסים עם שלוש רמות

אימות שהשכבה הנכונה מועברת

כדי לוודא שהמכשיר מקבל רק את הרמה הנכונה, צריך להשתמש בשיטה הבאה

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 של ה-build. שומרים את קוד הגרסה לשיחה הבאה.

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