@capgo/capacitor-stream-call 0.0.26 → 0.0.28

package/README.md

@@ -128,11 +128,14 @@ The SDK will automatically use the system language and these translations.
 * [`setMicrophoneEnabled(...)`](#setmicrophoneenabled)
 * [`setCameraEnabled(...)`](#setcameraenabled)
 * [`addListener('callEvent', ...)`](#addlistenercallevent-)
+* [`addListener('incomingCall', ...)`](#addlistenerincomingcall-)
 * [`removeAllListeners()`](#removealllisteners)
 * [`acceptCall()`](#acceptcall)
 * [`rejectCall()`](#rejectcall)
 * [`isCameraEnabled()`](#iscameraenabled)
 * [`getCallStatus()`](#getcallstatus)
+* [`setSpeaker(...)`](#setspeaker)
+* [`switchCamera(...)`](#switchcamera)
 * [Interfaces](#interfaces)
 * [Type Aliases](#type-aliases)
 * [Enums](#enums)
@@ -254,6 +257,25 @@ Add listener for call events
 --------------------
 
 
+### addListener('incomingCall', ...)
+
+```typescript
+addListener(eventName: 'incomingCall', listenerFunc: (event: IncomingCallPayload) => void) => Promise<{ remove: () => Promise<void>; }>
+```
+
+Listen for lock-screen incoming call (Android only).
+Fired when the app is shown by full-screen intent before user interaction.
+
+| Param              | Type                                                                                    |
+| ------------------ | --------------------------------------------------------------------------------------- |
+| **`eventName`**    | <code>'incomingCall'</code>                                                             |
+| **`listenerFunc`** | <code>(event: <a href="#incomingcallpayload">IncomingCallPayload</a>) =&gt; void</code> |
+
+**Returns:** <code>Promise&lt;{ remove: () =&gt; Promise&lt;void&gt;; }&gt;</code>
+
+--------------------
+
+
 ### removeAllListeners()
 
 ```typescript
@@ -317,6 +339,40 @@ Get the current call status
 --------------------
 
 
+### setSpeaker(...)
+
+```typescript
+setSpeaker(options: { name: string; }) => Promise<SuccessResponse>
+```
+
+Set speakerphone on
+
+| Param         | Type                           | Description         |
+| ------------- | ------------------------------ | ------------------- |
+| **`options`** | <code>{ name: string; }</code> | - Speakerphone name |
+
+**Returns:** <code>Promise&lt;<a href="#successresponse">SuccessResponse</a>&gt;</code>
+
+--------------------
+
+
+### switchCamera(...)
+
+```typescript
+switchCamera(options: { camera: 'front' | 'back'; }) => Promise<SuccessResponse>
+```
+
+Switch camera
+
+| Param         | Type                                        | Description           |
+| ------------- | ------------------------------------------- | --------------------- |
+| **`options`** | <code>{ camera: 'front' \| 'back'; }</code> | - Camera to switch to |
+
+**Returns:** <code>Promise&lt;<a href="#successresponse">SuccessResponse</a>&gt;</code>
+
+--------------------
+
+
 ### Interfaces
 
 
@@ -550,6 +606,14 @@ The JSON representation for <a href="#listvalue">`ListValue`</a> is JSON array.
 | **`sessionId`** | <code>string</code> | the user sesion_id to pin, if not provided, applies to all sessions |
 
 
+#### IncomingCallPayload
+
+| Prop       | Type                    | Description                              |
+| ---------- | ----------------------- | ---------------------------------------- |
+| **`cid`**  | <code>string</code>     | Full call CID (e.g. default:123)         |
+| **`type`** | <code>'incoming'</code> | Event type (currently always "incoming") |
+
+
 #### CameraEnabledResponse
 
 | Prop          | Type                 |

package/android/build.gradle

@@ -63,7 +63,7 @@ dependencies {
     implementation fileTree(dir: 'libs', include: ['*.jar'])
     implementation project(':capacitor-android')
     implementation "androidx.appcompat:appcompat:$androidxAppCompatVersion"
-    implementation 'androidx.core:core-ktx:1.15.0'
+    implementation 'androidx.core:core-ktx:1.16.0'
     
     // Compose dependencies with consistent versions
     def compose_version = '1.6.8'
@@ -72,20 +72,20 @@ dependencies {
     implementation "androidx.compose.ui:ui-tooling:$compose_version"
     implementation "androidx.compose.foundation:foundation:$compose_version"
     implementation "androidx.compose.runtime:runtime:$compose_version"
-    implementation "androidx.compose.material3:material3:1.3.1"
+    implementation "androidx.compose.material3:material3:1.3.2"
     
     // Stream dependencies
-    implementation("io.getstream:stream-video-android-ui-compose:1.4.5")
-    implementation("io.getstream:stream-video-android-core:1.4.5")
+    implementation("io.getstream:stream-video-android-ui-compose:1.6.1")
+    implementation("io.getstream:stream-video-android-core:1.6.1")
     implementation("io.getstream:stream-android-push:1.3.1")
     implementation("io.getstream:stream-android-push-firebase:1.3.1")
     
     // Firebase dependencies using BOM
-    implementation(platform('com.google.firebase:firebase-bom:32.8.0'))
+    implementation(platform('com.google.firebase:firebase-bom:33.13.0'))
     implementation('com.google.firebase:firebase-messaging-ktx')
     
     implementation("androidx.coordinatorlayout:coordinatorlayout:1.3.0")
-    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.8.1'
+    implementation 'org.jetbrains.kotlinx:kotlinx-coroutines-play-services:1.9.0'
     testImplementation "junit:junit:$junitVersion"
     androidTestImplementation "androidx.test.ext:junit:$androidxJunitVersion"
     androidTestImplementation "androidx.test.espresso:espresso-core:$androidxEspressoCoreVersion"

package/android/src/main/AndroidManifest.xml

@@ -1,2 +1,31 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android">
+    <uses-permission android:name="android.permission.USE_FULL_SCREEN_INTENT" />
+    <application>
+
+          <service
+              android:name="io.getstream.android.push.firebase.ChatFirebaseMessagingService"
+              android:exported="false">
+              <intent-filter>
+                  <action android:name="com.google.firebase.MESSAGING_EVENT" />
+              </intent-filter>
+              <intent-filter>
+                  <action android:name="FCM_PLUGIN_ACTIVITY" />
+                  <category android:name="android.intent.category.DEFAULT" />
+              </intent-filter>
+          </service>
+
+        <service
+            android:name="ee.forgr.capacitor.streamcall.StreamCallBackgroundService"
+            android:enabled="true"
+            android:exported="false" />
+    </application>
+
+    <uses-permission android:name="android.permission.REQUEST_IGNORE_BATTERY_OPTIMIZATIONS" />
+    <uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+    <uses-permission android:name="android.permission.RECORD_AUDIO" />
+    <uses-permission android:name="android.permission.CAMERA" />
+    <uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+    <uses-permission android:name="android.permission.BLUETOOTH" />
 </manifest>

package/android/src/main/java/ee/forgr/capacitor/streamcall/CustomNotificationHandler.kt

@@ -4,13 +4,11 @@ import android.app.Application
 import android.app.Notification
 import android.app.NotificationManager
 import android.app.PendingIntent
-import android.content.Context
 import android.content.Intent
 import android.media.RingtoneManager
 import android.os.Build
 import android.util.Log
 import androidx.core.app.NotificationCompat
-import io.getstream.log.taggedLogger
 import io.getstream.video.android.core.RingingState
 import io.getstream.video.android.core.notifications.DefaultNotificationHandler
 import io.getstream.video.android.core.notifications.NotificationHandler
@@ -36,11 +34,66 @@ class CustomNotificationHandler(
         callDisplayName: String?,
         shouldHaveContentIntent: Boolean,
     ): Notification? {
+        Log.d("CustomNotificationHandler", "getRingingCallNotification called: ringingState=$ringingState, callId=$callId, callDisplayName=$callDisplayName, shouldHaveContentIntent=$shouldHaveContentIntent")
         return if (ringingState is RingingState.Incoming) {
-            val fullScreenPendingIntent = intentResolver.searchIncomingCallPendingIntent(callId)
-            val acceptCallPendingIntent = intentResolver.searchAcceptCallPendingIntent(callId)
-            val rejectCallPendingIntent = intentResolver.searchRejectCallPendingIntent(callId)
- 
+            // Note: we create our own fullScreenPendingIntent later based on acceptCallPendingIntent
+
+            // Get the main launch intent for the application
+            val launchIntent = application.packageManager.getLaunchIntentForPackage(application.packageName)
+            var targetComponent: android.content.ComponentName? = null
+            if (launchIntent != null) {
+                targetComponent = launchIntent.component
+                Log.d("CustomNotificationHandler", "Derived launch component: ${targetComponent?.flattenToString()}")
+            } else {
+                Log.e("CustomNotificationHandler", "Could not get launch intent for package: ${application.packageName}. This is problematic for creating explicit intents.")
+            }
+
+            // Intent to simply bring the app to foreground and show incoming-call UI (no auto accept)
+            val incomingIntentAction = "io.getstream.video.android.action.INCOMING_CALL"
+            val incomingCallIntent = Intent(incomingIntentAction)
+                .putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
+                .setPackage(application.packageName)
+            if (targetComponent != null) incomingCallIntent.component = targetComponent
+            incomingCallIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+
+            // Use the app's MainActivity intent so webview loads; user sees app UI
+            val requestCodeFull = callId.cid.hashCode()
+            val fullScreenPendingIntent = PendingIntent.getActivity(
+                application,
+                requestCodeFull,
+                incomingCallIntent,
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            )
+
+            val acceptCallAction = NotificationHandler.ACTION_ACCEPT_CALL
+            val acceptCallIntent = Intent(acceptCallAction)
+                // Pass full Parcelable so both new and old handlers succeed
+                .putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
+                .setPackage(application.packageName)
+
+            if (targetComponent != null) {
+                acceptCallIntent.component = targetComponent
+            }
+            acceptCallIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+
+            Log.d("CustomNotificationHandler", "Constructed Accept Call Intent for PI: action=${acceptCallIntent.action}, cid=${acceptCallIntent.getStringExtra(NotificationHandler.INTENT_EXTRA_CALL_CID)}, package=${acceptCallIntent.getPackage()}, component=${acceptCallIntent.component?.flattenToString()}, flags=${acceptCallIntent.flags}")
+
+            // Create PendingIntent for Accept action using getActivity to launch the app
+            val requestCodeAccept = callId.cid.hashCode() + 1 // Unique request code for the PendingIntent with offset to avoid collisions
+            val acceptCallPendingIntent = PendingIntent.getActivity(
+                application,
+                requestCodeAccept,
+                acceptCallIntent,
+                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
+            )
+            Log.d("CustomNotificationHandler", "Created Accept Call PendingIntent with requestCode: $requestCodeAccept")
+
+            val rejectCallPendingIntent = intentResolver.searchRejectCallPendingIntent(callId) // Keep using resolver for reject for now, or change it too if needed
+
+            Log.d("CustomNotificationHandler", "Full Screen PI: $fullScreenPendingIntent")
+            Log.d("CustomNotificationHandler", "Custom Accept Call PI: $acceptCallPendingIntent")
+            Log.d("CustomNotificationHandler", "Resolver Reject Call PI: $rejectCallPendingIntent")
+            
             if (fullScreenPendingIntent != null && acceptCallPendingIntent != null && rejectCallPendingIntent != null) {
                 customGetIncomingCallNotification(
                     fullScreenPendingIntent,
@@ -81,37 +134,11 @@ class CustomNotificationHandler(
         shouldHaveContentIntent: Boolean,
         callId: StreamCallId
     ): Notification {
- 
-        // customCreateIncomingCallChannel()
-        val manufacturer = Build.MANUFACTURER.lowercase()
-        if (manufacturer.contains("xiaomi") || manufacturer.contains("mi")) {
-            // val serviceIntent = Intent(application, CallForegroundService::class.java)
-            // serviceIntent.action = CallForegroundService.ACTION_START_FOREGROUND_SERVICE
-            // if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-            //     application.startForegroundService(serviceIntent)
-            // } else {
-            //     application.startService(serviceIntent)
-            // }
-            // Adjust PendingIntent for Xiaomi to avoid permission denial
-            val xiaomiAcceptIntent = PendingIntent.getActivity(
-                application,
-                0,
-                Intent("io.getstream.video.android.action.ACCEPT_CALL")
-                .setPackage(application.packageName)
-                .putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId),
-                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
-            )
-            return buildNotification(
-                fullScreenPendingIntent,
-                xiaomiAcceptIntent,
-                rejectCallPendingIntent,
-                callerName,
-                shouldHaveContentIntent,
-                INCOMING_CALLS_CUSTOM,
-                true // Include sound
-            )
-        }
- 
+        Log.d("CustomNotificationHandler", "customGetIncomingCallNotification called: callerName=$callerName, callId=$callId")
+        customCreateIncomingCallChannel()
+        // Always use the provided acceptCallPendingIntent (created with getActivity) so that
+        // the app process is started and MainActivity receives the ACCEPT_CALL action even
+        // when the app has been killed.
         return buildNotification(
             fullScreenPendingIntent,
             acceptCallPendingIntent,
@@ -132,10 +159,11 @@ class CustomNotificationHandler(
         channelId: String,
         includeSound: Boolean
     ): Notification {
+        Log.d("CustomNotificationHandler", "buildNotification called: callerName=$callerName, channelId=$channelId, includeSound=$includeSound")
         return getNotification {
             priority = NotificationCompat.PRIORITY_HIGH
             setContentTitle(callerName)
-            setContentText("Incoming call")
+            setContentText("Incoming call toto")
             setChannelId(channelId)
             setOngoing(true)
             setAutoCancel(false)
@@ -173,11 +201,13 @@ class CustomNotificationHandler(
     }
  
     override fun onMissedCall(callId: StreamCallId, callDisplayName: String) {
+        Log.d("CustomNotificationHandler", "onMissedCall called: callId=$callId, callDisplayName=$callDisplayName")
         endCall(callId)
         super.onMissedCall(callId, callDisplayName)
     }
  
     private fun customCreateIncomingCallChannel() {
+        Log.d("CustomNotificationHandler", "customCreateIncomingCallChannel called")
         maybeCreateChannel(
             channelId = INCOMING_CALLS_CUSTOM,
             context = application,
@@ -204,6 +234,7 @@ class CustomNotificationHandler(
     }
  
     public fun clone(): CustomNotificationHandler {
+        Log.d("CustomNotificationHandler", "clone called")
         return CustomNotificationHandler(this.application, this.endCall, this.incomingCall)
     }
 }

package/android/src/main/java/ee/forgr/capacitor/streamcall/StreamCallBackgroundService.java

@@ -0,0 +1,41 @@
+package ee.forgr.capacitor.streamcall;
+
+import android.app.Service;
+import android.content.Intent;
+import android.os.IBinder;
+import android.util.Log;
+import androidx.annotation.Nullable;
+
+public class StreamCallBackgroundService extends Service {
+
+    private static final String TAG = "StreamCallBackgroundService";
+
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        Log.d(TAG, "Service created");
+    }
+
+    @Override
+    public int onStartCommand(Intent intent, int flags, int startId) {
+        Log.d(TAG, "Service started");
+        // Keep the service running even if the app is killed
+        return START_STICKY;
+    }
+
+    @Override
+    public void onDestroy() {
+        super.onDestroy();
+        Log.d(TAG, "Service destroyed");
+        // Restart the service if it's killed by the system
+        Intent restartServiceIntent = new Intent(getApplicationContext(), StreamCallBackgroundService.class);
+        restartServiceIntent.setPackage(getPackageName());
+        startService(restartServiceIntent);
+    }
+
+    @Nullable
+    @Override
+    public IBinder onBind(Intent intent) {
+        return null;
+    }
+}

package/android/src/main/java/ee/forgr/capacitor/streamcall/StreamCallFragment.kt

@@ -0,0 +1,56 @@
+package ee.forgr.capacitor.streamcall;
+
+import android.os.Bundle;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import androidx.fragment.app.Fragment;
+import io.getstream.video.android.core.Call;
+import kotlinx.coroutines.CoroutineScope;
+import kotlinx.coroutines.Dispatchers;
+import kotlinx.coroutines.flow.launchIn;
+import kotlinx.coroutines.flow.onEach;
+import kotlinx.coroutines.launch;
+import io.getstream.webrtc.android.ui.VideoTextureViewRenderer;
+import stream.video.sfu.models.TrackType;
+
+class StreamCallFragment : Fragment() {
+    private var call: Call? = null
+    private var videoRenderer: VideoTextureViewRenderer? = null
+
+    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View {
+        videoRenderer = VideoTextureViewRenderer(requireContext())
+        return videoRenderer!!
+    }
+
+    fun setCall(call: Call) {
+        this.call = call
+        videoRenderer?.let { renderer ->
+            // Setup video rendering for local video
+            call.initRenderer(renderer, call.sessionId, TrackType.TRACK_TYPE_VIDEO)
+            // Setup listener for remote participants' video
+            val scope = CoroutineScope(Dispatchers.Main)
+            scope.launch {
+                call.state.participants.onEach { participantStates ->
+                    participantStates.forEach { participantState ->
+                        participantState.videoTrack.onEach { videoTrack ->
+                            videoTrack?.let { track ->
+                                // Additional renderers might be needed for multiple participants
+                                track.video.addSink(renderer)
+                            }
+                        }.launchIn(scope)
+                    }
+                }.launchIn(scope)
+            }
+        }
+    }
+
+    fun getCall(): Call? {
+        return call
+    }
+
+    override fun onDestroyView() {
+        super.onDestroyView()
+        videoRenderer = null
+    }
+}