Diese Seite wurde von der Cloud Translation API übersetzt.

Targeting auf Geräteebene

Was ist das Targeting auf Geräteklassen?

Mit der Ausrichtung auf Geräteklassen kannst du verschiedene Versionen (z. B. Auflösungen) desselben Assets für Geräte basierend auf ihrer Hardware bereitstellen. Beispielsweise können Sie Assets mit niedriger Auflösung für Low-End-Geräte bereitstellen, um die Leistung zu verbessern, und Assets mit hoher Auflösung für High-End-Geräte, um die Grafikqualität zu verbessern. Dabei wird die Gesamtgröße des Spiels nicht erhöht, da nur die erforderlichen Assets auf die Geräte der Nutzer übertragen 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 festlegen (aktuell basierend auf RAM, bestimmten Gerätemodellen oder verfügbaren Systemfunktionen) und bis zu fünf Stufen verwenden.

Wie bei der Play Asset Delivery wird das Geräteebenen-Targeting ab API 16 (Jelly Bean 4.1) unterstützt. Auf Geräten mit API 19 (KitKat 4.4.X) und niedriger wird jedoch unabhängig von der Geräteversion die Standardebene bereitgestellt.

Entwickler Journey

Um DTT in Ihr bestehendes Spiel einzubinden, müssen Sie im Wesentlichen die folgenden Schritte ausführen:

Geräteebenen-Targeting (und damit auch Play Asset Delivery) in Ihr Spiel einbinden
- Play Asset Delivery in Ihr Spiel einbinden (falls noch nicht geschehen)
- Assets in Asset-Packs unterteilen
- Verpacken Sie Ihren Code und Ihre Assets in einem endgültigen Android App Bundle-Artefakt, das Sie in Google Play hochladen.
Erstellen Sie die Konfiguration für die Geräteebene, damit Google Play weiß, wie Ihre Assets auf Nutzergeräten ausgeliefert werden sollen.
- Richten Sie die Google Play Developer API ein (falls noch nicht geschehen). Über diese API senden Sie die DTT-Konfigurationen an Google Play.
- Führe die Schritte zum Erstellen der DTT-Konfiguration aus.
Laden Sie Ihre AAB bei Google Play hoch und prüfen Sie, ob alles richtig konfiguriert ist.

Wie Sie sehen, gibt es je nach verwendetem Build-System Forks in der Anleitung. Welches System Sie wählen, hängt von der verwendeten Engine und Ihrer bestehenden Einrichtung ab.

Gradle (empfohlen für Java- und native Spiele): Wenn Sie Spiele mit Gradle erstellen, folgen Sie diesen Schritten, um das Build-System so zu konfigurieren, dass Ihre AAB mit DTT-Unterstützung erstellt wird.
- Wenn Sie Ihr Spiel nach Gradle exportieren und den Build dort fertigstellen, empfehlen wir Ihnen, dieser Anleitung zu folgen (z. B. Unity-Spiele, die nach Gradle exportiert wurden
Unity-Plug-in: Wir stellen Ihnen Unity-Pakete zur Verfügung, die Sie in Ihr Unity-Projekt importieren können. So können Sie Ihre AAB mit DTT-Unterstützung konfigurieren und erstellen.

Targeting auf Geräteklassen in Ihrer App einrichten

Play Asset Delivery in Ihr Spiel einbinden (falls noch nicht geschehen)

Mit Play Asset Delivery (PAD) kannst du die Assets deines Spiels zum Zeitpunkt der Installation oder Laufzeit dynamisch bereitstellen. Eine Übersicht dazu findest du hier. Mit dem Targeting auf Gerätestufen stellt Google Play Asset-Packs bereit, die auf den von Ihnen vorgegebenen Geräteklassenkonfigurationen für verschiedene Geräteebenen basieren. Wir empfehlen, der Anleitung unten zu folgen und PAD in Ihr Spiel einzubinden (d.h. Asset-Pakete erstellen, Abruf in Ihrem Spiel implementieren) und dann den Projektcode so zu ändern, dass das Targeting auf Geräteebene aktiviert wird.

Gradle

Für mit Gradle erstellte Spiele folgen Sie dieser Anleitung zum Erstellen von Asset-Packs mit Gradle und dann dieser Anleitung zum Einbinden des Abrufs von Asset-Packs in Ihr Spiel:

Java
Nativ
Unity-Spiele, die nach Gradle exportiert wurden
- Java-Bibliotheken über die JNI verwenden (z. B. die in Unity integrierte)

Unity

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

Geräteebenenspezifische Verzeichnisse erstellen

Wenn Sie Gradle verwenden

Sie teilen nun Ihre Assets auf die n Stufen (max. 5) auf, die Sie später definieren. Erstellen Sie Ihre DTT-Verzeichnisse, indem Sie die vorhandenen Asset-Bundle-Verzeichnisse, die im letzten Schritt erstellt wurden, und anschließend die Korrektur des entsprechenden Ordners (wie unten beschrieben) mit #tier_0, #tier_1, #tier_2 usw. nachbearbeiten. Wenn Sie die Asset-Packs in Ihrem Spiel verwenden, müssen Sie Ordner nicht per Postfix adressieren (d. h., das Postfix wird während des Build-Prozesses automatisch entfernt).

Nach dem vorherigen Schritt könnte dies 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 im Ordner zugreifen, können Sie einfach denselben Pfad ohne Suffix verwenden. In diesem Beispiel würde ich auf level1/assets/character-textures/ ohne Suffix verweisen.

Wenn Sie Unity verwenden

Du hast folgende Möglichkeiten, ein Asset-Paket mit DTT hinzuzufügen: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)

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

Mit dem folgenden Snippet kannst du diese AssetBundles der entsprechenden Geräteebene zuordnen.

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 folgenden Versionen (oder höher) für das Android Gradle-Plug-in und bundletool haben:

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

Außerdem müssen Sie Ihre Gradle-Version auf 6.7.1 oder höher aktualisieren. Sie können dies in Ihrem Projekt unter gradle/wrapper/gradle-wrapper.properties aktualisieren.

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

Außerdem müssen Sie die Play Asset Delivery Library verwenden. Wenn Sie noch die monolithische Play Core Library verwenden, aktualisieren Sie sie auf Version 1.8.3 oder höher. Wir empfehlen, auf die Play Asset Delivery Library umzustellen 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 Haupt-App-Moduls die DTT-Aufteilung:

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

Schließlich können Sie Ihr Android App Bundle (AAB) erstellen.

Bundletool

Erstellen Sie Ihr Bundle mit bundletool und fügen Sie beim 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 die AssetPackConfig so konfiguriert haben, dass sie Ihre DTT-Pakete 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)

Lokales Testen

Bevor Sie fortfahren, sollten Sie Ihr App-Bundle lokal testen, um sicherzustellen, dass alles richtig eingerichtet ist. Mit bundletool (Version 1.8.0 oder höher) können Sie Ihre App lokal erstellen und testen, indem Sie das richtige Geräte-Tier explizit angeben. Sie generieren zuerst mit build-apks eine Reihe von .apks-Dateien und stellen Ihre App dann mit install-apks auf einem verbundenen Gerät bereit. Sie können auch über das Flag „device-tier“ 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: Du kannst auch extract-apks verwenden, um eine Reihe von APKs für ein bestimmtes Gerät zu extrahieren. Die Verwendung von get-device-spec und die Angabe der Geräteebene für dieses Gerät funktioniert jedoch nicht in Verbindung mit dem Flag --local-testing. Du kannst also keine Fast-Follow- oder On-Demand-Asset-Packs testen.

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

Mit der Menüoption Google -> Build and Run (Google -> Build and Run) wird dein Spiel erstellt und ausgeführt, wobei das Flag --local-testing aktiviert ist. Sie können damit jedoch nicht die Geräteebene angeben, die an den install-apks-Befehl übergeben wird.

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

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

Geräteebenen-Konfiguration über die Google Play Developer API erstellen

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

Wenn Sie das Targeting auf Geräteebene konfigurieren möchten (z.B. die Anforderungen für jede Stufe definieren), müssen Sie die Android Publisher API verwenden, um Ihre Konfiguration bei Google Play hochzuladen. Weitere Informationen zur API findest du über den obigen Link. Für den Einstieg sind einige Schritte erforderlich:

Die API-Referenz finden Sie hier. Wenn Sie Ihren Build später über die API hochladen, verwenden Sie die Methoden für Änderungen. Außerdem empfehlen wir dir, diese Seite zu lesen, bevor du die API verwendest.

Device Tier Configuration API verwenden

Mit dem folgenden API-Aufruf kannst du die Geräteebenen-Konfiguration erstellen:

Gerätestufenkonfiguration erstellen

HTTP-Anfrage	`POST https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs`
Pfadparameter	–
Anfragetext	Geräteebenenkonfiguration
Antworttext	Geräteebenenkonfiguration

Konfigurationsobjekt für Geräteklasse

Gerätevarianten werden in zwei Schritten definiert:

Definieren Sie eine Reihe von Gerätegruppen.
Definieren Sie die Gerätestufengruppe, indem Sie Ihren Gerätegruppen eine Ebene zuweisen.

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

Mithilfe von Auswahlschaltern können Sie Anforderungen an den Geräte-RAM und das Gerätemodell definieren.

Gruppen werden durch einen von dir ausgewählten Namen identifiziert und Gruppen dürfen sich überschneiden.

Als Nächstes können Sie Ihren Gerätestufensatz definieren, indem Sie die Gruppen nach ihrer Stufe und einer Gerätegruppe ordnen. Jede Gerätestufe wird durch ihre Stufe und eine Gerätegruppe definiert.

Wenn ein Gerät mehreren Stufen entspricht, werden ihm die Inhalte der Stufe mit der höchsten Übereinstimmung 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äteebenen-Konfiguration entspricht.
device_groups (Objekt): Gruppendefinitionen
- name (String): Name der Gerätegruppe (eine von Ihnen definierte String-ID).
- device_selectors (Objekt): Geräteanforderungen, die ein Gerät erfüllen muss, um zu dieser Gruppe zu gehören.
- device_ram (Objekt): RAM-Anforderungen des Geräts
  - min_bytes (Ganzzahl, einschließlich): Mindestens erforderlicher RAM (in Byte)
  - max_bytes (Ganzzahl, ausschließlich): Maximaler erforderlicher RAM (in Byte)
- included_device_ids (Objekt): Gerätemodelle, die in diese Auswahl eingeschlossen werden sollen (maximal 10.000 device_ids pro Gruppe). Ein Gerät muss sich in dieser Liste befinden, um der Auswahl zu entsprechen. Dies ist eine notwendige, aber keine hinreichende Bedingung für eine Übereinstimmung mit der vollständigen Auswahl (siehe Hinweis oben zum Kombinieren von Anforderungen in einer Auswahl).
  - build_brand (String): Gerätehersteller
  - build_device (String): Gerätemodellcode
- excluded_device_ids (Objekt): Gerätemodelle, die in dieser Auswahl ausgeschlossen werden sollen (maximal 10.000 device_ids pro Gruppe). Ein Gerät aus dieser Liste wird nicht mit der Auswahl übereinstimmen, auch wenn es allen anderen Anforderungen in der Auswahl entspricht.
  - build_brand (String): Gerätehersteller
  - build_device (String): Gerätemodellcode
- required_system_features (Objekt): Funktionen, die ein Gerät haben muss, um in dieser Auswahl enthalten zu sein (maximal 100 Funktionen pro Gruppe). Für ein Gerät müssen alle Systemfunktionen in dieser Liste enthalten sein, damit es der Auswahl entspricht. Dies ist eine notwendige, aber keine hinreichende Bedingung für eine Übereinstimmung mit der gesamten Auswahl (siehe Hinweis oben zum Kombinieren von Anforderungen in einer Auswahl).
  
  Referenz zu Systemfunktionen
  - name (String): Eine Systemfunktion
- forbidden_system_features (Objekt): Funktionen, die bei einem Gerät nicht in dieser Auswahl enthalten sein dürfen (maximal 100 Funktionen pro Gruppe). Wenn ein Gerät eine der Systemfunktionen in dieser Liste hat, entspricht es nicht der Auswahl, auch wenn es alle anderen Anforderungen in der Auswahl erfüllt.
  
  Referenz zu Systemfunktionen
  - name (String): Eine Systemfunktion
device_tiers (Objekt): Stufendefinitionen
- level (int): Die Ebene der Stufe
- group_name (Stringarray): Der Name der Gerätegruppen, die zu dieser Stufe gehören

Hinweis:

Für eine Gruppe können mehrere Geräteselektoren angegeben werden. Ein Gerät gehört zu der Gruppe, wenn es mindestens einem Gruppenselektor entspricht (logisches ODER).
Ein Gerät kann mehreren Gruppen angehören.
Ein Selektor kann Bedingungen für RAM, Ein- und Ausschluss von Gerätemodellen sowie erforderliche/verbotene Systemfunktionen angeben. Wenn ein Selektor mehrere Bedingungen angibt, entspricht ein Gerät dem Selektor, wenn es allen Bedingungen entspricht (logisches UND).

Warnung: Wenn Sie mehrere Regeln in derselben Auswahl angeben, wird eine logische UND-Verknüpfung erstellt. Beispiel:

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

wird die Bedingung für alle Geräte mit mehr als 7 GB RAM UND Pixel 4 erstellt. Sie kann auch so geschrieben werden:

Wenn Sie eine ODER-Bedingung verwenden möchten, gruppieren Sie diese als separate Selektoren. Beispiel:

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

wird die Bedingung für alle Geräte mit mehr als 7 GB RAM ODER für Pixel 4 erstellt. Das kann auch so geschrieben werden:

Die richtige Formatierung für den Gerätehersteller und den Modellcode finden Sie im Gerätekatalog in der Google Play Console. Gehen Sie dazu so vor:

Prüfen Sie einzelne Geräte mit dem Gerätekatalog und suchen Sie den Hersteller- und Modellcode an den im folgenden Beispiel gezeigten Stellen. Bei Google Pixel 4a lautet der Hersteller „Google“ und der Modellcode „sunfish“.
Laden Sie eine CSV-Datei mit unterstützten Geräten herunter und verwenden Sie die Werte Hersteller und Modellcode für die Felder build_brand und build_device.

Hier ist eine Beispielkonfiguration mit drei Stufen: Stufe 2 verwendet die Gerätegruppe high (alle Geräte mit mehr als 7 GB und Google Pixel 4), Stufe 1 die Gerätegruppe medium (alle Geräte mit 4–7 GB) und Stufe 0, die implizit als All-inclusive-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, um die Konfiguration für die Geräteausrichtung zu validieren, bevor Sie sie bei Google Play hochladen.

Geräteebenen-Konfiguration nach ID abrufen

Mit dem folgenden Aufruf kannst du eine bestimmte Geräteebenen-Konfiguration anhand der ID abrufen:

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

Liste der Konfigurationen für Gerätestufen abrufen

Mit dem folgenden Aufruf kannst du die letzten zehn Konfigurationen der Geräteebene abrufen. Du kannst auch zehn Konfigurationen mit dem Abfrageparameter page_token angeben:

HTTP-Anfrage	`GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs`
Pfadparameter	–
Abfrageparameter	page_token (optional): Damit wird eine bestimmte Gruppe von 10 DTCs angegeben. Das ist hilfreich, wenn Sie mehr als 10 DTCs erstellt haben und sich DTCs ansehen möchten, die vor den letzten 10 erstellt wurden.
Anfragetext	–
Antworttext	Liste der Konfigurationen für Geräteebenen page_token

Konfiguration des Geräte-Targetings 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 auf Google Play hochladen.

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

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

Mit bundletool evaluate-device-targeting-config kannst du prüfen, welche Gruppen und Stufen zu einem bestimmten Gerät passen. Sie können entweder Ihr Zielgerät mit Ihrer Workstation verbinden und das Flag --connected-device verwenden oder 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 gemäß der Protobuf-Struktur DeviceProperties sein. Beispiel:

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

Sie können die Google Play Developer API verwenden, um Ihr Android App Bundle bei Google Play hochzuladen und eine bestimmte Konfiguration für die Ausrichtung auf Geräteebene mit Ihrem Build zu verknüpfen.

Eine allgemeine Übersicht über die Bearbeitungsmethoden sowie detailliertere Beispiele für die Veröffentlichung in den verschiedenen Tracks in der Google Play Console findest du hier. Für den letzten Link solltest du die AAB-freundlichen APIs anstelle der APK-freundlichen API verwenden, die auf der Seite aufgeführt sind. Um die Konfiguration der Gerätestufe für Ihren Build anzugeben, fügen Sie die Konfigurations-ID dem Abfrageparameter deviceTierConfigId hinzu, während Sie die Methode edits.bundle.upload 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 aktuellste DTC-Konfiguration wird auf Ihr App-Bundle angewendet.

Sie können prüfen, ob Ihr Bundle richtig erstellt wurde, indem Sie den App Bundle Explorer (mit dem richtigen Build ausgewählt) > Bereitstellung aufrufen und auf jedes Asset-Paket klicken. Es sollte angezeigt werden, dass Sie die von Ihnen erstellten N Stufen haben. In diesem Beispiel sind für mein Asset-Paket main_asset drei Stufen zu sehen: 0, 1 und 2.

Asset-Pack mit drei Stufen

Überprüfen, ob die richtige Stufe bereitgestellt wird

Mit der folgenden Methode kannst du dafür sorgen, dass 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 Beispiel wird mit dem Befehlszeilentool „curl“ eine neue Konfiguration für die Geräteebene erstellt. Anschließend wird mit der Edits API eine neue Änderung erstellt, eine neue AAB hochgeladen (mit einer bestimmten Konfiguration für die Geräteebene verknüpft), die Track-/Release-Konfiguration festgelegt und die Änderung committet. Die Änderung wird dadurch öffentlich. Sie benötigen die Standorte der folgenden Elemente:

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

Erstelle zuerst eine Geräteebenen-Konfiguration und notiere dir die deviceTierConfigId, die du bei einem erfolgreichen Aufruf erhältst.

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

Bearbeitung starten: Sie erhalten eine ID und ein Ablaufdatum für die Bearbeitung. 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 die AAB hoch und geben Sie die Geräteebenen-Konfiguration als Abfrageparameter an. Wenn der Aufruf erfolgreich war, sehen Sie einen Versionscode, SHA1 und SHA256 des Builds. 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. Für Tests wird empfohlen, den internen Test-Track zu verwenden. Hier finden Sie weitere Informationen zu den verschiedenen Tracks. Hier wird ein einfaches Rollout ohne Versionshinweise durchgeführt. Auf dieser Seite finden Sie weitere Informationen zu gestaffelten Roll-outs, Versionsentwürfen und Versionshinweisen. Wenn Sie die Publisher API zum ersten Mal verwenden, empfehlen wir Ihnen, diese als Release-Entwurf zu erstellen und den Release in der Google Play Console abzuschließen, 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}

Änderungen übernehmen (Vorsicht: Dadurch werden alle Änderungen am gewünschten Release-Track bei Google Play veröffentlicht.)

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