Lettura SDK Engage: istruzioni per l'integrazione tecnica di terze parti

Aumenta il coinvolgimento con l'app raggiungendo i tuoi utenti ovunque si trovino. Integra l'SDK Engage per fornire suggerimenti personalizzati e contenuti in continuità direttamente agli utenti su più piattaforme on-device, come Raccolte, Entertainment Space e il Play Store. L'integrazione aggiunge meno di 50 KB (compressi) all'APK medio e richiede circa una settimana di lavoro per gli sviluppatori della maggior parte delle app. Scopri di più sul nostro sito aziendale.

Questa guida contiene istruzioni per i partner sviluppatori per fornire contenuti di lettura (ebook, audiolibri, fumetti/manga, blog, notizie e riviste) alle piattaforme di contenuti di Engage.

Supporto delle categorie e piattaforme

L'idoneità alla piattaforma dell'SDK Engage si basa sulla categoria di contenuti della tua app. Utilizza la tabella seguente per determinare la tua idoneità per piattaforme specifiche:

App di notizie

Le app di notizie forniscono contenuti diversi, ognuno soggetto a regole di idoneità uniche. Poiché i contenuti dell'SDK Engage sul Play Store sono in linea con gli strumenti di crescita premium di Play, gli articoli e i video clip delle app di notizie non sono idonei per il Play Store, anche se sono idonei per Raccolte ed Entertainment Space. Al contrario, i contenuti di notizie non tradizionali, come podcast e ricette, potrebbero essere idonei per il Play Store:

android skills add engage-sdk-integration

Dettaglio dell'integrazione

Questa sezione descrive i passaggi, i modelli di dati e la terminologia necessari per l'integrazione con l'SDK Engage per i contenuti di lettura.

Terminologia

Questa integrazione include i seguenti tre tipi di cluster: Contenuti consigliati, Continua e In primo piano.

• I cluster di contenuti consigliati mostrano suggerimenti personalizzati per i contenuti da leggere di un singolo partner sviluppatore.

  I suggerimenti hanno la seguente struttura:

  • Cluster di contenuti consigliati:una visualizzazione della UI che contiene un gruppo di contenuti consigliati di un singolo partner sviluppatore.

    

  • Entità: un oggetto che rappresenta un singolo elemento in un cluster. Un'entità può essere un ebook, un audiolibro, una serie di libri e altro ancora. Consulta la sezione Fornisci i dati delle entità per un elenco dei tipi di entità supportati.

    

• Il cluster Continua mostra i libri non terminati di più partner sviluppatori in un unico raggruppamento dell'interfaccia utente. Ogni partner sviluppatore potrà trasmettere un massimo di 10 entità nel cluster di continuazione.

  

• Il cluster In evidenza mostra una selezione di elementi di più partner sviluppatori in un unico raggruppamento dell'interfaccia utente. Ci sarà un unico cluster In evidenza, che viene visualizzato nella parte superiore della UI con un posizionamento prioritario sopra tutti i cluster di contenuti consigliati. Ogni partner sviluppatore potrà trasmettere fino a 10 entità nel cluster In evidenza.

  

Preparazione

Livello API minimo: 19

Aggiungi la libreria 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.6.0'
}

Riepilogo

Il design si basa sull'implementazione di un servizio associato.

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

Passaggio 1: fornisci i dati della persona giuridica

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

1. EbookEntity
2. AudiobookEntity
3. BookSeriesEntity

I seguenti grafici illustrano gli attributi e i requisiti disponibili per ogni tipo.

EbookEntity

L'oggetto EbookEntity rappresenta un ebook (ad esempio, l'ebook di Becoming di Michelle Obama).

AudiobookEntity

L'oggetto AudiobookEntity rappresenta un audiolibro (ad esempio, l'audiolibro di Becoming di Michelle Obama).

BookSeriesEntity

L'oggetto BookSeriesEntity rappresenta una serie di libri (ad esempio, la serie di libri di Harry Potter, che comprende 7 libri).

Specifiche per le immagini

La tabella seguente elenca le specifiche richieste per gli asset immagine:

Formati file

PNG, JPG, GIF statico, WebP

Dimensioni massime del file

5120 kB

Altri consigli

• Area di sicurezza per l'immagine:inserisci i contenuti importanti al centro dell'immagine in modo da occuparne l'80%.

Esempio

AudiobookEntity audiobookEntity =
        new AudiobookEntity.Builder()
            .setName("Becoming")
            .addPosterImage(
                      new Image.Builder()
                          .setImageUri(Uri.parse("http://www.x.com/image.png"))
                          .setImageHeightInPixel(960)
                          .setImageWidthInPixel(408)
                          .build())
            .addAuthor("Michelle Obama")
            .addNarrator("Michelle Obama")
            .setActionLinkUri(Uri.parse("https://play.google/audiobooks/1"))
            .setDurationMillis(16335L)
            .setPublishDateEpochMillis(1633032895L)
            .setDescription("An intimate, powerful, and inspiring memoir")
            .setPrice("$16.95")
            .addGenre("biography")
            .build();

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 regolarmente o in base a un evento (ad esempio ogni volta che l'utente apre l'app o quando ha appena aggiunto un articolo al carrello).

AppEngagePublishClient è responsabile dei cluster publisher. Nel client sono disponibili le seguenti API:

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

Per l'SDK Engage v1.6.0 e versioni successive (consigliato)

android skills add engage-sdk-integration

Use the engage-sdk-integration skill to use Engage SDK 1.6.0 and refactor isServiceAvailable to pass ServiceAvailabilityRequest for publishing all cluster types.

Puoi verificare la disponibilità del servizio per ogni tipo di cluster che intendi pubblicare. L'API isServiceAvailable accetta un oggetto di richiesta, ServiceAvailabilityRequest, che contiene i tipi di cluster per i quali deve essere verificata la disponibilità del servizio. Puoi trovare i valori enum ClusterType richiesti per ServiceAvailabilityRequest nella tabella seguente.

val request = ServiceAvailabilityRequest.Builder()
    .addIntendedClusterType(ClusterType.TYPE_CONTINUATION)
    .addIntendedClusterType(ClusterType.TYPE_RECOMMENDATION)
    .build()

client.isServiceAvailable(request).addOnCompleteListener { task ->
    if (task.isSuccessful) {
        val availabilityMap = task.result
        if (availabilityMap[ClusterType.TYPE_CONTINUATION] == true) {
            // Proceed with publishing continuation content
        }
        if (availabilityMap[ClusterType.TYPE_RECOMMENDATION] == true) {
            // Proceed with publishing recommendation content
        }
    } else {
        // The IPC call itself fails, proceed with error handling logic here,
        // such as retry.
    }
}

ServiceAvailabilityRequest request =
    new ServiceAvailabilityRequest.Builder()
        .addIntendedClusterType(ClusterType.TYPE_CONTINUATION)
        .addIntendedClusterType(ClusterType.TYPE_RECOMMENDATION)
        .build();

client.isServiceAvailable(request).addOnCompleteListener(task -> {
    if (task.isSuccessful()) {
        Map<Integer, Boolean> availabilityMap = task.getResult();
        if (Boolean.TRUE.equals(availabilityMap.get(ClusterType.TYPE_CONTINUATION))) {
            // Proceed with publishing continuation content
        }
        if (Boolean.TRUE.equals(availabilityMap.get(ClusterType.TYPE_RECOMMENDATION))) {
            // Proceed with publishing recommendation content
        }
    } else {
        // The IPC call itself fails, proceed with error handling logic here such as retry.
    }
});

Funzionalità di disponibilità del servizio condizionale

Alcune app integrate richiedono una configurazione speciale che attiva e disattiva il servizio Engage in modo intermittente per ridurre i costi di pubblicazione. Tuttavia, questa strategia di importazione di contenuti intermittente influisce negativamente sull'esperienza utente: i contenuti obsoleti non verranno presentati e alcune piattaforme non verranno pubblicate.

A partire dalla versione 1.6.0, l'SDK Engage consente di verificare la disponibilità di tipi di cluster specifici. Se la tua app utilizza l'importazione intermittente:

• I cluster di continuazione (come Continua a leggere) rimangono attivi per impostazione predefinita su tutti i dispositivi supportati.
• Altri tipi di cluster (come i suggerimenti) vengono attivati e disattivati a intermittenza.

Se questa configurazione predefinita non è adatta alle tue esigenze, contatta engage-developers@google.com.

Per le versioni dell'SDK precedenti alla 1.6.0 (ritirate)

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("Reconnect with yourself")
                        .build())
                .build())

client.publishRecommendationClusters(
            new PublishRecommendationClustersRequest.Builder()
                .addRecommendationCluster(
                    new RecommendationCluster.Builder()
                        .addEntity(entity1)
                        .addEntity(entity2)
                        .setTitle("Reconnect with yourself")
                        .build())
                .build());

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

• I dati RecommendationCluster esistenti del partner sviluppatore vengono rimossi.
• I dati della richiesta vengono analizzati e archiviati nel cluster di suggerimenti 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()
                        ...
                        .build())
                .build())

client.publishFeaturedCluster(
            new PublishFeaturedClusterRequest.Builder()
                .setFeaturedCluster(
                    new FeaturedCluster.Builder()
                        ...
                        .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(book_entity1)
                        .addEntity(book_entity2)
                        .build())
                .build())

client.publishContinuationCluster(
            PublishContinuationClusterRequest.Builder()
                .setContinuationCluster(
                    ContinuationCluster.Builder()
                        .addEntity(book_entity1)
                        .addEntity(book_entity2)
                        .build())
                .build())

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

• I dati ContinuationCluster esistenti del partner sviluppatore vengono 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 tessera 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 del partner sviluppatore vengono rimossi.
• I dati della richiesta vengono analizzati e archiviati nel cluster UserAccountManagementCluster aggiornato.

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

updatePublishStatus

Se per qualsiasi motivo aziendale interno non viene pubblicato nessuno dei cluster, 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 sono pubblicati (STATUS == PUBLISHED), è fondamentale per compilare le dashboard che utilizzano questo stato esplicito per comunicare l'integrità e altre metriche della tua integrazione.
• Se non vengono pubblicati contenuti, ma lo stato dell'integrazione non è interrotto (STATUS == NOT_PUBLISHED), Google può evitare di attivare avvisi nelle dashboard di integrità dell'app. Conferma che i contenuti non vengono pubblicati a causa di una situazione prevista dal punto di vista del fornitore.
• Aiuta gli sviluppatori a fornire informazioni su quando i dati vengono pubblicati e quando no.
• Google potrebbe utilizzare i codici di stato per invitare l'utente a eseguire determinate azioni nell'app in modo che possa visualizzare i contenuti dell'app o superare il problema.

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

deleteRecommendationsClusters

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

client.deleteRecommendationsClusters()

client.deleteRecommendationsClusters();

Quando il servizio riceve la richiesta, rimuove i dati esistenti dai 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 evidenza.

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 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 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_FEATURED)
      .addClusterType(ClusterType.TYPE_RECOMMENDATION)
      ...
      .build())

client.deleteClusters(
            new DeleteClustersRequest.Builder()
                .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(
              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 codice di errore.

Passaggio 3: gestisci gli intent di trasmissione

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

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

BroadcastReceiver deve essere configurato nei seguenti due modi:

• Registra dinamicamente un'istanza della classe BroadcastReceiver utilizzando Context.registerReceiver(). In questo modo, le applicazioni ancora attive in memoria possono comunicare.

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),
                           com.google.android.engage.service.BroadcastReceiverPermissions.BROADCAST_REQUEST_DATA_PUBLISH_PERMISSION,
                           /*scheduler=*/null)

// Register Featured Cluster Publish Intent
  context.registerReceiver(AppEngageBroadcastReceiver(),
                           IntentFilter(Intents.ACTION_PUBLISH_FEATURED),
                           com.google.android.engage.service.BroadcastReceiverPermissions.BROADCAST_REQUEST_DATA_PUBLISH_PERMISSION,
                           /*scheduler=*/null)

// Register Continuation Cluster Publish Intent
  context.registerReceiver(AppEngageBroadcastReceiver(),
                           IntentFilter(Intents.ACTION_PUBLISH_CONTINUATION),
                           com.google.android.engage.service.BroadcastReceiverPermissions.BROADCAST_REQUEST_DATA_PUBLISH_PERMISSION,
                           /*scheduler=*/null)
}

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),
                         com.google.android.engage.service.BroadcastReceiverPermissions.BROADCAST_REQUEST_DATA_PUBLISH_PERMISSION,
                         /*scheduler=*/null);

// Register Featured Cluster Publish Intent
context.registerReceiver(new AppEngageBroadcastReceiver(),
                         new IntentFilter(com.google.android.engage.service.Intents.ACTION_PUBLISH_FEATURED),
                         com.google.android.engage.service.BroadcastReceiverPermissions.BROADCAST_REQUEST_DATA_PUBLISH_PERMISSION,
                         /*scheduler=*/null);

// Register Continuation Cluster Publish Intent
context.registerReceiver(new AppEngageBroadcastReceiver(),
                         new IntentFilter(com.google.android.engage.service.Intents.ACTION_PUBLISH_CONTINUATION),
                         com.google.android.engage.service.BroadcastReceiverPermissions.BROADCAST_REQUEST_DATA_PUBLISH_PERMISSION,
                         /*scheduler=*/null);

}

• Dichiara staticamente 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 può anche pubblicare i contenuti.

<application>
   <receiver
      android:name=".AppEngageBroadcastReceiver"
      android:permission="com.google.android.engage.REQUEST_ENGAGE_DATA"
      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 verranno inviati dal servizio:

• com.google.android.engage.action.PUBLISH_RECOMMENDATION Ti consigliamo di avviare una chiamata publishRecommendationClusters quando ricevi questo intent.
• com.google.android.engage.action.PUBLISH_FEATURED Quando ricevi questo intent, ti consigliamo di avviare una chiamata publishFeaturedCluster.
• com.google.android.engage.action.PUBLISH_CONTINUATIONIt is recommended to start aChiamata publishContinuationCluster` quando ricevi questo intent.

Workflow di integrazione

Per una guida passo passo sulla verifica dell'integrazione una volta completata, consulta il flusso di lavoro di integrazione per gli sviluppatori di Engage.

Domande frequenti

Per le domande frequenti, consulta Domande frequenti sull'SDK Engage.

Contatto

Contatta engage-developers@google.com in caso di domande durante il processo di integrazione. Il nostro team ti risponderà il prima possibile.

Passaggi successivi

Dopo aver completato questa integrazione, i passaggi successivi sono i seguenti:

• Invia un'email all'indirizzo engage-developers@google.com e allega l'APK integrato pronto per essere testato da Google.
• Google eseguirà una verifica e una revisione interna per assicurarsi che l'integrazione funzioni come previsto. Se sono necessarie modifiche, Google ti contatterà con tutti i dettagli necessari.
• Al termine dei test, se non sono necessarie modifiche, Google ti contatterà per comunicarti 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 Contenuti consigliati, In evidenza e Continua verranno pubblicati e saranno visibili agli utenti.