@capgo/capacitor-stream-call 0.0.2

package/ios/Sources/StreamCallPlugin/TouchInterceptView.swift

@@ -0,0 +1,177 @@
+import UIKit
+
+class TouchInterceptView: UIView {
+    private var webView: UIView?
+    private var overlayView: UIView?
+    private var labeledFrames: [ViewFramePreferenceData] = []
+
+    override init(frame: CGRect) {
+        super.init(frame: frame)
+        isUserInteractionEnabled = true
+    }
+
+    required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        isUserInteractionEnabled = true
+    }
+
+    func setupWithWebView(_ webView: UIView, overlayView: UIView) {
+        self.webView = webView
+        self.overlayView = overlayView
+
+        // Add both views as subviews
+        addSubview(overlayView)
+        addSubview(webView)
+
+        // Ensure both views can receive touches
+        webView.isUserInteractionEnabled = true
+        overlayView.isUserInteractionEnabled = true
+    }
+
+    override func touchesBegan(_ touches: Set<UITouch>, with event: UIEvent?) {
+        guard let webView = webView,
+              let overlayView = overlayView else {
+            super.touchesBegan(touches, with: event)
+            return
+        }
+
+        // Convert touch locations and check labeled frames
+        if let touch = touches.first {
+            let point = touch.location(in: self)
+            let globalPoint = convert(point, to: nil)
+
+            // If touch is in a labeled frame, only send to overlay
+            if labeledFrames.contains(where: { $0.frame.contains(globalPoint) }) {
+                overlayView.touchesBegan(touches, with: event)
+            } else {
+                // Otherwise broadcast to both views
+                webView.touchesBegan(touches, with: event)
+                overlayView.touchesBegan(touches, with: event)
+            }
+        }
+
+        super.touchesBegan(touches, with: event)
+    }
+
+    override func touchesMoved(_ touches: Set<UITouch>, with event: UIEvent?) {
+        guard let webView = webView,
+              let overlayView = overlayView else {
+            super.touchesMoved(touches, with: event)
+            return
+        }
+
+        if let touch = touches.first {
+            let point = touch.location(in: self)
+            let globalPoint = convert(point, to: nil)
+
+            if labeledFrames.contains(where: { $0.frame.contains(globalPoint) }) {
+                overlayView.touchesMoved(touches, with: event)
+            } else {
+                webView.touchesMoved(touches, with: event)
+                overlayView.touchesMoved(touches, with: event)
+            }
+        }
+
+        super.touchesMoved(touches, with: event)
+    }
+
+    override func touchesEnded(_ touches: Set<UITouch>, with event: UIEvent?) {
+        guard let webView = webView,
+              let overlayView = overlayView else {
+            super.touchesEnded(touches, with: event)
+            return
+        }
+
+        if let touch = touches.first {
+            let point = touch.location(in: self)
+            let globalPoint = convert(point, to: nil)
+
+            if labeledFrames.contains(where: { $0.frame.contains(globalPoint) }) {
+                overlayView.touchesEnded(touches, with: event)
+            } else {
+                webView.touchesEnded(touches, with: event)
+                overlayView.touchesEnded(touches, with: event)
+            }
+        }
+
+        super.touchesEnded(touches, with: event)
+    }
+
+    override func touchesCancelled(_ touches: Set<UITouch>, with event: UIEvent?) {
+        guard let webView = webView,
+              let overlayView = overlayView else {
+            super.touchesCancelled(touches, with: event)
+            return
+        }
+
+        if let touch = touches.first {
+            let point = touch.location(in: self)
+            let globalPoint = convert(point, to: nil)
+
+            if labeledFrames.contains(where: { $0.frame.contains(globalPoint) }) {
+                overlayView.touchesCancelled(touches, with: event)
+            } else {
+                webView.touchesCancelled(touches, with: event)
+                overlayView.touchesCancelled(touches, with: event)
+            }
+        }
+
+        super.touchesCancelled(touches, with: event)
+    }
+
+    override func point(inside point: CGPoint, with event: UIEvent?) -> Bool {
+        return true
+    }
+
+    override func hitTest(_ point: CGPoint, with event: UIEvent?) -> UIView? {
+        guard let webView = webView,
+              let overlayView = overlayView else {
+            return super.hitTest(point, with: event)
+        }
+
+        // Convert point to global coordinates for labeled frame checking
+        let globalPoint = convert(point, to: nil)
+
+        print("TouchInterceptView - Hit test at global point: \(globalPoint)")
+        print("Current labeled frames: \(labeledFrames.map { "\($0.label): \($0.frame)" }.joined(separator: ", "))")
+
+        // Convert point for both views
+        let webViewPoint = convert(point, to: webView)
+        let overlayPoint = convert(point, to: overlayView)
+
+        // First check if the point is inside any labeled frame
+        for labeledFrame in labeledFrames {
+            if labeledFrame.frame.contains(globalPoint) {
+                print("Hit labeled frame: \(labeledFrame.label)")
+                // If it's in a labeled frame, let the overlay handle it
+                if overlayView.point(inside: overlayPoint, with: event),
+                   let overlayHitView = overlayView.hitTest(overlayPoint, with: event) {
+                    return overlayHitView
+                }
+            }
+        }
+
+        // If not in a labeled frame, let webview try first
+        if webView.point(inside: webViewPoint, with: event),
+           let webViewHitView = webView.hitTest(webViewPoint, with: event) {
+            return webViewHitView
+        }
+
+        // Finally check if overlay wants to handle the touch
+        if overlayView.point(inside: overlayPoint, with: event),
+           let overlayHitView = overlayView.hitTest(overlayPoint, with: event) {
+            return overlayHitView
+        }
+
+        return super.hitTest(point, with: event)
+    }
+
+    func updateLabeledFrames(_ frames: [ViewFramePreferenceData]) {
+        print("TouchInterceptView - Updating labeled frames:")
+        print("Number of frames: \(frames.count)")
+        frames.forEach { frame in
+            print("Label: \(frame.label), Frame: \(frame.frame)")
+        }
+        self.labeledFrames = frames
+    }
+}

package/ios/Sources/StreamCallPlugin/UserRepository.swift

@@ -0,0 +1,96 @@
+//
+//  UserRepository.swift
+//  Pods
+//
+//  Created by Michał Tremblay on 07/02/2025.
+//
+
+import Security
+import StreamVideo
+import Foundation
+
+struct UserCredentials: Identifiable, Codable {
+    var id: String {
+        user.id
+    }
+    let user: User
+    let tokenValue: String
+}
+
+protocol UserRepository {
+
+    func save(user: UserCredentials)
+
+    func loadCurrentUser() -> UserCredentials?
+
+    func removeCurrentUser()
+
+    func save(token: String)
+
+}
+
+protocol VoipTokenHandler {
+
+    func save(voipPushToken: String?)
+
+    func currentVoipPushToken() -> String?
+
+}
+
+// NOTE: This is just for simplicity. User data shouldn't be kept in `UserDefaults`.
+// NOTE: This is just for simplicity. User data shouldn't be kept in `UserDefaults`.
+class SecureUserRepository: UserRepository, VoipTokenHandler {
+
+    private let defaults = UserDefaults.standard
+    private let userKey = "stream.video.user"
+    private let tokenKey = "stream.video.token"
+    private let chatTokenKey = "stream.chat.token"
+    private let voipPushTokenKey = "stream.video.voip.token"
+
+    static let shared = SecureUserRepository()
+
+    private init() {}
+
+    func save(user: UserCredentials) {
+        let encoder = JSONEncoder()
+        if let encoded = try? encoder.encode(user.user) {
+            defaults.set(encoded, forKey: userKey)
+            defaults.set(user.tokenValue, forKey: tokenKey)
+        }
+    }
+
+    func save(token: String) {
+        defaults.set(token, forKey: tokenKey)
+    }
+
+    func loadCurrentUser() -> UserCredentials? {
+        if let savedUser = defaults.object(forKey: userKey) as? Data {
+            let decoder = JSONDecoder()
+            do {
+                let loadedUser = try decoder.decode(User.self, from: savedUser)
+                guard let tokenValue = defaults.value(forKey: tokenKey) as? String else {
+                    throw ClientError.Unexpected()
+                }
+                return UserCredentials(user: loadedUser, tokenValue: tokenValue)
+            } catch {
+                log.error("Error while decoding user: \(String(describing: error))")
+            }
+        }
+        return nil
+    }
+
+    func save(voipPushToken: String?) {
+        defaults.set(voipPushToken, forKey: voipPushTokenKey)
+    }
+
+    func currentVoipPushToken() -> String? {
+        defaults.value(forKey: voipPushTokenKey) as? String
+    }
+
+    func removeCurrentUser() {
+        defaults.set(nil, forKey: userKey)
+        defaults.set(nil, forKey: tokenKey)
+        defaults.set(nil, forKey: voipPushTokenKey)
+    }
+
+}

package/ios/Sources/StreamCallPlugin/WebviewNavigationDelegate.swift

@@ -0,0 +1,68 @@
+import Foundation
+import WebKit
+
+class WebviewNavigationDelegate: NSObject, WKNavigationDelegate {
+    private let wrappedDelegate: WKNavigationDelegate?
+    private let onSetupOverlay: () -> Void
+
+    init(wrappedDelegate: WKNavigationDelegate?, onSetupOverlay: @escaping () -> Void) {
+        self.wrappedDelegate = wrappedDelegate
+        self.onSetupOverlay = onSetupOverlay
+        super.init()
+    }
+
+    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+        // Then forward to the original delegate
+        wrappedDelegate?.webView?(webView, didFinish: navigation)
+
+        // Call our custom setup
+        onSetupOverlay()
+    }
+
+    // Forward all other WKNavigationDelegate methods
+
+    func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction, decisionHandler: @escaping (WKNavigationActionPolicy) -> Void) {
+        if let result = wrappedDelegate?.webView?(webView, decidePolicyFor: navigationAction, decisionHandler: decisionHandler) {
+            return result
+        }
+        decisionHandler(.allow)
+    }
+
+    func webView(_ webView: WKWebView, decidePolicyFor navigationResponse: WKNavigationResponse, decisionHandler: @escaping (WKNavigationResponsePolicy) -> Void) {
+        if let result = wrappedDelegate?.webView?(webView, decidePolicyFor: navigationResponse, decisionHandler: decisionHandler) {
+            return result
+        }
+        decisionHandler(.allow)
+    }
+
+    func webView(_ webView: WKWebView, didStartProvisionalNavigation navigation: WKNavigation!) {
+        wrappedDelegate?.webView?(webView, didStartProvisionalNavigation: navigation)
+    }
+
+    func webView(_ webView: WKWebView, didReceiveServerRedirectForProvisionalNavigation navigation: WKNavigation!) {
+        wrappedDelegate?.webView?(webView, didReceiveServerRedirectForProvisionalNavigation: navigation)
+    }
+
+    func webView(_ webView: WKWebView, didFailProvisionalNavigation navigation: WKNavigation!, withError error: Error) {
+        wrappedDelegate?.webView?(webView, didFailProvisionalNavigation: navigation, withError: error)
+    }
+
+    func webView(_ webView: WKWebView, didCommit navigation: WKNavigation!) {
+        wrappedDelegate?.webView?(webView, didCommit: navigation)
+    }
+
+    func webView(_ webView: WKWebView, didFail navigation: WKNavigation!, withError error: Error) {
+        wrappedDelegate?.webView?(webView, didFail: navigation, withError: error)
+    }
+
+    func webView(_ webView: WKWebView, didReceive challenge: URLAuthenticationChallenge, completionHandler: @escaping (URLSession.AuthChallengeDisposition, URLCredential?) -> Void) {
+        if let result = wrappedDelegate?.webView?(webView, didReceive: challenge, completionHandler: completionHandler) {
+            return result
+        }
+        completionHandler(.performDefaultHandling, nil)
+    }
+
+    func webViewWebContentProcessDidTerminate(_ webView: WKWebView) {
+        wrappedDelegate?.webViewWebContentProcessDidTerminate?(webView)
+    }
+}

package/ios/Tests/StreamCallPluginTests/StreamCallPluginTests.swift

@@ -0,0 +1,15 @@
+import XCTest
+@testable import StreamCallPlugin
+
+class StreamCallTests: XCTestCase {
+    func testEcho() {
+        // This is an example of a functional test case for a plugin.
+        // Use XCTAssert and related functions to verify your tests produce the correct results.
+
+        let implementation = StreamCall()
+        let value = "Hello, World!"
+        let result = implementation.echo(value)
+
+        XCTAssertEqual(value, result)
+    }
+}

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@capgo/capacitor-stream-call",
+  "version": "0.0.2",
+  "description": "Uses the https://getstream.io/ SDK to implement calling in Capacitor",
+  "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/Sources",
+    "ios/Tests",
+    "Package.swift",
+    "StreamCall.podspec"
+  ],
+  "author": "Martin Donadieu <martin@capgo.app>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Cap-go/StreamCall.git"
+  },
+  "bugs": {
+    "url": "https://github.com/Cap-go/StreamCall/issues"
+  },
+  "keywords": [
+    "capacitor",
+    "plugin",
+    "stream",
+    "call",
+    "video",
+    "audio",
+    "getstream",
+    "stream-video",
+    "stream-call",
+    "group-call",
+    "native",
+    "ios",
+    "android",
+    "web",
+    "capacitor-plugin"    
+  ],
+  "scripts": {
+    "verify": "npm run verify:ios && npm run verify:android && npm run verify:web",
+    "verify:ios": "xcodebuild -scheme StreamCall -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}\" --plugin=prettier-plugin-java",
+    "swiftlint": "node-swiftlint",
+    "docgen": "docgen --api StreamCallPlugin --output-readme README.md --output-json dist/docs.json",
+    "build": "npm run clean && npm run docgen && tsc && rollup -c rollup.config.mjs",
+    "clean": "rimraf ./dist",
+    "watch": "tsc --watch",
+    "prepublishOnly": "npm run build"
+  },
+  "devDependencies": {
+    "@capacitor/android": "^7.0.0",
+    "@capacitor/core": "^7.0.0",
+    "@capacitor/docgen": "^0.3.0",
+    "@capacitor/ios": "^7.0.0",
+    "@ionic/eslint-config": "^0.4.0",
+    "@ionic/prettier-config": "^4.0.0",
+    "@ionic/swiftlint-config": "^2.0.0",
+    "eslint": "^8.57.0",
+    "prettier": "^3.5.0",
+    "prettier-plugin-java": "^2.6.7",
+    "rimraf": "^6.0.1",
+    "rollup": "^4.34.6",
+    "swiftlint": "^2.0.0",
+    "typescript": "^5.7.3"
+  },
+  "peerDependencies": {
+    "@capacitor/core": ">=7.0.0"
+  },
+  "prettier": "@ionic/prettier-config",
+  "swiftlint": "@ionic/swiftlint-config",
+  "eslintConfig": {
+    "extends": "@ionic/eslint-config/recommended"
+  },
+  "capacitor": {
+    "ios": {
+      "src": "ios"
+    },
+    "android": {
+      "src": "android"
+    }
+  },
+  "dependencies": {
+    "@stream-io/video-client": "1.16.7",
+    "@stream-io/audio-filters-web": "^0.2.2"
+  }
+}