@capacitor-plus/ios 8.0.0-beta.0

package/Capacitor/Capacitor/KeyValueStore.swift

@@ -0,0 +1,303 @@
+//
+//  KeyValueStore.swift
+//  Capacitor
+//
+//  Created by Steven Sherry on 1/5/24.
+//  Copyright © 2024 Drifty Co. All rights reserved.
+//
+
+import Foundation
+
+/// A generic KeyValueStore that allows storing and retrieving values associated with string keys.
+/// The store supports both ephemeral (in-memory) storage and persistent (file-based) storage backends
+/// by default, however it can also take anything that conforms to ``KeyValueStoreBackend`` as
+/// a backend.
+///
+/// This class provides methods to get, set and delete key-value pairs for any type of value, provided the
+/// types conform to `Codable`. The default ``Backend/ephemeral`` and ``Backend/persistent(suiteName:)``
+/// backends are thread-safe.
+///
+/// ## Usage Examples
+///
+/// ### Non-throwing API
+/// ```swift
+/// let store = KeyValueStore.standard
+/// // Set
+/// store["key"] = "value"
+///
+/// // Get
+/// if let value = store["key", as: String.self] {
+///   // Do something with value
+/// }
+///
+/// // Delete
+/// // The type here is a required argument because
+/// // it is unable to be inferred
+/// store["key", as: String.self] = nil
+/// // or
+/// store["key"] = nil as String?
+/// ```
+///
+///
+/// ### Throwing API
+///
+/// ```swift
+/// let store = KeyValueStore.standard
+/// do {
+///     // Set
+///     try store.set("key", value: "value")
+///
+///     // Get
+///     if let value = try store.get("key", as: String.self) {
+///         // Do something with value
+///     }
+///
+///     // Delete
+///     try store.delete("key")
+/// } catch {
+///     print(error.localizedDescription)
+/// }
+/// ```
+///
+/// ### Throwing vs Non-throwing
+///
+/// Of the built-in backends, both ``Backend/ephemeral`` and ``Backend/persistent(suiteName:)`` will throw in the following cases:
+/// * The data read from the file retrieved during ``get(_:as:)`` is unable to be decoded as the type provided.
+/// * The value provided to ``set(_:value:)`` encounters an error during encoding.
+///     * This is more likely to happen with types that have custom `Encodable` implementations
+///
+/// ``Backend/persistent(suiteName:)`` will throw for the following additional cases:
+/// * A file is unable to be read from disk during ``get(_:as:)``
+///     * The existence of the file on disk is checked before attempting to read the file, so out of the
+///       [possible file reading errors](https://developer.apple.com/documentation/foundation/1448136-nserror_codes#file-reading-errors),
+///       the only likely candidate would be
+///       [NSFileReadCorruptFileError](https://developer.apple.com/documentation/foundation/1448136-nserror_codes/nsfilereadcorruptfileerror).
+///       In practice, this should never happen since writes happen atomically.
+/// * The data from the value encoded in ``set(_:value:)`` is unable to be written to disk
+///     * Of the [possible file writing errors](https://developer.apple.com/documentation/foundation/1448136-nserror_codes#file-writing-errors),
+///       the only likely candidates are
+///       [NSFileWriteInvalidFileNameError](https://developer.apple.com/documentation/foundation/1448136-nserror_codes/nsfilewriteinvalidfilenameerror)
+///       if the key provided makes for an invalid file name and
+///       [NSFileWriteOutOfSpaceError](https://developer.apple.com/documentation/foundation/1448136-nserror_codes/nsfilewriteoutofspaceerror)
+///       if the user has no space left on disk
+///
+/// The throwing API should be used in cases where detailed error information is needed for logging or diagnostics. The non-throwing API should be used
+/// in cases where silent failure is preferred.
+public class KeyValueStore {
+
+    /// The built-in storage backends
+    public enum Backend {
+        /// An in-memory backing store
+        case ephemeral
+        /// A persistent file-based backing store using the
+        /// `suiteName` as an identifier for the collection of files
+        case persistent(suiteName: String)
+    }
+
+    private let backend: any KeyValueStoreBackend
+
+    /// Creates an instance of ``KeyValueStore`` with a custom backend
+    /// - Parameter backend: The custom backend implementation
+    public init(backend: any KeyValueStoreBackend) {
+        self.backend = backend
+    }
+
+    /// Creates an instance of ``KeyValueStore`` with the provided built-in ``Backend``
+    /// - Parameter type: The type of ``Backend`` to use
+    public init(type: Backend) {
+        switch type {
+        case .ephemeral:
+            backend = InMemoryStore()
+        case .persistent(suiteName: let name):
+            backend = FileStore.with(name: name)
+        }
+    }
+
+    /// Creates an instance of ``KeyValueStore`` with ``Backend/persistent(suiteName:)``
+    /// - Parameter suiteName: The suite name to provide ``Backend/persistent(suiteName:)``
+    public convenience init(suiteName: String) {
+        self.init(type: .persistent(suiteName: suiteName))
+    }
+
+    /// Retrieves a value of the specified type and key
+    /// - Parameters:
+    ///   - key: The unique identifier for the value
+    ///   - type: The expected type of the value being retried
+    /// - Returns: A decoded value of the given type or `nil` if there is no such value
+    public func `get`<T>(_ key: String, as type: T.Type = T.self) throws -> T? where T: Decodable {
+        try backend.get(key, as: type)
+    }
+
+    /// Stores the value under the specified key
+    /// - Parameters:
+    ///   - key: The unique identifier
+    ///   - value: The value to be stored
+    public func `set`<T>(_ key: String, value: T) throws where T: Encodable {
+        try backend.set(key, value: value)
+    }
+
+    /// Deletes the value for the specified key
+    public func `delete`(_ key: String) throws {
+        try backend.delete(key)
+    }
+
+    /// Convenience for accessing and modifying values in the store without calling ``get(_:as:)``, ``set(_:value:)``, or ``delete(_:)``
+    /// - Parameters:
+    ///     - key: The unique identifier for the value to access or modify
+    ///     - type: The type the value is stored as
+    ///
+    /// This method is only really necessary when accessing a key and the type cannot be inferred from it's context.
+    /// ```swift
+    /// let store = KeyValueStore.standard
+    ///
+    /// // Get
+    /// let value = store["key", as: String.self]
+    ///
+    /// // If the type can be inferred then it may be omitted
+    /// let value: String? = store["key"]
+    /// let value = store["key"] as String?
+    /// let value = store["key"] ?? "default"
+    ///
+    /// // Delete
+    /// store["key", as: String.self] = nil
+    /// store["key"] = nil as String?
+    /// ```
+    public subscript<T> (_ key: String, as type: T.Type = T.self) -> T? where T: Codable {
+        get { try? self.get(key) }
+        set {
+            if let newValue {
+                try? self.set(key, value: newValue)
+            } else {
+                try? self.delete(key)
+            }
+        }
+    }
+
+    /// A shared persistent instance of ``KeyValueStore``
+    public static let standard = KeyValueStore(type: .persistent(suiteName: "standard"))
+}
+
+public protocol KeyValueStoreBackend {
+    func `get`<T>(_ key: String, as type: T.Type) throws -> T? where T: Decodable
+    func `set`<T>(_ key: String, value: T) throws where T: Encodable
+    func `delete`(_ key: String) throws
+}
+
+private class FileStore: KeyValueStoreBackend {
+    private let cache = ConcurrentDictionary<Data>()
+    private let decoder = JSONDecoder()
+    private let encoder = JSONEncoder()
+    private let baseUrl: URL
+
+    private init(baseUrl: URL) {
+        self.baseUrl = baseUrl
+    }
+
+    func get<T>(_ key: String, as type: T.Type) throws -> T? where T: Decodable {
+        if let cached = cache[key],
+           let value = try? decoder.decode(type, from: cached) {
+            return value
+        }
+
+        let fileCacheLocation = baseUrl.appendingPathComponent(key)
+        guard FileManager.default.fileExists(atPath: fileCacheLocation.path) else { return nil }
+
+        let data = try Data(contentsOf: fileCacheLocation)
+        let decoded = try decoder.decode(type, from: data)
+
+        cache[key] = data
+        return decoded
+    }
+
+    func set<T>(_ key: String, value: T) throws where T: Encodable {
+        let encoded = try encoder.encode(value)
+        try encoded.write(to: url(for: key), options: .atomic)
+        cache[key] = encoded
+    }
+
+    func delete(_ key: String) throws {
+        cache[key] = nil
+        try FileManager.default.removeItem(at: url(for: key))
+    }
+
+    private func url(for key: String) -> URL {
+        baseUrl.appendingPathComponent(key)
+    }
+
+    private static let instances = ConcurrentDictionary<FileStore>()
+
+    // This ensures we essentially have singletons for accessing file based resources
+    // so we don't have a scenario where two separate instances may be writing to
+    // the same files.
+    static func with(name: String) -> FileStore {
+        if let existing = instances[name] { return existing }
+        guard let library = try? FileManager
+                .default
+                .url(
+                    for: .libraryDirectory,
+                    in: .userDomainMask,
+                    appropriateFor: nil,
+                    create: true
+                )
+        else { fatalError("⚡️ ❌ Library URL unable to be accessed or created by the current application. This is an impossible state.") }
+
+        let url = library.appendingPathComponent("kvstore").appendingPathComponent(name)
+
+        // Create the folder if it doesn't exist. This should never throw for the current base directory, so we ignore the exception.
+        try? FileManager.default.createDirectory(at: url, withIntermediateDirectories: true, attributes: nil)
+
+        let new = FileStore(baseUrl: url)
+        instances[name] = new
+        return new
+    }
+}
+
+private class InMemoryStore: KeyValueStoreBackend {
+    private let storage = ConcurrentDictionary<Data>()
+    private let decoder = JSONDecoder()
+    private let encoder = JSONEncoder()
+
+    func get<T>(_ key: String, as type: T.Type) throws -> T? where T: Decodable {
+        guard let data = storage[key] else { return nil }
+        return try decoder.decode(type, from: data)
+    }
+
+    func set<T>(_ key: String, value: T) throws where T: Encodable {
+        let data = try encoder.encode(value)
+        storage[key] = data
+    }
+
+    func delete(_ key: String) {
+        storage[key] = nil
+    }
+}
+
+class ConcurrentDictionary<Value> {
+    typealias StorageType = [String: Value]
+    private var storage: StorageType
+    private let lock = NSLock()
+
+    init(_ initial: StorageType = [:]) {
+        storage = initial
+    }
+
+    subscript (_ key: String) -> Value? {
+        get {
+            lock.withLock {
+                storage[key]
+            }
+        }
+
+        set {
+            lock.withLock {
+                storage[key] = newValue
+            }
+        }
+    }
+
+    func withLock<T>(_ body: (_ storage: inout StorageType) -> T) -> T {
+        lock.withLock {
+            body(&storage)
+        }
+    }
+}

package/Capacitor/Capacitor/NotificationHandlerProtocol.swift

@@ -0,0 +1,6 @@
+import Foundation
+
+@objc(CAPNotificationHandlerProtocol) public protocol NotificationHandlerProtocol {
+    func willPresent(notification: UNNotification) -> UNNotificationPresentationOptions
+    func didReceive(response: UNNotificationResponse)
+}

package/Capacitor/Capacitor/NotificationRouter.swift

@@ -0,0 +1,60 @@
+import Foundation
+
+@objc(CAPNotificationRouter) public class NotificationRouter: NSObject, UNUserNotificationCenterDelegate {
+    var handleApplicationNotifications: Bool {
+        get {
+            return UNUserNotificationCenter.current().delegate === self
+        }
+        set {
+            let center = UNUserNotificationCenter.current()
+
+            if newValue {
+                center.delegate = self
+            } else if center.delegate === self {
+                center.delegate = nil
+            }
+        }
+    }
+
+    public weak var pushNotificationHandler: NotificationHandlerProtocol? {
+        didSet {
+            if pushNotificationHandler != nil, oldValue != nil {
+                CAPLog.print("Push notification handler overriding previous instance: \(String(describing: type(of: oldValue)))")
+            }
+        }
+    }
+
+    public weak var localNotificationHandler: NotificationHandlerProtocol? {
+        didSet {
+            if localNotificationHandler != nil, oldValue != nil {
+                CAPLog.print("Local notification handler overriding previous instance: \(String(describing: type(of: oldValue)))")
+            }
+        }
+    }
+
+    public func userNotificationCenter(_ center: UNUserNotificationCenter,
+                                       willPresent notification: UNNotification,
+                                       withCompletionHandler completionHandler: @escaping (UNNotificationPresentationOptions) -> Void) {
+        let presentationOptions: UNNotificationPresentationOptions?
+
+        if notification.request.trigger?.isKind(of: UNPushNotificationTrigger.self) == true {
+            presentationOptions = pushNotificationHandler?.willPresent(notification: notification)
+        } else {
+            presentationOptions = localNotificationHandler?.willPresent(notification: notification)
+        }
+
+        completionHandler(presentationOptions ?? [])
+    }
+
+    public func userNotificationCenter(_ center: UNUserNotificationCenter,
+                                       didReceive response: UNNotificationResponse,
+                                       withCompletionHandler completionHandler: @escaping () -> Void) {
+        if response.notification.request.trigger?.isKind(of: UNPushNotificationTrigger.self) == true {
+            pushNotificationHandler?.didReceive(response: response)
+        } else {
+            localNotificationHandler?.didReceive(response: response)
+        }
+
+        completionHandler()
+    }
+}

package/Capacitor/Capacitor/PluginCallResult.swift

@@ -0,0 +1,106 @@
+import Foundation
+
+public typealias PluginCallResultData = [String: Any]
+
+public enum PluginCallResult {
+    case dictionary(PluginCallResultData)
+
+    enum SerializationError: Error {
+        case invalidObject
+    }
+
+    func jsonRepresentation(includingFields: PluginCallResultData? = nil) throws -> String? {
+        switch self {
+        case .dictionary(var dictionary):
+            if let fields = includingFields {
+                dictionary.merge(fields) { (current, _) in current }
+            }
+            dictionary = prepare(dictionary: dictionary)
+            guard JSONSerialization.isValidJSONObject(dictionary) else {
+                throw SerializationError.invalidObject
+            }
+            let data = try JSONSerialization.data(withJSONObject: dictionary, options: [])
+            return String(data: data, encoding: .utf8)
+        }
+    }
+
+    private static let formatter = ISO8601DateFormatter()
+
+    private func prepare(dictionary: PluginCallResultData) -> PluginCallResultData {
+        return dictionary.mapValues { (value) -> Any in
+            if let date = value as? Date {
+                return PluginCallResult.formatter.string(from: date)
+            } else if let aDictionary = value as? PluginCallResultData {
+                return prepare(dictionary: aDictionary)
+            } else if let anArray = value as? [Any] {
+                return prepare(array: anArray)
+            }
+            return value
+        }
+    }
+
+    private func prepare(array: [Any]) -> [Any] {
+        return array.map { (value) -> Any in
+            if let date = value as? Date {
+                return PluginCallResult.formatter.string(from: date)
+            } else if let aDictionary = value as? PluginCallResultData {
+                return prepare(dictionary: aDictionary)
+            } else if let anArray = value as? [Any] {
+                return prepare(array: anArray)
+            }
+            return value
+        }
+    }
+}
+
+@objc public class CAPPluginCallResult: NSObject {
+    public let resultData: PluginCallResult?
+
+    @objc public var data: PluginCallResultData? {
+        guard let result = resultData else {
+            return nil
+        }
+        switch result {
+        case .dictionary(let data):
+            return data
+        }
+    }
+
+    @objc(init:)
+    public init(_ data: PluginCallResultData?) {
+        if let data = data {
+            resultData = .dictionary(data)
+        } else {
+            resultData = nil
+        }
+    }
+}
+
+@objc public class CAPPluginCallError: NSObject {
+    @objc public let message: String
+    @objc public let code: String?
+    @objc public let error: Error?
+    public let resultData: PluginCallResult?
+
+    @objc public var data: PluginCallResultData? {
+        guard let result = resultData else {
+            return nil
+        }
+        switch result {
+        case .dictionary(let data):
+            return data
+        }
+    }
+
+    @objc(init:code:error:data:)
+    public init(message: String, code: String?, error: Error?, data: PluginCallResultData?) {
+        self.message = message
+        self.code = code
+        self.error = error
+        if let data = data {
+            resultData = .dictionary(["data": data])
+        } else {
+            resultData = nil
+        }
+    }
+}

package/Capacitor/Capacitor/PluginConfig.swift

@@ -0,0 +1,56 @@
+import Foundation
+
+@objc public class PluginConfig: NSObject {
+
+    // The object containing the plugin config values
+    private var config: JSObject
+
+    init(config: JSObject) {
+        self.config = config
+    }
+
+    @objc public func getString(_ configKey: String, _ defaultValue: String? = nil) -> String? {
+        if let val = (self.config)[keyPath: KeyPath(configKey)] as? String {
+            return val
+        }
+        return defaultValue
+    }
+
+    @objc public func getBoolean(_ configKey: String, _ defaultValue: Bool) -> Bool {
+        if let val = (self.config)[keyPath: KeyPath(configKey)] as? Bool {
+            return val
+        }
+        return defaultValue
+    }
+
+    @objc public func getInt(_ configKey: String, _ defaultValue: Int) -> Int {
+        if let val = (self.config)[keyPath: KeyPath(configKey)] as? Int {
+            return val
+        }
+        return defaultValue
+    }
+
+    public func getArray(_ configKey: String, _ defaultValue: JSArray? = nil) -> JSArray? {
+        if let val = (self.config)[keyPath: KeyPath(configKey)] as? JSArray {
+            return val
+        }
+        return defaultValue
+    }
+
+    public func getObject(_ configKey: String) -> JSObject? {
+        return (self.config)[keyPath: KeyPath(configKey)] as? JSObject
+    }
+
+    @objc public func isEmpty() -> Bool {
+        return self.config.isEmpty
+    }
+
+    /**
+     * Gets the JSObject containing the config of the the provided plugin ID.
+     *
+     * @return The config for that plugin
+     */
+    public func getConfigJSON() -> JSObject {
+        return self.config
+    }
+}

package/Capacitor/Capacitor/Plugins/CapacitorCookieManager.swift

@@ -0,0 +1,141 @@
+import Foundation
+
+public class CapacitorWKCookieObserver: NSObject, WKHTTPCookieStoreObserver {
+    // Sync WKWebView Cookies to HTTPCookieStorage
+    public func cookiesDidChange(in cookieStore: WKHTTPCookieStore) {
+        DispatchQueue.main.async {
+            cookieStore.getAllCookies { cookies in
+                cookies.forEach { cookie in
+                    HTTPCookieStorage.shared.setCookie(cookie)
+                }
+            }
+        }
+    }
+}
+
+public class CapacitorCookieManager {
+    var config: InstanceConfiguration?
+
+    init(_ capConfig: InstanceConfiguration?) {
+        self.config = capConfig
+    }
+
+    public func getServerUrl() -> URL? {
+        return self.config?.serverURL ?? self.config?.localURL
+    }
+
+    private func isUrlSanitized(_ urlString: String) -> Bool {
+        return urlString.isEmpty || urlString == getServerUrl()?.absoluteString || urlString.hasPrefix("http://") || urlString.hasPrefix("https://")
+    }
+
+    public func getServerUrl(_ urlString: String?) -> URL? {
+        guard let urlString = urlString else {
+            return getServerUrl()
+        }
+
+        if urlString.isEmpty {
+            return getServerUrl()
+        }
+
+        let validUrlString = (isUrlSanitized(urlString)) ? urlString : "http://\(urlString)"
+
+        guard let url = URL(string: validUrlString) else {
+            return getServerUrl()
+        }
+
+        return url
+    }
+
+    public func encode(_ value: String) -> String {
+        return value.addingPercentEncoding(withAllowedCharacters: .urlPathAllowed)!
+    }
+
+    public func decode(_ value: String) -> String {
+        return value.removingPercentEncoding!
+    }
+
+    public func setCookie(_ domain: String, _ action: String) {
+        let url = getServerUrl(domain)!
+        let jar = HTTPCookieStorage.shared
+        let field = ["Set-Cookie": action]
+        let cookies = HTTPCookie.cookies(withResponseHeaderFields: field, for: url)
+        jar.setCookies(cookies, for: url, mainDocumentURL: nil)
+        syncCookiesToWebView()
+    }
+
+    public func setCookie(_ url: URL, _ key: String, _ value: String, _ expires: String?, _ path: String?) {
+        let jar = HTTPCookieStorage.shared
+        let field = ["Set-Cookie": "\(key)=\(value); expires=\(expires ?? ""); path=\(path ?? "/")"]
+        let cookies = HTTPCookie.cookies(withResponseHeaderFields: field, for: url)
+        jar.setCookies(cookies, for: url, mainDocumentURL: nil)
+        syncCookiesToWebView()
+    }
+
+    public func getCookiesAsMap(_ url: URL) -> [String: String] {
+        syncCookiesToWebView()
+        var cookiesMap: [String: String] = [:]
+        let jar = HTTPCookieStorage.shared
+        if let cookies = jar.cookies(for: url) {
+            for cookie in cookies {
+                if !cookie.isHTTPOnly {
+                    cookiesMap[cookie.name] = cookie.value
+                }
+            }
+        }
+        return cookiesMap
+    }
+
+    public func getCookies() -> String {
+        syncCookiesToWebView()
+        let jar = HTTPCookieStorage.shared
+        guard let url = self.getServerUrl() else { return "" }
+        guard let cookies = jar.cookies(for: url) else { return "" }
+        let filteredCookies = cookies.filter { !$0.isHTTPOnly }
+        return filteredCookies.map({"\($0.name)=\($0.value)"}).joined(separator: "; ")
+    }
+
+    public func deleteCookie(_ url: URL, _ key: String) {
+        let jar = HTTPCookieStorage.shared
+        if let cookie = jar.cookies(for: url)?.first(where: { (cookie) -> Bool in
+            return cookie.name == key
+        }) {
+            jar.deleteCookie(cookie)
+            DispatchQueue.main.async {
+                WKWebsiteDataStore.default().httpCookieStore.delete(cookie)
+            }
+        }
+    }
+
+    public func clearCookies(_ url: URL) {
+        let jar = HTTPCookieStorage.shared
+        jar.cookies(for: url)?.forEach({ (cookie) in
+            jar.deleteCookie(cookie)
+            DispatchQueue.main.async {
+                WKWebsiteDataStore.default().httpCookieStore.delete(cookie)
+            }
+        })
+    }
+
+    public func clearAllCookies() {
+        let jar = HTTPCookieStorage.shared
+        jar.cookies?.forEach({ (cookie) in
+            jar.deleteCookie(cookie)
+            DispatchQueue.main.async {
+                WKWebsiteDataStore.default().httpCookieStore.delete(cookie)
+            }
+        })
+    }
+
+    public func syncCookiesToWebView() {
+        if let cookies = HTTPCookieStorage.shared.cookies {
+            for cookie in cookies {
+                DispatchQueue.main.async {
+                    WKWebsiteDataStore.default()
+                        .httpCookieStore
+                        .setCookie(cookie, completionHandler: nil)
+                }
+
+            }
+        }
+    }
+}