Ta strona została przetłumaczona przez Cloud Translation API.

Kierowanie na poziom urządzenia

Co to jest kierowanie na poziomie urządzenia?

Kierowanie na poziom urządzeń umożliwia udostępnianie różnych wersji (np. rozdzielczości itp.) tego samego zasobu na poszczególnych urządzeniach w zależności od ich sprzętu. Możesz na przykład przesyłać zasoby w niskiej rozdzielczości na słabsze urządzenia, aby zwiększyć wydajność, oraz przesyłać zasoby w wysokiej rozdzielczości do urządzeń wyższej jakości, aby poprawić jakość grafiki. Nie spowoduje to zwiększenia ogólnego rozmiaru gry, ponieważ będzie przesyłać tylko niezbędne zasoby na urządzenia użytkowników. Ten przykład nawiązuje do koncepcji pakietów zasobów w ramach funkcji Asset Delivery w Google Play. Jak widać poniżej, możesz określić kryteria poszczególnych poziomów (na podstawie pamięci RAM, konkretnych modeli urządzeń lub dostępnych funkcji systemu) i skorzystać z maksymalnie 5 poziomów.

Tak jak w przypadku Play Asset Delivery, kierowanie na poziom urządzenia obsługuje interfejsy API 16 (Jelly Bean 4.1) i nowsze, jednak na urządzeniach z interfejsem API 19 (KitKat 4.4.X) i niższą wersją domyślną jest realizowany niezależnie od kompilacji urządzenia.

Ścieżka programisty

Ogólnie, aby zintegrować funkcję przenoszenia danych z usługą z dotychczasową grą, musisz wykonać te czynności:

Zintegruj ze swoją grą kierowanie na poziomie urządzeń (a także funkcję Play Asset Delivery)
- Zintegruj funkcję Play Asset Delivery ze swoją grą (jeśli jeszcze tego nie zrobiłeś).
- 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.
Utwórz konfigurację kierowania na poziomie urządzeń, aby firma Google Play wiedziała, jak przesyłać zasoby na urządzenia użytkowników.
- Skonfiguruj interfejs Google Play Developer API (jeśli jeszcze nie został skonfigurowany), którego będziesz używać do przesyłania konfiguracji DTT do Google Play.
- Wykonaj kolejne kroki, aby utworzyć konfigurację DTT.
Prześlij pakiet aplikacji na Androida do Play i sprawdź, czy wszystko jest poprawnie skonfigurowane.

W pierwszej sekcji przewodnik będzie zawierać rozwidlenia w zależności od używanego systemu kompilacji. Wybór systemu zależy od używanego wyszukiwarki i bieżącej konfiguracji.

Gradle (zalecana w przypadku gier Java i gier natywnych): w przypadku gier tworzonych za pomocą Gradle wykonaj te czynności, aby skonfigurować system kompilacji pod kątem tworzenia pakietu aplikacji na Androida z obsługą DTT.
- Jeśli wyeksportujesz grę do Gradle, a potem dokończ jej kompilację, zalecamy wykonanie tych instrukcji (np. gry na Unity wyeksportowane do Gradle).
Wtyczka Unity: udostępnimy Ci pakiety jednostkowe do zaimportowania do projektu Unity, co pozwoli Ci skonfigurować i utworzyć pakiet aplikacji z obsługą DTT.

Konfigurowanie kierowania na kategorię urządzeń w aplikacji

integracja Play Asset Delivery z grą (jeśli nie została jeszcze zakończona);

Usługa Play Asset Delivery (PAD) umożliwia dynamiczne przesyłanie zasobów gry w momencie instalacji lub w czasie działania. Tutaj znajdziesz opis tej funkcji. Dzięki kierowaniu na poziom urządzenia Google Play będzie dostarczać pakiety zasobów na podstawie konfiguracji klasy urządzeń określonych przez Ciebie w przypadku różnych poziomów urządzeń. Zalecamy, aby postępować zgodnie z poniższymi wskazówkami i zintegrować PAD z grą (np. utworzyć pakiety zasobów, wdrożyć pobieranie w grze), a potem zmodyfikować kod projektu tak, aby włączyć kierowanie na poziomie urządzenia.

Gradle

W przypadku gier utworzonych za pomocą Gradle wykonaj te instrukcje tworzenia pakietów zasobów za pomocą Gradle, a potem postępuj zgodnie z instrukcjami integracji pobierania pakietów zasobów w Twojej grze:

Java
Reklamy natywne
Gry na Unity eksportowane do Gradle
- Użyj bibliotek Java za pomocą interfejsu JNI (np. biblioteki wbudowanej w Unity).

Jedność

W przypadku gier utworzonych na Unity pakiety zasobów możesz konfigurować za pomocą klasy AssetPackConfig, jak opisano w tych instrukcjach.

Tworzenie katalogów specyficznych dla urządzenia

Jeśli używasz Gradle

Twoje zasoby zostaną podzielone między N warstw (maks. 5), które zdefiniujesz później. Utwórz katalogi DTT, korzystając z istniejących katalogów pakietów zasobów utworzonych w ostatnim kroku i poprawiaj odpowiedni folder (jak opisano poniżej) za pomocą #tier_0, #tier_1, #tier_2 itp. Jeśli używasz w grze pakietów zasobów, nie musisz stosować do folderów postfix (czyli postfix jest automatycznie usuwany podczas kompilacji).

Po poprzednim 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 uzyskasz dostęp do plików w folderze, możesz użyć tej samej ścieżki bez poprawek postów (w tym przykładzie będzie to level1/assets/character-textures/ bez poprawek).

Jeśli używasz Unity

Aby dodać pakiet zasobów korzystający z DTT, możesz użyć 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 dla swojej postaci o różnym poziomie szczegółowości.

Aby zmapować te AssetBundles na odpowiedni typ 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 dla wtyczki Androida do obsługi Gradle i narzędzia bundletool były dostępne poniższe (lub wyższe) wersje:

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

Musisz też zaktualizować Gradle do wersji 6.7.1 lub nowszej. Możesz to zmienić w sekcji gradle/wrapper/gradle-wrapper.properties w projekcie.

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 zaktualizowanie jej do najnowszej wersji, jeśli to możliwe.

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 Android App Bundle (Android App Bundle).

Narzędzie pakietu

Utwórz pakiet za pomocą narzędzia do łączenia i w trakcie dostosowywania pakietu AAB dodaj poniższe polecenie do pliku BundleConfig.pb.

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

Jedność

Gdy skonfigurujesz AssetPackConfig tak, aby zawierał pakiety DTT, możesz przekazać tę konfigurację do jednej z poniższych metod, aby utworzyć pakiet 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)

Testowanie lokalne

Zanim przejdziesz dalej, zalecamy przetestowanie pakietu aplikacji lokalnie i upewnienie się, że wszystko jest prawidłowo skonfigurowane. Za pomocą bundletool (w wersji 1.8.0 lub nowszej) możesz kompilować i testować aplikację lokalnie, wyraźnie wskazując właściwy typ urządzenia. Najpierw za pomocą build-apks wygenerujesz zestaw plików .apks, a następnie wdrożysz aplikację na połączonym urządzeniu za pomocą install-apks. Poziom, który chcesz zainstalować, możesz też określić za pomocą flagi poziomu urządzenia. Więcej informacji o tej metodzie testowania lokalnego znajdziesz tutaj (pamiętaj, że ta strona nie została jeszcze zaktualizowana pod kątem przesyłania danych przez przenoszenie danych, więc brakuje w 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

Opcjonalnie: możesz też użyć extract-apks, aby wyodrębnić zestaw plików APK dla konkretnego urządzenia. Jednak użycie parametru get-device-spec wraz z określaniem poziomu urządzenia nie będzie działać w połączeniu z flagą --local-testing, co oznacza, że nie będzie można testować pakietów zasobów Szybkich śledzenia ani pakietów zasobów 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

Jedność

Opcja menu Google -> Skompiluj i uruchom pozwala skompilować i uruchomić grę z włączoną flagą --local-testing. Nie można jednak określić poziomu urządzenia przekazywanego w poleceniu install-apks.

Jeśli chcesz określić poziom urządzenia inny niż 0:

Utwórz pakiet aplikacji na Androida, korzystając z opcji menu Google -> Utwórz pakiet Android App Bundle.
Wykonaj instrukcje z poprzedniej sekcji, aby uruchomić bundletool, build-apks i install-apks w utworzonym pakiecie aplikacji na Androida.

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

Pierwsze kroki z interfejsem Google Play Developer API (jeśli jeszcze nie masz ukończonego kursu)

Aby skonfigurować kierowanie na poziomie urządzenia (np. określić 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, klikając powyższy link. Jest kilka kroków, które musisz wykonać, aby rozpocząć:

Dokumentacja API znajdziesz tutaj. Jeśli zdecydujesz się później przesłać kompilację przez interfejs API, będziesz używać metod edycji. Zachęcamy również do zapoznania się z tą stroną przed użyciem interfejsu API.

Korzystanie z interfejsu Device Tier Configuration API

Aby utworzyć konfigurację klasy urządzenia, możesz użyć tego wywołania interfejsu API:

Tworzenie konfiguracji typu urządzenia

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

Obiekt konfiguracji typu urządzenia

Definicja poziomów urządzeń obejmuje 2 kroki:

Zdefiniuj zbiór grup urządzeń.
Określ typ urządzeń, przypisując do grup urządzeń poziom.

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

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

Grupy są identyfikowane przez wybraną przez Ciebie nazwę. Grupy mogą się nakładać.

Następnie możesz określić zestaw urządzeń, tworząc ich ranking. Każdy poziom urządzeń jest określany przez swój poziom i grupę urządzeń.

Jeśli urządzenie pasuje do kilku poziomów, w treściach będą wyświetlane treści z tego poziomu o najwyższym dopasowaniu.

  {
    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 konfiguracji tego typu urządzenia.
device_groups (obiekt): definicje grup
- name (ciąg znaków): nazwa grupy urządzeń (określony przez Ciebie ciąg znaków).
- device_selectors (obiekt): wymagania dotyczące urządzenia, które ma zostać przypisane 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, wyłącznie): 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ądzeń na grupę) Aby można było dopasować selektor, urządzenie musi się znajdować na tej liście. Jest to wymagany, ale niewystarczający warunek, aby można było dopasować pełny selektor (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ą zostać wykluczone z tego selektora (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 pozostałe wymagania.
  - 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 uwzględnić w tym selektorze (maksymalnie 100 funkcji na grupę). Aby można było dopasować selektor, na urządzeniu muszą być wszystkie funkcje systemowe z tej listy. Jest to warunek konieczny, ale niewystarczający, aby można było dopasować pełny selektor (patrz uwaga powyżej na temat łączenia wymagań w selektorze).
  
  Odniesienie do funkcji systemowych
  - name (ciąg znaków): funkcja systemowa
- forbidden_system_features (obiekt): funkcje, których urządzenie nie może zawierać w tym selektorze (maksymalnie 100 funkcji na grupę). Jeśli urządzenie ma którąś z funkcji systemowych z tej listy, nie pasuje do selektora, nawet jeśli spełnia wszystkie pozostałe wymagania.
  
  Odniesienie do funkcji systemowych
  - name (ciąg znaków): funkcja systemowa
device_tiers (obiekt): definicje poziomów
- level (int): poziom poziomu;
- group_name (tablica ciągów znaków): nazwa grup urządzeń należących do tego poziomu

Uwaga:

W grupie można określić wiele selektorów urządzeń. Urządzenie należy do grupy, jeśli pasuje do co najmniej 1 selektora grupy (logiczne LUB).
Urządzenie może należeć do kilku grup.
Selektor może określać warunki dotyczące pamięci RAM, uwzględniania i wykluczania modelu urządzenia oraz wymaganych/zabronionych funkcji systemowych. Jeśli selektor określa kilka warunków, urządzenie pasuje do niego, jeśli spełnia wszystkie swoje warunki (logiczne ORAZ).

Ostrzeżenie: uwzględnienie wielu reguł w tym samym selektorze spowoduje utworzenie logicznego operatora I, np.:

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

utworzy warunek dla wszystkich urządzeń z więcej niż 7 GB pamięci RAM ORAZ telefon Pixel 4, również w ten sposób:

Jeśli potrzebujesz warunku LUB, pogrupuj je jako osobne selektory, np.:

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

utworzy warunek dla wszystkich urządzeń z więcej niż 7 GB pamięci RAM LUB Pixel 4 – również w ten sposób:

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

Sprawdzanie poszczególnych urządzeń za pomocą katalogu urządzeń i znajdowanie w nich producenta i kodu modelu, tak jak to widać w przykładzie poniżej (w przypadku telefonu Google Pixel 4a producentem jest „Google”, a kod modelu to „sunfish”)”.
Pobierając plik CSV z obsługiwanymi urządzeniami i używając Manufacturer oraz Model Code w polach build_brand i build_device.

Oto przykładowa konfiguracja z 3 poziomami. Poziom 2 wykorzystuje grupę urządzeń wysoka (która obejmuje wszystkie urządzenia powyżej 7 GB i Pixel 4), poziom 1 korzysta z grupy urządzeń medium (która obejmuje wszystkie urządzenia o rozmiarze od 4 do 7 GB) oraz poziomu 0, który jest domyślnie zdefiniowana jako grupa typu catch-all.

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

Zanim prześlesz ją do Google Play, możesz zweryfikować konfigurację kierowania na urządzenia, postępując zgodnie z podanymi niżej instrukcjami.

Pobieranie konfiguracji typu urządzenia według identyfikatora

Konfigurację rodzaju urządzenia możesz pobrać, korzystając z 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 typu urządzenia

Pobieranie listy konfiguracji poziomu urządzenia

Dziesięć ostatnich konfiguracji poziomu urządzenia możesz uzyskać, korzystając z następującego wywołania (lub optymalnie określić zbiór dziesięciu 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 (opcjonalny) – służy do określenia określonej grupy 10 kodów DTC. Jest to przydatne, jeśli masz utworzonych więcej niż 10 modyfikatorów bezpośrednich i chcesz zobaczyć te ostatnie sprzed 10 ostatnich.
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 pomogą Ci sprawdzić, czy konfiguracja kierowania na urządzenie działa prawidłowo, zanim prześlesz ją do Google Play.

Dzięki bundletool print-device-targeting-config możesz sprawdzać, czy składnia pliku JSON jest poprawna, oraz wizualizować grupy i warstwy urządzeń w bardziej czytelnym formacie.

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

Dzięki bundletool evaluate-device-targeting-config możesz ocenić, które grupy i poziomy pasują do danego urządzenia. Podłącz urządzenie docelowe do stacji roboczej i użyj flagi --connected-device lub ręcznie skompilujesz plik JSON z właściwościami urządzenia i przekaż 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 właściwości urządzenia powinien być plikiem JSON zgodnym ze strukturą protokołu DeviceWłaściwości. 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 Android App Bundle do Google Play

Przez interfejs API

Za pomocą interfejsu Google Play Developer API możesz przesłać pakiet Android App Bundle do Google Play i połączyć z kompilacją konkretną konfigurację kierowania na poziomie urządzenia.

Tutaj znajdziesz ogólny przegląd metod edycji i dokładniejsze przykłady publikowania na różnych ścieżkach w Konsoli Google Play (w ostatnim linku zalecamy użycie interfejsów API zgodnych z AAB zamiast interfejsów API zgodnych z APK, które są wymienione na stronie). Aby określić konfigurację poziomu urządzenia dla swojej kompilacji, podczas wywoływania metody edits.bundle.upload dodaj identyfikator konfiguracji do parametru zapytania deviceTierConfigId:

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

W 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 utworzony, otwórz Eksplorator pakietów aplikacji (z wybraną prawidłową kompilacją) > Dostawa i kliknij każdy pakiet zasobów. Powinna wyświetlić się informacja, że masz utworzone poziomy N. Ten przykład pokazuje, że w moim pakiecie zasobów main_asset są 3 poziomy – 0, 1 i 2.

3-poziomowy pakiet zasobów

Sprawdzamy prawidłowy poziom

Użyj tej metody, aby mieć pewność, że do urządzenia jest dostarczany tylko właściwy poziom

adb shell pm path {packageName}

Zobaczysz coś takiego:

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

Pomoc

Szybkie wprowadzenie do Curl

Poniżej znajdziesz przykład (za pomocą narzędzia wiersza poleceń curl) tworzenia nowej konfiguracji poziomu urządzenia oraz tworzenia nowej zmiany za pomocą interfejsu Edits API, przesyłania nowego pakietu aplikacji na Androida (powiązania go z konkretną konfiguracją typu urządzenia), ustawiania konfiguracji ścieżki/wersji i zatwierdzenia zmiany. W ten sposób opublikujesz informacje o zmianie. Musisz mieć:

Klucz odpowiadający Twojemu klientowi interfejsu API.
nazwę pakietu aplikacji;

Najpierw utwórz konfigurację klasy urządzenia i zanotuj deviceTierConfigId, które 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 modyfikacji. Zapisz identyfikator dla kolejnych wywołań.

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

Prześlij pakiet aplikacji na Androida, określając konfigurację poziomu urządzenia jako parametr zapytania. Jeśli wywołanie zakończy się powodzeniem, zobaczysz kod wersji, sha1 i sha256 kompilacji. Zapisz kod wersji do 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 aplikacji do odpowiedniej ścieżki (do testowania zalecamy użycie ścieżki testu wewnętrznego, ale tutaj znajdziesz więcej informacji o różnych ścieżkach). Tutaj przeprowadzamy proste wdrożenie bez informacji o wersji. Na tej stronie znajdziesz więcej informacji o wdrażaniu etapowym, wersjach roboczych i informacjach o wersji. Jeśli po raz pierwszy korzystasz z interfejsu Publisher API, zalecamy utworzenie go w wersji roboczej i dokończenie aktualizacji w Konsoli Google Play, aby mieć pewność, że wszystko jest skonfigurowane prawidłowo.

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}

Zatwierdź zmiany (działaj ostrożnie, ponieważ spowoduje to opublikowanie wszystkich zmian w Google Play na odpowiedniej ścieżce).

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