fix: warn natively if notifee is not configured for keep call alive (#1678)

fixes #1587 

Now even if notifee is installed, but not configured properly, we skip
call alive part from SDK..

upon inspecting native logs they can see whats not configured properly,
its on warn level for easiness

Author: santhoshvai

packages/react-native-sdk/android/src/main/java/com/streamvideo/reactnative/StreamVideoReactNativeModule.kt

@@ -12,6 +12,8 @@ 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.RCTDeviceEventEmitter
+import com.streamvideo.reactnative.util.CallAlivePermissionsHelper
+import com.streamvideo.reactnative.util.CallAliveServiceChecker
 import com.streamvideo.reactnative.util.PiPHelper
 import com.streamvideo.reactnative.util.RingtoneUtil
 
@@ -59,6 +61,22 @@ class StreamVideoReactNativeModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun isCallAliveConfigured(promise: Promise) {
+        val permissionsDeclared =
+            CallAlivePermissionsHelper.hasForegroundServicePermissionsDeclared(reactApplicationContext)
+        if (!permissionsDeclared) {
+            promise.resolve(false)
+            return
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            val isForegroundServiceDeclared = CallAliveServiceChecker.isForegroundServiceDeclared(reactApplicationContext)
+            promise.resolve(isForegroundServiceDeclared)
+        } else {
+            promise.resolve(true)
+        }
+    }
+
     @Suppress("UNUSED_PARAMETER")
     @ReactMethod
     fun addListener(eventName: String?) {

packages/react-native-sdk/android/src/main/java/com/streamvideo/reactnative/util/CallAlivePermissionsHelper.kt

@@ -0,0 +1,54 @@
+package com.streamvideo.reactnative.util
+
+import android.content.pm.PackageInfo
+import android.content.pm.PackageManager
+import android.util.Log
+import com.facebook.react.bridge.ReactApplicationContext
+
+
+object CallAlivePermissionsHelper {
+    private const val NAME = "StreamVideoReactNative"
+
+    fun hasForegroundServicePermissionsDeclared(context: ReactApplicationContext): Boolean {
+        val packageManager = context.packageManager
+        val packageName = context.packageName
+
+        try {
+            val packageInfo: PackageInfo =
+                packageManager.getPackageInfo(packageName, PackageManager.GET_PERMISSIONS)
+            val requestedPermissions = packageInfo.requestedPermissions
+
+            if (requestedPermissions != null) {
+                val requiredPermissions = arrayOf(
+                    "android.permission.FOREGROUND_SERVICE",
+                    "android.permission.FOREGROUND_SERVICE_CAMERA",
+                    "android.permission.FOREGROUND_SERVICE_MICROPHONE",
+                    "android.permission.FOREGROUND_SERVICE_CONNECTED_DEVICE",
+                    "android.permission.FOREGROUND_SERVICE_DATA_SYNC"
+                )
+
+                val missingPermissions =
+                    requiredPermissions.filterNot { requestedPermissions.contains(it) }
+
+                if (missingPermissions.isNotEmpty()) {
+                    Log.w(
+                        NAME,
+                        "Missing ForegroundServicePermissions: ${missingPermissions.joinToString(", ")}"
+                    )
+                    return false
+                } else {
+                    return true
+                }
+            }
+        } catch (e: PackageManager.NameNotFoundException) {
+            // do nothing, this can never happen actually
+            Log.e(
+                NAME,
+                "Package not found: $packageName",
+                e
+            )
+        }
+        return false
+    }
+
+}

packages/react-native-sdk/android/src/main/java/com/streamvideo/reactnative/util/CallAliveServiceChecker.kt

@@ -0,0 +1,96 @@
+package com.streamvideo.reactnative.util
+
+import android.content.ComponentName
+import android.content.pm.PackageManager
+import android.content.pm.ServiceInfo
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import com.facebook.react.bridge.ReactApplicationContext
+
+@RequiresApi(api = Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
+object CallAliveServiceChecker {
+    private const val NAME = "StreamVideoReactNative"
+
+    fun isForegroundServiceDeclared(context: ReactApplicationContext): Boolean {
+        val packageManager = context.packageManager
+        val packageName = context.packageName // Get the package name of your app
+        val componentName = ComponentName(
+            packageName,
+            "app.notifee.core.ForegroundService"
+        ) // Use service name string
+
+        try {
+            val serviceInfo =
+                packageManager.getServiceInfo(componentName, PackageManager.GET_META_DATA)
+
+            val expectedForegroundServiceTypes =
+                ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE or
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC or
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA or
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE or
+                        ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE
+
+            val actualForegroundServiceType = serviceInfo.foregroundServiceType
+
+            if (actualForegroundServiceType == expectedForegroundServiceTypes) {
+                return true
+            } else {
+                Log.w(
+                    NAME,
+                    "android:foregroundServiceType does not match: expected=${
+                        foregroundServiceTypeToString(
+                            expectedForegroundServiceTypes
+                        )
+                    }, actual=${foregroundServiceTypeToString(actualForegroundServiceType)}"
+                )
+                return false
+            }
+
+        } catch (e: PackageManager.NameNotFoundException) {
+            Log.d(NAME, "Service not found: " + e.message)
+            return false // Service not declared
+        }
+    }
+
+    private fun foregroundServiceTypeToString(foregroundServiceType: Int): String {
+        val types = mutableListOf<String>()
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_SHORT_SERVICE != 0) {
+            types.add("shortService")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_DATA_SYNC != 0) {
+            types.add("dataSync")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_CAMERA != 0) {
+            types.add("camera")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_MICROPHONE != 0) {
+            types.add("microphone")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_CONNECTED_DEVICE != 0) {
+            types.add("connectedDevice")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION != 0) {
+            types.add("location")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PLAYBACK != 0) {
+            types.add("mediaPlayback")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_MEDIA_PROJECTION != 0) {
+            types.add("mediaProjection")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_PHONE_CALL != 0) {
+            types.add("phoneCall")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_HEALTH != 0) {
+            types.add("health")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_REMOTE_MESSAGING != 0) {
+            types.add("remoteMessaging")
+        }
+        if (foregroundServiceType and ServiceInfo.FOREGROUND_SERVICE_TYPE_SYSTEM_EXEMPTED != 0) {
+            types.add("systemExempted")
+        }
+        return types.joinToString("|")
+    }
+}

packages/react-native-sdk/src/hooks/useAndroidKeepCallAliveEffect.ts

@@ -1,7 +1,12 @@
 import { useCall, useCallStateHooks } from '@stream-io/video-react-bindings';
 import { useEffect, useRef } from 'react';
 import { StreamVideoRN } from '../utils';
-import { AppState, AppStateStatus, Platform } from 'react-native';
+import {
+  NativeModules,
+  AppState,
+  AppStateStatus,
+  Platform,
+} from 'react-native';
 import { CallingState, getLogger } from '@stream-io/video-client';
 import {
   getNotifeeLibNoThrowForKeepCallAlive,
@@ -11,12 +16,25 @@ import {
 const notifeeLib = getNotifeeLibNoThrowForKeepCallAlive();
 
 function setForegroundService() {
-  notifeeLib?.default.registerForegroundService(() => {
-    return new Promise(() => {
-      const logger = getLogger(['setForegroundService method']);
-      logger('info', 'Foreground service running for call in progress');
-    });
-  });
+  if (Platform.OS === 'ios' || !notifeeLib) return;
+  NativeModules.StreamVideoReactNative.isCallAliveConfigured().then(
+    (isConfigured: boolean) => {
+      if (!isConfigured) {
+        const logger = getLogger(['setForegroundService method']);
+        logger(
+          'info',
+          'KeepCallAlive is not configured. Skipping foreground service setup.'
+        );
+        return;
+      }
+      notifeeLib.default.registerForegroundService(() => {
+        return new Promise(() => {
+          const logger = getLogger(['setForegroundService method']);
+          logger('info', 'Foreground service running for call in progress');
+        });
+      });
+    }
+  );
 }
 
 async function startForegroundService(call_cid: string) {
@@ -25,6 +43,16 @@ async function startForegroundService(call_cid: string) {
 
   // check for notification permission and then start the foreground service
   if (!notifeeLib) return;
+  const isCallAliveConfigured =
+    await NativeModules.StreamVideoReactNative.isCallAliveConfigured();
+  if (!isCallAliveConfigured) {
+    const logger = getLogger(['startForegroundService']);
+    logger(
+      'info',
+      'KeepCallAlive is not configured. Skipping foreground service setup.'
+    );
+    return;
+  }
   const settings = await notifeeLib.default.getNotificationSettings();
   if (
     settings.authorizationStatus !== notifeeLib.AuthorizationStatus.AUTHORIZED