@capacitor-plus/ios 8.0.0-beta.0

package/Capacitor/Capacitor/CAPBridgeViewController.swift

@@ -0,0 +1,384 @@
+import UIKit
+import WebKit
+import Cordova
+
+@objc open class CAPBridgeViewController: UIViewController {
+    private var capacitorBridge: CapacitorBridge?
+    public final var bridge: CAPBridgeProtocol? {
+        return capacitorBridge
+    }
+
+    public fileprivate(set) var webView: WKWebView?
+
+    public var isStatusBarVisible = true
+    public var statusBarStyle: UIStatusBarStyle = .default
+    public var statusBarAnimation: UIStatusBarAnimation = .fade
+    @objc public var supportedOrientations: [Int] = []
+
+    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 = KeyValueStore.standard["lastBinaryVersionCode", as: String.self],
+               let lastVersionName = KeyValueStore.standard["lastBinaryVersionName", as: String.self] {
+                return curVersionCode != lastVersionCode || curVersionName != lastVersionName
+            }
+            return true
+        }
+        return false
+    }()
+
+    override public final func loadView() {
+        // load the configuration and set the logging flag
+        let configDescriptor = instanceDescriptor()
+        let configuration = InstanceConfiguration(with: configDescriptor, isDebug: CapacitorBridge.isDevEnvironment)
+        CAPLog.enableLogging = configuration.loggingEnabled
+        logWarnings(for: configDescriptor)
+
+        setStatusBarDefaults()
+        setScreenOrientationDefaults()
+
+        // get the web view
+        let assetHandler = WebViewAssetHandler(router: router())
+        assetHandler.setAssetPath(configuration.appLocation.path)
+        assetHandler.setServerUrl(configuration.serverURL)
+        let delegationHandler = WebViewDelegationHandler()
+        prepareWebView(with: configuration, assetHandler: assetHandler, delegationHandler: delegationHandler)
+        view = webView
+        // create the bridge
+        capacitorBridge = CapacitorBridge(with: configuration,
+                                          delegate: self,
+                                          cordovaConfiguration: configDescriptor.cordovaConfiguration,
+                                          assetHandler: assetHandler,
+                                          delegationHandler: delegationHandler)
+        capacitorDidLoad()
+
+        if configDescriptor.instanceType == .fixed {
+            updateBinaryVersion()
+        }
+    }
+
+    override open func viewDidLoad() {
+        super.viewDidLoad()
+        loadWebView()
+    }
+
+    override open func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        NotificationCenter.default.post(Notification(name: .capacitorViewDidAppear))
+        if bridge?.config.hasInitialFocus ?? true {
+            self.webView?.becomeFirstResponder()
+        }
+    }
+
+    override open func viewWillTransition(to size: CGSize, with coordinator: UIViewControllerTransitionCoordinator) {
+        super.viewWillTransition(to: size, with: coordinator)
+        NotificationCenter.default.post(Notification(name: .capacitorViewWillTransition))
+    }
+
+    override open func canPerformUnwindSegueAction(_ action: Selector, from fromViewController: UIViewController, withSender sender: Any) -> Bool {
+        return false
+    }
+
+    // MARK: - Initialization
+
+    /**
+     The InstanceDescriptor that should be used for the Capacitor environment.
+
+     - Returns: `InstanceDescriptor`
+
+     - Note: This is called early in the View Controller's lifecycle. Not all properties will be set at invocation.
+     */
+    open func instanceDescriptor() -> InstanceDescriptor {
+        let descriptor = InstanceDescriptor.init()
+        if !isNewBinary && !descriptor.cordovaDeployDisabled {
+            if let persistedPath = KeyValueStore.standard["serverBasePath", as: String.self], !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
+    }
+
+    open func router() -> Router {
+        return CapacitorRouter()
+    }
+
+    /**
+     The WKWebViewConfiguration to use for the webview.
+
+     - Parameter instanceConfiguration: the configuration that will define the capacitor environment.
+
+     - Returns: `WKWebViewConfiguration`
+
+     It is recommended to call super's implementation and modify the result, rather than creating a new object.
+     */
+    open func webViewConfiguration(for instanceConfiguration: InstanceConfiguration) -> WKWebViewConfiguration {
+        let webViewConfiguration = WKWebViewConfiguration()
+        webViewConfiguration.websiteDataStore.httpCookieStore.add(CapacitorWKCookieObserver())
+        webViewConfiguration.allowsInlineMediaPlayback = true
+        webViewConfiguration.suppressesIncrementalRendering = false
+        webViewConfiguration.allowsAirPlayForMediaPlayback = true
+        webViewConfiguration.mediaTypesRequiringUserActionForPlayback = []
+        webViewConfiguration.limitsNavigationsToAppBoundDomains = instanceConfiguration.limitsNavigationsToAppBoundDomains
+        if #available(iOS 15.4, *) {
+            webViewConfiguration.preferences.isElementFullscreenEnabled = true
+        }
+        if let appendUserAgent = instanceConfiguration.appendedUserAgentString {
+            if let appName = webViewConfiguration.applicationNameForUserAgent {
+                webViewConfiguration.applicationNameForUserAgent = "\(appName) \(appendUserAgent)"
+            } else {
+                webViewConfiguration.applicationNameForUserAgent = appendUserAgent
+            }
+        }
+        if let preferredContentMode = instanceConfiguration.preferredContentMode {
+            var mode = WKWebpagePreferences.ContentMode.recommended
+            if preferredContentMode == "mobile" {
+                mode = WKWebpagePreferences.ContentMode.mobile
+            } else if preferredContentMode == "desktop" {
+                mode = WKWebpagePreferences.ContentMode.desktop
+            }
+            webViewConfiguration.defaultWebpagePreferences.preferredContentMode = mode
+        }
+        return webViewConfiguration
+    }
+
+    /**
+     Returns a WKWebView initialized with the frame and configuration.
+
+     Subclasses can override this method to return a subclass of WKWebView if needed.
+     */
+    open func webView(with frame: CGRect, configuration: WKWebViewConfiguration) -> WKWebView {
+        return WKWebView(frame: frame, configuration: configuration)
+    }
+
+    /**
+     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() {
+    }
+
+    public final func loadWebView() {
+        guard let bridge = capacitorBridge else {
+            return
+        }
+
+        guard FileManager.default.fileExists(atPath: bridge.config.appStartFileURL.path) else {
+            fatalLoadError()
+        }
+
+        let url = bridge.config.appStartServerURL
+        CAPLog.print("⚡️  Loading app at \(url.absoluteString)...")
+        bridge.webViewDelegationHandler.willLoadWebview(webView)
+        _ = webView?.load(URLRequest(url: url))
+    }
+
+    // MARK: - System Integration
+
+    open func setStatusBarDefaults() {
+        if let plist = Bundle.main.infoDictionary {
+            if let statusBarHidden = plist["UIStatusBarHidden"] as? Bool {
+                if statusBarHidden {
+                    self.isStatusBarVisible = false
+                }
+            }
+            if let statusBarStyle = plist["UIStatusBarStyle"] as? String {
+                if statusBarStyle == "UIStatusBarStyleDarkContent" {
+                    self.statusBarStyle = .darkContent
+                } else if statusBarStyle != "UIStatusBarStyleDefault" {
+                    self.statusBarStyle = .lightContent
+                }
+            }
+        }
+    }
+
+    open func setScreenOrientationDefaults() {
+        if let plist = Bundle.main.infoDictionary {
+            if let orientations = plist["UISupportedInterfaceOrientations"] as? [String] {
+                for orientation in orientations {
+                    if orientation == "UIInterfaceOrientationPortrait" {
+                        self.supportedOrientations.append(UIInterfaceOrientation.portrait.rawValue)
+                    }
+                    if orientation == "UIInterfaceOrientationPortraitUpsideDown" {
+                        self.supportedOrientations.append(UIInterfaceOrientation.portraitUpsideDown.rawValue)
+                    }
+                    if orientation == "UIInterfaceOrientationLandscapeLeft" {
+                        self.supportedOrientations.append(UIInterfaceOrientation.landscapeLeft.rawValue)
+                    }
+                    if orientation == "UIInterfaceOrientationLandscapeRight" {
+                        self.supportedOrientations.append(UIInterfaceOrientation.landscapeRight.rawValue)
+                    }
+                }
+                if self.supportedOrientations.count == 0 {
+                    self.supportedOrientations.append(UIInterfaceOrientation.portrait.rawValue)
+                }
+            }
+        }
+    }
+
+    override open var prefersStatusBarHidden: Bool {
+        return !isStatusBarVisible
+    }
+
+    override open var preferredStatusBarStyle: UIStatusBarStyle {
+        return statusBarStyle
+    }
+
+    override open var preferredStatusBarUpdateAnimation: UIStatusBarAnimation {
+        return statusBarAnimation
+    }
+
+    open func setStatusBarVisible(_ isStatusBarVisible: Bool) {
+        self.isStatusBarVisible = isStatusBarVisible
+        UIView.animate(withDuration: 0.2, animations: {
+            self.setNeedsStatusBarAppearanceUpdate()
+        })
+    }
+
+    open func setStatusBarStyle(_ statusBarStyle: UIStatusBarStyle) {
+        self.statusBarStyle = statusBarStyle
+        UIView.animate(withDuration: 0.2, animations: {
+            self.setNeedsStatusBarAppearanceUpdate()
+        })
+    }
+
+    open func setStatusBarAnimation(_ statusBarAnimation: UIStatusBarAnimation) {
+        self.statusBarAnimation = statusBarAnimation
+    }
+
+    override open var supportedInterfaceOrientations: UIInterfaceOrientationMask {
+        var ret = 0
+        if self.supportedOrientations.contains(UIInterfaceOrientation.portrait.rawValue) {
+            ret = ret | (1 << UIInterfaceOrientation.portrait.rawValue)
+        }
+        if self.supportedOrientations.contains(UIInterfaceOrientation.portraitUpsideDown.rawValue) {
+            ret = ret | (1 << UIInterfaceOrientation.portraitUpsideDown.rawValue)
+        }
+        if self.supportedOrientations.contains(UIInterfaceOrientation.landscapeRight.rawValue) {
+            ret = ret | (1 << UIInterfaceOrientation.landscapeRight.rawValue)
+        }
+        if self.supportedOrientations.contains(UIInterfaceOrientation.landscapeLeft.rawValue) {
+            ret = ret | (1 << UIInterfaceOrientation.landscapeLeft.rawValue)
+        }
+        return UIInterfaceOrientationMask.init(rawValue: UInt(ret))
+    }
+}
+
+// MARK: - Application Path
+
+extension CAPBridgeViewController {
+    @objc public func getServerBasePath() -> String {
+        return bridge?.config.appLocation.path ?? ""
+    }
+
+    @objc public func setServerBasePath(path: String) {
+        guard let capBridge = capacitorBridge else { return }
+        capBridge.setServerBasePath(path)
+        DispatchQueue.main.async { [weak self] in
+            _ = self?.webView?.load(URLRequest(url: capBridge.config.serverURL))
+        }
+    }
+}
+
+// MARK: - Private
+
+extension CAPBridgeViewController {
+    private func prepareWebView(with configuration: InstanceConfiguration, assetHandler: WebViewAssetHandler, delegationHandler: WebViewDelegationHandler) {
+        // set the cookie policy
+        HTTPCookieStorage.shared.cookieAcceptPolicy = HTTPCookie.AcceptPolicy.always
+        // setup the web view configuration
+        let webConfig = webViewConfiguration(for: configuration)
+        webConfig.setURLSchemeHandler(assetHandler, forURLScheme: configuration.localURL.scheme ?? InstanceDescriptorDefaults.scheme)
+        webConfig.userContentController = delegationHandler.contentController
+        // create the web view and set its properties
+        let aWebView = webView(with: .zero, configuration: webConfig)
+        aWebView.scrollView.bounces = false
+        aWebView.scrollView.contentInsetAdjustmentBehavior = configuration.contentInsetAdjustmentBehavior
+        aWebView.allowsLinkPreview = configuration.allowLinkPreviews
+        aWebView.scrollView.isScrollEnabled = configuration.scrollingEnabled
+        if let overrideUserAgent = configuration.overridenUserAgentString {
+            aWebView.customUserAgent = overrideUserAgent
+        }
+        if let backgroundColor = configuration.backgroundColor {
+            aWebView.backgroundColor = backgroundColor
+            aWebView.scrollView.backgroundColor = backgroundColor
+        } else {
+            // Use the system background colors if background is not set by user
+            aWebView.backgroundColor = UIColor.systemBackground
+            aWebView.scrollView.backgroundColor = UIColor.systemBackground
+        }
+        aWebView.capacitor.setKeyboardShouldRequireUserInteraction(false)
+        // set our ivar
+        webView = aWebView
+        // set our delegates
+        aWebView.uiDelegate = delegationHandler
+        aWebView.navigationDelegate = delegationHandler
+        if !configuration.zoomingEnabled {
+            aWebView.scrollView.delegate = delegationHandler
+        }
+    }
+
+    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 store = KeyValueStore.standard
+        store["lastBinaryVersionCode"] = versionCode
+        store["lastBinaryVersionName"] = versionName
+        store["serverBasePath"] = nil as String?
+    }
+
+    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 printLoadError() {
+        let fullStartPath = bridge?.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.")
+    }
+
+    private func fatalLoadError() -> Never {
+        printLoadError()
+        exit(1)
+    }
+}
+
+extension CAPBridgeViewController: CAPBridgeDelegate {
+    public var bridgedWebView: WKWebView? {
+        return webView
+    }
+
+    public var bridgedViewController: UIViewController? {
+        return self
+    }
+}

package/Capacitor/Capacitor/CAPBridgedJSTypes.h

@@ -0,0 +1,18 @@
+// Convenience methods for bridging to/from JavaScript types. Deliberately hidden from
+// Swift by omission (to avoid collisions with Swift protocols), use
+// `#import <Capacitor/CAPBridgedJSTypes.h>` if working in Objective-C.
+
+#import <Foundation/Foundation.h>
+#import <Capacitor/Capacitor-Swift.h>
+
+@protocol BridgedJSValueContainerImplementation <NSObject>
+@required
+- (NSString * _Nullable)getString:(NSString * _Nonnull)key defaultValue:(NSString * _Nullable)defaultValue;
+- (NSDate * _Nullable)getDate:(NSString * _Nonnull)key defaultValue:(NSDate * _Nullable)defaultValue;
+- (NSDictionary * _Nullable)getObject:(NSString * _Nonnull)key defaultValue:(NSDictionary * _Nullable)defaultValue;
+- (NSNumber * _Nullable)getNumber:(NSString * _Nonnull)key defaultValue:(NSNumber * _Nullable)defaultValue;
+- (BOOL)getBool:(NSString * _Nonnull)key defaultValue:(BOOL)defaultValue;
+@end
+
+@interface CAPPluginCall (BridgedJSProtocol) <BridgedJSValueContainerImplementation>
+@end

package/Capacitor/Capacitor/CAPBridgedJSTypes.m

@@ -0,0 +1,43 @@
+#import <Foundation/Foundation.h>
+#import "CAPBridgedJSTypes.h"
+
+@implementation CAPPluginCall (BridgedJSProtocol)
+- (NSString * _Nullable)getString:(NSString * _Nonnull)key defaultValue:(NSString * _Nullable)defaultValue {
+    id value = [[self dictionaryRepresentation] objectForKey:key];
+    if (value != nil && [value isKindOfClass:[NSString class]]) {
+        return value;
+    }
+    return defaultValue;
+}
+
+- (NSDate * _Nullable)getDate:(NSString * _Nonnull)key defaultValue:(NSDate * _Nullable)defaultValue {
+    id value = [[self dictionaryRepresentation] objectForKey:key];
+    if (value != nil && [value isKindOfClass:[NSDate class]]) {
+        return value;
+    }
+    else if (value != nil && [value isKindOfClass:[NSString class]]) {
+        return [[[self class] jsDateFormatter] dateFromString:value];
+    }
+    return defaultValue;
+}
+
+- (NSDictionary * _Nullable)getObject:(NSString * _Nonnull)key defaultValue:(NSDictionary * _Nullable)defaultValue {
+    id value = [[self dictionaryRepresentation] objectForKey:key];
+    if (value != nil && [value isKindOfClass:[NSDictionary class]]) {
+        return value;
+    }
+    return defaultValue;
+}
+
+- (NSNumber * _Nullable)getNumber:(NSString * _Nonnull)key defaultValue:(NSNumber * _Nullable)defaultValue {
+    id value = [[self dictionaryRepresentation] objectForKey:key];
+    if (value != nil && [value isKindOfClass:[NSNumber class]]) {
+        return value;
+    }
+    return defaultValue;
+}
+
+- (BOOL)getBool:(NSString * _Nonnull)key defaultValue:(BOOL)defaultValue {
+    return [[self getNumber:key defaultValue:[NSNumber numberWithBool:defaultValue]] boolValue];
+}
+@end

package/Capacitor/Capacitor/CAPBridgedPlugin+getMethod.swift

@@ -0,0 +1,13 @@
+//
+//  CAPBridgedPlugin+getMethod.swift
+//  Capacitor
+//
+//  Created by Steven Sherry on 3/1/23.
+//  Copyright © 2023 Drifty Co. All rights reserved.
+//
+
+extension CAPBridgedPlugin {
+    func getMethod(named name: String) -> CAPPluginMethod? {
+        pluginMethods.first { $0.name == name }
+    }
+}

package/Capacitor/Capacitor/CAPBridgedPlugin.h

@@ -0,0 +1,41 @@
+#import "CAPPluginMethod.h"
+
+#if defined(__cplusplus)
+#define CAP_EXTERN extern "C" __attribute__((visibility("default")))
+#else
+#define CAP_EXTERN extern __attribute__((visibility("default")))
+#endif
+
+#define CAPPluginReturnNone @"none"
+#define CAPPluginReturnCallback @"callback"
+#define CAPPluginReturnPromise @"promise"
+
+@class CAPPluginCall;
+@class CAPPlugin;
+
+@protocol CAPBridgedPlugin <NSObject>
+@property (nonnull, readonly) NSString *identifier;
+@property (nonnull, readonly) NSString *jsName;
+@property (nonnull, readonly) NSArray<CAPPluginMethod *> *pluginMethods;
+@end
+
+#define CAP_PLUGIN_CONFIG(plugin_id, js_name) \
+- (NSString *)identifier { return @#plugin_id; } \
+- (NSString *)jsName { return @js_name; }
+#define CAP_PLUGIN_METHOD(method_name, method_return_type) \
+[methods addObject:[[CAPPluginMethod alloc] initWithName:@#method_name returnType:method_return_type]]
+
+#define CAP_PLUGIN(objc_name, js_name, methods_body) \
+@interface objc_name : NSObject \
+@end \
+@interface objc_name (CAPPluginCategory) <CAPBridgedPlugin> \
+@end \
+@implementation objc_name (CAPPluginCategory) \
+- (NSArray *)pluginMethods { \
+  NSMutableArray *methods = [NSMutableArray new]; \
+  methods_body \
+  return methods; \
+} \
+CAP_PLUGIN_CONFIG(objc_name, js_name) \
+@end
+

package/Capacitor/Capacitor/CAPFile.swift

@@ -0,0 +1,14 @@
+/**
+ * CAPFileManager helps map file schemes to physical files, whether they are on
+ * disk, in a bundle, or in another location.
+ */
+@objc public class CAPFileManager: NSObject {
+    @available(*, deprecated, message: "Use portablePath(fromLocalURL:) on the Bridge")
+    public static func getPortablePath(host: String, uri: URL?) -> String? {
+        if let uri = uri {
+            let uriWithoutFile = uri.absoluteString.replacingOccurrences(of: "file://", with: "")
+            return host + CapacitorBridge.fileStartIdentifier + uriWithoutFile
+        }
+        return nil
+    }
+}

package/Capacitor/Capacitor/CAPInstanceConfiguration.h

@@ -0,0 +1,38 @@
+#ifndef CAPInstanceConfiguration_h
+#define CAPInstanceConfiguration_h
+
+@import UIKit;
+
+@class CAPInstanceDescriptor;
+
+NS_SWIFT_NAME(InstanceConfiguration)
+@interface CAPInstanceConfiguration: NSObject
+@property (nonatomic, readonly, nullable) NSString *appendedUserAgentString;
+@property (nonatomic, readonly, nullable) NSString *overridenUserAgentString;
+@property (nonatomic, readonly, nullable) UIColor *backgroundColor;
+@property (nonatomic, readonly, nonnull) NSArray<NSString*> *allowedNavigationHostnames;
+@property (nonatomic, readonly, nonnull) NSURL *localURL;
+@property (nonatomic, readonly, nonnull) NSURL *serverURL;
+@property (nonatomic, readonly, nullable) NSString *errorPath;
+@property (nonatomic, readonly, nonnull) NSDictionary *pluginConfigurations;
+@property (nonatomic, readonly) BOOL loggingEnabled;
+@property (nonatomic, readonly) BOOL scrollingEnabled;
+@property (nonatomic, readonly) BOOL zoomingEnabled;
+@property (nonatomic, readonly) BOOL allowLinkPreviews;
+@property (nonatomic, readonly) BOOL handleApplicationNotifications;
+@property (nonatomic, readonly) BOOL isWebDebuggable;
+@property (nonatomic, readonly) BOOL hasInitialFocus;
+@property (nonatomic, readonly) BOOL cordovaDeployDisabled;
+@property (nonatomic, readonly) UIScrollViewContentInsetAdjustmentBehavior contentInsetAdjustmentBehavior;
+@property (nonatomic, readonly, nonnull) NSURL *appLocation;
+@property (nonatomic, readonly, nullable) NSString *appStartPath;
+@property (nonatomic, readonly) BOOL limitsNavigationsToAppBoundDomains;
+@property (nonatomic, readonly, nullable) NSString *preferredContentMode;
+
+@property (nonatomic, readonly, nonnull) NSDictionary *legacyConfig DEPRECATED_MSG_ATTRIBUTE("Use direct properties instead");
+
+- (instancetype _Nonnull)initWithDescriptor:(CAPInstanceDescriptor* _Nonnull)descriptor isDebug:(BOOL)debug NS_SWIFT_NAME(init(with:isDebug:));
+- (instancetype _Nonnull)updatingAppLocation:(NSURL* _Nonnull)location NS_SWIFT_NAME(updatingAppLocation(_:));
+@end
+
+#endif /* CAPInstanceConfiguration_h */

package/Capacitor/Capacitor/CAPInstanceConfiguration.m

@@ -0,0 +1,93 @@
+#import "CAPInstanceConfiguration.h"
+#import <Capacitor/Capacitor-Swift.h>
+
+@interface CAPInstanceConfiguration (Internal)
+- (instancetype)initWithConfiguration:(CAPInstanceConfiguration*)configuration andLocation:(NSURL*)location;
+@end
+
+
+@implementation CAPInstanceConfiguration
+
+- (instancetype)initWithDescriptor:(CAPInstanceDescriptor *)descriptor isDebug:(BOOL)debug {
+    if (self = [super init]) {
+        // first, give the descriptor a chance to make itself internally consistent
+        [descriptor normalize];
+        // now copy the simple properties
+        _appendedUserAgentString = descriptor.appendedUserAgentString;
+        _overridenUserAgentString = descriptor.overridenUserAgentString;
+        _backgroundColor = descriptor.backgroundColor;
+        _allowedNavigationHostnames = descriptor.allowedNavigationHostnames;
+        switch (descriptor.loggingBehavior) {
+            case CAPInstanceLoggingBehaviorProduction:
+                _loggingEnabled = true;
+                break;
+            case CAPInstanceLoggingBehaviorDebug:
+                _loggingEnabled = debug;
+                break;
+            default:
+                _loggingEnabled = false;
+                break;
+        }
+        _scrollingEnabled = descriptor.scrollingEnabled;
+        _zoomingEnabled =  descriptor.zoomingEnabled;
+        _allowLinkPreviews = descriptor.allowLinkPreviews;
+        _handleApplicationNotifications = descriptor.handleApplicationNotifications;
+        _contentInsetAdjustmentBehavior = descriptor.contentInsetAdjustmentBehavior;
+        _appLocation = descriptor.appLocation;
+        _appStartPath = descriptor.appStartPath;
+        _limitsNavigationsToAppBoundDomains = descriptor.limitsNavigationsToAppBoundDomains;
+        _preferredContentMode = descriptor.preferredContentMode;
+        _pluginConfigurations = descriptor.pluginConfigurations;
+        _isWebDebuggable = descriptor.isWebDebuggable;
+        _hasInitialFocus = descriptor.hasInitialFocus;
+        _legacyConfig = descriptor.legacyConfig;
+        // construct the necessary URLs
+        _localURL = [[NSURL alloc] initWithString:[NSString stringWithFormat:@"%@://%@", descriptor.urlScheme, descriptor.urlHostname]];
+        if (descriptor.serverURL != nil) {
+            _serverURL = [[NSURL alloc] initWithString:(descriptor.serverURL)];
+        }
+        else {
+            _serverURL = _localURL;
+        }
+        _errorPath = descriptor.errorPath;
+        // extract the one value we care about from the cordova configuration
+        _cordovaDeployDisabled = [descriptor cordovaDeployDisabled];
+    }
+    return self;
+}
+
+- (instancetype)initWithConfiguration:(CAPInstanceConfiguration*)configuration andLocation:(NSURL*)location {
+    if (self = [super init]) {
+        _appendedUserAgentString = [[configuration appendedUserAgentString] copy];
+        _overridenUserAgentString = [[configuration overridenUserAgentString] copy];
+        _backgroundColor = configuration.backgroundColor;
+        _allowedNavigationHostnames = [[configuration allowedNavigationHostnames] copy];
+        _localURL = [[configuration localURL] copy];
+        _serverURL = [[configuration serverURL] copy];
+        _errorPath = [[configuration errorPath] copy];
+        _pluginConfigurations = [[configuration pluginConfigurations] copy];
+        _loggingEnabled = configuration.loggingEnabled;
+        _scrollingEnabled = configuration.scrollingEnabled;
+        _zoomingEnabled = configuration.zoomingEnabled;
+        _allowLinkPreviews = configuration.allowLinkPreviews;
+        _handleApplicationNotifications = configuration.handleApplicationNotifications;
+        _isWebDebuggable = configuration.isWebDebuggable;
+        _hasInitialFocus = configuration.hasInitialFocus;
+        _cordovaDeployDisabled = configuration.cordovaDeployDisabled;
+        _contentInsetAdjustmentBehavior = configuration.contentInsetAdjustmentBehavior;
+        // we don't care about internal usage of deprecated APIs and the framework should build cleanly
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+        _legacyConfig = [[configuration legacyConfig] copy];
+#pragma clang diagnostic pop
+        _appStartPath = configuration.appStartPath;
+        _appLocation = [location copy];
+    }
+    return self;
+}
+
+- (instancetype)updatingAppLocation:(NSURL*)location {
+    return [[CAPInstanceConfiguration alloc] initWithConfiguration:self andLocation:location];
+}
+
+@end