@onekeyfe/react-native-device-utils 6.7.0-alpha.385 → 6.7.0-alpha.388

package/android/src/main/java/com/margelo/nitro/reactnativedeviceutils/ReactNativeDeviceUtils.kt

@@ -765,6 +765,35 @@ class ReactNativeDeviceUtils : HybridReactNativeDeviceUtilsSpec(), LifecycleEven
         spanningChangedListeners.removeIf { it.id == id }
     }
 
+  // Android has no window controls inside the app window: the value is always
+  // zero and never changes, so listeners are accepted but never called.
+  override fun getWindowControlsInsets(): WindowControlsInsets =
+    WindowControlsInsets(0.0, 0.0, 0.0, 0.0)
+
+  override fun addWindowControlsInsetsChangedListener(
+    callback: (insets: WindowControlsInsets) -> Unit
+  ): Double = synchronized(this) {
+    val id = nextListenerId
+    nextListenerId++
+    return@synchronized id
+  }
+
+  override fun removeWindowControlsInsetsChangedListener(id: Double) {}
+
+  // Android has no app-owned main menu bar: the config is ignored, and
+  // listeners are accepted but never called.
+  override fun setMainMenuConfig(config: MainMenuConfig) {}
+
+  override fun addMainMenuCommandListener(
+    callback: (command: MainMenuCommand) -> Unit
+  ): Double = synchronized(this) {
+    val id = nextListenerId
+    nextListenerId++
+    return@synchronized id
+  }
+
+  override fun removeMainMenuCommandListener(id: Double) {}
+
   private fun startObservingLayoutChanges() {
     if (isObservingLayoutChanges) {
       return

package/ios/DualScreenDetector.swift

@@ -0,0 +1,158 @@
+import Foundation
+import UIKit
+import ReactNativeNativeLogger
+
+/// Detects foldable iPhones such as iPhone Duo.
+///
+/// Detection runs in two steps so the answer is available synchronously at
+/// launch and still covers models that are not listed yet:
+/// 1. The model identifier is matched against known foldable iPhones.
+/// 2. A `UIHingeInteraction` (iOS 27.1+) confirms the hinge at runtime.
+/// A positive result is persisted, so later launches answer synchronously
+/// even for models that only the hinge check recognized.
+final class DualScreenDetector {
+    static let shared = DualScreenDetector()
+
+    private static let cacheKey = "1k_is_dual_screen_device"
+    private static let foldableModelIdentifiers: Set<String> = [
+        "iPhone19,4", // iPhone Duo
+    ]
+
+    private let lock = NSLock()
+    private var isDualScreen: Bool
+    private var spanning = false
+    private var listeners: [Double: (Bool) -> Void] = [:]
+    private var nextListenerId: Double = 1
+    private var hingeObserver: AnyObject?
+
+    private init() {
+        let modelIdentifier = DualScreenDetector.modelIdentifier()
+        let isKnownModel = DualScreenDetector.foldableModelIdentifiers.contains(modelIdentifier)
+        let isCached = UserDefaults.standard.bool(forKey: DualScreenDetector.cacheKey)
+        isDualScreen = isKnownModel || isCached
+        if isKnownModel && !isCached {
+            UserDefaults.standard.set(true, forKey: DualScreenDetector.cacheKey)
+        }
+        OneKeyLog.info(
+            "DeviceUtils",
+            "Dual screen detection: model=\(modelIdentifier), knownModel=\(isKnownModel), cached=\(isCached)"
+        )
+        installHingeObserver()
+    }
+
+    static func modelIdentifier() -> String {
+        #if targetEnvironment(simulator)
+        if let identifier = ProcessInfo.processInfo.environment["SIMULATOR_MODEL_IDENTIFIER"],
+           !identifier.isEmpty {
+            return identifier
+        }
+        #endif
+        var systemInfo = utsname()
+        uname(&systemInfo)
+        return withUnsafePointer(to: &systemInfo.machine) { pointer in
+            pointer.withMemoryRebound(to: CChar.self, capacity: MemoryLayout.size(ofValue: pointer.pointee)) {
+                String(cString: $0)
+            }
+        }
+    }
+
+    var isDualScreenDevice: Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return isDualScreen
+    }
+
+    var isSpanning: Bool {
+        lock.lock()
+        defer { lock.unlock() }
+        return spanning
+    }
+
+    func addSpanningChangedListener(_ callback: @escaping (Bool) -> Void) -> Double {
+        lock.lock()
+        defer { lock.unlock() }
+        let id = nextListenerId
+        nextListenerId += 1
+        listeners[id] = callback
+        return id
+    }
+
+    func removeSpanningChangedListener(_ id: Double) {
+        lock.lock()
+        defer { lock.unlock() }
+        listeners.removeValue(forKey: id)
+    }
+
+    private func installHingeObserver() {
+        // UIHinge ships in the iOS 27.1 SDK (Swift 6.4). Older toolchains keep
+        // the model identifier and cache only.
+        #if compiler(>=6.4)
+        guard #available(iOS 27.1, *) else { return }
+        DispatchQueue.main.async { [weak self] in
+            self?.attachHingeInteraction()
+        }
+        #endif
+    }
+
+    #if compiler(>=6.4)
+    @available(iOS 27.1, *)
+    private func attachHingeInteraction() {
+        guard hingeObserver == nil else { return }
+        guard let window = DualScreenDetector.keyWindow() else {
+            // Native modules can initialize before the first window exists.
+            hingeObserver = NotificationCenter.default.addObserver(
+                forName: UIWindow.didBecomeKeyNotification,
+                object: nil,
+                queue: .main
+            ) { [weak self] _ in
+                guard let self, let observer = self.hingeObserver else { return }
+                NotificationCenter.default.removeObserver(observer)
+                self.hingeObserver = nil
+                self.attachHingeInteraction()
+            }
+            return
+        }
+        let interaction = UIHingeInteraction { [weak self] _, update in
+            self?.handleHingeUpdate(update.hinge)
+        }
+        window.addInteraction(interaction)
+        hingeObserver = interaction
+    }
+
+    @available(iOS 27.1, *)
+    private func handleHingeUpdate(_ hinge: UIHinge?) {
+        // A nil hinge means the hierarchy no longer provides hinge updates;
+        // keep the last known state.
+        guard let hinge else { return }
+        let nextSpanning = hinge.status == .fullyOpen || hinge.status == .partiallyOpen
+
+        lock.lock()
+        let isNewlyDetected = !isDualScreen
+        isDualScreen = true
+        let didChangeSpanning = spanning != nextSpanning
+        spanning = nextSpanning
+        let callbacks = Array(listeners.values)
+        lock.unlock()
+
+        if isNewlyDetected {
+            UserDefaults.standard.set(true, forKey: DualScreenDetector.cacheKey)
+            OneKeyLog.info(
+                "DeviceUtils",
+                "Dual screen detected by hinge: model=\(DualScreenDetector.modelIdentifier())"
+            )
+        }
+        // A newly detected device also notifies, so JS can react without
+        // waiting for the next fold.
+        if didChangeSpanning || isNewlyDetected {
+            callbacks.forEach { $0(nextSpanning) }
+        }
+    }
+    #endif
+
+    private static func keyWindow() -> UIWindow? {
+        UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .flatMap { $0.windows }
+            .first { $0.isKeyWindow }
+    }
+}

package/ios/MainMenuController.swift

@@ -0,0 +1,170 @@
+import Foundation
+import UIKit
+import ReactNativeNativeLogger
+
+/// Owns the app's custom main menu (the iPadOS menu bar).
+///
+/// JS supplies localized titles and Help links through `setMainMenuConfig`.
+/// The app delegate forwards `buildMenu(with:)` to `buildMenu(withBuilder:)`
+/// (it reaches this class through `NSClassFromString`, because the app target
+/// cannot import Nitro modules). App commands are `UIKeyCommand`s whose action
+/// lives on `UIApplication`, which is always in the responder chain, so the
+/// app delegate needs no command handler.
+public final class MainMenuController: NSObject {
+    static let shared = MainMenuController()
+
+    private struct Link {
+        let title: String
+        let url: URL
+    }
+
+    private struct Config {
+        let aboutTitle: String
+        let preferencesTitle: String
+        let lockNowTitle: String
+        let helpLinks: [Link]
+    }
+
+    private static let aboutMenuIdentifier = UIMenu.Identifier("so.onekey.mainMenu.about")
+    private static let settingsMenuIdentifier = UIMenu.Identifier("so.onekey.mainMenu.settings")
+
+    private let lock = NSLock()
+    private var config: Config?
+    private var listeners: [Double: (MainMenuCommand) -> Void] = [:]
+    private var nextListenerId: Double = 1
+
+    func setConfig(_ config: MainMenuConfig) {
+        let links = config.helpLinks.compactMap { link -> Link? in
+            guard let url = URL(string: link.url) else {
+                OneKeyLog.warn("DeviceUtils", "Main menu: invalid help link URL")
+                return nil
+            }
+            return Link(title: link.title, url: url)
+        }
+        let next = Config(
+            aboutTitle: config.aboutTitle,
+            preferencesTitle: config.preferencesTitle,
+            lockNowTitle: config.lockNowTitle,
+            helpLinks: links
+        )
+        lock.lock()
+        self.config = next
+        lock.unlock()
+        DispatchQueue.main.async {
+            UIMenuSystem.main.setNeedsRebuild()
+        }
+    }
+
+    func addListener(_ callback: @escaping (MainMenuCommand) -> Void) -> Double {
+        lock.lock()
+        defer { lock.unlock() }
+        let id = nextListenerId
+        nextListenerId += 1
+        listeners[id] = callback
+        return id
+    }
+
+    func removeListener(_ id: Double) {
+        lock.lock()
+        defer { lock.unlock() }
+        listeners.removeValue(forKey: id)
+    }
+
+    /// Called by the app delegate's `buildMenu(with:)` on the main thread.
+    @objc(buildMenuWithBuilder:)
+    public static func buildMenu(withBuilder builder: UIMenuBuilder) {
+        shared.build(builder)
+    }
+
+    fileprivate func perform(commandName: String) {
+        guard let command = MainMenuCommand(fromString: commandName) else { return }
+        lock.lock()
+        let callbacks = Array(listeners.values)
+        lock.unlock()
+        OneKeyLog.info("DeviceUtils", "Main menu command: \(commandName), listeners=\(callbacks.count)")
+        callbacks.forEach { $0(command) }
+    }
+
+    private func build(_ builder: UIMenuBuilder) {
+        guard builder.system == .main else { return }
+
+        // A wallet has no documents to open or text to format.
+        builder.remove(menu: .file)
+        builder.remove(menu: .format)
+
+        lock.lock()
+        let config = self.config
+        lock.unlock()
+        // Keep the system app and Help menus until JS provides localized titles.
+        guard let config else { return }
+
+        let action = #selector(UIApplication.onekeyPerformMainMenuCommand(_:))
+        let about = UICommand(
+            title: config.aboutTitle,
+            action: action,
+            propertyList: MainMenuCommand.about.stringValue
+        )
+        let preferences = UIKeyCommand(
+            title: config.preferencesTitle,
+            action: action,
+            input: ",",
+            modifierFlags: .command,
+            propertyList: MainMenuCommand.preferences.stringValue
+        )
+        let lockNow = UIKeyCommand(
+            title: config.lockNowTitle,
+            action: action,
+            input: "l",
+            modifierFlags: [.command, .shift],
+            propertyList: MainMenuCommand.locknow.stringValue
+        )
+        let aboutMenu = UIMenu(
+            title: "",
+            identifier: MainMenuController.aboutMenuIdentifier,
+            options: .displayInline,
+            children: [about]
+        )
+        let settingsMenu = UIMenu(
+            title: "",
+            identifier: MainMenuController.settingsMenuIdentifier,
+            options: .displayInline,
+            children: [preferences, lockNow]
+        )
+
+        // The system Preferences item opens the app's page in the Settings app;
+        // replace it with the in-app preferences, which own the same shortcut.
+        if builder.menu(for: .preferences) != nil {
+            builder.replace(menu: .preferences, with: settingsMenu)
+        } else {
+            builder.insertChild(settingsMenu, atStartOfMenu: .application)
+        }
+        // An empty About title removes the item (Travel Mode hides About).
+        if config.aboutTitle.isEmpty {
+            builder.remove(menu: .about)
+        } else if builder.menu(for: .about) != nil {
+            builder.replace(menu: .about, with: aboutMenu)
+        } else {
+            builder.insertSibling(aboutMenu, beforeMenu: MainMenuController.settingsMenuIdentifier)
+        }
+
+        if config.helpLinks.isEmpty {
+            builder.remove(menu: .help)
+        } else if builder.menu(for: .help) != nil {
+            let links = config.helpLinks.map { link in
+                UIAction(title: link.title) { _ in
+                    UIApplication.shared.open(link.url)
+                }
+            }
+            builder.replaceChildren(ofMenu: .help) { _ in links }
+        }
+    }
+}
+
+extension UIApplication {
+    /// Action of the main menu app commands; the command name is the
+    /// command's property list.
+    @objc func onekeyPerformMainMenuCommand(_ sender: UICommand) {
+        guard let name = sender.propertyList as? String else { return }
+        MainMenuController.shared.perform(commandName: name)
+    }
+}

package/ios/ReactNativeDeviceUtils.swift

@@ -112,14 +112,14 @@ class ReactNativeDeviceUtils: HybridReactNativeDeviceUtilsSpec {
     }
 
     public func isDualScreenDevice() throws -> Bool {
-        return false
+        return DualScreenDetector.shared.isDualScreenDevice
     }
 
     public func initEventListeners() throws -> Void {
     }
-    
+
     public func isSpanning() throws -> Bool {
-        return false
+        return DualScreenDetector.shared.isSpanning
     }
     
     public func getWindowRects() throws -> Promise<[DualScreenInfoRect]> {
@@ -132,10 +132,35 @@ class ReactNativeDeviceUtils: HybridReactNativeDeviceUtilsSpec {
 
    
     func addSpanningChangedListener(callback: @escaping (Bool) -> Void) throws -> Double {
-        return 0
+        return DualScreenDetector.shared.addSpanningChangedListener(callback)
     }
 
     func removeSpanningChangedListener(id: Double) throws -> Void {
+        DualScreenDetector.shared.removeSpanningChangedListener(id)
+    }
+
+    func getWindowControlsInsets() throws -> WindowControlsInsets {
+        return WindowControlsInsetsObserver.shared.currentInsets
+    }
+
+    func addWindowControlsInsetsChangedListener(callback: @escaping (WindowControlsInsets) -> Void) throws -> Double {
+        return WindowControlsInsetsObserver.shared.addListener(callback)
+    }
+
+    func removeWindowControlsInsetsChangedListener(id: Double) throws -> Void {
+        WindowControlsInsetsObserver.shared.removeListener(id)
+    }
+
+    func setMainMenuConfig(config: MainMenuConfig) throws -> Void {
+        MainMenuController.shared.setConfig(config)
+    }
+
+    func addMainMenuCommandListener(callback: @escaping (MainMenuCommand) -> Void) throws -> Double {
+        return MainMenuController.shared.addListener(callback)
+    }
+
+    func removeMainMenuCommandListener(id: Double) throws -> Void {
+        MainMenuController.shared.removeListener(id)
     }
     
     

package/ios/WindowControlsInsetsObserver.swift

@@ -0,0 +1,149 @@
+import Foundation
+import UIKit
+import ReactNativeNativeLogger
+
+/// Tracks how much room the key window's system window controls (the iPadOS
+/// window controls in the top-leading corner, for example) take beyond the
+/// safe area.
+///
+/// UIKit reports the controls through the safe area with horizontal corner
+/// adaptation (iOS 26+). An invisible view spanning the window recomputes the
+/// difference on every layout and safe area change, so window resizes and
+/// entering or leaving full screen update the value.
+final class WindowControlsInsetsObserver {
+    static let shared = WindowControlsInsetsObserver()
+
+    private let lock = NSLock()
+    private var insets = WindowControlsInsets(top: 0, left: 0, bottom: 0, right: 0)
+    private var listeners: [Double: (WindowControlsInsets) -> Void] = [:]
+    private var nextListenerId: Double = 1
+    private var keyWindowObserver: NSObjectProtocol?
+    private weak var trackingView: UIView?
+
+    private init() {
+        DispatchQueue.main.async { [weak self] in
+            self?.install()
+        }
+    }
+
+    var currentInsets: WindowControlsInsets {
+        lock.lock()
+        defer { lock.unlock() }
+        return insets
+    }
+
+    func addListener(_ callback: @escaping (WindowControlsInsets) -> Void) -> Double {
+        lock.lock()
+        defer { lock.unlock() }
+        let id = nextListenerId
+        nextListenerId += 1
+        listeners[id] = callback
+        return id
+    }
+
+    func removeListener(_ id: Double) {
+        lock.lock()
+        defer { lock.unlock() }
+        listeners.removeValue(forKey: id)
+    }
+
+    private func install() {
+        // UIView.LayoutRegion ships in the iOS 26 SDK (Swift 6.2). Older
+        // toolchains and systems keep the all-zero value.
+        #if compiler(>=6.2)
+        guard #available(iOS 26.0, *) else { return }
+        guard trackingView == nil else { return }
+        guard let window = WindowControlsInsetsObserver.keyWindow() else {
+            // Native modules can initialize before the first window exists.
+            guard keyWindowObserver == nil else { return }
+            keyWindowObserver = NotificationCenter.default.addObserver(
+                forName: UIWindow.didBecomeKeyNotification,
+                object: nil,
+                queue: .main
+            ) { [weak self] _ in
+                guard let self, let observer = self.keyWindowObserver else { return }
+                NotificationCenter.default.removeObserver(observer)
+                self.keyWindowObserver = nil
+                self.install()
+            }
+            return
+        }
+        let view = WindowControlsTrackingView(frame: window.bounds) { [weak self] view in
+            self?.update(from: view)
+        }
+        view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+        view.isUserInteractionEnabled = false
+        view.isAccessibilityElement = false
+        // Behind the root view controller's view, so it never draws or
+        // receives touches above app content.
+        window.insertSubview(view, at: 0)
+        trackingView = view
+        update(from: view)
+        #endif
+    }
+
+    #if compiler(>=6.2)
+    @available(iOS 26.0, *)
+    private func update(from view: UIView) {
+        let safeArea = view.safeAreaInsets
+        let adapted = view.edgeInsets(for: .safeArea(cornerAdaptation: .horizontal))
+        let next = WindowControlsInsets(
+            top: Double(max(0, adapted.top - safeArea.top)),
+            left: Double(max(0, adapted.left - safeArea.left)),
+            bottom: Double(max(0, adapted.bottom - safeArea.bottom)),
+            right: Double(max(0, adapted.right - safeArea.right))
+        )
+
+        lock.lock()
+        let previous = insets
+        let didChange = previous.top != next.top
+            || previous.left != next.left
+            || previous.bottom != next.bottom
+            || previous.right != next.right
+        if didChange {
+            insets = next
+        }
+        let callbacks = didChange ? Array(listeners.values) : []
+        lock.unlock()
+
+        guard didChange else { return }
+        OneKeyLog.debug(
+            "DeviceUtils",
+            "Window controls insets: top=\(next.top), left=\(next.left), bottom=\(next.bottom), right=\(next.right)"
+        )
+        callbacks.forEach { $0(next) }
+    }
+    #endif
+
+    private static func keyWindow() -> UIWindow? {
+        UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .flatMap { $0.windows }
+            .first { $0.isKeyWindow }
+    }
+}
+
+/// Invisible full-window view that reports layout and safe area changes.
+private final class WindowControlsTrackingView: UIView {
+    private let onChange: (UIView) -> Void
+
+    init(frame: CGRect, onChange: @escaping (UIView) -> Void) {
+        self.onChange = onChange
+        super.init(frame: frame)
+    }
+
+    @available(*, unavailable)
+    required init?(coder: NSCoder) {
+        fatalError("init(coder:) has not been implemented")
+    }
+
+    override func layoutSubviews() {
+        super.layoutSubviews()
+        onChange(self)
+    }
+
+    override func safeAreaInsetsDidChange() {
+        super.safeAreaInsetsDidChange()
+        onChange(self)
+    }
+}

package/lib/typescript/src/ReactNativeDeviceUtils.nitro.d.ts

@@ -9,6 +9,35 @@ export interface DualScreenInfoRect {
     width: number;
     height: number;
 }
+/**
+ * Extra room, in points beyond the safe area, that content near the window
+ * corners must leave for system window controls (the iPadOS window controls in
+ * the top-leading corner, for example). All zero when no controls are shown.
+ */
+export interface WindowControlsInsets {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+}
+/** App commands in the iPadOS menu bar that JS performs. */
+export type MainMenuCommand = 'about' | 'preferences' | 'lockNow';
+export interface MainMenuLink {
+    title: string;
+    url: string;
+}
+/**
+ * Localized content of the custom main menu (the iPadOS menu bar). Help links
+ * open in the system browser natively; the other items notify JS. An empty
+ * `aboutTitle` removes the About item and empty `helpLinks` remove the Help
+ * menu.
+ */
+export interface MainMenuConfig {
+    aboutTitle: string;
+    preferencesTitle: string;
+    lockNowTitle: string;
+    helpLinks: MainMenuLink[];
+}
 export interface LaunchOptions {
     launchType: string;
     deepLink?: string;
@@ -43,6 +72,23 @@ export interface ReactNativeDeviceUtils extends HybridObject<{
     addSpanningChangedListener(callback: (isSpanning: boolean) => void): number;
     removeSpanningChangedListener(id: number): void;
     setUserInterfaceStyle(style: UserInterfaceStyle): void;
+    /**
+     * Window-controls insets of the app's main window, for content that adapts
+     * horizontally (a header row beside the controls). iOS 26+ reads UIKit's
+     * safe area with horizontal corner adaptation; Android and older iOS return
+     * all zeros. Listeners fire on the main thread when the value changes.
+     */
+    getWindowControlsInsets(): WindowControlsInsets;
+    addWindowControlsInsetsChangedListener(callback: (insets: WindowControlsInsets) => void): number;
+    removeWindowControlsInsetsChangedListener(id: number): void;
+    /**
+     * Replaces the custom main menu content and rebuilds the menu bar. The menu
+     * only shows on iPadOS (and in windows with a menu bar); Android ignores it.
+     */
+    setMainMenuConfig(config: MainMenuConfig): void;
+    /** Listeners fire on the main thread when the user picks an app command. */
+    addMainMenuCommandListener(callback: (command: MainMenuCommand) => void): number;
+    removeMainMenuCommandListener(id: number): void;
     getLaunchOptions(): Promise<LaunchOptions>;
     clearLaunchOptions(): Promise<boolean>;
     getDeviceToken(): Promise<string>;