@ammarahmed/notifee-react-native 7.3.1 → 7.4.2

package/android/src/main/java/app/notifee/core/NotificationPendingIntent.java

@@ -0,0 +1,189 @@
+package app.notifee.core;
+
+/*
+ * 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.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import app.notifee.core.event.MainComponentEvent;
+import app.notifee.core.model.NotificationAndroidPressActionModel;
+import app.notifee.core.utility.IntentUtils;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class NotificationPendingIntent {
+  public static final String EVENT_TYPE_INTENT_KEY = "notifee_event_type";
+  public static final String NOTIFICATION_ID_INTENT_KEY = "notification_id";
+  private static final AtomicInteger uniqueIds = new AtomicInteger(0);
+  private static final String TAG = "NotificationPendingIntent";
+
+  /**
+   * Creates a PendingIntent, which when sent triggers this class.
+   *
+   * @param notificationId int
+   * @param pressActionModelBundle NotificationAndroidPressActionModel.
+   * @param extraKeys Array of strings
+   * @param extraBundles One or more bundles
+   */
+  static PendingIntent createIntent(
+      int notificationId,
+      Bundle pressActionModelBundle,
+      int eventType,
+      String[] extraKeys,
+      Bundle... extraBundles) {
+    Context context = ContextHolder.getApplicationContext();
+
+    // Get launch activity intent
+    Intent launchActivityIntent = null;
+    if (pressActionModelBundle != null) {
+      launchActivityIntent =
+          createLaunchActivityIntent(
+              context,
+              notificationId,
+              NotificationAndroidPressActionModel.fromBundle(pressActionModelBundle));
+    }
+
+    // Create an activity to receive notification events
+    Intent receiverIntent = new Intent(context, NotificationReceiverActivity.class);
+
+    // Set extras for each intent
+    setIntentExtras(launchActivityIntent, eventType, notificationId, extraKeys, extraBundles);
+    setIntentExtras(receiverIntent, eventType, notificationId, extraKeys, extraBundles);
+
+    // Create pending intent with activities
+    int uniqueInt = uniqueIds.getAndIncrement();
+    Intent[] intents;
+
+    if (launchActivityIntent != null) {
+      intents = new Intent[2];
+      intents[0] = launchActivityIntent;
+
+      receiverIntent.setFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP | Intent.FLAG_ACTIVITY_CLEAR_TOP);
+      intents[1] = receiverIntent;
+    } else {
+      intents = new Intent[1];
+      receiverIntent.setFlags(
+          Intent.FLAG_ACTIVITY_NEW_TASK
+              | Intent.FLAG_ACTIVITY_MULTIPLE_TASK
+              | Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
+
+      intents[0] = receiverIntent;
+    }
+
+    return PendingIntent.getActivities(
+        context,
+        uniqueInt,
+        intents,
+        PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+  }
+
+  static void setIntentExtras(
+      Intent intent,
+      int eventType,
+      int notificationId,
+      String[] extraKeys,
+      Bundle... extraBundles) {
+    if (intent == null) {
+      return;
+    }
+
+    intent.putExtra(EVENT_TYPE_INTENT_KEY, eventType);
+    intent.putExtra(NOTIFICATION_ID_INTENT_KEY, notificationId);
+
+    for (int i = 0; i < extraKeys.length; i++) {
+      String key = extraKeys[i];
+
+      if (i <= extraBundles.length - 1) {
+        Bundle bundle = extraBundles[i];
+        intent.putExtra(key, bundle);
+      } else {
+        intent.putExtra(key, (String) null);
+      }
+    }
+  }
+
+  static boolean shouldCreateLaunchActivityIntent(
+      NotificationAndroidPressActionModel pressActionModel) {
+    if (pressActionModel == null) {
+      return false;
+    }
+
+    if (pressActionModel.getLaunchActivity() == null
+        && pressActionModel.getMainComponent() == null) {
+      return false;
+    }
+
+    return true;
+  }
+
+  static Intent createLaunchActivityIntent(
+      Context context, int notificationId, NotificationAndroidPressActionModel pressActionModel) {
+    if (!shouldCreateLaunchActivityIntent(pressActionModel)) {
+      return null;
+    }
+
+    try {
+      Intent launchActivityIntent =
+          context.getPackageManager().getLaunchIntentForPackage(context.getPackageName());
+
+      // Get launchActivity value from payload
+      String launchActivity = null;
+      if (pressActionModel != null) {
+        launchActivity = pressActionModel.getLaunchActivity();
+      }
+
+      // Determine if existing launchActivityIntent should be overwritten
+      // to handle a custom launchActivity
+      Boolean shouldOverwriteDefaultLaunchActivityIntent = launchActivityIntent == null;
+      if (launchActivityIntent != null) {
+        // overwrite if custom launch activity set (launch activity in payload does not equal current activity)
+        shouldOverwriteDefaultLaunchActivityIntent = launchActivity != "default" && launchActivityIntent.getComponent().getClassName() != launchActivity;
+      }
+
+      // Set new launch activity intent
+      if (launchActivity != null && shouldOverwriteDefaultLaunchActivityIntent) {
+        Class<?> launchActivityClass = IntentUtils.getLaunchActivity(launchActivity);
+        launchActivityIntent = new Intent(context, launchActivityClass);
+
+        launchActivityIntent.setPackage(null);
+
+        launchActivityIntent.setFlags(
+            Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED);
+      }
+
+      // Set any additional flags or main component if specified
+      if (pressActionModel.getLaunchActivityFlags() != -1) {
+        launchActivityIntent.setFlags(pressActionModel.getLaunchActivityFlags());
+      }
+
+      if (pressActionModel.getMainComponent() != null) {
+        launchActivityIntent.putExtra("mainComponent", pressActionModel.getMainComponent());
+        EventBus.postSticky(new MainComponentEvent(pressActionModel.getMainComponent()));
+      }
+
+      return launchActivityIntent;
+    } catch (Exception e) {
+      Logger.e(
+          "NotificationPendingIntent",
+          "Failed to create LaunchActivityIntent for notification " + notificationId,
+          e);
+    }
+
+    return null;
+  }
+}

package/android/src/main/java/app/notifee/core/NotificationReceiverActivity.java

@@ -0,0 +1,38 @@
+package app.notifee.core;
+
+/*
+ * 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.os.Bundle;
+
+public class NotificationReceiverActivity extends Activity {
+  @Override
+  protected void onCreate(Bundle savedInstanceState) {
+    super.onCreate(savedInstanceState);
+    NotificationReceiverHandler.handleNotification(this, getIntent());
+    finish();
+  }
+
+  @Override
+  protected void onNewIntent(Intent intent) {
+    super.onNewIntent(intent);
+    NotificationReceiverHandler.handleNotification(this, intent);
+    finish();
+  }
+}

package/android/src/main/java/app/notifee/core/NotificationReceiverHandler.java

@@ -0,0 +1,140 @@
+package app.notifee.core;
+
+/*
+ * 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 static app.notifee.core.NotificationPendingIntent.EVENT_TYPE_INTENT_KEY;
+import static app.notifee.core.NotificationPendingIntent.NOTIFICATION_ID_INTENT_KEY;
+import static app.notifee.core.event.NotificationEvent.TYPE_ACTION_PRESS;
+import static app.notifee.core.event.NotificationEvent.TYPE_PRESS;
+
+import android.app.RemoteInput;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import androidx.core.app.NotificationManagerCompat;
+import app.notifee.core.event.InitialNotificationEvent;
+import app.notifee.core.event.MainComponentEvent;
+import app.notifee.core.event.NotificationEvent;
+import app.notifee.core.model.NotificationAndroidPressActionModel;
+import app.notifee.core.model.NotificationModel;
+
+public class NotificationReceiverHandler {
+  public static final String REMOTE_INPUT_RECEIVER_KEY =
+      "app.notifee.core.ReceiverService.REMOTE_INPUT_RECEIVER_KEY";
+  private static final String TAG = "NotificationReceiverHandler";
+
+  static void handleNotification(Context context, Intent intent) {
+    if (!intent.hasExtra("notification")) {
+      return;
+    }
+
+    if (context != null && ContextHolder.getApplicationContext() == null) {
+      ContextHolder.setApplicationContext(context.getApplicationContext());
+    }
+
+    handleNotificationIntent(context, intent);
+  }
+
+  private static void handleNotificationIntent(Context context, Intent intent) {
+    int type = intent.getIntExtra(EVENT_TYPE_INTENT_KEY, 0);
+
+    if (type == 0) {
+      // no-op, ignore intent
+      return;
+    }
+
+    switch (type) {
+      case TYPE_PRESS:
+        handleNotificationPressIntent(context, intent);
+        break;
+      case TYPE_ACTION_PRESS:
+        handleNotificationActionIntent(context, intent);
+        break;
+    }
+  }
+
+  private static void handleNotificationActionIntent(Context context, Intent intent) {
+    Bundle notification = intent.getBundleExtra("notification");
+    Bundle pressAction = intent.getBundleExtra("pressAction");
+
+    if (notification == null || pressAction == null) {
+      return;
+    }
+
+    NotificationModel notificationModel = NotificationModel.fromBundle(notification);
+    NotificationAndroidPressActionModel pressActionBundle =
+        NotificationAndroidPressActionModel.fromBundle(pressAction);
+
+    Bundle extras = new Bundle();
+    extras.putBundle("pressAction", pressActionBundle.toBundle());
+
+    Bundle remoteInput = RemoteInput.getResultsFromIntent(intent);
+    if (remoteInput != null) {
+      CharSequence input = remoteInput.getCharSequence(REMOTE_INPUT_RECEIVER_KEY);
+      if (input != null) {
+        extras.putString("input", input.toString());
+      }
+    }
+
+    NotificationManagerCompat.from(context)
+        .cancel(intent.getIntExtra(NOTIFICATION_ID_INTENT_KEY, 0));
+
+    InitialNotificationEvent initialNotificationEvent =
+        new InitialNotificationEvent(notificationModel, extras);
+    EventBus.postSticky(initialNotificationEvent);
+
+    // Send event
+    EventBus.post(new NotificationEvent(TYPE_ACTION_PRESS, notificationModel, extras));
+  }
+
+  private static void handleNotificationPressIntent(Context context, Intent intent) {
+    Bundle notification = intent.getBundleExtra("notification");
+
+    if (notification == null) {
+      return;
+    }
+
+    NotificationModel notificationModel = NotificationModel.fromBundle(notification);
+
+    Bundle pressAction = intent.getBundleExtra("pressAction");
+    NotificationAndroidPressActionModel pressActionBundle = null;
+
+    Bundle extras = new Bundle();
+
+    if (pressAction != null) {
+      pressActionBundle = NotificationAndroidPressActionModel.fromBundle(pressAction);
+      extras.putBundle("pressAction", pressActionBundle.toBundle());
+    }
+
+    EventBus.post(new NotificationEvent(TYPE_PRESS, notificationModel, extras));
+
+    if (pressActionBundle == null) {
+      return;
+    }
+
+    String mainComponent = pressActionBundle.getMainComponent();
+    InitialNotificationEvent initialNotificationEvent =
+        new InitialNotificationEvent(notificationModel, extras);
+    EventBus.postSticky(initialNotificationEvent);
+
+    // Send sticky event to save the mainComponent
+    if (mainComponent != null) {
+      EventBus.postSticky(new MainComponentEvent(mainComponent));
+    }
+  }
+}

package/android/src/main/java/app/notifee/core/Preferences.java

@@ -0,0 +1,79 @@
+package app.notifee.core;
+
+/*
+ * 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.content.Context;
+import android.content.SharedPreferences;
+
+class Preferences {
+  private static final String PREFERENCES_FILE = "app.notifee.core";
+  private static Preferences sharedInstance = new Preferences();
+  private SharedPreferences preferences;
+
+  static Preferences getSharedInstance() {
+    return sharedInstance;
+  }
+
+  boolean contains(String key) {
+    return getPreferences().contains(key);
+  }
+
+  void setBooleanValue(String key, boolean value) {
+    getPreferences().edit().putBoolean(key, value).apply();
+  }
+
+  boolean getBooleanValue(String key, boolean defaultValue) {
+    return getPreferences().getBoolean(key, defaultValue);
+  }
+
+  void setLongValue(String key, long value) {
+    getPreferences().edit().putLong(key, value).apply();
+  }
+
+  long getLongValue(String key, long defaultValue) {
+    return getPreferences().getLong(key, defaultValue);
+  }
+
+  void setIntValue(String key, int value) {
+    getPreferences().edit().putInt(key, value).apply();
+  }
+
+  int getIntValue(String key, int defaultValue) {
+    return getPreferences().getInt(key, defaultValue);
+  }
+
+  void setStringValue(String key, String value) {
+    getPreferences().edit().putString(key, value).apply();
+  }
+
+  String getStringValue(String key, String defaultValue) {
+    return getPreferences().getString(key, defaultValue);
+  }
+
+  void clearAll() {
+    getPreferences().edit().clear().apply();
+  }
+
+  private SharedPreferences getPreferences() {
+    if (preferences != null) return preferences;
+    preferences =
+        ContextHolder.getApplicationContext()
+            .getSharedPreferences(PREFERENCES_FILE, Context.MODE_PRIVATE);
+    return preferences;
+  }
+}

package/android/src/main/java/app/notifee/core/RebootBroadcastReceiver.java

@@ -0,0 +1,38 @@
+package app.notifee.core;
+
+/*
+ * 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.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+/*
+ * This is invoked when the phone restarts to ensure that all notifications created by the alarm manager
+ * are rescheduled correctly, as Android removes all scheduled alarms when the phone shuts down.
+ */
+public class RebootBroadcastReceiver extends BroadcastReceiver {
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    Log.i("RebootReceiver", "Received reboot event");
+    if (ContextHolder.getApplicationContext() == null) {
+      ContextHolder.setApplicationContext(context.getApplicationContext());
+    }
+    new NotifeeAlarmManager().rescheduleNotifications();
+  }
+}