@kapsula-chat/capacitor-push-calls 1.0.0

package/android/src/main/java/com/capacitor/voipcalls/CapacitorVoipCallsPlugin.kt

@@ -0,0 +1,584 @@
+package com.capacitor.voipcalls
+
+import android.Manifest
+import android.app.Notification
+import android.app.NotificationChannel
+import android.app.NotificationManager
+import android.content.Context
+import android.content.Intent
+import android.content.pm.PackageManager
+import android.os.Build
+import androidx.core.content.ContextCompat
+import com.getcapacitor.JSArray
+import com.getcapacitor.JSObject
+import com.getcapacitor.PermissionState
+import com.getcapacitor.Plugin
+import com.getcapacitor.PluginCall
+import com.getcapacitor.PluginMethod
+import com.getcapacitor.annotation.CapacitorPlugin
+import com.getcapacitor.annotation.Permission
+import com.getcapacitor.annotation.PermissionCallback
+import com.google.firebase.messaging.FirebaseMessaging
+import org.json.JSONObject
+import java.util.UUID
+
+@CapacitorPlugin(
+    name = "CapacitorPushCalls",
+    permissions = [
+        Permission(strings = [Manifest.permission.RECORD_AUDIO], alias = "audio"),
+        Permission(strings = [Manifest.permission.CAMERA], alias = "camera"),
+        Permission(strings = [Manifest.permission.POST_NOTIFICATIONS], alias = "receive")
+    ]
+)
+class CapacitorVoipCallsPlugin : Plugin() {
+    internal var callManager: CallManager? = null
+
+    companion object {
+        private const val BADGE_PREFS = "capacitor_push_calls"
+        private const val BADGE_KEY = "badge_count"
+
+        @Volatile
+        private var pluginInstance: CapacitorVoipCallsPlugin? = null
+
+        private val pendingEvents = mutableListOf<Pair<String, JSObject>>()
+
+        fun emitFromService(event: String, data: JSObject) {
+            val instance = pluginInstance
+            if (instance != null) {
+                instance.emitEvent(event, data)
+                return
+            }
+
+            synchronized(pendingEvents) {
+                pendingEvents.add(event to data)
+            }
+        }
+
+        fun routeRemoteMessage(context: Context, data: Map<String, String>, title: String?, body: String?) {
+            val type = data["type"]?.lowercase()
+            if (type == "call") {
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
+                    return
+                }
+
+                try {
+                    VoipConnectionService.registerPhoneAccount(context)
+                } catch (_: SecurityException) {
+                }
+
+                val callId = data["callId"] ?: UUID.randomUUID().toString()
+                val handle = data["handle"] ?: return
+                val displayName = data["displayName"] ?: handle
+                val handleType = data["handleType"] ?: "generic"
+                val video = parseBoolean(data["video"])
+
+                val metadata = JSObject()
+                for ((key, value) in data) {
+                    if (key in setOf("type", "callId", "handle", "displayName", "handleType", "video")) {
+                        continue
+                    }
+                    metadata.put(key, value)
+                }
+
+                val manager = CallManager(context)
+                manager.reportIncomingCall(
+                    callId = callId,
+                    handle = handle,
+                    displayName = displayName,
+                    handleType = handleType,
+                    video = video,
+                    metadata = if (metadata.length() > 0) metadata else null
+                )
+                return
+            }
+
+            val notification = JSObject().apply {
+                put("id", data["messageId"] ?: UUID.randomUUID().toString())
+                if (title != null) put("title", title)
+                if (body != null) put("body", body)
+                put("data", JSObject().apply {
+                    data.forEach { (key, value) -> put(key, value) }
+                })
+            }
+
+            emitFromService("pushNotificationReceived", notification)
+        }
+
+        private fun parseBoolean(value: String?): Boolean {
+            return value.equals("true", ignoreCase = true) || value == "1"
+        }
+    }
+
+    override fun load() {
+        callManager = CallManager(this)
+        pluginInstance = this
+        flushPendingEvents()
+    }
+
+    override fun handleOnDestroy() {
+        if (pluginInstance === this) {
+            pluginInstance = null
+        }
+        super.handleOnDestroy()
+    }
+
+    @PluginMethod
+    fun register(call: PluginCall) {
+        FirebaseMessaging.getInstance().token
+            .addOnSuccessListener { token ->
+                emitEvent("registration", JSObject().apply { put("value", token) })
+                call.resolve()
+            }
+            .addOnFailureListener { error ->
+                emitEvent("registrationError", JSObject().apply {
+                    put("error", error.localizedMessage ?: "Failed to get FCM token")
+                })
+                call.reject("Failed to register for push notifications", error)
+            }
+    }
+
+    @PluginMethod
+    fun unregister(call: PluginCall) {
+        FirebaseMessaging.getInstance().deleteToken()
+            .addOnSuccessListener { call.resolve() }
+            .addOnFailureListener { error ->
+                call.reject("Failed to unregister from push notifications", error)
+            }
+    }
+
+    @PluginMethod
+    override fun checkPermissions(call: PluginCall) {
+        val receive = if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            PermissionState.GRANTED.toString()
+        } else {
+            getPermissionState("receive").toString()
+        }
+
+        call.resolve(JSObject().apply {
+            put("receive", receive)
+        })
+    }
+
+    @PluginMethod
+    override fun requestPermissions(call: PluginCall) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            call.resolve(JSObject().apply {
+                put("receive", PermissionState.GRANTED.toString())
+            })
+            return
+        }
+
+        requestPermissionForAlias("receive", call, "receivePermissionCallback")
+    }
+
+    @PermissionCallback
+    private fun receivePermissionCallback(call: PluginCall) {
+        checkPermissions(call)
+    }
+
+    @PluginMethod
+    fun getDeliveredNotifications(call: PluginCall) {
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val notifications = JSArray()
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            manager.activeNotifications.forEach { sbn ->
+                val extras = sbn.notification.extras
+                val notification = JSObject().apply {
+                    put("id", sbn.id.toString())
+                    put("title", extras.getString("android.title"))
+                    put("body", extras.getCharSequence("android.text")?.toString())
+                    put("tag", sbn.tag)
+                    put("data", JSObject())
+                }
+                notifications.put(notification)
+            }
+        }
+
+        call.resolve(JSObject().apply {
+            put("notifications", notifications)
+        })
+    }
+
+    @PluginMethod
+    fun removeDeliveredNotifications(call: PluginCall) {
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val payload = call.getArray("notifications")
+
+        if (payload == null) {
+            call.reject("Missing notifications parameter")
+            return
+        }
+
+        for (index in 0 until payload.length()) {
+            when (val item = payload.opt(index)) {
+                is String -> manager.cancel(item.toIntOrNull() ?: continue)
+                is JSObject -> {
+                    val id = item.getString("id")
+                    if (id != null) {
+                        manager.cancel(id.toIntOrNull() ?: continue)
+                    }
+                }
+                is JSONObject -> {
+                    val id = item.optString("id", null)
+                    if (id != null) {
+                        manager.cancel(id.toIntOrNull() ?: continue)
+                    }
+                }
+            }
+        }
+
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun removeAllDeliveredNotifications(call: PluginCall) {
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        manager.cancelAll()
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun getBadgeCount(call: PluginCall) {
+        val prefs = context.getSharedPreferences(BADGE_PREFS, Context.MODE_PRIVATE)
+        val count = prefs.getInt(BADGE_KEY, 0)
+        call.resolve(JSObject().apply {
+            put("count", count)
+        })
+    }
+
+    @PluginMethod
+    fun getBadgeNumber(call: PluginCall) {
+        getBadgeCount(call)
+    }
+
+    @PluginMethod
+    fun setBadgeCount(call: PluginCall) {
+        val count = call.getInt("count")
+        if (count == null || count < 0) {
+            call.reject("Invalid count parameter")
+            return
+        }
+
+        val prefs = context.getSharedPreferences(BADGE_PREFS, Context.MODE_PRIVATE)
+        prefs.edit().putInt(BADGE_KEY, count).apply()
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun setBadgeNumber(call: PluginCall) {
+        setBadgeCount(call)
+    }
+
+    @PluginMethod
+    fun clearBadgeCount(call: PluginCall) {
+        val prefs = context.getSharedPreferences(BADGE_PREFS, Context.MODE_PRIVATE)
+        prefs.edit().putInt(BADGE_KEY, 0).apply()
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun createChannel(call: PluginCall) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            call.resolve()
+            return
+        }
+
+        val id = call.getString("id")
+        val name = call.getString("name")
+        if (id == null || name == null) {
+            call.reject("Missing required channel fields: id and name")
+            return
+        }
+
+        val importance = call.getInt("importance") ?: NotificationManager.IMPORTANCE_DEFAULT
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val channel = NotificationChannel(id, name, importance).apply {
+            description = call.getString("description")
+            enableLights(call.getBoolean("lights") ?: false)
+            enableVibration(call.getBoolean("vibration") ?: true)
+            lockscreenVisibility = call.getInt("visibility") ?: Notification.VISIBILITY_PRIVATE
+            val sound = call.getString("sound")
+            if (sound == null || sound == "default") {
+                setSound(null, null)
+            }
+        }
+
+        manager.createNotificationChannel(channel)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun deleteChannel(call: PluginCall) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            call.resolve()
+            return
+        }
+
+        val id = call.getString("id")
+        if (id == null) {
+            call.reject("Missing channel id")
+            return
+        }
+
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        manager.deleteNotificationChannel(id)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun listChannels(call: PluginCall) {
+        val manager = context.getSystemService(Context.NOTIFICATION_SERVICE) as NotificationManager
+        val channels = JSArray()
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            manager.notificationChannels.forEach { channel ->
+                channels.put(JSObject().apply {
+                    put("id", channel.id)
+                    put("name", channel.name.toString())
+                    put("description", channel.description)
+                    put("importance", channel.importance)
+                    put("visibility", channel.lockscreenVisibility)
+                    put("lights", channel.shouldShowLights())
+                    put("vibration", channel.shouldVibrate())
+                })
+            }
+        }
+
+        call.resolve(JSObject().apply {
+            put("channels", channels)
+        })
+    }
+
+    @PluginMethod
+    fun registerVoipNotifications(call: PluginCall) {
+        // Android uses FCM for call signaling via PushRouterMessagingService.
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun startCall(call: PluginCall) {
+        startCallInternal(call, canRequestPermissions = true)
+    }
+
+    private fun startCallInternal(call: PluginCall, canRequestPermissions: Boolean) {
+        val handle = call.getString("handle") ?: run {
+            call.reject("Missing handle parameter")
+            return
+        }
+        val displayName = call.getString("displayName") ?: run {
+            call.reject("Missing displayName parameter")
+            return
+        }
+
+        val handleType = call.getString("handleType") ?: "generic"
+        val video = call.getBoolean("video", false) ?: false
+
+        if (!hasRequiredPermissions()) {
+            if (!canRequestPermissions) {
+                call.reject("Missing required RECORD_AUDIO permission")
+                return
+            }
+            requestPermissionForAliases(arrayOf("audio"), call, "startCallPermissions")
+            return
+        }
+
+        val callId = UUID.randomUUID().toString()
+
+        callManager?.startCall(
+            callId = callId,
+            handle = handle,
+            displayName = displayName,
+            handleType = handleType,
+            video = video
+        )
+
+        call.resolve(JSObject().apply {
+            put("callId", callId)
+        })
+    }
+
+    @PermissionCallback
+    private fun startCallPermissions(call: PluginCall) {
+        startCallInternal(call, canRequestPermissions = false)
+    }
+
+    @PluginMethod
+    fun endCall(call: PluginCall) {
+        val callId = call.getString("callId") ?: run {
+            call.reject("Missing callId parameter")
+            return
+        }
+
+        callManager?.endCall(callId)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun answerCall(call: PluginCall) {
+        answerCallInternal(call, canRequestPermissions = true)
+    }
+
+    private fun answerCallInternal(call: PluginCall, canRequestPermissions: Boolean) {
+        val callId = call.getString("callId") ?: run {
+            call.reject("Missing callId parameter")
+            return
+        }
+
+        if (!hasRequiredPermissions()) {
+            if (!canRequestPermissions) {
+                call.reject("Missing required RECORD_AUDIO permission")
+                return
+            }
+            requestPermissionForAliases(arrayOf("audio"), call, "answerCallPermissions")
+            return
+        }
+
+        callManager?.answerCall(callId)
+        call.resolve()
+    }
+
+    @PermissionCallback
+    private fun answerCallPermissions(call: PluginCall) {
+        answerCallInternal(call, canRequestPermissions = false)
+    }
+
+    @PluginMethod
+    fun rejectCall(call: PluginCall) {
+        val callId = call.getString("callId") ?: run {
+            call.reject("Missing callId parameter")
+            return
+        }
+
+        callManager?.rejectCall(callId)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun setCallOnHold(call: PluginCall) {
+        val callId = call.getString("callId") ?: run {
+            call.reject("Missing callId parameter")
+            return
+        }
+        val onHold = call.getBoolean("onHold", false) ?: false
+
+        callManager?.setCallOnHold(callId, onHold)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun setAudioRoute(call: PluginCall) {
+        val route = call.getString("route") ?: run {
+            call.reject("Missing route parameter")
+            return
+        }
+
+        callManager?.setAudioRoute(route)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun setMuted(call: PluginCall) {
+        val muted = call.getBoolean("muted", false) ?: false
+
+        callManager?.setMuted(muted)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun handleIncomingCall(call: PluginCall) {
+        val callId = call.getString("callId") ?: UUID.randomUUID().toString()
+        val handle = call.getString("handle") ?: run {
+            call.reject("Missing handle parameter")
+            return
+        }
+        val displayName = call.getString("displayName") ?: run {
+            call.reject("Missing displayName parameter")
+            return
+        }
+
+        val handleType = call.getString("handleType") ?: "generic"
+        val video = call.getBoolean("video", false) ?: false
+        val metadata = call.getObject("metadata")
+
+        callManager?.reportIncomingCall(
+            callId = callId,
+            handle = handle,
+            displayName = displayName,
+            handleType = handleType,
+            video = video,
+            metadata = metadata
+        )
+
+        call.resolve(JSObject().apply {
+            put("callId", callId)
+        })
+    }
+
+    @PluginMethod
+    fun updateCallStatus(call: PluginCall) {
+        val callId = call.getString("callId") ?: run {
+            call.reject("Missing callId parameter")
+            return
+        }
+        val status = call.getString("status") ?: run {
+            call.reject("Missing status parameter")
+            return
+        }
+
+        callManager?.updateCallStatus(callId, status)
+        call.resolve()
+    }
+
+    @PluginMethod
+    fun isSupported(call: PluginCall) {
+        call.resolve(JSObject().apply {
+            put("supported", Build.VERSION.SDK_INT >= Build.VERSION_CODES.M)
+        })
+    }
+
+    override fun handleOnNewIntent(intent: Intent?) {
+        super.handleOnNewIntent(intent)
+        val extras = intent?.extras ?: return
+
+        if (!extras.containsKey("google.message_id") && !extras.containsKey("type")) {
+            return
+        }
+
+        val data = JSObject()
+        for (key in extras.keySet()) {
+            data.put(key, extras.get(key))
+        }
+
+        val actionPayload = JSObject().apply {
+            put("actionId", "tap")
+            put("notification", JSObject().apply {
+                put("id", extras.getString("google.message_id") ?: UUID.randomUUID().toString())
+                put("title", extras.getString("title"))
+                put("body", extras.getString("body"))
+                put("data", data)
+            })
+        }
+        emitEvent("pushNotificationActionPerformed", actionPayload)
+    }
+
+    private fun hasRequiredPermissions(): Boolean {
+        return ContextCompat.checkSelfPermission(
+            context,
+            Manifest.permission.RECORD_AUDIO
+        ) == PackageManager.PERMISSION_GRANTED
+    }
+
+    internal fun emitEvent(event: String, data: JSObject) {
+        super.notifyListeners(event, data)
+    }
+
+    private fun flushPendingEvents() {
+        synchronized(pendingEvents) {
+            pendingEvents.forEach { (event, payload) ->
+                emitEvent(event, payload)
+            }
+            pendingEvents.clear()
+        }
+    }
+}

package/android/src/main/java/com/capacitor/voipcalls/PushRouterMessagingService.kt

@@ -0,0 +1,26 @@
+package com.capacitor.voipcalls
+
+import com.getcapacitor.JSObject
+import com.google.firebase.messaging.FirebaseMessagingService
+import com.google.firebase.messaging.RemoteMessage
+
+class PushRouterMessagingService : FirebaseMessagingService() {
+    override fun onNewToken(token: String) {
+        super.onNewToken(token)
+        CapacitorVoipCallsPlugin.emitFromService(
+            "registration",
+            JSObject().apply { put("value", token) }
+        )
+    }
+
+    override fun onMessageReceived(message: RemoteMessage) {
+        super.onMessageReceived(message)
+
+        CapacitorVoipCallsPlugin.routeRemoteMessage(
+            context = applicationContext,
+            data = message.data,
+            title = message.notification?.title,
+            body = message.notification?.body
+        )
+    }
+}