Coinvolgi SDK Health and Fitness: istruzioni per l'integrazione tecnica di terze parti

Google sta creando una piattaforma on-device che organizza le app degli utenti per verticali e consente una nuova esperienza immersiva per la scoperta e il consumo di contenuti personalizzati delle app. Questa esperienza a schermo intero offre agli sviluppatori partner l'opportunità di mostrare i propri contenuti avanzati migliori in un canale dedicato al di fuori della loro app. Questa guida contiene le istruzioni per gli sviluppatori partner per integrare i propri contenuti relativi a salute e fitness, utilizzando l'SDK Engage per compilare questa nuova area.

Dettagli integrazione

Terminologia

Questa integrazione include i seguenti tre tipi di cluster: Recommendation, In primo piano e Continuazione.

• I cluster di consigli mostrano suggerimenti personalizzati su salute e fitness di un singolo sviluppatore partner. Questi consigli possono essere personalizzati in base all'utente o essere generalizzati (ad esempio, tendenze per fitness e salute). Usali per mettere in evidenza articoli o persone correlati a salute e fitness.

  • Un cluster di consigli può essere composto da ArticleEntity, PersonEntity o EventEntity, ma non da una combinazione di diversi tipi di entità.

  I consigli hanno la seguente struttura:

  • Gruppo di consigli: una visualizzazione dell'interfaccia utente che contiene un gruppo di consigli dello stesso sviluppatore partner.

  • Entità: un oggetto che rappresenta un singolo elemento in un cluster. Questa integrazione offre alcune entità che verrebbero visualizzate utilizzando il cluster di consigli:

    • ArticleEntity: rappresenta un consiglio per contenuti basati su testo correlati a salute e fitness. Può essere utilizzato per articoli, post del blog, contenuti di marketing, snippet di notizie e così via.

      

    • PersonEntity: PersonEntity rappresenta una persona. I consigli potrebbero essere finalizzati a mettere in evidenza un allenatore o qualsiasi persona legata a salute e fitness e così via.

      

    • EventEntity: EventEntity rappresenta un evento che si verifica nel futuro. L'ora di inizio dell'evento è un'informazione fondamentale che deve essere comunicata agli utenti. Questa entità potrebbe essere utilizzata per mostrare eventi come campi di donazione del sangue, sessioni di allenamento, palestra o corsi di yoga e così via, relativi a salute e fitness.

      

• Il cluster Continuazione mostra i contenuti con cui gli utenti di più sviluppatori partner hanno interagito di recente in un unico raggruppamento dell'interfaccia utente. Ogni sviluppatore partner potrà trasmettere un massimo di 10 entità nel cluster di continuazione.

  I contenuti continui possono avere la seguente struttura:

  • ArticleEntity: rappresenta un consiglio per contenuti basati su testo correlati a salute e fitness. Questa entità può essere utilizzata per rappresentare articoli di notizie incompleti o altri contenuti che l'utente vorrebbe continuare a consumare da dove li aveva interrotti. Esempio: snippet di notizie, snippet di post del blog su argomenti relativi a salute o fitness.

    

  • EventReservationEntity: EventReservationEntity rappresenta la prenotazione di un evento e aiuta gli utenti a monitorare le prenotazioni di eventi di fitness e salute imminenti o in corso. Esempio: sessioni di formazione

    

• Il cluster In primo piano mostra una selezione di entità di più partner di sviluppatori in un raggruppamento di UI. Ci sarà un singolo cluster in primo piano, visualizzato nella parte superiore dell'interfaccia utente con un posizionamento prioritario sopra tutti i cluster dei suggerimenti. Ogni sviluppatore partner potrà trasmettere fino a 10 entità nel cluster In primo piano.

  • GenericFeaturedEntity: GenericFeaturedEntity è diverso dall'elemento Recommendation in quanto l'elemento In primo piano deve essere utilizzato per un singolo contenuto di primo piano degli sviluppatori e deve rappresentare il singolo contenuto più importante che sarà interessante e pertinente per gli utenti.

    

Attività preliminare

Livello API minimo: 19

Aggiungi la raccolta com.google.android.engage:engage-core alla tua app:

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

Riepilogo

Il design si basa su un'implementazione di un servizio vincolato.

I dati che un client può pubblicare sono soggetti ai seguenti limiti per diversi tipi di cluster:

Passaggio 1: fornisci i dati delle entità

L'SDK ha definito diverse entità per rappresentare ogni tipo di elemento. Supportiamo le seguenti entità per la categoria Salute e fitness:

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

I grafici riportati di seguito illustrano gli attributi e i requisiti disponibili per ciascun tipo.

GenericFeaturedEntity

ArticleEntity

PersonEntity

EventEntity

EventReservationEntity

Specifiche per le immagini

Le specifiche richieste per gli asset immagine sono elencate in questa tabella:

Le immagini devono essere ospitate su CDN pubbliche per consentire a Google di accedervi.

Formati file

PNG, JPG, GIF statico, WebP

Dimensioni massime del file

5120 kB

Consigli aggiuntivi

• Area di sicurezza dell'immagine: inserisci i contenuti importanti al centro dell'immagine in modo da occuparne l'80%.
• Utilizza uno sfondo trasparente in modo che l'immagine possa essere visualizzata correttamente nelle impostazioni dei temi scuro e chiaro.

Categoria di contenuti

La categoria dei contenuti consente alle app di pubblicare contenuti appartenenti a più categorie. I contenuti vengono associati ad alcune delle categorie predefinite, ovvero:

• 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

Le immagini devono essere ospitate su CDN pubbliche per consentire a Google di accedervi.

Linee guida per l'utilizzo delle categorie di contenuti

1. Alcune entità, come ArticleEntity e GenericFeaturedEntity, sono idonee all'utilizzo di qualsiasi categoria di contenuti. Per altre entità come EventEntity, EventReservationEntity, PersonEntity, solo un sottoinsieme di queste categorie è idoneo. Controlla l'elenco delle categorie idonee per un tipo di entità prima di compilarlo.

2. Utilizza il tipo di entità specifico per alcune categorie di contenuti rispetto a una combinazione di entità Generic e ContentCategory:

   • TYPE_MOVIES_AND_TV_SHOWS: consulta le entità riportate nella guida all'integrazione di Watch prima di utilizzare le entità generiche.
   • TYPE_BOOKS: consulta EbookEntity prima di utilizzare le entità generiche.
   • TYPE_AUDIOBOOKS: consulta AudiobookEntity prima di utilizzare le entità generiche.
   • TYPE_SHOPPING: consulta ShoppingEntity prima di utilizzare le entità generiche.
   • TYPE_FOOD_AND_DRINK: consulta le entità della guida all'integrazione di Google Food prima di utilizzare le entità generiche.

3. Il campo ContentCategory è facoltativo e deve essere lasciato vuoto se i contenuti non appartengono a nessuna delle categorie sopra menzionate.

4. Se vengono fornite più categorie di contenuti, forniscile nell'ordine di pertinenza per i contenuti, con la categoria più pertinente posizionata prima nell'elenco.

Passaggio 2: fornisci i dati del cluster

Ti consigliamo di eseguire il job di pubblicazione dei contenuti in background (ad esempio utilizzando WorkManager) e di pianificarlo su base regolare o in base a un evento (ad esempio ogni volta che l'utente apre l'app o quando l'utente ha appena aggiunto un articolo al carrello).

AppEngagePublishClient è responsabile della pubblicazione dei cluster.

Esistono le seguenti API per pubblicare i cluster nel client:

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

isServiceAvailable

Questa API viene utilizzata per verificare se il servizio è disponibile per l'integrazione e se i contenuti possono essere presentati sul dispositivo.

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

Questa API viene utilizzata per pubblicare un elenco di oggetti 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());

Quando il servizio riceve la richiesta, all'interno di una transazione vengono eseguite le seguenti azioni:

• I dati esistenti relativi a RecommendationCluster dello sviluppatore partner verranno rimossi.
• I dati della richiesta vengono analizzati e archiviati nel cluster di consigli aggiornato.

In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente viene mantenuto.

publishFeaturedCluster

Questa API viene utilizzata per pubblicare un elenco di oggetti 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());

Quando il servizio riceve la richiesta, vengono eseguite le seguenti azioni all'interno di una transazione:

• I dati FeaturedCluster esistenti del partner sviluppatore vengono rimossi.
• I dati della richiesta vengono analizzati e archiviati nel cluster in primo piano aggiornato.

In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente viene mantenuto.

publishContinuationCluster

Questa API viene utilizzata per pubblicare un oggetto 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());

Quando il servizio riceve la richiesta, vengono eseguite le seguenti azioni all'interno di una transazione:

• I dati esistenti relativi a ContinuationCluster dello sviluppatore partner verranno rimossi.
• I dati della richiesta vengono analizzati e archiviati nel cluster di continuazione aggiornato.

In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente viene mantenuto.

publishUserAccountManagementRequest

Questa API viene utilizzata per pubblicare una scheda di accesso . L'azione di accesso indirizza gli utenti alla pagina di accesso dell'app in modo che l'app possa pubblicare contenuti (o fornire contenuti più personalizzati).

I seguenti metadati fanno parte della scheda Accedi:

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

Quando il servizio riceve la richiesta, vengono eseguite le seguenti azioni all'interno di una transazione:

• I dati UserAccountManagementCluster esistenti dello sviluppatore partner vengono rimossi.
• I dati della richiesta vengono analizzati e archiviati nel cluster aggiornato UserAccountManagementCluster.

In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente viene mantenuto.

updatePublishStatus

Se, per qualsiasi motivo aziendale interno, nessuno dei cluster viene pubblicato, ti consigliamo vivamente di aggiornare lo stato di pubblicazione utilizzando l'API updatepublishStatus. Questo è importante perché:

• Fornire lo stato in tutti gli scenari, anche quando i contenuti vengono pubblicati (STATO == PUBBLICATO), è fondamentale per compilare le dashboard che usano questo stato esplicito per comunicare lo stato di integrità e altre metriche dell'integrazione.
• Se non vengono pubblicati contenuti, ma lo stato dell'integrazione non è interrotto (STATUS == NOT_PUBLISHERED), Google può evitare di attivare avvisi nelle dashboard sullo stato dell'app. Conferma che i contenuti non vengono pubblicati a causa di una situazione prevedibile dal punto di vista del fornitore.
• Aiuta gli sviluppatori a fornire informazioni su quando i dati vengono pubblicati o meno.
• Google potrebbe utilizzare i codici di stato per indurre l'utente a eseguire determinate azioni nell'app in modo da poter vedere i contenuti dell'app o superarli.

L'elenco dei codici di stato di pubblicazione idonei è il seguente:

// 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

Se i contenuti non vengono pubblicati perché un utente non ha eseguito l'accesso, Google consiglia di pubblicare la scheda di accesso. Se per qualsiasi motivo i fornitori non sono in grado di pubblicare la scheda di accesso, consigliamo di chiamare l'API updatePublishStatus con il codice di stato 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

Questa API viene utilizzata per eliminare i contenuti dei cluster di consigli.

client.deleteRecommendationClusters()

client.deleteRecommendationClusters();

Quando il servizio riceve la richiesta, rimuove i dati esistenti dai gruppi di consigli. In caso di errore, l'intera richiesta viene rifiutata e viene mantenuto lo stato esistente.

deleteFeaturedCluster

Questa API viene utilizzata per eliminare i contenuti del cluster in primo piano.

client.deleteFeaturedCluster()

client.deleteFeaturedCluster();

Quando il servizio riceve la richiesta, rimuove i dati esistenti dal cluster in primo piano. In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente viene mantenuto.

deleteContinuationCluster

Questa API viene utilizzata per eliminare i contenuti del cluster di continuazione.

client.deleteContinuationCluster()

client.deleteContinuationCluster();

Quando il servizio riceve la richiesta, rimuove i dati esistenti dal cluster di continuazione. In caso di errore, l'intera richiesta viene rifiutata e viene mantenuto lo stato esistente.

deleteUserManagementCluster

Questa API viene utilizzata per eliminare i contenuti del cluster UserAccountManagement.

client.deleteUserManagementCluster()

client.deleteUserManagementCluster();

Quando il servizio riceve la richiesta, rimuove i dati esistenti dal cluster UserAccountManagement. In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente viene mantenuto.

deleteClusters

Questa API viene utilizzata per eliminare i contenuti di un determinato tipo di cluster.

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

Quando il servizio riceve la richiesta, rimuove i dati esistenti da tutti i cluster corrispondenti ai tipi di cluster specificati. I client possono scegliere di passare uno o più tipi di cluster. In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente viene mantenuto.

Gestione degli errori

Ti consigliamo vivamente di ascoltare il risultato dell'attività dalle API di pubblicazione in modo da poter intraprendere un'azione di follow-up per recuperare e inviare nuovamente un'attività riuscita.

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'errore viene restituito come AppEngageException e la causa è inclusa sotto forma di codice di errore.

Passaggio 3: gestisci gli intent di trasmissione

Oltre a effettuare chiamate API di pubblicazione dei contenuti tramite un job, è necessario anche configurare un BroadcastReceiver per ricevere la richiesta di pubblicazione dei contenuti.

Lo scopo degli intent di trasmissione è principalmente la riattivazione dell'app e l'applicazione forzata della sincronizzazione dei dati. Gli intent di trasmissione non sono progettati per essere inviati molto di frequente. Viene attivata solo quando il servizio Engage determina che i contenuti potrebbero essere obsoleti (ad esempio, risalenti a una settimana prima). In questo modo, è più sicura che l'utente possa usufruire di una nuova esperienza con i contenuti, anche se l'applicazione non è stata eseguita per un lungo periodo di tempo.

BroadcastReceiver deve essere configurato nei seguenti due modi:

• Registra in modo dinamico un'istanza della classe BroadcastReceiver utilizzando Context.registerReceiver(). In questo modo, viene attivata la comunicazione da applicazioni che sono ancora attive in memoria.

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

}

• Dichiarare in modo statico un'implementazione con il tag <receiver> nel file AndroidManifest.xml. In questo modo, l'applicazione può ricevere intent di trasmissione quando non è in esecuzione e pubblicare i contenuti.

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

I seguenti intent vengono inviati dal servizio:

• com.google.android.engage.action.PUBLISH_RECOMMENDATION È consigliabile avviare una chiamata publishRecommendationClusters quando si riceve questa intenzione.
• com.google.android.engage.action.PUBLISH_FEATURED Ti consigliamo di avviare una chiamata publishFeaturedCluster quando ricevi questo intent.
• com.google.android.engage.action.PUBLISH_CONTINUATION Ti consigliamo di avviare una chiamata publishContinuationCluster quando ricevi questo intent.

Flusso di lavoro di integrazione

Per una guida passo passo sulla verifica dell'integrazione al termine, consulta Flusso di lavoro di integrazione degli sviluppatori di Engage.

Domande frequenti

Consulta le Domande frequenti sull'SDK Engage per approfondire.

Contatto

Contatta engage-developers@google.com in caso di domande durante la procedura di integrazione.

Passaggi successivi

Dopo aver completato l'integrazione, i passaggi successivi sono i seguenti:

• Invia un'email all'indirizzo engagement-developers@google.com e allega l'APK integrato pronto per i test da parte di Google.
• Google esegue una verifica e delle revisioni interne per assicurarsi che l'integrazione funzioni come previsto. Se sono necessarie modifiche, Google ti contatta fornendoti i dettagli necessari.
• Al termine del test, se non sono necessarie modifiche, Google ti contatta per informarti che puoi iniziare a pubblicare l'APK aggiornato e integrato sul Play Store.
• Dopo che Google avrà confermato che l'APK aggiornato è stato pubblicato sul Play Store, i cluster Consiglio, In evidenza e Continuazione potrebbero essere pubblicati e visibili agli utenti.