Segmentación por nivel de dispositivo

¿Qué es la segmentación por nivel de dispositivo?

La segmentación por nivel de dispositivo (DTT, por su sigla en inglés) te permite publicar diferentes versiones (p. ej., resoluciones, etc.) del mismo recurso en dispositivos según su hardware. Por ejemplo, puedes optar por publicar recursos de baja resolución para dispositivos de gama inferior a fin de mejorar el rendimiento y proporcionar otros de alta resolución a dispositivos de alta gama para mejorar la calidad gráfica, sin incurrir en ningún aumento de tamaño del juego en general, si solo proporcionas los recursos necesarios a los dispositivos de los usuarios. Esto se basa en el concepto de paquetes de recursos de Asset Delivery en Play. Como verás a continuación, puedes definir los criterios de nivel (por ahora, basados en la RAM, los modelos de dispositivo específicos o las funciones disponibles del sistema) y usar hasta 5 niveles.

Al igual que Play Asset Delivery, la segmentación por nivel de dispositivo admite el nivel de API 16 (Jelly Bean 4.1) y versiones posteriores. Sin embargo, en dispositivos con nivel de API 19 (KitKat 4.4.X) y versiones anteriores, se entrega el nivel predeterminado independientemente de la compilación del dispositivo.

Exploración del desarrollador

En términos generales, para integrar la DTT en un juego existente, deberás seguir estos pasos:

1. Integra la segmentación por nivel de dispositivo (y, por extensión, Play Asset Delivery) en tu juego.
   • Integra Play Asset Delivery en tu juego (si aún no lo hiciste).
   • Divide los recursos en paquetes de recursos.
   • Empaqueta los recursos y el código juntos para obtener el artefacto final de Android App Bundle que subirás a Play.
2. Crea la configuración de segmentación por nivel de dispositivo de modo que Play sepa cómo entregar tus recursos a los dispositivos de los usuarios.
   • Configura la API de Google Play Developer (si aún no lo hiciste), que es lo que usarás para enviar la configuración de la DTT a Play.
   • Sigue los pasos para crear la configuración de la DTT.
3. Sube tu AAB a Play y realiza pruebas para asegurarte de que todo esté configurado correctamente.

Verás que en la primera sección habrá bifurcaciones en la guía según el sistema de compilación que uses. Este sistema dependerá del motor que uses y de tu configuración existente.

• Gradle (recomendado para Java y juegos nativos): En los juegos compilados con Gradle, sigue estos pasos a fin de configurar el sistema de compilación de modo que compile tu AAB compatible con la DTT.
  • Si exportas tu juego a Gradle y, luego, terminas tu compilación allí, te recomendamos que sigas estas instrucciones (p. ej., juegos de Unity exportados a Gradle).
• Complemento de Unity: Te proporcionaremos paquetes para importar a tu proyecto de Unity, lo que te permitirá configurar y compilar tu AAB compatible con la DTT.

Cómo configurar la segmentación por nivel de dispositivo en tu app

Cómo integrar Play Asset Delivery en tu juego (si aún no lo hiciste)

Play Asset Delivery (PAD) te permite enviar de manera dinámica los recursos de tu juego al momento de la instalación o durante el tiempo de ejecución. Puedes leer una descripción general sobre este proceso aquí. Con la segmentación por nivel de dispositivo, Play entregará paquetes de recursos según las configuraciones que indiques de nivel de los dispositivos para diferentes niveles. Te recomendamos que sigas las instrucciones que se indican a continuación y que integres PAD en tu juego (es decir, que crees paquetes de recursos e implementes la recuperación en tu juego) y, luego, que modifiques el código del proyecto para habilitar la segmentación por nivel de dispositivo.

Gradle

En el caso de los juegos compilados con Gradle, usa estas instrucciones para compilar paquetes de recursos con Gradle y, luego, sigue las instrucciones para integrar la recuperación de paquetes de recursos en tu juego:

• Java
• Nativo
• Juegos de Unity exportados a Gradle
  • Usa las bibliotecas de Java a través de la JNI (como la que está integrada en Unity).

Unity

En los juegos compilados en Unity, configurarás los paquetes de recursos mediante la clase AssetPackConfig, como se describe en estas instrucciones.

Cómo crear directorios específicos para cada nivel de dispositivo

Si usas Gradle

Ahora dividirás los elementos entre los N niveles (5 como máximo) que definirás más adelante. Crea tus directorios de la DTT. Para ello, toma los directorios de paquetes de recursos existentes que creaste en el último paso y aplica los sufijos de la carpeta adecuada (como se describe a continuación) con #tier_0, #tier_1, #tier_2, etc. Cuando uses los paquetes de recursos en tu juego, no tendrás que nombrar las carpetas por el sufijo (en otras palabras, el sufijo se quita automáticamente durante el proceso de compilación).

Después del paso anterior, podría verse así:

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

Cuando accedes a los archivos de la carpeta, puedes usar la misma ruta de acceso sin los sufijos (en este ejemplo, nos referiríamos a level1/assets/character-textures/ sin sufijos).

Si usas Unity:

Para agregar un paquete de recursos que usa la DTT, puedes utilizar los siguientes métodos de 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)

Por ejemplo, supongamos que tienes tres AssetBundles para un personaje en diferentes grados de detalle.

Para asignar esos AssetBundles a su nivel de dispositivo correspondiente, usa el siguiente fragmento.

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

Cómo compilar el Android App Bundle

Gradle

En el archivo build.gradle del proyecto, configura las dependencias de modo que tengan las siguientes versiones (o alguna posterior) del complemento de Android para Gradle y bundletool:

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

También deberás actualizar tu versión de Gradle a 6.7.1 o una posterior. Puedes actualizar esto en gradle/wrapper/gradle-wrapper.properties dentro de tu proyecto.

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

Por último, deberás usar la Biblioteca de Play Asset Delivery. Si todavía usas la biblioteca monolítica de Play Core, actualízala a la versión 1.8.3 o a una posterior. Recomendamos cambiar a la Biblioteca de Play Asset Delivery y actualizar a la versión más reciente si es posible.

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

En el archivo build.gradle del módulo principal de la app, habilita la división por la DTT:

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

Por último, puedes compilar tu Android App Bundle (AAB).

• Android Studio
• CLI

Bundletool

Compila tu paquete con bundletool y, durante el paso para personalizar tu AAB, agrega lo siguiente a tu archivo BundleConfig.pb.

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

Unity

Una vez que hayas configurado tu AssetPackConfig de modo que incluya los paquetes de la DTT, puedes pasar esa configuración a uno de los siguientes métodos para compilar el 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)

Cómo realizar pruebas locales

Antes de continuar, te recomendamos que pruebes tu paquete de aplicación de forma local a fin de asegurarte de que todo esté configurado de manera correcta. Con bundletool (1.8.0 o versiones posteriores), compilarás y probarás la app de forma local y especificarás de forma explícita el nivel de dispositivo correcto. Primero, usarás build-apks para generar un conjunto de archivos .apks y, luego, implementarás tu app en un dispositivo conectado usando install-apks. También puedes especificar el nivel que te gustaría instalar mediante la marca del nivel del dispositivo. Puedes encontrar más información sobre este método de pruebas locales aquí. Ten en cuenta que esta página aún no se actualizó para la DTT y, por lo tanto, falta la marca de 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

Otra alternativa: También puedes usar extract-apks para extraer un conjunto de APK para un dispositivo específico. Sin embargo, el uso de get-device-spec junto con la especificación del nivel del dispositivo en cuestión, no funciona junto con la marca de --local-testing, lo que significa que no podrás probar los paquetes de recursos de seguimiento rápido o a pedido.

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

La opción Google -> Build and Run del menú creará y ejecutará el juego con la marca --local-testing habilitada. Sin embargo, no te permitirá especificar el nivel del dispositivo que se pasó al comando install-apks.

Si quieres especificar un nivel del dispositivo distinto de 0, debes hacer lo siguiente:

1. Compila el AAB usando la opción del menú Google -> Build Android App Bundle.
2. Sigue las instrucciones en la sección anterior para ejecutar bundletool, build-apks y install-apks en el AAB compilado.

Cómo crear una configuración del nivel del dispositivo a través de la API de Google Play Developer

Cómo comenzar a usar la API de Google Play Developer (si aún no lo hiciste)

Si deseas configurar la segmentación por nivel de dispositivo (p. ej., mediante la definición de los requisitos para cada nivel), deberás usar la API de Android Publisher a fin de subir la configuración a Google Play. Puedes obtener más información sobre la API en el vínculo de arriba. Hay algunos pasos que deberás seguir para comenzar:

1. Crea tu proyecto de API (si es necesario) y vincúlalo a Google Play Console.
2. Configura un cliente de acceso a la API.

Puedes encontrar la referencia de la API aquí. Más adelante, si eliges subir tu compilación a través de la API, usarás los métodos de edición. Además, te recomendamos que revises esta página antes de usar la API.

Cómo usar la API de configuración del nivel del dispositivo

Puedes usar la siguiente llamada a la API para crear la configuración del nivel del dispositivo (DTC):

Cómo crear la configuración del nivel del dispositivo

Solicitud HTTP	POST https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs
Parámetros de ruta de acceso	N/A
Cuerpo de la solicitud	Configuración del nivel del dispositivo
Cuerpo de la respuesta	Configuración del nivel del dispositivo

Objeto de la configuración del nivel del dispositivo

La definición de los niveles de los dispositivos consta de 2 pasos:

1. Definir un conjunto de grupos de dispositivos
2. Asignar un nivel a tus grupos de dispositivos para definir el conjunto de niveles de dispositivos

Un grupo de dispositivos es un conjunto de dispositivos que coinciden con los selectores definidos en la configuración.

Los selectores pueden definir requisitos del modelo del dispositivos y de su RAM.

Los grupos se identifican con el nombre que elijas y pueden superponerse.

Luego, puedes definir el conjunto de niveles de los dispositivos mediante la clasificación de cada grupo. El nivel del dispositivo se define en función de su categoría y del grupo de dispositivos.

Si un dispositivo coincide con varios niveles, se entregará el contenido para el nivel coincidente más 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]
        }
      ]
    }
  }

Campos:

• device_confid_id (número entero): ID correspondiente a la configuración del nivel del dispositivo

• device_groups (objeto): Definiciones de los grupos

  • name (string): Nombre del grupo de dispositivos (un ID de string que definas)
  • device_selectors (objeto): Los requisitos del dispositivo para que un dispositivo pertenezca a este grupo
  • device_ram (objeto): Requisitos de RAM del dispositivo
    • min_bytes (número entero, inclusive): RAM mínima requerida (en bytes)
    • max_bytes (número entero, exclusive): RAM máxima requerida (en bytes)
  • included_device_ids (objeto): Modelos de dispositivos que se incluirán en este selector (10,000 device_ids por grupo como máximo). Un dispositivo debe estar en esta lista para coincidir con el selector. Esta es una condición necesaria pero no suficiente, para hacer coincidir el selector completo (consulta la nota anterior sobre la combinación de requisitos de un selector)
    • build_brand (cadena): Fabricante del dispositivo
    • build_device (cadena): Código del modelo del dispositivo
  • excluded_device_ids (objeto): Modelos de dispositivos que se excluirán del selector (10000 device_ids por grupo como máximo). Los dispositivos de esta lista no coincidirán con el selector incluso aunque coincidieran con todos los demás requisitos del selector.
    • build_brand (cadena): Fabricante del dispositivo
    • build_device (cadena): Código del modelo del dispositivo

  • required_system_features (objeto): Funciones que un dispositivo debe tener para que se incluya en este selector (100 funciones por grupo como máximo). Un dispositivo debe tener todas las funciones del sistema de esta lista a fin de que coincida con el selector. Esta es una condición necesaria, pero no suficiente, para hacer coincidir el selector completo (consulta la nota anterior sobre la combinación de requisitos de un selector)

    Referencia de las funciones del sistema

    • name (string): Una función del sistema

  • forbidden_system_features (objeto): Funciones que un dispositivo no debe tener para que se incluya en este selector (100 funciones por grupo como máximo). Si un dispositivo tiene alguna de las funciones del sistema que se detallan en esta lista, no coincidirá con el selector, incluso aunque coincidiera con todos los demás requisitos del selector.

    Referencia de las funciones del sistema

    • name (string): Una función del sistema

• device_tiers (objeto): Definiciones de niveles

  • level (número entero): Categoría del nivel
  • group_name (array de strings): Nombre de los grupos de dispositivos que pertenecen a este nivel

Puedes encontrar el formato correcto para el fabricante y el código del modelo del dispositivo en el catálogo de dispositivos de Google Play Console optando por una de las siguientes maneras:

• Inspecciona los dispositivos individuales mediante el catálogo de dispositivos y encuentra el fabricante y el código del modelo en las ubicaciones como se muestra en el siguiente ejemplo (para un Google Pixel 4a, el fabricante es "Google" y el código del modelo es "sunfish").

  

  

• Descarga un archivo CSV de dispositivos compatibles e ingresa el Fabricante y el Código del modelo en los campos build_brand y build_device respectivamente.

El siguiente es un ejemplo de configuración con 3 niveles: el nivel 2 usa un grupo de dispositivos alto (que incluye todos los dispositivos Pixel 4 de más de 7 GB), el nivel 1 usa un grupo de dispositivos medio (que incluye todos los dispositivos de entre 4 GB y 7 GB) y el nivel 0, que se define de forma implícita como el grupo genérico.

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

Puedes seguir las instrucciones que aparecen a continuación para validar tu configuración de segmentación por dispositivo antes de subirla a Google Play.

Cómo obtener la configuración del nivel del dispositivo por ID

Puedes recuperar una configuración del nivel del dispositivo específica por ID utilizando la siguiente llamada:

Solicitud HTTP	GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs/{deviceTierConfigId}
Parámetros de ruta de acceso	N/A
Cuerpo de la solicitud	N/A
Cuerpo de la respuesta	Configuración del nivel del dispositivo

Cómo obtener una lista de configuraciones del nivel del dispositivo

Puedes obtener las últimas 10 configuraciones del nivel del dispositivo utilizando la siguiente llamada (o especificando de manera óptima un conjunto de diez mediante el parámetro de búsqueda page_token):

Solicitud HTTP	GET https://androidpublisher.googleapis.com/androidpublisher/v3/applications/{packageName}/deviceTierConfigs
Parámetros de ruta de acceso	N/A
Parámetros de búsqueda	page_token (opcional): Se usa para especificar un grupo determinado de 10 DTC. Esto resulta útil si creaste más de 10 DTC y deseas ver aquellas creadas antes de las 10 más recientes.
Cuerpo de la solicitud	N/A
Cuerpo de la respuesta	Lista de configuraciones del nivel del dispositivo page_token

Cómo validar la configuración de la segmentación por dispositivo

bundletool incluye dos comandos que te ayudan a validar que tu configuración de segmentación por dispositivo funcione según lo previsto antes de subirla a Play.

Con bundletool print-device-targeting-config, puedes validar que tu archivo JSON sea sintácticamente correcto y visualizar tus grupos de dispositivos y niveles en un formato más legible.

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

Con bundletool evaluate-device-targeting-config, puedes evaluar qué grupos y niveles coincidirían con un dispositivo específico. Conecta el dispositivo de destino a la estación de trabajo y usa la marca --connected-device. También puedes compilar manualmente un archivo JSON con las propiedades del dispositivo y proporcionarlo a través de la marca --device-properties.

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

El archivo de propiedades del dispositivo debe ser un archivo JSON según la estructura protobuf de DeviceProperties. Por ejemplo:

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

Cómo subir tu Android App Bundle a Google Play

Mediante la API

Puedes usar la API de Google Play Developer a fin de subir tu Android App Bundle a Google Play y vincular una configuración específica de segmentación por nivel de dispositivo a la compilación.

Aquí se presenta una descripción general de los métodos de edición junto con ejemplos más detallados sobre el lanzamiento en los diferentes segmentos en Google Play Console (para el último vínculo, te recomendamos que uses API compatibles con AAB en lugar de API compatibles con APK, las cuales se enumeran en la página). Si quieres especificar la configuración del nivel del dispositivo para tu compilación, debes agregar el ID de configuración al parámetro de búsqueda deviceTierConfigId mientras llamas al método edits.bundle.upload, de esta manera:

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

Mediante Google Play Console

Puedes seguir estas instrucciones para subir el Android App Bundle. Se aplicará la configuración de la DTC más reciente a tu Android App Bundle.

Para verificar que tu paquete se compiló correctamente, ve al Explorador de paquete de aplicación (con la compilación correcta seleccionada) > Entrega y haz clic en cada paquete de recursos. Debería mostrar que tienes los N niveles que creaste. En este ejemplo, muestra que tenemos 3 niveles: 0, 1 y 2 para nuestro paquete de recursos main_asset.

Cómo verificar si se está entregando el nivel correcto

Usa el siguiente método para asegurarte de que solo se entregue el nivel correcto al dispositivo.

adb shell pm path {packageName}

Deberías ver algo como lo siguiente:

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

Información auxiliar

Guía de inicio rápido para Curl

A continuación, se muestra un ejemplo (que usa la herramienta de línea de comandos curl) para crear una nueva configuración del nivel del dispositivo y usar la API de edición para crear una edición nueva, subir un AAB nuevo (y asociarlo a una configuración del nivel del dispositivo específica), establecer la configuración del segmento y la versión, y confirmar la edición. (por lo tanto, harás público el cambio). Asegúrate de tener la ubicación de los siguientes datos:

• La clave correspondiente a tu cliente de la API
• El nombre del paquete de tu app

Primero, crea una configuración del nivel del dispositivo y toma nota del deviceTierConfigId que recibirás cuando se realice una llamada con éxito.

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

Inicia una edición: Recibirás un ID y una hora de vencimiento para la edición. Guarda el ID para las siguientes llamadas.

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

Sube el AAB y especifica la configuración del nivel del dispositivo como un parámetro de búsqueda. Si la llamada se realiza correctamente, verás un código de versión y los SHA1 y SHA256 de la compilación. Guarda el código de versión para la próxima llamada.

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

Asigna el AAB al segmento deseado (para las pruebas, te recomendamos que uses el segmento de pruebas internas, pero puedes obtener más información sobre los distintos segmentos aquí). Este es un lanzamiento sencillo sin notas de la versión, pero puedes leer esta página para obtener más información sobre el lanzamiento en etapas, las versiones en borrador y las notas de la versión. Si es la primera vez que usas la API de Publisher, te recomendamos que crees esta versión como una en borrador y que la completes en Google Play Console para asegurarte de que todo se haya configurado correctamente.

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}

Confirma los cambios (hazlo con cuidado, ya que esto permitirá que todos los cambios se publiquen en Play en el segmento deseado).

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