Questa pagina è stata tradotta dall'API Cloud Translation.

Targeting a livello di dispositivo

Che cos'è il targeting a livello di dispositivo?

Il targeting a livello di dispositivo consente di pubblicare sui dispositivi versioni diverse (ad es. risoluzioni e così via) dello stesso asset in base all'hardware. Ad esempio, puoi scegliere di pubblicare asset a bassa risoluzione su dispositivi di fascia inferiore per migliorare le prestazioni e di fornire asset ad alta risoluzione a dispositivi di fascia alta per migliorare la qualità grafica, il tutto senza aumentare le dimensioni complessive del gioco fornendo solo gli asset necessari ai dispositivi degli utenti. Questa funzionalità si basa sul concetto di pacchetti di asset in Asset Delivery di Play. Come vedrai di seguito, puoi definire i criteri dei livelli (per ora in base alla RAM, ai modelli di dispositivi specifici o alle funzionalità di sistema disponibili) e puoi utilizzare fino a 5 livelli.

Come Play Asset Delivery, il targeting a livello di dispositivo supporta l'API 16 (Jelly Bean 4.1) e versioni successive, tuttavia sui dispositivi con API 19 (Lollipop 4.4.X) e versioni precedenti viene fornito il livello predefinito indipendentemente dalla build del dispositivo.

Percorso dello sviluppatore

A livello generale, per integrare DTT nel tuo gioco esistente, dovrai seguire questi passaggi:

Integra il targeting a livello di dispositivo (e, per estensione, Play Asset Delivery) nel tuo gioco
- Integra Play Asset Delivery nel tuo gioco (se non l'hai già fatto)
- Dividi gli asset in pacchetti di asset.
- Combina il codice e gli asset per l'artefatto finale Android App Bundle che caricherai su Google Play.
Crea la configurazione di targeting a livello di dispositivo in modo che Play sappia come inviare gli asset ai dispositivi degli utenti.
- Imposta l'API Google Play Developer (se non l'hai già completata), che è quella che utilizzerai per inviare le configurazioni DTT a Play.
- Segui i passaggi per creare la configurazione DTT.
Carica l'AAB su Play ed esegui il test per assicurarti che tutto sia configurato correttamente

Nella prima sezione noterai che la guida contiene dei fork, a seconda del sistema di build utilizzato. Il sistema che scegli dipende dal motore che usi e dalla configurazione esistente.

Gradle (consigliato per giochi Java e nativi): per i giochi creati utilizzando Gradle, segui questi passaggi per configurare il sistema di build in modo da creare il tuo AAB con supporto DTT.
- Se esporti il gioco in Gradle e poi completi la build lì, ti consigliamo di seguire queste istruzioni (ad esempio giochi Unity esportati in Gradle))
Plug-in Unity: ti forniremo pacchetti unity da importare nel tuo progetto Unity, così potrai configurare e creare il tuo AAB con supporto DTT.

Configurare il targeting a livello di dispositivo all'interno dell'app

Integrazione di Play Asset Delivery nel tuo gioco (se non l'hai già completata)

Play Asset Delivery (PAD) ti consente di caricare dinamicamente le risorse del tuo gioco al momento dell'installazione o di runtime. Puoi leggere una panoramica in merito qui. Con il targeting a livello di dispositivo, Google Play pubblicherà pacchetti di asset in base alle configurazioni a livello di dispositivo prescritte per i diversi livelli di dispositivi. Ti consigliamo di seguire le indicazioni riportate di seguito e di integrare PAD nel tuo gioco (ovvero creare pacchetti di asset, implementare il recupero nel gioco) e poi modificare il codice del progetto per abilitare il targeting a livello di dispositivo.

Gradle

Per i giochi creati con Gradle, segui queste istruzioni per creare pacchetti di asset con Gradle, quindi segui le istruzioni per integrare il recupero dei pacchetti di asset nel tuo gioco:

Java
Nativo
Giochi Unity esportati in Gradle
- Utilizza le librerie Java tramite JNI (ad esempio quella integrata in Unity).

Unity

Per i giochi creati in Unity, configurerai i pacchetti di asset utilizzando la classe AssetPackConfig, come descritto in queste istruzioni.

Creazione di directory specifiche per i livelli di dispositivi

Se utilizzi Gradle

Ora suddividerai gli asset tra N livelli (massimo 5) che definirai in seguito. Crea le directory DTT seguendo le directory dei bundle di asset esistenti create nell'ultimo passaggio e poi correggendo la cartella appropriata (come descritto di seguito) con #tier_0, #tier_1, #tier_2 e così via. Se utilizzi i pacchetti di asset nel tuo gioco, non dovrai gestire le cartelle in base a Postfix (in altre parole, il postfix viene rimosso automaticamente durante il processo di creazione).

Dopo il passaggio precedente, l'output potrebbe avere il seguente aspetto:

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

Quando accedi ai file all'interno della cartella, puoi utilizzare lo stesso percorso senza correzione dei post (in questo esempio farò riferimento a level1/assets/character-textures/ senza alcuna correzione).

Se utilizzi Unity

Per aggiungere un pacchetto di asset che utilizzi DTT, puoi usare i seguenti AssetPackConfig metodi:

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

Ad esempio, supponiamo che tu abbia tre AssetBundles per il tuo personaggio a vari livelli di dettaglio.

Per mappare questi AssetBundles al livello di dispositivo corrispondente, utilizza lo snippet seguente.

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

Creazione di Android App Bundle

Gradle

Nel file build.gradle del tuo progetto, configura le dipendenze in modo che abbiano le versioni seguenti (o successive) per il plug-in Android Gradle e bundletool:

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

Dovrai anche aggiornare la versione gradle alla 6.7.1 o successive. Puoi aggiornare questa impostazione in gradle/wrapper/gradle-wrapper.properties all'interno del tuo progetto.

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

Infine, dovrai utilizzare Play Asset Delivery Library; se usi ancora la libreria monolitica Play Core Library, aggiornala alla versione 1.8.3 o successiva. Ti consigliamo di passare alla raccolta Asset Delivery di Google Play e di eseguire l'aggiornamento alla versione più recente, se possibile.

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

Nel file build.gradle del modulo dell'app principale, abilita la suddivisione DTT:

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

Infine, puoi creare il tuo Android App Bundle (AAB).

Strumento bundle

Crea il tuo bundle con bundletool e durante il passaggio per personalizzare l'AAB, aggiungi quanto segue al file BundleConfig.pb.

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

Unity

Dopo aver configurato AssetPackConfig per includere i pacchetti DTT, puoi passare la configurazione in uno dei seguenti metodi per creare il tuo 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)

Test locali

Prima di continuare, ti consigliamo di testare a livello locale l'app bundle per assicurarti che sia tutto configurato correttamente. Utilizzando bundletool (1.8.0 o versioni successive), puoi creare e testare la tua app a livello locale, specificando esplicitamente il livello di dispositivo corretto. Innanzitutto, utilizzerai build-apks per generare un insieme di file .apks, quindi esegui il deployment della tua app su un dispositivo connesso utilizzando install-apks. Puoi anche specificare il livello che vuoi installare tramite il flag del livello di dispositivo. Puoi trovare maggiori informazioni su questo metodo di test locale qui (tieni presente che questa pagina non è stata ancora aggiornata per DTT e non include il flag 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

In alternativa: puoi utilizzare anche extract-apks per estrarre un insieme di APK per un dispositivo specifico. Tuttavia, l'utilizzo di get-device-spec insieme alla specifica del livello di dispositivo per questo dispositivo non funzionerà in combinazione con il flag --local-testing, quindi non potrai testare i pacchetti di asset fast-follow o on demand.

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

L'opzione di menu Google -> Crea ed esegui consente di creare ed eseguire il tuo gioco con il flag --local-testing abilitato. Tuttavia, non consente di specificare il livello di dispositivo passato nel comando install-apks.

Se vuoi specificare un livello di dispositivo diverso da 0:

Crea l'AAB utilizzando l'opzione di menu Google -> Crea Android App Bundle.
Segui le istruzioni nella sezione precedente per eseguire bundletool, build-apks e install-apks sull'AAB creato.

Creazione di una configurazione a livello di dispositivo tramite l'API Google Play Developer

Iniziare a utilizzare l'API Google Play Developer (se non l'hai già fatto)

Per configurare il targeting a livello di dispositivo (ad es. definire i requisiti per ogni livello) dovrai utilizzare l'API Android Publisher per caricare la configurazione su Google Play. Per scoprire di più sull'API, visita il link riportato sopra: ecco alcuni passaggi da seguire per iniziare:

Puoi trovare il riferimento API qui. In seguito, se scegli di caricare la build tramite l'API, utilizzerai i metodi di modifica. Inoltre, ti consigliamo di esaminare questa pagina prima di utilizzare l'API.

Utilizzo dell'API Device Tier Configuration

Per creare la configurazione del livello di dispositivo, puoi utilizzare la seguente chiamata API:

Crea configurazione livello dispositivo

Richiesta HTTP	`POST https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs`
Parametri percorso	N/A
Corpo della richiesta	Configurazione a livello di dispositivo
Corpo della risposta	Configurazione a livello di dispositivo

Oggetto di configurazione livello dispositivo

La definizione dei livelli di dispositivi comprende due passaggi:

Definisci un insieme di gruppi di dispositivi.
Definisci il tuo insieme di livelli di dispositivi assegnando un livello ai gruppi di dispositivi.

Un gruppo di dispositivi è un insieme di dispositivi che corrisponde ai selettori che hai definito nella configurazione.

I selettori possono definire i requisiti relativi alla RAM e al modello del dispositivo.

I gruppi vengono identificati da un nome a tua scelta; i gruppi possono sovrapporsi.

Successivamente, puoi definire il set di livelli di dispositivi classificando i gruppi: ogni livello di dispositivo è definito dal proprio livello e da un gruppo di dispositivi.

Se un dispositivo corrisponde a più livelli, verranno pubblicati i contenuti per il livello corrispondente più alto.

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

Campi:

device_confid_id (numero intero): ID corrispondente a questa configurazione a livello di dispositivo.
device_groups (oggetto): definizioni di gruppi
- name (stringa): nome del gruppo di dispositivi (un ID stringa definito da te).
- device_selectors (oggetto): requisiti del dispositivo affinché un dispositivo appartenga a questo gruppo.
- device_ram (oggetto): requisiti di RAM del dispositivo
  - min_bytes (numero intero, inclusivo): RAM minima richiesta (in byte)
  - max_bytes (numero intero, esclusivo): numero massimo di RAM richiesta (in byte)
- included_device_ids (oggetto): i modelli di dispositivi da includere in questo selettore (massimo 10.000 device_id per gruppo). Un dispositivo deve essere in questo elenco per corrispondere al selettore. Questa è una condizione necessaria, ma non sufficiente, per corrispondere al selettore completo (vedi la nota sopra sulla combinazione dei requisiti in un selettore).
  - build_brand (stringa). Produttore del dispositivo
  - build_device (stringa). Il codice del modello del dispositivo.
- excluded_device_ids (oggetto): i modelli di dispositivi da escludere in questo selettore (massimo 10000 device_id per gruppo). Un dispositivo di questo elenco non corrisponderà al selettore, anche se soddisfa tutti gli altri requisiti del selettore.
  - build_brand (stringa). Produttore del dispositivo
  - build_device (stringa). Il codice del modello del dispositivo.
- required_system_features (oggetto): le funzionalità che un dispositivo deve essere incluso nel selettore (massimo 100 funzionalità per gruppo). Un dispositivo deve avere tutte le funzionalità di sistema in questo elenco per corrispondere al selettore. Questa è una condizione necessaria, ma non sufficiente, per corrispondere al selettore completo (vedi la nota sopra sulla combinazione dei requisiti in un selettore).
  
  Riferimento alle funzionalità di sistema
  - name (stringa): una funzionalità del sistema
- forbidden_system_features (oggetto): funzionalità che un dispositivo non deve essere incluso nel selettore (massimo 100 funzionalità per gruppo). Se un dispositivo include una qualsiasi delle funzionalità di sistema presenti in questo elenco, non corrisponde al selettore, anche se soddisfa tutti gli altri requisiti del selettore.
  
  Riferimento alle funzionalità di sistema
  - name (stringa): una funzionalità del sistema
device_tiers (oggetto): definizioni dei livelli
- level (int): il livello del livello
- group_name (array di stringhe): il nome dei gruppi di dispositivi che appartengono a questo livello

Nota:

Un gruppo può specificare più selettori di dispositivi. Un dispositivo appartiene al gruppo se corrisponde ad almeno un selettore di gruppo (OR logico).
Un dispositivo può appartenere a più gruppi.
Un selettore può specificare condizioni relative a RAM, inclusione ed esclusione del modello di dispositivo e funzionalità di sistema richieste/vietate. Se un selettore specifica più condizioni, un dispositivo corrisponde al selettore se soddisfa tutte le sue condizioni (AND logico).

Avviso: l'inclusione di più regole nello stesso selettore creerà un AND logico, ad esempio:

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

crea la condizione per tutti i dispositivi con più di 7 GB di RAM SE si tratta di un Pixel 4, inoltre è scritto come segue:

Altrimenti, se vuoi una condizione OR, raggruppali come selettori separati, ad esempio:

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

crea la condizione per tutti i dispositivi con più di 7 GB di RAM OPPURE si tratta di un Pixel 4 - è scritto anche come segue:

Puoi trovare la formattazione corretta per il produttore e il codice del dispositivo utilizzando il Catalogo dei dispositivi su Google Play Console in uno dei seguenti modi:

Ispezione di singoli dispositivi utilizzando il catalogo dei dispositivi e individuazione del produttore e del codice del modello nelle posizioni come mostrato nell'esempio riportato di seguito (per Google Pixel 4a, il produttore è "Google" e il codice modello è "sunfish").
Scaricando un file CSV dei dispositivi supportati e utilizzando i campi Manufacturer e Model Code rispettivamente per i campi build_brand e build_device.

Ecco un esempio di configurazione con 3 livelli: il livello 2 utilizza il gruppo di dispositivi high (che include tutti i dispositivi con dimensioni superiori a 7 GB e Pixel 4), il livello 1 utilizza il gruppo di dispositivi medium (che include tutti i dispositivi con una dimensione compresa tra 4 e 7 GB) e il livello 0, che è implicitamente definito come gruppo 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'
        ]
      }
    ]
  }
}

Segui le istruzioni riportate di seguito per convalidare la configurazione del targeting per dispositivo prima di caricarlo su Google Play.

Recupero configurazione livello dispositivo per ID

Puoi recuperare una configurazione specifica di livelli di dispositivo in base all'ID utilizzando la seguente chiamata:

Richiesta HTTP	`GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs/{deviceTierConfigId}`
Parametri percorso	N/A
Corpo della richiesta	N/A
Corpo della risposta	Configurazione a livello di dispositivo

Recupera elenco di configurazioni a livello di dispositivo

Puoi ottenere le ultime 10 configurazioni di livelli di dispositivi con la seguente chiamata (o specificare in modo ottimale un set di dieci utilizzando il parametro di query page_token):

Richiesta HTTP	`GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs`
Parametri percorso	N/A
Parametri di ricerca	page_token (facoltativo): utilizzato per specificare un gruppo specifico di 10 DTC. Ciò è utile se hai creato più di 10 DTC e vuoi visualizzare quelle create prima delle ultime 10.
Corpo della richiesta	N/A
Corpo della risposta	Elenco di configurazioni a livello di dispositivo token_pagina

Convalida della configurazione del targeting per dispositivo

bundletool include due comandi che ti consentono di verificare che la configurazione del targeting per dispositivo funzioni come previsto prima di caricarla su Google Play.

Con bundletool print-device-targeting-config, puoi verificare che la sintassi del file JSON sia corretta e visualizzare i gruppi di dispositivi e i livelli in un formato più leggibile.

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

Con bundletool evaluate-device-targeting-config puoi valutare i gruppi e il livello corrispondenti a un dispositivo specifico. Puoi connettere il dispositivo di destinazione alla workstation e utilizzare il flag --connected-device oppure compilare manualmente un file JSON con le proprietà del dispositivo e fornirlo tramite il flag --device-properties.

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

Il file delle proprietà del dispositivo deve essere un file JSON che segue la struttura protobuf DeviceProperties. Ecco alcuni esempi:

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

Caricare Android App Bundle su Google Play

Tramite API

Puoi utilizzare l'API Google Play Developer per caricare l'Android App Bundle su Google Play e collegare una specifica configurazione di targeting a livello di dispositivo alla tua build.

Qui puoi trovare una panoramica generale dei metodi di modifica, oltre ad esempi più approfonditi sul rilascio nei diversi canali in Google Play Console (per l'ultimo link, ti consigliamo di utilizzare le API compatibili con AAB anziché l'API compatibile con l'APK, elencata nella pagina). Per specificare la configurazione a livello di dispositivo per la build, dovrai aggiungere l'ID configurazione al parametro di query deviceTierConfigId durante la chiamata al metodo edits.bundle.upload, in questo modo:

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

Tramite Google Play Console

Puoi seguire queste istruzioni per caricare il tuo Android App Bundle. All'app bundle verrà applicata l'ultima configurazione DTC.

Per verificare che il bundle sia stato creato correttamente, vai a Explorer per app bundle (con la build corretta selezionata) > Pubblicazione e fai clic su ogni pacchetto di asset. Dovresti visualizzare N livelli che hai creato. In questo esempio, mostra che sono presenti tre livelli: 0, 1 e 2 per il pacchetto di asset main_asset.

pacchetto di asset con tre livelli

Verifica dell'invio del livello corretto in corso...

Utilizza il metodo seguente per assicurarti che al dispositivo venga fornito solo il livello corretto

adb shell pm path {packageName}

Il risultato dovrebbe essere simile a questo:

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

Ausiliario

Guida rapida all'utilizzo di Curl

Di seguito è riportato un esempio (mediante lo strumento a riga di comando curl) di creazione di una nuova configurazione a livello di dispositivo e l'utilizzo dell'API Edits per creare una nuova modifica, caricare un nuovo AAB (associandolo a una configurazione specifica a livello di dispositivo), impostare la configurazione canale/release ed eseguire il commit della modifica. (di conseguenza rendendo pubblica la modifica). Assicurati di avere la posizione di:

La chiave corrispondente al tuo client API
Il nome del pacchetto della tua app

Per prima cosa, crea una configurazione a livello di dispositivo e prendi nota di deviceTierConfigId che riceverai se la chiamata andrà a buon fine.

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

Avvia una modifica: riceverai un ID e una data di scadenza della modifica. Salva l'ID per le chiamate seguenti.

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

Carica l'AAB, specificando la configurazione del livello di dispositivo come parametro di query. Se la chiamata ha esito positivo, vedrai i codici versione, sha1 e sha256 della build. Salva il codice di versione per la chiamata successiva.

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

Assegna l'AAB al canale desiderato (per i test, è consigliabile utilizzare il canale di test interno, ma puoi scoprire di più sui diversi canali qui), qui faremo una semplice implementazione senza note di rilascio, ma puoi leggi questa pagina per scoprire di più su come implementazioni graduali, bozze e note di rilascio. Se è la prima volta che utilizzi l'API Publisher, ti consigliamo di crearla come bozza e di completarla su Google Play Console per assicurarti che tutto sia stato configurato correttamente.

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}

Esegui il commit delle modifiche (procedi con cautela, poiché tutte le modifiche verranno pubblicate su Google Play per la traccia desiderata)

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