@capgo/capacitor-stream-call 0.0.87 → 0.0.89

package/README.md

@@ -254,6 +254,7 @@ export class CallService {
 * [`getCallInfo(...)`](#getcallinfo)
 * [`setDynamicStreamVideoApikey(...)`](#setdynamicstreamvideoapikey)
 * [`getDynamicStreamVideoApikey()`](#getdynamicstreamvideoapikey)
+* [`getCurrentUser()`](#getcurrentuser)
 * [Interfaces](#interfaces)
 * [Type Aliases](#type-aliases)
 * [Enums](#enums)
@@ -538,6 +539,19 @@ Get the currently set dynamic Stream Video API key
 --------------------
 
 
+### getCurrentUser()
+
+```typescript
+getCurrentUser() => Promise<CurrentUserResponse>
+```
+
+Get the current user's information
+
+**Returns:** <code>Promise&lt;<a href="#currentuserresponse">CurrentUserResponse</a>&gt;</code>
+
+--------------------
+
+
 ### Interfaces
 
 
@@ -819,6 +833,16 @@ The JSON representation for <a href="#listvalue">`ListValue`</a> is JSON array.
 | **`hasDynamicKey`** | <code>boolean</code>        | Whether a dynamic key is currently set  |
 
 
+#### CurrentUserResponse
+
+| Prop             | Type                 | Description                             |
+| ---------------- | -------------------- | --------------------------------------- |
+| **`userId`**     | <code>string</code>  | User ID of the current user             |
+| **`name`**       | <code>string</code>  | Display name of the current user        |
+| **`imageURL`**   | <code>string</code>  | Avatar URL of the current user          |
+| **`isLoggedIn`** | <code>boolean</code> | Whether the user is currently logged in |
+
+
 ### Type Aliases
 
 

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(NotificationHandler.INTENT_EXTRA_CALL_CID, callId)
+            action = "io.getstream.video.android.action.INCOMING_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
@@ -196,16 +200,20 @@ class StreamCallPlugin : Plugin() {
     }
 
     override fun load() {
+        Log.d("StreamCallPlugin", "Plugin load() called")
         try {
             val packageInfo = context.packageManager.getPackageInfo(context.packageName, 0)
             if (packageInfo.firstInstallTime == packageInfo.lastUpdateTime) {
                 Log.d("StreamCallPlugin", "Fresh install detected, clearing user credentials.")
                 SecureUserRepository.getInstance(context).removeCurrentUser()
+            } else {
+                Log.d("StreamCallPlugin", "App update or existing installation detected")
             }
         } catch (e: Exception) {
             Log.e("StreamCallPlugin", "Error checking for fresh install", e)
         }
         // general init
+        Log.d("StreamCallPlugin", "Calling initializeStreamVideo() from load()")
         initializeStreamVideo()
         setupViews()
         super.load()
@@ -316,6 +324,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 +581,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 +589,23 @@ class StreamCallPlugin : Plugin() {
                     )
                 ),
                 requestPermissionOnAppLaunch = { true },
-                notificationHandler = notificationHandler,
+                notificationHandler = CompatibilityStreamNotificationHandler(
+                    application = application,
+                    intentResolver = CustomStreamIntentResolver(application),
+                    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 +1965,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}")
@@ -2501,6 +2503,35 @@ class StreamCallPlugin : Plugin() {
         }
     }
 
+    @PluginMethod
+    fun getCurrentUser(call: PluginCall) {
+        Log.d("StreamCallPlugin", "getCurrentUser called")
+        try {
+            val savedCredentials = SecureUserRepository.getInstance(context).loadCurrentUser()
+            val ret = JSObject()
+            
+            if (savedCredentials != null) {
+                Log.d("StreamCallPlugin", "getCurrentUser: Found saved credentials for user: ${savedCredentials.user.id}")
+                ret.put("userId", savedCredentials.user.id)
+                ret.put("name", savedCredentials.user.name ?: "")
+                ret.put("imageURL", savedCredentials.user.image ?: "")
+                ret.put("isLoggedIn", true)
+            } else {
+                Log.d("StreamCallPlugin", "getCurrentUser: No saved credentials found")
+                ret.put("userId", "")
+                ret.put("name", "")
+                ret.put("imageURL", "")
+                ret.put("isLoggedIn", false)
+            }
+            
+            Log.d("StreamCallPlugin", "getCurrentUser: Returning ${ret}")
+            call.resolve(ret)
+        } catch (e: Exception) {
+            Log.e("StreamCallPlugin", "getCurrentUser: Failed to get current user", e)
+            call.reject("Failed to get current user", e)
+        }
+    }
+
     companion object {
         @JvmStatic fun preLoadInit(ctx: Context, app: Application) {
             holder ?: run {

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

@@ -50,6 +50,8 @@ class SecureUserRepository private constructor(context: Context) : UserRepositor
     }
 
     override fun save(user: UserCredentials) {
+        android.util.Log.d("SecureUserRepository", "Saving user credentials for: ${user.user.id}")
+        
         val customJson = user.user.custom?.let { customMap ->
             JSONObject().apply {
                 customMap.forEach { (key, value) ->
@@ -70,6 +72,8 @@ class SecureUserRepository private constructor(context: Context) : UserRepositor
             putString(KEY_USER, userJson.toString())
             putString(KEY_TOKEN, user.tokenValue)
         }
+        
+        android.util.Log.d("SecureUserRepository", "User credentials saved successfully for: ${user.user.id}")
     }
 
     override fun save(token: String) {
@@ -77,6 +81,8 @@ class SecureUserRepository private constructor(context: Context) : UserRepositor
     }
 
     override fun loadCurrentUser(): UserCredentials? {
+        android.util.Log.d("SecureUserRepository", "Loading current user credentials")
+        
         val userJson = sharedPreferences.getString(KEY_USER, null)
         val token = sharedPreferences.getString(KEY_TOKEN, null)
 
@@ -91,20 +97,26 @@ class SecureUserRepository private constructor(context: Context) : UserRepositor
                     role = jsonObject.optString("role"),
                     custom = ArrayMap()
                 )
-                UserCredentials(user, token)
+                val credentials = UserCredentials(user, token)
+                android.util.Log.d("SecureUserRepository", "Successfully loaded credentials for user: ${user.id}")
+                credentials
             } else {
+                android.util.Log.d("SecureUserRepository", "No stored credentials found (userJson: ${userJson != null}, token: ${token != null})")
                 null
             }
         } catch (e: Exception) {
+            android.util.Log.e("SecureUserRepository", "Error loading user credentials", e)
             e.printStackTrace()
             null
         }
     }
 
     override fun removeCurrentUser() {
+        android.util.Log.d("SecureUserRepository", "Removing current user credentials")
         sharedPreferences.edit {
             remove(KEY_USER)
             remove(KEY_TOKEN)
         }
+        android.util.Log.d("SecureUserRepository", "User credentials removed successfully")
     }
-} 
+} 

package/dist/docs.json

@@ -483,6 +483,27 @@
           "DynamicApiKeyResponse"
         ],
         "slug": "getdynamicstreamvideoapikey"
+      },
+      {
+        "name": "getCurrentUser",
+        "signature": "() => Promise<CurrentUserResponse>",
+        "parameters": [],
+        "returns": "Promise<CurrentUserResponse>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "Current user information"
+          },
+          {
+            "name": "example",
+            "text": "const currentUser = await StreamCall.getCurrentUser();\nconsole.log(currentUser);"
+          }
+        ],
+        "docs": "Get the current user's information",
+        "complexTypes": [
+          "CurrentUserResponse"
+        ],
+        "slug": "getcurrentuser"
       }
     ],
     "properties": []
@@ -1462,6 +1483,68 @@
           "type": "boolean"
         }
       ]
+    },
+    {
+      "name": "CurrentUserResponse",
+      "slug": "currentuserresponse",
+      "docs": "",
+      "tags": [
+        {
+          "text": "CurrentUserResponse",
+          "name": "interface"
+        },
+        {
+          "text": "Response from getCurrentUser containing user information",
+          "name": "description"
+        },
+        {
+          "text": "{string} userId - User ID of the current user",
+          "name": "property"
+        },
+        {
+          "text": "{string} name - Display name of the current user",
+          "name": "property"
+        },
+        {
+          "text": "{string} [imageURL] - Avatar URL of the current user",
+          "name": "property"
+        },
+        {
+          "text": "{boolean} isLoggedIn - Whether the user is currently logged in",
+          "name": "property"
+        }
+      ],
+      "methods": [],
+      "properties": [
+        {
+          "name": "userId",
+          "tags": [],
+          "docs": "User ID of the current user",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "name",
+          "tags": [],
+          "docs": "Display name of the current user",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "imageURL",
+          "tags": [],
+          "docs": "Avatar URL of the current user",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "isLoggedIn",
+          "tags": [],
+          "docs": "Whether the user is currently logged in",
+          "complexTypes": [],
+          "type": "boolean"
+        }
+      ]
     }
   ],
   "enums": [

package/dist/esm/definitions.d.ts

@@ -98,6 +98,24 @@ export interface DynamicApiKeyResponse {
     /** Whether a dynamic key is currently set */
     hasDynamicKey: boolean;
 }
+/**
+ * @interface CurrentUserResponse
+ * @description Response from getCurrentUser containing user information
+ * @property {string} userId - User ID of the current user
+ * @property {string} name - Display name of the current user
+ * @property {string} [imageURL] - Avatar URL of the current user
+ * @property {boolean} isLoggedIn - Whether the user is currently logged in
+ */
+export interface CurrentUserResponse {
+    /** User ID of the current user */
+    userId: string;
+    /** Display name of the current user */
+    name: string;
+    /** Avatar URL of the current user */
+    imageURL?: string;
+    /** Whether the user is currently logged in */
+    isLoggedIn: boolean;
+}
 /**
  * @interface SuccessResponse
  * @description Standard response indicating operation success/failure
@@ -299,6 +317,14 @@ export interface StreamCallPlugin {
      * }
      */
     getDynamicStreamVideoApikey(): Promise<DynamicApiKeyResponse>;
+    /**
+     * Get the current user's information
+     * @returns {Promise<CurrentUserResponse>} Current user information
+     * @example
+     * const currentUser = await StreamCall.getCurrentUser();
+     * console.log(currentUser);
+     */
+    getCurrentUser(): Promise<CurrentUserResponse>;
 }
 /**
  * @interface IncomingCallPayload