Coinvolgi incontri con SDK: istruzioni per l'integrazione tecnica di terze parti

Google sta creando una piattaforma sul dispositivo che organizza app per verticali e consente una nuova esperienza immersiva per la fruizione personalizzata dei contenuti delle app e scoperta. Questa esperienza a schermo intero offre ai partner sviluppatori l'opportunità di mostrare i migliori contenuti avanzati in un canale dedicato esterno dell'app.Questa guida contiene istruzioni che aiutano gli sviluppatori partner a integrare i propri contenuti relativi agli incontri, utilizzando l'SDK Engage per completare questo nuovo in base all'area geografica.

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 per gli appuntamenti di un singolo sviluppatore partner. Questi consigli possono essere personalizzati per l'utente.

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

  I consigli hanno la seguente struttura:

  • Cluster dei suggerimenti:una visualizzazione UI che contiene un gruppo di contenuti consigliati dallo stesso partner di sviluppo.

  • Entità: un oggetto che rappresenta un singolo elemento in un cluster. Questo offre alcune entità che verrebbero scoperte utilizzando Cluster di suggerimenti:

    • ArticleEntity: ArticleEntity rappresenta una raccomandazione per contenuti testuali correlati agli incontri. Elemento ArticleEntity consente agli sviluppatori di fornire una varietà di contenuti di testo e immagini con più metadati per articolare le informazioni agli utenti.

      

    • PersonEntity: PersonEntity rappresenta una persona. La i consigli potrebbero essere quelli di mettere in evidenza una persona potenziali clienti.

      

    • EventEntity: EventEntity rappresenta un evento che si verifica nella per il futuro. L'ora di inizio dell'evento è un'informazione fondamentale che deve essere comunicato agli utenti.

      

• Il cluster Continuazione mostra i contenuti recentemente coinvolti dagli utenti di più sviluppatori partner in un unico raggruppamento di UI. Ogni sviluppatore partner potranno trasmettere un massimo di 10 entità nella continua in un cluster Kubernetes.

  I contenuti continui possono avere la seguente struttura:

  • ArticleEntity: ArticleEntity rappresenta una raccomandazione per contenuti testuali correlati agli incontri. Questa entità può essere utilizzata per rappresentare articoli da completare o altri contenuti che l'utente potrebbe continuare a consumare dal punto in cui l'aveva lasciata.

    

  • EventReservationEntity: EventReservationEntity rappresenta per un evento e aiuta gli utenti a monitorare quelli in programma o in corso prenotazioni di incontri e incontri.

    

• Il cluster In primo piano è una visualizzazione UI che mostra l'hero scelto GenericFeaturedEntity di molti sviluppatori partner in un unico raggruppamento della UI. È presente un singolo cluster in primo piano, che viene visualizzato vicino alla parte superiore UI, con un posizionamento prioritario sopra tutti i cluster dei suggerimenti. Ciascuna il partner di sviluppo è autorizzato a trasmettere una singola entità di un elemento supportato di digitare in In primo piano, con molte entità (potenzialmente di tipo diverso) da più sviluppatori di app nel cluster In primo piano.

  • GenericFeatureEntity: GenericFeatureEntity è diverso da L'elemento consiglio in quell'elemento in primo piano deve essere utilizzato per un singolo i contenuti principali degli sviluppatori e dovrebbero rappresentare contenuti importanti che siano interessanti e pertinenti 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

La progettazione si basa sull'implementazione di uno servizio associato.

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

Passaggio 1: fornisci i dati dell'entità

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

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

I grafici riportati di seguito descrivono gli attributi e i requisiti disponibili per ogni tipo.

GenericFeaturedEntity

ArticleEntity

PersonEntity

EventEntity

EventReservationEntity

Specifiche per le immagini

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

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

Formati file

PNG, JPG, GIF statica, WebP

Dimensioni massime del file

5120 kB

Consigli aggiuntivi

• Area di sicurezza dell'immagine:inserisci i contenuti importanti al centro dell'80% della sezione dell'immagine.
• Utilizza uno sfondo trasparente per consentire una corretta visualizzazione dell'immagine Impostazioni tema scuro e chiaro.

Categoria di contenuti

La categoria di contenuti consente alle app di pubblicare contenuti appartenenti a più categorie categorie. In questo modo i contenuti vengono mappati con 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 che li rappresentano.

Linee guida per l'utilizzo delle categorie di contenuti

1. Alcune entità come ArticleEntity e GenericFeatureEntity sono idonei all'utilizzo di una qualsiasi delle categorie di contenuti. Per altre entità come EventEntity, EventReservationEntity, PersonEntity, solo un sottoinsieme di queste categorie sono idonee. Consulta l'elenco delle categorie idonee per un tipo di entità prima di compilare l'elenco.

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

   • TYPE_MovieS_AND_TV_SHOWS. Controlla le entità di Guarda la guida all'integrazione prima di utilizzare il o entità generiche.
   • TYPE_BOOKS - Consulta EbookEntity prima di utilizzare o entità generiche.
   • TYPE_AUDIOBOOKS - Pagamento AudiobookEntity prima del giorno utilizzando le entità generiche.
   • TYPE_SHOPPING - Pagamento ShoppingEntity prima del giorno utilizzando le entità generiche.
   • TYPE_FOOD_AND_DRINK - Controlla le entità di Guida all'integrazione alimentare prima di utilizzare la o entità generiche.

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

4. Nel caso in cui vengano fornite più categorie di contenuti, indicale nell'ordine indicato della pertinenza rispetto ai contenuti con la categoria di contenuti più pertinente per primo 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 pianificato con cadenza regolare o evento (ad esempio, ogni volta l'utente apre l'app o quando ha appena aggiunto qualcosa al carrello).

AppEngagePublishClient è responsabile della pubblicazione dei cluster.

Esistono le API seguenti 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, vengono eseguite le seguenti azioni: una transazione:

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

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

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: una transazione:

• I dati esistenti relativi a FeaturedCluster dello sviluppatore partner verranno 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 viene mantenuta.

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: una transazione:

• I dati esistenti relativi a ContinuationCluster dello sviluppatore partner verranno rimossi.
• I dati della richiesta vengono analizzati e archiviati nella continuazione aggiornata di un cluster Kubernetes.

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

publishUserAccountManagementRequest

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

I seguenti metadati fanno parte della scheda di accesso:

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: una transazione:

• I dati di UserAccountManagementCluster esistenti dallo sviluppatore partner sono rimosso.
• I dati della richiesta vengono analizzati e archiviati nel Cluster UserAccountManagementCluster.

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

updatePublishStatus

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

• Indicare lo stato in tutti gli scenari, anche quando i contenuti vengono pubblicati (STATO == PUBBLICATO), è fondamentale per compilare le dashboard che utilizzano questo stato esplicito per comunicare lo stato di integrità e altre metriche della tua integrazione.
• Se non sono stati pubblicati contenuti, ma lo stato dell'integrazione non funziona (STATUS == NOT_PUBLISHERED), Google può evitare di attivare avvisi nell'app dashboard dell'integrità. Conferma che i contenuti non sono stati pubblicati a causa di un situazione prevista dal punto di vista del provider.
• Consente agli sviluppatori di capire quando i dati vengono pubblicati e quando .
• Google potrebbe utilizzare i codici di stato per sollecitare l'utente a eseguire determinate azioni in dell'app in modo da poter vedere o risolvere i contenuti dell'app.

Ecco un elenco di codici di stato idonei per la pubblicazione :

// 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, consigliamo di pubblicare la scheda di accesso. Se, per qualsiasi motivo, i fornitori non riescono per pubblicare la scheda di accesso, ti consigliamo di chiamare il API updatePubblicaStatus con il codice di stato NOT_PUBLISHERED_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 dei suggerimenti.

client.deleteRecommendationClusters()

client.deleteRecommendationClusters();

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

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 Cluster in primo piano. In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente.

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 Cluster di continuazione. In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente viene mantenuto.

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 Cluster UserAccountManagement. In caso di errore, l'intera richiesta viene viene rifiutato 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 corrispondenti ai tipi di cluster specificati. I clienti possono scegliere di superare uno o per molti tipi di cluster. In caso di errore, l'intera richiesta viene rifiutata e lo stato esistente.

Gestione degli errori

Ti consigliamo vivamente di ascoltare il risultato dell'attività dalle API di pubblicazione, ad esempio che è possibile eseguire 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 con la causa inclusa come un codice di errore.

Passaggio 3: gestisci gli intent di trasmissione

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

L'obiettivo degli intent di trasmissione è principalmente la riattivazione dell'app e l'applicazione forzata dei dati sincronizzare. Gli intent di trasmissione non sono progettati per essere inviati molto spesso. È solo attivata quando il servizio Engage stabilisce che i contenuti potrebbero essere obsoleti (ad esempio, una settimana fa). In questo modo, l'utente può avere una maggiore sicurezza nuova esperienza con i contenuti, anche se l'applicazione non è stata eseguita per per un lungo periodo di tempo.

BroadcastReceiver deve essere configurato nei due modi seguenti:

• Registra dinamicamente un'istanza della classe BroadcastReceiver utilizzando Context.registerReceiver(). Ciò consente la comunicazione dalle applicazioni ancora 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 tuo AndroidManifest.xml file. Ciò consente all'applicazione di ricevere annunci quando non è in esecuzione e consente inoltre all'applicazione di pubblicare dei 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 servizio:

• com.google.android.engage.action.PUBLISH_RECOMMENDATION È consigliato per avviare una chiamata publishRecommendationClusters quando ricevi questo intent.
• com.google.android.engage.action.PUBLISH_FEATURED È consigliabile avvia una chiamata publishFeaturedCluster quando ricevi questo intent.
• com.google.android.engage.action.PUBLISH_CONTINUATION È consigliabile avvia una chiamata publishContinuationCluster quando ricevi questo intent.

Flusso di lavoro di integrazione

Per una guida passo passo sulla verifica dell'integrazione dopo il suo completamento, consulta Flusso di lavoro per l'integrazione degli sviluppatori del coinvolgimento.

Domande frequenti

Consulta le domande frequenti sull'SDK Engage per Domande frequenti.

Contatto

Contatto engagement-developers@google.com se ci sono a eventuali domande durante il processo di integrazione.

Passaggi successivi

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

• Invia un'email a engagement-developers@google.com e Allega l'APK integrato pronto per i test da parte di Google.
• Google esegue una verifica ed esamina internamente per assicurarsi che che funzioni come previsto. Se sono necessarie modifiche, Google ti contatta con tutti i dettagli necessari.
• Quando il test è stato completato e non sono necessarie modifiche, Google ti contatta per ti comunicherà che puoi iniziare a pubblicare l'APK aggiornato e integrato per dal Play Store.
• Dopo che Google avrà confermato la pubblicazione dell'APK aggiornato su Play Store, il tuo Consiglio, In primo piano e Continuazione possono essere pubblicati ed essere visibili agli utenti.