@react-native-firebase/messaging 23.8.0 → 23.8.1

package/android/src/main/java/io/invertase/firebase/messaging/ReactNativeFirebaseMessagingModule.java

@@ -0,0 +1,332 @@
+package io.invertase.firebase.messaging;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import android.app.Activity;
+import android.content.Intent;
+import android.util.Log;
+import androidx.core.app.NotificationManagerCompat;
+import com.facebook.react.bridge.ActivityEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
+import com.google.android.gms.tasks.Tasks;
+import com.google.firebase.FirebaseApp;
+import com.google.firebase.messaging.FirebaseMessaging;
+import com.google.firebase.messaging.RemoteMessage;
+import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter;
+import io.invertase.firebase.common.ReactNativeFirebaseModule;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ReactNativeFirebaseMessagingModule extends ReactNativeFirebaseModule
+    implements ActivityEventListener {
+  private static final String TAG = "Messaging";
+  ReadableMap initialNotification = null;
+  private HashMap<String, Boolean> initialNotificationMap = new HashMap<>();
+
+  ReactNativeFirebaseMessagingModule(ReactApplicationContext reactContext) {
+    super(reactContext, TAG);
+    reactContext.addActivityEventListener(this);
+  }
+
+  private WritableMap popRemoteMessageMapFromMessagingStore(String messageId) {
+    ReactNativeFirebaseMessagingStore messagingStore =
+        ReactNativeFirebaseMessagingStoreHelper.getInstance().getMessagingStore();
+    WritableMap remoteMessageMap = messagingStore.getFirebaseMessageMap(messageId);
+    messagingStore.clearFirebaseMessage(messageId);
+    return remoteMessageMap;
+  }
+
+  @ReactMethod
+  public void getInitialNotification(Promise promise) {
+    if (initialNotification != null) {
+      promise.resolve(initialNotification);
+      initialNotification = null;
+      return;
+    } else {
+      Activity activity = getCurrentActivity();
+
+      if (activity != null) {
+        Intent intent = activity.getIntent();
+
+        if (intent != null && intent.getExtras() != null) {
+          // messageId can be either one...
+          String messageId = intent.getExtras().getString("google.message_id");
+          if (messageId == null) messageId = intent.getExtras().getString("message_id");
+
+          // only handle non-consumed initial notifications
+          if (messageId != null && initialNotificationMap.get(messageId) == null) {
+            WritableMap remoteMessageMap;
+            RemoteMessage remoteMessage =
+                ReactNativeFirebaseMessagingReceiver.notifications.get(messageId);
+            if (remoteMessage == null) {
+              remoteMessageMap = popRemoteMessageMapFromMessagingStore(messageId);
+            } else {
+              remoteMessageMap =
+                  ReactNativeFirebaseMessagingSerializer.remoteMessageToWritableMap(remoteMessage);
+            }
+            if (remoteMessageMap != null) {
+              promise.resolve(remoteMessageMap);
+              initialNotificationMap.put(messageId, true);
+              return;
+            }
+          }
+        }
+      } else {
+        Log.w(
+            TAG,
+            "Attempt to call getInitialNotification failed. The current activity is not ready, try"
+                + " calling the method later in the React lifecycle.");
+      }
+    }
+
+    promise.resolve(null);
+  }
+
+  @ReactMethod
+  public void setAutoInitEnabled(Boolean enabled, Promise promise) {
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              FirebaseMessaging.getInstance().setAutoInitEnabled(enabled);
+              return null;
+            })
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(FirebaseMessaging.getInstance().isAutoInitEnabled());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void isNotificationDelegationEnabled(Promise promise) {
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              FirebaseMessaging.getInstance().isNotificationDelegationEnabled();
+              return null;
+            })
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setNotificationDelegationEnabled(Boolean enabled, Promise promise) {
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              FirebaseMessaging.getInstance().setNotificationDelegationEnabled(enabled);
+              return null;
+            })
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(FirebaseMessaging.getInstance().isNotificationDelegationEnabled());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void getToken(String appName, String senderId, Promise promise) {
+    FirebaseMessaging messagingInstance =
+        FirebaseApp.getInstance(appName).get(FirebaseMessaging.class);
+    Tasks.call(getExecutor(), () -> Tasks.await(messagingInstance.getToken()))
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void deleteToken(String appName, String senderId, Promise promise) {
+    FirebaseMessaging messagingInstance =
+        FirebaseApp.getInstance(appName).get(FirebaseMessaging.class);
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              Tasks.await(messagingInstance.deleteToken());
+              return null;
+            })
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void hasPermission(Promise promise) {
+    Tasks.call(
+            getExecutor(),
+            () ->
+                NotificationManagerCompat.from(getReactApplicationContext())
+                    .areNotificationsEnabled())
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult() ? 1 : 0);
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void sendMessage(ReadableMap remoteMessageMap, Promise promise) {
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              FirebaseMessaging.getInstance()
+                  .send(
+                      ReactNativeFirebaseMessagingSerializer.remoteMessageFromReadableMap(
+                          remoteMessageMap));
+              return null;
+            })
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void subscribeToTopic(String topic, Promise promise) {
+    FirebaseMessaging.getInstance()
+        .subscribeToTopic(topic)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void unsubscribeFromTopic(String topic, Promise promise) {
+    FirebaseMessaging.getInstance()
+        .unsubscribeFromTopic(topic)
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(task.getResult());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @ReactMethod
+  public void setDeliveryMetricsExportToBigQuery(Boolean enabled, Promise promise) {
+    Tasks.call(
+            getExecutor(),
+            () -> {
+              FirebaseMessaging.getInstance().setDeliveryMetricsExportToBigQuery(enabled);
+              return null;
+            })
+        .addOnCompleteListener(
+            task -> {
+              if (task.isSuccessful()) {
+                promise.resolve(
+                    FirebaseMessaging.getInstance().deliveryMetricsExportToBigQueryEnabled());
+              } else {
+                rejectPromiseWithExceptionMap(promise, task.getException());
+              }
+            });
+  }
+
+  @Override
+  public Map<String, Object> getConstants() {
+    final Map<String, Object> constants = new HashMap<>();
+    constants.put("isAutoInitEnabled", FirebaseMessaging.getInstance().isAutoInitEnabled());
+    constants.put(
+        "isDeliveryMetricsExportToBigQueryEnabled",
+        FirebaseMessaging.getInstance().deliveryMetricsExportToBigQueryEnabled());
+    constants.put(
+        "isNotificationDelegationEnabled",
+        FirebaseMessaging.getInstance().isNotificationDelegationEnabled());
+    return constants;
+  }
+
+  @Override
+  public void onActivityResult(Activity activity, int requestCode, int resultCode, Intent data) {
+    // noop
+  }
+
+  @Override
+  public void onNewIntent(Intent intent) {
+    if (intent != null && intent.getExtras() != null) {
+      String messageId = intent.getExtras().getString("google.message_id");
+      if (messageId == null) messageId = intent.getExtras().getString("message_id");
+
+      if (messageId != null) {
+        RemoteMessage remoteMessage =
+            ReactNativeFirebaseMessagingReceiver.notifications.get(messageId);
+        WritableMap remoteMessageMap;
+
+        if (remoteMessage == null) {
+          remoteMessageMap = popRemoteMessageMapFromMessagingStore(messageId);
+        } else {
+          remoteMessageMap =
+              ReactNativeFirebaseMessagingSerializer.remoteMessageToWritableMap(remoteMessage);
+        }
+
+        if (remoteMessageMap != null) {
+          // WritableNativeMap not be consumed twice. But it is resolved in future and in event
+          // below. Make a copy - issue #5231
+          WritableNativeMap newInitialNotification = new WritableNativeMap();
+          newInitialNotification.merge(remoteMessageMap);
+          initialNotification = newInitialNotification;
+          ReactNativeFirebaseMessagingReceiver.notifications.remove(messageId);
+
+          ReactNativeFirebaseEventEmitter emitter =
+              ReactNativeFirebaseEventEmitter.getSharedInstance();
+          emitter.sendEvent(
+              ReactNativeFirebaseMessagingSerializer.remoteMessageMapToEvent(
+                  remoteMessageMap, true));
+        }
+      }
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/messaging/ReactNativeFirebaseMessagingPackage.java

@@ -0,0 +1,41 @@
+package io.invertase.firebase.messaging;
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+@SuppressWarnings("unused")
+public class ReactNativeFirebaseMessagingPackage implements ReactPackage {
+  @Override
+  public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
+    List<NativeModule> modules = new ArrayList<>();
+    modules.add(new ReactNativeFirebaseMessagingModule(reactContext));
+    return modules;
+  }
+
+  @Override
+  public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    return Collections.emptyList();
+  }
+}

package/android/src/main/java/io/invertase/firebase/messaging/ReactNativeFirebaseMessagingReceiver.java

@@ -0,0 +1,66 @@
+package io.invertase.firebase.messaging;
+
+import android.content.BroadcastReceiver;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+import com.facebook.react.HeadlessJsTaskService;
+import com.google.firebase.messaging.RemoteMessage;
+import io.invertase.firebase.app.ReactNativeFirebaseApp;
+import io.invertase.firebase.common.ReactNativeFirebaseEventEmitter;
+import io.invertase.firebase.common.SharedUtils;
+import java.util.HashMap;
+
+public class ReactNativeFirebaseMessagingReceiver extends BroadcastReceiver {
+  private static final String TAG = "RNFirebaseMsgReceiver";
+  static HashMap<String, RemoteMessage> notifications = new HashMap<>();
+
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    Log.d(TAG, "broadcast received for message");
+    if (ReactNativeFirebaseApp.getApplicationContext() == null) {
+      ReactNativeFirebaseApp.setApplicationContext(context.getApplicationContext());
+    }
+    if (intent.getExtras() == null) {
+      Log.e(TAG, "broadcast intent received with no extras");
+      return;
+    }
+    RemoteMessage remoteMessage = new RemoteMessage(intent.getExtras());
+    ReactNativeFirebaseEventEmitter emitter = ReactNativeFirebaseEventEmitter.getSharedInstance();
+
+    // Add a RemoteMessage if the message contains a notification payload
+    if (remoteMessage.getNotification() != null) {
+      notifications.put(remoteMessage.getMessageId(), remoteMessage);
+      ReactNativeFirebaseMessagingStoreHelper.getInstance()
+          .getMessagingStore()
+          .storeFirebaseMessage(remoteMessage);
+    }
+
+    //  |-> ---------------------
+    //      App in Foreground
+    //   ------------------------
+    if (SharedUtils.isAppInForeground(context)) {
+      emitter.sendEvent(
+          ReactNativeFirebaseMessagingSerializer.remoteMessageToEvent(remoteMessage, false));
+      return;
+    }
+
+    //  |-> ---------------------
+    //    App in Background/Quit
+    //   ------------------------
+
+    try {
+      Intent backgroundIntent =
+          new Intent(context, ReactNativeFirebaseMessagingHeadlessService.class);
+      backgroundIntent.putExtra("message", remoteMessage);
+      ComponentName name = context.startService(backgroundIntent);
+      if (name != null) {
+        HeadlessJsTaskService.acquireWakeLockNow(context);
+      }
+    } catch (IllegalStateException ex) {
+      // By default, data only messages are "default" priority and cannot trigger Headless tasks
+      Log.e(TAG, "Background messages only work if the message priority is set to 'high'", ex);
+    }
+  }
+}

package/android/src/main/java/io/invertase/firebase/messaging/ReactNativeFirebaseMessagingSerializer.java

@@ -0,0 +1,225 @@
+package io.invertase.firebase.messaging;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableMapKeySetIterator;
+import com.facebook.react.bridge.WritableMap;
+import com.google.firebase.messaging.RemoteMessage;
+import io.invertase.firebase.common.ReactNativeFirebaseEvent;
+import io.invertase.firebase.common.SharedUtils;
+import java.util.Map;
+import java.util.Set;
+
+public class ReactNativeFirebaseMessagingSerializer {
+  private static final String KEY_TOKEN = "token";
+  private static final String KEY_COLLAPSE_KEY = "collapseKey";
+  private static final String KEY_DATA = "data";
+  private static final String KEY_FROM = "from";
+  private static final String KEY_MESSAGE_ID = "messageId";
+  private static final String KEY_MESSAGE_TYPE = "messageType";
+  private static final String KEY_SENT_TIME = "sentTime";
+  private static final String KEY_ERROR = "error";
+  private static final String KEY_TO = "to";
+  private static final String KEY_TTL = "ttl";
+  private static final String KEY_PRIORITY = "priority";
+  private static final String KEY_ORIGINAL_PRIORITY = "originalPriority";
+  private static final String EVENT_MESSAGE_SENT = "messaging_message_sent";
+  private static final String EVENT_MESSAGES_DELETED = "messaging_message_deleted";
+  private static final String EVENT_MESSAGE_RECEIVED = "messaging_message_received";
+  private static final String EVENT_NOTIFICATION_OPENED = "messaging_notification_opened";
+  private static final String EVENT_MESSAGE_SEND_ERROR = "messaging_message_send_error";
+  private static final String EVENT_NEW_TOKEN = "messaging_token_refresh";
+
+  public static ReactNativeFirebaseEvent messagesDeletedToEvent() {
+    return new ReactNativeFirebaseEvent(EVENT_MESSAGES_DELETED, Arguments.createMap());
+  }
+
+  public static ReactNativeFirebaseEvent messageSentToEvent(String messageId) {
+    WritableMap eventBody = Arguments.createMap();
+    eventBody.putString(KEY_MESSAGE_ID, messageId);
+    return new ReactNativeFirebaseEvent(EVENT_MESSAGE_SENT, eventBody);
+  }
+
+  public static ReactNativeFirebaseEvent messageSendErrorToEvent(
+      String messageId, Exception sendError) {
+    WritableMap eventBody = Arguments.createMap();
+    eventBody.putString(KEY_MESSAGE_ID, messageId);
+    eventBody.putMap(KEY_ERROR, SharedUtils.getExceptionMap(sendError));
+    return new ReactNativeFirebaseEvent(EVENT_MESSAGE_SEND_ERROR, eventBody);
+  }
+
+  public static ReactNativeFirebaseEvent remoteMessageToEvent(
+      RemoteMessage remoteMessage, Boolean openEvent) {
+    return new ReactNativeFirebaseEvent(
+        openEvent ? EVENT_NOTIFICATION_OPENED : EVENT_MESSAGE_RECEIVED,
+        remoteMessageToWritableMap(remoteMessage));
+  }
+
+  public static ReactNativeFirebaseEvent remoteMessageMapToEvent(
+      WritableMap remoteMessageMap, Boolean openEvent) {
+    return new ReactNativeFirebaseEvent(
+        openEvent ? EVENT_NOTIFICATION_OPENED : EVENT_MESSAGE_RECEIVED, remoteMessageMap);
+  }
+
+  public static ReactNativeFirebaseEvent newTokenToTokenEvent(String newToken) {
+    WritableMap eventBody = Arguments.createMap();
+    eventBody.putString(KEY_TOKEN, newToken);
+    return new ReactNativeFirebaseEvent(EVENT_NEW_TOKEN, eventBody);
+  }
+
+  static WritableMap remoteMessageToWritableMap(RemoteMessage remoteMessage) {
+    WritableMap messageMap = Arguments.createMap();
+    WritableMap dataMap = Arguments.createMap();
+
+    if (remoteMessage.getCollapseKey() != null) {
+      messageMap.putString(KEY_COLLAPSE_KEY, remoteMessage.getCollapseKey());
+    }
+
+    if (remoteMessage.getFrom() != null) {
+      messageMap.putString(KEY_FROM, remoteMessage.getFrom());
+    }
+
+    if (remoteMessage.getTo() != null) {
+      messageMap.putString(KEY_TO, remoteMessage.getTo());
+    }
+
+    if (remoteMessage.getMessageId() != null) {
+      messageMap.putString(KEY_MESSAGE_ID, remoteMessage.getMessageId());
+    }
+
+    if (remoteMessage.getMessageType() != null) {
+      messageMap.putString(KEY_MESSAGE_TYPE, remoteMessage.getMessageType());
+    }
+
+    if (remoteMessage.getData().size() > 0) {
+      Set<Map.Entry<String, String>> entries = remoteMessage.getData().entrySet();
+      for (Map.Entry<String, String> entry : entries) {
+        dataMap.putString(entry.getKey(), entry.getValue());
+      }
+    }
+
+    messageMap.putMap(KEY_DATA, dataMap);
+    messageMap.putDouble(KEY_TTL, remoteMessage.getTtl());
+    messageMap.putDouble(KEY_SENT_TIME, remoteMessage.getSentTime());
+    messageMap.putInt(KEY_PRIORITY, remoteMessage.getPriority());
+    messageMap.putInt(KEY_ORIGINAL_PRIORITY, remoteMessage.getOriginalPriority());
+
+    if (remoteMessage.getNotification() != null) {
+      messageMap.putMap(
+          "notification", remoteMessageNotificationToWritableMap(remoteMessage.getNotification()));
+    }
+
+    return messageMap;
+  }
+
+  static WritableMap remoteMessageNotificationToWritableMap(
+      RemoteMessage.Notification notification) {
+    WritableMap notificationMap = Arguments.createMap();
+    WritableMap androidNotificationMap = Arguments.createMap();
+
+    if (notification.getTitle() != null) {
+      notificationMap.putString("title", notification.getTitle());
+    }
+
+    if (notification.getTitleLocalizationKey() != null) {
+      notificationMap.putString("titleLocKey", notification.getTitleLocalizationKey());
+    }
+
+    if (notification.getTitleLocalizationArgs() != null) {
+      notificationMap.putArray(
+          "titleLocArgs", Arguments.fromJavaArgs(notification.getTitleLocalizationArgs()));
+    }
+
+    if (notification.getBody() != null) {
+      notificationMap.putString("body", notification.getBody());
+    }
+
+    if (notification.getBodyLocalizationKey() != null) {
+      notificationMap.putString("bodyLocKey", notification.getBodyLocalizationKey());
+    }
+
+    if (notification.getBodyLocalizationArgs() != null) {
+      notificationMap.putArray(
+          "bodyLocArgs", Arguments.fromJavaArgs(notification.getBodyLocalizationArgs()));
+    }
+
+    if (notification.getChannelId() != null) {
+      androidNotificationMap.putString("channelId", notification.getChannelId());
+    }
+
+    if (notification.getClickAction() != null) {
+      androidNotificationMap.putString("clickAction", notification.getClickAction());
+    }
+
+    if (notification.getColor() != null) {
+      androidNotificationMap.putString("color", notification.getColor());
+    }
+
+    if (notification.getIcon() != null) {
+      androidNotificationMap.putString("smallIcon", notification.getIcon());
+    }
+
+    if (notification.getImageUrl() != null) {
+      androidNotificationMap.putString("imageUrl", notification.getImageUrl().toString());
+    }
+
+    if (notification.getLink() != null) {
+      androidNotificationMap.putString("link", notification.getLink().toString());
+    }
+
+    if (notification.getNotificationCount() != null) {
+      androidNotificationMap.putInt("count", notification.getNotificationCount());
+    }
+
+    if (notification.getNotificationPriority() != null) {
+      androidNotificationMap.putInt("priority", notification.getNotificationPriority());
+    }
+
+    if (notification.getSound() != null) {
+      androidNotificationMap.putString("sound", notification.getSound());
+    }
+
+    if (notification.getTicker() != null) {
+      androidNotificationMap.putString("ticker", notification.getTicker());
+    }
+
+    if (notification.getVisibility() != null) {
+      androidNotificationMap.putInt("visibility", notification.getVisibility());
+    }
+
+    notificationMap.putMap("android", androidNotificationMap);
+    return notificationMap;
+  }
+
+  static RemoteMessage remoteMessageFromReadableMap(ReadableMap readableMap) {
+    RemoteMessage.Builder builder = new RemoteMessage.Builder(readableMap.getString(KEY_TO));
+
+    if (readableMap.hasKey(KEY_TTL)) {
+      builder.setTtl(readableMap.getInt(KEY_TTL));
+    }
+
+    if (readableMap.hasKey(KEY_MESSAGE_ID)) {
+      builder.setMessageId(readableMap.getString(KEY_MESSAGE_ID));
+    }
+
+    if (readableMap.hasKey(KEY_MESSAGE_TYPE)) {
+      builder.setMessageType(readableMap.getString(KEY_MESSAGE_TYPE));
+    }
+
+    if (readableMap.hasKey(KEY_COLLAPSE_KEY)) {
+      builder.setCollapseKey(readableMap.getString(KEY_COLLAPSE_KEY));
+    }
+
+    if (readableMap.hasKey(KEY_DATA)) {
+      ReadableMap messageData = readableMap.getMap(KEY_DATA);
+      ReadableMapKeySetIterator iterator = messageData.keySetIterator();
+
+      while (iterator.hasNextKey()) {
+        String key = iterator.nextKey();
+        builder.addData(key, messageData.getString(key));
+      }
+    }
+
+    return builder.build();
+  }
+}