REST Resource: applications.deviceTierConfigs

Ressource: DeviceTierConfig

Configuration décrivant les critères de ciblage par types d'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 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'appareil pour l'application.
userCountrySets[]

object (UserCountrySet)

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

DeviceGroup

Un groupe d'appareils.

Un groupe est défini par un ensemble de sélecteurs d'appareils. Un appareil appartient au groupe s'il correspond à un 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 les conditions de RAM, l'inclusion du modèle d'appareil et l'exclusion du modèle d'appareil, un appareil est considéré comme correspondant si: l'appareil répond aux conditions de RAM ET l'appareil correspond à l'un des modèles inclus ET l'appareil ne correspond pas aux modèles exclus.

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

object (DeviceRam)

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

object (DeviceId)

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

object (DeviceId)

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

object (SystemFeature)

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

object (SystemFeature)

Ce sélecteur exclut tout appareil doté de l'une de ces fonctionnalités système, même s'il remplit toutes les autres conditions.

DeviceRam

Conditions relatives aux capacités de RAM d'un appareil.

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

string (int64 format)

RAM minimale en octets (limitée).
maxBytes

string (int64 format)

RAM maximale en octets (limitées).

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 l'élément géographique.

DeviceTierSet

Ensemble de niveaux d'appareils.

Un ensemble de niveaux détermine quelle variante du contenu de l'application est diffusée sur un appareil spécifique, pour le contenu ciblé par types d'appareil.

Vous devez attribuer un niveau de priorité à chaque niveau, qui détermine l'ordre d'évaluation par Play. Pour en savoir plus, consultez la documentation de DeviceTier.level.

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

object (DeviceTier)

Niveaux d'appareil appartenant à l'ensemble.

DeviceTier

Un seul niveau d'appareil.

Les appareils correspondant à l'un des groupes d'appareils dans 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 contiguë 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 la solution globale de remplacement), vous devez définir les niveaux 1, 2 et 3 dans cette configuration.

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

UserCountrySet

Un ensemble de pays d'utilisateurs.

Un ensemble de pays détermine quelle variante du contenu de l'application est diffusée dans une zone géographique 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 les pays. Un code pays est représenté au format ISO 3166 alpha-2. Par 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, classées par heure de création décroissante.