REST Resource: applications.deviceTierConfigs

Ressource: DeviceTierConfig

Configuration décrivant les critères de ciblage par appareil pour le contenu d'une application.

Représentation JSON 
{
  "deviceTierConfigId": string,
  "deviceGroups": [
    {
      object (DeviceGroup)
    }
  ],
  "deviceTierSet": {
    object (DeviceTierSet)
  },
  "userCountrySets": [
    {
      object (UserCountrySet)
    }
  ]
}
Champs
deviceTierConfigId

string (int64 format)

Uniquement en sortie. ID de la configuration du niveau d'appareil.
deviceGroups[]

object (DeviceGroup)

Définition des groupes d'appareils pour l'application.
deviceTierSet

object (DeviceTierSet)

Définition de l'ensemble des niveaux d'appareils pour l'application.
userCountrySets[]

object (UserCountrySet)

Définition des ensembles de pays des utilisateurs pour l'application.

DeviceGroup

Groupe d'appareils.

Un groupe est défini par un ensemble de sélecteurs d'appareils. Un appareil appartient au groupe s'il correspond à n'importe quel sélecteur (opérateur logique OU).

Représentation JSON 
{
  "name": string,
  "deviceSelectors": [
    {
      object (DeviceSelector)
    }
  ]
}
Champs
name

string

Nom du groupe.
deviceSelectors[]

object (DeviceSelector)

Sélecteurs d'appareils pour ce groupe. Un appareil correspondant à l'un des sélecteurs est inclus dans ce groupe.

DeviceSelector

Sélecteur d'un groupe d'appareils. Un sélecteur consiste en un ensemble de conditions sur l'appareil qui doivent toutes correspondre (opérateur logique ET) pour déterminer l'éligibilité d'un groupe d'appareils.

Par exemple, si un sélecteur spécifie des conditions de RAM, l'inclusion et l'exclusion de modèles d'appareils, un appareil est considéré comme correspondant si: il remplit les conditions de RAM ET il correspond à l'un des modèles d'appareils inclus ET il ne correspond pas aux modèles d'appareils exclus.

Représentation JSON 
{
  "deviceRam": {
    object (DeviceRam)
  },
  "includedDeviceIds": [
    {
      object (DeviceId)
    }
  ],
  "excludedDeviceIds": [
    {
      object (DeviceId)
    }
  ],
  "requiredSystemFeatures": [
    {
      object (SystemFeature)
    }
  ],
  "forbiddenSystemFeatures": [
    {
      object (SystemFeature)
    }
  ],
  "systemOnChips": [
    {
      object (SystemOnChip)
    }
  ]
}
Champs
deviceRam

object (DeviceRam)

Conditions concernant la RAM de l'appareil.
includedDeviceIds[]

object (DeviceId)

Modèles d'appareils inclus par ce sélecteur.
excludedDeviceIds[]

object (DeviceId)

Modèles d'appareils exclus par ce sélecteur, même s'ils répondent à toutes les autres conditions.
requiredSystemFeatures[]

object (SystemFeature)

Un appareil doit disposer de toutes ces fonctionnalités système pour être inclus par le sélecteur.
forbiddenSystemFeatures[]

object (SystemFeature)

Un appareil qui dispose de l'une de ces fonctionnalités système est exclu par ce sélecteur, même s'il répond à toutes les autres conditions.
systemOnChips[]

object (SystemOnChip)

Facultatif. SoC inclus par ce sélecteur. Fonctionne uniquement avec les appareils Android S+.

DeviceRam

Conditions concernant les capacités de RAM d'un appareil.

Représentation JSON 
{
  "minBytes": string,
  "maxBytes": string
}
Champs
minBytes

string (int64 format)

Mémoire RAM minimale en octets (avec la mémoire allouée incluse).
maxBytes

string (int64 format)

RAM maximale en octets (mémoire allouée exclue).

DeviceId

Identifiant d'un appareil.

Représentation JSON 
{
  "buildBrand": string,
  "buildDevice": string
}
Champs
buildBrand

string

Valeur de Build.BRAND.
buildDevice

string

Valeur de Build.DEVICE.

SystemFeature

Représentation d'une fonctionnalité système.

Représentation JSON 
{
  "name": string
}
Champs
name

string

Nom de la fonctionnalité.

SystemOnChip

Représentation d'un système sur puce (SoC) d'un appareil Android. Peut être utilisé pour cibler les appareils S+.

Représentation JSON 
{
  "manufacturer": string,
  "model": string
}
Champs
manufacturer

string

Obligatoire. Le concepteur du SoC, par exemple "Google" Valeur de la propriété de compilation "ro.soc.manufacturer" https://developer.android.com/reference/android/os/Build#SOC_MANUFACTURER requise.
model

string

Obligatoire. Modèle du SoC (par exemple, "Tensor" Valeur de la propriété de compilation "ro.soc.model" https://developer.android.com/reference/android/os/Build#SOC_MODEL Obligatoire.

DeviceTierSet

Ensemble de niveaux d'appareils.

Un ensemble de niveaux détermine la variation de contenu de l'application diffusée sur un appareil spécifique, pour le contenu ciblé par appareil.

Vous devez attribuer un niveau de priorité à chaque niveau, ce qui détermine l'ordre dans lequel ils sont évalués par Play. Pour en savoir plus, consultez la documentation de DeviceTier.level.

Représentation JSON 
{
  "deviceTiers": [
    {
      object (DeviceTier)
    }
  ]
}
Champs
deviceTiers[]

object (DeviceTier)

Niveaux d'appareils appartenant à l'ensemble.

DeviceTier

Niveau d'abonnement pour un seul appareil.

Les appareils correspondant à l'un des groupes d'appareils de deviceGroupNames sont considérés comme correspondant au niveau.

Représentation JSON 
{
  "deviceGroupNames": [
    string
  ],
  "level": integer
}
Champs
deviceGroupNames[]

string

Groupes d'appareils inclus dans ce niveau. Ces groupes doivent être définis explicitement sous "deviceGroups" dans cette configuration.
level

integer

Niveau de priorité du niveau.

Les niveaux sont évalués par ordre décroissant: le niveau le plus élevé a la priorité la plus élevée. Le niveau le plus élevé correspondant à un appareil donné est sélectionné pour cet appareil.

Vous devez utiliser une plage de niveaux contigus pour vos niveaux dans un ensemble de niveaux. Les niveaux d'un ensemble de niveaux doivent être uniques. Par exemple, si votre ensemble de niveaux comporte quatre niveaux (y compris le niveau de remplacement global), vous devez définir les niveaux 1, 2 et 3 dans cette configuration.

Remarque: Le niveau 0 est défini implicitement comme un niveau de remplacement global et est sélectionné pour les appareils qui ne correspondent à aucun des niveaux définis explicitement ici. Vous ne devez pas définir explicitement le niveau 0 dans cette configuration.

UserCountrySet

Ensemble de pays des utilisateurs.

Un ensemble de pays détermine la variante de contenu de l'application diffusée dans un emplacement spécifique.

Représentation JSON 
{
  "name": string,
  "countryCodes": [
    string
  ]
}
Champs
name

string

Nom de l'ensemble de pays.
countryCodes[]

string

Liste des codes pays représentant des pays. Un code pays est représenté au format ISO 3166 alpha-2. Exemple : "IT" pour l'Italie, "GE" pour la Géorgie.

Méthodes

create

 Crée une configuration de niveau d'appareil pour une application.

get

 Renvoie une configuration de niveau d'appareil spécifique.

list

 Renvoie les configurations de niveau d'appareil créées, triées par date de création décroissante.