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'appareils pour l'application.
userCountrySets[]

object (UserCountrySet)

Définition des ensembles de pays des utilisateurs 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 pour un groupe d'appareils. Un sélecteur est 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 concernant la 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 correspond 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 par ce sélecteur.
excludedDeviceIds[]

object (DeviceId)

Modèles d'appareils exclus par ce sélecteur, même s'ils correspondent à 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 possède l'une de ces fonctionnalités système est exclu par ce sélecteur, même s'il remplit toutes les autres conditions.

DeviceRam

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

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

string (int64 format)

RAM minimale en octets (limités inclus).
maxBytes

string (int64 format)

RAM maximale en octets (limités exclus).

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

Un ensemble de niveaux d'appareils.

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

Vous devez attribuer un niveau de priorité à chaque niveau, 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

Un seul niveau d'appareil.

Les appareils correspondant à l'un des groupes d'appareils définis dans deviceGroupNames sont considérés comme correspondant à ce 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é.

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ës pour vos niveaux dans un ensemble. Les niveaux d'un ensemble doivent être uniques. Par exemple, si votre ensemble comprend quatre niveaux (dont la valeur de remplacement globale), 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 secours globale. Il 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 pays défini détermine quelle variante du contenu de l'application sera 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. Le 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 particulière.

list

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