@cometchat/calls-sdk-react-native 4.0.9-experimental.2 → 4.1.0

package/android/src/main/java/com/CometChatCalls/CallNotificationService.java

@@ -0,0 +1,93 @@
+package com.CometChatCalls;
+
+import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.app.Service;
+import android.content.Intent;
+import android.content.pm.ServiceInfo;
+import android.os.Build;
+import android.os.IBinder;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.app.NotificationCompat;
+
+public class CallNotificationService extends Service {
+
+    private static final String CHANNEL_ID = "CALL_NOTIFICATION_CHANNEL";
+    private static final int NOTIFICATION_ID = 1;
+    private static long startingTime = 0;
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        createNotificationChannel();
+        Intent notificationIntent = new Intent(this, CallNotificationService.class);
+        PendingIntent pendingIntent = PendingIntent.getActivity(this, 0, notificationIntent, PendingIntent.FLAG_IMMUTABLE);
+        if (startingTime == 0) {
+            startingTime = System.currentTimeMillis();
+        }
+        Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
+                .setCategory(NotificationCompat.CATEGORY_CALL)
+                .setContentTitle("Ongoing Call")
+                .setContentText("Tap to return to the call")
+                .setPriority(NotificationCompat.PRIORITY_DEFAULT)
+                .setSmallIcon(R.drawable.callingcomponent_icons_headphones_pluged)
+                .setContentIntent(pendingIntent)
+                .setOngoing(true)
+                .setWhen(startingTime)
+                .setUsesChronometer(true)
+                .setAutoCancel(false)
+                .setVisibility(NotificationCompat.VISIBILITY_PUBLIC)
+                .setOnlyAlertOnce(true)
+                .build();
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+            startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK | ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE);
+        } else if (Build.VERSION.SDK_INT == Build.VERSION_CODES.Q) {
+            startForeground(NOTIFICATION_ID, notification, ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK);
+        } else {
+            startForeground(NOTIFICATION_ID, notification);
+        }
+
+        return START_NOT_STICKY;
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        stopSelf();
+    }
+
+
+    static void resetStartingTime() {
+        startingTime = 0;
+    }
+
+    @Override
+    public void onTaskRemoved(Intent rootIntent) {
+        super.onTaskRemoved(rootIntent);
+        stopSelf();
+        CallNotificationServiceModule.sendEvent("onTaskRemoved", "onTaskRemoved");
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+
+    private void createNotificationChannel() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel serviceChannel = new NotificationChannel(
+                    CHANNEL_ID,
+                    "Call Notification Service",
+                    NotificationManager.IMPORTANCE_DEFAULT
+            );
+            NotificationManager manager = getSystemService(NotificationManager.class);
+            manager.createNotificationChannel(serviceChannel);
+        }
+    }
+}

package/android/src/main/java/com/CometChatCalls/CallNotificationServiceModule.java

@@ -0,0 +1,48 @@
+package com.CometChatCalls;
+
+import android.content.Intent;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+public class CallNotificationServiceModule extends ReactContextBaseJavaModule {
+
+    public static ReactApplicationContext reactContext;
+
+    public CallNotificationServiceModule(ReactApplicationContext reactContext) {
+        super(reactContext);
+        CallNotificationServiceModule.reactContext = reactContext;
+    }
+
+    public static void sendEvent(String eventName, String message) {
+        if (reactContext != null) {
+            reactContext
+                    .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                    .emit(eventName, message);
+        }
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return "CallNotificationService";
+    }
+
+    @ReactMethod
+    public void startService() {
+        Intent serviceIntent = new Intent(reactContext, CallNotificationService.class);
+        reactContext.startService(serviceIntent);
+    }
+
+    @ReactMethod
+    public static void stopService() {
+        Intent serviceIntent = new Intent(reactContext, CallNotificationService.class);
+        reactContext.stopService(serviceIntent);
+        CallNotificationService.resetStartingTime();
+    }
+}
+

package/android/src/main/java/com/CometChatCalls/CometChatCallsPackage.java

@@ -16,20 +16,29 @@
 
 package com.CometChatCalls;
 
+import androidx.annotation.NonNull;
+import androidx.annotation.NonNull;
 import com.facebook.react.ReactPackage;
 import com.facebook.react.bridge.JavaScriptModule;
 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.ArrayList;
 import java.util.Collections;
 import java.util.List;
 
 public class CometChatCallsPackage implements ReactPackage {
 
+    @NonNull
     @Override
-    public List<NativeModule> createNativeModules(ReactApplicationContext reactContext) {
-        return Collections.<NativeModule>singletonList(new AudioModeModule(reactContext));
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new AudioModeModule(reactContext));
+        modules.add(new CallNotificationServiceModule(reactContext));
+        modules.add(new PictureInPictureModule(reactContext));
+        return modules;
     }
 
     // Deprecated RN 0.47
@@ -37,8 +46,9 @@ public class CometChatCallsPackage implements ReactPackage {
         return Collections.emptyList();
     }
 
+    @NonNull
     @Override
-    public List<ViewManager> createViewManagers(ReactApplicationContext reactContext) {
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
         return Collections.emptyList();
     }
 

package/android/src/main/java/com/CometChatCalls/PictureInPictureModule.java

@@ -0,0 +1,133 @@
+package com.CometChatCalls;
+
+import android.app.Activity;
+import android.app.KeyguardManager;
+import android.app.PictureInPictureParams;
+import android.content.Context;
+import android.media.AudioAttributes;
+import android.media.AudioFocusRequest;
+import android.media.AudioManager;
+import android.os.Build;
+import android.os.PowerManager;
+import android.util.DisplayMetrics;
+import android.util.Log;
+import android.util.Rational;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.RequiresApi;
+
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReactContextBaseJavaModule;
+import com.facebook.react.bridge.ReactMethod;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+public class PictureInPictureModule extends ReactContextBaseJavaModule {
+    public static final String NAME = "PictureInPictureModule";
+    public static final String TAG = NAME;
+    public static boolean isPIPInitialized = false;
+    private ReactApplicationContext mReactContext;
+    public  PowerManager.WakeLock wakeLock;
+    private AudioManager audioManager;
+    private static boolean isEnabled;
+
+    public PictureInPictureModule(@NonNull ReactApplicationContext reactContext) {
+        super(reactContext);
+        mReactContext = reactContext;
+    }
+
+    @NonNull
+    @Override
+    public String getName() {
+        return NAME;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    @ReactMethod
+    public void enterPictureInPictureMode() {
+        if (!isEnabled) {
+            return;
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            Activity currentActivity = getCurrentActivity();
+            if (currentActivity != null) {
+                DisplayMetrics metrics = currentActivity.getResources().getDisplayMetrics();
+
+                Rational aspectRatio = new Rational(metrics.widthPixels, metrics.heightPixels);
+                PictureInPictureParams params = new PictureInPictureParams.Builder()
+                        .setAspectRatio(aspectRatio)
+                        .build();
+                currentActivity.enterPictureInPictureMode(params);
+            }
+        }
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    @ReactMethod
+    public void exitPictureInPictureMode() {
+        Activity currentActivity = getCurrentActivity();
+
+        try {
+            if (currentActivity != null) {
+                if (currentActivity.isInPictureInPictureMode()) {
+                    currentActivity.moveTaskToBack(true);
+                }
+            }
+        } catch (Exception e) {
+            Log.e(TAG, "[exitPictureInPictureMode]", e);
+        }
+    }
+
+    @ReactMethod
+    public void setPictureInPictureEnabled(Boolean enabled) {
+        isEnabled = enabled;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    @ReactMethod
+    public void initializePictureInPictureMode() {
+        isPIPInitialized = true;
+    }
+
+    @RequiresApi(api = Build.VERSION_CODES.O)
+    @ReactMethod
+    public void getIsPIPInitialized(Promise promise) {
+        promise.resolve(isPIPInitialized);
+    }
+
+    public void notifyPipModeChanged(boolean isInPipMode) {
+        mReactContext.getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+                .emit("onPipModeChanged", isInPipMode);
+    }
+
+    @ReactMethod
+    private void requestAudioFocus() {
+        audioManager = (AudioManager) mReactContext.getSystemService(Context.AUDIO_SERVICE);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            int result = audioManager.requestAudioFocus(new AudioFocusRequest.Builder(AudioManager.AUDIOFOCUS_GAIN)
+                    .setAudioAttributes(
+                            new AudioAttributes.Builder()
+                                    .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+                                    .setContentType(AudioAttributes.CONTENT_TYPE_SPEECH)
+                                    .build()
+                    )
+                    .build());
+            if (result == AudioManager.AUDIOFOCUS_REQUEST_GRANTED) {
+                Log.d(TAG, "Audio focus granted");
+            } else {
+                Log.d(TAG, "Audio focus request failed");
+            }
+        }
+    }
+
+    @ReactMethod
+    public void isDeviceLocked(Promise promise) {
+        try {
+            KeyguardManager keyguardManager = (KeyguardManager) mReactContext.getSystemService(Context.KEYGUARD_SERVICE);
+            boolean isLocked = keyguardManager.isDeviceLocked();
+            promise.resolve(isLocked);
+        } catch (Exception e) {
+            promise.reject("ERROR", e.getMessage());
+        }
+    }
+}