דף זה תורגם על ידי 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 במשחק (אם עוד לא עשיתם זאת) כבר עשית זאת)
- מחלקים את הנכסים לחבילות נכסים
- עליכם לארוז את הקוד והנכסים שלכם יחד כדי ליצור את פריט מידע שנוצר בקובץ Android App Bundle שיעלה ל-Play.
קובעים את הגדרות הטירגוט לפי רמת המכשיר כדי ש-Play תדע איך לשלוח את הנכסים שלכם למכשירים של המשתמשים.
- להגדיר את Google Play Developer API (אם עדיין לא השלמתם אותו), שבו משתמשים כדי לשלוח את הגדרות ה-DTT ל-Play.
- מבצעים את השלבים ליצירת הגדרת ה-DTT.
צריך להעלות את קובץ ה-AAB ל-Play ולבדוק אם הכול תקין הוגדר כראוי

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

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

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

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

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

גרדל

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

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

אחדות

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

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

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

עכשיו תפצלו את הנכסים בין N רמות (5 לכל היותר) שאתם רוצים אגדיר מאוחר יותר. יוצרים את ספריות ה-DTT באמצעות הספרייה הקיימת. ספריות של חבילות נכסים שנוצרו בשלב האחרון, ולאחר תיקון התיקייה המתאימה (כפי שמתואר למטה) עם #tier_0, #tier_1, #tier_2, וכו' כשמשתמשים בחבילות הנכסים במשחק, לא צריך לעשות כתובות תיקיות לפי Postfix (במילים אחרות, התיקון מפרסום) בתהליך ה-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/ ללא סיומות (postfix)).

אם משתמשים ב-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

גרדל

בקובץ 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. אם אתם עדיין באמצעות ספריית הליבה המונולית של Play, לעדכן אותה לגרסה 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 יחד עם ציון סוג המכשיר של המכשיר הזה, לא תפעל בשילוב עם הדגל --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 -> אפשרות התפריט 'יצירה והפעלה' תבנה ותפעיל את המשחק באמצעות הדגל --local-testing מופעל. עם זאת, הוא לא מאפשר לכם לציין רמת המכשיר שמועברת בפקודה install-apks.

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

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

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

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

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

יוצרים (במידת הצורך) את פרויקט ה-API ומקשרים אותו ל-Google Play Console.
Set up API Access Client (הגדרת לקוח גישה ל-API).

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

הערה:

קבוצה יכולה לציין כמה בוררי מכשירים. מכשיר שייך ל- הקבוצה אם היא תואמת לבורר קבוצה אחד לפחות ('או' לוגי).
אפשר לשייך מכשיר לכמה קבוצות.
בורר יכול לציין תנאים ל-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, הוא 'דג שמש')
הורדת קובץ CSV של מכשירים נתמכים באמצעות היצרן Model Code (קוד המודל) בשדות build_brand ו-build_device, בהתאמה.

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

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

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

בקשת HTTP	`GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs`
פרמטרים של נתיב	לא רלוונטי
פרמטרים של שאילתה	page_token (אופציונלי) – משמש לציון קבוצה ספציפית של 10 המרות דיגיטליות. האפשרות הזו שימושית אם יצרתם יותר מ-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 שמופיע אחרי מאפייני מכשיר למבנה של אב טיפוס. לדוגמה:

{
  "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 ולקשר הגדרת טירגוט ספציפית ברמת המכשיר אל את ה-build שלך.

יש סקירה כללית על שיטות העריכה, וגם דוגמאות מעמיקות יותר להשקה לטראקים השונים ב-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 תהיה הוחל על קובץ ה-App 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 של כלי שורת הפקודה) של יצירת הגדרה חדשה של רמת מכשיר, וכן באמצעות ממשק ה-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