C++ ऐप्लिकेशन में Firebase Cloud Messaging का इस्तेमाल शुरू करना

इस गाइड में, C++ क्लाइंट ऐप्लिकेशन में Firebase Cloud Messaging का इस्तेमाल शुरू करने का तरीका बताया गया है, ताकि भरोसेमंद तरीके से मैसेज भेजे जा सकें.

C++ की मदद से, क्रॉस-प्लैटफ़ॉर्म Firebase Cloud Messaging क्लाइंट ऐप्लिकेशन बनाने के लिए, Firebase Cloud Messaging एपीआई का इस्तेमाल करें. C++ SDK, Android और Apple, दोनों प्लैटफ़ॉर्म पर काम करता है. हालांकि, हर प्लैटफ़ॉर्म के लिए कुछ अतिरिक्त सेटअप करना ज़रूरी है. iOS और Android के लिए C++ SDK टूल, FCM के साथ कैसे काम करता है, इस बारे में ज़्यादा जानने के लिए, C++ के लिए Firebase के बारे में जानकारी लेख पढ़ें.

Firebase और FCM SDK टूल सेट अप करना

Firebase इंस्टॉलेशन आईडी को ऐक्सेस करना

Firebase इंस्टॉलेशन आईडी का इस्तेमाल करके रजिस्ट्रेशन की सुविधा चालू करना

Firebase इंस्टॉलेशन आईडी (FID) का इस्तेमाल करके, FCM के साथ अपने ऐप्लिकेशन इंस्टेंस को रजिस्टर करने की सुविधा चालू करने के लिए, आपको सबसे पहले Android और Apple, दोनों प्लैटफ़ॉर्म के लिए अपने ऐप्लिकेशन के कॉन्फ़िगरेशन में FID चालू करने होंगे:

<meta-data android:name="firebase_messaging_installation_id_enabled"
           android:value="true" />

FirebaseMessagingInstallationIdEnabled = YES

onRegistrationReceived लिसनर को लागू करना

Firebase Cloud Messaging लाइब्रेरी को शुरू करने पर, यह Firebase इंस्टॉलेशन आईडी (FID) का इस्तेमाल करके, मैसेज पाने के लिए क्लाइंट ऐप्लिकेशन इंस्टेंस को रजिस्टर करती है. ऐप्लिकेशन को OnRegistrationReceived कॉलबैक के साथ एफ़आईडी मिलेगा. इसे आपके firebase::messaging::Listener लागू करने के तरीके में तय किया जाना चाहिए:

class MyListener : public firebase::messaging::Listener {
 public:
  void OnRegistrationReceived(const char* installation_id) override {
    LogMessage("Received Firebase Installation ID: %s", installation_id);
    // TODO: Send the Firebase Installation ID (FID) to your app server to
    // target this device for messages.
  }
};

अगर आपको उस खास ऐप्लिकेशन इंस्टेंस को टारगेट करना है, तो अपने ऐप्लिकेशन सर्वर को एफआईडी भेजें और उसे अपनी पसंद के तरीके से सेव करें.

अपने-आप शुरू होने की सुविधा बंद होने पर, मैन्युअल तरीके से रजिस्टर करना

Register() का इस्तेमाल करके, रनटाइम के दौरान FCM के साथ मैन्युअल तरीके से भी रजिस्ट्रेशन को ट्रिगर किया जा सकता है:

// Manually register with FCM
firebase::Future<void> register_future = firebase::messaging::Register();
register_future.OnCompletion([](const firebase::Future<void>& future) {
  if (future.status() == firebase::kFutureStatusComplete &&
      future.error() == 0) {
    // Note: The registered Firebase Installation ID is delivered to the
    // OnRegistrationReceived callback.
    LogMessage("Registered with FCM");
  }
});

FCM रजिस्ट्रेशन टोकन को ऐक्सेस करना (अब काम नहीं करता)

Firebase Cloud Messaging लाइब्रेरी शुरू करने पर, क्लाइंट ऐप्लिकेशन इंस्टेंस के लिए रजिस्ट्रेशन टोकन का अनुरोध किया जाता है. ऐप्लिकेशन को OnTokenReceived कॉलबैक के साथ टोकन मिलेगा. इसे उस क्लास में तय किया जाना चाहिए जो firebase::messaging::Listener को लागू करती है.

अगर आपको उस ऐप्लिकेशन इंस्टेंस को टारगेट करना है, तो आपको इस टोकन का ऐक्सेस चाहिए होगा.

Android पर मैसेज डिलीवर होने के बारे में जानकारी

जब ऐप्लिकेशन नहीं चल रहा होता है और कोई उपयोगकर्ता सूचना पर टैप करता है, तो मैसेज डिफ़ॉल्ट रूप से FCM के बिल्ट-इन कॉलबैक के ज़रिए रूट नहीं होता है. इस मामले में, मैसेज पेलोड Intent के ज़रिए मिलते हैं. इसका इस्तेमाल, ऐप्लिकेशन को शुरू करने के लिए किया जाता है. अगर आपको FCM को इन आने वाले मैसेज को C++ लाइब्रेरी के कॉलबैक पर फ़ॉरवर्ड करना है, तो आपको अपनी ऐक्टिविटी में onNewIntent तरीके को बदलना होगा. साथ ही, Intent को MessageForwardingService पर पास करना होगा.

import com.google.firebase.messaging.MessageForwardingService;

class MyActivity extends Activity {
  private static final String TAG = "MyActvity";

  @Override
  protected void onNewIntent(Intent intent) {
    Log.d(TAG, "A message was sent to this app while it was in the background.");
    Intent message = new Intent(this, MessageForwardingService.class);
    message.setAction(MessageForwardingService.ACTION_REMOTE_INTENT);
    message.putExtras(intent);
    message.setData(intent.getData());
    // For older versions of Firebase C++ SDK (< 7.1.0), use `startService`.
    // startService(message);
    MessageForwardingService.enqueueWork(this, message);
  }
}

जब ऐप्लिकेशन बैकग्राउंड में चल रहा होता है, तब मिले मैसेज के सूचना फ़ील्ड के कॉन्टेंट का इस्तेमाल, सिस्टम ट्रे में सूचना दिखाने के लिए किया जाता है. हालांकि, सूचना के इस कॉन्टेंट को FCM के साथ शेयर नहीं किया जाएगा. इसका मतलब है कि Message::notification की वैल्यू शून्य होगी.

सारांश में:

Android पर कस्टम मैसेज हैंडल करना

डिफ़ॉल्ट रूप से, ऐप्लिकेशन को भेजी गई सूचनाएं ::firebase::messaging::Listener::OnMessageReceived को पास की जाती हैं. हालांकि, कुछ मामलों में आपको डिफ़ॉल्ट व्यवहार को बदलना पड़ सकता है. Android पर ऐसा करने के लिए, आपको com.google.firebase.messaging.cpp.ListenerService को बढ़ाने वाली कस्टम क्लास लिखनी होंगी. साथ ही, अपने प्रोजेक्ट के com.google.firebase.messaging.cpp.ListenerService को अपडेट करना होगा.AndroidManifest.xml

ListenerService तरीके को बदलना

ListenerService एक Java क्लास है. यह ऐप्लिकेशन को भेजे गए आने वाले मैसेज को इंटरसेप्ट करती है और उन्हें C++ लाइब्रेरी पर भेजती है. जब ऐप्लिकेशन फ़ोरग्राउंड में होता है (या जब ऐप्लिकेशन बैकग्राउंड में होता है और उसे सिर्फ़ डेटा वाला पेलोड मिलता है), तो मैसेज इस क्लास में दिए गए किसी एक कॉलबैक से होकर गुज़रेंगे. मैसेज हैंडलिंग में कस्टम व्यवहार जोड़ने के लिए, आपको FCM के डिफ़ॉल्ट ListenerService को बढ़ाना होगा:

import com.google.firebase.messaging.cpp.ListenerService;

class MyListenerService extends ListenerService {

ListenerService.onMessageReceived तरीके को बदलकर, आपको मिले RemoteMessage ऑब्जेक्ट के आधार पर कार्रवाइयां की जा सकती हैं. साथ ही, मैसेज का डेटा भी पाया जा सकता है:

@Override
public void onMessageReceived(RemoteMessage message) {
  Log.d(TAG, "A message has been received.");
  // Do additional logic...
  super.onMessageReceived(message);
}

ListenerService के पास कुछ अन्य तरीके भी हैं जिनका इस्तेमाल कम किया जाता है. इन्हें बदला भी जा सकता है. ज़्यादा जानकारी के लिए, FirebaseMessagingService रेफ़रंस देखें.

@Override
public void onDeletedMessages() {
  Log.d(TAG, "Messages have been deleted on the server.");
  // Do additional logic...
  super.onDeletedMessages();
}

@Override
public void onMessageSent(String messageId) {
  Log.d(TAG, "An outgoing message has been sent.");
  // Do additional logic...
  super.onMessageSent(messageId);
}

@Override
public void onSendError(String messageId, Exception exception) {
  Log.d(TAG, "An outgoing message encountered an error.");
  // Do additional logic...
  super.onSendError(messageId, exception);
}

AndroidManifest.xml को अपडेट करें

कस्टम क्लास लिखने के बाद, उन्हें AndroidManifest.xml में शामिल करना ज़रूरी है, ताकि वे लागू हो सकें. पक्का करें कि मेनिफ़ेस्ट में मर्ज करने वाले टूल शामिल हों. इसके लिए, <manifest> टैग में सही एट्रिब्यूट जोड़ें. जैसे:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.google.firebase.messaging.cpp.samples"
    xmlns:tools="http://schemas.android.com/tools">

firebase_messaging_cpp.aar संग्रह में एक AndroidManifest.xml फ़ाइल है, जो FCM के डिफ़ॉल्ट ListenerService के बारे में बताती है. इस मेनिफ़ेस्ट को आम तौर पर, प्रोजेक्ट के हिसाब से बनाए गए मेनिफ़ेस्ट के साथ मर्ज किया जाता है. इससे ListenerService को चलाया जा सकता है. इस ListenerService को कस्टम लिसनर सर्विस से बदलना होगा. इसके लिए, डिफ़ॉल्ट ListenerService को हटाकर कस्टम सेवा जोड़ें. इसके लिए, अपने प्रोजेक्ट की AndroidManifest.xml फ़ाइल में ये लाइनें जोड़ें:

<service android:name="com.google.firebase.messaging.cpp.ListenerService"
         tools:node="remove" />

<service android:name="com.google.firebase.messaging.cpp.samples.MyListenerService"
         android:exported="false">
  <intent-filter>
    <action android:name="com.google.firebase.MESSAGING_EVENT"/>
  </intent-filter>
</service>

Firebase C++ SDK के नए वर्शन (7.1.0 और इसके बाद के वर्शन) JobIntentService का इस्तेमाल करते हैं. इसके लिए, AndroidManifest.xml फ़ाइल में और बदलाव करने की ज़रूरत होती है.

<service android:name="com.google.firebase.messaging.MessageForwardingService"
     android:permission="android.permission.BIND_JOB_SERVICE"
     android:exported="false" >
</service>

अपने-आप शुरू होने की सुविधा को रोकना

FCM, ऐप्लिकेशन इंस्टेंस को टारगेट करने के लिए रजिस्ट्रेशन टोकन जनरेट करता है. टोकन जनरेट होने पर, लाइब्रेरी आइडेंटिफ़ायर और कॉन्फ़िगरेशन डेटा को Firebase पर अपलोड करती है. अगर आपको टोकन का इस्तेमाल करने से पहले, साफ़ तौर पर ऑप्ट-इन करना है, तो कॉन्फ़िगरेशन के समय जनरेट होने से रोका जा सकता है. इसके लिए, FCM और Android पर Analytics को बंद करें. इसके लिए, Apple प्लैटफ़ॉर्म पर अपने Info.plist (GoogleService-Info.plist नहीं) में मेटाडेटा वैल्यू जोड़ें. इसके अलावा, Android पर अपने AndroidManifest.xml में मेटाडेटा वैल्यू जोड़ें:

<?xml version="1.0" encoding="utf-8"?>
<application>
  <meta-data android:name="firebase_messaging_auto_init_enabled"
             android:value="false" />
  <meta-data android:name="firebase_analytics_collection_enabled"
             android:value="false" />
</application>

FirebaseMessagingAutoInitEnabled = NO

FCM को फिर से चालू करने के लिए, रनटाइम कॉल किया जा सकता है:

::firebase::messaging::SetRegistrationOnInitEnabled(true);

यह वैल्यू सेट होने के बाद, ऐप्लिकेशन को रीस्टार्ट करने पर भी बनी रहती है.

Android पर डीप लिंक वाले मैसेज

FCM की मदद से, आपके ऐप्लिकेशन में डीप लिंक वाले मैसेज भेजे जा सकते हैं. डीप लिंक वाले मैसेज पाने के लिए, आपको उस गतिविधि में एक नया इंटेंट फ़िल्टर जोड़ना होगा जो आपके ऐप्लिकेशन के लिए डीप लिंक मैनेज करती है. इंटेंट फ़िल्टर को आपके डोमेन के डीप लिंक को कैच करना चाहिए. अगर आपके मैसेज में डीप लिंक शामिल नहीं है, तो यह कॉन्फ़िगरेशन ज़रूरी नहीं है. AndroidManifest.xml में:

<intent-filter>
  <action android:name="android.intent.action.VIEW"/>
  <category android:name="android.intent.category.DEFAULT"/>
  <category android:name="android.intent.category.BROWSABLE"/>
  <data android:host="CHANGE_THIS_DOMAIN.example.com" android:scheme="http"/>
  <data android:host="CHANGE_THIS_DOMAIN.example.com" android:scheme="https"/>
</intent-filter>

इंटेंट फ़िल्टर को ज़्यादा फ़्लेक्सिबल बनाने के लिए, वाइल्डकार्ड भी तय किया जा सकता है. उदाहरण के लिए:

<intent-filter>
  <action android:name="android.intent.action.VIEW"/>
  <category android:name="android.intent.category.DEFAULT"/>
  <category android:name="android.intent.category.BROWSABLE"/>
  <data android:host="*.example.com" android:scheme="http"/>
  <data android:host="*.example.com" android:scheme="https"/>
</intent-filter>

जब उपयोगकर्ता किसी ऐसी सूचना पर टैप करते हैं जिसमें आपकी तय की गई स्कीम और होस्ट का लिंक होता है, तो आपका ऐप्लिकेशन इस इंटेंट फ़िल्टर के साथ गतिविधि शुरू कर देगा, ताकि लिंक को मैनेज किया जा सके.

अगले चरण

सेटअप के चरण पूरे करने के बाद, C++ के लिए FCM का इस्तेमाल करने के लिए, यहां कुछ विकल्प दिए गए हैं:

• डिवाइसों को मैसेज भेजना
• C++ ऐप्लिकेशन में मैसेज पाना
• विषयों पर मैसेज भेजना