@tagea/capacitor-matrix 1.1.1 → 1.2.0

package/ios/Sources/CapMatrixPlugin/CapMatrix.swift

@@ -28,6 +28,7 @@ class MatrixSDKBridge {
     // Keep strong references so GC doesn't cancel subscriptions
     private var timelineListenerHandles: [Any] = []
     private var syncStateHandle: TaskHandle?
+    private var platformInitialized = false
     private var syncStateObserver: SyncStateObserverProxy?
     private let subscriptionLock = NSLock()
     private var receiptSyncTask: Task<Void, Never>?
@@ -174,6 +175,59 @@ class MatrixSDKBridge {
         return sessionStore.load()?.toDictionary()
     }
 
+    func updateAccessToken(accessToken: String) async throws {
+        guard client != nil else {
+            throw MatrixBridgeError.notLoggedIn
+        }
+
+        // Stop sync service and clean up references
+        await syncService?.stop()
+        syncService = nil
+        syncStateHandle = nil
+        receiptSyncTask?.cancel()
+        receiptSyncTask = nil
+        timelineListenerHandles.removeAll()
+        roomTimelines.removeAll()
+        subscribedRoomIds.removeAll()
+
+        guard let oldSession = sessionStore.load() else {
+            throw MatrixBridgeError.custom("No persisted session to update")
+        }
+
+        // Build a new client pointing to the same data directory (preserves crypto store).
+        // The Rust SDK's restoreSession() can only be called once per Client instance.
+        let dataDir = Self.dataDirectory()
+        let cacheDir = Self.cacheDirectory()
+
+        let newClient = try await ClientBuilder()
+            .homeserverUrl(url: oldSession.homeserverUrl)
+            .sessionPaths(dataPath: dataDir, cachePath: cacheDir)
+            .slidingSyncVersionBuilder(versionBuilder: .native)
+            .autoEnableCrossSigning(autoEnableCrossSigning: true)
+            .build()
+
+        let newSession = Session(
+            accessToken: accessToken,
+            refreshToken: nil,
+            userId: oldSession.userId,
+            deviceId: oldSession.deviceId,
+            homeserverUrl: oldSession.homeserverUrl,
+            oidcData: nil,
+            slidingSyncVersion: .native
+        )
+
+        try await newClient.restoreSession(session: newSession)
+        client = newClient
+
+        let updatedInfo = MatrixSessionInfo(
+            accessToken: accessToken,
+            userId: oldSession.userId,
+            deviceId: oldSession.deviceId,
+            homeserverUrl: oldSession.homeserverUrl
+        )
+        sessionStore.save(session: updatedInfo)
+    }
+
     // MARK: - Sync
 
     func startSync(
@@ -186,16 +240,19 @@ class MatrixSDKBridge {
             throw MatrixBridgeError.notLoggedIn
         }
 
-        // Enable Rust SDK tracing to diagnose sync errors
-        let tracingConfig = TracingConfiguration(
-            logLevel: .warn,
-            traceLogPacks: [],
-            extraTargets: ["matrix_sdk", "matrix_sdk_ui"],
-            writeToStdoutOrSystem: true,
-            writeToFiles: nil,
-            sentryDsn: nil
-        )
-        try? initPlatform(config: tracingConfig, useLightweightTokioRuntime: false)
+        // Enable Rust SDK tracing (once — calling initPlatform twice panics)
+        if !platformInitialized {
+            let tracingConfig = TracingConfiguration(
+                logLevel: .warn,
+                traceLogPacks: [],
+                extraTargets: ["matrix_sdk", "matrix_sdk_ui"],
+                writeToStdoutOrSystem: true,
+                writeToFiles: nil,
+                sentryDsn: nil
+            )
+            try? initPlatform(config: tracingConfig, useLightweightTokioRuntime: false)
+            platformInitialized = true
+        }
 
         print("[CapMatrix] startSync: building sync service...")
         let service = try await c.syncService().finish()
@@ -485,6 +542,23 @@ class MatrixSDKBridge {
                 print("[CapMatrix]   room \(roomId): FAILED: \(error)")
             }
         }
+
+        // Preload messages for all rooms in the background so paginateBackwards
+        // has already run by the time the user opens a room.
+        Task {
+            let t0 = CFAbsoluteTimeGetCurrent()
+            await withTaskGroup(of: Void.self) { group in
+                for (_, roomId) in roomsToSubscribe {
+                    group.addTask { [weak self] in
+                        guard let self = self, let timeline = self.roomTimelines[roomId] else { return }
+                        let tRoom = CFAbsoluteTimeGetCurrent()
+                        _ = try? await timeline.paginateBackwards(numEvents: 30)
+                        print("[CapMatrix] [PERF] preload \(roomId.prefix(12))… paginateBackwards=\(self.ms(tRoom, CFAbsoluteTimeGetCurrent()))ms")
+                    }
+                }
+            }
+            print("[CapMatrix] [PERF] preload ALL rooms done in \(ms(t0, CFAbsoluteTimeGetCurrent()))ms")
+        }
     }
 
     func stopSync() async throws {
@@ -624,8 +698,12 @@ class MatrixSDKBridge {
     }
 
     func getRoomMessages(roomId: String, limit: Int, from: String?) async throws -> [String: Any] {
+        let t0 = CFAbsoluteTimeGetCurrent()
         let room = try requireRoom(roomId: roomId)
+        let t1 = CFAbsoluteTimeGetCurrent()
         let timeline = try await getOrCreateTimeline(room: room)
+        let t2 = CFAbsoluteTimeGetCurrent()
+        print("[CapMatrix] [PERF] getRoomMessages(\(roomId.prefix(12))…) requireRoom=\(ms(t0,t1))ms getOrCreateTimeline=\(ms(t1,t2))ms")
 
         // Suppress live listener while we paginate to avoid flooding JS with historical events
         paginatingLock.lock()
@@ -633,15 +711,20 @@ class MatrixSDKBridge {
         paginatingLock.unlock()
 
         let collector = TimelineItemCollector(roomId: roomId)
+        let t3 = CFAbsoluteTimeGetCurrent()
         let handle = await timeline.addListener(listener: collector)
+        let t4 = CFAbsoluteTimeGetCurrent()
+        print("[CapMatrix] [PERF] addListener=\(ms(t3,t4))ms")
 
         var hitStart = false
         do {
             // Wait for the initial Reset snapshot before paginating
+            let tWait1 = CFAbsoluteTimeGetCurrent()
             let gotInitial = await collector.waitForUpdate(timeoutNanos: 5_000_000_000)
+            let tWait1Done = CFAbsoluteTimeGetCurrent()
             let countBefore = collector.events.count
             let isPagination = from != nil
-            print("[CapMatrix] getRoomMessages: initial snapshot: \(countBefore) items, gotInitial=\(gotInitial), from=\(from ?? "nil")")
+            print("[CapMatrix] [PERF] waitForInitial=\(ms(tWait1,tWait1Done))ms gotInitial=\(gotInitial) items=\(countBefore) from=\(from ?? "nil")")
 
             // Reset cursor on initial load
             if !isPagination {
@@ -650,14 +733,18 @@ class MatrixSDKBridge {
 
             // Paginate when: first load with too few items, OR explicit pagination request
             if isPagination || countBefore < limit {
+                let tPag = CFAbsoluteTimeGetCurrent()
                 hitStart = try await timeline.paginateBackwards(numEvents: UInt16(limit))
-                print("[CapMatrix] getRoomMessages: paginated, hitStart=\(hitStart)")
+                let tPagDone = CFAbsoluteTimeGetCurrent()
+                print("[CapMatrix] [PERF] paginateBackwards=\(ms(tPag,tPagDone))ms hitStart=\(hitStart)")
 
                 // If there were new events, wait for the diffs to arrive via the listener
                 if !hitStart {
+                    let tWait2 = CFAbsoluteTimeGetCurrent()
                     _ = await collector.waitForUpdate(timeoutNanos: 5_000_000_000)
+                    let tWait2Done = CFAbsoluteTimeGetCurrent()
+                    print("[CapMatrix] [PERF] waitForPagination=\(ms(tWait2,tWait2Done))ms items=\(collector.events.count)")
                 }
-                print("[CapMatrix] getRoomMessages: after pagination: \(collector.events.count) items (was \(countBefore))")
             }
         } catch {
             handle.cancel()
@@ -672,38 +759,30 @@ class MatrixSDKBridge {
         paginatingRooms.remove(roomId)
         paginatingLock.unlock()
 
+        let tSlice = CFAbsoluteTimeGetCurrent()
         let allEvents = collector.events
         var events: [[String: Any]]
 
         if let cursorId = oldestReturnedEventId[roomId], from != nil {
-            // Pagination: find the cursor event and return events before it
             if let cursorIdx = allEvents.firstIndex(where: { ($0["eventId"] as? String) == cursorId }) {
                 let available = Array(allEvents.prefix(cursorIdx))
                 events = Array(available.suffix(limit))
             } else {
-                // Cursor not found (shouldn't happen) — fall back to empty
                 print("[CapMatrix] getRoomMessages: cursor eventId \(cursorId) not found in timeline")
                 events = []
             }
         } else {
-            // Initial load: return newest events
             events = Array(allEvents.suffix(limit))
         }
 
-        // Update cursor to the oldest event we're returning
         if let oldest = events.first, let eid = oldest["eventId"] as? String {
             oldestReturnedEventId[roomId] = eid
         }
 
-        // Apply receipt watermark: if any own event has readBy data,
-        // all earlier own events in the timeline are also read.
-        // The SDK only attaches receipts to the specific event they target,
-        // but in Matrix a read receipt implies all prior events are read too.
-        // Only events BEFORE the watermark are marked — events after it are unread.
+        // Apply receipt watermark
         let myUserId = client.flatMap({ try? $0.userId() })
         var watermarkReadBy: [String]? = nil
         var watermarkIndex = -1
-        // Walk backwards (newest first) to find the newest own event with a receipt
         for i in stride(from: events.count - 1, through: 0, by: -1) {
             let evt = events[i]
             let sender = evt["senderId"] as? String
@@ -715,7 +794,6 @@ class MatrixSDKBridge {
                 }
             }
         }
-        // Apply watermark only to own events BEFORE the watermark (older)
         if let watermark = watermarkReadBy, watermarkIndex >= 0 {
             for i in 0..<watermarkIndex {
                 let sender = events[i]["senderId"] as? String
@@ -728,19 +806,22 @@ class MatrixSDKBridge {
                 }
             }
         }
+        let tSliceDone = CFAbsoluteTimeGetCurrent()
 
-        // Return a pagination token so the JS layer knows more messages are available.
-        // The Rust SDK timeline handles pagination state internally, so we use a
-        // synthetic token ("more") to signal that further back-pagination is possible.
-        // Also stop if pagination returned no new events (timeline fully loaded).
         let nextBatch: String? = (hitStart || events.isEmpty) ? nil : "more"
 
+        print("[CapMatrix] [PERF] getRoomMessages TOTAL=\(ms(t0,tSliceDone))ms slicing+watermark=\(ms(tSlice,tSliceDone))ms returning \(events.count) events")
+
         return [
             "events": events,
             "nextBatch": nextBatch as Any
         ]
     }
 
+    private func ms(_ start: CFAbsoluteTime, _ end: CFAbsoluteTime) -> Int {
+        return Int((end - start) * 1000)
+    }
+
     func markRoomAsRead(roomId: String, eventId: String) async throws {
         let room = try requireRoom(roomId: roomId)
         let timeline = try await getOrCreateTimeline(room: room)
@@ -1256,6 +1337,123 @@ class MatrixSDKBridge {
         throw MatrixBridgeError.notSupported("importRoomKeys")
     }
 
+    // MARK: - Presence
+
+    func setPresence(presence: String, statusMsg: String?) async throws {
+        guard let session = sessionStore.load() else {
+            throw MatrixBridgeError.notLoggedIn
+        }
+        let baseUrl = session.homeserverUrl.hasSuffix("/")
+            ? String(session.homeserverUrl.dropLast())
+            : session.homeserverUrl
+        let encodedUserId = session.userId.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? session.userId
+        let urlString = "\(baseUrl)/_matrix/client/v3/presence/\(encodedUserId)/status"
+        guard let url = URL(string: urlString) else {
+            throw MatrixBridgeError.notSupported("Invalid presence URL")
+        }
+
+        var body: [String: Any] = ["presence": presence]
+        if let msg = statusMsg { body["status_msg"] = msg }
+        let bodyData = try JSONSerialization.data(withJSONObject: body)
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "PUT"
+        request.setValue("Bearer \(session.accessToken)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = bodyData
+
+        let (_, response) = try await URLSession.shared.data(for: request)
+        let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
+        guard statusCode >= 200 && statusCode < 300 else {
+            throw MatrixBridgeError.notSupported("setPresence failed with status \(statusCode)")
+        }
+    }
+
+    func getPresence(userId: String) async throws -> [String: Any] {
+        guard let session = sessionStore.load() else {
+            throw MatrixBridgeError.notLoggedIn
+        }
+        let baseUrl = session.homeserverUrl.hasSuffix("/")
+            ? String(session.homeserverUrl.dropLast())
+            : session.homeserverUrl
+        let encodedUserId = userId.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed) ?? userId
+        let urlString = "\(baseUrl)/_matrix/client/v3/presence/\(encodedUserId)/status"
+        guard let url = URL(string: urlString) else {
+            throw MatrixBridgeError.notSupported("Invalid presence URL")
+        }
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "GET"
+        request.setValue("Bearer \(session.accessToken)", forHTTPHeaderField: "Authorization")
+
+        let (data, response) = try await URLSession.shared.data(for: request)
+        let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
+        guard statusCode >= 200 && statusCode < 300 else {
+            throw MatrixBridgeError.notSupported("getPresence failed with status \(statusCode)")
+        }
+
+        guard let json = try JSONSerialization.jsonObject(with: data) as? [String: Any] else {
+            throw MatrixBridgeError.notSupported("Invalid presence response")
+        }
+
+        var result: [String: Any] = ["presence": json["presence"] as? String ?? "offline"]
+        if let msg = json["status_msg"] as? String { result["statusMsg"] = msg }
+        if let ago = json["last_active_ago"] as? Int { result["lastActiveAgo"] = ago }
+        return result
+    }
+
+    // MARK: - Pushers
+
+    func setPusher(
+        pushkey: String,
+        kind: String?,
+        appId: String,
+        appDisplayName: String,
+        deviceDisplayName: String,
+        lang: String,
+        dataUrl: String,
+        dataFormat: String?
+    ) async throws {
+        guard let session = sessionStore.load() else {
+            throw MatrixBridgeError.notLoggedIn
+        }
+        let baseUrl = session.homeserverUrl.hasSuffix("/")
+            ? String(session.homeserverUrl.dropLast())
+            : session.homeserverUrl
+        let urlString = "\(baseUrl)/_matrix/client/v3/pushers/set"
+        guard let url = URL(string: urlString) else {
+            throw MatrixBridgeError.notSupported("Invalid pushers URL")
+        }
+
+        var dataObj: [String: Any] = ["url": dataUrl]
+        if let format = dataFormat { dataObj["format"] = format }
+
+        var body: [String: Any] = [
+            "pushkey": pushkey,
+            "kind": kind as Any,
+            "app_id": appId,
+            "app_display_name": appDisplayName,
+            "device_display_name": deviceDisplayName,
+            "lang": lang,
+            "data": dataObj,
+        ]
+        if kind == nil { body["kind"] = NSNull() }
+
+        let bodyData = try JSONSerialization.data(withJSONObject: body)
+
+        var request = URLRequest(url: url)
+        request.httpMethod = "POST"
+        request.setValue("Bearer \(session.accessToken)", forHTTPHeaderField: "Authorization")
+        request.setValue("application/json", forHTTPHeaderField: "Content-Type")
+        request.httpBody = bodyData
+
+        let (_, response) = try await URLSession.shared.data(for: request)
+        let statusCode = (response as? HTTPURLResponse)?.statusCode ?? -1
+        guard statusCode >= 200 && statusCode < 300 else {
+            throw MatrixBridgeError.notSupported("setPusher failed with status \(statusCode)")
+        }
+    }
+
     // MARK: - Helpers
 
     private static func dataDirectory() -> String {
@@ -1291,18 +1489,25 @@ class MatrixSDKBridge {
         let isDirect = info.isDirect
         let avatarUrl: String? = nil // Rust SDK doesn't expose avatar URL via RoomInfo yet
 
-        return [
+        let latestEvent = await room.latestEvent()
+        let latestEventDict = serializeLatestEventValue(latestEvent, roomId: room.id())
+
+        var dict: [String: Any] = [
             "roomId": room.id(),
             "name": info.displayName ?? "",
             "topic": info.topic as Any,
             "memberCount": info.joinedMembersCount ?? 0,
             "isEncrypted": encrypted,
             "unreadCount": info.numUnreadMessages ?? 0,
-            "lastEventTs": nil as Int? as Any,
+            "lastEventTs": latestEventDict?["originServerTs"] as Any,
             "membership": membership,
             "avatarUrl": avatarUrl as Any,
             "isDirect": isDirect,
         ]
+        if let le = latestEventDict {
+            dict["latestEvent"] = le
+        }
+        return dict
     }
 
     private static func mapSyncState(_ state: SyncServiceState) -> String {
@@ -1323,6 +1528,89 @@ class MatrixSDKBridge {
 
 // MARK: - Timeline Serialization Helpers
 
+/// Serialize a LatestEventValue (from room.latestEvent()) into a lightweight dictionary
+/// for last-message previews. Does NOT create a timeline subscription.
+private func serializeLatestEventValue(_ value: LatestEventValue, roomId: String) -> [String: Any]? {
+    let timestamp: UInt64
+    let sender: String
+    let profile: ProfileDetails
+    let content: TimelineItemContent
+
+    switch value {
+    case .none:
+        return nil
+    case .remote(let ts, let s, _, let p, let c):
+        timestamp = ts
+        sender = s
+        profile = p
+        content = c
+    case .local(let ts, let s, let p, let c, _):
+        timestamp = ts
+        sender = s
+        profile = p
+        content = c
+    @unknown default:
+        return nil
+    }
+
+    var contentDict: [String: Any] = [:]
+    var eventType = "m.room.message"
+
+    switch content {
+    case .msgLike(let msgLikeContent):
+        switch msgLikeContent.kind {
+        case .message(let messageContent):
+            contentDict["body"] = messageContent.body
+            switch messageContent.msgType {
+            case .text:
+                contentDict["msgtype"] = "m.text"
+            case .image:
+                contentDict["msgtype"] = "m.image"
+            case .file:
+                contentDict["msgtype"] = "m.file"
+            case .audio:
+                contentDict["msgtype"] = "m.audio"
+            case .video:
+                contentDict["msgtype"] = "m.video"
+            case .emote:
+                contentDict["msgtype"] = "m.emote"
+            case .notice:
+                contentDict["msgtype"] = "m.notice"
+            default:
+                contentDict["msgtype"] = "m.text"
+            }
+        case .unableToDecrypt:
+            contentDict["body"] = "Unable to decrypt message"
+            contentDict["msgtype"] = "m.text"
+            contentDict["encrypted"] = true
+        case .redacted:
+            eventType = "m.room.redaction"
+            contentDict["body"] = "Message deleted"
+        default:
+            eventType = "m.room.unknown"
+        }
+    default:
+        eventType = "m.room.unknown"
+    }
+
+    var senderDisplayName: String? = nil
+    if case .ready(let displayName, _, _) = profile {
+        senderDisplayName = displayName
+    }
+
+    var dict: [String: Any] = [
+        "roomId": roomId,
+        "senderId": sender,
+        "type": eventType,
+        "content": contentDict,
+        "originServerTs": timestamp,
+    ]
+    if let name = senderDisplayName {
+        dict["senderDisplayName"] = name
+    }
+    return dict
+}
+
 /// Extract the event ID string from an EventOrTransactionId enum.
 private func extractEventId(_ eventOrTxnId: EventOrTransactionId) -> String? {
     switch eventOrTxnId {
@@ -1417,6 +1705,35 @@ private func serializeEventTimelineItem(_ eventItem: EventTimelineItem, roomId:
                 ] as [String: Any]
             }
         }
+    case .roomMembership(let userId, let userDisplayName, let change, _):
+        eventType = "m.room.member"
+        let membership: String
+        switch change {
+        case .joined, .invitationAccepted:
+            membership = "join"
+        case .left:
+            membership = "leave"
+        case .banned, .kickedAndBanned:
+            membership = "ban"
+        case .invited:
+            membership = "invite"
+        case .kicked:
+            membership = "leave"
+        case .unbanned:
+            membership = "leave"
+        default:
+            membership = "join"
+        }
+        contentDict["membership"] = membership
+        contentDict["displayname"] = userDisplayName ?? userId
+        contentDict["stateKey"] = userId
+    case .state(_, let stateContent):
+        switch stateContent {
+        case .roomCreate:
+            eventType = "m.room.create"
+        default:
+            eventType = "m.room.unknown"
+        }
     default:
         eventType = "m.room.unknown"
     }
@@ -1479,7 +1796,7 @@ class LiveTimelineListener: TimelineListener {
         self.isPaginating = isPaginating
     }
 
-    /// Emit a room update with the current unread count fetched from the room.
+    /// Emit a room update with unread count and latest event preview.
     private func emitRoomUpdate() {
         Task {
             let unreadCount: Int
@@ -1488,7 +1805,12 @@ class LiveTimelineListener: TimelineListener {
             } else {
                 unreadCount = 0
             }
-            onRoomUpdate(roomId, ["roomId": roomId, "unreadCount": unreadCount])
+            var summary: [String: Any] = ["roomId": roomId, "unreadCount": unreadCount]
+            let latestEvent = await room.latestEvent()
+            if let le = serializeLatestEventValue(latestEvent, roomId: roomId) {
+                summary["latestEvent"] = le
+            }
+            onRoomUpdate(roomId, summary)
         }
     }
 

package/ios/Sources/CapMatrixPlugin/CapMatrixPlugin.swift

@@ -58,6 +58,7 @@ public class MatrixPlugin: CAPPlugin, CAPBridgedPlugin {
         CAPPluginMethod(name: "setPusher", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "verifyDevice", returnType: CAPPluginReturnPromise),
         CAPPluginMethod(name: "clearAllData", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "updateAccessToken", returnType: CAPPluginReturnPromise),
     ]
 
     private let matrixBridge = MatrixSDKBridge()
@@ -118,6 +119,21 @@ public class MatrixPlugin: CAPPlugin, CAPBridgedPlugin {
         call.resolve()
     }
 
+    @objc func updateAccessToken(_ call: CAPPluginCall) {
+        guard let accessToken = call.getString("accessToken") else {
+            return call.reject("Missing accessToken")
+        }
+
+        Task {
+            do {
+                try await matrixBridge.updateAccessToken(accessToken: accessToken)
+                call.resolve()
+            } catch {
+                call.reject(error.localizedDescription)
+            }
+        }
+    }
+
     @objc func getSession(_ call: CAPPluginCall) {
         if let session = matrixBridge.getSession() {
             call.resolve(session)
@@ -661,11 +677,34 @@ public class MatrixPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     @objc func setPresence(_ call: CAPPluginCall) {
-        call.reject("setPresence is not supported on this platform")
+        guard let presence = call.getString("presence") else {
+            return call.reject("Missing presence")
+        }
+        let statusMsg = call.getString("statusMsg")
+
+        Task {
+            do {
+                try await matrixBridge.setPresence(presence: presence, statusMsg: statusMsg)
+                call.resolve()
+            } catch {
+                call.reject(error.localizedDescription)
+            }
+        }
     }
 
     @objc func getPresence(_ call: CAPPluginCall) {
-        call.reject("getPresence is not supported on this platform")
+        guard let userId = call.getString("userId") else {
+            return call.reject("Missing userId")
+        }
+
+        Task {
+            do {
+                let result = try await matrixBridge.getPresence(userId: userId)
+                call.resolve(result)
+            } catch {
+                call.reject(error.localizedDescription)
+            }
+        }
     }
 
     @objc func forgetRoom(_ call: CAPPluginCall) {
@@ -811,6 +850,34 @@ public class MatrixPlugin: CAPPlugin, CAPBridgedPlugin {
     }
 
     @objc func setPusher(_ call: CAPPluginCall) {
-        call.reject("setPusher is not yet supported")
+        guard let pushkey = call.getString("pushkey"),
+              let appId = call.getString("appId"),
+              let appDisplayName = call.getString("appDisplayName"),
+              let deviceDisplayName = call.getString("deviceDisplayName"),
+              let lang = call.getString("lang"),
+              let dataObj = call.getObject("data"),
+              let dataUrl = dataObj["url"] as? String else {
+            return call.reject("Missing required parameters")
+        }
+        let kind = call.getString("kind")
+        let dataFormat = dataObj["format"] as? String
+
+        Task {
+            do {
+                try await matrixBridge.setPusher(
+                    pushkey: pushkey,
+                    kind: kind,
+                    appId: appId,
+                    appDisplayName: appDisplayName,
+                    deviceDisplayName: deviceDisplayName,
+                    lang: lang,
+                    dataUrl: dataUrl,
+                    dataFormat: dataFormat
+                )
+                call.resolve()
+            } catch {
+                call.reject(error.localizedDescription)
+            }
+        }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagea/capacitor-matrix",
-  "version": "1.1.1",
+  "version": "1.2.0",
   "description": "A capacitor plugin wrapping native matrix SDKs",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",