@bubblsdk/react-native-sdk 4.1.7 → 5.0.0-alpha.2

package/ios-sdk/BubblSDK/Engine/SystemLog.swift

@@ -0,0 +1,27 @@
+import Foundation
+import os
+#if !COCOAPODS
+import BubblCore
+#endif
+
+/// Points the core's log at the system log (Console, `log stream --subsystem tech.bubbl.sdk`).
+/// Messages are public: the core's rule is that they carry ids, types and codes only. Errors also
+/// reach the app's event listeners (BubblEvent.error), whatever the log level.
+@available(iOS 17, *)
+enum SystemLog {
+    private static let logger = Logger(subsystem: "tech.bubbl.sdk", category: "Bubbl")
+
+    static func use(_ level: BubblOptions.LogLevel) {
+        let writes = level.core != nil
+        BubblLog.setSink(level: level.core ?? .error) { level, message in
+            if level == .error { BubblEvents.shared.emit(.error(message: message)) }
+            guard writes else { return }
+            switch level {
+            case .error: logger.error("\(message, privacy: .public)")
+            case .warning: logger.warning("\(message, privacy: .public)")
+            case .info: logger.info("\(message, privacy: .public)")
+            case .debug: logger.debug("\(message, privacy: .public)")
+            }
+        }
+    }
+}

package/ios-sdk/BubblSDK/Engine/WorkRunner.swift

@@ -0,0 +1,107 @@
+import Foundation
+#if !COCOAPODS
+import BubblCore
+#endif
+
+/// Runs the engine's work while the app is alive, as WorkManager does on Android: each job by name,
+/// one at a time (asked for again while running, it runs once more after), retried with a growing
+/// wait when it says `.retry`, and held back until the engine's data can be read: before the first
+/// unlock after a reboot the Keychain and the engine's files are closed. From then on they stay
+/// readable while the phone is locked, which is when most region events arrive, so nothing waits
+/// for an unlock.
+@available(iOS 17, *)
+actor WorkRunner {
+    typealias Work = @Sendable () async -> WorkOutcome
+
+    private static let maxDelaySeconds = 15 * 60
+
+    /// Whether the engine's data can be read now. Once it can, it stays so until the next reboot
+    /// (which ends the process), so it's asked only until it says yes.
+    private let dataReadable: @Sendable () -> Bool
+    private var ready = false
+    private var running: Set<String> = []
+    private var again: [String: Work] = [:]
+    private var held: [String: Work] = [:]
+    private var attempts: [String: Int] = [:]
+    private var waits: [String: Task<Void, Never>] = [:]
+
+    init(dataReadable: @escaping @Sendable () -> Bool = { true }) {
+        self.dataReadable = dataReadable
+    }
+
+    /// Run `work` as `name` now (or once the engine's data can be read).
+    func submit(_ name: String, _ work: @escaping Work) {
+        guard isReady() else {
+            held[name] = work
+            return
+        }
+        start(name, work)
+    }
+
+    /// Ask again whether the engine's data can be read (the device was unlocked).
+    func recheck() {
+        _ = isReady()
+    }
+
+    /// Asks until the data can be read; the moment it can, held work starts.
+    private func isReady() -> Bool {
+        guard !ready else { return true }
+        ready = dataReadable()
+        if ready {
+            let waiting = held
+            held.removeAll()
+            waiting.forEach { start($0.key, $0.value) }
+        }
+        return ready
+    }
+
+    private func start(_ name: String, _ work: @escaping Work) {
+        guard !running.contains(name) else {
+            again[name] = work
+            return
+        }
+        // Asked for now: whatever retry was waiting is overtaken.
+        waits.removeValue(forKey: name)?.cancel()
+        running.insert(name)
+        Task {
+            let outcome = await work()
+            finished(name, outcome, work)
+        }
+    }
+
+    /// Forget every job not already running (Bubbl.stop, an opt-out).
+    func cancelAll() {
+        waits.values.forEach { $0.cancel() }
+        waits.removeAll()
+        again.removeAll()
+        held.removeAll()
+        attempts.removeAll()
+    }
+
+    private func finished(_ name: String, _ outcome: WorkOutcome, _ work: @escaping Work) {
+        running.remove(name)
+        switch outcome {
+        case .done:
+            attempts[name] = nil
+            if let next = again.removeValue(forKey: name) { submit(name, next) }
+        case .retry(let afterSeconds):
+            let attempt = (attempts[name] ?? 0) + 1
+            attempts[name] = attempt
+            let next = again.removeValue(forKey: name) ?? work
+            // 30 s, 1 min, 2 min… up to 15 min, never sooner than asked, with a little jitter.
+            let backoff = min(30 << min(attempt - 1, 10), Self.maxDelaySeconds)
+            let seconds = Double(max(afterSeconds, backoff)) * Double.random(in: 1.0...1.1)
+            waits[name]?.cancel()
+            waits[name] = Task { [weak self] in
+                try? await Task.sleep(nanoseconds: UInt64(seconds * 1_000_000_000))
+                guard !Task.isCancelled else { return }
+                await self?.retry(name, next)
+            }
+        }
+    }
+
+    private func retry(_ name: String, _ work: @escaping Work) {
+        waits[name] = nil
+        submit(name, work)
+    }
+}

package/ios-sdk/BubblSDK/Notification/Look.swift

@@ -0,0 +1,78 @@
+#if os(iOS)
+import SwiftUI
+import UIKit
+
+/// The notification screen's look. An app changes any colour with a colour set of the same name
+/// in its asset catalogue (bubbl_accent, bubbl_surface…), light and dark, as Android's bubbl_
+/// colour resources; the defaults follow the system's light and dark appearance.
+@available(iOS 17, *)
+enum Look {
+    static let scrim = color("bubbl_scrim", light: 0x000000, 0.60, dark: 0x000000, 0.70)
+    static let surface = color("bubbl_surface", light: 0xFFFFFF, dark: 0x1D2027)
+    static let onSurface = color("bubbl_on_surface", light: 0x16181D, dark: 0xF1F2F5)
+    static let onSurfaceMuted = color("bubbl_on_surface_muted", light: 0x5F6570, dark: 0xA9AEB8)
+    static let outline = color("bubbl_outline", light: 0xD9DCE1, dark: 0x3A3F4A)
+    static let accent = color("bubbl_accent", light: 0x3E4BDB, dark: 0x8C95FF)
+    static let onAccent = color("bubbl_on_accent", light: 0xFFFFFF, dark: 0x10123A)
+    static let error = color("bubbl_error", light: 0xC62828, dark: 0xFF8A80)
+    static let mediaSurface = color("bubbl_media_surface", light: 0xF1F2F5, dark: 0x2A2E37)
+
+    static let cardMaxWidth: CGFloat = 480
+    static let cardRadius: CGFloat = 20
+    static let cardPadding: CGFloat = 20
+    static let mediaMaxHeight: CGFloat = 240
+
+    private static func color(_ name: String, light: UInt32, _ lightAlpha: CGFloat = 1, dark: UInt32, _ darkAlpha: CGFloat = 1) -> Color {
+        if let custom = UIColor(named: name, in: .main, compatibleWith: nil) { return Color(uiColor: custom) }
+        return Color(uiColor: UIColor { traits in
+            traits.userInterfaceStyle == .dark ? rgb(dark, darkAlpha) : rgb(light, lightAlpha)
+        })
+    }
+
+    private static func rgb(_ hex: UInt32, _ alpha: CGFloat) -> UIColor {
+        UIColor(
+            red: CGFloat((hex >> 16) & 0xFF) / 255,
+            green: CGFloat((hex >> 8) & 0xFF) / 255,
+            blue: CGFloat(hex & 0xFF) / 255,
+            alpha: alpha
+        )
+    }
+}
+
+/// The notification screen's words, in English unless the app gives its own: a Bubbl.strings
+/// table in the app (keys as Android's strings: bubbl_close, bubbl_next…), translated the usual way.
+@available(iOS 17, *)
+enum Words {
+    static func text(_ key: String, _ english: String) -> String {
+        Bundle.main.localizedString(forKey: key, value: english, table: "Bubbl")
+    }
+
+    static var close: String { text("bubbl_close", "Close") }
+    static var submit: String { text("bubbl_submit", "Send answers") }
+    static var thanks: String { text("bubbl_thanks", "Thanks for your answers") }
+    static var answerRequired: String { text("bubbl_answer_required", "Please answer this question to carry on") }
+    static var next: String { text("bubbl_next", "Next") }
+    static var back: String { text("bubbl_back", "Back") }
+    static var done: String { text("bubbl_done", "Done") }
+    static var yes: String { text("bubbl_yes", "Yes") }
+    static var no: String { text("bubbl_no", "No") }
+    static var answerHint: String { text("bubbl_answer_hint", "Your answer") }
+    static var numberHint: String { text("bubbl_number_hint", "A number") }
+    static var sliderUnanswered: String { text("bubbl_slider_unanswered", "Drag to answer") }
+    static var play: String { text("bubbl_play_media", "Play") }
+    static var pause: String { text("bubbl_pause_media", "Pause") }
+    static var open: String { text("bubbl_open_media", "Open") }
+
+    static func progress(_ step: Int, of total: Int) -> String {
+        String(format: text("bubbl_question_progress", "Question %1$d of %2$d"), step, total)
+    }
+
+    static func ratingStar(_ value: Int) -> String {
+        String(format: text("bubbl_rating_star", "%1$d of 5"), value)
+    }
+
+    static func mediaDescription(_ headline: String) -> String {
+        String(format: text("bubbl_media_description", "Image for %1$@"), headline)
+    }
+}
+#endif

package/ios-sdk/BubblSDK/Notification/NotificationMedia.swift

@@ -0,0 +1,329 @@
+#if os(iOS)
+import AVFoundation
+import AVKit
+import SwiftUI
+import WebKit
+#if !COCOAPODS
+import BubblCore
+#endif
+
+/// The media at the top of the card. Images show as they are; video and YouTube show their
+/// picture with a Play button and then play right there in the card (nothing plays, and no sound
+/// starts, until the person asks); audio's cover picture only (its player is a row in the card);
+/// other kinds (a PDF, a file) open outside.
+@available(iOS 17, *)
+struct MediaHeader: View {
+    @ObservedObject var model: NotificationModel
+    let media: BubblNotification.Media
+    @State private var playing = false
+
+    var body: some View {
+        switch media.kind {
+        case .image:
+            picture(height: Look.mediaMaxHeight)
+                .onAppear { if media.url != nil { model.mediaViewed() } }
+        case .video:
+            if playing, let url = media.url.flatMap(URL.init(string:)) {
+                InlineVideo(model: model, url: url).aspectRatio(16 / 9, contentMode: .fit)
+            } else {
+                videoPicture(button: media.url == nil ? nil : Words.play)
+            }
+        case .youtube:
+            if let id = media.url.flatMap(YouTube.videoId) {
+                if playing {
+                    YouTubePlayer(videoId: id)
+                        .aspectRatio(16 / 9, contentMode: .fit)
+                        .onAppear { model.mediaViewed() }
+                } else {
+                    videoPicture(button: Words.play)
+                }
+            } else {
+                openable
+            }
+        case .audio:
+            picture(height: Look.mediaMaxHeight)
+        case .application, .text, .file:
+            openable
+        }
+    }
+
+    /// Media the card can't show: its picture, and a button that opens it outside.
+    private var openable: some View {
+        picture(height: Look.mediaMaxHeight).overlay {
+            if let url = media.url, LinkPolicy.canOpen(url) {
+                OverlayButton(title: Words.open) { model.openMedia(url) }
+            }
+        }
+    }
+
+    private func videoPicture(button: String?) -> some View {
+        Color.clear
+            .aspectRatio(16 / 9, contentMode: .fit)
+            .overlay { picture(height: nil) }
+            .overlay {
+                if let button { OverlayButton(title: button) { playing = true } }
+            }
+            .clipped()
+    }
+
+    private func picture(height: CGFloat?) -> some View {
+        Look.outline
+            .frame(height: height)
+            .overlay {
+                if let url = media.pictureUrl.flatMap(URL.init(string:)) {
+                    AsyncImage(url: url) { phase in
+                        if let image = phase.image { image.resizable().scaledToFill() }
+                    }
+                }
+            }
+            .clipped()
+            .accessibilityElement()
+            .accessibilityLabel(Words.mediaDescription(model.notification.headline))
+            .accessibilityAddTraits(.isImage)
+    }
+}
+
+/// A video file, played in the card with the system's controls.
+@available(iOS 17, *)
+struct InlineVideo: View {
+    @ObservedObject var model: NotificationModel
+    let url: URL
+    @State private var player: AVPlayer?
+
+    var body: some View {
+        VideoPlayer(player: player)
+            .onAppear {
+                guard player == nil else { return }
+                Playback.prepareSession()
+                let created = AVPlayer(url: url)
+                player = created
+                created.play()
+                model.mediaViewed()
+            }
+            .onDisappear { player?.pause() }
+            .onReceive(NotificationCenter.default.publisher(for: AVPlayerItem.didPlayToEndTimeNotification)) { note in
+                guard let item = player?.currentItem, (note.object as? AVPlayerItem) === item else { return }
+                model.mediaCompleted(seconds: item.duration.seconds)
+            }
+    }
+}
+
+/// A YouTube video in YouTube's privacy-enhanced embedded player, in a web view kept to that one
+/// page: no script bridge to the app, nothing kept between runs, and any link in it (Watch on
+/// YouTube, the channel) opens outside rather than in the card. Its fullscreen button works. The
+/// page is loaded with the app's own https origin as its address: YouTube refuses an embed that
+/// doesn't say where it is (error 153).
+@available(iOS 17, *)
+struct YouTubePlayer: UIViewRepresentable {
+    let videoId: String
+
+    private static var origin: String {
+        "https://" + (Bundle.main.bundleIdentifier ?? "tech.bubbl.sdk").lowercased()
+    }
+
+    func makeCoordinator() -> Coordinator { Coordinator(origin: Self.origin) }
+
+    func makeUIView(context: Context) -> WKWebView {
+        let configuration = WKWebViewConfiguration()
+        configuration.allowsInlineMediaPlayback = true
+        // The person has just tapped Play: let the player start without a second tap.
+        configuration.mediaTypesRequiringUserActionForPlayback = []
+        configuration.websiteDataStore = .nonPersistent()
+        let web = WKWebView(frame: .zero, configuration: configuration)
+        web.navigationDelegate = context.coordinator
+        web.isOpaque = false
+        web.backgroundColor = .black
+        web.scrollView.isScrollEnabled = false
+        if let html = YouTube.embedHtml(videoId: videoId, origin: Self.origin) {
+            web.loadHTMLString(html, baseURL: URL(string: Self.origin))
+        }
+        return web
+    }
+
+    func updateUIView(_ web: WKWebView, context: Context) {}
+
+    static func dismantleUIView(_ web: WKWebView, coordinator: Coordinator) {
+        web.stopLoading()
+        web.loadHTMLString("", baseURL: nil)
+    }
+
+    @MainActor
+    final class Coordinator: NSObject, WKNavigationDelegate {
+        private let origin: String
+
+        init(origin: String) {
+            self.origin = origin
+        }
+
+        func webView(_ webView: WKWebView, decidePolicyFor navigationAction: WKNavigationAction) async -> WKNavigationActionPolicy {
+            // The embed's own frames (the player) load normally.
+            if let frame = navigationAction.targetFrame, !frame.isMainFrame { return .allow }
+            // The page itself, at the app's origin.
+            if let url = navigationAction.request.url, url.absoluteString.hasPrefix(origin) || url.scheme == "about" { return .allow }
+            // Anything else leaves the card: opened outside.
+            if let url = navigationAction.request.url, LinkPolicy.canOpen(url.absoluteString) {
+                _ = await UIApplication.shared.open(url)
+            }
+            return .cancel
+        }
+    }
+}
+
+/// Audio's player, a row in the card: play/pause, a position to drag, and elapsed / total time.
+/// Nothing loads or plays until Play is tapped.
+@available(iOS 17, *)
+struct AudioRow: View {
+    @ObservedObject var model: NotificationModel
+    let url: URL
+    @StateObject private var playback = Playback()
+
+    var body: some View {
+        HStack(spacing: 12) {
+            Button {
+                playback.toggle(url) { model.mediaViewed() } completed: { model.mediaCompleted(seconds: $0) }
+            } label: {
+                Image(systemName: playback.playing ? "pause.fill" : "play.fill")
+                    .font(.system(size: 18, weight: .semibold))
+                    .foregroundStyle(Look.onAccent)
+                    .frame(width: 44, height: 44)
+                    .background(Look.accent, in: Circle())
+                    .opacity(playback.loading ? 0.6 : 1)
+            }
+            .buttonStyle(.plain)
+            .disabled(playback.loading)
+            .accessibilityLabel(playback.playing ? Words.pause : Words.play)
+            .accessibilityIdentifier("bubbl.audio")
+
+            Slider(value: Binding(get: { playback.position }, set: { playback.seek($0) }), in: 0...max(playback.duration, 0.1))
+                .tint(Look.accent)
+                .disabled(!playback.started)
+                .accessibilityLabel(model.notification.headline)
+
+            Text("\(Self.clock(playback.position)) / \(Self.clock(playback.duration))")
+                .font(.footnote.monospacedDigit())
+                .foregroundStyle(Look.onSurfaceMuted)
+        }
+        .padding(EdgeInsets(top: 10, leading: 10, bottom: 10, trailing: 14))
+        .background(Look.mediaSurface, in: RoundedRectangle(cornerRadius: 16, style: .continuous))
+        .onDisappear { playback.stop() }
+    }
+
+    /// m:ss.
+    static func clock(_ seconds: Double) -> String {
+        let whole = seconds.isFinite ? max(Int(seconds), 0) : 0
+        return String(format: "%d:%02d", whole / 60, whole % 60)
+    }
+}
+
+/// One audio or video playback's state, for the audio row.
+@available(iOS 17, *)
+@MainActor
+final class Playback: ObservableObject {
+    @Published private(set) var playing = false
+    @Published private(set) var loading = false
+    @Published private(set) var started = false
+    @Published private(set) var position: Double = 0
+    @Published private(set) var duration: Double = 0
+
+    private var player: AVPlayer?
+    private var timeObserver: Any?
+    private var statusObservation: NSKeyValueObservation?
+    private var endObserver: NSObjectProtocol?
+
+    /// Plays even with the ring/silent switch on, as a person who taps Play expects, unless the app
+    /// has set its own audio session up (then that's left as it is).
+    static func prepareSession() {
+        let session = AVAudioSession.sharedInstance()
+        if session.category == .soloAmbient { try? session.setCategory(.playback) }
+    }
+
+    func toggle(_ url: URL, viewed: @escaping @MainActor () -> Void, completed: @escaping @MainActor (Double) -> Void) {
+        if let player {
+            if playing { player.pause() } else { player.play() }
+            playing.toggle()
+            return
+        }
+        Self.prepareSession()
+        loading = true
+        let item = AVPlayerItem(url: url)
+        let created = AVPlayer(playerItem: item)
+        player = created
+        statusObservation = Self.observeStatus(item) { [weak self] status, seconds in
+            Task { @MainActor in
+                guard let self else { return }
+                switch status {
+                case .readyToPlay where !self.started:
+                    self.loading = false
+                    self.started = true
+                    self.duration = seconds.isFinite ? seconds : 0
+                    self.player?.play()
+                    self.playing = true
+                    viewed()
+                case .failed:
+                    self.loading = false
+                    self.stop()
+                default:
+                    break
+                }
+            }
+        }
+        timeObserver = created.addPeriodicTimeObserver(forInterval: CMTime(seconds: 0.25, preferredTimescale: 600), queue: .main) { [weak self] time in
+            let seconds = time.seconds
+            MainActor.assumeIsolated { self?.position = seconds.isFinite ? seconds : 0 }
+        }
+        endObserver = NotificationCenter.default.addObserver(forName: AVPlayerItem.didPlayToEndTimeNotification, object: item, queue: .main) { [weak self] _ in
+            MainActor.assumeIsolated {
+                guard let self else { return }
+                self.playing = false
+                completed(self.duration)
+                self.player?.seek(to: .zero)
+                self.position = 0
+            }
+        }
+    }
+
+    /// The item's status as it changes, on whatever thread AVFoundation reports it (so not main-actor
+    /// code, which would trap off the main thread).
+    nonisolated private static func observeStatus(_ item: AVPlayerItem, _ handler: @escaping @Sendable (AVPlayerItem.Status, Double) -> Void) -> NSKeyValueObservation {
+        item.observe(\.status) { item, _ in handler(item.status, item.duration.seconds) }
+    }
+
+    func seek(_ seconds: Double) {
+        position = seconds
+        player?.seek(to: CMTime(seconds: seconds, preferredTimescale: 600))
+    }
+
+    func stop() {
+        player?.pause()
+        if let timeObserver { player?.removeTimeObserver(timeObserver) }
+        if let endObserver { NotificationCenter.default.removeObserver(endObserver) }
+        statusObservation?.invalidate()
+        timeObserver = nil
+        endObserver = nil
+        statusObservation = nil
+        player = nil
+        playing = false
+        started = false
+    }
+}
+
+/// A button over media: Play, or Open.
+@available(iOS 17, *)
+struct OverlayButton: View {
+    let title: String
+    let action: () -> Void
+
+    var body: some View {
+        Button(action: action) {
+            Text(title)
+                .font(.body.weight(.semibold))
+                .foregroundStyle(Look.onAccent)
+                .padding(.horizontal, 24)
+                .frame(minHeight: 48)
+                .background(Look.accent, in: Capsule())
+        }
+        .buttonStyle(.plain)
+        .accessibilityIdentifier("bubbl.media")
+    }
+}
+#endif