@onekeyfe/react-native-device-utils 6.7.0-2 → 6.7.0-20

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

@@ -4,9 +4,11 @@ import android.app.Activity
 import android.content.Context
 import android.content.pm.PackageManager
 import android.graphics.Color
+import android.graphics.drawable.GradientDrawable
 import android.graphics.Rect
 import android.os.Build
 import android.view.Gravity
+import android.view.WindowInsetsController
 import android.view.View
 import android.view.ViewGroup
 import android.widget.FrameLayout
@@ -763,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
@@ -909,16 +940,30 @@ class ReactNativeDeviceUtils : HybridReactNativeDeviceUtilsSpec(), LifecycleEven
         val window = activity.window
         val decorView = window.decorView
 
-        WindowCompat.getInsetsController(window, decorView)
-          .isAppearanceLightNavigationBars = appearance.useDarkIcons
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
+          // WindowInsetsControllerCompat leaves the previous value in place on
+          // Android 11-14 once the window is appearance-controlled, so runtime
+          // theme switches kept stale button colors. Use the platform API.
+          window.insetsController?.setSystemBarsAppearance(
+            if (appearance.useDarkIcons) WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS else 0,
+            WindowInsetsController.APPEARANCE_LIGHT_NAVIGATION_BARS,
+          )
+        } else {
+          WindowCompat.getInsetsController(window, decorView)
+            .isAppearanceLightNavigationBars = appearance.useDarkIcons
+        }
 
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
           window.isNavigationBarContrastEnforced = false
         }
 
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM) {
-          // Android 15 enforces edge-to-edge. Keep the platform bar transparent
-          // and draw the requested color only behind three-button navigation.
+        if (
+          Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM ||
+          com.facebook.react.views.view.isEdgeToEdgeFeatureFlagOn
+        ) {
+          // Edge-to-edge windows (enforced on Android 15, opted in below it) keep
+          // the platform bar transparent and draw the requested color only
+          // behind three-button navigation.
           window.navigationBarColor = Color.TRANSPARENT
           installNavigationBarProtection(decorView, appearance.color)
         } else {
@@ -953,7 +998,6 @@ class ReactNativeDeviceUtils : HybridReactNativeDeviceUtilsSpec(), LifecycleEven
       )
     }
 
-    protectionView.setBackgroundColor(color)
     protectionView.visibility = View.VISIBLE
     protectionView.bringToFront()
     ViewCompat.setOnApplyWindowInsetsListener(protectionView) { view, windowInsets ->
@@ -985,6 +1029,17 @@ class ReactNativeDeviceUtils : HybridReactNativeDeviceUtilsSpec(), LifecycleEven
         )
         else -> Triple(0, 0, Gravity.BOTTOM)
       }
+      // Fade in over the first third from the content edge so the protection never
+      // draws a hard line against the page; the buttons sit on the solid rest.
+      val fadeOrientation = when (gravity) {
+        Gravity.LEFT -> GradientDrawable.Orientation.RIGHT_LEFT
+        Gravity.RIGHT -> GradientDrawable.Orientation.LEFT_RIGHT
+        else -> GradientDrawable.Orientation.TOP_BOTTOM
+      }
+      view.background = GradientDrawable(
+        fadeOrientation,
+        intArrayOf(color and 0x00FFFFFF, color, color, color),
+      )
       if (
         layoutParams.width != width ||
         layoutParams.height != height ||

package/ios/DualScreenDetector.swift

@@ -0,0 +1,170 @@
+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 hingeInteraction: UIInteraction?
+    private var keyWindowObserver: NSObjectProtocol?
+    private var resignKeyWindowObserver: NSObjectProtocol?
+
+    private init() {
+        let modelIdentifier = DualScreenDetector.modelIdentifier()
+        let isKnownModel = DualScreenDetector.foldableModelIdentifiers.contains(modelIdentifier)
+        let isCached = UserDefaults.standard.string(forKey: DualScreenDetector.cacheKey) == modelIdentifier
+        isDualScreen = isKnownModel || isCached
+        if isKnownModel && !isCached {
+            UserDefaults.standard.set(modelIdentifier, 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
+            guard let self else { return }
+            self.keyWindowObserver = NotificationCenter.default.addObserver(
+                forName: UIWindow.didBecomeKeyNotification,
+                object: nil,
+                queue: .main
+            ) { [weak self] notification in
+                guard let window = notification.object as? UIWindow else { return }
+                self?.attachHingeInteraction(in: window)
+            }
+            self.resignKeyWindowObserver = NotificationCenter.default.addObserver(
+                forName: UIWindow.didResignKeyNotification,
+                object: nil,
+                queue: .main
+            ) { [weak self] notification in
+                guard let self, let window = notification.object as? UIWindow,
+                      self.hingeInteraction?.view === window else { return }
+                self.attachHingeInteraction(in: nil)
+            }
+            self.attachHingeInteraction(in: DualScreenDetector.keyWindow())
+        }
+        #endif
+    }
+
+    #if compiler(>=6.4)
+    @available(iOS 27.1, *)
+    private func attachHingeInteraction(in window: UIWindow?) {
+        if let interaction = hingeInteraction, interaction.view === window { return }
+        let previousInteraction = hingeInteraction
+        hingeInteraction = nil
+        if let interaction = previousInteraction {
+            interaction.view?.removeInteraction(interaction)
+        }
+        handleHingeUpdate(nil)
+        // A listener can change the key window while spanning is reset.
+        guard let window, window.isKeyWindow, hingeInteraction == nil else { return }
+        let interaction = UIHingeInteraction { [weak self] interaction, update in
+            guard let self, self.hingeInteraction === interaction else { return }
+            self.handleHingeUpdate(update.hinge)
+        }
+        hingeInteraction = interaction
+        window.addInteraction(interaction)
+    }
+
+    @available(iOS 27.1, *)
+    private func handleHingeUpdate(_ hinge: UIHinge?) {
+        let nextSpanning = hinge?.status == .fullyOpen || hinge?.status == .partiallyOpen
+
+        lock.lock()
+        let isNewlyDetected = hinge != nil && !isDualScreen
+        if hinge != nil { isDualScreen = true }
+        let didChangeSpanning = spanning != nextSpanning
+        spanning = nextSpanning
+        let callbacks = Array(listeners.values)
+        lock.unlock()
+
+        if isNewlyDetected {
+            UserDefaults.standard.set(DualScreenDetector.modelIdentifier(), 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,151 @@
+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(in keyWindow: UIWindow? = nil) {
+        // 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 }
+        if keyWindowObserver == nil {
+            keyWindowObserver = NotificationCenter.default.addObserver(
+                forName: UIWindow.didBecomeKeyNotification,
+                object: nil,
+                queue: .main
+            ) { [weak self] notification in
+                guard let window = notification.object as? UIWindow else { return }
+                self?.install(in: window)
+            }
+        }
+        guard let window = keyWindow ?? WindowControlsInsetsObserver.keyWindow() else { return }
+        if let view = trackingView, view.window === window {
+            update(from: view)
+            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.
+        let previousView = trackingView
+        trackingView = view
+        previousView?.removeFromSuperview()
+        window.insertSubview(view, at: 0)
+        update(from: view)
+        #endif
+    }
+
+    #if compiler(>=6.2)
+    @available(iOS 26.0, *)
+    private func update(from view: UIView) {
+        guard view === trackingView else { return }
+        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)
+    }
+}