Engage SDK Health and Fitness: instructions d'intégration technique tierce

Google est en train de développer une surface sur appareil, qui organisera les applications des utilisateurs par secteurs et offrira une nouvelle expérience immersive permettant une consommation et une découverte personnalisées du contenu de ces applications. Cette expérience plein écran offre aux développeurs partenaires l'opportunité de mettre en avant leurs meilleurs contenus enrichis sur une chaîne dédiée à l'extérieur de leur application.Ce guide explique aux développeurs partenaires intégrer leurs contenus de santé et remise en forme, à l'aide du SDK Engage pour remplir cette nouvelle surface.

Détails de l'intégration

Terminologie

Cette intégration comprend les trois types de clusters suivants: Recommendation, Featured et Continuation.

• Les clusters Recommandations affichent des suggestions personnalisées de santé et de remise en forme d'un développeur partenaire individuel. Ces recommandations peuvent être personnalisées ou généralisées (par exemple, les tendances du fitness et l'état de fonctionnement). Utilisez-les pour mettre en avant des articles ou des personnes en rapport avec la santé et le fitness.

  • Un cluster "Recommendation" peut être constitué des éléments suivants : ArticleEntity, PersonEntity, ou EventEntity, mais pas une combinaison de types d'entités différents.

  Les recommandations présentent la structure suivante :

  • Cluster "Recommendations" : vue de l'interface utilisateur contenant un groupe de recommandations du même développeur partenaire.

  • Entité : objet représentant un seul élément dans un cluster. Ce propose des entités qui seront mises en évidence à l'aide du Cluster "Recommendation" :

    • ArticleEntity: ArticleEntity représente une recommandation pour contenus textuels liés à la santé et le fitness. Il peut être utilisé pour articles, articles de blog, contenus marketing, extraits d'actualités, etc.

      

    • PersonEntity: PersonEntity représente une personne. La les recommandations peuvent consister à mettre en avant un coach ou toute personne à la santé et à la remise en forme, etc.

      

    • EventEntity: EventEntity représente un événement ayant lieu dans le à venir. L'heure de début de l'événement est une information essentielle qui doit être transmise aux utilisateurs. Cette entité peut être utilisée mettre en avant des événements tels que des camps de don du sang, des séances d'entraînement, des salles de sport ou des cours de yoga, etc., en rapport avec la santé et la remise en forme.

      

• Le cluster Continuation affiche le contenu récemment interagi par les utilisateurs depuis plusieurs développeurs partenaires dans un seul regroupement d'UI. Chaque développeur partenaire pourra diffuser au maximum 10 entités dans la section "Suite" cluster.

  Le contenu de la continuation peut avoir la structure suivante:

  • ArticleEntity: ArticleEntity représente une recommandation pour contenus textuels liés à la santé et le fitness. Cette entité peut être utilisée pour représenter des articles de presse mis en pause ou d'autres contenus l’utilisateur aimerait continuer à consommer là où il l’a laissé. Exemple: Actualités extrait, extrait d'article de blog sur des sujets liés à la santé ou à la remise en forme.

    

  • EventRéservationEntity: EventRéservationEntity représente réservation pour un événement et aide les utilisateurs à suivre les événements à venir ou en cours réservations d'événements de remise en forme et de santé. Ex: sessions de formation

    

• Le cluster Featured est une vue d'interface utilisateur qui présente le héros choisi GenericFeaturedEntity de nombreux développeurs partenaires dans un seul regroupement d'interface utilisateur. Il n'y a qu'un seul cluster "Featured", situé dans la partie supérieure de UI avec un emplacement prioritaire au-dessus de tous les clusters "Recommendation" Chaque Les développeurs partenaires sont autorisés à diffuser une seule entité d'un dans "Sélection", avec de nombreuses entités (de types potentiellement différents) plusieurs développeurs d'applications dans le cluster "Featured".

  • GenericFeaturedEntity: GenericFeaturedEntity est différent de L'élément de recommandation de cet élément de la sélection doit être utilisé pour un seul contenus populaires des développeurs et doit représenter du contenu important qui sera intéressant et pertinent pour les utilisateurs.

    

Travail préalable

Niveau d'API minimal : 19

Ajoutez la bibliothèque com.google.android.engage:engage-core à votre application :

dependencies {
    // Make sure you also include that repository in your project's build.gradle file.
    implementation 'com.google.android.engage:engage-core:1.5.2'
}

Résumé

La conception repose sur la mise en œuvre d'un service lié.

Les données qu'un client peut publier sont soumises aux limites suivantes pour chaque type de cluster :

Étape 1 : Fournir les données d'entité

Le SDK a défini différentes entités pour représenter chaque type d'élément. Nous acceptons les entités suivantes pour la colonne "Health & Catégorie de remise en forme:

1. GenericFeaturedEntity
2. ArticleEntity
3. PersonEntity
4. EventEntity
5. EventReservationEntity

Les tableaux ci-dessous décrivent les attributs disponibles pour chaque type et indiquent s'ils sont obligatoires.

GenericFeaturedEntity

ArticleEntity

PersonEntity

EventEntity

EventReservationEntity

Caractéristiques des images

Le tableau suivant indique les spécifications requises pour les composants Image:

Les images doivent être hébergées sur des CDN publics pour que Google puisse y accéder.

Formats des fichiers

PNG, JPG, GIF statique, WebP

Taille maximale des fichiers

5 120 Ko

Autres recommandations

• Zone de sécurité de l'image : placez le contenu important dans les 80 % les plus au centre de l'image.
• Utilisez un arrière-plan transparent pour que l'image s'affiche correctement avec les paramètres du thème sombre et clair.

Catégorie de contenu

La catégorie de contenu permet aux applications de publier du contenu appartenant à plusieurs catégories. Le contenu est ainsi mis en correspondance avec certaines des catégories prédéfinies, à savoir:

• TYPE_EDUCATION
• TYPE_SPORTS
• TYPE_MOVIES_AND_TV_SHOWS
• TYPE_BOOKS
• TYPE_AUDIOBOOKS
• TYPE_MUSIC
• TYPE_DIGITAL_GAMES
• TYPE_TRAVEL_AND_LOCAL
• TYPE_HOME_AND_AUTO
• TYPE_BUSINESS
• TYPE_NEWS
• TYPE_FOOD_AND_DRINK
• TYPE_SHOPPING
• TYPE_HEALTH_AND_FITENESS
• TYPE_MEDICAL
• TYPE_PARENTING
• TYPE_DATING

Les images doivent être hébergées sur des CDN publics pour que Google puisse y accéder.

Consignes d'utilisation des catégories de contenu

1. Certaines entités telles que ArticleEntity et GenericFeaturedEntity sont pouvant utiliser n'importe quelle catégorie de contenu. Pour les autres entités telles que EventEntity, EventRéservationEntity, PersonEntity : un sous-ensemble uniquement de ces catégories sont éligibles. Consultez la liste des catégories éligibles pour un type d'entité avant de remplir la liste.

2. Utiliser le type d'entité spécifique pour certaines catégories de contenu plutôt qu'une combinaison des entités Generic et de ContentCategory:

   • TYPE_movieS_AND_TV_SHOWS – Consultez les entités de Consultez le guide d'intégration avant d'utiliser la des entités génériques.
   • TYPE_BOOKS - Consultez les EbookEntity avant d'utiliser la des entités génériques.
   • TYPE_AUDIOBOOKS - Règlement AudiobookEntity avant à l'aide des entités génériques.
   • TYPE_SHOPPING - Règlement ShoppingEntity avant à l'aide des entités génériques.
   • TYPE_FOOD_AND_DRINK – Extraire les entités de Guide d'intégration de l'alimentation avant d'utiliser le des entités génériques.

3. Le champ "ContentCategory" est facultatif et ne doit pas être renseigné si le paramètre le contenu n'appartient à aucune des catégories mentionnées précédemment.

4. Si plusieurs catégories de contenu sont fournies, indiquez-les dans l'ordre par rapport au contenu classé dans la catégorie la plus pertinente en premier dans la liste.

Étape 2 : Fournir les données de cluster

Il est recommandé d'exécuter la tâche de publication de contenu en arrière-plan (par exemple, à l'aide de WorkManager) et de la programmer régulièrement ou sur la base d'un événement précis (par exemple, chaque fois que l'utilisateur ouvre l'application ou lorsqu'il vient d'ajouter quelque chose à son panier).

AppEngagePublishClient permet la publication des clusters.

Les API suivantes permettent de publier des clusters dans le client :

• isServiceAvailable
• publishRecommendationClusters
• publishFeaturedCluster
• publishContinuationCluster
• publishUserAccountManagementRequest
• updatePublishStatus
• deleteRecommendationsClusters
• deleteFeaturedCluster
• deleteContinuationCluster
• deleteUserManagementCluster
• deleteClusters

isServiceAvailable

Cette API permet de vérifier si le service est disponible pour l'intégration et de déterminer si le contenu peut être présenté sur l'appareil.

client.isServiceAvailable.addOnCompleteListener { task ->
    if (task.isSuccessful) {
        // Handle IPC call success
        if(task.result) {
          // Service is available on the device, proceed with content publish
          // calls.
        } else {
          // Service is not available, no further action is needed.
        }
    } else {
      // The IPC call itself fails, proceed with error handling logic here,
      // such as retry.
    }
}

client.isServiceAvailable().addOnCompleteListener(task - > {
    if (task.isSuccessful()) {
        // Handle success
        if(task.getResult()) {
          // Service is available on the device, proceed with content publish
          // calls.
        } else {
          // Service is not available, no further action is needed.
        }
    } else {
      // The IPC call itself fails, proceed with error handling logic here,
      // such as retry.
    }
});

publishRecommendationClusters

Cette API permet de publier une liste d'objets RecommendationCluster.

client.publishRecommendationClusters(
      PublishRecommendationClustersRequest.Builder()
        .addRecommendationCluster(
          RecommendationCluster.Builder()
            .addEntity(entity1)
            .addEntity(entity2)
            .setTitle("Top Picks For You")
            .build()
        )
        .build()
    )

client.publishRecommendationClusters(
            new PublishRecommendationClustersRequest.Builder()
                .addRecommendationCluster(
                    new RecommendationCluster.Builder()
                        .addEntity(entity1)
                        .addEntity(entity2)
                        .setTitle("Top Picks For You")
                        .build())
                .build());

Lorsque le service reçoit la requête, les actions suivantes ont lieu dans une seule transaction :

• Les données RecommendationCluster existantes du développeur partenaire sont supprimées.
• Les données de la requête sont analysées et stockées dans le cluster "Recommendation" mis à jour.

En cas d'erreur, la requête entière est rejetée, et l'état existant est maintenu.

publishFeaturedCluster

Cette API permet de publier une liste d'objets FeaturedCluster.

client.publishFeaturedCluster(
    PublishFeaturedClusterRequest.Builder()
      .setFeaturedCluster(
        FeaturedCluster.Builder()
          .addEntity(entity1)
          .addEntity(entity2)
          .build())
      .build())

client.publishFeaturedCluster(
            new PublishFeaturedClustersRequest.Builder()
                .addFeaturedCluster(
                    new FeaturedCluster.Builder()
                        .addEntity(entity1)
                        .addEntity(entity2)
                        .build())
                .build());

Lorsque le service reçoit la requête, les actions suivantes ont lieu dans une seule transaction :

• Les données FeaturedCluster existantes du développeur partenaire sont supprimées.
• Les données de la requête sont analysées et stockées dans le cluster "Featured" mis à jour.

En cas d'erreur, la requête entière est rejetée, et l'état existant est maintenu.

publishContinuationCluster

Cette API permet de publier un objet ContinuationCluster.

client.publishContinuationCluster(
    PublishContinuationClusterRequest.Builder()
      .setContinuationCluster(
        ContinuationCluster.Builder()
          .addEntity(entity1)
          .addEntity(entity2)
          .build())
      .build())

client.publishContinuationCluster(
            new PublishContinuationClusterRequest.Builder()
                .setContinuationCluster(
                    new ContinuationCluster.Builder()
                        .addEntity(entity1)
                        .addEntity(entity2)
                        .build())
                .build());

Lorsque le service reçoit la requête, les actions suivantes ont lieu dans une seule transaction :

• Les données ContinuationCluster existantes du développeur partenaire sont supprimées.
• Les données de la requête sont analysées et stockées dans le cluster "Continuation" mis à jour.

En cas d'erreur, la requête entière est rejetée, et l'état existant est maintenu.

publishUserAccountManagementRequest

Cette API permet de publier une fiche de connexion. L'action de connexion redirige les utilisateurs vers la page de connexion de l'application afin que celle-ci puisse publier du contenu (ou fournir un contenu plus personnalisé).

Les métadonnées suivantes font partie de la fiche de connexion :

var SIGN_IN_CARD_ENTITY =
      SignInCardEntity.Builder()
          .addPosterImage(
              Image.Builder()
                  .setImageUri(Uri.parse("http://www.x.com/image.png"))
                  .setImageHeightInPixel(500)
                  .setImageWidthInPixel(500)
                  .build())
          .setActionText("Sign In")
          .setActionUri(Uri.parse("http://xx.com/signin"))
          .build()

client.publishUserAccountManagementRequest(
            PublishUserAccountManagementRequest.Builder()
                .setSignInCardEntity(SIGN_IN_CARD_ENTITY)
                .build());

SignInCardEntity SIGN_IN_CARD_ENTITY =
      new SignInCardEntity.Builder()
          .addPosterImage(
              new Image.Builder()
                  .setImageUri(Uri.parse("http://www.x.com/image.png"))
                  .setImageHeightInPixel(500)
                  .setImageWidthInPixel(500)
                  .build())
          .setActionText("Sign In")
          .setActionUri(Uri.parse("http://xx.com/signin"))
          .build();

client.publishUserAccountManagementRequest(
            new PublishUserAccountManagementRequest.Builder()
                .setSignInCardEntity(SIGN_IN_CARD_ENTITY)
                .build());

Lorsque le service reçoit la requête, les actions suivantes ont lieu dans une seule transaction :

• Les données UserAccountManagementCluster existantes du développeur partenaire sont supprimées.
• Les données de la requête sont analysées et stockées dans le cluster "UserAccountManagementCluster" mis à jour.

En cas d'erreur, la requête entière est rejetée, et l'état existant est maintenu.

updatePublishStatus

Si, pour une raison commerciale interne, aucun des clusters n'est publié, nous recommandons vivement de mettre à jour l'état de publication à l'aide de la updatePublishStatus. Ce point est important pour les raisons suivantes :

• Il est essentiel d'indiquer l'état dans tous les scénarios, même lorsque le contenu est publié (STATUS == PUBLISHED) pour renseigner les tableaux de bord qui utilisent cet état explicite afin de transmettre l'état et d'autres métriques de votre intégration.
• Si aucun contenu n'est publié, mais que l'état de l'intégration fonctionne correctement (STATUS == NOT_PUBLISHED), Google peut éviter de déclencher des alertes dans les tableaux de bord concernant l'état de l'application. Cela confirme que le contenu n'est pas publié en raison d'une situation attendue du point de vue du fournisseur.
• Il aide les développeurs à fournir des informations sur la date de publication des données et sur non.
• Google peut utiliser les codes d'état pour encourager l'utilisateur à effectuer certaines actions l'application afin qu'ils puissent voir le contenu de l'application ou le passer.

Voici la liste des codes d'état de publication éligibles :

// Content is published
AppEngagePublishStatusCode.PUBLISHED,

// Content is not published as user is not signed in
AppEngagePublishStatusCode.NOT_PUBLISHED_REQUIRES_SIGN_IN,

// Content is not published as user is not subscribed
AppEngagePublishStatusCode.NOT_PUBLISHED_REQUIRES_SUBSCRIPTION,

// Content is not published as user location is ineligible
AppEngagePublishStatusCode.NOT_PUBLISHED_INELIGIBLE_LOCATION,

// Content is not published as there is no eligible content
AppEngagePublishStatusCode.NOT_PUBLISHED_NO_ELIGIBLE_CONTENT,

// Content is not published as the feature is disabled by the client
// Available in v1.3.1
AppEngagePublishStatusCode.NOT_PUBLISHED_FEATURE_DISABLED_BY_CLIENT,

// Content is not published as the feature due to a client error
// Available in v1.3.1
AppEngagePublishStatusCode.NOT_PUBLISHED_CLIENT_ERROR,

// Content is not published as the feature due to a service error
// Available in v1.3.1
AppEngagePublishStatusCode.NOT_PUBLISHED_SERVICE_ERROR,

// Content is not published due to some other reason
// Reach out to engage-developers@ before using this enum.
AppEngagePublishStatusCode.NOT_PUBLISHED_OTHER

Si le contenu n'est pas publié parce que l'utilisateur n'est pas connecté, Google nous vous recommandons de publier la fiche de connexion. Si, pour une raison quelconque, les fournisseurs pour publier la fiche de connexion, nous vous recommandons d'appeler l'API updatePublishStatus avec le code d'état ; NOT_PUBLISHED_REQUIRES_SIGN_IN

client.updatePublishStatus(
   PublishStatusRequest.Builder()
     .setStatusCode(AppEngagePublishStatusCode.NOT_PUBLISHED_REQUIRES_SIGN_IN)
     .build())

client.updatePublishStatus(
    new PublishStatusRequest.Builder()
        .setStatusCode(AppEngagePublishStatusCode.NOT_PUBLISHED_REQUIRES_SIGN_IN)
        .build());

deleteRecommendationClusters

Cette API permet de supprimer le contenu des clusters "Recommendation".

client.deleteRecommendationClusters()

client.deleteRecommendationClusters();

Lorsque le service reçoit la requête, il supprime les données existantes des clusters "Recommendation". En cas d'erreur, la requête entière est rejetée. l'état existant est maintenu.

deleteFeaturedCluster

Cette API permet de supprimer le contenu du cluster "Featured".

client.deleteFeaturedCluster()

client.deleteFeaturedCluster();

Lorsque le service reçoit la requête, il supprime les données existantes du cluster "Featured". En cas d'erreur, la requête entière est rejetée, et l'état existant est maintenu.

deleteContinuationCluster

Cette API permet de supprimer le contenu du cluster "Continuation".

client.deleteContinuationCluster()

client.deleteContinuationCluster();

Lorsque le service reçoit la requête, il supprime les données existantes du cluster "Continuation". En cas d'erreur, la requête entière est rejetée. l'état existant est maintenu.

deleteUserManagementCluster

Cette API permet de supprimer le contenu du cluster "UserAccountManagement".

client.deleteUserManagementCluster()

client.deleteUserManagementCluster();

Lorsque le service reçoit la requête, il supprime les données existantes du cluster "UserAccountManagement". En cas d'erreur, la requête entière est rejetée, et l'état existant est maintenu.

deleteClusters

Cette API permet de supprimer le contenu d'un type de cluster donné.

client.deleteClusters(
    DeleteClustersRequest.Builder()
      .addClusterType(ClusterType.TYPE_CONTINUATION)
      .addClusterType(ClusterType.TYPE_FEATURED)
      .addClusterType(ClusterType.TYPE_RECOMMENDATION)
      .build())

client.deleteClusters(
            new DeleteClustersRequest.Builder()
                .addClusterType(ClusterType.TYPE_CONTINUATION)
                .addClusterType(ClusterType.TYPE_FEATURED)
                .addClusterType(ClusterType.TYPE_RECOMMENDATION)
                .build());

Lorsque le service reçoit la requête, il supprime les données existantes de tous les clusters correspondant aux types de clusters spécifiés. Les clients peuvent choisir de transmettre un ou plusieurs types de clusters. En cas d'erreur, la requête entière est rejetée, et l'état existant est maintenu.

Gestion des exceptions

Il est fortement recommandé d'écouter le résultat de la tâche à partir des API de publication afin qu'une action de suivi puisse être effectuée pour récupérer et renvoyer une tâche réussie.

client.publishRecommendationClusters(
        PublishRecommendationClustersRequest.Builder()
          .addRecommendationCluster(..)
          .build())
      .addOnCompleteListener { task ->
        if (task.isSuccessful) {
          // do something
        } else {
          val exception = task.exception
          if (exception is AppEngageException) {
            @AppEngageErrorCode val errorCode = exception.errorCode
            if (errorCode == AppEngageErrorCode.SERVICE_NOT_FOUND) {
              // do something
            }
          }
        }
      }

client.publishRecommendationClusters(
              new PublishRecommendationClustersRequest.Builder()
                  .addRecommendationCluster(...)
                  .build())
          .addOnCompleteListener(
              task -> {
                if (task.isSuccessful()) {
                  // do something
                } else {
                  Exception exception = task.getException();
                  if (exception instanceof AppEngageException) {
                    @AppEngageErrorCode
                    int errorCode = ((AppEngageException) exception).getErrorCode();
                    if (errorCode == AppEngageErrorCode.SERVICE_NOT_FOUND) {
                      // do something
                    }
                  }
                }
              });

L'erreur est renvoyée au format AppEngageException. La cause est incluse sous la forme d'un code d'erreur.

Étape 3 : Gérer les intents de diffusion

En plus d'effectuer des appels d'API de publication de contenu via une tâche, vous devez également configurer un objet BroadcastReceiver pour recevoir la requête de publication de contenu.

L'objectif des intents de diffusion est principalement de réactiver des applications et de forcer la synchronisation des données. Les intents de diffusion ne sont pas conçus pour être envoyés très fréquemment. Ils ne se déclenchent que lorsque le service Engage détermine que le contenu est peut-être obsolète (par exemple, s'il date d'il y a une semaine). De cette façon, l'utilisateur a plus de chances de bénéficier d'une expérience de contenu actualisée, même si l'application n'a pas été exécutée pendant une longue période.

Le BroadcastReceiver doit être configuré de deux manières :

• Enregistrez dynamiquement une instance de la classe BroadcastReceiver à l'aide de Context.registerReceiver(). Cela permet la communication à partir d'applications restées actives en mémoire.

class AppEngageBroadcastReceiver : BroadcastReceiver(){
  // Trigger recommendation cluster publish when PUBLISH_RECOMMENDATION broadcast
  // is received
  // Trigger featured cluster publish when PUBLISH_FEATURED broadcast is received
  // Trigger continuation cluster publish when PUBLISH_CONTINUATION broadcast is
  // received
}

fun registerBroadcastReceivers(context: Context){
  var  context = context
  context = context.applicationContext

// Register Recommendation Cluster Publish Intent
  context.registerReceiver(AppEngageBroadcastReceiver(),
                           IntentFilter(Intents.ACTION_PUBLISH_RECOMMENDATION))

// Register Featured Cluster Publish Intent
  context.registerReceiver(AppEngageBroadcastReceiver(),
                           IntentFilter(Intents.ACTION_PUBLISH_FEATURED))

// Register Continuation Cluster Publish Intent
  context.registerReceiver(AppEngageBroadcastReceiver(),
                           IntentFilter(Intents.ACTION_PUBLISH_CONTINUATION))
}

class AppEngageBroadcastReceiver extends BroadcastReceiver {
// Trigger recommendation cluster publish when PUBLISH_RECOMMENDATION broadcast
// is received

// Trigger featured cluster publish when PUBLISH_FEATURED broadcast is received

// Trigger continuation cluster publish when PUBLISH_CONTINUATION broadcast is
// received
}

public static void registerBroadcastReceivers(Context context) {

context = context.getApplicationContext();

// Register Recommendation Cluster Publish Intent
context.registerReceiver(new AppEngageBroadcastReceiver(),
new IntentFilter(com.google.android.engage.service.Intents.ACTION_PUBLISH_RECOMMENDATION));

// Register Featured Cluster Publish Intent
context.registerReceiver(new AppEngageBroadcastReceiver(),
new IntentFilter(com.google.android.engage.service.Intents.ACTION_PUBLISH_FEATURED));

// Register Continuation Cluster Publish Intent
context.registerReceiver(new AppEngageBroadcastReceiver(),
new IntentFilter(com.google.android.engage.service.Intents.ACTION_PUBLISH_CONTINUATION));

}

• Déclarez une implémentation de manière statique avec la balise <receiver> dans le fichier AndroidManifest.xml. Cela permet à l'application de recevoir des intents de diffusion lorsqu'elle n'est pas en cours d'exécution, et de publier le contenu.

<application>
   <receiver
      android:name=".AppEngageBroadcastReceiver"
      android:exported="true"
      android:enabled="true">
      <intent-filter>
         <action android:name="com.google.android.engage.action.PUBLISH_RECOMMENDATION" />
      </intent-filter>
      <intent-filter>
         <action android:name="com.google.android.engage.action.PUBLISH_FEATURED" />
      </intent-filter>
      <intent-filter>
         <action android:name="com.google.android.engage.action.PUBLISH_CONTINUATION" />
      </intent-filter>
   </receiver>
</application>

Les intents suivants sont envoyés par le service :

• com.google.android.engage.action.PUBLISH_RECOMMENDATION Il est recommandé pour démarrer un appel publishRecommendationClusters lors de la réception de cet intent.
• com.google.android.engage.action.PUBLISH_FEATURED Nous vous recommandons de démarrer un appel publishFeaturedCluster lors de la réception de cet intent.
• com.google.android.engage.action.PUBLISH_CONTINUATION Nous vous recommandons de démarrer un appel publishContinuationCluster lors de la réception de cet intent.

Workflow d'intégration

Pour vous procurer un guide par étapes sur la validation de votre intégration une fois celle-ci terminée, consultez la page Workflow d'intégration pour les développeurs d'Engage.

Questions fréquentes

Pour en savoir plus, consultez les questions fréquentes concernant le SDK Engage.

Contact

Contact engage-developers@google.com s'il y a toute question pendant le processus d'intégration.

Étapes suivantes

Une fois cette intégration effectuée, procédez comme suit :

• Envoyer un e-mail à engage-developers@google.com et et joignez votre APK intégré prêt à être testé par Google.
• Google effectue une vérification et des examens en interne pour s'assurer que l'intégration fonctionne comme prévu. Si des modifications sont nécessaires, nous vous contacterons avec toutes les informations nécessaires.
• Une fois les tests terminés et qu'aucune modification n'est nécessaire, Google vous contacte au vous informer que vous pouvez commencer à publier le fichier APK mis à jour et intégré dans sur le Play Store.
• Une fois que nous aurons confirmé la publication de votre APK mis à jour sur le Play Store, vos clusters Recommendation (Recommandations), Featured (Sélection) et Continuation (Suite) pourront être publiés et visibles par les utilisateurs.