Kierowanie na poziom urządzenia

Czym jest kierowanie na kategorię urządzeń?

Kierowanie na kategorię urządzeń umożliwia dostarczanie różnych wersji (np. rozdzielczości) tego samego komponentu na urządzenia na podstawie ich sprzętu. Możesz na przykład dostarczać zasoby o niskiej rozdzielczości na słabsze urządzenia, żeby gra działała szybciej, a zasoby o wyższej rozdzielczości – na urządzenia o lepszych parametrach, które poradzą sobie z grafiką wysokiej jakości. Wszystko to bez zwiększania rozmiaru gry, ponieważ na urządzenia użytkowników dostarczane są tylko niezbędne zasoby. Jest to rozwinięcie koncepcji pakietów zasobów w Play Asset Delivery. Jak zobaczysz poniżej, możesz zdefiniować kryteria poziomów (obecnie na podstawie pamięci RAM, konkretnych modeli urządzeń lub dostępnych funkcji systemu) i użyć maksymalnie 5 poziomów.

Podobnie jak usługa dostarczania zasobów w Google Play, kierowanie na poziom urządzenia obsługuje interfejs API 16 (Jelly Bean 4.1) lub nowszy. Na urządzeniach z interfejsem API 19 (KitKat 4.4.X) lub starszym domyślny poziom jest dostarczany niezależnie od wersji urządzenia.

Ścieżka dewelopera

Ogólnie rzecz biorąc, aby zintegrować DTT z dotychczasową grą, wykonaj te czynności:

  1. Zintegruj kierowanie na poziom urządzenia (a co za tym idzie, Play Asset Delivery) w swojej grze.
    • Zintegruj z grą Play Asset Delivery (jeśli jeszcze tego nie zrobiono)
    • Podziel zasoby na pakiety zasobów
    • Spakuj kod i zasoby, aby utworzyć końcowy artefakt pakietu Android App Bundle, który prześlesz do Google Play.
  2. Utwórz konfigurację kierowania na poziom urządzenia, aby Google Play wiedział, jak dostarczać zasoby na urządzenia użytkowników.
    • Skonfiguruj interfejs Google Play Developer API (jeśli nie zostało to jeszcze zrobione). Będziesz go używać do wysyłania konfiguracji DTT do Google Play.
    • Wykonaj czynności, aby utworzyć konfigurację DTT.
  3. Prześlij pakiet AAB do Google Play i sprawdź, czy wszystko jest prawidłowo skonfigurowane.

W pierwszej sekcji znajdziesz informacje o rozgałęzieniach w poradniku, które zależą od używanego systemu kompilacji. Wybór systemu zależy od używanego silnika i dotychczasowej konfiguracji.

  • Gradle (zalecana w przypadku gier Java i natywnych): w przypadku gier tworzonych przy użyciu Gradle wykonaj te czynności, aby skonfigurować system kompilacji pod kątem pakietu pakietu aplikacji na żywo z obsługą przenoszenia danych.
    • Jeśli wyeksportujesz grę do Gradle, a potem dokończyć kompilację, zalecamy wykonanie tych instrukcji (np. gier Unity wyeksportowanych do Gradle)).
  • Wtyczka do Unity: udostępnimy Ci pakiety Unity do zaimportowania do projektu Unity, które umożliwią skonfigurowanie i skompilowanie AAB z obsługą DTT.

Konfigurowanie kierowania na kategorię urządzeń w aplikacji

Zintegruj Play Asset Delivery z grą (jeśli nie zostało to jeszcze zrobione).

Usługa Play Asset Delivery (PAD) umożliwia dynamiczne przesyłanie zasobów gry w momencie instalacji lub w czasie działania. Tutaj znajdziesz jej omówienie. Dzięki kierowaniu na kategorię urządzeń Google Play będzie dostarczać pakiety komponentów na podstawie konfiguracji kategorii urządzeń określonych dla różnych kategorii urządzeń. Zalecamy postępowanie zgodnie z poniższymi wskazówkami i zintegrowanie PAD z grą (tzn. utworzenie pakietów zasobów, wdrożenie pobierania w grze), a potem zmodyfikowanie kodu projektu, by włączyć kierowanie na grupę urządzeń.

Gradle

W przypadku gier utworzonych za pomocą Gradle skorzystaj z tych instrukcji dotyczących tworzenia pakietów zasobów za pomocą Gradle, a następnie postępuj zgodnie z instrukcjami integracji funkcji pobierania pakietów zasobów w grze:

Unity

W przypadku gier utworzonych w Unity pakiety zasobów skonfigurujesz za pomocą klasy AssetPackConfig, zgodnie z tymi instrukcjami.

Tworzenie katalogów dla poszczególnych poziomów urządzeń

Jeśli używasz Gradle

Teraz podzielisz zasoby na N poziomów (maksymalnie 5), które zdefiniujesz później. Utwórz katalogi DTT, korzystając z dotychczasowych katalogów pakietów zasobów utworzonych w ostatnim kroku i poprawiając odpowiedni folder (jak opisano poniżej) za pomocą #tier_0, #tier_1, #tier_2 itd. Korzystając z pakietów zasobów w grze, nie musisz adresować folderów za pomocą postfixa (czyli postfix jest automatycznie usuwany podczas procesu kompilacji).

Po wykonaniu poprzedniego kroku może to wyglądać tak:

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

Gdy otworzysz pliki w tym folderze, możesz użyć tej samej ścieżki bez poprawiania postu (w tym przykładzie użyję nazwy level1/assets/character-textures/ bez poprawek).

Jeśli używasz Unity

Aby dodać pakiet zasobów, który korzysta z przenoszenia danych, możesz skorzystać z tych metod 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)

Załóżmy na przykład, że masz 3 AssetBundles z różnymi poziomami szczegółowości.

Aby zmapować te wartości AssetBundles z odpowiednim poziomem urządzenia, użyj tego fragmentu kodu.

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

Tworzenie pakietu Android App Bundle

Gradle

W pliku build.gradle projektu skonfiguruj zależności, aby wtyczka Androida do obsługi Gradle i bundletool miały te wersje (lub nowsze):

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

Musisz też zaktualizować Gradle w wersji 6.7.1 lub nowszej. Możesz to zmienić w gradle/wrapper/gradle-wrapper.propertiesw ramach projektu.

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

Na koniec musisz użyć biblioteki Play Asset Delivery. Jeśli nadal używasz monolitycznej biblioteki podstawowej Play, zaktualizuj ją do wersji 1.8.3 lub nowszej. Zalecamy przejście na Bibliotekę Play Asset Delivery i w miarę możliwości zaktualizowanie do najnowszej wersji.

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

W pliku build.gradle głównego modułu aplikacji włącz podział DTT:

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

Na koniec możesz utworzyć pakiet aplikacji na Androida (AAB).

Pakiet narzędzi

Utwórz pakiet za pomocą narzędzia bundletool i podczas dostosowywania pakietu aplikacji na Androida dodaj do pliku BundleConfig.pb poniższy kod.

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

Unity

Po skonfigurowaniu AssetPackConfig tak, aby zawierało pakiety DTT, możesz przekazać tę konfigurację za pomocą jednej z tych metod, aby utworzyć pakiet aplikacji na Androida:

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

Testowanie lokalne

Przed kontynuacją zalecamy przetestowanie pakietu aplikacji lokalnie, aby mieć pewność, że wszystko jest prawidłowo skonfigurowane. Za pomocą bundletool (w wersji 1.8.0 lub nowszej) możesz skompilować i przetestować aplikację lokalnie, wyraźnie określając odpowiedni poziom urządzenia. Najpierw za pomocą narzędzia build-apks wygenerujesz zestaw plików .apks, a następnie wdrożysz aplikację na połączonym urządzeniu za pomocą install-apks. Za pomocą flagi poziomu urządzenia możesz też określić poziom instalacji. Więcej informacji o tej metodzie testowania lokalnego znajdziesz tutaj (pamiętaj, że ta strona nie została jeszcze zaktualizowana pod kątem DTT, dlatego brakuje na niej flagi 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

Alternatywnie: możesz też użyć extract-apks, aby wyodrębnić zestaw plików APK dla konkretnego urządzenia. Użycie właściwości get-device-spec oraz określenie klasy urządzenia dla tego urządzenia nie będzie jednak działać w połączeniu z flagą --local-testing, co oznacza, że nie będzie można testować pakietów zasobów typu fast-Follow ani na żądanie.

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

Opcja menu Google -> Kompiluj i uruchamiaj skompiluje i uruchomi grę z włączoną flagą --local-testing. Nie pozwala jednak na określenie typu urządzenia przekazywanego do polecenia install-apks.

Jeśli chcesz określić kategorię urządzenia inną niż 0, wykonaj te czynności:

  1. Aby utworzyć pakiet aplikacji na Androida, użyj opcji menu Google -> Utwórz pakiet Android App Bundle.
  2. Aby uruchomić bundletool, build-apks i install-apks na skompilowanym pakiecie aplikacji na Androida, wykonaj instrukcje z poprzedniej sekcji.

Tworzenie konfiguracji poziomu urządzenia za pomocą interfejsu Google Play Developer API

Pierwsze kroki z interfejsem Google Play Developer API (jeśli nie zostało to jeszcze zrobione)

Aby skonfigurować kierowanie na poziom urządzenia (np. zdefiniować wymagania dla poszczególnych poziomów), musisz przesłać konfigurację do Google Play za pomocą interfejsu Android Publisher API. Więcej informacji o interfejsie API znajdziesz w linku powyżej. Aby zacząć, musisz wykonać kilka czynności:

  1. Utwórz (w razie potrzeby) i połącz projekt interfejsu API z Konsolą Google Play.
  2. Skonfiguruj klienta dostępu do interfejsu API.

Dokumentację API znajdziesz tutaj. Jeśli później zdecydujesz się przesłać wersję za pomocą interfejsu API, użyjesz metod edycji. Przed użyciem interfejsu API zachęcamy też do zapoznania się z tą stroną.

Korzystanie z interfejsu Device Tier Configuration API

Do utworzenia konfiguracji poziomu urządzenia możesz użyć tego wywołania interfejsu API:

Tworzenie konfiguracji poziomu urządzenia

żądanie HTTP, POST https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs
Parametry ścieżki Nie dotyczy
Treść żądania Konfiguracja poziomu urządzenia
Treść odpowiedzi Konfiguracja poziomu urządzenia
Obiekt konfiguracji poziomu urządzenia

Definiowanie poziomów urządzeń składa się z 2 etapów:

  1. Zdefiniuj zbiór grup urządzeń.
  2. Określ zestaw kategorii urządzeń, przypisując poziom do grup urządzeń.

Grupa urządzeń to zestaw urządzeń, które pasują do selektorów zdefiniowanych w konfiguracji.

Selektory mogą określać wymagania dotyczące pamięci RAM i modelu urządzenia.

Grupy są identyfikowane przez wybraną przez Ciebie nazwę. Mogą się one na siebie nakładać.

Następnie możesz zdefiniować zbiór poziomów urządzeń, porządkując grupy: każdy poziom urządzenia jest definiowany przez jego poziom i grupę urządzeń.

Jeśli urządzenie pasuje do kilku poziomów, wyświetlane są treści dla najwyższego pasującego poziomu.

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

Pola:

  • device_confid_id (liczba całkowita): identyfikator odpowiadający tej konfiguracji typu urządzenia.

  • device_groups (obiekt): definicje grup.

    • name (ciąg znaków): nazwa grupy urządzeń (zdefiniowany przez Ciebie ciąg znaków identyfikatora).
    • device_selectors (obiekt): wymagania dotyczące urządzenia, które ma należeć do tej grupy.
    • device_ram (obiekt): wymagania dotyczące pamięci RAM urządzenia.
      • min_bytes (liczba całkowita, włącznie): minimalna wymagana ilość pamięci RAM (w bajtach).
      • max_bytes (liczba całkowita, z wyłączeniem): maksymalna wymagana ilość pamięci RAM (w bajtach)
    • included_device_ids (obiekt): modele urządzeń, które mają być uwzględnione w tym selektorze (maksymalnie 10 000 identyfikatorów urządzenia na grupę). Aby pasować do selektora, urządzenie musi znajdować się na tej liście. Jest to warunek konieczny, ale niewystarczający do dopasowania pełnego selektora (patrz uwaga powyżej na temat łączenia wymagań w selektorze).
      • build_brand (ciąg znaków): producent urządzenia
      • build_device (ciąg znaków): kod modelu urządzenia.
    • excluded_device_ids (obiekt): modele urządzeń, które mają być wykluczone w tym selektorze (maksymalnie 10 000 identyfikatorów urządzenia na grupę). Urządzenie z tej listy nie będzie pasować do selektora, nawet jeśli spełnia wszystkie inne wymagania selektora.
      • build_brand (ciąg znaków): producent urządzenia
      • build_device (ciąg znaków): kod modelu urządzenia.

    • required_system_features (obiekt): funkcje, które urządzenie musi zawierać ten selektor (maksymalnie 100 funkcji na grupę). Urządzenie musi mieć wszystkie funkcje systemowe z tej listy, aby można było dopasować selektor. Jest to warunek niezbędny, ale niewystarczający do dopasowania pełnego selektora (zobacz powyżej uwagę o łączeniu wymagań w selektorze).

      Informacje o funkcjach systemu

      • name (ciąg znaków): funkcja systemowa

    • forbidden_system_features (obiekt): funkcje, których urządzenie nie musi uwzględniać w ramach tego selektora (maksymalnie 100 funkcji na grupę). Jeśli urządzenie ma którąś z funkcji systemu z tej listy, nie kwalifikuje się do selektora, nawet jeśli spełnia wszystkie inne wymagania selektora.

      Informacje o funkcjach systemu

      • name (ciąg znaków): funkcja systemowa.

  • device_tiers (obiekt): definicje poziomów

    • level (int): poziom danego poziomu.
    • nazwa_grupy (tab. ciągów znaków): nazwa grup urządzeń należących do tego poziomu.

Prawidłowe formatowanie kodu producenta i modelu urządzenia możesz znaleźć w katalogu urządzeń w Konsoli Google Play, wykonując jedną z tych czynności:

  • sprawdzenie poszczególnych urządzeń w katalogu urządzeń i znalezienie kodu producenta oraz modelu w lokalizacjach, jak pokazano w przykładzie poniżej (w przypadku telefonu Google Pixel 4a producent to „Google”, a kod modelu to „sunfish”)

    Strona Pixela 4a w katalogu urządzeń

    Strona Pixela 4a w katalogu urządzeń

  • Pobieranie pliku CSV z obsługiwanymi urządzeniami i używanie pól Manufacturer i Model Code odpowiednio do pól build_brand i build_device.

Oto przykładowa konfiguracja z 3 poziomami – poziom 2 korzysta z grupy urządzeń wysoki (która obejmuje wszystkie urządzenia o pojemności powyżej 7 GB i Pixel 4), poziom 1 korzysta z grupy urządzeń średni (która obejmuje wszystkie urządzenia o pojemności od 4 do 7 GB), a poziom 0 jest domyślnie zdefiniowany jako grupa ogólna.

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

Przed przesłaniem konfiguracji kierowania na urządzenia do Google Play możesz ją potwierdzić, postępując zgodnie z instrukcjami podanymi poniżej.

Pobieranie konfiguracji typu urządzenia według identyfikatora

Aby pobrać konkretną konfigurację poziomu urządzenia za pomocą identyfikatora, użyj tego wywołania:

Żądanie HTTP GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs/{deviceTierConfigId}
Parametry ścieżki Nie dotyczy
Treść żądania Nie dotyczy
Treść odpowiedzi Konfiguracja poziomu urządzenia

Pobieranie listy konfiguracji poziomów urządzeń

Aby uzyskać 10 ostatnich konfiguracji poziomów urządzeń, użyj tego wywołania (lub wybierz optymalny zestaw 10 konfiguracji za pomocą parametru zapytania page_token):

Żądanie HTTP GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs
Parametry ścieżki Nie dotyczy
Parametry zapytania page_token (opcjonalnie) – służy do określania konkretnej grupy 10 DTC. Jest to przydatne, jeśli masz utworzonych ponad 10 konfiguracji DTC i chcesz wyświetlić te, które zostały utworzone przed 10 najnowszymi.
Treść żądania Nie dotyczy
Treść odpowiedzi Lista konfiguracji poziomu urządzenia

page_token

Weryfikowanie konfiguracji kierowania na urządzenia

bundletool zawiera 2 polecenia, które przed przesłaniem konfiguracji kierowania na urządzenia do Google Play pozwalają sprawdzić, czy działa ona zgodnie z oczekiwaniami.

Za pomocą bundletool print-device-targeting-config możesz sprawdzić, czy składnia pliku JSON jest prawidłowa, i zwizualizować grupy i poziomy urządzeń w bardziej czytelnym formacie.

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

Dzięki bundletool evaluate-device-targeting-config możesz określić, które grupy i poziomy pasują do konkretnego urządzenia. Możesz albo połączyć urządzenie docelowe z stacją roboczą i użyć flagi --connected-device, albo skompilować plik JSON z właściwościami urządzenia ręcznie i przekazać go za pomocą flagi --device-properties.

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

Plik z właściwościami urządzenia powinien być plikiem JSON zgodnym ze strukturą protokołu protobuf DeviceProperties. Na przykład:

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

Przesyłanie pakietu aplikacji na Androida do Google Play

Za pomocą interfejsu API

Za pomocą interfejsu Google Play Developer API możesz przesłać pakiet aplikacji na Androida do Google Play i powiązać z kompilacją określoną konfigurację kierowania na poziom urządzenia.

Tutaj znajdziesz ogólny przegląd metod edycji, a także szczegółowe przykłady publikowania na różnych ścieżkach w Konsoli Google Play (w przypadku ostatniego linku użyj interfejsów API zgodnych z Androidem AAB, a nie interfejsów API zgodnych z Androidem APK, które są wymienione na tej stronie). Aby określić konfigurację poziomu urządzenia dla kompilacji, dodaj identyfikator konfiguracji do parametru zapytania deviceTierConfigId podczas wywoływania metody edits.bundle.upload w ten sposób:

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

Za pomocą Konsoli Google Play

Aby przesłać pakiet Android App Bundle, postępuj zgodnie z tymi instrukcjami. Do pakietu aplikacji zostanie zastosowana najnowsza konfiguracja DTC.

Aby sprawdzić, czy pakiet został prawidłowo skompilowany, wybierz Eksplorator pakietów aplikacji (po wybraniu właściwej kompilacji) > Delivery (Dostawa) i kliknij każdy pakiet zasobów. Powinien on pokazywać, że masz N poziomów. W tym przykładzie widać, że mam 3 poziomy – 0, 1 i 2 – w przypadku pakietu komponentów main_asset.

pakiet zasobów z 3 poziomami

Sprawdzanie, czy dostarczany jest właściwy poziom

Aby mieć pewność, że na urządzenie jest dostarczana tylko prawidłowa wersja, wykonaj te czynności:

adb shell pm path {packageName}

Strona powinna wyglądać mniej więcej tak:

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

Organizacja pomocnicza

Szybki start z Curl

Poniżej przedstawiamy przykład (za pomocą narzędzia wiersza poleceń curl) tworzenia nowej konfiguracji poziomu urządzenia oraz korzystania z interfejsu API funkcji edycji w celu utworzenia nowej edycji, przesłania nowego pakietu AAB (powiązania go z konkretną konfiguracją poziomu urządzenia), ustawienia konfiguracji utworu/wersji i zaakceptowania edycji. (czyli upublicznia zmiany). Upewnij się, że masz dostęp do tych lokalizacji:

  • klucz odpowiadający klientowi API,
  • Nazwa pakietu Twojej aplikacji

Najpierw utwórz konfigurację poziomu urządzenia i zanotuj deviceTierConfigId, który otrzymasz po udanym wywołaniu.

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

Rozpocznij edycję – otrzymasz identyfikator i czas wygaśnięcia zmiany. Zapisz identyfikator na potrzeby kolejnych połączeń.

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

Prześlij pakiet AAB, podając konfigurację poziomu urządzenia jako parametr zapytania. Jeśli wywołanie się powiedzie, zobaczysz kod wersji, sha1 i sha256 kompilacji. zapisz kod wersji na potrzeby następnego wywołania.

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

Przypisz pakiet AAB do wybranej ścieżki (do testowania zalecamy użycie ścieżki testu wewnętrznego, ale tutaj znajdziesz więcej informacji o różnych ścieżkach). Tutaj przeprowadzimy proste wdrożenie bez informacji o wersji. Więcej informacji o wdrażaniu etapowym i wersjach roboczych znajdziesz na tej stronie. Jeśli po raz pierwszy korzystasz z Publisher API, zalecamy utworzenie wersji roboczej i jej opublikowanie w Konsoli Google Play, aby sprawdzić, czy wszystko jest prawidłowo skonfigurowane.

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}

Zapisz zmiany (działaj ostrożnie, ponieważ wprowadzi to wszystkie zmiany w Google Play na wybranej ścieżce).

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