@capacitor-plus/ios 8.0.0-beta.0

package/Capacitor/Capacitor/Plugins/CapacitorCookies.swift

@@ -0,0 +1,57 @@
+import Foundation
+
+@objc(CAPCookiesPlugin)
+public class CAPCookiesPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "CAPCookiesPlugin"
+    public let jsName = "CapacitorCookies"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "getCookies", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setCookie", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "deleteCookie", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "clearCookies", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "clearAllCookies", returnType: CAPPluginReturnPromise)
+    ]
+
+    var cookieManager: CapacitorCookieManager?
+
+    @objc override public func load() {
+        cookieManager = CapacitorCookieManager(bridge?.config)
+    }
+
+    @objc func getCookies(_ call: CAPPluginCall) {
+        guard let url = cookieManager!.getServerUrl(call.getString("url")) else { return call.reject("Invalid URL / Server URL")}
+        call.resolve(cookieManager!.getCookiesAsMap(url))
+    }
+
+    @objc func setCookie(_ call: CAPPluginCall) {
+        guard let key = call.getString("key") else { return call.reject("Must provide key") }
+        guard let value = call.getString("value") else { return call.reject("Must provide value") }
+
+        guard let url = cookieManager!.getServerUrl(call.getString("url")) else { return call.reject("Invalid domain") }
+
+        let expires = call.getString("expires", "")
+        let path = call.getString("path", "")
+        cookieManager!.setCookie(url, key, cookieManager!.encode(value), expires, path)
+        call.resolve()
+    }
+
+    @objc func deleteCookie(_ call: CAPPluginCall) {
+        guard let key = call.getString("key") else { return call.reject("Must provide key") }
+        guard let url = cookieManager!.getServerUrl(call.getString("url")) else { return call.reject("Invalid URL / Server URL")}
+        cookieManager!.deleteCookie(url, key)
+        call.resolve()
+    }
+
+    @objc func clearCookies(_ call: CAPPluginCall) {
+        let url = cookieManager!.getServerUrl(call.getString("url"))
+        if url != nil {
+            cookieManager!.clearCookies(url!)
+            call.resolve()
+        }
+    }
+
+    @objc func clearAllCookies(_ call: CAPPluginCall) {
+        cookieManager!.clearAllCookies()
+        call.resolve()
+    }
+}

package/Capacitor/Capacitor/Plugins/CapacitorHttp.swift

@@ -0,0 +1,57 @@
+import Foundation
+
+@objc(CAPHttpPlugin)
+public class CAPHttpPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "CAPHttpPlugin"
+    public let jsName = "CapacitorHttp"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "request", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "get", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "post", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "put", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "patch", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "delete", returnType: CAPPluginReturnPromise)
+    ]
+
+    @objc func http(_ call: CAPPluginCall, _ httpMethod: String?) {
+        do {
+            if let clazz = NSClassFromString("SSLPinningHttpRequestHandlerClass") {
+                // swiftlint:disable force_cast
+                (clazz as! NSObject.Type).perform(#selector(self.request(_:)), with: [
+                    "call": call,
+                    "httpMethod": httpMethod as Any,
+                    "config": self.bridge?.config as Any
+                ])
+                // swiftlint:enable force_cast
+            } else {
+                try HttpRequestHandler.request(call, httpMethod, self.bridge?.config)
+            }
+        } catch let error {
+            call.reject(error.localizedDescription)
+        }
+    }
+
+    @objc func request(_ call: CAPPluginCall) {
+        http(call, nil)
+    }
+
+    @objc func get(_ call: CAPPluginCall) {
+        http(call, "GET")
+    }
+
+    @objc func post(_ call: CAPPluginCall) {
+        http(call, "POST")
+    }
+
+    @objc func put(_ call: CAPPluginCall) {
+        http(call, "PUT")
+    }
+
+    @objc func patch(_ call: CAPPluginCall) {
+        http(call, "PATCH")
+    }
+
+    @objc func delete(_ call: CAPPluginCall) {
+        http(call, "DELETE")
+    }
+}

package/Capacitor/Capacitor/Plugins/CapacitorUrlRequest.swift

@@ -0,0 +1,225 @@
+import Foundation
+
+open class CapacitorUrlRequest: NSObject, URLSessionTaskDelegate {
+    public var request: URLRequest
+    public var headers: [String: String]
+
+    public enum CapacitorUrlRequestError: Error {
+        case serializationError(String?)
+    }
+
+    public init(_ url: URL, method: String) {
+        request = URLRequest(url: url)
+        request.httpMethod = method
+        headers = [:]
+        if let lang = Locale.autoupdatingCurrent.languageCode {
+            if let country = Locale.autoupdatingCurrent.regionCode {
+                headers["Accept-Language"] = "\(lang)-\(country),\(lang);q=0.5"
+            } else {
+                headers["Accept-Language"] = "\(lang);q=0.5"
+            }
+            request.addValue(headers["Accept-Language"]!, forHTTPHeaderField: "Accept-Language")
+        }
+    }
+
+    public func getRequestDataAsJson(_ data: JSValue) throws -> Data? {
+        // We need to check if the JSON is valid before attempting to serialize, as JSONSerialization.data will not throw an exception that can be caught, and will cause the application to crash if it fails.
+        if JSONSerialization.isValidJSONObject(data) {
+            return try JSONSerialization.data(withJSONObject: data)
+        } else {
+            throw CapacitorUrlRequest.CapacitorUrlRequestError.serializationError("[ data ] argument for request of content-type [ application/json ] must be serializable to JSON")
+        }
+    }
+
+    public func getRequestDataAsFormUrlEncoded(_ data: JSValue) throws -> Data? {
+        guard var components = URLComponents(url: request.url!, resolvingAgainstBaseURL: false) else { return nil }
+        components.queryItems = []
+
+        guard let obj = data as? JSObject else {
+            // Throw, other data types explicitly not supported
+            throw CapacitorUrlRequestError.serializationError("[ data ] argument for request with content-type [ multipart/form-data ] may only be a plain javascript object")
+        }
+
+        let allowed = CharacterSet(charactersIn: "-._*").union(.alphanumerics)
+
+        obj.keys.forEach { (key: String) in
+            let value = obj[key] as? String ?? ""
+            components.queryItems?.append(URLQueryItem(name: key.addingPercentEncoding(withAllowedCharacters: allowed)?.replacingOccurrences(of: "%20", with: "+") ?? key, value: value.addingPercentEncoding(withAllowedCharacters: allowed)?.replacingOccurrences(of: "%20", with: "+")))
+        }
+
+        if components.query != nil {
+            return Data(components.query!.utf8)
+        }
+
+        return nil
+    }
+
+    public func getRequestDataAsMultipartFormData(_ data: JSValue, _ contentType: String) throws -> Data {
+        guard let obj = data as? JSObject else {
+            // Throw, other data types explicitly not supported.
+            throw CapacitorUrlRequestError.serializationError("[ data ] argument for request with content-type [ application/x-www-form-urlencoded ] may only be a plain javascript object")
+        }
+
+        let strings: [String: String] = obj.compactMapValues { any in
+            any as? String
+        }
+
+        var data = Data()
+        var boundary = UUID().uuidString
+        if contentType.contains("="), let contentBoundary = contentType.components(separatedBy: "=").last {
+            boundary = contentBoundary
+        } else {
+            overrideContentType(boundary)
+        }
+        strings.forEach { key, value in
+            data.append("\r\n--\(boundary)\r\n".data(using: .utf8)!)
+            data.append("Content-Disposition: form-data; name=\"\(key)\"\r\n\r\n".data(using: .utf8)!)
+            data.append(value.data(using: .utf8)!)
+        }
+        data.append("\r\n--\(boundary)--\r\n".data(using: .utf8)!)
+
+        return data
+    }
+
+    private func overrideContentType(_ boundary: String) {
+        let contentType = "multipart/form-data; boundary=\(boundary)"
+        request.setValue(contentType, forHTTPHeaderField: "Content-Type")
+        headers["Content-Type"] = contentType
+    }
+
+    public func getRequestDataAsString(_ data: JSValue) throws -> Data {
+        guard let stringData = data as? String else {
+            throw CapacitorUrlRequestError.serializationError("[ data ] argument could not be parsed as string")
+        }
+        return Data(stringData.utf8)
+    }
+
+    public func getRequestHeader(_ index: String) -> Any? {
+        var normalized = [:] as [String: Any]
+        self.headers.keys.forEach { (key: String) in
+            normalized[key.lowercased()] = self.headers[key]
+        }
+
+        return normalized[index.lowercased()]
+    }
+
+    public func getRequestDataFromFormData(_ data: JSValue, _ contentType: String) throws -> Data? {
+        guard let list = data as? JSArray else {
+            // Throw, other data types explicitly not supported.
+            throw CapacitorUrlRequestError.serializationError("Data must be an array for FormData")
+        }
+        var data = Data()
+        var boundary = UUID().uuidString
+        if contentType.contains("="), let contentBoundary = contentType.components(separatedBy: "=").last {
+            boundary = contentBoundary
+        } else {
+            overrideContentType(boundary)
+        }
+        for entry in list {
+            guard let item = entry as? [String: String] else {
+                throw CapacitorUrlRequestError.serializationError("Data must be an array for FormData")
+            }
+
+            let type = item["type"]
+            let key = item["key"]
+            let value = item["value"]!
+
+            if type == "base64File" {
+                let fileName = item["fileName"]
+                let fileContentType = item["contentType"]
+
+                data.append("--\(boundary)\r\n".data(using: .utf8)!)
+                data.append("Content-Disposition: form-data; name=\"\(key!)\"; filename=\"\(fileName!)\"\r\n".data(using: .utf8)!)
+                data.append("Content-Type: \(fileContentType!)\r\n".data(using: .utf8)!)
+                data.append("Content-Transfer-Encoding: binary\r\n".data(using: .utf8)!)
+                data.append("\r\n".data(using: .utf8)!)
+
+                data.append(Data(base64Encoded: value)!)
+
+                data.append("\r\n".data(using: .utf8)!)
+            } else if type == "string" {
+                data.append("--\(boundary)\r\n".data(using: .utf8)!)
+                data.append("Content-Disposition: form-data; name=\"\(key!)\"\r\n".data(using: .utf8)!)
+                data.append("\r\n".data(using: .utf8)!)
+                data.append(value.data(using: .utf8)!)
+                data.append("\r\n".data(using: .utf8)!)
+            }
+        }
+        data.append("--\(boundary)--\r\n".data(using: .utf8)!)
+
+        return data
+    }
+
+    public func getRequestData(_ body: JSValue, _ contentType: String, _ dataType: String? = nil) throws -> Data? {
+        if dataType == "file" {
+            guard let stringData = body as? String else {
+                throw CapacitorUrlRequestError.serializationError("[ data ] argument could not be parsed as string")
+            }
+            return Data(base64Encoded: stringData)
+        } else if dataType == "formData" {
+            return try getRequestDataFromFormData(body, contentType)
+        }
+
+        // If data can be parsed directly as a string, return that without processing.
+        if let strVal = try? getRequestDataAsString(body) {
+            return strVal
+        } else if contentType.contains("application/json") {
+            return try getRequestDataAsJson(body)
+        } else if contentType.contains("application/x-www-form-urlencoded") {
+            return try getRequestDataAsFormUrlEncoded(body)
+        } else if contentType.contains("multipart/form-data") {
+            return try getRequestDataAsMultipartFormData(body, contentType)
+        } else {
+            throw CapacitorUrlRequestError.serializationError("[ data ] argument could not be parsed for content type [ \(contentType) ]")
+        }
+    }
+
+    @available(*, deprecated, message: "Use newer function with passed headers of type [String: Any]")
+    public func setRequestHeaders(_ headers: [String: String]) {
+        headers.keys.forEach { (key: String) in
+            let value = headers[key]
+            request.addValue(value!, forHTTPHeaderField: key)
+            self.headers[key] = value
+        }
+    }
+
+    public func setRequestHeaders(_ headers: [String: Any]) {
+        headers.keys.forEach { (key: String) in
+            let value = headers[key]
+            request.setValue("\(value!)", forHTTPHeaderField: key)
+            self.headers[key] = "\(value!)"
+        }
+    }
+
+    public func setRequestBody(_ body: JSValue, _ dataType: String? = nil) throws {
+        let contentType = self.getRequestHeader("Content-Type") as? String
+
+        if contentType != nil {
+            request.httpBody = try getRequestData(body, contentType!, dataType)
+        }
+    }
+
+    public func setContentType(_ data: String?) {
+        request.setValue(data, forHTTPHeaderField: "Content-Type")
+    }
+
+    public func setTimeout(_ timeout: TimeInterval) {
+        request.timeoutInterval = timeout
+    }
+
+    public func getUrlRequest() -> URLRequest {
+        return request
+    }
+
+    open func urlSession(_ session: URLSession, task: URLSessionTask, willPerformHTTPRedirection response: HTTPURLResponse, newRequest request: URLRequest, completionHandler: @escaping (URLRequest?) -> Void) {
+        completionHandler(nil)
+    }
+
+    open func getUrlSession(_ call: CAPPluginCall) -> URLSession {
+        let disableRedirects = call.getBool("disableRedirects") ?? false
+        if !disableRedirects {
+            return URLSession.shared
+        }
+        return URLSession(configuration: URLSessionConfiguration.default, delegate: self, delegateQueue: nil)
+    }
+}

package/Capacitor/Capacitor/Plugins/Console.swift

@@ -0,0 +1,16 @@
+import Foundation
+
+@objc(CAPConsolePlugin)
+public class CAPConsolePlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "CAPConsolePlugin"
+    public let jsName = "Console"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "log", returnType: CAPPluginReturnNone)
+    ]
+
+    @objc public func log(_ call: CAPPluginCall) {
+        let message = call.getString("message") ?? ""
+        let level = call.getString("level") ?? "log"
+        CAPLog.print("⚡️  [\(level)] - \(message)")
+    }
+}

package/Capacitor/Capacitor/Plugins/HttpRequestHandler.swift

@@ -0,0 +1,236 @@
+import Foundation
+
+/// See https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/responseType
+public enum ResponseType: String {
+    case arrayBuffer = "arraybuffer"
+    case blob = "blob"
+    case document = "document"
+    case json = "json"
+    case text = "text"
+
+    public static let `default`: ResponseType = .text
+
+    public init(string: String?) {
+        guard let string = string else {
+            self = .default
+            return
+        }
+
+        guard let responseType = ResponseType(rawValue: string.lowercased()) else {
+            self = .default
+            return
+        }
+
+        self = responseType
+    }
+}
+
+/// Helper that safely parses JSON Data. Otherwise returns an error (without throwing)
+/// - Parameters:
+///     - data: The JSON Data to parse
+/// - Returns: The parsed value or an error
+func tryParseJson(_ data: Data) -> Any {
+    do {
+        return try JSONSerialization.jsonObject(with: data, options: [.mutableContainers, .fragmentsAllowed])
+    } catch {
+        return error.localizedDescription
+    }
+}
+
+/// Helper to convert the headers dictionary to lower case keys. This allows case-insensitive querying in the bridge javascript.
+/// - Parameters:
+///     - headers: The headers as dictionary. The type is unspecific because the incoming headers are coming from the
+///       allHeaderFields property of the HttpResponse.
+/// - Returns: The modified headers dictionary with lowercase keys
+private func lowerCaseHeaderDictionary(_ headers: [AnyHashable: Any]) -> [String: Any] {
+    // Lowercases the key of the headers dictionary.
+    return Dictionary(uniqueKeysWithValues: headers.map({ (key: AnyHashable, value: Any) in
+        return (String(describing: key).lowercased(), value)
+    }))
+}
+
+open class HttpRequestHandler {
+    open class CapacitorHttpRequestBuilder {
+        public var url: URL?
+        public var method: String?
+        public var params: [String: String]?
+        open var request: CapacitorUrlRequest?
+
+        public init() { }
+
+        /// Set the URL of the HttpRequest
+        /// - Throws: an error of URLError if the urlString cannot be parsed
+        /// - Parameters:
+        ///     - urlString: The URL value to parse
+        /// - Returns: self to continue chaining functions
+        public func setUrl(_ urlString: String) throws -> CapacitorHttpRequestBuilder {
+            guard let url = URL(string: urlString) else {
+                throw URLError(.badURL)
+            }
+            self.url = url
+            return self
+        }
+
+        public func setMethod(_ method: String) -> CapacitorHttpRequestBuilder {
+            self.method = method
+            return self
+        }
+
+        public func setUrlParams(_ params: [String: Any], _ shouldEncodeUrlParams: Bool = true) -> CapacitorHttpRequestBuilder {
+            if params.count != 0 {
+                // swiftlint:disable force_cast
+                var cmps = URLComponents(url: url!, resolvingAgainstBaseURL: true)
+                if cmps?.queryItems == nil {
+                    cmps?.queryItems = []
+                }
+
+                if shouldEncodeUrlParams {
+                    var urlSafeParams: [URLQueryItem] = []
+                    for (key, value) in params {
+                        if let arr = value as? [String] {
+                            arr.forEach { str in
+                                urlSafeParams.append(URLQueryItem(name: key, value: str))
+                            }
+                        } else {
+                            urlSafeParams.append(URLQueryItem(name: key, value: (value as! String)))
+                        }
+                    }
+                    cmps!.queryItems?.append(contentsOf: urlSafeParams)
+                } else {
+                    cmps?.query = params.flatMap { key, value -> [String] in
+                        if let arrayValue = value as? [String] {
+                            return arrayValue.map { "\(key)=\($0)" }
+                        } else {
+                            return ["\(key)=\(value)"]
+                        }
+                    }.joined(separator: "&")
+                }
+                url = cmps!.url!
+            }
+            return self
+        }
+
+        open func openConnection() -> CapacitorHttpRequestBuilder {
+            request = CapacitorUrlRequest(url!, method: method!)
+            return self
+        }
+
+        public func build() -> CapacitorUrlRequest {
+            return request!
+        }
+    }
+
+    public static func setCookiesFromResponse(_ response: HTTPURLResponse, _ config: InstanceConfiguration?) {
+        let headers = response.allHeaderFields
+        if let cookies = headers["Set-Cookie"] as? String {
+            for cookie in cookies.components(separatedBy: ",") {
+                let domainComponents = cookie.lowercased().components(separatedBy: "domain=")
+                if domainComponents.count > 1 {
+                    CapacitorCookieManager(config).setCookie(
+                        domainComponents[1].components(separatedBy: ";")[0],
+                        cookie
+                    )
+                } else {
+                    CapacitorCookieManager(config).setCookie("", cookie)
+                }
+            }
+        }
+        CapacitorCookieManager(config).syncCookiesToWebView()
+    }
+
+    public static func buildResponse(_ data: Data?, _ response: HTTPURLResponse, responseType: ResponseType = .default) -> [String: Any] {
+        var output = [:] as [String: Any]
+
+        output["status"] = response.statusCode
+
+        // HTTP Headers are case insensitive. The allHeaderFields dictionary returned by Apple Foundation Code has its keys capitalized.
+        // According to the documentation at https://developer.apple.com/documentation/foundation/httpurlresponse/1417930-allheaderfields
+        // "HTTP headers are case insensitive. To simplify your code, URL Loading System canonicalizes certain header field names into
+        // their standard form. For example, if the server sends a content-length header, it’s automatically adjusted to be Content-Length."
+        // To handle the case insevitivy, we are converting the header keys to lower case here. When querying for headers in the native bridge,
+        // we are lowercasing the key as well.
+        output["headers"] = lowerCaseHeaderDictionary(response.allHeaderFields)
+        output["url"] = response.url?.absoluteString
+
+        guard let data = data else {
+            output["data"] = ""
+            return output
+        }
+
+        let contentType = (response.allHeaderFields["Content-Type"] as? String ?? "application/default").lowercased()
+
+        if contentType.contains("application/json") || responseType == .json {
+            output["data"] = tryParseJson(data)
+        } else if responseType == .arrayBuffer || responseType == .blob {
+            output["data"] = data.base64EncodedString()
+        } else if responseType == .document || responseType == .text || responseType == .default {
+            output["data"] = String(data: data, encoding: .utf8)
+        }
+
+        return output
+    }
+
+    public static func request(_ call: CAPPluginCall, _ httpMethod: String?, _ config: InstanceConfiguration?) throws {
+        guard var urlString = call.getString("url") else { throw URLError(.badURL) }
+        let method = httpMethod ?? call.getString("method", "GET")
+
+        var headers = (call.getObject("headers") ?? [:]) as [String: Any]
+        let params = (call.getObject("params") ?? [:]) as [String: Any]
+        let responseType = call.getString("responseType") ?? "text"
+        let connectTimeout = call.getDouble("connectTimeout")
+        let shouldEncodeUrlParams = call.getBool("shouldEncodeUrlParams", true)
+        let readTimeout = call.getDouble("readTimeout")
+        let dataType = call.getString("dataType") ?? "any"
+
+        if urlString == urlString.removingPercentEncoding {
+            guard let encodedUrlString = urlString.addingPercentEncoding(withAllowedCharacters: .urlQueryAllowed)  else { throw URLError(.badURL) }
+            urlString = encodedUrlString
+        }
+
+        let request = try CapacitorHttpRequestBuilder()
+            .setUrl(urlString)
+            .setMethod(method)
+            .setUrlParams(params, shouldEncodeUrlParams)
+            .openConnection()
+            .build()
+
+        if let userAgentString = config?.overridenUserAgentString, headers["User-Agent"] == nil, headers["user-agent"] == nil {
+            headers["User-Agent"] = userAgentString
+        }
+
+        request.setRequestHeaders(headers)
+
+        // Timeouts in iOS are in seconds. So read the value in millis and divide by 1000
+        let timeout = (connectTimeout ?? readTimeout ?? 600000.0) / 1000.0
+        request.setTimeout(timeout)
+
+        if let data = call.options["data"] as? JSValue {
+            do {
+                try request.setRequestBody(data, dataType)
+            } catch {
+                // Explicitly reject if the http request body was not set successfully,
+                // so as to not send a known malformed request, and to provide the developer with additional context.
+                call.reject(error.localizedDescription, (error as NSError).domain, error, nil)
+                return
+            }
+        }
+
+        let urlRequest = request.getUrlRequest()
+        let urlSession = request.getUrlSession(call)
+        let task = urlSession.dataTask(with: urlRequest) { (data, response, error) in
+            urlSession.invalidateAndCancel()
+
+            if let error = error {
+                call.reject(error.localizedDescription, (error as NSError).domain, error, nil)
+                return
+            }
+
+            setCookiesFromResponse(response as! HTTPURLResponse, config)
+
+            let type = ResponseType(rawValue: responseType) ?? .default
+            call.resolve(self.buildResponse(data, response as! HTTPURLResponse, responseType: type))
+        }
+
+        task.resume()
+    }
+}