@capacitor/ios 3.5.1 → 3.8.0

package/CHANGELOG.md

@@ -3,6 +3,46 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [3.8.0](https://github.com/ionic-team/capacitor/compare/3.7.0...3.8.0) (2022-09-08)
+
+
+### Features
+
+* **ios:** Add `setServerBasePath(_:)` to CAPBridgeProtocol ([#5860](https://github.com/ionic-team/capacitor/issues/5860)) ([#5892](https://github.com/ionic-team/capacitor/issues/5892)) ([9954281](https://github.com/ionic-team/capacitor/commit/995428129de9c06e199b67264b9840bb4a87939e))
+
+
+
+
+
+# [3.7.0](https://github.com/ionic-team/capacitor/compare/3.6.0...3.7.0) (2022-08-01)
+
+
+### Features
+
+* **ios:** Add `setServerBasePath(path:)` to CAPWebView ([#5742](https://github.com/ionic-team/capacitor/issues/5742)) ([#5748](https://github.com/ionic-team/capacitor/issues/5748)) ([9c25aad](https://github.com/ionic-team/capacitor/commit/9c25aad0ca8f97416753e7589a92efa401ad75bc))
+* **ios:** Add overrideable router var for CAPWebView. ([#5743](https://github.com/ionic-team/capacitor/issues/5743)) ([#5760](https://github.com/ionic-team/capacitor/issues/5760)) ([6ba286d](https://github.com/ionic-team/capacitor/commit/6ba286d0429f70c9d2df9132f38c04f156f572b6))
+* Add CapWebView  ([#5715](https://github.com/ionic-team/capacitor/issues/5715)) ([#5730](https://github.com/ionic-team/capacitor/issues/5730)) ([bb54ac1](https://github.com/ionic-team/capacitor/commit/bb54ac1c9973dc01262119f0b0925f67c942264c))
+
+
+
+
+
+# [3.6.0](https://github.com/ionic-team/capacitor/compare/3.5.1...3.6.0) (2022-06-17)
+
+
+### Bug Fixes
+
+* **ios:** Use `URL(fileURLWithPath:)` instead of `URL(string:)` ([#5603](https://github.com/ionic-team/capacitor/issues/5603)) ([5fac1b2](https://github.com/ionic-team/capacitor/commit/5fac1b2da5aa5882087716cb2aa862d89173f4a1))
+
+
+### Features
+
+* **iOS, Android:** add AppUUID Lib for plugins ([#5690](https://github.com/ionic-team/capacitor/issues/5690)) ([05e76cf](https://github.com/ionic-team/capacitor/commit/05e76cf526a44e07fa75f9482fa2223a13918638))
+
+
+
+
+
 ## [3.5.1](https://github.com/ionic-team/capacitor/compare/3.5.0...3.5.1) (2022-05-04)
 
 **Note:** Version bump only for package @capacitor/ios

package/Capacitor/Capacitor/AppUUID.swift

@@ -0,0 +1,53 @@
+import CommonCrypto
+import Foundation
+
+private func hexString(_ iterator: Array<UInt8>.Iterator) -> String {
+    return iterator.map { String(format: "%02x", $0) }.joined()
+}
+
+extension Data {
+    public var sha256: String {
+        var digest = [UInt8](repeating: 0, count: Int(CC_SHA256_DIGEST_LENGTH))
+        self.withUnsafeBytes { bytes in
+            _ = CC_SHA256(bytes.baseAddress, CC_LONG(self.count), &digest)
+        }
+        return hexString(digest.makeIterator())
+    }
+}
+
+public class AppUUID {
+    private static let key: String = "CapacitorAppUUID"
+
+    public static func getAppUUID() -> String {
+        assertAppUUID()
+        return readUUID()
+    }
+
+    public static func regenerateAppUUID() {
+        let uuid = generateUUID()
+        writeUUID(uuid)
+    }
+
+    private static func assertAppUUID() {
+        let uuid = readUUID()
+        if uuid == "" {
+            regenerateAppUUID()
+        }
+    }
+
+    private static func generateUUID() -> String {
+        let uuid: String = UUID.init().uuidString
+        return uuid.data(using: .utf8)!.sha256
+    }
+
+    private static func readUUID() -> String {
+        let defaults = UserDefaults.standard
+        return defaults.string(forKey: key) ?? ""
+    }
+
+    private static func writeUUID(_ uuid: String) {
+        let defaults = UserDefaults.standard
+        defaults.set(uuid, forKey: key)
+    }
+
+}

package/Capacitor/Capacitor/CAPBridgeProtocol.swift

@@ -70,6 +70,7 @@ import WebKit
     // MARK: - Paths, Files, Assets
     func localURL(fromWebURL webURL: URL?) -> URL?
     func portablePath(fromLocalURL localURL: URL?) -> URL?
+    func setServerBasePath(_ path: String)
 
     // MARK: - View Presentation
     func showAlertWith(title: String, message: String, buttonTitle: String)

package/Capacitor/Capacitor/CAPBridgeViewController.swift

@@ -258,16 +258,10 @@ extension CAPBridgeViewController {
     }
 
     @objc public func setServerBasePath(path: String) {
-        let url = URL(fileURLWithPath: path, isDirectory: true)
-        guard let capBridge = capacitorBridge, FileManager.default.fileExists(atPath: url.path) else {
-            return
-        }
-        capBridge.config = capBridge.config.updatingAppLocation(url)
-        capBridge.webViewAssetHandler.setAssetPath(url.path)
-        if let url = capacitorBridge?.config.serverURL {
-            DispatchQueue.main.async { [weak self] in
-                _ = self?.webView?.load(URLRequest(url: url))
-            }
+        guard let capBridge = capacitorBridge else { return }
+        capBridge.setServerBasePath(path)
+        DispatchQueue.main.async { [weak self] in
+            _ = self?.webView?.load(URLRequest(url: capBridge.config.serverURL))
         }
     }
 }

package/Capacitor/Capacitor/CAPWebView.swift

@@ -0,0 +1,242 @@
+import Foundation
+import WebKit
+import UIKit
+
+open class CAPWebView: UIView {
+    lazy var webView: WKWebView = createWebView(
+        with: configuration,
+        assetHandler: assetHandler,
+        delegationHandler: delegationHandler
+    )
+
+    private lazy var capacitorBridge = CapacitorBridge(
+        with: configuration,
+        delegate: self,
+        cordovaConfiguration: configDescriptor.cordovaConfiguration,
+        assetHandler: assetHandler,
+        delegationHandler: delegationHandler
+    )
+
+    public final var bridge: CAPBridgeProtocol {
+        return capacitorBridge
+    }
+
+    private lazy var configDescriptor = instanceDescriptor()
+    private lazy var configuration = InstanceConfiguration(with: configDescriptor, isDebug: CapacitorBridge.isDevEnvironment)
+
+    private lazy var assetHandler: WebViewAssetHandler = {
+        let handler = WebViewAssetHandler(router: router)
+        handler.setAssetPath(configuration.appLocation.path)
+        return handler
+    }()
+
+    private lazy var delegationHandler = WebViewDelegationHandler()
+
+    open var router: Router { _Router() }
+
+    public required init?(coder: NSCoder) {
+        super.init(coder: coder)
+        setup()
+    }
+
+    public init() {
+        super.init(frame: .zero)
+        setup()
+    }
+
+    private func setup() {
+        CAPLog.enableLogging = configuration.loggingEnabled
+        logWarnings(for: configDescriptor)
+
+        if configDescriptor.instanceType == .fixed { updateBinaryVersion() }
+
+        addSubview(webView)
+        webView.translatesAutoresizingMaskIntoConstraints = false
+        NSLayoutConstraint.activate([
+            webView.topAnchor.constraint(equalTo: topAnchor),
+            webView.bottomAnchor.constraint(equalTo: bottomAnchor),
+            webView.leadingAnchor.constraint(equalTo: leadingAnchor),
+            webView.trailingAnchor.constraint(equalTo: trailingAnchor)
+        ])
+
+        guard FileManager.default.fileExists(atPath: bridge.config.appStartFileURL.path) else { fatalLoadError() }
+        capacitorDidLoad()
+
+        let url = bridge.config.appStartServerURL
+        CAPLog.print("⚡️  Loading app at \(url.absoluteString)")
+        capacitorBridge.webViewDelegationHandler.willLoadWebview(webView)
+        _ = webView.load(URLRequest(url: url))
+    }
+
+    public lazy final var isNewBinary: Bool = {
+        if let curVersionCode = Bundle.main.infoDictionary?["CFBundleVersion"] as? String,
+           let curVersionName = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String {
+            if let lastVersionCode = UserDefaults.standard.string(forKey: "lastBinaryVersionCode"),
+               let lastVersionName = UserDefaults.standard.string(forKey: "lastBinaryVersionName") {
+                return (curVersionCode.isEqual(lastVersionCode) == false || curVersionName.isEqual(lastVersionName) == false)
+            }
+        }
+        return false
+    }()
+
+    open func instanceDescriptor() -> InstanceDescriptor {
+        let descriptor = InstanceDescriptor.init()
+        if !isNewBinary && !descriptor.cordovaDeployDisabled {
+            if let persistedPath = UserDefaults.standard.string(forKey: "serverBasePath"), !persistedPath.isEmpty {
+                if let libPath = NSSearchPathForDirectoriesInDomains(.libraryDirectory, .userDomainMask, true).first {
+                    descriptor.appLocation = URL(fileURLWithPath: libPath, isDirectory: true)
+                        .appendingPathComponent("NoCloud")
+                        .appendingPathComponent("ionic_built_snapshots")
+                        .appendingPathComponent(URL(fileURLWithPath: persistedPath, isDirectory: true).lastPathComponent)
+                }
+            }
+        }
+        return descriptor
+    }
+
+    /**
+     Allows any additional configuration to be performed. The `webView` and `bridge` properties will be set by this point.
+
+     - Note: This is called before the webview has been added to the view hierarchy. Not all operations may be possible at
+     this time.
+     */
+    open func capacitorDidLoad() {
+    }
+
+    open func loadInitialContext(_ userContentController: WKUserContentController) {
+        CAPLog.print("in loadInitialContext base")
+    }
+
+    public func setServerBasePath(path: String) {
+        let url = URL(fileURLWithPath: path, isDirectory: true)
+        guard FileManager.default.fileExists(atPath: url.path) else { return }
+
+        capacitorBridge.config = capacitorBridge.config.updatingAppLocation(url)
+        capacitorBridge.webViewAssetHandler.setAssetPath(url.path)
+
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            _ = self.webView.load(URLRequest(url: self.capacitorBridge.config.serverURL))
+        }
+    }
+}
+
+extension CAPWebView {
+
+    open func webViewConfiguration(for instanceConfiguration: InstanceConfiguration) -> WKWebViewConfiguration {
+        let webViewConfiguration = WKWebViewConfiguration()
+        webViewConfiguration.allowsInlineMediaPlayback = true
+        webViewConfiguration.suppressesIncrementalRendering = false
+        webViewConfiguration.allowsAirPlayForMediaPlayback = true
+        webViewConfiguration.mediaTypesRequiringUserActionForPlayback = []
+        if let appendUserAgent = instanceConfiguration.appendedUserAgentString {
+            if let appName = webViewConfiguration.applicationNameForUserAgent {
+                webViewConfiguration.applicationNameForUserAgent = "\(appName)  \(appendUserAgent)"
+            } else {
+                webViewConfiguration.applicationNameForUserAgent = appendUserAgent
+            }
+        }
+        return webViewConfiguration
+    }
+
+    private func createWebView(with configuration: InstanceConfiguration, assetHandler: WebViewAssetHandler, delegationHandler: WebViewDelegationHandler) -> WKWebView {
+        // set the cookie policy
+        HTTPCookieStorage.shared.cookieAcceptPolicy = HTTPCookie.AcceptPolicy.always
+        // setup the web view configuration
+        let webViewConfig = webViewConfiguration(for: configuration)
+        webViewConfig.setURLSchemeHandler(assetHandler, forURLScheme: configuration.localURL.scheme ?? InstanceDescriptorDefaults.scheme)
+        webViewConfig.userContentController = delegationHandler.contentController
+        // create the web view and set its properties
+        loadInitialContext(webViewConfig.userContentController)
+        let webView = WKWebView(frame: .zero, configuration: webViewConfig)
+        webView.scrollView.bounces = false
+        webView.scrollView.contentInsetAdjustmentBehavior = configuration.contentInsetAdjustmentBehavior
+        webView.allowsLinkPreview = configuration.allowLinkPreviews
+        webView.configuration.preferences.setValue(true, forKey: "allowFileAccessFromFileURLs")
+        webView.scrollView.isScrollEnabled = configuration.scrollingEnabled
+
+        if let overrideUserAgent = configuration.overridenUserAgentString {
+            webView.customUserAgent = overrideUserAgent
+        }
+
+        if let backgroundColor = configuration.backgroundColor {
+            self.backgroundColor = backgroundColor
+            webView.backgroundColor = backgroundColor
+            webView.scrollView.backgroundColor = backgroundColor
+        } else if #available(iOS 13, *) {
+            // Use the system background colors if background is not set by user
+            self.backgroundColor = UIColor.systemBackground
+            webView.backgroundColor = UIColor.systemBackground
+            webView.scrollView.backgroundColor = UIColor.systemBackground
+        }
+
+        // set our delegates
+        webView.uiDelegate = delegationHandler
+        webView.navigationDelegate = delegationHandler
+        return webView
+    }
+
+    private func logWarnings(for descriptor: InstanceDescriptor) {
+        if descriptor.warnings.contains(.missingAppDir) {
+            CAPLog.print("⚡️  ERROR: Unable to find application directory at: \"\(descriptor.appLocation.absoluteString)\"!")
+        }
+        if descriptor.instanceType == .fixed {
+            if descriptor.warnings.contains(.missingFile) {
+                CAPLog.print("Unable to find capacitor.config.json, make sure it exists and run npx cap copy.")
+            }
+            if descriptor.warnings.contains(.invalidFile) {
+                CAPLog.print("Unable to parse capacitor.config.json. Make sure it's valid JSON.")
+            }
+            if descriptor.warnings.contains(.missingCordovaFile) {
+                CAPLog.print("Unable to find config.xml, make sure it exists and run npx cap copy.")
+            }
+            if descriptor.warnings.contains(.invalidCordovaFile) {
+                CAPLog.print("Unable to parse config.xml. Make sure it's valid XML.")
+            }
+        }
+    }
+
+    private func updateBinaryVersion() {
+        guard isNewBinary else {
+            return
+        }
+        guard let versionCode = Bundle.main.infoDictionary?["CFBundleVersion"] as? String,
+              let versionName = Bundle.main.infoDictionary?["CFBundleShortVersionString"] as? String else {
+            return
+        }
+        let prefs = UserDefaults.standard
+        prefs.set(versionCode, forKey: "lastBinaryVersionCode")
+        prefs.set(versionName, forKey: "lastBinaryVersionName")
+        prefs.set("", forKey: "serverBasePath")
+        prefs.synchronize()
+    }
+
+    private func fatalLoadError() -> Never {
+        printLoadError()
+        exit(1)
+    }
+
+    private func printLoadError() {
+        let fullStartPath = capacitorBridge.config.appStartFileURL.path
+
+        CAPLog.print("⚡️  ERROR: Unable to load \(fullStartPath)")
+        CAPLog.print("⚡️  This file is the root of your web app and must exist before")
+        CAPLog.print("⚡️  Capacitor can run. Ensure you've run capacitor copy at least")
+        CAPLog.print("⚡️  or, if embedding, that this directory exists as a resource directory.")
+    }
+}
+
+extension CAPWebView: CAPBridgeDelegate {
+    internal var bridgedWebView: WKWebView? {
+        return webView
+    }
+
+    internal var bridgedViewController: UIViewController? {
+        // search for the parent view controller
+        var object = self.next
+        while !(object is UIViewController) && object != nil {
+            object = object?.next
+        }
+        return object as? UIViewController
+    }
+}

package/Capacitor/Capacitor/CapacitorBridge.swift

@@ -156,6 +156,13 @@ internal class CapacitorBridge: NSObject, CAPBridgeProtocol {
         statusBarAnimation = animation
     }
 
+    public func setServerBasePath(_ path: String) {
+        let url = URL(fileURLWithPath: path, isDirectory: true)
+        guard FileManager.default.fileExists(atPath: url.path) else { return }
+        config = config.updatingAppLocation(url)
+        webViewAssetHandler.setAssetPath(url.path)
+    }
+
     // MARK: - Static Methods
 
     /**

package/Capacitor/Capacitor/JSTypes.swift

@@ -125,6 +125,15 @@ public protocol JSValueContainer: JSStringContainer, JSBoolContainer, JSIntConta
 }
 
 extension JSValueContainer {
+    public func getValue(_ key: String) -> JSValue? {
+        return jsObjectRepresentation[key]
+    }
+
+    @available(*, message: "All values returned conform to JSValue, use getValue(_:) instead.", renamed: "getValue(_:)")
+    public func getAny(_ key: String) -> Any? {
+        return getValue(key)
+    }
+
     public func getString(_ key: String) -> String? {
         return jsObjectRepresentation[key] as? String
     }

package/Capacitor/Capacitor/Router.swift

@@ -10,18 +10,20 @@ import Foundation
 
 public protocol Router {
     func route(for path: String) -> String
+    var basePath: String { get set }
 }
 
 // swiftlint:disable:next type_name
 internal struct _Router: Router {
+    var basePath: String = ""
     func route(for path: String) -> String {
-        let pathUrl = URL(string: path)
+        let pathUrl = URL(fileURLWithPath: path)
        
-        // if the pathUrl is null, then it is an invalid url (meaning it is empty or just plain invalid) then we want to route to /index.html
-        if pathUrl?.pathExtension.isEmpty ?? true {
-            return "/index.html"
+        // If there's no path extension it also means the path is empty or a SPA route
+        if pathUrl.pathExtension.isEmpty {
+            return basePath + "/index.html"
         }
         
-        return path
+        return basePath + path
     }
 }

package/Capacitor/Capacitor/WebViewAssetHandler.swift

@@ -3,8 +3,7 @@ import MobileCoreServices
 
 @objc(CAPWebViewAssetHandler)
 internal class WebViewAssetHandler: NSObject, WKURLSchemeHandler {
-    private let router: Router
-    private var basePath: String = ""
+    private var router: Router
     
     init(router: Router) {
         self.router = router
@@ -12,19 +11,18 @@ internal class WebViewAssetHandler: NSObject, WKURLSchemeHandler {
     }
 
     func setAssetPath(_ assetPath: String) {
-        self.basePath = assetPath
+        router.basePath = assetPath
     }
 
     func webView(_ webView: WKWebView, start urlSchemeTask: WKURLSchemeTask) {
-        var startPath = self.basePath
+        let startPath: String
         let url = urlSchemeTask.request.url!
         let stringToLoad = url.path
         
-        let resolvedRoute = router.route(for: stringToLoad)
         if stringToLoad.starts(with: CapacitorBridge.fileStartIdentifier) {
             startPath = stringToLoad.replacingOccurrences(of: CapacitorBridge.fileStartIdentifier, with: "")
         } else {
-            startPath.append(resolvedRoute)
+            startPath = router.route(for: stringToLoad)
         }
         
         let localUrl = URL.init(string: url.absoluteString)!

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capacitor/ios",
-  "version": "3.5.1",
+  "version": "3.8.0",
   "description": "Capacitor: Cross-platform apps with JavaScript and the web",
   "homepage": "https://capacitorjs.com",
   "author": "Ionic Team <hi@ionic.io> (https://ionic.io)",
@@ -24,10 +24,10 @@
     "xc:build:CapacitorCordova": "cd CapacitorCordova && xcodebuild && cd .."
   },
   "peerDependencies": {
-    "@capacitor/core": "^3.5.0"
+    "@capacitor/core": "^3.8.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "009064dbf01cbc5900bbc16053b6d7535ad4c2b4"
+  "gitHead": "8ec9df5d4a8c5760c834c7706aaedea1b402108b"
 }