How to set up Firebase Cloud Messaging (FCM)?

 

Step 1: Create a Firebase Project

 

1. Go to the Firebase Console.
2. Click on "Add Project" or select an existing project if you already have one.
3. Follow the steps to create a project: give it a name, set up Google Analytics if needed, and click "Create Project."

 

Step 2: Add Firebase to Your App

 

1. Once the project is created, navigate to the Project Overview page.
2. Click on the Android or iOS icon to add Firebase to your app.
3. For Android:

• Register your app by entering the package name, and optionally, the app nickname and the debug signing certificate SHA-1.
• Download the google-services.json file and place it in the app directory of your project.
• Add the Firebase SDK to your app by ensuring that your root-level build.gradle file contains the Maven repository for Google:
  ```groovy
  buildscript {
  dependencies {
  classpath 'com.google.gms:google-services:4.3.10'
  }
  }
  allprojects {
  repositories {
  google()
  }
  }
  ```
• Apply the google-services plugin in your app-level build.gradle:
  ```groovy
  apply plugin: 'com.android.application'
  apply plugin: 'com.google.gms.google-services'
  ```
• Add dependencies to your app-level build.gradle file:
  ```groovy
  dependencies {
  // Firebase Cloud Messaging
  implementation 'com.google.firebase:firebase-messaging:23.0.0'
  }
  ```

1. For iOS:

• Register your app by entering the iOS bundle ID.

• Download the GoogleService-Info.plist file and add it to your Xcode project.

• Use CocoaPods to install Firebase in your project:
  ```
  pod 'Firebase/Messaging'
  ```

• Initialize Firebase in your App Delegate:
  ```swift
  import Firebase

  @UIApplicationMain
  class AppDelegate: UIResponder, UIApplicationDelegate {
  func application(_ application: UIApplication,
  didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
  FirebaseApp.configure()
  return true
  }
  }
  ```

 

Step 3: Set Up FCM Server Environment

 

1. Navigate to the Firebase Console, and go to the "Project Settings."

2. Click on the "Cloud Messaging" tab.

3. There, you will find the server key, which is necessary for sending messages.

4. For server-side setup, you can use any language or platform that can make HTTP POST requests. Below is an example using Node.js:

   ```javascript
   const fetch = require('node-fetch');

   async function sendMessage() {
   const response = await fetch('https://fcm.googleapis.com/fcm/send', {
   method: 'POST',
   headers: {
   'Authorization': 'key=YOUR_SERVER_KEY',
   'Content-Type': 'application/json'
   },
   body: JSON.stringify({
   to: 'DEVICE_REGISTRATION_TOKEN',
   notification: {
   title: 'Hello!',
   body: 'This is a notification message.'
   }
   })
   });
   
   const data = await response.json();
   console.log(data);
   }

   sendMessage();
   ```

 

Step 4: Implement FCM in Your App

 

1. For Android:

• Implement a service to handle message delivery. Create a class that extends FirebaseMessagingService:
  ```java
  public class MyFirebaseMessagingService extends FirebaseMessagingService {
  @Override
  public void onMessageReceived(RemoteMessage remoteMessage) {
  // Handle the message
  String message = remoteMessage.getNotification().getBody();
  }
  }
  ```

1. For iOS:

• Request permission to receive notifications:
  ```swift
  UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .sound, .badge]) { granted, error in
  // Handle permissions
  }
  ```
• Implement UNUserNotificationCenterDelegate to handle incoming notifications:
  ```swift
  class AppDelegate: UIResponder, UIApplicationDelegate, UNUserNotificationCenterDelegate {
  func userNotificationCenter(_ center: UNUserNotificationCenter,
  willPresent notification: UNNotification,
  withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
  // Handle foreground notification
  completionHandler([.banner, .badge, .sound])
  }
  }
  ```

Now, your app is set up to receive messages from Firebase Cloud Messaging. You can test sending notifications from the Firebase Console to confirm everything is working correctly.