@capgo/capacitor-stream-call 0.0.2

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

@@ -0,0 +1,31 @@
+import android.view.MotionEvent
+import android.view.ViewGroup
+import androidx.coordinatorlayout.widget.CoordinatorLayout
+
+class TouchInterceptWrapper(private val originalViewGroup: ViewGroup) : CoordinatorLayout(
+    originalViewGroup.context
+) {
+    init {
+        // Copy layout parameters and children
+        layoutParams = originalViewGroup.layoutParams
+        while (originalViewGroup.childCount > 0) {
+            val child = originalViewGroup.getChildAt(0)
+            originalViewGroup.removeViewAt(0)
+            addView(child)
+        }
+    }
+
+    override fun dispatchTouchEvent(ev: MotionEvent): Boolean {
+        // Broadcast to all children first
+        for (i in 0 until childCount) {
+            val child = getChildAt(i)
+            if (child.visibility == VISIBLE) {
+                val eventCopy = MotionEvent.obtain(ev)
+                child.dispatchTouchEvent(eventCopy)
+                eventCopy.recycle()
+            }
+        }
+        // Then let the normal touch handling occur
+        return super.dispatchTouchEvent(ev)
+    }
+}

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

@@ -0,0 +1,111 @@
+package ee.forgr.capacitor.streamcall
+
+import android.content.Context
+import android.content.SharedPreferences
+import android.util.ArrayMap
+import io.getstream.video.android.model.User
+import org.json.JSONObject
+
+data class UserCredentials(
+    val user: User,
+    val tokenValue: String
+) {
+    val id: String
+        get() = user.id
+}
+
+interface UserRepository {
+    fun save(user: UserCredentials)
+    fun loadCurrentUser(): UserCredentials?
+    fun removeCurrentUser()
+    fun save(token: String)
+}
+
+/**
+ * Note: This is just for simplicity. In a production environment,
+ * consider using more secure storage solutions like EncryptedSharedPreferences
+ * or a proper database with encryption.
+ */
+class SecureUserRepository private constructor(context: Context) : UserRepository {
+
+    private val sharedPreferences: SharedPreferences = context.getSharedPreferences(
+        PREFS_NAME,
+        Context.MODE_PRIVATE
+    )
+
+    companion object {
+        private const val PREFS_NAME = "stream_video_prefs"
+        private const val KEY_USER = "stream.video.user"
+        private const val KEY_TOKEN = "stream.video.token"
+
+        @Volatile
+        private var instance: SecureUserRepository? = null
+
+        fun getInstance(context: Context): SecureUserRepository {
+            return instance ?: synchronized(this) {
+                instance ?: SecureUserRepository(context.applicationContext).also { instance = it }
+            }
+        }
+    }
+
+    override fun save(user: UserCredentials) {
+        val customJson = user.user.custom?.let { customMap ->
+            JSONObject().apply {
+                customMap.forEach { (key, value) ->
+                    put(key, value)
+                }
+            }
+        }
+
+        val userJson = JSONObject().apply {
+            put("id", user.user.id)
+            put("name", user.user.name)
+            put("image", user.user.image)
+            put("role", user.user.role)
+            put("custom", customJson)
+        }
+
+        with(sharedPreferences.edit()) {
+            putString(KEY_USER, userJson.toString())
+            putString(KEY_TOKEN, user.tokenValue)
+            apply()
+        }
+    }
+
+    override fun save(token: String) {
+        sharedPreferences.edit().putString(KEY_TOKEN, token).apply()
+    }
+
+    override fun loadCurrentUser(): UserCredentials? {
+        val userJson = sharedPreferences.getString(KEY_USER, null)
+        val token = sharedPreferences.getString(KEY_TOKEN, null)
+
+        return try {
+            if (userJson != null && token != null) {
+                val jsonObject = JSONObject(userJson)
+
+                val user = User(
+                    id = jsonObject.getString("id"),
+                    name = jsonObject.optString("name"),
+                    image = jsonObject.optString("image"),
+                    role = jsonObject.optString("role"),
+                    custom = ArrayMap()
+                )
+                UserCredentials(user, token)
+            } else {
+                null
+            }
+        } catch (e: Exception) {
+            e.printStackTrace()
+            null
+        }
+    }
+
+    override fun removeCurrentUser() {
+        with(sharedPreferences.edit()) {
+            remove(KEY_USER)
+            remove(KEY_TOKEN)
+            apply()
+        }
+    }
+} 

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources xmlns:tools="http://schemas.android.com/tools">
+    <string name="CAPACITOR_STREAM_VIDEO_APIKEY" />
+    <string name="stream_video_incoming_call_notification_channel_title">Incoming Calls</string>
+    <string name="stream_video_incoming_call_notification_channel_description">Incoming audio and video call alerts</string>
+    <string name="stream_video_incoming_call_low_priority_notification_channel_description">Incoming audio and video call alerts</string>
+</resources>

package/dist/docs.json

@@ -0,0 +1,533 @@
+{
+  "api": {
+    "name": "StreamCallPlugin",
+    "slug": "streamcallplugin",
+    "docs": "",
+    "tags": [
+      {
+        "text": "StreamCallPlugin",
+        "name": "interface"
+      },
+      {
+        "text": "Capacitor plugin for Stream Video calling functionality",
+        "name": "description"
+      }
+    ],
+    "methods": [
+      {
+        "name": "login",
+        "signature": "(options: LoginOptions) => Promise<SuccessResponse>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "- Login configuration",
+            "type": "LoginOptions"
+          }
+        ],
+        "returns": "Promise<SuccessResponse>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "options - Login configuration"
+          },
+          {
+            "name": "returns",
+            "text": "Success status"
+          },
+          {
+            "name": "example",
+            "text": "await StreamCall.login({\n  token: 'your-token',\n  userId: 'user-123',\n  name: 'John Doe',\n  apiKey: 'your-api-key'\n});"
+          }
+        ],
+        "docs": "Login to Stream Video service",
+        "complexTypes": [
+          "SuccessResponse",
+          "LoginOptions"
+        ],
+        "slug": "login"
+      },
+      {
+        "name": "logout",
+        "signature": "() => Promise<SuccessResponse>",
+        "parameters": [],
+        "returns": "Promise<SuccessResponse>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "Success status"
+          },
+          {
+            "name": "example",
+            "text": "await StreamCall.logout();"
+          }
+        ],
+        "docs": "Logout from Stream Video service",
+        "complexTypes": [
+          "SuccessResponse"
+        ],
+        "slug": "logout"
+      },
+      {
+        "name": "call",
+        "signature": "(options: CallOptions) => Promise<SuccessResponse>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "- Call configuration",
+            "type": "CallOptions"
+          }
+        ],
+        "returns": "Promise<SuccessResponse>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "options - Call configuration"
+          },
+          {
+            "name": "returns",
+            "text": "Success status"
+          },
+          {
+            "name": "example",
+            "text": "await StreamCall.call({\n  userId: 'user-456',\n  type: 'video',\n  ring: true\n});"
+          }
+        ],
+        "docs": "Initiate a call to another user",
+        "complexTypes": [
+          "SuccessResponse",
+          "CallOptions"
+        ],
+        "slug": "call"
+      },
+      {
+        "name": "endCall",
+        "signature": "() => Promise<SuccessResponse>",
+        "parameters": [],
+        "returns": "Promise<SuccessResponse>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "Success status"
+          },
+          {
+            "name": "example",
+            "text": "await StreamCall.endCall();"
+          }
+        ],
+        "docs": "End the current call",
+        "complexTypes": [
+          "SuccessResponse"
+        ],
+        "slug": "endcall"
+      },
+      {
+        "name": "setMicrophoneEnabled",
+        "signature": "(options: { enabled: boolean; }) => Promise<SuccessResponse>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "- Microphone state",
+            "type": "{ enabled: boolean; }"
+          }
+        ],
+        "returns": "Promise<SuccessResponse>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "options - Microphone state"
+          },
+          {
+            "name": "returns",
+            "text": "Success status"
+          },
+          {
+            "name": "example",
+            "text": "await StreamCall.setMicrophoneEnabled({ enabled: false });"
+          }
+        ],
+        "docs": "Enable or disable microphone",
+        "complexTypes": [
+          "SuccessResponse"
+        ],
+        "slug": "setmicrophoneenabled"
+      },
+      {
+        "name": "setCameraEnabled",
+        "signature": "(options: { enabled: boolean; }) => Promise<SuccessResponse>",
+        "parameters": [
+          {
+            "name": "options",
+            "docs": "- Camera state",
+            "type": "{ enabled: boolean; }"
+          }
+        ],
+        "returns": "Promise<SuccessResponse>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "options - Camera state"
+          },
+          {
+            "name": "returns",
+            "text": "Success status"
+          },
+          {
+            "name": "example",
+            "text": "await StreamCall.setCameraEnabled({ enabled: false });"
+          }
+        ],
+        "docs": "Enable or disable camera",
+        "complexTypes": [
+          "SuccessResponse"
+        ],
+        "slug": "setcameraenabled"
+      },
+      {
+        "name": "addListener",
+        "signature": "(eventName: 'callEvent', listenerFunc: (event: CallEvent) => void) => Promise<{ remove: () => Promise<void>; }>",
+        "parameters": [
+          {
+            "name": "eventName",
+            "docs": "- Name of the event to listen for",
+            "type": "'callEvent'"
+          },
+          {
+            "name": "listenerFunc",
+            "docs": "- Callback function",
+            "type": "(event: CallEvent) => void"
+          }
+        ],
+        "returns": "Promise<{ remove: () => Promise<void>; }>",
+        "tags": [
+          {
+            "name": "param",
+            "text": "eventName - Name of the event to listen for"
+          },
+          {
+            "name": "param",
+            "text": "listenerFunc - Callback function"
+          },
+          {
+            "name": "returns",
+            "text": "Function to remove listener"
+          },
+          {
+            "name": "example",
+            "text": "const listener = await StreamCall.addListener('callEvent', (event) => {\n  console.log(`Call ${event.callId} is now ${event.state}`);\n});"
+          }
+        ],
+        "docs": "Add listener for call events",
+        "complexTypes": [
+          "CallEvent"
+        ],
+        "slug": "addlistenercallevent-"
+      },
+      {
+        "name": "removeAllListeners",
+        "signature": "() => Promise<void>",
+        "parameters": [],
+        "returns": "Promise<void>",
+        "tags": [
+          {
+            "name": "returns"
+          },
+          {
+            "name": "example",
+            "text": "await StreamCall.removeAllListeners();"
+          }
+        ],
+        "docs": "Remove all event listeners",
+        "complexTypes": [],
+        "slug": "removealllisteners"
+      },
+      {
+        "name": "acceptCall",
+        "signature": "() => Promise<SuccessResponse>",
+        "parameters": [],
+        "returns": "Promise<SuccessResponse>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "Success status"
+          },
+          {
+            "name": "example",
+            "text": "await StreamCall.acceptCall();"
+          }
+        ],
+        "docs": "Accept an incoming call",
+        "complexTypes": [
+          "SuccessResponse"
+        ],
+        "slug": "acceptcall"
+      },
+      {
+        "name": "rejectCall",
+        "signature": "() => Promise<SuccessResponse>",
+        "parameters": [],
+        "returns": "Promise<SuccessResponse>",
+        "tags": [
+          {
+            "name": "returns",
+            "text": "Success status"
+          },
+          {
+            "name": "example",
+            "text": "await StreamCall.rejectCall();"
+          }
+        ],
+        "docs": "Reject an incoming call",
+        "complexTypes": [
+          "SuccessResponse"
+        ],
+        "slug": "rejectcall"
+      }
+    ],
+    "properties": []
+  },
+  "interfaces": [
+    {
+      "name": "SuccessResponse",
+      "slug": "successresponse",
+      "docs": "",
+      "tags": [
+        {
+          "text": "SuccessResponse",
+          "name": "interface"
+        },
+        {
+          "text": "Standard response indicating operation success/failure",
+          "name": "description"
+        },
+        {
+          "text": "{boolean} success - Whether the operation succeeded",
+          "name": "property"
+        }
+      ],
+      "methods": [],
+      "properties": [
+        {
+          "name": "success",
+          "tags": [],
+          "docs": "Whether the operation was successful",
+          "complexTypes": [],
+          "type": "boolean"
+        }
+      ]
+    },
+    {
+      "name": "LoginOptions",
+      "slug": "loginoptions",
+      "docs": "",
+      "tags": [
+        {
+          "text": "LoginOptions",
+          "name": "interface"
+        },
+        {
+          "text": "Configuration options for logging into the Stream Video service",
+          "name": "description"
+        },
+        {
+          "text": "{string} token - Stream Video API token for authentication",
+          "name": "property"
+        },
+        {
+          "text": "{string} userId - Unique identifier for the current user",
+          "name": "property"
+        },
+        {
+          "text": "{string} name - Display name for the current user",
+          "name": "property"
+        },
+        {
+          "text": "{string} [imageURL] - Avatar URL for the current user",
+          "name": "property"
+        },
+        {
+          "text": "{string} apiKey - Stream Video API key for your application",
+          "name": "property"
+        },
+        {
+          "text": "{string} [magicDivId] - DOM element ID where video will be rendered",
+          "name": "property"
+        },
+        {
+          "text": "{Object} [refreshToken] - Token refresh configuration",
+          "name": "property"
+        },
+        {
+          "text": "{string} refreshToken.url - Endpoint URL for token refresh",
+          "name": "property"
+        },
+        {
+          "text": "{Record<string, string>} [refreshToken.headers] - Custom headers for refresh request",
+          "name": "property"
+        }
+      ],
+      "methods": [],
+      "properties": [
+        {
+          "name": "token",
+          "tags": [],
+          "docs": "Stream Video API token",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "userId",
+          "tags": [],
+          "docs": "User ID for the current user",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "name",
+          "tags": [],
+          "docs": "Display name for the current user",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "imageURL",
+          "tags": [],
+          "docs": "Optional avatar URL for the current user",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "apiKey",
+          "tags": [],
+          "docs": "Stream Video API key",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "magicDivId",
+          "tags": [],
+          "docs": "ID of the HTML element where the video will be rendered",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "refreshToken",
+          "tags": [],
+          "docs": "Configuration for token refresh",
+          "complexTypes": [
+            "Record"
+          ],
+          "type": "{ url: string; headers?: Record<string, string> | undefined; } | undefined"
+        }
+      ]
+    },
+    {
+      "name": "CallOptions",
+      "slug": "calloptions",
+      "docs": "",
+      "tags": [
+        {
+          "text": "CallOptions",
+          "name": "interface"
+        },
+        {
+          "text": "Options for initiating a video call",
+          "name": "description"
+        },
+        {
+          "text": "{string} userId - ID of the user to call",
+          "name": "property"
+        },
+        {
+          "text": "{string} [type=default] - Type of call",
+          "name": "property"
+        },
+        {
+          "text": "{boolean} [ring=true] - Whether to send ring notification",
+          "name": "property"
+        }
+      ],
+      "methods": [],
+      "properties": [
+        {
+          "name": "userId",
+          "tags": [],
+          "docs": "User ID of the person to call",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "type",
+          "tags": [],
+          "docs": "Type of call, defaults to 'default'",
+          "complexTypes": [],
+          "type": "string | undefined"
+        },
+        {
+          "name": "ring",
+          "tags": [],
+          "docs": "Whether to ring the other user, defaults to true",
+          "complexTypes": [],
+          "type": "boolean | undefined"
+        }
+      ]
+    },
+    {
+      "name": "CallEvent",
+      "slug": "callevent",
+      "docs": "",
+      "tags": [
+        {
+          "text": "CallEvent",
+          "name": "interface"
+        },
+        {
+          "text": "Event emitted when call state changes",
+          "name": "description"
+        },
+        {
+          "text": "{string} callId - Unique identifier of the call",
+          "name": "property"
+        },
+        {
+          "text": "{string} state - Current state of the call (joined, left, ringing, etc)",
+          "name": "property"
+        }
+      ],
+      "methods": [],
+      "properties": [
+        {
+          "name": "callId",
+          "tags": [],
+          "docs": "ID of the call",
+          "complexTypes": [],
+          "type": "string"
+        },
+        {
+          "name": "state",
+          "tags": [],
+          "docs": "Current state of the call",
+          "complexTypes": [],
+          "type": "string"
+        }
+      ]
+    }
+  ],
+  "enums": [],
+  "typeAliases": [
+    {
+      "name": "Record",
+      "slug": "record",
+      "docs": "Construct a type with a set of properties K of type T",
+      "types": [
+        {
+          "text": "{\r\n    [P in K]: T;\r\n}",
+          "complexTypes": [
+            "K",
+            "T"
+          ]
+        }
+      ]
+    }
+  ],
+  "pluginConfigs": []
+}