@capacitor-plus/ios 8.0.0-beta.0

package/Capacitor/Capacitor/Plugins/SystemBars.swift

@@ -0,0 +1,133 @@
+import Foundation
+
+@objc(CAPSystemBarsPlugin)
+public class CAPSystemBarsPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "CAPSystemBarsPlugin"
+    public let jsName = "SystemBars"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "setStyle", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setAnimation", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "show", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "hide", returnType: CAPPluginReturnPromise)
+    ]
+
+    public private(set) var hideHomeIndicator: Bool = false
+
+    enum Style: String {
+        case dark = "DARK"
+        case light = "LIGHT"
+        case defaultStyle = "DEFAULT"
+    }
+
+    @objc override public func load() {
+        let hidden = getConfig().getBoolean("hidden", false)
+
+        if let style = getConfig().getString("style", "DEFAULT") {
+            setStyle(style: style)
+        }
+
+        if let animation = getConfig().getString("animation") {
+            setAnimation(animation: animation)
+        }
+
+        setHidden(hidden: hidden)
+    }
+
+    @objc func setStyle(_ call: CAPPluginCall) {
+        setStyle(style: call.getString("style") ?? Style.defaultStyle.rawValue)
+        call.resolve()
+    }
+
+    @objc func show(_ call: CAPPluginCall) {
+        let bar = call.getString("bar")
+
+        if let animation = call.getString("animation") {
+            setAnimation(animation: animation)
+        }
+
+        DispatchQueue.main.async {
+            self.setHidden(hidden: false, bar: bar)
+            call.resolve()
+        }
+    }
+
+    @objc func hide(_ call: CAPPluginCall) {
+        let bar = call.getString("bar")
+
+        if let animation = call.getString("animation") {
+            setAnimation(animation: animation)
+        }
+
+        DispatchQueue.main.async {
+            self.setHidden(hidden: true, bar: bar)
+            call.resolve()
+        }
+    }
+
+    @objc func setAnimation(_ call: CAPPluginCall) {
+        let animation = call.getString("animation", "FADE")
+        setAnimation(animation: animation)
+
+        call.resolve()
+    }
+
+    func setStyle(style: String) {
+        var newStyle: UIStatusBarStyle = .default
+
+        if let style = Style(rawValue: style.uppercased()) {
+            switch style {
+            case .dark:
+                newStyle = .lightContent
+            case .light:
+                newStyle = .darkContent
+            case .defaultStyle:
+                newStyle = .default
+            }
+        }
+
+        bridge?.statusBarStyle = newStyle
+    }
+
+    func setHidden(hidden: Bool, bar: String? = nil) {
+        if hidden {
+            if bar == nil || bar?.isEmpty ?? true || bar == "StatusBar" {
+                bridge?.statusBarVisible = false
+            }
+
+            if bar == nil || bar?.isEmpty ?? true || bar == "NavigationBar" {
+                hideHomeIndicator = true
+                bridge?.viewController?.setNeedsUpdateOfHomeIndicatorAutoHidden()
+            }
+
+            return
+        }
+
+        if bar == nil || bar?.isEmpty ?? true || bar == "StatusBar" {
+            bridge?.statusBarVisible = true
+        }
+
+        if bar == nil || bar?.isEmpty ?? true || bar == "NavigationBar" {
+            hideHomeIndicator = false
+            bridge?.viewController?.setNeedsUpdateOfHomeIndicatorAutoHidden()
+        }
+
+    }
+
+    func setAnimation(animation: String) {
+        if animation.uppercased() == "NONE" {
+            bridge?.statusBarAnimation = .none
+        } else {
+            bridge?.statusBarAnimation = .fade
+        }
+    }
+}
+
+extension CAPBridgeViewController {
+    override public var prefersHomeIndicatorAutoHidden: Bool {
+        if let systemBarPlugin = self.bridge?.plugin(withName: "SystemBars") as? CAPSystemBarsPlugin {
+            return systemBarPlugin.hideHomeIndicator
+        }
+
+        return false
+    }
+}

package/Capacitor/Capacitor/Plugins/WebView.swift

@@ -0,0 +1,44 @@
+import Foundation
+
+@objc(CAPWebViewPlugin)
+public class CAPWebViewPlugin: CAPPlugin, CAPBridgedPlugin {
+    public let identifier = "CAPWebViewPlugin"
+    public let jsName = "WebView"
+    public let pluginMethods: [CAPPluginMethod] = [
+        CAPPluginMethod(name: "setServerAssetPath", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "setServerBasePath", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "getServerBasePath", returnType: CAPPluginReturnPromise),
+        CAPPluginMethod(name: "persistServerBasePath", returnType: CAPPluginReturnPromise)
+    ]
+
+    @objc func setServerAssetPath(_ call: CAPPluginCall) {
+        if let path = call.getString("path"), let viewController = bridge?.viewController as? CAPBridgeViewController {
+            viewController.setServerBasePath(path: Bundle.main.url(forResource: path, withExtension: nil)?.path ?? path)
+            call.resolve()
+        }
+    }
+
+    @objc func setServerBasePath(_ call: CAPPluginCall) {
+        if let path = call.getString("path"), let viewController = bridge?.viewController as? CAPBridgeViewController {
+            viewController.setServerBasePath(path: path)
+            call.resolve()
+        }
+    }
+
+    @objc func getServerBasePath(_ call: CAPPluginCall) {
+        if let viewController = bridge?.viewController as? CAPBridgeViewController {
+            let path = viewController.getServerBasePath()
+            call.resolve([
+                "path": path
+            ])
+        }
+    }
+
+    @objc func persistServerBasePath(_ call: CAPPluginCall) {
+        if let viewController = bridge?.viewController as? CAPBridgeViewController {
+            let path = viewController.getServerBasePath()
+            KeyValueStore.standard["serverBasePath"] = path
+            call.resolve()
+        }
+    }
+}

package/Capacitor/Capacitor/PrivacyInfo.xcprivacy

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>NSPrivacyAccessedAPITypes</key>
+	<array/>
+	<key>NSPrivacyCollectedDataTypes</key>
+	<array/>
+	<key>NSPrivacyTrackingDomains</key>
+	<array/>
+	<key>NSPrivacyTracking</key>
+	<false/>
+</dict>
+</plist>

package/Capacitor/Capacitor/Router.swift

@@ -0,0 +1,29 @@
+//
+//  Router.swift
+//  Capacitor
+//
+//  Created by Steven Sherry on 3/29/22.
+//  Copyright © 2022 Drifty Co. All rights reserved.
+//
+
+import Foundation
+
+public protocol Router {
+    func route(for path: String) -> String
+    var basePath: String { get set }
+}
+
+public struct CapacitorRouter: Router {
+    public init() {}
+    public var basePath: String = ""
+    public func route(for path: String) -> String {
+        let pathUrl = URL(fileURLWithPath: path)
+
+        // 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 basePath + path
+    }
+}

package/Capacitor/Capacitor/TmpViewController.swift

@@ -0,0 +1,8 @@
+import UIKit
+
+internal class TmpViewController: UIViewController {
+    override func viewDidAppear(_ animated: Bool) {
+        super.viewDidAppear(animated)
+        NotificationCenter.default.post(CapacitorBridge.tmpVCAppeared)
+    }
+}

package/Capacitor/Capacitor/UIColor.swift

@@ -0,0 +1,55 @@
+extension UIColor: CapacitorExtension {}
+public extension CapacitorExtensionTypeWrapper where T: UIColor {
+    // disable linting for the short variable names, since that's the point of the method
+    // swiftlint:disable:next identifier_name
+    static func color(r: Int, g: Int, b: Int, a: Int = 0xFF) -> UIColor {
+        return T(
+            red: CGFloat(r) / 255.0,
+            green: CGFloat(g) / 255.0,
+            blue: CGFloat(b) / 255.0,
+            alpha: CGFloat(a) / 255.0
+        )
+    }
+
+    static func color(argb: UInt32) -> UIColor {
+        return T(
+            red: CGFloat((argb >> 16) & 0xFF),
+            green: CGFloat((argb >> 8) & 0xFF),
+            blue: CGFloat(argb & 0xFF),
+            alpha: CGFloat((argb >> 24) & 0xFF)
+        )
+    }
+
+    static func color(fromHex: String) -> UIColor? {
+        let hexString = fromHex.trimmingCharacters(in: .whitespacesAndNewlines).replacingOccurrences(
+            of: "#",
+            with: ""
+        )
+
+        var argb: UInt64 = 0
+
+        var red: CGFloat = 0.0
+        var green: CGFloat = 0.0
+        var blue: CGFloat = 0.0
+        var alpha: CGFloat = 1.0
+
+        guard Scanner(string: hexString).scanHexInt64(&argb) else { return nil }
+
+        if hexString.count == 6 {
+            red = CGFloat((argb & 0xFF0000) >> 16) / 255.0
+            green = CGFloat((argb & 0x00FF00) >> 8) / 255.0
+            blue = CGFloat(argb & 0x0000FF) / 255.0
+
+        } else if hexString.count == 8 {
+            red = CGFloat((argb & 0xFF00_0000) >> 24) / 255.0
+            green = CGFloat((argb & 0x00FF0000) >> 16) / 255.0
+            blue = CGFloat((argb & 0x0000FF00) >> 8) / 255.0
+            alpha = CGFloat(argb & 0x000000FF) / 255.0
+
+        } else {
+            return nil
+        }
+
+        return T(red: red, green: green, blue: blue, alpha: alpha)
+    }
+}

package/Capacitor/Capacitor/UIStatusBarManager+CAPHandleTapAction.m

@@ -0,0 +1,37 @@
+#import <Capacitor/Capacitor-Swift.h>
+#import <objc/message.h>
+#import <objc/runtime.h>
+
+@implementation UIStatusBarManager (CAPHandleTapAction)
+
++ (void)load {
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    Class class = [self class];
+    SEL originalSelector = NSSelectorFromString(@"handleTapAction:");
+    SEL swizzledSelector = @selector(nofity_handleTapAction:);
+
+    Method originalMethod = class_getInstanceMethod(class, originalSelector);
+    Method swizzledMethod = class_getInstanceMethod(class, swizzledSelector);
+
+    BOOL didAddMethod = class_addMethod(class,
+                                        originalSelector,
+                                        method_getImplementation(swizzledMethod),
+                                        method_getTypeEncoding(swizzledMethod));
+    if (didAddMethod) {
+      class_replaceMethod(class,
+                          swizzledSelector,
+                          method_getImplementation(originalMethod),
+                          method_getTypeEncoding(originalMethod));
+    } else {
+      method_exchangeImplementations(originalMethod, swizzledMethod);
+    }
+  });
+}
+
+-(void)nofity_handleTapAction:(id)arg1 {
+  [[NSNotificationCenter defaultCenter] postNotification:[NSNotification notificationWithName:NSNotification.capacitorStatusBarTapped object:nil]];
+  [self nofity_handleTapAction:arg1];
+}
+
+@end

package/Capacitor/Capacitor/WKWebView+Capacitor.m

@@ -0,0 +1,15 @@
+#import <objc/runtime.h>
+#import <Capacitor/Capacitor-Swift.h>
+
+// Swift extensions marked as @objc and internal are available to the runtime but won't be found at compile time
+// so we need this declaration to avoid compiler complaints.
+@interface WKWebView (InternalSwiftExtension)
++ (void)_swizzleKeyboardMethods;
+@end
+
+// +load is the safest place to swizzle methods but that won't work from a swift extension so we need this wrapper.
+@implementation WKWebView (CapacitorAutoFocus)
++ (void)load {
+    [self _swizzleKeyboardMethods];
+}
+@end

package/Capacitor/Capacitor/WKWebView+Capacitor.swift

@@ -0,0 +1,80 @@
+import Foundation
+import WebKit
+
+extension WKWebView: CapacitorExtension {}
+public extension CapacitorExtensionTypeWrapper where T == WKWebView {
+    var keyboardShouldRequireUserInteraction: Bool? {
+        return (self.baseType.associatedKeyboardFlagValue as? NSNumber)?.boolValue
+    }
+
+    // the readonly nature of the wrapper extension means we can't use a computed property with a setter
+    func setKeyboardShouldRequireUserInteraction(_ flag: Bool? = nil) {
+        if let flag = flag {
+            self.baseType.associatedKeyboardFlagValue = NSNumber(value: flag)
+        } else {
+            self.baseType.associatedKeyboardFlagValue = nil
+        }
+    }
+}
+
+private var associatedKeyboardFlagHandle: UInt8 = 0
+
+internal extension WKWebView {
+    // Our lazy property can't be represented in Obj-C so we need this simple wrapper.
+    // swiftlint:disable identifier_name
+    @objc static func _swizzleKeyboardMethods() {
+        _ = oneTimeOnlySwizzle
+    }
+
+    typealias FiveArgClosureType =  @convention(c) (Any, Selector, UnsafeRawPointer, Bool, Bool, Bool, Any?) -> Void
+
+    // dispatch_once isn't available in Swift, but lazy properties use the same mechanism under the hood so
+    // we can safely assume that this block of code will only execute once.
+    static let oneTimeOnlySwizzle: () = {
+        let frameworkName = "WK"
+        let className = "ContentView"
+        guard let targetClass = NSClassFromString(frameworkName + className) else {
+            return
+        }
+
+        let containingWebView = { (object: Any?) -> WKWebView? in
+            var view = object as? UIView
+            while view != nil {
+                if let webview = view as? WKWebView {
+                    return webview
+                }
+                view = view?.superview
+            }
+            return nil
+        }
+
+        let swizzleFiveArgClosure = { (method: Method, selector: Selector) in
+            let originalImp: IMP = method_getImplementation(method)
+            let original: FiveArgClosureType = unsafeBitCast(originalImp, to: FiveArgClosureType.self)
+            let block: @convention(block) (Any, UnsafeRawPointer, Bool, Bool, Bool, Any?) -> Void = { (me, arg0, arg1, arg2, arg3, arg4) in
+                if let webview = containingWebView(me), let flag = webview.capacitor.keyboardShouldRequireUserInteraction {
+                    original(me, selector, arg0, !flag, arg2, arg3, arg4)
+                } else {
+                    original(me, selector, arg0, arg1, arg2, arg3, arg4)
+                }
+            }
+            let imp: IMP = imp_implementationWithBlock(block)
+            method_setImplementation(method, imp)
+        }
+
+        let selectorMkIV: Selector = sel_getUid("_elementDidFocus:userIsInteracting:blurPreviousNode:activityStateChanges:userObject:")
+
+        if let method = class_getInstanceMethod(targetClass, selectorMkIV) {
+            swizzleFiveArgClosure(method, selectorMkIV)
+        }
+    }()
+
+    var associatedKeyboardFlagValue: Any? {
+        get {
+            return objc_getAssociatedObject(self, &associatedKeyboardFlagHandle)
+        }
+        set {
+            objc_setAssociatedObject(self, &associatedKeyboardFlagHandle, newValue, .OBJC_ASSOCIATION_RETAIN_NONATOMIC)
+        }
+    }
+}