@kapsula-chat/capacitor-push-calls 1.0.0

package/ios/Plugin/CapacitorVoipCallsPlugin.swift

@@ -0,0 +1,517 @@
+import AVFoundation
+import CallKit
+import Capacitor
+import Foundation
+import PushKit
+import UIKit
+import UserNotifications
+
+@objc(CapacitorVoipCallsPlugin)
+public class CapacitorVoipCallsPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "CapacitorVoipCallsPlugin"
+    public let jsName = "CapacitorPushCalls"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "register", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "unregister", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "checkPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "requestPermissions", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getDeliveredNotifications", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeDeliveredNotifications", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "removeAllDeliveredNotifications", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getBadgeCount", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getBadgeNumber", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setBadgeCount", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setBadgeNumber", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "clearBadgeCount", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "createChannel", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "deleteChannel", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "listChannels", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "registerVoipNotifications", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "startCall", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "endCall", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "answerCall", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "rejectCall", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setCallOnHold", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setAudioRoute", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setMuted", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "handleIncomingCall", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "updateCallStatus", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "isSupported", returnType: CAPPluginReturnPromise),
+    ]
+
+    private var callManager: CallManager?
+    private var voipRegistry: PKPushRegistry?
+
+    override public func load() {
+        callManager = CallManager(plugin: self)
+
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(didRegisterForRemoteNotifications(_:)),
+            name: .capacitorDidRegisterForRemoteNotifications,
+            object: nil
+        )
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(didFailToRegisterForRemoteNotifications(_:)),
+            name: .capacitorDidFailToRegisterForRemoteNotifications,
+            object: nil
+        )
+        bridge?.notificationRouter.pushNotificationHandler = self
+    }
+
+    deinit {
+        NotificationCenter.default.removeObserver(self)
+    }
+
+    @objc func register(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            UIApplication.shared.registerForRemoteNotifications()
+            call.resolve()
+        }
+    }
+
+    @objc func unregister(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            UIApplication.shared.unregisterForRemoteNotifications()
+            call.resolve()
+        }
+    }
+
+    @objc override public func checkPermissions(_ call: CAPPluginCall) {
+        UNUserNotificationCenter.current().getNotificationSettings { settings in
+            let permission = self.permissionValue(from: settings.authorizationStatus)
+            call.resolve(["receive": permission])
+        }
+    }
+
+    @objc override public func requestPermissions(_ call: CAPPluginCall) {
+        UNUserNotificationCenter.current().requestAuthorization(options: [.alert, .badge, .sound]) { _, error in
+            if let error {
+                call.reject("Failed to request push notification permissions", nil, error)
+                return
+            }
+
+            self.checkPermissions(call)
+        }
+    }
+
+    @objc func getDeliveredNotifications(_ call: CAPPluginCall) {
+        UNUserNotificationCenter.current().getDeliveredNotifications { notifications in
+            let payload = notifications.map { self.serialize(notification: $0) }
+            call.resolve(["notifications": payload])
+        }
+    }
+
+    @objc func removeDeliveredNotifications(_ call: CAPPluginCall) {
+        guard let raw = call.options["notifications"] as? [Any] else {
+            call.reject("Missing notifications parameter")
+            return
+        }
+
+        let identifiers: [String] = raw.compactMap {
+            if let identifier = $0 as? String {
+                return identifier
+            }
+
+            if let dict = $0 as? [String: Any] {
+                return dict["id"] as? String
+            }
+
+            return nil
+        }
+
+        UNUserNotificationCenter.current().removeDeliveredNotifications(withIdentifiers: identifiers)
+        call.resolve()
+    }
+
+    @objc func removeAllDeliveredNotifications(_ call: CAPPluginCall) {
+        UNUserNotificationCenter.current().removeAllDeliveredNotifications()
+        call.resolve()
+    }
+
+    @objc func getBadgeCount(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            call.resolve(["count": UIApplication.shared.applicationIconBadgeNumber])
+        }
+    }
+
+    @objc func getBadgeNumber(_ call: CAPPluginCall) {
+        getBadgeCount(call)
+    }
+
+    @objc func setBadgeCount(_ call: CAPPluginCall) {
+        guard let count = call.getInt("count"), count >= 0 else {
+            call.reject("Invalid count parameter")
+            return
+        }
+
+        DispatchQueue.main.async {
+            UIApplication.shared.applicationIconBadgeNumber = count
+            call.resolve()
+        }
+    }
+
+    @objc func setBadgeNumber(_ call: CAPPluginCall) {
+        setBadgeCount(call)
+    }
+
+    @objc func clearBadgeCount(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            UIApplication.shared.applicationIconBadgeNumber = 0
+            call.resolve()
+        }
+    }
+
+    @objc func createChannel(_ call: CAPPluginCall) {
+        // iOS does not support Android notification channels.
+        call.resolve()
+    }
+
+    @objc func deleteChannel(_ call: CAPPluginCall) {
+        // iOS does not support Android notification channels.
+        call.resolve()
+    }
+
+    @objc func listChannels(_ call: CAPPluginCall) {
+        // iOS does not support Android notification channels.
+        call.resolve(["channels": []])
+    }
+
+    @objc func registerVoipNotifications(_ call: CAPPluginCall) {
+        DispatchQueue.main.async {
+            self.voipRegistry = PKPushRegistry(queue: DispatchQueue.main)
+            self.voipRegistry?.delegate = self
+            self.voipRegistry?.desiredPushTypes = [.voIP]
+
+            call.resolve()
+        }
+    }
+
+    @objc func startCall(_ call: CAPPluginCall) {
+        guard let handle = call.getString("handle"),
+              let displayName = call.getString("displayName") else {
+            call.reject("Missing required parameters: handle and displayName")
+            return
+        }
+
+        let handleType = call.getString("handleType") ?? "generic"
+        let video = call.getBool("video") ?? false
+
+        let callId = UUID()
+        let handleTypeEnum: CXHandle.HandleType = {
+            switch handleType {
+            case "phone": return .phoneNumber
+            case "email": return .emailAddress
+            default: return .generic
+            }
+        }()
+
+        callManager?.startCall(
+            uuid: callId,
+            handle: handle,
+            displayName: displayName,
+            handleType: handleTypeEnum,
+            video: video
+        )
+
+        call.resolve(["callId": callId.uuidString])
+    }
+
+    @objc func endCall(_ call: CAPPluginCall) {
+        guard let callIdString = call.getString("callId"),
+              let callId = UUID(uuidString: callIdString) else {
+            call.reject("Invalid callId")
+            return
+        }
+
+        callManager?.endCall(uuid: callId)
+        call.resolve()
+    }
+
+    @objc func answerCall(_ call: CAPPluginCall) {
+        guard let callIdString = call.getString("callId"),
+              let callId = UUID(uuidString: callIdString) else {
+            call.reject("Invalid callId")
+            return
+        }
+
+        callManager?.answerCall(uuid: callId)
+        call.resolve()
+    }
+
+    @objc func rejectCall(_ call: CAPPluginCall) {
+        guard let callIdString = call.getString("callId"),
+              let callId = UUID(uuidString: callIdString) else {
+            call.reject("Invalid callId")
+            return
+        }
+
+        callManager?.rejectCall(uuid: callId)
+        call.resolve()
+    }
+
+    @objc func setCallOnHold(_ call: CAPPluginCall) {
+        guard let callIdString = call.getString("callId"),
+              let callId = UUID(uuidString: callIdString),
+              let onHold = call.getBool("onHold") else {
+            call.reject("Invalid parameters")
+            return
+        }
+
+        callManager?.setCallOnHold(uuid: callId, onHold: onHold)
+        call.resolve()
+    }
+
+    @objc func setAudioRoute(_ call: CAPPluginCall) {
+        guard let route = call.getString("route") else {
+            call.reject("Missing route parameter")
+            return
+        }
+
+        let audioSession = AVAudioSession.sharedInstance()
+
+        do {
+            switch route {
+            case "speaker":
+                try audioSession.overrideOutputAudioPort(.speaker)
+            case "earpiece":
+                try audioSession.overrideOutputAudioPort(.none)
+            case "bluetooth":
+                try audioSession.setCategory(.playAndRecord, mode: .voiceChat, options: [.allowBluetooth])
+            default:
+                call.reject("Invalid route: \(route)")
+                return
+            }
+            call.resolve()
+        } catch {
+            call.reject("Failed to set audio route: \(error.localizedDescription)")
+        }
+    }
+
+    @objc func setMuted(_ call: CAPPluginCall) {
+        guard call.getBool("muted") != nil else {
+            call.reject("Missing muted parameter")
+            return
+        }
+
+        // Mute should be handled in your media layer.
+        call.resolve()
+    }
+
+    @objc func handleIncomingCall(_ call: CAPPluginCall) {
+        guard let handle = call.getString("handle"),
+              let displayName = call.getString("displayName") else {
+            call.reject("Missing required parameters: handle and displayName")
+            return
+        }
+
+        let requestedCallId = call.getString("callId")
+        let callId = UUID(uuidString: requestedCallId ?? "") ?? UUID()
+        let callIdString = callId.uuidString
+
+        let handleTypeString = call.getString("handleType") ?? "generic"
+        let video = call.getBool("video") ?? false
+        let metadata = call.getObject("metadata")
+
+        let handleType: CXHandle.HandleType = {
+            switch handleTypeString {
+            case "phone": return .phoneNumber
+            case "email": return .emailAddress
+            default: return .generic
+            }
+        }()
+
+        callManager?.reportIncomingCall(
+            uuid: callId,
+            handle: handle,
+            displayName: displayName,
+            handleType: handleType,
+            video: video
+        ) { error in
+            if let error {
+                call.reject("Failed to report incoming call: \(error.localizedDescription)")
+                return
+            }
+
+            var notificationData: [String: Any] = [
+                "callId": callIdString,
+                "handle": handle,
+                "displayName": displayName,
+                "handleType": handleTypeString,
+                "video": video,
+            ]
+            if let metadata {
+                notificationData["metadata"] = metadata
+            }
+            self.emitEvent("incomingCall", data: notificationData)
+            call.resolve(["callId": callIdString])
+        }
+    }
+
+    @objc func updateCallStatus(_ call: CAPPluginCall) {
+        guard let callIdString = call.getString("callId"),
+              let callId = UUID(uuidString: callIdString),
+              let status = call.getString("status") else {
+            call.reject("Invalid parameters")
+            return
+        }
+
+        callManager?.updateCallStatus(uuid: callId, status: status)
+        call.resolve()
+    }
+
+    @objc func isSupported(_ call: CAPPluginCall) {
+        call.resolve(["supported": true])
+    }
+
+    @objc private func didRegisterForRemoteNotifications(_ notification: Notification) {
+        guard let token = notification.object as? Data else {
+            emitEvent("registrationError", data: ["error": "Missing APNS token data"])
+            return
+        }
+
+        let tokenString = token.map { String(format: "%02x", $0) }.joined()
+        emitEvent("registration", data: ["value": tokenString])
+    }
+
+    @objc private func didFailToRegisterForRemoteNotifications(_ notification: Notification) {
+        let error = (notification.object as? Error)?.localizedDescription ?? "Unknown registration error"
+        emitEvent("registrationError", data: ["error": error])
+    }
+
+    private func permissionValue(from status: UNAuthorizationStatus) -> String {
+        switch status {
+        case .authorized, .provisional, .ephemeral:
+            return "granted"
+        case .denied:
+            return "denied"
+        case .notDetermined:
+            return "prompt"
+        @unknown default:
+            return "prompt"
+        }
+    }
+
+    private func serialize(notification: UNNotification) -> [String: Any] {
+        let content = notification.request.content
+        let userInfo = content.userInfo.reduce(into: [String: Any]()) { result, entry in
+            result[String(describing: entry.key)] = entry.value
+        }
+
+        var payload: [String: Any] = [
+            "id": notification.request.identifier,
+            "title": content.title,
+            "subtitle": content.subtitle,
+            "body": content.body,
+            "data": userInfo,
+        ]
+
+        if let badge = content.badge as? Int {
+            payload["badge"] = badge
+        }
+
+        return payload
+    }
+
+    internal func emitEvent(_ event: String, data: [String: Any]) {
+        super.notifyListeners(event, data: data)
+    }
+
+    // Backward-compatible helper used by CallManager.
+    internal func notifyListeners(event: String, data: [String: Any]) {
+        emitEvent(event, data: data)
+    }
+}
+
+// MARK: - PKPushRegistryDelegate
+extension CapacitorVoipCallsPlugin: PKPushRegistryDelegate {
+    public func pushRegistry(_ registry: PKPushRegistry, didUpdate pushCredentials: PKPushCredentials, for type: PKPushType) {
+        let token = pushCredentials.token.map { String(format: "%02x", $0) }.joined()
+        emitEvent("voipPushToken", data: ["token": token])
+    }
+
+    public func pushRegistry(_ registry: PKPushRegistry, didReceiveIncomingPushWith payload: PKPushPayload, for type: PKPushType, completion: @escaping () -> Void) {
+        guard type == .voIP else {
+            completion()
+            return
+        }
+
+        let payloadDict = payload.dictionaryPayload
+
+        guard let callIdString = payloadDict["callId"] as? String,
+              let callId = UUID(uuidString: callIdString),
+              let handle = payloadDict["handle"] as? String,
+              let displayName = payloadDict["displayName"] as? String else {
+            completion()
+            return
+        }
+
+        let handleTypeString = payloadDict["handleType"] as? String ?? "generic"
+        let video = payloadDict["video"] as? Bool ?? false
+
+        let handleType: CXHandle.HandleType = {
+            switch handleTypeString {
+            case "phone": return .phoneNumber
+            case "email": return .emailAddress
+            default: return .generic
+            }
+        }()
+
+        callManager?.reportIncomingCall(
+            uuid: callId,
+            handle: handle,
+            displayName: displayName,
+            handleType: handleType,
+            video: video
+        ) { error in
+            if let error {
+                print("Error reporting incoming call: \(error.localizedDescription)")
+            }
+            completion()
+        }
+
+        var notificationData: [String: Any] = [
+            "callId": callIdString,
+            "handle": handle,
+            "displayName": displayName,
+            "handleType": handleTypeString,
+            "video": video,
+        ]
+
+        if let metadata = payloadDict["metadata"] as? [String: Any] {
+            notificationData["metadata"] = metadata
+        }
+
+        emitEvent("incomingCall", data: notificationData)
+    }
+
+    public func pushRegistry(_ registry: PKPushRegistry, didInvalidatePushTokenFor type: PKPushType) {
+        print("Push token invalidated for type: \(type)")
+    }
+}
+
+extension CapacitorVoipCallsPlugin: NotificationHandlerProtocol {
+    public func willPresent(notification: UNNotification) -> UNNotificationPresentationOptions {
+        emitEvent("pushNotificationReceived", data: serialize(notification: notification))
+
+        if #available(iOS 14.0, *) {
+            return [.banner, .list, .badge, .sound]
+        } else {
+            return [.alert, .badge, .sound]
+        }
+    }
+
+    public func didReceive(response: UNNotificationResponse) {
+        var payload: [String: Any] = [
+            "actionId": response.actionIdentifier,
+            "notification": serialize(notification: response.notification),
+        ]
+
+        if let textResponse = response as? UNTextInputNotificationResponse {
+            payload["inputValue"] = textResponse.userText
+        }
+
+        emitEvent("pushNotificationActionPerformed", data: payload)
+    }
+}

package/ios/Plugin/Plugin.m

@@ -0,0 +1,31 @@
+#import <Foundation/Foundation.h>
+#import <Capacitor/Capacitor.h>
+
+CAP_PLUGIN(CapacitorVoipCallsPlugin, "CapacitorPushCalls",
+    CAP_PLUGIN_METHOD(register, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(unregister, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(checkPermissions, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(requestPermissions, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(getDeliveredNotifications, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(removeDeliveredNotifications, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(removeAllDeliveredNotifications, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(getBadgeCount, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(getBadgeNumber, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(setBadgeCount, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(setBadgeNumber, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(clearBadgeCount, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(createChannel, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(deleteChannel, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(listChannels, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(registerVoipNotifications, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(startCall, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(endCall, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(answerCall, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(rejectCall, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(setCallOnHold, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(setAudioRoute, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(setMuted, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(handleIncomingCall, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(updateCallStatus, CAPPluginReturnPromise);
+    CAP_PLUGIN_METHOD(isSupported, CAPPluginReturnPromise);
+)

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@kapsula-chat/capacitor-push-calls",
+  "version": "1.0.0",
+  "description": "Capacitor plugin with push routing (message/call), CallKit (iOS), and ConnectionService (Android)",
+  "main": "dist/plugin.cjs.js",
+  "module": "dist/esm/index.js",
+  "types": "dist/esm/index.d.ts",
+  "unpkg": "dist/plugin.js",
+  "files": [
+    "android/src/main/",
+    "android/build.gradle",
+    "dist/",
+    "ios/",
+    "Package.swift"
+  ],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": ""
+  },
+  "bugs": {
+    "url": ""
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "native",
+    "voip",
+    "calls",
+    "callkit",
+    "pushkit",
+    "connectionservice",
+    "ios",
+    "android",
+    "sip",
+    "webrtc",
+    "phone",
+    "telephony",
+    "spm"
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme CapacitorPushCalls -destination generic/platform=iOS",
+    "verify:android": "cd android && ./gradlew clean build test && cd ..",
+    "verify:web": "npm run build",
+    "lint": "npm run eslint && npm run prettier -- --check && npm run swiftlint -- lint",
+    "fmt": "npm run eslint -- --fix && npm run prettier -- --write && npm run swiftlint -- --fix --format",
+    "eslint": "eslint . --ext ts",
+    "prettier": "prettier \"**/*.{css,html,ts,js,java}\"",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api CapacitorPushCallsPlugin --output-readme README.md --output-json dist/docs.json || true",
+    "build": "npm run clean && tsc && rollup -c rollup.config.js",
+    "build:docs": "npm run build && npm run docgen",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build",
+    "test:setup": "./scripts/test-plugin.sh",
+    "test:update": "./scripts/update-test.sh"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^8.0.0",
+    "@capacitor/core": "^8.0.0",
+    "@capacitor/docgen": "^0.2.0",
+    "@capacitor/ios": "^8.0.0",
+    "@ionic/eslint-config": "^0.3.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^1.1.2",
+    "eslint": "^8.0.0",
+    "prettier": "^3.0.0",
+    "prettier-plugin-java": "^2.0.0",
+    "rimraf": "^5.0.0",
+    "rollup": "^3.0.0",
+    "swiftlint": "^1.0.1",
+    "typescript": "~5.0.0"
+  },
+  "peerDependencies": {
+    "@capacitor/core": "^8.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  }
+}