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

अपने उपयोगकर्ताओं तक पहुंचकर, ऐप्लिकेशन में यूज़र ऐक्टिविटी बढ़ाएं. Engage SDK टूल को इंटिग्रेट करें, ताकि 'देखना जारी रखें' कॉन्टेंट और उनकी दिलचस्पी के मुताबिक सुझाव सीधे उपयोगकर्ताओं के डिवाइस पर अलग-अलग जगहों पर दिखे. इनमें कलेक्शन, टीवी, फ़िल्में वगैरह एक ही जगह पर देखने की सुविधा, और Play Store शामिल हैं. इंटिग्रेशन की वजह से, औसत APK में 50 केबी (कंप्रेस किया गया) से कम का डेटा जुड़ता है. साथ ही, ज़्यादातर ऐप्लिकेशन के लिए डेवलपर को एक हफ़्ते का समय लगता है. ज़्यादा जानने के लिए, हमारी कारोबार की साइट पर जाएं.

इस गाइड में, डेवलपर पार्टनर के लिए निर्देश दिए गए हैं. इनमें बताया गया है कि 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 में पैकेज की जानकारी दिखने की सुविधा देखें.

खास जानकारी

यह डिज़ाइन, बाउंड सर्विस को लागू करने पर आधारित है.

कोई क्लाइंट, अलग-अलग क्लस्टर टाइप के लिए इतना डेटा पब्लिश कर सकता है:

पहला चरण: Media Home SDK टूल के मौजूदा इंटिग्रेशन से माइग्रेट करना

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

अगर आपको Media Home के मौजूदा इंटिग्रेशन से माइग्रेट करना है, तो यहां दी गई टेबल में बताया गया है कि मौजूदा एसडीके में डेटा मॉडल को नए 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();

पहला चरण: इकाई का डेटा उपलब्ध कराना

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

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 == PUBLISHED). ऐसा इसलिए, ताकि उन डैशबोर्ड में जानकारी भरी जा सके जो इस स्टेटस का इस्तेमाल करके, आपके इंटिग्रेशन की परफ़ॉर्मेंस और अन्य मेट्रिक की जानकारी देते हैं.
• अगर कोई कॉन्टेंट पब्लिश नहीं किया गया है, लेकिन इंटिग्रेशन का स्टेटस ठीक है (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 API को कॉल करें. इसके लिए, स्टेटस कोड 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();

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

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 के तौर पर दिखाया जाता है. साथ ही, गड़बड़ी की वजह को गड़बड़ी कोड के तौर पर दिखाया जाता है.

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

कॉन्टेंट पब्लिश करने के लिए, नौकरी के ज़रिए एपीआई कॉल करने के अलावा, कॉन्टेंट पब्लिश करने का अनुरोध पाने के लिए, 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),
                           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);

}

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

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

यह सेवा, नीचे दिए गए इंटेंट भेजती है:

• 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 डेवलपर इंटिग्रेशन वर्कफ़्लो देखें.

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

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

संपर्क

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

अगले चरण

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

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