Engage SDK Watch: तीसरे पक्ष के तकनीकी इंटिग्रेशन के निर्देश

Google, डिवाइस पर एक ऐसा प्लैटफ़ॉर्म बना रहा है जो उपयोगकर्ताओं के ऐप्लिकेशन को वर्टिकल के हिसाब से व्यवस्थित करता है. साथ ही, ऐप्लिकेशन के कॉन्टेंट को उपयोगकर्ताओं के हिसाब से इस्तेमाल करने और खोजने के लिए, एक नया अनुभव देता है. फ़ुलस्क्रीन वाला यह अनुभव, डेवलपर पार्टनर को अपने ऐप्लिकेशन के बाहर, किसी खास चैनल पर अपना सबसे अच्छा रिच कॉन्टेंट दिखाने का अवसर देता है.

इस गाइड में, डेवलपर पार्टनर के लिए निर्देश दिए गए हैं. इन निर्देशों की मदद से, वे Engage SDK टूल का इस्तेमाल करके अपने वीडियो कॉन्टेंट को इंटिग्रेट कर सकते हैं. इससे, इस नए प्लैटफ़ॉर्म और Google के मौजूदा प्लैटफ़ॉर्म, दोनों पर वीडियो दिखाए जा सकते हैं.

इंटिग्रेशन की जानकारी

शब्दावली

इस इंटिग्रेशन में तीन तरह के क्लस्टर शामिल हैं: सुझाव, जारी रखना, और चुनिंदा.

• सुझाव क्लस्टर, किसी डेवलपर पार्टनर के कॉन्टेंट के लिए, आपके हिसाब से सुझाव दिखाते हैं.

  आपके सुझावों का स्ट्रक्चर इस तरह का होता है:

  • सुझाव क्लस्टर: एक यूज़र इंटरफ़ेस (यूआई) व्यू, जिसमें एक ही डेवलपर पार्टनर के सुझावों का ग्रुप होता है.

    

  • इकाई: क्लस्टर में किसी एक आइटम को दिखाने वाला ऑब्जेक्ट. इकाई, एक फ़िल्म, टीवी शो, टीवी सीरीज़, लाइव वीडियो वगैरह हो सकती है. इकाई के काम करने वाले टाइप की सूची देखने के लिए, इकाई का डेटा दें सेक्शन देखें.

    

• जारी रखें क्लस्टर, एक यूज़र इंटरफ़ेस (यूआई) ग्रुपिंग में कई डेवलपर पार्टनर के अधूरे वीडियो और हाल ही में रिलीज़ किए गए काम के एपिसोड दिखाता है. हर डेवलपर पार्टनर को, जारी रखने वाले क्लस्टर में ज़्यादा से ज़्यादा 10 इकाइयां ब्रॉडकास्ट करने की अनुमति होगी. रिसर्च से पता चला है कि उपयोगकर्ताओं के हिसाब से सुझावों के साथ-साथ, उनके हिसाब से कॉन्टेंट जारी रखने की सुविधा, उपयोगकर्ताओं के जुड़ाव को बढ़ाती है.

  

• चुनिंदा क्लस्टर में, एक यूज़र इंटरफ़ेस ग्रुपिंग में कई डेवलपर पार्टनर की चुनिंदा इकाइयां दिखती हैं. इसमें एक हाइलाइट किया गया क्लस्टर होगा. यह यूज़र इंटरफ़ेस (यूआई) के सबसे ऊपर दिखेगा. साथ ही, सुझाव वाले सभी क्लस्टर के ऊपर प्राथमिकता के तौर पर दिखेगा. हर डेवलपर पार्टनर को चुनिंदा क्लस्टर में, ज़्यादा से ज़्यादा 10 इकाइयों का ब्रॉडकास्ट करने की अनुमति होगी.

  

सेशन की तैयारी

कम से कम एपीआई लेवल: 19

अपने ऐप्लिकेशन में com.google.android.engage:engage-core लाइब्रेरी जोड़ें:

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

ज़्यादा जानकारी के लिए, Android 11 में पैकेज की जानकारी दिखने की सुविधा देखें.

खास जानकारी

यह डिज़ाइन, ज़रूरी सेवा को लागू करने के हिसाब से बनाया गया है.

क्लाइंट, अलग-अलग क्लस्टर टाइप के लिए, यहां दी गई सीमाओं के हिसाब से डेटा पब्लिश कर सकता है:

पहला चरण: मौजूदा मीडिया होम SDK टूल के इंटिग्रेशन से डेटा दूसरी जगह भेजना

मौजूदा इंटिग्रेशन से डेटा मॉडल मैप करना

अगर आपको किसी मौजूदा मीडिया होम इंटिग्रेशन से माइग्रेट करना है, तो नीचे दी गई टेबल में बताया गया है कि मौजूदा SDK टूल में मौजूद डेटा मॉडल को नए Engage SDK टूल पर कैसे मैप किया जा सकता है:

Media Home SDK बनाम Engage SDK में पब्लिशिंग क्लस्टर

Media Home SDK की मदद से, क्लस्टर और इकाइयों को अलग-अलग एपीआई के ज़रिए पब्लिश किया जाता था:

// 1. Fetch existing channels
List<PreviewChannel> channels = PreviewChannelHelper.getAllChannels();

// 2. If there are no channels, publish new channels
long channelId = PreviewChannelHelper.publishChannel(builder.build());

// 3. If there are existing channels, decide whether to update channel contents
PreviewChannelHelper.updatePreviewChannel(channelId, builder.build());

// 4. Delete all programs in the channel
PreviewChannelHelper.deleteAllPreviewProgramsByChannelId(channelId);

// 5. publish new programs in the channel
PreviewChannelHelper.publishPreviewProgram(builder.build());

Engage SDK टूल की मदद से, क्लस्टर और इकाई पब्लिश करने की प्रोसेस को एक ही एपीआई कॉल में जोड़ा जाता है. किसी क्लस्टर से जुड़ी सभी इकाइयां, उस क्लस्टर के साथ पब्लिश की जाती हैं:

RecommendationCluster.Builder()
            .addEntity(MOVIE_ENTITY)
            .addEntity(MOVIE_ENTITY)
            .addEntity(MOVIE_ENTITY)
            .setTitle("Top Picks For You")
            .build()

new RecommendationCluster.Builder()
                        .addEntity(MOVIE_ENTITY)
                        .addEntity(MOVIE_ENTITY)
                        .addEntity(MOVIE_ENTITY)
                        .setTitle("Top Picks For You")
                        .build();

पहला चरण: इकाई का डेटा देना

SDK ने हर तरह के आइटम को दिखाने के लिए, अलग-अलग इकाइयां तय की हैं. 'वॉच' कैटगरी के लिए, ये इकाइयां काम करती हैं:

1. MovieEntity
2. TvShowEntity
3. TvSeasonEntity
4. TvEpisodeEntity
5. LiveStreamingVideoEntity
6. VideoClipEntity

नीचे दिए गए चार्ट में, हर तरह के एट्रिब्यूट और उनसे जुड़ी ज़रूरी शर्तों के बारे में बताया गया है.

MovieEntity

TvShowEntity

TvSeasonEntity

TvEpisodeEntity

LiveStreamingVideoEntity

VideoClipEntity

VideoClipEntity ऑब्जेक्ट, सोशल मीडिया से आने वाली वीडियो इकाई को दिखाता है. जैसे, TikTok या YouTube.

इमेज की जानकारी

नीचे दिए गए सेक्शन में, इमेज ऐसेट के लिए ज़रूरी जानकारी दी गई है:

फ़ाइल फ़ॉर्मैट

PNG, JPG, स्टैटिक GIF, WebP

फ़ाइल का ज़्यादा से ज़्यादा साइज़

5120 केबी

अतिरिक्त सुझाव

• इमेज के लिए सेफ़ एरिया: अपने मुख्य कॉन्टेंट को इमेज के बीच वाले 80% हिस्से में रखें.

उदाहरण

var movie = MovieEntity.Builder()
    .setName("Avengers")
    .addPosterImage(Image.Builder()
                          .setImageUri(Uri.parse("http://www.x.com/image.png"))
                          .setImageHeightInPixel(960)
                          .setImageWidthInPixel(408)
                          .build())
    .setPlayBackUri(Uri.parse("http://tv.com/playback/1"))
    .setReleaseDateEpochMillis(1633032895L)
    .setAvailability(ContentAvailability.AVAILABILITY_AVAILABLE)
    .setDurationMillis(12345678L)
    .addGenre("action")
    .addContentRating("R")
    .setWatchNextType(WatchNextType.TYPE_NEW)
    .setLastEngagementTimeMillis(1664568895L)
    .build()

MovieEntity movie = new MovieEntity.Builder()
                  .setName("Avengers")
                  .addPosterImage(
                      new Image.Builder()
                          .setImageUri(Uri.parse("http://www.x.com/image.png"))
                          .setImageHeightInPixel(960)
                          .setImageWidthInPixel(408)
                          .build())
                  .setPlayBackUri(Uri.parse("http://tv.com/playback/1"))
                  .setReleaseDateEpochMillis(1633032895L)
                  .setAvailability(ContentAvailability.AVAILABILITY_AVAILABLE)
                  .setDurationMillis(12345678L)
                  .addGenre("action")
                  .addContentRating("R")
                  .setWatchNextType(WatchNextType.TYPE_NEW)
                  .setLastEngagementTimeMillis(1664568895L)
                  .build();

दूसरा चरण: क्लस्टर डेटा उपलब्ध कराना

हमारा सुझाव है कि बैकग्राउंड में कॉन्टेंट पब्लिश करने का काम बैकग्राउंड में लागू करें (उदाहरण के लिए, WorkManager का इस्तेमाल करके) और उसे नियमित तौर पर या इवेंट के हिसाब से शेड्यूल किया जाना चाहिए (जैसे, हर बार जब उपयोगकर्ता ऐप्लिकेशन खोलता है या जब उपयोगकर्ता अपने कार्ट में कुछ जोड़ता है).

क्लस्टर पब्लिश करने की ज़िम्मेदारी AppEngagePublishClient की है. क्लाइंट में ये एपीआई उपलब्ध हैं:

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

isServiceAvailable

इस एपीआई का इस्तेमाल यह देखने के लिए किया जाता है कि सेवा, इंटिग्रेशन के लिए उपलब्ध है या नहीं और डिवाइस पर कॉन्टेंट दिखाया जा सकता है या नहीं.

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

इस एपीआई का इस्तेमाल, 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());

जब सेवा को अनुरोध मिलता है, तो एक ही लेन-देन में ये कार्रवाइयां होती हैं:

• डेवलपर पार्टनर का मौजूदा RecommendationCluster डेटा हटा दिया जाता है.
• अनुरोध के डेटा को पार्स किया जाता है और अपडेट किए गए सुझाव क्लस्टर में सेव किया जाता है.

गड़बड़ी होने पर, पूरा अनुरोध अस्वीकार कर दिया जाता है और मौजूदा स्थिति को बनाए रखा जाता है.

publishFeaturedCluster

इस एपीआई का इस्तेमाल, 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());

जब सेवा को अनुरोध मिलता है, तो एक ही लेन-देन में ये कार्रवाइयां होती हैं:

• डेवलपर पार्टनर से मिला, FeaturedCluster का मौजूदा डेटा हटा दिया जाता है.
• अनुरोध से मिले डेटा को पार्स करके, अपडेट किए गए हाइलाइट किए गए क्लस्टर में सेव किया जाता है.

गड़बड़ी होने पर, पूरा अनुरोध अस्वीकार कर दिया जाता है और मौजूदा स्थिति को बनाए रखा जाता है.

publishContinuationCluster

इस एपीआई का इस्तेमाल, 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());

जब सेवा को अनुरोध मिलता है, तो एक ही लेन-देन में ये कार्रवाइयां होती हैं:

• डेवलपर पार्टनर का मौजूदा ContinuationCluster डेटा हटा दिया जाता है.
• अनुरोध से मिले डेटा को पार्स करके, अपडेट किए गए कंटिन्यूएशन क्लस्टर में सेव किया जाता है.

गड़बड़ी होने पर, पूरा अनुरोध अस्वीकार कर दिया जाता है और मौजूदा स्थिति को बनाए रखा जाता है.

publishUserAccountManagementRequest

इस एपीआई का इस्तेमाल, साइन इन कार्ड पब्लिश करने के लिए किया जाता है. साइन इन ऐक्शन, उपयोगकर्ताओं को ऐप्लिकेशन के साइन इन पेज पर ले जाता है, ताकि ऐप्लिकेशन कॉन्टेंट पब्लिश कर सके (या ज़्यादा पसंद के मुताबिक कॉन्टेंट उपलब्ध करा सके)

यहां दिया गया मेटाडेटा, साइन इन कार्ड का हिस्सा है -

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

जब सेवा को अनुरोध मिलता है, तो एक ही लेन-देन में ये कार्रवाइयां होती हैं:

• डेवलपर पार्टनर का मौजूदा UserAccountManagementCluster डेटा हटा दिया जाता है.
• अनुरोध से मिले डेटा को पार्स करके, अपडेट किए गए UserAccountManagementCluster क्लस्टर में सेव किया जाता है.

गड़बड़ी होने पर, पूरा अनुरोध अस्वीकार कर दिया जाता है और मौजूदा स्थिति को बनाए रखा जाता है.

updatePublishStatus

अगर किसी अंदरूनी कारोबारी वजह से, कोई भी क्लस्टर पब्लिश नहीं किया गया है, तो हमारा सुझाव है कि आप updatepublishStatus एपीआई का इस्तेमाल करके, प्रकाशन की स्थिति अपडेट करें. ऐसा इसलिए ज़रूरी है, क्योंकि :

• कॉन्टेंट पब्लिश होने के बाद भी, सभी स्थितियों में स्टेटस देना ज़रूरी है. (STATUS == पब्लिश किया गया). यह ऐसे डैशबोर्ड को पॉप्युलेट करने के लिए ज़रूरी है जो आपके इंटिग्रेशन की हेल्थ और अन्य मेट्रिक के बारे में साफ़ तौर पर जानकारी देते हैं.
• अगर कोई कॉन्टेंट पब्लिश नहीं किया गया है, लेकिन इंटिग्रेशन का स्टेटस ठीक है (STATUS == NOT_PUBLISHED), तो Google, ऐप्लिकेशन की परफ़ॉर्मेंस के डैशबोर्ड में सूचनाएं ट्रिगर करने से बच सकता है. इससे यह पुष्टि होती है कि कॉन्टेंट, कॉन्टेंट उपलब्ध कराने वाली कंपनी के हिसाब से, उम्मीद के मुताबिक स्थिति की वजह से पब्लिश नहीं किया गया है.
• इससे डेवलपर को यह जानकारी देने में मदद मिलती है कि डेटा कब पब्लिश किया गया है और कब नहीं.
• Google, उपयोगकर्ता को ऐप्लिकेशन में कुछ कार्रवाइयां करने के लिए कहने के लिए, स्टेटस कोड का इस्तेमाल कर सकता है. इससे वह ऐप्लिकेशन का कॉन्टेंट देख सकता है या उससे समस्या को हल कर सकता है.

पब्लिश करने की स्थिति के कोड की सूची यहां दी गई है:

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

अगर उपयोगकर्ता के लॉग इन न करने की वजह से कॉन्टेंट पब्लिश नहीं होता है, तो Google, साइन इन कार्ड पब्लिश करने का सुझाव देगा. अगर किसी भी वजह से, सेवा देने वाली कंपनियां साइन इन कार्ड पब्लिश नहीं कर पा रही हैं, तो हमारा सुझाव है कि वे updatePublishStatus एपीआई को कॉल करें. इसके लिए, स्टेटस कोड 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

इस एपीआई का इस्तेमाल, सुझाव क्लस्टर का कॉन्टेंट मिटाने के लिए किया जाता है.

client.deleteRecommendationClusters()

client.deleteRecommendationClusters();

जब किसी सेवा को अनुरोध मिलता है, तो वह सुझाव क्लस्टर से मौजूदा डेटा को हटा देती है. गड़बड़ी होने पर, पूरा अनुरोध अस्वीकार कर दिया जाता है और मौजूदा स्थिति में कोई बदलाव नहीं किया जाता.

deleteFeaturedCluster

इस एपीआई का इस्तेमाल, हाइलाइट किए गए क्लस्टर का कॉन्टेंट मिटाने के लिए किया जाता है.

client.deleteFeaturedCluster()

client.deleteFeaturedCluster();

अनुरोध मिलने पर, यह सेवा 'चुनिंदा क्लस्टर' से मौजूदा डेटा हटा देती है. गड़बड़ी होने पर, पूरा अनुरोध अस्वीकार कर दिया जाता है और मौजूदा स्थिति में कोई बदलाव नहीं किया जाता.

deleteContinuationCluster

इस एपीआई का इस्तेमाल, कंटिन्यूएशन क्लस्टर का कॉन्टेंट मिटाने के लिए किया जाता है.

client.deleteContinuationCluster()

client.deleteContinuationCluster();

जब सेवा को अनुरोध मिलता है, तो वह 'जारी रखने वाले क्लस्टर' से मौजूदा डेटा हटा देती है. गड़बड़ी होने पर, पूरा अनुरोध अस्वीकार कर दिया जाता है और मौजूदा स्थिति में कोई बदलाव नहीं किया जाता.

deleteUserManagementCluster

इस एपीआई का इस्तेमाल, UserAccountManagement क्लस्टर का कॉन्टेंट मिटाने के लिए किया जाता है.

client.deleteUserManagementCluster()

client.deleteUserManagementCluster();

जब सेवा को अनुरोध मिलता है, तो वह UserAccountManagement क्लस्टर से मौजूदा डेटा को हटा देती है. गड़बड़ी होने पर, पूरा अनुरोध अस्वीकार कर दिया जाता है और मौजूदा स्थिति में कोई बदलाव नहीं किया जाता.

deleteClusters

इस एपीआई का इस्तेमाल, किसी क्लस्टर टाइप का कॉन्टेंट मिटाने के लिए किया जाता है.

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

जब सेवा को अनुरोध मिलता है, तो वह बताए गए अलग-अलग तरह के क्लस्टर से मेल खाने वाले सभी क्लस्टर से मौजूदा डेटा हटा देती है. क्लाइंट एक या कई तरह के क्लस्टर पास कर सकते हैं. गड़बड़ी होने पर, पूरा अनुरोध अस्वीकार कर दिया जाता है और मौजूदा स्थिति में कोई बदलाव नहीं किया जाता.

गड़बड़ी ठीक करना

हमारा सुझाव है कि पब्लिश करने वाले एपीआई से टास्क के नतीजे को सुनें, ताकि किसी टास्क को फिर से सबमिट करने और उसे वापस पाने के लिए, फ़ॉलो-अप कार्रवाई की जा सके.

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

गड़बड़ी को AppEngageException के तौर पर दिखाया जाता है. इसकी वजह को गड़बड़ी के कोड के तौर पर शामिल किया जाता है.

तीसरा चरण: ब्रॉडकास्ट इंटेंट मैनेज करना

किसी जॉब के ज़रिए कॉन्टेंट पब्लिश करने के लिए Content API कॉल करने के अलावा, कॉन्टेंट पब्लिश करने का अनुरोध पाने के लिए, BroadcastReceiver सेट अप करना भी ज़रूरी है.

ब्रॉडकास्ट इंटेंट का मकसद, मुख्य रूप से ऐप्लिकेशन को फिर से चालू करना और डेटा को सिंक करना है. ब्रॉडकास्ट इंटेंट को बार-बार भेजने के लिए डिज़ाइन नहीं किया गया है. यह सिर्फ़ तब ट्रिगर होता है, जब Engage Service यह तय करती है कि कॉन्टेंट पुराना हो सकता है. उदाहरण के लिए, एक हफ़्ते पुराना. इससे यह भरोसा बढ़ता है कि उपयोगकर्ता को नया कॉन्टेंट दिखेगा, भले ही ऐप्लिकेशन को लंबे समय से इस्तेमाल न किया गया हो.

BroadcastReceiver को इन दो तरीकों से सेट अप करना होगा:

• Context.registerReceiver() का इस्तेमाल करके, BroadcastReceiver क्लास के इंस्टेंस को डाइनैमिक तौर पर रजिस्टर करें. इससे, उन ऐप्लिकेशन से कम्यूनिकेशन की सुविधा चालू हो जाती है जो अब भी मेमोरी में मौजूद हैं.

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

}

• अपनी AndroidManifest.xml फ़ाइल में, <receiver> टैग के साथ लागू करने का एलान करें. इससे ऐप्लिकेशन को ब्रॉडकास्ट के लिए भेजे गए इंटेंट तब भी मिल सकते हैं, जब वह ऐप्लिकेशन बंद हो. साथ ही, ऐप्लिकेशन को कॉन्टेंट पब्लिश करने की अनुमति भी मिलती है.

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

सेवा, ये इंटेंट भेजती है:

• com.google.android.engage.action.PUBLISH_RECOMMENDATION इस इंटेंट को मिलने पर, publishRecommendationClusters कॉल शुरू करने का सुझाव दिया जाता है.
• com.google.android.engage.action.PUBLISH_FEATURED हमारा सुझाव है कि इस मकसद के लिए, publishFeaturedCluster कॉल करें.
• com.google.android.engage.action.PUBLISH_CONTINUATION इस इंटेंट को मिलने पर, publishContinuationCluster कॉल शुरू करने का सुझाव दिया जाता है.

इंटिग्रेशन वर्कफ़्लो

इंटिग्रेशन पूरा हो जाने के बाद, उसकी पुष्टि करने के सिलसिलेवार निर्देश के लिए, डेवलपर इंटिग्रेशन का वर्कफ़्लो बढ़ाएं देखें.

अक्सर पूछे जाने वाले सवाल

अक्सर पूछे जाने वाले सवालों के लिए, Engage SDK के बारे में अक्सर पूछे जाने वाले सवाल देखें.

संपर्क

अगर इंटिग्रेशन की प्रोसेस के दौरान आपका कोई सवाल है, तो engage-developers@google.com पर संपर्क करें.

अगले चरण

इस इंटिग्रेशन को पूरा करने के बाद, आपको ये चरण पूरे करने होंगे:

• engage-developers@google.com पर ईमेल भेजें और Google से टेस्ट कराने के लिए, इंटिग्रेट किया गया अपना APK अटैच करें.
• Google, पुष्टि करने के लिए अंदरूनी तौर पर समीक्षा करता है, ताकि यह पक्का किया जा सके कि इंटिग्रेशन उम्मीद के मुताबिक काम कर रहा है. अगर बदलाव ज़रूरी हैं, तो Google आपसे संपर्क करेगा और ज़रूरी जानकारी देगा.
• जांच पूरी होने और कोई बदलाव न किए जाने पर, Google आपसे संपर्क करके यह सूचना देता है कि अपडेट किए गए और इंटिग्रेट किए गए APK को Play Store पर पब्लिश किया जा सकता है.
• जब Google यह पुष्टि कर लेगा कि आपका अपडेट किया गया APK Play Store पर प्रकाशित हो गया है, तब आपके सुझाव, चुनिंदा, और जारी रखें क्लस्टर पब्लिश किए जा सकते हैं और उपयोगकर्ताओं को दिख सकते हैं.