craft-native 0.0.115 → 0.0.119

package/dist/ios/src/index.js

@@ -111,6 +111,27 @@ function renderOrientations(config) {
   return values.map((value) => `        <string>${names[value]}</string>`).join(`
 `);
 }
+function renderAppBoundDomains(config) {
+  const hostOf = (value) => {
+    try {
+      const url = new URL(value);
+      return url.protocol === "https:" || url.protocol === "http:" ? url.hostname.toLowerCase() : null;
+    } catch {
+      return null;
+    }
+  };
+  const domains = config.appBoundDomains !== undefined ? config.appBoundDomains.map((value) => value.trim().toLowerCase()).filter(Boolean) : (config.trustedOrigins ?? []).map(hostOf).filter((host) => !!host);
+  if (!domains.length)
+    return "";
+  const devHost = config.devServerURL ? hostOf(config.devServerURL) : null;
+  if (devHost)
+    domains.push(devHost);
+  const unique = [...new Set(domains)].slice(0, 10);
+  return `    <key>WKAppBoundDomains</key>
+    <array>
+${plistArray(unique)}
+    </array>`;
+}
 function renderUrlTypes(config) {
   const schemes = [...new Set(config.urlSchemes?.map((value) => value.trim()).filter(Boolean) ?? [])];
   if (!schemes.length)
@@ -168,6 +189,12 @@ ${plistArray(config.appGroups)}
     entries.push(`    <key>aps-environment</key>
     <string>$(CRAFT_APNS_ENVIRONMENT)</string>`);
   }
+  if (config.enableSecureStorage) {
+    entries.push(`    <key>keychain-access-groups</key>
+    <array>
+        <string>$(AppIdentifierPrefix)$(CFBundleIdentifier)</string>
+    </array>`);
+  }
   return `<?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">
@@ -410,7 +437,7 @@ async function init(options) {
   cpSync(join(TEMPLATES_DIR, "CraftNativeActions.swift"), join(output, "Sources", "CraftNativeActions.swift"));
   cpSync(join(TEMPLATES_DIR, "CraftNativeMutation.swift"), join(output, "Sources", "CraftNativeMutation.swift"));
   const infoPlistTemplate = readFileSync(join(TEMPLATES_DIR, "Info.plist.template"), "utf-8");
-  const infoPlist = infoPlistTemplate.replace(/\{\{APP_NAME\}\}/g, xmlEscape(displayName)).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{UI_STYLE\}\}/g, renderAppearance(config).interfaceStyle).replace(/\{\{STATUS_BAR_STYLE\}\}/g, renderAppearance(config).statusBarStyle).replace(/\{\{ORIENTATIONS\}\}/g, renderOrientations(config)).replace(/\{\{USAGE_DESCRIPTIONS\}\}/g, renderUsageDescriptions(config)).replace(/\{\{URL_TYPES\}\}/g, renderUrlTypes(config)).replace(/\{\{BACKGROUND_MODES\}\}/g, renderBackgroundModes(config)).replace(/\{\{LIVE_ACTIVITY_SUPPORT\}\}/g, config.enableLiveActivities ? `    <key>NSSupportsLiveActivities</key>
+  const infoPlist = infoPlistTemplate.replace(/\{\{APP_NAME\}\}/g, xmlEscape(displayName)).replace(/\{\{BUNDLE_ID\}\}/g, finalBundleId).replace(/\{\{VERSION\}\}/g, config.version || "1.0.0").replace(/\{\{BUILD_NUMBER\}\}/g, config.buildNumber || "1").replace(/\{\{UI_STYLE\}\}/g, renderAppearance(config).interfaceStyle).replace(/\{\{STATUS_BAR_STYLE\}\}/g, renderAppearance(config).statusBarStyle).replace(/\{\{ORIENTATIONS\}\}/g, renderOrientations(config)).replace(/\{\{USAGE_DESCRIPTIONS\}\}/g, renderUsageDescriptions(config)).replace(/\{\{URL_TYPES\}\}/g, renderUrlTypes(config)).replace(/\{\{APP_BOUND_DOMAINS\}\}/g, renderAppBoundDomains(config)).replace(/\{\{BACKGROUND_MODES\}\}/g, renderBackgroundModes(config)).replace(/\{\{LIVE_ACTIVITY_SUPPORT\}\}/g, config.enableLiveActivities ? `    <key>NSSupportsLiveActivities</key>
     <true/>
     <key>NSSupportsLiveActivitiesFrequentUpdates</key>
     <true/>` : "");
@@ -729,6 +756,7 @@ export {
   renderDeviceFamilies,
   renderBackgroundModes,
   renderAppearance,
+  renderAppBoundDomains,
   productName,
   pickSimulator,
   orderSimulators,

package/dist/ios/templates/CraftApp.swift

@@ -259,6 +259,7 @@ class DeepLinkManager {
     // the one the app was opened with; a link that arrives later is not, and
     // is no answer to getInitialURL.
     private var hasBeenReady = false
+    private var nativeListeners: [UUID: (URL, Bool) -> Void] = [:]
 
     private init() {}
 
@@ -289,7 +290,9 @@ class DeepLinkManager {
             initialURL = url
         }
 
-        if isReady && webView != nil {
+        if !nativeListeners.isEmpty {
+            dispatchNative(url, initial: false)
+        } else if isReady && webView != nil {
             dispatchDeepLink(url, initial: false)
         } else {
             pendingURLs.append(url)
@@ -300,6 +303,28 @@ class DeepLinkManager {
         return initialURL
     }
 
+    @discardableResult
+    func addNativeListener(_ listener: @escaping (URL, Bool) -> Void) -> UUID {
+        let token = UUID()
+        nativeListeners[token] = listener
+        let firstNativeScreen = !hasBeenReady
+        hasBeenReady = true
+        let urls = pendingURLs
+        pendingURLs.removeAll()
+        for url in urls {
+            listener(url, firstNativeScreen && url == initialURL)
+        }
+        return token
+    }
+
+    func removeNativeListener(_ token: UUID) {
+        nativeListeners.removeValue(forKey: token)
+    }
+
+    private func dispatchNative(_ url: URL, initial: Bool) {
+        for listener in nativeListeners.values { listener(url, initial) }
+    }
+
     private func dispatchDeepLink(_ url: URL, initial: Bool) {
         guard let webView = webView else { return }
 
@@ -392,6 +417,8 @@ struct CraftConfig: Codable {
     var backgroundColorDark: String? = nil
     /// Edge-swipe back and forward through the page's history.
     var swipeNavigation: Bool? = nil
+    /// Refuse to load anything but the Info.plist's WKAppBoundDomains.
+    var limitNavigationsToAppBoundDomains: Bool? = nil
     var enableSpeechRecognition: Bool = false
     var enableHaptics: Bool = false
     var enableShare: Bool = false
@@ -596,6 +623,13 @@ struct CraftWebView: UIViewRepresentable {
         webConfig.allowsInlineMediaPlayback = true
         webConfig.mediaTypesRequiringUserActionForPlayback = []
         webConfig.setURLSchemeHandler(BundledAssetSchemeHandler(), forURLScheme: "craft")
+        // The app's own domains (WKAppBoundDomains in Info.plist) get what an
+        // iOS web view reserves for them, service workers among them, so a
+        // site that works offline in Safari works offline here. This only
+        // narrows loading further when the app asks for it.
+        if config.limitNavigationsToAppBoundDomains == true {
+            webConfig.limitsNavigationsToAppBoundDomains = true
+        }
 
         // Add native bridge
         let contentController = WKUserContentController()
@@ -722,6 +756,24 @@ struct CraftWebView: UIViewRepresentable {
         // Keep awake
         private var isKeepingAwake = false
 
+        // Speech synthesis. One synthesizer for the life of the web view, so a
+        // cue can interrupt the one before it; each utterance it has not
+        // finished yet is held beside the call waiting on it.
+        private lazy var speechSynthesizer: AVSpeechSynthesizer = {
+            let synthesizer = AVSpeechSynthesizer()
+            synthesizer.delegate = self
+            return synthesizer
+        }()
+        private var pendingUtterances: [(utterance: AVSpeechUtterance, callbackId: String?)] = []
+        /// What the session was before speech claimed it; nil while speech
+        /// does not hold it.
+        private var speechAudioSessionToRestore: (AVAudioSession.Category, AVAudioSession.Mode, AVAudioSession.CategoryOptions)?
+        /// Activating and deactivating the audio session blocks until the
+        /// audio hardware answers, which iOS flags as a hang risk on the main
+        /// thread. They run here instead, in order, and the session state
+        /// above is only touched here.
+        private let speechAudioQueue = DispatchQueue(label: "craft.speech.audio")
+
         // Orientation lock
         private var lockedOrientation: UIInterfaceOrientationMask?
 
@@ -1058,6 +1110,16 @@ struct CraftWebView: UIViewRepresentable {
                 } else {
                     rejectCallback(callbackId, error: "setFlashlight needs true or false", code: "INVALID_ARGUMENT")
                 }
+            // Speech synthesis. Ungated, like the flashlight: speaking needs no
+            // permission and no entitlement.
+            case "speak":
+                if let text = body["text"] as? String, !text.trimmingCharacters(in: .whitespacesAndNewlines).isEmpty {
+                    speak(text, body: body, callbackId: callbackId)
+                } else {
+                    rejectCallback(callbackId, error: "speak needs some text to say", code: "INVALID_ARGUMENT")
+                }
+            case "stopSpeaking":
+                stopSpeaking(callbackId: callbackId)
             // Vibrate pattern
             case "vibrate":
                 if let pattern = body["pattern"] as? [Int] {
@@ -1850,6 +1912,7 @@ struct CraftWebView: UIViewRepresentable {
                     orientationLock: \(config.enableOrientationLock),
                     deepLinks: \(config.enableDeepLinks),
                     flashlight: true,
+                    speech: true,
                     network: true,
                     deviceInfo: true,
                     badge: true,
@@ -2788,6 +2851,37 @@ struct CraftWebView: UIViewRepresentable {
                     });
                 },
 
+                // Speech synthesis. speak() settles when the utterance ends:
+                // true when it was spoken, false when something stopped it.
+                // No timeout, because a long sentence at a slow rate can
+                // outlast any deadline that would be fair to a short one.
+                speech: {
+                    speak: function(text, options) {
+                        var self = window.craft;
+                        var id = 'cb_' + (++self._callbackId);
+                        options = options || {};
+                        window.webkit.messageHandlers.craft.postMessage({
+                            action: 'speak',
+                            text: text == null ? '' : String(text),
+                            rate: typeof options.rate === 'number' ? options.rate : null,
+                            language: typeof options.language === 'string' ? options.language : null,
+                            interrupt: options.interrupt !== false,
+                            callbackId: id
+                        });
+                        return new Promise(function(resolve, reject) {
+                            self._callbacks[id] = {resolve: resolve, reject: reject};
+                        });
+                    },
+                    stop: function() {
+                        var self = window.craft;
+                        var id = 'cb_' + (++self._callbackId);
+                        window.webkit.messageHandlers.craft.postMessage({action: 'stopSpeaking', callbackId: id});
+                        return new Promise(function(resolve, reject) {
+                            self._callbacks[id] = {resolve: resolve, reject: reject};
+                        });
+                    }
+                },
+
                 // Orientation Lock
                 lockOrientation: function(orientation) {
                     var self = this;
@@ -3400,6 +3494,10 @@ struct CraftWebView: UIViewRepresentable {
                 craft.secureStorage = {
                     set: function(key, value) { return legacySecureStore.set(key, value).then(function() {}); },
                     get: function(key) { return legacySecureStore.get(key); },
+                    // `remove` is the legacy name retained by the public Craft
+                    // type declaration; keep it as an alias of `delete` so
+                    // native STX callers can migrate without a feature check.
+                    remove: function(key) { return legacySecureStore.remove(key).then(function() {}); },
                     delete: function(key) { return legacySecureStore.remove(key).then(function() {}); },
                     clear: function() { return craft._invoke('secureClear').then(function() {}); }
                 };
@@ -4762,6 +4860,153 @@ struct CraftWebView: UIViewRepresentable {
             }
         }
 
+        // MARK: - Speech Synthesis
+        //
+        // Native rather than the page's own `speechSynthesis`, which in a
+        // WKWebView plays through the default soloAmbient session: it stops
+        // the person's music and the silent switch mutes it. A workout cue has
+        // to do neither, so the session is set up here for as long as there is
+        // something to say, and handed back when there is not.
+
+        private func speak(_ text: String, body: [String: Any], callbackId: String?) {
+            DispatchQueue.main.async {
+                if body["interrupt"] as? Bool ?? true {
+                    self.cancelPendingSpeech()
+                }
+
+                let utterance = AVSpeechUtterance(string: text)
+                utterance.rate = Self.utteranceRate(body["rate"] as? Double ?? 1)
+                // An unknown language finds no voice, and a nil voice is the
+                // device's own, which is the default anyway.
+                if let language = body["language"] as? String, !language.isEmpty,
+                   let voice = AVSpeechSynthesisVoice(language: language) {
+                    utterance.voice = voice
+                }
+
+                self.pendingUtterances.append((utterance, callbackId))
+                self.claimAudioSessionForSpeech {
+                    // Stopped while the session was being set up: say nothing.
+                    guard self.pendingUtterances.contains(where: { $0.utterance === utterance }) else { return }
+                    self.speechSynthesizer.speak(utterance)
+                }
+            }
+        }
+
+        private func stopSpeaking(callbackId: String?) {
+            DispatchQueue.main.async {
+                // When something was playing, its didCancel releases the
+                // session once the audio has actually stopped; deactivating
+                // before that fails as busy and leaves the music ducked.
+                if !self.cancelPendingSpeech() { self.releaseAudioSessionIfSilent() }
+                self.resolveCallback(callbackId, result: true)
+            }
+        }
+
+        /// Stop what is being said and settle every call waiting on it, false.
+        /// Returns whether the synthesizer was making a sound.
+        ///
+        /// Settled here rather than in `didCancel`, because the delegate hears
+        /// about the utterance that was playing and nothing about the ones
+        /// queued behind it, whose calls would otherwise never settle.
+        @discardableResult
+        private func cancelPendingSpeech() -> Bool {
+            let waiting = pendingUtterances
+            pendingUtterances.removeAll()
+            let synthesizer = speechSynthesizer
+            let wasSounding = synthesizer.isSpeaking || synthesizer.isPaused
+            if wasSounding { synthesizer.stopSpeaking(at: .immediate) }
+            for entry in waiting {
+                resolveCallback(entry.callbackId, result: false)
+            }
+            return wasSounding
+        }
+
+        /// The page's rate, where 1 is normal, on AVSpeechUtterance's scale.
+        ///
+        /// Apple's scale is not linear in speed: the default sits at 0.5 and
+        /// the maximum is far faster than twice that. So a slower rate scales
+        /// the default down in proportion, and a faster one climbs toward the
+        /// maximum at half the slope, which keeps 2 brisk but intelligible.
+        private static func utteranceRate(_ rate: Double) -> Float {
+            let requested = Float(min(max(rate.isFinite ? rate : 1, 0.5), 2))
+            let normal = AVSpeechUtteranceDefaultSpeechRate
+            let mapped = requested <= 1
+                ? normal * requested
+                : normal + (AVSpeechUtteranceMaximumSpeechRate - normal) * (requested - 1) / 2
+            return min(max(mapped, AVSpeechUtteranceMinimumSpeechRate), AVSpeechUtteranceMaximumSpeechRate)
+        }
+
+        /// Duck the music rather than stop it, and play through the silent
+        /// switch.
+        ///
+        /// `.playback` is what the switch does not mute, `.duckOthers` lowers
+        /// the music under the cue, and the spoken-audio option pauses a
+        /// podcast rather than talking over it. Left alone while recognition
+        /// or a recording holds the session: switching it to playback would
+        /// cut their microphone off mid-take.
+        ///
+        /// Set up on the speech queue, then `start` runs on the main thread.
+        private func claimAudioSessionForSpeech(then start: @escaping () -> Void) {
+            let microphoneBusy = audioEngine.isRunning || (audioRecorder?.isRecording ?? false)
+            speechAudioQueue.async {
+                if self.speechAudioSessionToRestore == nil && !microphoneBusy {
+                    let session = AVAudioSession.sharedInstance()
+                    let previous = (session.category, session.mode, session.categoryOptions)
+                    do {
+                        try session.setCategory(.playback, mode: .voicePrompt, options: [.duckOthers, .interruptSpokenAudioAndMixWithOthers])
+                        try session.setActive(true)
+                        self.speechAudioSessionToRestore = previous
+                    } catch {
+                        // Still speak, through whatever session the app has: a
+                        // cue that does not duck beats one that never plays.
+                        print("[Craft] Speech audio session failed: \(error.localizedDescription)")
+                    }
+                }
+                DispatchQueue.main.async(execute: start)
+            }
+        }
+
+        /// Hand the audio back once nothing is left to say, so the music
+        /// returns to full volume instead of staying ducked, and put back the
+        /// category the app had, so the page's own media plays as before.
+        ///
+        /// Checked on the main thread, where the queue of utterances lives, and
+        /// done on the speech queue after any setup already asked for, so a
+        /// cue that arrives meanwhile reclaims the session after this.
+        private func releaseAudioSessionIfSilent(retry: Bool = true) {
+            guard pendingUtterances.isEmpty else { return }
+            speechAudioQueue.async {
+                guard let previous = self.speechAudioSessionToRestore else { return }
+                let session = AVAudioSession.sharedInstance()
+                do {
+                    try session.setActive(false, options: .notifyOthersOnDeactivation)
+                } catch {
+                    // Busy: the synthesizer's audio has not quite drained, or
+                    // the page has its own media playing. Once more shortly
+                    // covers the first; for the second, staying active is
+                    // right, and the ducking still ends when the music app
+                    // hears nothing more.
+                    if retry {
+                        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+                            self.releaseAudioSessionIfSilent(retry: false)
+                        }
+                        return
+                    }
+                    print("[Craft] Speech audio session release failed: \(error.localizedDescription)")
+                }
+                self.speechAudioSessionToRestore = nil
+                try? session.setCategory(previous.0, mode: previous.1, options: previous.2)
+            }
+        }
+
+        fileprivate func speechDidEnd(_ utterance: AVSpeechUtterance, spoken: Bool) {
+            if let index = pendingUtterances.firstIndex(where: { $0.utterance === utterance }) {
+                let entry = pendingUtterances.remove(at: index)
+                resolveCallback(entry.callbackId, result: spoken)
+            }
+            releaseAudioSessionIfSilent()
+        }
+
         // MARK: - Orientation Lock
         private func lockOrientation(_ orientation: String, callbackId: String?) {
             var mask: UIInterfaceOrientationMask = .all
@@ -6698,6 +6943,20 @@ extension URL {
 }
 
 // MARK: - Contact Picker Delegate
+// MARK: - AVSpeechSynthesizerDelegate
+//
+// The end of an utterance is what `craft.speech.speak()` waits for. Hopped to
+// main because every piece of speech state is touched there and nowhere else.
+extension CraftWebView.Coordinator: AVSpeechSynthesizerDelegate {
+    func speechSynthesizer(_ synthesizer: AVSpeechSynthesizer, didFinish utterance: AVSpeechUtterance) {
+        DispatchQueue.main.async { self.speechDidEnd(utterance, spoken: true) }
+    }
+
+    func speechSynthesizer(_ synthesizer: AVSpeechSynthesizer, didCancel utterance: AVSpeechUtterance) {
+        DispatchQueue.main.async { self.speechDidEnd(utterance, spoken: false) }
+    }
+}
+
 extension CraftWebView.Coordinator: CNContactPickerDelegate {
     func contactPicker(_ picker: CNContactPickerViewController, didSelect contact: CNContact) {
         let contactData = formatContact(contact)