@capgo/capacitor-stream-call 0.0.87 → 0.0.88

package/android/build.gradle

@@ -73,6 +73,8 @@ dependencies {
     implementation "androidx.compose.foundation:foundation:$compose_version"
     implementation "androidx.compose.runtime:runtime:$compose_version"
     implementation "androidx.compose.material3:material3:1.3.2"
+    implementation 'androidx.media:media:1.7.0'
+
     
     // Stream dependencies
     implementation("io.getstream:stream-video-android-ui-compose:1.9.2")

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

@@ -0,0 +1,161 @@
+package ee.forgr.capacitor.streamcall
+
+import android.app.Application
+import android.app.PendingIntent
+import android.content.ComponentName
+import android.content.Intent
+import android.content.pm.ResolveInfo
+import io.getstream.log.taggedLogger
+import io.getstream.video.android.core.notifications.NotificationHandler
+import io.getstream.video.android.core.notifications.StreamIntentResolver
+import io.getstream.video.android.model.StreamCallId
+
+class CustomStreamIntentResolver(private val context: Application) : StreamIntentResolver {
+
+    private val logger by taggedLogger("CustomIntentResolver")
+    private val PENDING_INTENT_FLAG = PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+
+    override fun searchIncomingCallPendingIntent(callId: StreamCallId, notificationId: Int): PendingIntent? {
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)?.apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP
+            putExtra("callCid", callId.cid)
+            putExtra("action", "accept")
+            action = "io.getstream.video.android.action.ACCEPT_CALL"
+        }
+
+        return PendingIntent.getActivity(
+            context,
+            callId.cid.hashCode(),
+            launchIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+    }
+
+    override fun searchOutgoingCallPendingIntent(callId: StreamCallId, notificationId: Int): PendingIntent? {
+        // For outgoing calls, create a specific intent that only opens webview when user taps
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)?.apply {
+            flags = Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP or Intent.FLAG_ACTIVITY_SINGLE_TOP
+            putExtra("callCid", callId.cid)
+            putExtra("action", "outgoing_call_tap") // Different action to distinguish from automatic events
+            putExtra("openWebview", true)
+            putExtra("fromNotification", true)
+            putExtra("userTapped", true) // Explicitly mark this as user-initiated
+            action = "ee.forgr.capacitor.streamcall.OUTGOING_CALL_TAP.${callId.cid}"
+        }
+
+        return PendingIntent.getActivity(
+            context,
+            callId.cid.hashCode(),
+            launchIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+    }
+
+    override fun searchNotificationCallPendingIntent(callId: StreamCallId, notificationId: Int): PendingIntent? =
+        searchActivityPendingIntent(Intent(NotificationHandler.ACTION_NOTIFICATION), callId, notificationId)
+
+    override fun searchMissedCallPendingIntent(callId: StreamCallId, notificationId: Int): PendingIntent? =
+        searchActivityPendingIntent(Intent(NotificationHandler.ACTION_MISSED_CALL), callId, notificationId)
+
+    override fun getDefaultPendingIntent(): PendingIntent {
+        val intent = context.packageManager.getLaunchIntentForPackage(context.packageName)
+            ?: Intent(Intent.ACTION_MAIN).apply {
+                setPackage(context.packageName)
+                addCategory(Intent.CATEGORY_LAUNCHER)
+            }
+        intent.addFlags(Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        return PendingIntent.getActivity(
+            context,
+            0,
+            intent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+    }
+
+    override fun searchLiveCallPendingIntent(callId: StreamCallId, notificationId: Int): PendingIntent? =
+        searchActivityPendingIntent(Intent(NotificationHandler.ACTION_LIVE_CALL), callId, notificationId)
+
+    override fun searchAcceptCallPendingIntent(callId: StreamCallId, notificationId: Int): PendingIntent? {
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)?.apply {
+            action = NotificationHandler.ACTION_ACCEPT_CALL
+            putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
+        }
+
+        return PendingIntent.getActivity(
+            context,
+            callId.cid.hashCode() + 10,
+            launchIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+    }
+
+    override fun searchRejectCallPendingIntent(callId: StreamCallId): PendingIntent? =
+        searchBroadcastPendingIntent(Intent(NotificationHandler.ACTION_REJECT_CALL), callId)
+
+    override fun searchEndCallPendingIntent(callId: StreamCallId): PendingIntent? {
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)?.apply {
+            action = NotificationHandler.ACTION_LEAVE_CALL
+            putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        }
+
+        return PendingIntent.getActivity(
+            context,
+            callId.cid.hashCode() + 30,
+            launchIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+    }
+
+    override fun searchOngoingCallPendingIntent(callId: StreamCallId, notificationId: Int): PendingIntent? {
+        val launchIntent = context.packageManager.getLaunchIntentForPackage(context.packageName)?.apply {
+            action = NotificationHandler.ACTION_ONGOING_CALL
+            putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
+            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
+        }
+
+        return PendingIntent.getActivity(
+            context,
+            callId.cid.hashCode() + 20,
+            launchIntent,
+            PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
+        )
+    }
+
+    private fun searchBroadcastPendingIntent(baseIntent: Intent, callId: StreamCallId): PendingIntent? =
+        searchResolveInfo { context.packageManager.queryBroadcastReceivers(baseIntent, 0) }?.let {
+            getBroadcastForIntent(baseIntent, it, callId)
+        }
+
+    private fun searchActivityPendingIntent(baseIntent: Intent, callId: StreamCallId, notificationId: Int): PendingIntent? =
+        searchResolveInfo { context.packageManager.queryIntentActivities(baseIntent, 0) }?.let {
+            getActivityForIntent(baseIntent, it, callId, notificationId)
+        }
+
+    private fun searchResolveInfo(availableComponents: () -> List<ResolveInfo>): ResolveInfo? =
+        availableComponents()
+            .filter { it.activityInfo.packageName == context.packageName }
+            .maxByOrNull { it.priority }
+
+    private fun getActivityForIntent(baseIntent: Intent, resolveInfo: ResolveInfo, callId: StreamCallId, notificationId: Int, flags: Int = PENDING_INTENT_FLAG): PendingIntent {
+        return PendingIntent.getActivity(
+            context,
+            notificationId,
+            buildComponentIntent(baseIntent, resolveInfo, callId),
+            flags
+        )
+    }
+
+    private fun getBroadcastForIntent(baseIntent: Intent, resolveInfo: ResolveInfo, callId: StreamCallId, flags: Int = PENDING_INTENT_FLAG): PendingIntent {
+        return PendingIntent.getBroadcast(context, 0, buildComponentIntent(baseIntent, resolveInfo, callId), flags)
+    }
+
+    private fun buildComponentIntent(baseIntent: Intent, resolveInfo: ResolveInfo, callId: StreamCallId): Intent {
+        return Intent(baseIntent).apply {
+            component = ComponentName(resolveInfo.activityInfo.applicationInfo.packageName, resolveInfo.activityInfo.name)
+            putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
+            putExtra(NotificationHandler.INTENT_EXTRA_NOTIFICATION_ID, NotificationHandler.INCOMING_CALL_NOTIFICATION_ID)
+        }
+    }
+} 

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

@@ -73,6 +73,10 @@ import io.getstream.video.android.core.events.ParticipantLeftEvent
 import io.getstream.video.android.core.internal.InternalStreamVideoApi
 import io.getstream.video.android.core.notifications.NotificationConfig
 import io.getstream.video.android.core.notifications.NotificationHandler
+import io.getstream.video.android.core.notifications.handlers.CompatibilityStreamNotificationHandler
+import io.getstream.video.android.core.notifications.handlers.StreamNotificationBuilderInterceptors
+import androidx.core.app.NotificationCompat
+import android.app.PendingIntent
 import io.getstream.video.android.core.sounds.RingingConfig
 import io.getstream.video.android.core.sounds.toSounds
 import io.getstream.video.android.model.Device
@@ -316,6 +320,12 @@ class StreamCallPlugin : Plugin() {
                     Log.e("StreamCallPlugin", "handleOnNewIntent: ACCEPT_CALL - Call object is null for cid: $cid")
                 }
             }
+        } else if (action === NotificationHandler.ACTION_LEAVE_CALL) {
+            Log.d("StreamCallPlugin", "handleOnNewIntent: Matched LEAVE_CALL action")
+            kotlinx.coroutines.GlobalScope.launch {
+                val success = _endCall()
+                Log.d("StreamCallPlugin", "handleOnNewIntent: LEAVE_CALL - End call result: $success")
+            }
         }
         // Log the intent information
         Log.d("StreamCallPlugin", "New Intent - Action: $action")
@@ -567,47 +577,6 @@ class StreamCallPlugin : Plugin() {
             // unsafe cast, add better handling
             val application = contextToUse.applicationContext as Application
             Log.d("StreamCallPlugin", "No existing StreamVideo singleton client, creating new one")
-            val notificationHandler = CustomNotificationHandler(
-                application = application,
-                endCall = { callId ->
-                    val activeCall = streamVideoClient?.call(callId.type, callId.id)
-
-                    kotlinx.coroutines.GlobalScope.launch {
-                        try {
-                            Log.i(
-                                "StreamCallPlugin",
-                                "Attempt to endCallRaw, activeCall == null: ${activeCall == null}",
-                            )
-                            activeCall?.let { endCallRaw(it) }
-                        } catch (e: Exception) {
-                            Log.e(
-                                "StreamCallPlugin",
-                                "Error ending after missed call notif action",
-                                e
-                            )
-                        }
-                    }
-                },
-                incomingCall = {
-                    if (this.savedContext != null && initializationTime != 0L) {
-                        val contextCreatedAt = initializationTime
-                        val now = System.currentTimeMillis()
-                        val isWithinOneSecond = (now - contextCreatedAt) <= 1000L
-
-                        Log.i(
-                            "StreamCallPlugin",
-                            "Time between context creation and activity created (incoming call notif): ${now - contextCreatedAt}"
-                        )
-                        if (isWithinOneSecond && !bootedToHandleCall) {
-                            Log.i(
-                                "StreamCallPlugin",
-                                "Notification incomingCall received less than 1 second after the creation of streamVideoSDK. Booted FOR SURE in order to handle the notification"
-                            )
-                        }
-                    }
-                }
-            )
-
             val notificationConfig = NotificationConfig(
                 pushDeviceGenerators = listOf(
                     FirebasePushDeviceGenerator(
@@ -616,7 +585,23 @@ class StreamCallPlugin : Plugin() {
                     )
                 ),
                 requestPermissionOnAppLaunch = { true },
-                notificationHandler = notificationHandler,
+                notificationHandler = CompatibilityStreamNotificationHandler(
+                    application = contextToUse as Application,
+                    intentResolver = CustomStreamIntentResolver(contextToUse),
+                    initialNotificationBuilderInterceptor = object : StreamNotificationBuilderInterceptors() {
+                        override fun onBuildIncomingCallNotification(
+                            builder: NotificationCompat.Builder,
+                            fullScreenPendingIntent: PendingIntent,
+                            acceptCallPendingIntent: PendingIntent,
+                            rejectCallPendingIntent: PendingIntent,
+                            callerName: String?,
+                            shouldHaveContentIntent: Boolean
+                        ): NotificationCompat.Builder {
+                            return builder.setContentIntent(fullScreenPendingIntent)
+                                .setFullScreenIntent(fullScreenPendingIntent, true)
+                        }
+                    }
+                )
             )
 
             val soundsConfig = incomingOnlyRingingConfig()
@@ -1976,28 +1961,41 @@ class StreamCallPlugin : Plugin() {
     }
 
     @OptIn(DelicateCoroutinesApi::class)
+    private suspend fun _endCall(): Boolean {
+        val activeCall = streamVideoClient?.state?.activeCall?.value
+        val ringingCall = streamVideoClient?.state?.ringingCall?.value
+        
+        val callToEnd = activeCall ?: ringingCall
+        
+        if (callToEnd == null) {
+            Log.w("StreamCallPlugin", "Attempted to end call but no active or ringing call found")
+            return false
+        }
+
+        Log.d("StreamCallPlugin", "Ending call: activeCall=${activeCall?.id}, ringingCall=${ringingCall?.id}, callToEnd=${callToEnd.id}")
+
+        return try {
+            endCallRaw(callToEnd)
+            true
+        } catch (e: Exception) {
+            Log.e("StreamCallPlugin", "Error ending call: ${e.message}", e)
+            false
+        }
+    }
+
     @PluginMethod
     fun endCall(call: PluginCall) {
         try {
-            val activeCall = streamVideoClient?.state?.activeCall?.value
-            val ringingCall = streamVideoClient?.state?.ringingCall?.value
-            
-            val callToEnd = activeCall ?: ringingCall
-            
-            if (callToEnd == null) {
-                Log.w("StreamCallPlugin", "Attempted to end call but no active or ringing call found")
-                call.reject("No active call to end")
-                return
-            }
-
-            Log.d("StreamCallPlugin", "Ending call: activeCall=${activeCall?.id}, ringingCall=${ringingCall?.id}, callToEnd=${callToEnd.id}")
-
             kotlinx.coroutines.GlobalScope.launch {
                 try {
-                    endCallRaw(callToEnd)
-                    call.resolve(JSObject().apply {
-                        put("success", true)
-                    })
+                    val success = _endCall()
+                    if (success) {
+                        call.resolve(JSObject().apply {
+                            put("success", true)
+                        })
+                    } else {
+                        call.reject("No active call to end")
+                    }
                 } catch (e: Exception) {
                     Log.e("StreamCallPlugin", "Error ending call: ${e.message}")
                     call.reject("Failed to end call: ${e.message}")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/capacitor-stream-call",
-  "version": "0.0.87",
+  "version": "0.0.88",
   "description": "Uses the https://getstream.io/ SDK to implement calling in Capacitor",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",

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

@@ -1,323 +0,0 @@
-package ee.forgr.capacitor.streamcall
- 
-import android.app.Application
-import android.app.Notification
-import android.app.NotificationManager
-import android.app.PendingIntent
-import android.content.Intent
-import android.media.RingtoneManager
-import android.os.Build
-import android.util.Log
-import androidx.core.app.NotificationCompat
-import io.getstream.video.android.core.RingingState
-import io.getstream.video.android.core.notifications.DefaultNotificationHandler
-import io.getstream.video.android.core.notifications.NotificationHandler
-import io.getstream.video.android.model.StreamCallId
-import io.getstream.video.android.model.streamCallId
-import io.getstream.video.android.core.R
-
-// declare "incoming_calls_custom" as a constant
-const val INCOMING_CALLS_CUSTOM = "incoming_calls_custom"
- 
-class CustomNotificationHandler(
-    val application: Application,
-    private val endCall: (callId: StreamCallId) -> Unit = {},
-    private val incomingCall: () -> Unit = {}
-) : DefaultNotificationHandler(application, hideRingingNotificationInForeground = false) {
-    companion object {
-        private const val PREFS_NAME = "StreamCallPrefs"
-        private const val KEY_NOTIFICATION_TIME = "notification_creation_time"
-    }
-    private var allowSound = true
- 
-    override fun getRingingCallNotification(
-        ringingState: RingingState,
-        callId: StreamCallId,
-        callDisplayName: String?,
-        shouldHaveContentIntent: Boolean,
-    ): Notification? {
-        Log.d("CustomNotificationHandler", "getRingingCallNotification called: ringingState=$ringingState, callId=$callId, callDisplayName=$callDisplayName, shouldHaveContentIntent=$shouldHaveContentIntent")
-        return if (ringingState is RingingState.Incoming) {
-            // 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).apply {
-                putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
-                // Explicitly target our manifest-declared receiver
-                setClass(application, AcceptCallReceiver::class.java)
-            }
-
-            Log.d("CustomNotificationHandler", "Constructed Accept Call Intent for PI: action=${acceptCallIntent.action}, cid=${acceptCallIntent.streamCallId(NotificationHandler.INTENT_EXTRA_CALL_CID)}, component=${acceptCallIntent.component}")
-
-            val requestCodeAccept = callId.cid.hashCode() + 1 // Unique request code for the PendingIntent with offset to avoid collisions
-            val acceptCallPendingIntent = createAcceptCallPendingIntent(callId, requestCodeAccept, acceptCallIntent)
-            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,
-                    acceptCallPendingIntent,
-                    rejectCallPendingIntent,
-                    callDisplayName,
-                    shouldHaveContentIntent,
-                    callId
-                )
-            } else {
-                Log.e("CustomNotificationHandler", "Ringing call notification not shown, one of the intents is null.")
-                null
-            }
-        } else if (ringingState is RingingState.Outgoing) {
-            val outgoingCallPendingIntent = intentResolver.searchOutgoingCallPendingIntent(callId)
-            val endCallPendingIntent = intentResolver.searchEndCallPendingIntent(callId)
- 
-            if (outgoingCallPendingIntent != null && endCallPendingIntent != null) {
-                getOngoingCallNotification(
-                    callId,
-                    callDisplayName,
-                    isOutgoingCall = true,
-                )
-            } else {
-                Log.e("CustomNotificationHandler", "Ringing call notification not shown, one of the intents is null.")
-                null
-            }
-        } else {
-            null
-        }
-    }
-
-    private fun createAcceptCallPendingIntent(
-        callId: StreamCallId,
-        requestCode: Int,
-        acceptCallIntent: Intent
-    ): PendingIntent? {
-        return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
-            val launchIntent = application.packageManager.getLaunchIntentForPackage(application.packageName)
-            if (launchIntent != null) {
-                launchIntent.action = NotificationHandler.ACTION_ACCEPT_CALL
-                launchIntent.putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
-                launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TOP)
-                PendingIntent.getActivity(
-                    application,
-                    requestCode,
-                    launchIntent,
-                    PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
-                )
-            } else {
-                Log.e("CustomNotificationHandler", "Could not get launch intent for package to create Accept PI.")
-                null
-            }
-        } else {
-            PendingIntent.getBroadcast(
-                application,
-                requestCode,
-                acceptCallIntent,
-                PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT
-            )
-        }
-    }
- 
-    fun customGetIncomingCallNotification(
-        fullScreenPendingIntent: PendingIntent,
-        acceptCallPendingIntent: PendingIntent,
-        rejectCallPendingIntent: PendingIntent,
-        callerName: String?,
-        shouldHaveContentIntent: Boolean,
-        callId: StreamCallId
-    ): Notification {
-        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,
-            rejectCallPendingIntent,
-            callerName,
-            shouldHaveContentIntent,
-            INCOMING_CALLS_CUSTOM,
-            true // Include sound
-        )
-    }
- 
-    private fun buildNotification(
-        fullScreenPendingIntent: PendingIntent,
-        acceptCallPendingIntent: PendingIntent,
-        rejectCallPendingIntent: PendingIntent,
-        callerName: String?,
-        shouldHaveContentIntent: Boolean,
-        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")
-            setChannelId(channelId)
-            setOngoing(true)
-            setAutoCancel(false)
-            setCategory(NotificationCompat.CATEGORY_CALL)
- 
-            // Clear all defaults first
-            setDefaults(0)
- 
-            if (includeSound && allowSound) {
-                setSound(RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE))
-                setDefaults(NotificationCompat.DEFAULT_VIBRATE or NotificationCompat.DEFAULT_LIGHTS)
-            } else {
-                setSound(null)
-                setDefaults(NotificationCompat.DEFAULT_VIBRATE or NotificationCompat.DEFAULT_LIGHTS)
-            }
- 
-            // setVibrate(longArrayOf(0, 1000, 500, 1000))
-            setLights(0xFF0000FF.toInt(), 1000, 1000)
-            setFullScreenIntent(fullScreenPendingIntent, true)
-            if (shouldHaveContentIntent) {
-                setContentIntent(fullScreenPendingIntent)
-            } else {
-                val emptyIntent = PendingIntent.getActivity(
-                    application,
-                    0,
-                    Intent(),
-                    PendingIntent.FLAG_IMMUTABLE,
-                )
-                setContentIntent(emptyIntent)
-            }
-            addCallActions(acceptCallPendingIntent, rejectCallPendingIntent, callerName)
-        }.apply {
-            // flags = flags or NotificationCompat.FLAG_ONGOING_EVENT
-        }
-    }
- 
-    override fun onMissedCall(callId: StreamCallId, callDisplayName: String) {
-        Log.d("CustomNotificationHandler", "onMissedCall called: callId=$callId, callDisplayName=$callDisplayName")
-        endCall(callId)
-        super.onMissedCall(callId, callDisplayName)
-    }
-
-    override fun getOngoingCallNotification(
-        callId: StreamCallId,
-        callDisplayName: String?,
-        isOutgoingCall: Boolean,
-        remoteParticipantCount: Int
-    ): Notification? {
-        Log.d("CustomNotificationHandler", "getOngoingCallNotification called: callId=$callId, isOutgoing=$isOutgoingCall, participants=$remoteParticipantCount")
-        createOngoingCallChannel()
-
-        val launchIntent = application.packageManager.getLaunchIntentForPackage(application.packageName)
-        val contentIntent = if (launchIntent != null) {
-            launchIntent.putExtra(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
-            launchIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_SINGLE_TOP)
-            PendingIntent.getActivity(
-                application,
-                callId.cid.hashCode(),
-                launchIntent,
-                PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
-            )
-        } else {
-            Log.e("CustomNotificationHandler", "Could not get launch intent for package: ${application.packageName}. Ongoing call notification will not open the app.")
-            null
-        }
-
-        return getNotification {
-            setContentTitle(callDisplayName ?: "Ongoing Call")
-            setContentText("Tap to return to the call")
-            setSmallIcon(R.drawable.stream_video_ic_call)
-            setChannelId("ongoing_calls")
-            setOngoing(true)
-            setAutoCancel(false)
-            setCategory(NotificationCompat.CATEGORY_CALL)
-            setDefaults(0)
-            if (contentIntent != null) {
-                setContentIntent(contentIntent)
-            }
-        }
-    }
- 
-    private fun customCreateIncomingCallChannel() {
-        Log.d("CustomNotificationHandler", "customCreateIncomingCallChannel called")
-        maybeCreateChannel(
-            channelId = INCOMING_CALLS_CUSTOM,
-            context = application,
-            configure = {
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                    name = application.getString(
-                        R.string.stream_video_incoming_call_notification_channel_title,
-                    )
-                    description = application.getString(R.string.stream_video_incoming_call_notification_channel_description)
-                    importance = NotificationManager.IMPORTANCE_HIGH
-                    this.lockscreenVisibility = Notification.VISIBILITY_PUBLIC
-                    this.setShowBadge(true)
- 
-                    // Set the channel to be silent since we handle sound via RingtonePlayer
-                    setSound(null, null)
-                    enableVibration(true)
-                    enableLights(true)
-                }
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
-                    this.setAllowBubbles(true)
-                }
-            },
-        )
-    }
-
-    private fun createOngoingCallChannel() {
-        Log.d("CustomNotificationHandler", "createOngoingCallChannel called")
-        maybeCreateChannel(
-            channelId = "ongoing_calls",
-            context = application,
-            configure = {
-                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                    name = "Ongoing calls"
-                    description = "Notifications for ongoing calls"
-                    importance = NotificationManager.IMPORTANCE_LOW
-                    this.lockscreenVisibility = Notification.VISIBILITY_PUBLIC
-                    this.setShowBadge(false)
-                    setSound(null, null)
-                    enableVibration(false)
-                    enableLights(false)
-                }
-            },
-        )
-    }
- 
-    fun clone(): CustomNotificationHandler {
-        Log.d("CustomNotificationHandler", "clone called")
-        return CustomNotificationHandler(this.application, this.endCall, this.incomingCall)
-    }
-}
-