Flutter ऐप्लिकेशन में मैसेज पाना

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

ऐप्लिकेशन को FCM का इस्तेमाल करके मैसेज पेलोड पाने के लिए, कुछ ज़रूरी शर्तें पूरी करनी होंगी:

• ऐप्लिकेशन को कम से कम एक बार खोला गया हो, ताकि इसे FCM के साथ रजिस्टर किया जा सके.
• iOS पर, अगर उपयोगकर्ता ऐप्लिकेशन स्विचर से ऐप्लिकेशन को स्वाइप करके हटा देता है, तो बैकग्राउंड में मैसेज पाने की सुविधा को फिर से चालू करने के लिए, उसे मैन्युअल तरीके से फिर से खोलना होगा.
• Android पर, अगर उपयोगकर्ता डिवाइस की सेटिंग से ऐप्लिकेशन को फ़ोर्स-क्विट करता है, तो मैसेज पाने की सुविधा को फिर से चालू करने के लिए, उसे मैन्युअल तरीके से फिर से खोलना होगा.
• वेब पर, आपको वेब पुश सर्टिफ़िकेट के साथ टोकन का अनुरोध करना होगा. इसके लिए, getToken() का इस्तेमाल करें.

मैसेज पाने की अनुमति का अनुरोध करना

iOS, macOS, वेब, और Android 13 (या उसके बाद के वर्शन) पर, FCM पेलोड को अपने डिवाइस पर पाने से पहले, आपको उपयोगकर्ता से अनुमति मांगनी होगी.

firebase_messaging पैकेज, तरीके requestPermission का इस्तेमाल करके अनुमति का अनुरोध करने के लिए एक एपीआई उपलब्ध कराता है. यह एपीआई, नाम वाले कई ऐसे आर्ग्युमेंट स्वीकार करता है जिनसे उन अनुमतियों के टाइप तय होते हैं जिनका अनुरोध करना है. जैसे, सूचना पेलोड वाले मैसेज से आवाज़ ट्रिगर हो सकती है या नहीं या Siri का इस्तेमाल करके मैसेज पढ़े जा सकते हैं या नहीं. डिफ़ॉल्ट रूप से, यह तरीका, डिफ़ॉल्ट अनुमतियों का अनुरोध करता है. रेफ़रंस एपीआई में, हर अनुमति के बारे में पूरी जानकारी दी गई है.

शुरू करने के लिए, अपने ऐप्लिकेशन से इस तरीके को कॉल करें. iOS पर, एक इन-बिल्ट मॉडल दिखेगा. वेब पर, ब्राउज़र का एपीआई फ़्लो ट्रिगर होगा:

FirebaseMessaging messaging = FirebaseMessaging.instance;

NotificationSettings settings = await messaging.requestPermission(
  alert: true,
  announcement: false,
  badge: true,
  carPlay: false,
  criticalAlert: false,
  provisional: false,
  sound: true,
);

print('User granted permission: ${settings.authorizationStatus}');

अनुरोध से मिले NotificationSettings ऑब्जेक्ट की authorizationStatus प्रॉपर्टी का इस्तेमाल करके, उपयोगकर्ता के फ़ैसले के बारे में पता लगाया जा सकता है:

• authorized: उपयोगकर्ता ने अनुमति दी.
• denied: उपयोगकर्ता ने अनुमति नहीं दी.
• notDetermined: उपयोगकर्ता ने अब तक यह तय नहीं किया है कि अनुमति देनी है या नहीं.
• provisional: उपयोगकर्ता ने अस्थायी अनुमति दी

NotificationSettings की अन्य प्रॉपर्टी से यह पता चलता है कि मौजूदा डिवाइस पर कोई खास अनुमति चालू है, बंद है या काम नहीं करती.

अनुमति मिलने और डिवाइस की अलग-अलग स्थितियों के बारे में समझने के बाद, आपका ऐप्लिकेशन अब आने वाले FCM पेलोड को मैनेज कर सकता है.

मैसेज मैनेज करना

आपके ऐप्लिकेशन की मौजूदा स्थिति के हिसाब से, अलग-अलग तरह के मैसेज के आने वाले पेलोड को मैनेज करने के लिए, अलग-अलग तरीके लागू करने होंगे:

फ़ोरग्राउंड में दिखने वाले मैसेज

जब आपका ऐप्लिकेशन फ़ोरग्राउंड में हो, तब मैसेज मैनेज करने के लिए, onMessage स्ट्रीम को सुनें.

FirebaseMessaging.onMessage.listen((RemoteMessage message) {
  print('Got a message whilst in the foreground!');
  print('Message data: ${message.data}');

  if (message.notification != null) {
    print('Message also contained a notification: ${message.notification}');
  }
});

इस स्ट्रीम में एक RemoteMessage होता है, जिसमें पेलोड के बारे में अलग-अलग जानकारी होती है. जैसे, यह कहां से आया, इसका यूनीक आईडी, इसे कब भेजा गया, इसमें कोई सूचना शामिल थी या नहीं वगैरह. चूंकि आपका ऐप्लिकेशन फ़ोरग्राउंड में है, इसलिए मैसेज को सीधे तौर पर वापस पाया जा सकता है. साथ ही, Flutter ऐप्लिकेशन की स्थिति और कॉन्टेक्स्ट को ऐक्सेस किया जा सकता है.

फ़ोरग्राउंड में दिखने वाले और सूचना वाले मैसेज

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

• Android पर, आपको "ज़्यादा प्राथमिकता" वाला सूचना चैनल बनाना होगा.
• iOS पर, ऐप्लिकेशन के लिए प्रज़ेंटेशन के विकल्प अपडेट किए जा सकते हैं.

बैकग्राउंड में दिखने वाले मैसेज

Android, Apple, और वेब पर आधारित प्लैटफ़ॉर्म पर, बैकग्राउंड में दिखने वाले मैसेज को मैनेज करने की प्रोसेस अलग-अलग होती है.

Apple के प्लैटफ़ॉर्म और Android

onBackgroundMessage हैंडलर रजिस्टर करके, बैकग्राउंड में दिखने वाले मैसेज मैनेज करें. मैसेज मिलने पर, एक आइसोलेट स्पॉन होता है. यह सुविधा सिर्फ़ Android पर उपलब्ध है. iOS/macOS के लिए अलग आइसोलेट की ज़रूरत नहीं होती. इससे, आपका ऐप्लिकेशन न चलने पर भी मैसेज मैनेज किए जा सकते हैं.

बैकग्राउंड में दिखने वाले मैसेज के हैंडलर के बारे में कुछ बातें ध्यान में रखें:

1. यह कोई एनॉनिमस फ़ंक्शन नहीं होना चाहिए.
2. यह टॉप-लेवल फ़ंक्शन होना चाहिए. जैसे, क्लास मेथड नहीं, जिसके लिए इनिशियलाइज़ेशन की ज़रूरत होती है.
3. Flutter के 3.3.0 या उसके बाद के वर्शन का इस्तेमाल करते समय, मैसेज हैंडलर को फ़ंक्शन के एलान के ठीक ऊपर @pragma('vm:entry-point') के साथ एनोटेट किया जाना चाहिए. ऐसा न करने पर, रिलीज़ मोड के लिए ट्री शेकिंग के दौरान इसे हटाया जा सकता है.

@pragma('vm:entry-point')
Future<void> _firebaseMessagingBackgroundHandler(RemoteMessage message) async {
  // If you're going to use other Firebase services in the background, such as Firestore,
  // make sure you call `initializeApp` before using other Firebase services.
  await Firebase.initializeApp();

  print("Handling a background message: ${message.messageId}");
}

void main() {
  FirebaseMessaging.onBackgroundMessage(_firebaseMessagingBackgroundHandler);
  runApp(MyApp());
}

चूंकि हैंडलर, आपके ऐप्लिकेशन के कॉन्टेक्स्ट से बाहर अपने आइसोलेट में चलता है, इसलिए ऐप्लिकेशन की स्थिति को अपडेट नहीं किया जा सकता या यूज़र इंटरफ़ेस (यूआई) पर असर डालने वाली कोई भी लॉजिक लागू नहीं किया जा सकता. हालांकि, एचटीटीपी अनुरोध, आईओ कार्रवाइयां (जैसे, लोकल स्टोरेज अपडेट करना), अन्य प्लग-इन के साथ कम्यूनिकेट करना वगैरह जैसे लॉजिक लागू किए जा सकते हैं.

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

वेब

वेब पर, JavaScript सर्विस वर्कर लिखें, जो बैकग्राउंड में चलता है. बैकग्राउंड में दिखने वाले मैसेज मैनेज करने के लिए, सर्विस वर्कर का इस्तेमाल करें.

शुरू करने के लिए, अपनी web डायरेक्ट्री में एक नई फ़ाइल बनाएं और इसे firebase-messaging-sw.js नाम दें:

// See this file for the latest firebase-js-sdk version:
// https://github.com/firebase/flutterfire/blob/main/packages/firebase_core/firebase_core_web/lib/src/firebase_sdk_version.dart
importScripts("https://www.gstatic.com/firebasejs/10.7.0/firebase-app-compat.js");
importScripts("https://www.gstatic.com/firebasejs/10.7.0/firebase-messaging-compat.js");

firebase.initializeApp({
  apiKey: "...",
  authDomain: "...",
  databaseURL: "...",
  projectId: "...",
  storageBucket: "...",
  messagingSenderId: "...",
  appId: "...",
});

const messaging = firebase.messaging();

// Optional:
messaging.onBackgroundMessage((message) => {
  console.log("onBackgroundMessage", message);
});

फ़ाइल में, ऐप्लिकेशन और मैसेजिंग, दोनों एसडीके टूल इंपोर्ट किए जाने चाहिए. साथ ही, Firebase को इनिशियलाइज़ किया जाना चाहिए और messaging वैरिएबल को एक्सपोज़ किया जाना चाहिए.

इसके बाद, वर्कर को रजिस्टर करना होगा. index.html फ़ाइल में, Flutter को बूटस्ट्रैप करने वाले <script> टैग में बदलाव करके, वर्कर को रजिस्टर करें:

<script src="flutter_bootstrap.js" async>
  if ('serviceWorker' in navigator) {
    window.addEventListener('load', function () {
      navigator.serviceWorker.register('firebase-messaging-sw.js', {
        scope: '/firebase-cloud-messaging-push-scope',
      });
    });
  }
</script>

अगर अब भी पुराने टेंप्लेटिंग सिस्टम का इस्तेमाल किया जा रहा है, तो Flutter को बूटस्ट्रैप करने वाले <script> टैग में बदलाव करके, वर्कर को रजिस्टर किया जा सकता है. इसके लिए, यह तरीका अपनाएं:

<html>
<body>
  <script>
      var serviceWorkerVersion = null;
      var scriptLoaded = false;
      function loadMainDartJs() {
        if (scriptLoaded) {
          return;
        }
        scriptLoaded = true;
        var scriptTag = document.createElement('script');
        scriptTag.src = 'main.dart.js';
        scriptTag.type = 'application/javascript';
        document.body.append(scriptTag);
      }

      if ('serviceWorker' in navigator) {
        // Service workers are supported. Use them.
        window.addEventListener('load', function () {
          // Register Firebase Messaging service worker.
          navigator.serviceWorker.register('firebase-messaging-sw.js', {
            scope: '/firebase-cloud-messaging-push-scope',
          });

          // Wait for registration to finish before dropping the <script> tag.
          // Otherwise, the browser will load the script multiple times,
          // potentially different versions.
          var serviceWorkerUrl =
            'flutter_service_worker.js?v=' + serviceWorkerVersion;

          navigator.serviceWorker.register(serviceWorkerUrl).then((reg) => {
            function waitForActivation(serviceWorker) {
              serviceWorker.addEventListener('statechange', () => {
                if (serviceWorker.state == 'activated') {
                  console.log('Installed new service worker.');
                  loadMainDartJs();
                }
              });
            }
            if (!reg.active && (reg.installing || reg.waiting)) {
              // No active web worker and we have installed or are installing
              // one for the first time. Simply wait for it to activate.
              waitForActivation(reg.installing ?? reg.waiting);
            } else if (!reg.active.scriptURL.endsWith(serviceWorkerVersion)) {
              // When the app updates the serviceWorkerVersion changes, so we
              // need to ask the service worker to update.
              console.log('New service worker available.');
              reg.update();
              waitForActivation(reg.installing);
            } else {
              // Existing service worker is still good.
              console.log('Loading app from service worker.');
              loadMainDartJs();
            }
          });

          // If service worker doesn't succeed in a reasonable amount of time,
          // fallback to plaint <script> tag.
          setTimeout(() => {
            if (!scriptLoaded) {
              console.warn(
                'Failed to load app from service worker. Falling back to plain <script> tag.'
              );
              loadMainDartJs();
            }
          }, 4000);
        });
      } else {
        // Service workers not supported. Just drop the <script> tag.
        loadMainDartJs();
      }
  </script>
</body>

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

इंटरैक्शन मैनेज करना

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

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

firebase-messaging पैकेज, इस इंटरैक्शन को मैनेज करने के दो तरीके उपलब्ध कराता है:

• getInitialMessage(): अगर ऐप्लिकेशन को बंद होने के बाद खोला जाता है, तो RemoteMessage वाला Future वापस मिलेगा. इस्तेमाल होने के बाद, RemoteMessage हटा दिया जाएगा.
• onMessageOpenedApp: एक Stream, जो ऐप्लिकेशन को बैकग्राउंड से खोलने पर RemoteMessage पोस्ट करता है.

हमारा सुझाव है कि दोनों स्थितियों को मैनेज किया जाए, ताकि उपयोगकर्ताओं को बेहतर अनुभव मिल सके. यहां दिए गए कोड के उदाहरण में बताया गया है कि यह कैसे किया जा सकता है:

class Application extends StatefulWidget {
  @override
  State<StatefulWidget> createState() => _Application();
}

class _Application extends State<Application> {
  // It is assumed that all messages contain a data field with the key 'type'
  Future<void> setupInteractedMessage() async {
    // Get any messages which caused the application to open from
    // a terminated state.
    RemoteMessage? initialMessage =
        await FirebaseMessaging.instance.getInitialMessage();

    // If the message also contains a data property with a "type" of "chat",
    // navigate to a chat screen
    if (initialMessage != null) {
      _handleMessage(initialMessage);
    }

    // Also handle any interaction when the app is in the background using a
    // Stream listener
    FirebaseMessaging.onMessageOpenedApp.listen(_handleMessage);
  }

  void _handleMessage(RemoteMessage message) {
    if (message.data['type'] == 'chat') {
      Navigator.pushNamed(context, '/chat',
        arguments: ChatArguments(message),
      );
    }
  }

  @override
  void initState() {
    super.initState();

    // Run code required to handle interacted messages in an async function
    // as initState() must not be async
    setupInteractedMessage();
  }

  @override
  Widget build(BuildContext context) {
    return Text("...");
  }
}

इंटरैक्शन को मैनेज करने का तरीका, आपके ऐप्लिकेशन के सेटअप पर निर्भर करता है. पिछले उदाहरण में, StatefulWidget का इस्तेमाल करके एक बुनियादी उदाहरण दिखाया गया है.

मैसेज को स्थानीय भाषा में दिखाना

स्थानीय भाषा में स्ट्रिंग भेजने के दो तरीके हैं:

• अपने सर्वर में, हर उपयोगकर्ता की पसंदीदा भाषा सेव करें और हर भाषा के लिए, पसंद के मुताबिक सूचनाएं भेजें
• अपने ऐप्लिकेशन में स्थानीय भाषा में स्ट्रिंग एम्बेड करें और ऑपरेटिंग सिस्टम की इन-बिल्ट स्थानीय भाषा की सेटिंग का इस्तेमाल करें

दूसरा तरीका इस्तेमाल करने का तरीका यहां दिया गया है:

Android

1. resources/values/strings.xml में, डिफ़ॉल्ट भाषा में मैसेज तय करें:

   <string name="notification_title">Hello world</string>
   <string name="notification_message">This is a message</string>
   

2. values-language डायरेक्ट्री में, अनुवाद किए गए मैसेज तय करें. उदाहरण के लिए, resources/values-fr/strings.xml में फ़्रेंच में मैसेज तय करें:

   <string name="notification_title">Bonjour le monde</string>
   <string name="notification_message">C'est un message</string>
   

3. सर्वर पेलोड में, title, message, और body कुंजियों का इस्तेमाल करने के बजाय, स्थानीय भाषा में मैसेज के लिए title_loc_key और body_loc_key का इस्तेमाल करें. साथ ही, उन्हें उस मैसेज के name एट्रिब्यूट पर सेट करें जिसे आपको दिखाना है.

   मैसेज पेलोड इस तरह दिखेगा:

   {
     "android": {
        "notification": {
          "title_loc_key": "notification_title",
          "body_loc_key": "notification_message"
        }
     }
   }
   

iOS

1. Base.lproj/Localizable.strings में, डिफ़ॉल्ट भाषा में मैसेज तय करें:

   "NOTIFICATION_TITLE" = "Hello World";
   "NOTIFICATION_MESSAGE" = "This is a message";
   

2. language.lproj डायरेक्ट्री में, अनुवाद किए गए मैसेज तय करें. उदाहरण के लिए, fr.lproj/Localizable.strings में फ़्रेंच में मैसेज तय करें:

   "NOTIFICATION_TITLE" = "Bonjour le monde";
   "NOTIFICATION_MESSAGE" = "C'est un message";
   

   मैसेज पेलोड इस तरह दिखेगा:

   {
     "apns": {
        "payload": {
          "alert": {
            "title-loc-key": "NOTIFICATION_TITLE",
            "loc-key": "NOTIFICATION_MESSAGE"
          }
        }
     }
   }
   

मैसेज डिलीवरी के डेटा को एक्सपोर्ट करने की सुविधा चालू करना

मैसेज के डेटा को ज़्यादा विश्लेषण के लिए, BigQuery में एक्सपोर्ट किया जा सकता है. BigQuery की मदद से, BigQuery SQL का इस्तेमाल करके डेटा का विश्लेषण किया जा सकता है. साथ ही, इसे किसी दूसरे क्लाउड प्रोवाइडर को एक्सपोर्ट किया जा सकता है या कस्टम एमएल मॉडल के लिए डेटा का इस्तेमाल किया जा सकता है. BigQuery में एक्सपोर्ट किए गए डेटा में, मैसेज से जुड़ा सारा उपलब्ध डेटा शामिल होता है. भले ही, मैसेज का टाइप कुछ भी हो या मैसेज को एपीआई या सूचनाएं कंपोज़र का इस्तेमाल करके भेजा गया हो.

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

Android

यहां दिया गया कोड इस्तेमाल किया जा सकता है:

await FirebaseMessaging.instance.setDeliveryMetricsExportToBigQuery(true);

iOS

iOS के लिए, आपको AppDelegate.m में यह कॉन्टेंट जोड़ना होगा.

#import "AppDelegate.h"
#import "GeneratedPluginRegistrant.h"
#import <Firebase/Firebase.h>

@implementation AppDelegate

- (BOOL)application:(UIApplication *)application
    didFinishLaunchingWithOptions:(NSDictionary *)launchOptions {
  [GeneratedPluginRegistrant registerWithRegistry:self];
  // Override point for customization after application launch.
  return [super application:application didFinishLaunchingWithOptions:launchOptions];
}

- (void)application:(UIApplication *)application
    didReceiveRemoteNotification:(NSDictionary *)userInfo
          fetchCompletionHandler:(void (^)(UIBackgroundFetchResult))completionHandler {
  [[FIRMessaging extensionHelper] exportDeliveryMetricsToBigQueryWithMessageInfo:userInfo];
}

@end

वेब

वेब के लिए, आपको एसडीके के v9 वर्शन का इस्तेमाल करने के लिए, अपने सर्विस वर्कर में बदलाव करना होगा. v9 वर्शन को बंडल करना होगा. इसलिए, सर्विस वर्कर को काम करने के लिए, esbuild जैसे बंडलर का इस्तेमाल करना होगा. यह जानने के लिए कि इसे कैसे किया जाता है, ऐप्लिकेशन का उदाहरण देखें.

v9 एसडीके पर माइग्रेट करने के बाद, यहां दिया गया कोड इस्तेमाल किया जा सकता है:

import {
  experimentalSetDeliveryMetricsExportedToBigQueryEnabled,
  getMessaging,
} from 'firebase/messaging/sw';
...

const messaging = getMessaging(app);
experimentalSetDeliveryMetricsExportedToBigQueryEnabled(messaging, true);

web फ़ोल्डर में, अपने सर्विस वर्कर का नया वर्शन एक्सपोर्ट करने के लिए, yarn build चलाना न भूलें.

iOS पर सूचनाओं में इमेज दिखाना

Apple डिवाइसों पर, आने वाली FCM सूचनाओं में FCM पेलोड से इमेज दिखाने के लिए, आपको सूचना सेवा का एक और एक्सटेंशन जोड़ना होगा. साथ ही, अपने ऐप्लिकेशन को इसे इस्तेमाल करने के लिए कॉन्फ़िगर करना होगा.

अगर Firebase फ़ोन से पुष्टि करने की सुविधा का इस्तेमाल किया जा रहा है, तो आपको अपने Podfile में Firebase Auth पॉड जोड़ना होगा.

पहला चरण - सूचना सेवा का एक्सटेंशन जोड़ना

1. Xcode में, File > New > Target... पर क्लिक करें
2. एक मॉडल में, संभावित टारगेट की सूची दिखेगी. Notification Service Extension चुनने के लिए, स्क्रोल करें या फ़िल्टर का इस्तेमाल करें. Next पर क्लिक करें.
3. कोई प्रॉडक्ट नाम जोड़ें. इस ट्यूटोरियल के साथ-साथ काम करने के लिए, "ImageNotification" का इस्तेमाल करें. इसके बाद, Swift या Objective-C में से कोई एक चुनें और Finish पर क्लिक करें.
4. स्कीम चालू करने के लिए, Activate पर क्लिक करें.

दूसरा चरण - Podfile में टारगेट जोड़ना

तीसरा चरण - एक्सटेंशन हेल्पर का इस्तेमाल करना

इस समय, सब कुछ सामान्य रूप से चलना चाहिए. आखिरी चरण, एक्सटेंशन हेल्पर को लागू करना है.

चौथा चरण - पेलोड में इमेज जोड़ना

अब सूचना के पेलोड में, इमेज जोड़ी जा सकती है. ज़्यादा जानने के लिए, भेजने का अनुरोध बनाने का तरीका देखें.