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

प्लैटफ़ॉर्म चुनें:

iOS+ Android वेब Flutter Unity C++

इस गाइड में, 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 टूल सेट अप करना

Android

1. अगर आपने पहले से ही A/B टेस्टिंग नहीं बनाई है, तो अपने C++ प्रोजेक्ट में Firebase जोड़ें.

   • लिंक किए गए सेटअप के निर्देशों में, Firebase C++ SDK टूल का इस्तेमाल करने के लिए, डिवाइस और ऐप्लिकेशन से जुड़ी ज़रूरी शर्तें देखें. इसमें, ऐप्लिकेशन बनाने के लिए CMake का इस्तेमाल करने का सुझाव भी शामिल है.

   • प्रोजेक्ट-लेवल की build.gradle फ़ाइल में, Google की Maven रिपॉज़िटरी को buildscript और allprojects, दोनों सेक्शन में शामिल करना न भूलें.

   अहम जानकारी: अपनी CMakeLists.txt फ़ाइल में firebase_messaging लाइब्रेरी जोड़ना न भूलें.

2. JNI एनवायरमेंट और ऐक्टिविटी को पास करके, Firebase ऐप्लिकेशन ऑब्जेक्ट बनाएं:

   app = ::firebase::App::Create(::firebase::AppOptions(), jni_env, activity);

3. firebase::messaging::Listener इंटरफ़ेस को लागू करने वाली क्लास तय करें.

4. ऐप्लिकेशन और बनाए गए लिसनर को पास करके, FCM को शुरू करें:

   ::firebase::messaging::Initialize(app, listener);

5. Google Play services SDK टूल का इस्तेमाल करने वाले ऐप्लिकेशन को सुविधाओं को ऐक्सेस करने से पहले, डिवाइस पर Google Play services के साथ काम करने वाले APK की जांच करनी चाहिए. ज़्यादा जानने के लिए, Google Play services के APK की जांच करना लेख पढ़ें.

iOS+

1. अगर आपने पहले से ऐसा नहीं किया है, तो अपने C++ प्रोजेक्ट में Firebase जोड़ें. इसके बाद, FCM के लिए अपना प्रोजेक्ट सेट अप करने के लिए:
   1. Swift Package Manager का इस्तेमाल करके, https://github.com/firebase/firebase-ios-sdk.git रिपॉज़िटरी से FirebaseMessaging लाइब्रेरी (वर्शन 13.1.1) को अपने Xcode प्रोजेक्ट में जोड़ें.
   2. Firebase C++ SDK की xcframeworks डायरेक्ट्री से firebase.xcframework और firebase_messaging.xcframework को अपने Xcode प्रोजेक्ट में खींचें और छोड़ें.

2. APNs की पुष्टि करने वाली कुंजी को Firebase पर अपलोड करें. अगर आपके पास पहले से कोई APNs ऑथेंटिकेशन कुंजी नहीं है, तो Apple Developer Member Center में जाकर एक कुंजी बनाएं.

   1. Firebase कंसोल में, सेटिंग > सामान्य पर जाएं. इसके बाद, क्लाउड से मैसेज टैब पर क्लिक करें.
   2. iOS ऐप्लिकेशन कॉन्फ़िगरेशन में जाकर, APNs की पुष्टि करने वाली कुंजी में, अपलोड करें पर क्लिक करें. इससे, डेवलपमेंट की पुष्टि करने वाली कुंजी या प्रोडक्शन की पुष्टि करने वाली कुंजी या दोनों को अपलोड किया जा सकता है. कम से कम एक होना ज़रूरी है.
   3. उस जगह पर जाएं जहां आपने अपनी कुंजी सेव की है. इसके बाद, उसे चुनें और खोलें पर क्लिक करें. कुंजी के लिए कुंजी आईडी जोड़ें (यह Apple Developer Member Center में उपलब्ध है) और अपलोड करें पर क्लिक करें.

3. पुश नोटिफ़िकेशन की सुविधा चालू करने के लिए, अपने Xcode प्रोजेक्ट को कॉन्फ़िगर करें:

   1. नेविगेटर एरिया से प्रोजेक्ट चुनें.
   2. एडिटर एरिया से प्रोजेक्ट टारगेट चुनें.

   3. एडिटर एरिया में जाकर, सामान्य टैब को चुनें.

      1. Linked Frameworks and Libraries तक स्क्रोल करें. इसके बाद, फ़्रेमवर्क जोड़ने के लिए + बटन पर क्लिक करें.

      2. इसके बाद, जो विंडो खुलेगी उसमें स्क्रोल करके UserNotifications.framework पर जाएं. इसके बाद, एंट्री पर क्लिक करें और फिर Add पर क्लिक करें.

         यह फ़्रेमवर्क सिर्फ़ Xcode v8 और इसके बाद के वर्शन में दिखता है. साथ ही, इस लाइब्रेरी के लिए यह ज़रूरी है.

   4. एडिटर एरिया में जाकर, Capabilities टैब को चुनें.

      1. पुश नोटिफ़िकेशन को चालू करें पर स्विच करें.
      2. स्क्रोल करके Background Modes पर जाएं. इसके बाद, इसे On पर स्विच करें.
      3. बैकग्राउंड मोड में जाकर, रिमोट सूचनाएं चुनें.

4. Firebase ऐप्लिकेशन ऑब्जेक्ट बनाएं:

   app = ::firebase::App::Create(::firebase::AppOptions());

5. firebase::messaging::Listener इंटरफ़ेस को लागू करने वाली क्लास तय करें.

6. ऐप्लिकेशन और बनाए गए लिसनर को पास करके, Firebase क्लाउड से मैसेज को शुरू करें:

   ::firebase::messaging::Initialize(app, listener);

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

ध्यान दें: Firebase Cloud Messaging, FCM रजिस्ट्रेशन टोकन से Firebase इंस्टॉलेशन आईडी (FID) पर स्विच कर रहा है. ऐसा, ऐप्लिकेशन के अलग-अलग इंस्टेंस को टारगेट करने के लिए किया जा रहा है.

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

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

Android

अपनी AndroidManifest.xml के <application> एलिमेंट में, यह <meta-data> एलिमेंट जोड़ें:

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

Swift

FirebaseMessagingInstallationIdEnabled कुंजी को अपने Info.plist में जोड़ें और इसे YES पर सेट करें:

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 इंस्टॉलेशन आईडी का इस्तेमाल करें, क्योंकि आने वाले समय में इस तरीके को हटा दिया जाएगा.

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 की वैल्यू शून्य होगी.

सारांश में:

ऐप्लिकेशन की स्थिति	सूचना	डेटा	दोनों
फ़ोरग्राउंड	OnMessageReceived	OnMessageReceived	OnMessageReceived
बैकग्राउंड	सिस्टम ट्रे	OnMessageReceived	सूचना: सिस्टम ट्रे डेटा: इंटेंट के अतिरिक्त डेटा में.

Android पर कस्टम मैसेज मैनेज करना

डिफ़ॉल्ट रूप से, ऐप्लिकेशन को भेजी गई सूचनाएं ::firebase::messaging::Listener::OnMessageReceived को पास की जाती हैं. हालांकि, कुछ मामलों में आपको डिफ़ॉल्ट ऐक्शन और सेटिंग को बदलना पड़ सकता है. Android पर ऐसा करने के लिए, आपको कस्टम क्लास लिखनी होंगी, जो 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="true">
  <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="true" >
</service>

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

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

Android

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

Swift

FirebaseMessagingAutoInitEnabled = NO

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

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

ध्यान दें: SetTokenRegistrationOnInitEnabled अब काम नहीं करता. इसके बजाय, SetRegistrationOnInitEnabled का इस्तेमाल करें.

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

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++ ऐप्लिकेशन में मैसेज पाना
• विषयों पर मैसेज भेजना