feat(android): Support android call notification style

CONTRIBUTING.md

@@ -46,13 +46,26 @@ yarn build:rn:watch
 
 ## Testing Code
 
+### Manual testing
+
+Run on iOS. Change `--simulator 'iPhone 16'` for you simulator if needed.
+```bash
+yarn run:ios
+```
+
+or Android
+```bash
+yarn run:android
+```
+
+
 ### Unit Testing
 
 The following package scripts are exported to help you run tests;
 
 - `yarn tests_rn:test` - run Jest tests once and exit.
-- `yarn tests_rn:jest-watch` - run Jest tests in interactive mode and watch for changes.
-- `yarn tests_rn:jest-coverage` - run Jest tests with coverage. Coverage is output to `./coverage`.
+- `yarn tests_rn:test-watch` - run Jest tests in interactive mode and watch for changes.
+- `yarn tests_rn:test-coverage` - run Jest tests with coverage. Coverage is output to `./coverage`.
 
 ### End-to-end Testing
 
@@ -76,6 +89,13 @@ yarn validate:all:js
 yarn validate:all:ts
 ```
 
+Runs auto-formatting
+
+```bash
+yarn format:all
+```
+
+
 ## Publishing
 
 Maintainers with write access to the repo and the npm organization can publish new versions by following the release checklist below.

android/build.gradle

@@ -109,9 +109,9 @@ dependencies {
   api 'com.facebook.fresco:fresco:2.6.0' // https://github.com/facebook/fresco/releases
 
   implementation("com.google.guava:guava:33.3.1-android") // https://github.com/google/guava
-  implementation 'androidx.core:core:1.6.0'
+  implementation 'androidx.core:core:1.10.0'
 
-  def room_version = '2.5.0' // https://developer.android.com/jetpack/androidx/releases/room
+  def room_version = '2.6.1' // https://developer.android.com/jetpack/androidx/releases/room
   implementation "androidx.room:room-runtime:$room_version"
   annotationProcessor "androidx.room:room-compiler:$room_version"
 

android/src/main/java/app/notifee/core/CallStyleNotificationPendingIntent.java

@@ -0,0 +1,46 @@
+package app.notifee.core;
+
+import static app.notifee.core.event.NotificationEvent.TYPE_ACTION_PRESS;
+
+import android.app.PendingIntent;
+import android.os.Bundle;
+import app.notifee.core.model.NotificationModel;
+import java.util.Objects;
+
+public class CallStyleNotificationPendingIntent {
+
+  public static PendingIntent getAnswerIntent(
+      Bundle callTypeActionsBundle, NotificationModel notificationModel) {
+    Bundle answerActionBundle =
+        Objects.requireNonNull(callTypeActionsBundle.getBundle("answerAction"));
+    return getPendingIntent(answerActionBundle, notificationModel.getHashCode(), notificationModel);
+  }
+
+  public static PendingIntent getDeclineIntent(
+      Bundle callTypeActionsBundle, NotificationModel notificationModel) {
+    Bundle declineActionBundle =
+        Objects.requireNonNull(callTypeActionsBundle.getBundle("declineAction"));
+    return getPendingIntent(
+        declineActionBundle, notificationModel.getHashCode() + 1, notificationModel);
+  }
+
+  public static PendingIntent getHangupIntent(
+      Bundle callTypeActionsBundle, NotificationModel notificationModel) {
+    Bundle hangUpActionBundle =
+        Objects.requireNonNull(callTypeActionsBundle.getBundle("hangUpAction"));
+    return getPendingIntent(
+        hangUpActionBundle, notificationModel.getHashCode() + 1, notificationModel);
+  }
+
+  private static PendingIntent getPendingIntent(
+      Bundle hangUpActionBundle, int notificationModel, NotificationModel notificationModel1) {
+    Bundle pressActionBundle = hangUpActionBundle.getBundle("pressAction");
+    return NotificationPendingIntent.createIntent(
+        notificationModel,
+        pressActionBundle,
+        TYPE_ACTION_PRESS,
+        new String[] {"notification", "pressAction"},
+        notificationModel1.toBundle(),
+        pressActionBundle);
+  }
+}

android/src/main/java/app/notifee/core/NotificationManager.java

@@ -438,7 +438,8 @@ private static ListenableFuture<NotificationCompat.Builder> notificationBundleTo
                   }
 
                   ListenableFuture<NotificationCompat.Style> styleTask =
-                      androidStyleBundle.getStyleTask(LISTENING_CACHED_THREAD_POOL);
+                      androidStyleBundle.getStyleTask(
+                          LISTENING_CACHED_THREAD_POOL, notificationModel);
                   if (styleTask == null) {
                     return builder;
                   }

android/src/main/java/app/notifee/core/model/CallType.java

@@ -0,0 +1,8 @@
+package app.notifee.core.model;
+
+public enum CallType {
+  UNKNOWN,
+  INCOMING,
+  ONGOING,
+  SCREENING
+}

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

@@ -17,13 +17,18 @@
  *
  */
 
+import android.app.PendingIntent;
 import android.graphics.Bitmap;
+import android.graphics.drawable.Icon;
+import android.os.Build;
 import android.os.Bundle;
 import androidx.annotation.Keep;
 import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
 import androidx.core.app.NotificationCompat;
 import androidx.core.app.Person;
 import androidx.core.graphics.drawable.IconCompat;
+import app.notifee.core.CallStyleNotificationPendingIntent;
 import app.notifee.core.Logger;
 import app.notifee.core.utility.ObjectUtils;
 import app.notifee.core.utility.ResourceUtils;
@@ -39,7 +44,7 @@
 @Keep
 public class NotificationAndroidStyleModel {
   private static final String TAG = "NotificationAndroidStyle";
-  private Bundle mNotificationAndroidStyleBundle;
+  private final Bundle mNotificationAndroidStyleBundle;
 
   private NotificationAndroidStyleModel(Bundle styleBundle) {
     mNotificationAndroidStyleBundle = styleBundle;
@@ -113,23 +118,30 @@ public Bundle toBundle() {
 
   @Nullable
   public ListenableFuture<NotificationCompat.Style> getStyleTask(
-      ListeningExecutorService lExecutor) {
-    int type = ObjectUtils.getInt(mNotificationAndroidStyleBundle.get("type"));
+      ListeningExecutorService lExecutor, NotificationModel notificationModel) {
+    NotificationAndroidStyleType type =
+        NotificationAndroidStyleType.values()[
+            ObjectUtils.getInt(mNotificationAndroidStyleBundle.get("type"))];
     ListenableFuture<NotificationCompat.Style> styleTask = null;
 
     switch (type) {
-      case 0:
+      case BIG_PICTURE:
         styleTask = getBigPictureStyleTask(lExecutor);
         break;
-      case 1:
+      case BIG_TEXT:
         styleTask = Futures.immediateFuture(getBigTextStyle());
         break;
-      case 2:
+      case INBOX:
         styleTask = Futures.immediateFuture(getInboxStyle());
         break;
-      case 3:
+      case MESSAGING:
         styleTask = getMessagingStyleTask(lExecutor);
         break;
+      case CALL:
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+          styleTask = getCallStyleTask(lExecutor, notificationModel);
+        }
+        break;
     }
 
     return styleTask;
@@ -181,7 +193,9 @@ private ListenableFuture<NotificationCompat.Style> getBigPictureStyleTask(
 
             // largeIcon has been specified to be null for BigPicture
             if (largeIcon == null) {
-              bigPictureStyle.bigLargeIcon(null);
+              if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+                bigPictureStyle.bigLargeIcon((Icon) null);
+              }
             }
           }
 
@@ -333,4 +347,65 @@ private ListenableFuture<NotificationCompat.Style> getMessagingStyleTask(
           return messagingStyle;
         });
   }
+
+  /**
+   * Gets a CallStyle for a notification
+   *
+   * @return NotificationCompat.CallStyle
+   */
+  @RequiresApi(31)
+  private ListenableFuture<NotificationCompat.Style> getCallStyleTask(
+      ListeningExecutorService lExecutor, NotificationModel notificationModel) {
+    return lExecutor.submit(
+        () -> {
+          Person caller =
+              getPerson(
+                      lExecutor,
+                      Objects.requireNonNull(mNotificationAndroidStyleBundle.getBundle("person")))
+                  .get(20, TimeUnit.SECONDS);
+
+          Bundle callTypeActionsBundle =
+              Objects.requireNonNull(mNotificationAndroidStyleBundle.getBundle("callTypeActions"));
+
+          CallType callType =
+              CallType.values()[ObjectUtils.getInt(callTypeActionsBundle.get("callType"))];
+
+          switch (callType) {
+            case INCOMING:
+              {
+                PendingIntent answerIntent =
+                    CallStyleNotificationPendingIntent.getAnswerIntent(
+                        callTypeActionsBundle, notificationModel);
+                PendingIntent declineIntent =
+                    CallStyleNotificationPendingIntent.getDeclineIntent(
+                        callTypeActionsBundle, notificationModel);
+
+                return NotificationCompat.CallStyle.forIncomingCall(
+                    caller, declineIntent, answerIntent);
+              }
+            case ONGOING:
+              {
+                PendingIntent hangupIntent =
+                    CallStyleNotificationPendingIntent.getHangupIntent(
+                        callTypeActionsBundle, notificationModel);
+
+                return NotificationCompat.CallStyle.forOngoingCall(caller, hangupIntent);
+              }
+            case SCREENING:
+              {
+                PendingIntent answerIntent =
+                    CallStyleNotificationPendingIntent.getAnswerIntent(
+                        callTypeActionsBundle, notificationModel);
+                PendingIntent hangupIntent =
+                    CallStyleNotificationPendingIntent.getHangupIntent(
+                        callTypeActionsBundle, notificationModel);
+
+                return NotificationCompat.CallStyle.forScreeningCall(
+                    caller, hangupIntent, answerIntent);
+              }
+            default:
+              throw new RuntimeException("CallStyleTask: Invalid callType " + callType);
+          }
+        });
+  }
 }

android/src/main/java/app/notifee/core/model/NotificationAndroidStyleType.java

@@ -0,0 +1,9 @@
+package app.notifee.core.model;
+
+public enum NotificationAndroidStyleType {
+  BIG_PICTURE,
+  BIG_TEXT,
+  INBOX,
+  MESSAGING,
+  CALL,
+}

docs/react-native/android/styles.mdx

@@ -144,3 +144,41 @@ Media style notifications are a way of showing a notification with intractable &
 song/video playing with album art.
 
 > Currently, Media Style notifications are not supported.
+
+# Call
+
+Call-style notifications starting from Android 12 display phone call-related notifications with a top ranking in the shade.
+
+At the root, the style accepts a `person` property, which contains information of the current device user. To see more about
+the options available to you, view the [`AndroidPerson`](/react-native/reference/androidperson) documentation.
+
+The property `callTypeActions` accepts an object with either the desired call type number (incoming, ongoing, screening) or a whole action object with only the `pressAction` object for better customization. When using the call type only, predefined pressAction IDs are provided matching the predefined button name (e.g., `answer`, `decline`, `hangUp`). If desired, we can change those IDs and even provide launch activity flags when defining the `pressAction`.
+
+It is important to known that the call style must be used with the Foreground service or a `fullScreenIntent`.
+
+To implement this style, we provide the `AndroidStyle.CALL` to the `style` object:
+
+```js
+import notifee, { AndroidStyle, AndroidImportance, AndroidCallType } from '@notifee/react-native';
+
+notifee.displayNotification({
+  title: 'Incoming call',
+  body: 'Sarah is calling',
+  android: {
+    channelId,
+    asForegroundService: true, // needs foreground Service or a fullScreenIntent.
+    category: AndroidCategory.CALL,
+    importance: AndroidImportance.HIGH,
+    style: {
+      type: AndroidStyle.CALL,
+      person: {
+        name: 'Sarah Lane',
+        icon: 'https://my-cdn.com/avatars/123.png',
+      },
+      callTypeActions: {
+        callType: AndroidCallType.INCOMING,
+      },
+    },
+  },
+});
+```