@ammarahmed/notifee-react-native 7.3.1 → 7.4.2

package/android/src/main/java/app/notifee/core/model/NotificationAndroidPressActionModel.java

@@ -0,0 +1,146 @@
+package app.notifee.core.model;
+
+/*
+ * 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.Intent;
+import android.os.Build;
+import android.os.Bundle;
+import androidx.annotation.Keep;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Objects;
+
+@Keep
+public class NotificationAndroidPressActionModel {
+
+  private Bundle mNotificationAndroidPressActionBundle;
+
+  private NotificationAndroidPressActionModel(Bundle pressActionBundle) {
+    mNotificationAndroidPressActionBundle = pressActionBundle;
+  }
+
+  public static NotificationAndroidPressActionModel fromBundle(Bundle pressActionBundle) {
+    return new NotificationAndroidPressActionModel(pressActionBundle);
+  }
+
+  public Bundle toBundle() {
+    return (Bundle) mNotificationAndroidPressActionBundle.clone();
+  }
+
+  public @NonNull String getId() {
+    return Objects.requireNonNull(mNotificationAndroidPressActionBundle.getString("id"));
+  }
+
+  public @Nullable String getLaunchActivity() {
+    return mNotificationAndroidPressActionBundle.getString("launchActivity");
+  }
+
+  public int getLaunchActivityFlags() {
+    if (!mNotificationAndroidPressActionBundle.containsKey("launchActivityFlags")) {
+      return -1;
+    }
+
+    int baseFlags = 0;
+    ArrayList<Integer> launchActivityFlags =
+        Objects.requireNonNull(
+            mNotificationAndroidPressActionBundle.getIntegerArrayList("launchActivityFlags"));
+
+    for (int i = 0; i < launchActivityFlags.size(); i++) {
+      Integer flag = launchActivityFlags.get(i);
+      switch (flag) {
+        case 0:
+          baseFlags |= Intent.FLAG_ACTIVITY_NO_HISTORY;
+          break;
+        case 1:
+          baseFlags |= Intent.FLAG_ACTIVITY_SINGLE_TOP;
+          break;
+        case 2:
+          baseFlags |= Intent.FLAG_ACTIVITY_NEW_TASK;
+          break;
+        case 3:
+          baseFlags |= Intent.FLAG_ACTIVITY_MULTIPLE_TASK;
+          break;
+        case 4:
+          baseFlags |= Intent.FLAG_ACTIVITY_CLEAR_TOP;
+          break;
+        case 5:
+          baseFlags |= Intent.FLAG_ACTIVITY_FORWARD_RESULT;
+          break;
+        case 6:
+          baseFlags |= Intent.FLAG_ACTIVITY_PREVIOUS_IS_TOP;
+          break;
+        case 7:
+          baseFlags |= Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS;
+          break;
+        case 8:
+          baseFlags |= Intent.FLAG_ACTIVITY_BROUGHT_TO_FRONT;
+          break;
+        case 9:
+          baseFlags |= Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED;
+          break;
+        case 10:
+          baseFlags |= Intent.FLAG_ACTIVITY_LAUNCHED_FROM_HISTORY;
+          break;
+        case 11:
+          baseFlags |= Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET;
+          break;
+        case 12:
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            baseFlags |= Intent.FLAG_ACTIVITY_NEW_DOCUMENT;
+          }
+          break;
+        case 13:
+          baseFlags |= Intent.FLAG_ACTIVITY_NO_USER_ACTION;
+          break;
+        case 14:
+          baseFlags |= Intent.FLAG_ACTIVITY_REORDER_TO_FRONT;
+          break;
+        case 15:
+          baseFlags |= Intent.FLAG_ACTIVITY_NO_ANIMATION;
+          break;
+        case 16:
+          baseFlags |= Intent.FLAG_ACTIVITY_CLEAR_TASK;
+          break;
+        case 17:
+          baseFlags |= Intent.FLAG_ACTIVITY_TASK_ON_HOME;
+          break;
+        case 18:
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
+            baseFlags |= Intent.FLAG_ACTIVITY_RETAIN_IN_RECENTS;
+          }
+          break;
+        case 19:
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            baseFlags |= Intent.FLAG_ACTIVITY_LAUNCH_ADJACENT;
+          }
+          break;
+        case 20:
+          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            baseFlags |= Intent.FLAG_ACTIVITY_MATCH_EXTERNAL;
+          }
+          break;
+      }
+    }
+    return baseFlags;
+  }
+
+  public @Nullable String getMainComponent() {
+    return mNotificationAndroidPressActionBundle.getString("mainComponent");
+  }
+}

package/android/src/main/java/app/notifee/core/model/NotificationAndroidStyleModel.java

@@ -0,0 +1,341 @@
+package app.notifee.core.model;
+
+/*
+ * 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.graphics.Bitmap;
+import android.os.Bundle;
+import androidx.annotation.Keep;
+import androidx.annotation.Nullable;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.Person;
+import androidx.core.graphics.drawable.IconCompat;
+import app.notifee.core.Logger;
+import app.notifee.core.utility.ObjectUtils;
+import app.notifee.core.utility.ResourceUtils;
+import app.notifee.core.utility.TextUtils;
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.common.util.concurrent.ListeningExecutorService;
+import com.google.common.util.concurrent.SettableFuture;
+import java.util.ArrayList;
+import java.util.Objects;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+@Keep
+public class NotificationAndroidStyleModel {
+  private static final String TAG = "NotificationAndroidStyle";
+  private Bundle mNotificationAndroidStyleBundle;
+
+  private NotificationAndroidStyleModel(Bundle styleBundle) {
+    mNotificationAndroidStyleBundle = styleBundle;
+  }
+
+  public static NotificationAndroidStyleModel fromBundle(Bundle styleBundle) {
+    return new NotificationAndroidStyleModel(styleBundle);
+  }
+
+  /**
+   * Converts a person bundle from JS into a Person
+   *
+   * @param personBundle
+   * @return
+   */
+  private static ListenableFuture<Person> getPerson(
+    ListeningExecutorService lExecutor, Bundle personBundle) {
+    return lExecutor.submit(
+        () -> {
+          Person.Builder personBuilder = new Person.Builder();
+
+          personBuilder.setName(personBundle.getString("name"));
+
+          if (personBundle.containsKey("id")) {
+            personBuilder.setKey(personBundle.getString("id"));
+          }
+
+          if (personBundle.containsKey("bot")) {
+            personBuilder.setBot(personBundle.getBoolean("bot"));
+          }
+
+          if (personBundle.containsKey("important")) {
+            personBuilder.setImportant(personBundle.getBoolean("important"));
+          }
+
+          if (personBundle.containsKey("icon")) {
+            String personIcon = Objects.requireNonNull(personBundle.getString("icon"));
+            Bitmap personIconBitmap = null;
+
+            try {
+              personIconBitmap =
+                      ResourceUtils.getImageBitmapFromUrl(personIcon)
+                          .get(10, TimeUnit.SECONDS);
+            } catch (TimeoutException e) {
+              Logger.e(
+                  TAG,
+                  "Timeout occurred whilst trying to retrieve a person icon: " + personIcon,
+                  e);
+            } catch (Exception e) {
+              Logger.e(
+                  TAG,
+                  "An error occurred whilst trying to retrieve a person icon: " + personIcon,
+                  e);
+            }
+
+            if (personIconBitmap != null) {
+              personBuilder.setIcon(IconCompat.createWithAdaptiveBitmap(personIconBitmap));
+            }
+          }
+
+          if (personBundle.containsKey("uri")) {
+            personBuilder.setUri(personBundle.getString("uri"));
+          }
+
+          return personBuilder.build();
+        });
+  }
+
+  public Bundle toBundle() {
+    return (Bundle) mNotificationAndroidStyleBundle.clone();
+  }
+
+  @Nullable
+  public ListenableFuture<NotificationCompat.Style> getStyleTask(
+    ListeningExecutorService lExecutor) {
+    int type = ObjectUtils.getInt(mNotificationAndroidStyleBundle.get("type"));
+    ListenableFuture<NotificationCompat.Style> styleTask = null;
+
+    switch (type) {
+      case 0:
+        styleTask = getBigPictureStyleTask(lExecutor);
+        break;
+      case 1:
+        styleTask = Futures.immediateFuture(getBigTextStyle());
+        break;
+      case 2:
+        styleTask = Futures.immediateFuture(getInboxStyle());
+        break;
+      case 3:
+        styleTask = getMessagingStyleTask(lExecutor);
+        break;
+    }
+
+    return styleTask;
+  }
+
+  /**
+   * Gets a BigPictureStyle for a notification
+   *
+   * @return
+   */
+  private ListenableFuture<NotificationCompat.Style> getBigPictureStyleTask(
+    ListeningExecutorService lExecutor) {
+    return lExecutor.submit(
+        () -> {
+          NotificationCompat.BigPictureStyle bigPictureStyle =
+              new NotificationCompat.BigPictureStyle();
+
+          if (mNotificationAndroidStyleBundle.containsKey("picture")) {
+            String picture =
+                Objects.requireNonNull(mNotificationAndroidStyleBundle.getString("picture"));
+            Bitmap pictureBitmap = null;
+
+            try {
+              pictureBitmap = 
+                  ResourceUtils.getImageBitmapFromUrl(picture)
+                      .get(10, TimeUnit.SECONDS);
+            } catch (TimeoutException e) {
+              Logger.e(
+                  TAG,
+                  "Timeout occurred whilst trying to retrieve a big picture style image: "
+                      + picture,
+                  e);
+            } catch (Exception e) {
+              Logger.e(
+                  TAG,
+                  "An error occurred whilst trying to retrieve a big picture style image: "
+                      + picture,
+                  e);
+            }
+
+            if (pictureBitmap != null) {
+              bigPictureStyle.bigPicture(pictureBitmap);
+            }
+          }
+
+          String largeIcon = null;
+
+          if (mNotificationAndroidStyleBundle.containsKey("largeIcon")) {
+            largeIcon = mNotificationAndroidStyleBundle.getString("largeIcon");
+
+            // largeIcon has been specified to be null for BigPicture
+            if (largeIcon == null) {
+              bigPictureStyle.bigLargeIcon(null);
+            }
+          }
+
+          if (largeIcon != null) {
+            Bitmap largeIconBitmap = null;
+
+            try {
+              largeIconBitmap = 
+                  ResourceUtils.getImageBitmapFromUrl(largeIcon)
+                    .get(10, TimeUnit.SECONDS);
+            } catch (TimeoutException e) {
+              Logger.e(
+                  TAG,
+                  "Timeout occurred whilst trying to retrieve a big picture style large icon: "
+                      + largeIcon,
+                  e);
+            } catch (Exception e) {
+              Logger.e(
+                  TAG,
+                  "An error occurred whilst trying to retrieve a big picture style large icon: "
+                      + largeIcon,
+                  e);
+            }
+
+            if (largeIconBitmap != null) {
+              bigPictureStyle.bigLargeIcon(largeIconBitmap);
+            }
+          }
+
+          if (mNotificationAndroidStyleBundle.containsKey("title")) {
+            bigPictureStyle =
+                bigPictureStyle.setBigContentTitle(
+                    TextUtils.fromHtml(mNotificationAndroidStyleBundle.getString("title")));
+          }
+
+          if (mNotificationAndroidStyleBundle.containsKey("summary")) {
+            bigPictureStyle =
+                bigPictureStyle.setSummaryText(
+                    TextUtils.fromHtml(mNotificationAndroidStyleBundle.getString("summary")));
+          }
+
+          return bigPictureStyle;
+        });
+  }
+
+  /**
+   * Gets a BigTextStyle for a notification
+   *
+   * @return NotificationCompat.BigTextStyle
+   */
+  private NotificationCompat.BigTextStyle getBigTextStyle() {
+    NotificationCompat.BigTextStyle bigTextStyle = new NotificationCompat.BigTextStyle();
+
+    if (mNotificationAndroidStyleBundle.containsKey("text")) {
+      bigTextStyle =
+          bigTextStyle.bigText(
+              TextUtils.fromHtml(mNotificationAndroidStyleBundle.getString("text")));
+    }
+
+    if (mNotificationAndroidStyleBundle.containsKey("title")) {
+      bigTextStyle =
+          bigTextStyle.setBigContentTitle(
+              TextUtils.fromHtml(mNotificationAndroidStyleBundle.getString("title")));
+    }
+
+    if (mNotificationAndroidStyleBundle.containsKey("summary")) {
+      bigTextStyle =
+          bigTextStyle.setSummaryText(
+              TextUtils.fromHtml(mNotificationAndroidStyleBundle.getString("summary")));
+    }
+
+    return bigTextStyle;
+  }
+
+  /**
+   * Gets an InboxStyle for a notification
+   *
+   * @return NotificationCompat.InboxStyle
+   */
+  private NotificationCompat.InboxStyle getInboxStyle() {
+    NotificationCompat.InboxStyle inputStyle = new NotificationCompat.InboxStyle();
+
+    if (mNotificationAndroidStyleBundle.containsKey("title")) {
+      inputStyle =
+          inputStyle.setBigContentTitle(
+              TextUtils.fromHtml(mNotificationAndroidStyleBundle.getString("title")));
+    }
+
+    if (mNotificationAndroidStyleBundle.containsKey("summary")) {
+      inputStyle =
+          inputStyle.setSummaryText(
+              TextUtils.fromHtml(mNotificationAndroidStyleBundle.getString("summary")));
+    }
+
+    ArrayList<String> lines = mNotificationAndroidStyleBundle.getStringArrayList("lines");
+
+    for (int i = 0; i < Objects.requireNonNull(lines).size(); i++) {
+      String line = lines.get(i);
+      inputStyle = inputStyle.addLine(TextUtils.fromHtml(line));
+    }
+
+    return inputStyle;
+  }
+
+  /** Gets a MessagingStyle for a notification */
+  private ListenableFuture<NotificationCompat.Style> getMessagingStyleTask(
+    ListeningExecutorService lExecutor) {
+    return lExecutor.submit(
+        () -> {
+          Person person =
+              getPerson(lExecutor, 
+                  Objects.requireNonNull(
+                      mNotificationAndroidStyleBundle.getBundle("person"))
+              ).get(20, TimeUnit.SECONDS);
+
+          NotificationCompat.MessagingStyle messagingStyle =
+              new NotificationCompat.MessagingStyle(person);
+
+          if (mNotificationAndroidStyleBundle.containsKey("title")) {
+            messagingStyle =
+                messagingStyle.setConversationTitle(
+                    TextUtils.fromHtml(mNotificationAndroidStyleBundle.getString("title")));
+          }
+
+          if (mNotificationAndroidStyleBundle.containsKey("group")) {
+            messagingStyle =
+                messagingStyle.setGroupConversation(
+                    mNotificationAndroidStyleBundle.getBoolean("group"));
+          }
+
+          ArrayList<Bundle> messages =
+              mNotificationAndroidStyleBundle.getParcelableArrayList("messages");
+
+          for (int i = 0; i < Objects.requireNonNull(messages).size(); i++) {
+            Bundle message = messages.get(i);
+            Person messagePerson = null;
+            long timestamp = ObjectUtils.getLong(message.get("timestamp"));
+
+            if (message.containsKey("person")) {
+              messagePerson =
+                  getPerson(lExecutor,
+                      Objects.requireNonNull(message.getBundle("person"))
+                  ).get(20, TimeUnit.SECONDS);
+            }
+
+            messagingStyle =
+                messagingStyle.addMessage(
+                    TextUtils.fromHtml(message.getString("text")), timestamp, messagePerson);
+          }
+
+          return messagingStyle;
+        });
+  }
+}

package/android/src/main/java/app/notifee/core/model/NotificationModel.java

@@ -0,0 +1,72 @@
+package app.notifee.core.model;
+
+/*
+ * 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.os.Bundle;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import app.notifee.core.KeepForSdk;
+import java.util.Objects;
+
+@KeepForSdk
+public class NotificationModel {
+  private Bundle mNotificationBundle;
+
+  public NotificationModel(Bundle bundle) {
+    mNotificationBundle = bundle;
+  }
+
+  public static NotificationModel fromBundle(@NonNull Bundle bundle) {
+    return new NotificationModel(bundle);
+  }
+
+  public @NonNull Integer getHashCode() {
+    return getId().hashCode();
+  }
+
+  public @NonNull String getId() {
+    return Objects.requireNonNull(mNotificationBundle.getString("id"));
+  }
+
+  public @Nullable String getTitle() {
+    return mNotificationBundle.getString("title");
+  }
+
+  public @Nullable String getSubTitle() {
+    return mNotificationBundle.getString("subtitle");
+  }
+
+  public @Nullable String getBody() {
+    return mNotificationBundle.getString("body");
+  }
+
+  public @NonNull NotificationAndroidModel getAndroid() {
+    return NotificationAndroidModel.fromBundle(mNotificationBundle.getBundle("android"));
+  }
+
+  public @NonNull Bundle getData() {
+    Bundle data = mNotificationBundle.getBundle("data");
+    if (data != null) return (Bundle) data.clone();
+    return new Bundle();
+  }
+
+  @KeepForSdk
+  public Bundle toBundle() {
+    return (Bundle) mNotificationBundle.clone();
+  }
+}