@ammarahmed/notifee-react-native 7.3.0 → 7.4.1

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

@@ -0,0 +1,268 @@
+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.event.NotificationEvent.TYPE_ACTION_PRESS;
+import static app.notifee.core.event.NotificationEvent.TYPE_DISMISSED;
+import static app.notifee.core.event.NotificationEvent.TYPE_PRESS;
+
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import android.os.IBinder;
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.core.app.RemoteInput;
+import app.notifee.core.event.InitialNotificationEvent;
+import app.notifee.core.event.MainComponentEvent;
+import app.notifee.core.event.NotificationEvent;
+import app.notifee.core.model.NotificationAndroidModel;
+import app.notifee.core.model.NotificationAndroidPressActionModel;
+import app.notifee.core.model.NotificationModel;
+import app.notifee.core.utility.IntentUtils;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class ReceiverService extends Service {
+  private static final String TAG = "ReceiverService";
+  public static final String REMOTE_INPUT_RECEIVER_KEY =
+      "app.notifee.core.ReceiverService.REMOTE_INPUT_RECEIVER_KEY";
+
+  private static final AtomicInteger uniqueIds = new AtomicInteger(0);
+
+  static final String DELETE_INTENT = "app.notifee.core.ReceiverService.DELETE_INTENT";
+  static final String PRESS_INTENT = "app.notifee.core.ReceiverService.PRESS_INTENT";
+  static final String ACTION_PRESS_INTENT = "app.notifee.core.ReceiverService.ACTION_PRESS_INTENT";
+
+  /**
+   * Creates a PendingIntent, which when sent triggers this class.
+   *
+   * @param action An Action - matches up with the JS EventType Enum.
+   * @param extraKeys Array of strings
+   * @param extraBundles One or more bundles
+   */
+  public static PendingIntent createIntent(
+      String action, String[] extraKeys, Bundle... extraBundles) {
+    Context context = ContextHolder.getApplicationContext();
+    Intent intent = new Intent(context, ReceiverService.class);
+    intent.setAction(action);
+
+    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);
+      }
+    }
+
+    int uniqueInt = uniqueIds.getAndIncrement();
+    return PendingIntent.getService(
+        context, uniqueInt, intent, PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+  }
+
+  @Nullable
+  @Override
+  public IBinder onBind(Intent intent) {
+    return null;
+  }
+
+  @Override
+  public int onStartCommand(Intent intent, int flags, int startId) {
+    String action = intent.getAction();
+
+    if (action == null) {
+      return START_NOT_STICKY;
+    }
+
+    switch (action) {
+      case DELETE_INTENT:
+        onDeleteIntent(intent);
+        break;
+      case PRESS_INTENT:
+        onPressIntent(intent);
+        break;
+      case ACTION_PRESS_INTENT:
+        onActionPressIntent(intent);
+        break;
+    }
+
+    return START_NOT_STICKY;
+  }
+
+  /** Handle users delete/dismiss intents */
+  private void onDeleteIntent(Intent intent) {
+    Bundle notification = intent.getBundleExtra("notification");
+
+    if (notification == null) {
+      return;
+    }
+
+    NotificationModel notificationModel = NotificationModel.fromBundle(notification);
+    EventBus.post(new NotificationEvent(TYPE_DISMISSED, notificationModel));
+  }
+
+  /** Handle user notification press */
+  private void onPressIntent(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 launchActivity = pressActionBundle.getLaunchActivity();
+    String mainComponent = pressActionBundle.getMainComponent();
+
+    if (launchActivity != null || mainComponent != null) {
+      InitialNotificationEvent initialNotificationEvent =
+          new InitialNotificationEvent(notificationModel, extras);
+      launchPendingIntentActivity(
+          initialNotificationEvent,
+          launchActivity,
+          mainComponent,
+          pressActionBundle.getLaunchActivityFlags());
+    }
+  }
+
+  /** Handle action intents */
+  private void onActionPressIntent(Intent intent) {
+    Bundle notification = intent.getBundleExtra("notification");
+    Bundle pressAction = intent.getBundleExtra("pressAction");
+
+    if (notification == null || pressAction == null) {
+      return;
+    }
+
+    NotificationModel notificationModel = NotificationModel.fromBundle(notification);
+    NotificationAndroidModel notificationAndroidModel = notificationModel.getAndroid();
+    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());
+      }
+    }
+
+    EventBus.post(new NotificationEvent(TYPE_ACTION_PRESS, notificationModel, extras));
+
+    if (notificationModel.getAndroid().getAutoCancel()) {
+      NotificationManagerCompat notificationManagerCompat =
+          NotificationManagerCompat.from(getApplicationContext());
+
+      notificationManagerCompat.cancel(
+          notificationAndroidModel.getTag(), notificationModel.getId().hashCode());
+    }
+
+    String launchActivity = pressActionBundle.getLaunchActivity();
+    String mainComponent = pressActionBundle.getMainComponent();
+
+    if (launchActivity != null || mainComponent != null) {
+      InitialNotificationEvent initialNotificationEvent =
+          new InitialNotificationEvent(notificationModel, extras);
+      launchPendingIntentActivity(
+          initialNotificationEvent,
+          launchActivity,
+          mainComponent,
+          pressActionBundle.getLaunchActivityFlags());
+
+      int targetSdkVersion =
+          ContextHolder.getApplicationContext().getApplicationInfo().targetSdkVersion;
+
+      // Close notification drawer if application SDK is Android 11 and lower
+      // See
+      // https://developer.android.com/about/versions/12/behavior-changes-all#close-system-dialogs
+      if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+        ContextHolder.getApplicationContext()
+            .sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS));
+      }
+    }
+  }
+
+  private void launchPendingIntentActivity(
+      InitialNotificationEvent initialNotificationEvent,
+      @Nullable String launchActivity,
+      @Nullable String mainComponent,
+      int launchActivityFlags) {
+    Class<?> launchActivityClass = IntentUtils.getLaunchActivity(launchActivity);
+    if (launchActivityClass == null) {
+      Logger.e(TAG, "Failed to get launch activity");
+      return;
+    }
+
+    Intent launchIntent = new Intent(getApplicationContext(), launchActivityClass);
+
+    if (launchActivityFlags != -1) {
+      launchIntent.addFlags(launchActivityFlags);
+    }
+
+    if (mainComponent != null) {
+      launchIntent.putExtra("mainComponent", mainComponent);
+    }
+
+    PendingIntent pendingContentIntent =
+        PendingIntent.getActivity(
+            getApplicationContext(),
+            initialNotificationEvent.getNotificationModel().getHashCode(),
+            launchIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_MUTABLE);
+
+    try {
+      pendingContentIntent.send();
+      EventBus.postSticky(initialNotificationEvent);
+
+      // Send sticky event to save the mainComponent
+      if (mainComponent != null) {
+        EventBus.postSticky(new MainComponentEvent(mainComponent));
+      }
+    } catch (Exception e) {
+      Logger.e(
+          "ReceiverService",
+          "Failed to send PendingIntent from launchPendingIntentActivity for notification "
+              + initialNotificationEvent.getNotificationModel().getId(),
+          e);
+    }
+  }
+}

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

@@ -0,0 +1,87 @@
+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 androidx.annotation.Keep;
+import androidx.annotation.NonNull;
+import androidx.concurrent.futures.CallbackToFutureAdapter;
+import androidx.work.ListenableWorker;
+import androidx.work.WorkerParameters;
+import com.google.common.util.concurrent.ListenableFuture;
+
+public class Worker extends ListenableWorker {
+  static final String KEY_WORK_TYPE = "workType";
+  static final String KEY_IS_PRIMARY = "isPrimaryKey";
+  static final String WORK_TYPE_BLOCK_STATE_RECEIVER =
+      "app.notifee.core.BlockStateBroadcastReceiver.WORKER";
+  static final String WORK_TYPE_NOTIFICATION_TRIGGER =
+      "app.notifee.core.NotificationManager.TRIGGER";
+  static final String WORK_REQUEST_ONE_TIME = "OneTime";
+  static final String WORK_REQUEST_PERIODIC = "Periodic";
+  static final String KEY_WORK_REQUEST = "workRequestType";
+  private static final String TAG = "Worker";
+
+  private CallbackToFutureAdapter.Completer<Result> mCompleter;
+
+  /**
+   * @param appContext The application {@link Context}
+   * @param workerParams Parameters to setup the internal state of this worker
+   */
+  @Keep
+  public Worker(@NonNull Context appContext, @NonNull WorkerParameters workerParams) {
+    super(appContext, workerParams);
+  }
+
+  @Override
+  public void onStopped() {
+    if (mCompleter != null) mCompleter.set(Result.failure());
+    mCompleter = null;
+  }
+
+  @NonNull
+  @Override
+  public ListenableFuture<Result> startWork() {
+    return CallbackToFutureAdapter.getFuture(
+        completer -> {
+          mCompleter = completer;
+          String workType = getInputData().getString(KEY_WORK_TYPE);
+          if (workType == null) {
+            Logger.d(TAG, "received task with no input key type.");
+            completer.set(Result.success());
+            return "Worker.startWork operation cancelled - no input.";
+          }
+
+          switch (workType) {
+            case WORK_TYPE_BLOCK_STATE_RECEIVER:
+              Logger.d(TAG, "received task with type " + workType);
+              BlockStateBroadcastReceiver.doWork(getInputData(), completer);
+              break;
+            case WORK_TYPE_NOTIFICATION_TRIGGER:
+              NotificationManager.doScheduledWork(getInputData(), completer);
+              break;
+            default:
+              Logger.d(TAG, "unknown work type received: " + workType);
+              completer.set(Result.success());
+              return "Worker.startWork operation cancelled - unknown work type.";
+          }
+
+          return "Worker.startWork operation created successfully.";
+        });
+  }
+}

package/android/src/main/java/app/notifee/core/database/NotifeeCoreDatabase.java

@@ -0,0 +1,76 @@
+package app.notifee.core.database;
+
+/*
+ * 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 androidx.annotation.VisibleForTesting;
+import androidx.room.Database;
+import androidx.room.Room;
+import androidx.room.RoomDatabase;
+import androidx.room.migration.Migration;
+import androidx.sqlite.db.SupportSQLiteDatabase;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.MoreExecutors;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+@Database(
+    entities = {WorkDataEntity.class},
+    version = 2,
+    exportSchema = true)
+public abstract class NotifeeCoreDatabase extends RoomDatabase {
+
+  public abstract WorkDataDao workDao();
+
+  private static volatile NotifeeCoreDatabase INSTANCE;
+
+  static final ExecutorService databaseWriteExecutor = Executors.newCachedThreadPool();
+  static final ListeningExecutorService databaseWriteListeningExecutor = MoreExecutors.listeningDecorator(databaseWriteExecutor);
+
+  /**
+   * Migrate from: version 1 to version 2 - where the {@link WorkDataEntity} has an extra field:
+   * alert
+   */
+  @VisibleForTesting
+  static final Migration MIGRATION_1_2 =
+      new Migration(1, 2) {
+        @Override
+        public void migrate(SupportSQLiteDatabase database) {
+          database.execSQL(
+              "ALTER TABLE work_data"
+                  + " ADD COLUMN with_alarm_manager INTEGER NOT NULL DEFAULT 0");
+        }
+      };
+
+  static NotifeeCoreDatabase getDatabase(final Context context) {
+    if (INSTANCE == null) {
+      synchronized (NotifeeCoreDatabase.class) {
+        if (INSTANCE == null) {
+          INSTANCE =
+              Room.databaseBuilder(
+                      context.getApplicationContext(),
+                      NotifeeCoreDatabase.class,
+                      "notifee_core_database")
+                  .addMigrations(MIGRATION_1_2)
+                  .build();
+        }
+      }
+    }
+    return INSTANCE;
+  }
+}

package/android/src/main/java/app/notifee/core/database/WorkDataDao.java

@@ -0,0 +1,52 @@
+package app.notifee.core.database;
+
+/*
+ * 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 androidx.room.Dao;
+import androidx.room.Insert;
+import androidx.room.OnConflictStrategy;
+import androidx.room.Query;
+import androidx.room.Update;
+import java.util.List;
+
+@Dao
+public interface WorkDataDao {
+  @Insert(onConflict = OnConflictStrategy.REPLACE)
+  void insert(WorkDataEntity workDataEntity);
+
+  @Update(onConflict = OnConflictStrategy.REPLACE)
+  void update(WorkDataEntity workDataEntity);
+
+  @Query("DELETE FROM work_data")
+  void deleteAll();
+
+  @Query("DELETE FROM work_data WHERE id = :id")
+  void deleteById(String id);
+
+  @Query("DELETE FROM work_data WHERE id in (:ids)")
+  void deleteByIds(List<String> ids);
+
+  @Query("SELECT * from work_data WHERE id = :id")
+  WorkDataEntity getWorkDataById(String id);
+
+  @Query("SELECT * FROM work_data WHERE with_alarm_manager = :withAlarmManager")
+  List<WorkDataEntity> getAllWithAlarmManager(Boolean withAlarmManager);
+
+  @Query("SELECT * FROM work_data")
+  List<WorkDataEntity> getAll();
+}

package/android/src/main/java/app/notifee/core/database/WorkDataEntity.java

@@ -0,0 +1,68 @@
+package app.notifee.core.database;
+
+/*
+ * 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 androidx.annotation.NonNull;
+import androidx.room.ColumnInfo;
+import androidx.room.Entity;
+import androidx.room.PrimaryKey;
+
+@Entity(tableName = "work_data")
+public class WorkDataEntity {
+
+  @PrimaryKey(autoGenerate = false)
+  @NonNull
+  private String id;
+
+  @ColumnInfo(name = "notification", typeAffinity = ColumnInfo.BLOB)
+  private byte[] notification;
+
+  @ColumnInfo(name = "trigger", typeAffinity = ColumnInfo.BLOB)
+  private byte[] trigger;
+
+  @ColumnInfo(name = "with_alarm_manager", defaultValue = "0")
+  @NonNull
+  private Boolean withAlarmManager;
+
+  public WorkDataEntity(String id, byte[] notification, byte[] trigger, Boolean withAlarmManager) {
+    this.id = id;
+    this.notification = notification;
+    this.trigger = trigger;
+    this.withAlarmManager = withAlarmManager;
+  }
+
+  public String getId() {
+    return this.id;
+  }
+
+  public byte[] getNotification() {
+    return this.notification;
+  }
+
+  public byte[] getTrigger() {
+    return this.trigger;
+  }
+
+  public Boolean getWithAlarmManager() {
+    return this.withAlarmManager;
+  }
+
+  public void setTrigger(byte[] trigger) {
+    this.trigger = trigger;
+  }
+}

package/android/src/main/java/app/notifee/core/database/WorkDataRepository.java

@@ -0,0 +1,107 @@
+package app.notifee.core.database;
+
+/*
+ * 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.os.Bundle;
+import androidx.annotation.NonNull;
+import app.notifee.core.model.NotificationModel;
+import app.notifee.core.utility.ObjectUtils;
+import com.google.common.util.concurrent.ListenableFuture;
+import java.util.List;
+
+public class WorkDataRepository {
+  private WorkDataDao mWorkDataDao;
+  private static WorkDataRepository mInstance;
+
+  public static @NonNull WorkDataRepository getInstance(@NonNull Context context) {
+    synchronized (WorkDataRepository.class) {
+      if (mInstance == null) {
+        mInstance = new WorkDataRepository(context);
+      }
+
+      return mInstance;
+    }
+  }
+
+  public WorkDataRepository(Context context) {
+    NotifeeCoreDatabase db = NotifeeCoreDatabase.getDatabase(context);
+    mWorkDataDao = db.workDao();
+  }
+
+  public void insert(WorkDataEntity workData) {
+    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
+        () -> {
+          mWorkDataDao.insert(workData);
+        });
+  }
+
+  public ListenableFuture<WorkDataEntity> getWorkDataById(String id) {
+    return NotifeeCoreDatabase.databaseWriteListeningExecutor.submit(() -> mWorkDataDao.getWorkDataById(id));
+  }
+
+  public ListenableFuture<List<WorkDataEntity>> getAllWithAlarmManager(Boolean withAlarmManager) {
+    return
+        NotifeeCoreDatabase.databaseWriteListeningExecutor.submit(
+        () -> mWorkDataDao.getAllWithAlarmManager(withAlarmManager));
+  }
+
+  public ListenableFuture<List<WorkDataEntity>> getAll() {
+    return NotifeeCoreDatabase.databaseWriteListeningExecutor.submit( () -> mWorkDataDao.getAll());
+  }
+
+  public void deleteById(String id) {
+    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
+        () -> {
+          mWorkDataDao.deleteById(id);
+        });
+  }
+
+  public void deleteByIds(List<String> ids) {
+    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
+        () -> {
+          mWorkDataDao.deleteByIds(ids);
+        });
+  }
+
+  public void deleteAll() {
+    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
+        () -> {
+          mWorkDataDao.deleteAll();
+        });
+  }
+
+  public static void insertTriggerNotification(
+      NotificationModel notificationModel, Bundle triggerBundle, Boolean withAlarmManager) {
+    WorkDataEntity workData =
+        new WorkDataEntity(
+            notificationModel.getId(),
+            ObjectUtils.bundleToBytes(notificationModel.toBundle()),
+            ObjectUtils.bundleToBytes(triggerBundle),
+            withAlarmManager);
+
+    mInstance.insert(workData);
+  }
+
+  public void update(WorkDataEntity workData) {
+    NotifeeCoreDatabase.databaseWriteListeningExecutor.execute(
+        () -> {
+          mWorkDataDao.update(workData);
+        });
+  }
+}