Targeting auf Geräteebene

Was ist die Ausrichtung auf Gerätestufen?

Mit dem Targeting auf Gerätestufen können Sie Geräten je nach Hardware verschiedene Versionen (z. B. Auflösungen) desselben Assets bereitstellen. Du kannst beispielsweise Assets mit niedriger Auflösung an Low-End-Geräte senden, um die Leistung zu verbessern, und Assets mit hoher Auflösung an High-End-Geräte, um die Grafikqualität zu verbessern – ohne die Gesamtgröße des Spiels zu erhöhen, da nur die erforderlichen Assets an die Geräte der Nutzer gesendet werden. Dies baut auf dem Konzept der Asset-Packs in der Asset-Lieferung von Google Play auf. Wie Sie unten sehen, können Sie die Stufenkriterien (jetzt basierend auf dem RAM, bestimmten Gerätemodellen oder verfügbaren Systemfunktionen) definieren und bis zu 5 Stufen verwenden.

Wie Play Asset Delivery unterstützt das Gerätestufen-Targeting API 16 (Jelly Bean 4.1) und höher. Auf Geräten mit API 19 (KitKat 4.4.X) und niedriger wird die Standardstufe unabhängig vom Geräte-Build bereitgestellt.

Vorgehensweise für Entwickler*innen

Grundsätzlich müssen Sie die folgenden Schritte ausführen, um DTT in Ihr vorhandenes Spiel zu integrieren:

  1. Gerätestufen-Targeting (und dadurch Play Asset Delivery) in das Spiel einbinden
    • Integrieren Sie Play Asset Delivery in Ihr Spiel (falls Sie dies noch nicht getan haben).
    • Assets in Asset-Packs aufteilen
    • Verpacke deinen Code und die Assets für das endgültige Android App Bundle-Artefakt, das du bei Google Play hochlädst.
  2. Erstellen Sie Ihre Gerätestufen-Targeting-Konfiguration, damit Play weiß, wie Ihre Assets an die Geräte der Nutzer gesendet werden sollen.
    • Richten Sie die Google Play Developer API ein (falls noch nicht abgeschlossen). Damit senden Sie die DTT-Konfigurationen an Play.
    • Folgen Sie den Schritten zum Erstellen der DTT-Konfiguration.
  3. Laden Sie Ihr AAB in Google Play hoch und testen Sie, ob alles richtig konfiguriert ist

Im ersten Abschnitt werden Sie feststellen, dass die Anleitung je nach verwendetem Build-System Verzweigungen enthält. Welches System Sie auswählen, hängt von der verwendeten Engine und Ihrer aktuellen Einrichtung ab.

  • Gradle (empfohlen für Java und native Spiele): Führen Sie für Spiele, die mit Gradle erstellt wurden, die folgenden Schritte aus, um das Build-System so zu konfigurieren, dass Ihr AAB mit DTT-Unterstützung erstellt wird.
    • Wenn du dein Spiel nach Gradle exportierst und den Build dort fertigstellst, empfehlen wir, dieser Anleitung zu folgen (z. B. Unity-Spiele zu Gradle exportiert))
  • Unity-Plug-in: Wir stellen Ihnen Unity-Pakete für den Import in Ihr Unity-Projekt bereit, mit denen Sie Ihr AAB mit DTT-Unterstützung konfigurieren und erstellen können.

Gerätestufen-Targeting in Ihrer App einrichten

Play Asset Delivery in dein Spiel integrieren (falls noch nicht abgeschlossen)

Mit Play Asset Delivery (PAD) können Sie die Assets Ihres Spiels bei der Installation oder Laufzeit dynamisch bereitstellen. Eine Übersicht dazu finden Sie hier. Beim Gerätestufen-Targeting stellt Play Asset-Packs basierend auf den Gerätestufen-Konfigurationen bereit, die Sie für verschiedene Gerätestufen vorschreiben. Es wird empfohlen, der unten stehenden Anleitung zu folgen, PAD in Ihr Spiel zu integrieren (z.B. Asset-Packs zu erstellen, den Abruf in Ihrem Spiel zu implementieren) und dann den Projektcode zu ändern, um das Gerätestufen-Targeting zu aktivieren.

Gradle

Folgen Sie bei Spielen, die mit Gradle erstellt wurden, dieser Anleitung zum Erstellen von Asset-Packs mit Gradle und anschließend der Anleitung zum Einbinden des Asset-Pack-Abrufs in Ihr Spiel:

Unity

Bei Spielen, die in Unity erstellt wurden, konfigurieren Sie Ihre Asset-Packs mithilfe der Klasse AssetPackConfig, wie in dieser Anleitung beschrieben.

Gerätestufenspezifische Verzeichnisse erstellen

Bei Verwendung von Gradle

Sie teilen Ihre Assets jetzt auf die N-Stufen (maximal 5) auf, die Sie später definieren. Erstellen Sie Ihre DTT-Verzeichnisse, indem Sie die vorhandenen Asset-Bundle-Verzeichnisse verwenden, die im letzten Schritt erstellt wurden, und den entsprechenden Ordner (wie unten beschrieben) mit #tier_0, #tier_1, #tier_2 usw. aktualisieren. Wenn Sie die Asset-Packs in Ihrem Spiel verwenden, müssen Sie Ordner nicht per Postfix adressieren (mit anderen Worten, das Postfix wird während des Build-Prozesses automatisch entfernt).

Nach dem vorherigen Schritt könnte das so aussehen:

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

Wenn Sie auf die Dateien unter dem Ordner zugreifen, können Sie einfach denselben Pfad ohne Post-Fixing verwenden (in diesem Beispiel würde ich als level1/assets/character-textures/ ohne Postfixes verweisen).

Mit Unity

Mit den folgenden AssetPackConfig-Methoden können Sie ein Asset-Pack hinzufügen, das DTT verwendet:

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

Angenommen, Sie haben drei AssetBundles für Ihren Charakter mit unterschiedlichen Detaillierungsgraden.

Verwende das folgende Snippet, um diese AssetBundles der entsprechenden Gerätestufe zuzuordnen.

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 erstellen

Gradle

Konfigurieren Sie in der Datei build.gradle Ihres Projekts die Abhängigkeiten so, dass sie die unten aufgeführten Versionen (oder höher) für das Android-Gradle-Plug-in und das Bundletool haben:

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

Außerdem musst du deine Gradle-Version auf 6.7.1 oder höher aktualisieren. Sie können dies in Ihrem Projekt in gradle/wrapper/gradle-wrapper.properties aktualisieren.

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

Schließlich müssen Sie die Play Asset Delivery Library verwenden. Wenn Sie noch die monolithische Play Core Library verwenden, aktualisieren Sie sie auf 1.8.3 oder höher. Wir empfehlen, zur Play Asset Delivery Library zu wechseln und nach Möglichkeit auf die neueste Version zu aktualisieren.

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

Aktivieren Sie in der Datei build.gradle des Hauptmoduls die DTT-Aufteilung:

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

Als Letztes können Sie Ihr Android App Bundle (AAB) erstellen.

Bundletool

Erstellen Sie Ihr Bundle mit Bundletool und fügen Sie im Schritt zum Anpassen Ihres AAB Folgendes in die BundleConfig.pb-Datei ein:

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

Unity

Nachdem Sie AssetPackConfig so konfiguriert haben, dass es Ihre DTT-Packs enthält, können Sie diese Konfiguration an eine der folgenden Methoden übergeben, um Ihr AAB zu erstellen:

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

Lokale Tests

Bevor du fortfährst, solltest du dein App Bundle lokal testen, um sicherzustellen, dass alles korrekt eingerichtet ist. Mit bundletool (1.8.0 oder höher) erstellen und testen Sie Ihre Anwendung lokal und geben dabei explizit die richtige Gerätestufe an. Zuerst verwenden Sie build-apks, um eine Reihe von .apks-Dateien zu generieren, und stellen dann die App mithilfe von install-apks auf einem verbundenen Gerät bereit. Sie können auch über das Flag für die Gerätestufe angeben, welche Stufe installiert werden soll. Weitere Informationen zu dieser Methode für lokale Tests finden Sie hier. Beachten Sie, dass diese Seite noch nicht für DTT aktualisiert wurde und daher das Flag device-tier fehlt.

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

Alternativ: Sie können auch extract-apks verwenden, um eine Reihe von APKs für ein bestimmtes Gerät zu extrahieren. Die Verwendung von get-device-spec zusammen mit der Angabe der Gerätestufe für dieses Gerät funktioniert jedoch nicht in Verbindung mit dem Flag --local-testing. Das bedeutet, dass du keine Fast-Follow- oder On-Demand-Asset-Packs testen kannst.

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

Die Menüoption Google -> Build and Run (Google -> Erstellen und ausführen) erstellt und führt dein Spiel mit aktiviertem Flag --local-testing aus. Sie können jedoch die an den Befehl install-apks übergebene Gerätestufe nicht angeben.

Wenn Sie eine andere Gerätestufe als 0 angeben möchten, sollten Sie so vorgehen:

  1. Erstellen Sie das AAB mithilfe der Menüoption Google -> Android App Bundle erstellen.
  2. Folgen Sie der Anleitung im vorherigen Abschnitt, um bundletool, build-apks und install-apks auf dem erstellten AAB auszuführen.

Gerätestufenkonfiguration über die Google Play Developer API erstellen

Erste Schritte mit der Google Play Developer API (falls noch nicht abgeschlossen)

Wenn Sie das Gerätestufen-Targeting konfigurieren möchten (z.B. zum Definieren der Anforderungen für jede Stufe), müssen Sie die Konfiguration mit der Android Publisher API bei Google Play hochladen. Unter dem oben angegebenen Link können Sie mehr über die API erfahren. Für den Einstieg sind einige Schritte erforderlich:

  1. Erstellen Sie bei Bedarf Ihr API-Projekt und verknüpfen Sie es mit der Google Play Console.
  2. Richten Sie einen API-Zugriffsclient ein.

Die API-Referenz finden Sie hier. Wenn Sie den Build später über die API hochladen, verwenden Sie die Bearbeitungsmethoden. Es empfiehlt sich außerdem, diese Seite zu lesen, bevor Sie die API verwenden.

Device Tier Configuration API verwenden

Mit dem folgenden API-Aufruf können Sie die Konfiguration der Gerätestufe erstellen:

Gerätestufenkonfiguration erstellen

HTTP-Anfrage POST https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs
Pfadparameter –
Anfragetext Konfiguration der Gerätestufe
Antworttext Konfiguration der Gerätestufe
Konfigurationsobjekt für Gerätestufe

Die Definition von Gerätevarianten umfasst zwei Schritte:

  1. Definieren Sie eine Gruppe von Gerätegruppen.
  2. Definieren Sie Ihre Gerätestufen, indem Sie Ihren Gerätegruppen eine Ebene zuweisen.

Eine Gerätegruppe besteht aus einer Reihe von Geräten, die den in der Konfiguration definierten Selektoren entsprechen.

Selektoren können Anforderungen an den Geräte-RAM und Gerätemodell definieren.

Gruppen werden durch einen von Ihnen gewählten Namen identifiziert. Gruppen können sich überschneiden.

Als Nächstes können Sie Ihre Gerätestufen definieren, indem Sie die Gruppen sortieren: Jede Gerätestufe wird durch ihre Ebene und eine Gerätegruppe definiert.

Wenn ein Gerät mit mehreren Ebenen übereinstimmt, werden ihm die Inhalte der höchsten übereinstimmenden Stufe bereitgestellt.

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

Felder:

  • device_confid_id (Ganzzahl): ID, die dieser Gerätestufenkonfiguration entspricht.

  • device_groups (Objekt): Gruppendefinitionen

    • name (String): Name der Gerätegruppe (eine von Ihnen definierte String-ID).
    • device_selectors (Objekt): Geräteanforderungen, damit ein Gerät zu dieser Gruppe gehört.
    • device_ram (Objekt): RAM-Anforderungen des Geräts
      • min_bytes (Ganzzahl, einschließlich): mindestens erforderlicher RAM (in Byte)
      • max_bytes (Ganzzahl, exklusiv): maximal benötigter RAM (in Byte)
    • included_device_ids (Objekt): Gerätemodelle, die in diesen Selektor aufgenommen werden sollen (max. 10.000 Geräte-IDs pro Gruppe) Ein Gerät muss in dieser Liste enthalten sein, damit es dem Selektor entspricht. Dies ist eine notwendige, aber nicht ausreichend Bedingung für den vollständigen Selektor (siehe Hinweis zum Kombinieren von Anforderungen in einem Selektor oben).
      • build_brand (String): Gerätehersteller
      • build_device (String): Gerätemodellcode
    • excluded_device_ids (Objekt): Gerätemodelle, die in diesem Selektor ausgeschlossen werden sollen (max. 10.000 device_ids pro Gruppe) Ein Gerät aus dieser Liste entspricht nicht der Auswahl, auch wenn sie alle anderen Anforderungen in der Auswahl erfüllt.
      • build_brand (String): Gerätehersteller
      • build_device (String): Gerätemodellcode

    • required_system_features (Objekt): Funktionen, die ein Gerät in dieser Auswahl enthalten müssen (max. 100 Features pro Gruppe) Auf einem Gerät müssen alle Systemfunktionen in dieser Liste enthalten sein, damit es zur Auswahl passt. Dies ist eine notwendige, aber nicht ausreichende Bedingung, um den vollständigen Selektor zu erfüllen (siehe Hinweis oben zum Kombinieren von Anforderungen in einem Selektor).

      Systemreferenz

      • name (String): eine Systemfunktion

    • forbidden_system_features (Objekt): Funktionen, die in dieser Auswahl nicht enthalten sein dürfen (max. 100 Features pro Gruppe). Wenn ein Gerät eine der Systemfunktionen in dieser Liste hat, stimmt es nicht mit dem Selektor überein, auch wenn es alle anderen Anforderungen im Selektor erfüllt.

      Systemreferenz

      • name (String): eine Systemfunktion

  • device_tiers (Objekt): Stufendefinitionen

    • level (int): die Ebene der Stufe
    • group_name (String-Array): Der Name der Gerätegruppen, die zu dieser Stufe gehören

Die richtige Formatierung für den Gerätehersteller und den Modellcode findest du im Gerätekatalog in der Google Play Console. Dazu hast du eine der folgenden Möglichkeiten:

  • Überprüfung einzelner Geräte mithilfe des Gerätekatalogs

    Seite für Pixel 4a im Gerätekatalog

    Seite für Pixel 4a im Gerätekatalog

  • Sie laden eine CSV-Datei der unterstützten Geräte herunter und verwenden den Hersteller bzw. den Modellcode für die Felder build_brand bzw. build_device.

Hier ist eine Beispielkonfiguration mit drei Stufen: Stufe 2 verwendet die Gerätegruppe hoch (die alle Geräte über 7 GB und Pixel 4 umfasst), Stufe 1 verwendet die Gerätegruppe medium (die alle Geräte zwischen 4–7 GB umfasst) und Stufe 0, die implizit als Catchall-Gruppe definiert ist.

{
  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'
        ]
      }
    ]
  }
}

Folgen Sie der Anleitung unten zum Validieren der Geräte-Targeting-Konfiguration, bevor Sie sie bei Google Play hochladen.

Gerätestufenkonfiguration nach ID abrufen

Mit dem folgenden Aufruf können Sie eine bestimmte Geräteklassenkonfiguration nach ID abrufen:

HTTP-Anfrage GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs/{deviceTierConfigId}
Pfadparameter –
Anfragetext –
Antworttext Konfiguration der Gerätestufe

Liste der Gerätestufenkonfigurationen abrufen

Mit dem folgenden Aufruf können Sie die letzten zehn Geräteebenenkonfigurationen abrufen (oder optimal mit dem Abfrageparameter page_token eine Zehnergruppe angeben):

HTTP-Anfrage GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs
Pfadparameter –
Abfrageparameter page_token (optional): Wird verwendet, um eine bestimmte Gruppe von zehn DTCs anzugeben. Dies ist nützlich, wenn Sie mehr als 10 DTCs erstellt haben und DTCs sehen möchten, die vor den letzten 10 erstellt wurden.
Anfragetext –
Antworttext Liste der Gerätestufenkonfigurationen

Seitentoken

Konfiguration für die Ausrichtung auf Geräte prüfen

bundletool enthält zwei Befehle, mit denen Sie prüfen können, ob Ihre Geräte-Targeting-Konfiguration wie beabsichtigt funktioniert, bevor Sie sie bei Google Play hochladen.

Mit bundletool print-device-targeting-config können Sie prüfen, ob die Syntax Ihrer JSON-Datei korrekt ist, und Ihre Gerätegruppen und -stufen in einem besser lesbaren Format visualisieren.

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

Mit bundletool evaluate-device-targeting-config können Sie auswerten, welche Gruppen und Stufen zu einem bestimmten Gerät passen würden. Entweder verbinden Sie das Zielgerät mit Ihrer Workstation und verwenden das Flag --connected-device. Sie können aber auch eine JSON-Datei mit den Geräteeigenschaften manuell kompilieren und über das Flag --device-properties bereitstellen.

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

Die Datei mit den Geräteeigenschaften sollte eine JSON-Datei sein, die der Protokollpuff-Struktur DeviceProperties entspricht. Beispiele:

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

Android App Bundle bei Google Play hochladen

Über API

Mit der Google Play Developer API können Sie Ihr Android App Bundle bei Google Play hochladen und eine bestimmte Konfiguration für die Ausrichtung auf Gerätestufen mit Ihrem Build verknüpfen.

Einen allgemeinen Überblick über die Bearbeitungsmethoden sowie detailliertere Beispiele für Veröffentlichungen in den verschiedenen Tracks in der Google Play Console finden Sie hier. Unter dem letzten Link finden Sie die AAB-freundlichen APIs anstelle der APK-freundlichen API, die auf dieser Seite aufgeführt ist. Zum Angeben der Gerätestufenkonfiguration für Ihren Build fügen Sie dem Abfrageparameter deviceTierConfigId die Konfigurations-ID hinzu, während Sie die Methode edits.bundle.upload so aufrufen:

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

Über die Google Play Console

Folgen Sie dieser Anleitung, um Ihr Android App Bundle hochzuladen. Die aktuelle DTC-Konfiguration wird auf Ihr App Bundle angewendet.

Sie können prüfen, ob Ihr Bundle richtig erstellt wurde. Rufen Sie dazu App Bundle Explorer mit dem richtigen Build > Bereitstellung auf und klicken Sie auf die einzelnen Asset-Packs. Es sollte angezeigt werden, dass Sie die von Ihnen erstellten N Stufen haben. In diesem Beispiel ist zu sehen, dass ich drei Ebenen für mein Asset-Pack main_asset habe: 0, 1 und 2.

Asset-Pack mit drei Ebenen

Prüfen, ob die richtige Stufe bereitgestellt wird

Verwende die folgende Methode, damit nur die richtige Stufe an das Gerät gesendet wird

adb shell pm path {packageName}

Sie sollten etwa Folgendes sehen:

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

Zusatz

Schnellstart mit Curl

Im Folgenden finden Sie ein Beispiel (unter Verwendung des Befehlszeilentools „curl“) zum Erstellen einer neuen Geräteebenenkonfiguration und zum Erstellen einer neuen Änderung über die Edits API, zum Hochladen eines neuen AAB (Verknüpfen mit einer bestimmten Gerätestufenkonfiguration), zum Festlegen der Track-/Release-Konfiguration und zum Commit der Änderung. (die Änderung wird somit öffentlich gemacht). Sie benötigen den folgenden Speicherort:

  • Den Schlüssel für Ihren API-Client
  • Paketname Ihrer App

Erstellen Sie zuerst eine Konfiguration für Gerätestufen und notieren Sie sich die deviceTierConfigId, die Sie nach einem erfolgreichen Aufruf erhalten.

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

Änderung starten: Sie erhalten eine ID und die Ablaufzeit für die Änderung. Speichern Sie die ID für die folgenden Aufrufe.

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

Laden Sie das AAB hoch und geben Sie die Gerätestufenkonfiguration als Abfrageparameter an. Bei einem erfolgreichen Aufruf wird der Versionscode „sha1“ und „sha256“ des Builds angezeigt. Speichern Sie den Versionscode für den nächsten Aufruf.

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

Weisen Sie das AAB dem gewünschten Track zu. Zum Testen wird empfohlen, den internen Test-Track zu verwenden. Hier finden Sie weitere Informationen zu den verschiedenen Tracks. Hier führen wir ein einfaches Rollout ohne Versionshinweise durch. Auf dieser Seite finden Sie weitere Informationen zu gestaffelten Roll-outs, Release-Entwürfen und Versionshinweisen. Wenn du die Publisher API zum ersten Mal verwendest, solltest du sie als Versionsentwurf erstellen und diesen in der Google Play Console fertigstellen, um sicherzustellen, dass alles richtig konfiguriert ist.

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}

Commit für Änderungen durchführen (verfahren Sie mit Vorsicht, da dadurch alle Änderungen für den gewünschten Track bei Google Play live geschaltet werden)

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