窗口、键盘与状态栏

- (UIWindow * _Nullable)internalGetKeyboardForScene:(UIWindowScene * _Nullable)scene {
    if (scene == nil) {
        return nil;
    }
    if (![scene respondsToSelector:@selector(keyboardSceneDelegate)]) {
        return nil;
    }

    id keyboardSceneDelegate = [(id<UIWindowSceneKeyboardProtocol>)scene keyboardSceneDelegate];
    if (![keyboardSceneDelegate respondsToSelector:@selector(keyboardWindow)]) {
        return nil;
    }

    // nil until the keyboard has been created for this scene, and also whenever the keyboard UI is
    // hosted out of process — in that configuration there is no in-process keyboard window at all.
    UIWindow *result = [(id<UIKeyboardSceneDelegateProtocol>)keyboardSceneDelegate keyboardWindow];
    if (![result isKindOfClass:[UIWindow class]]) {
        return nil;
    }

    return result;
}

private func isKeyboardWindow(window: NSObject) -> Bool {
    let typeName = NSStringFromClass(type(of: window))
    if #available(iOS 9.0, *) {
        if typeName.hasPrefix("UI") && typeName.hasSuffix("RemoteKeyboardWindow") {
            return true
        }
    } else {
        if typeName.hasPrefix("UI") && typeName.hasSuffix("TextEffectsWindow") {
            return true
        }
    }
    return false
}

private func isKeyboardView(view: NSObject) -> Bool {
    let typeName = NSStringFromClass(type(of: view))
    if typeName.hasPrefix("UI") && typeName.hasSuffix("InputSetHostView") {
        return true
    }
    if typeName.hasPrefix("UI") && typeName.hasSuffix("KeyboardItemContainerView") {
        return true
    }
    return false
}

func updateInteractiveInputOffset(_ offset: CGFloat, transition: ContainedViewLayoutTransition, completion: @escaping () -> Void) {
    guard let keyboardView = self.host.keyboardView else {
        return
    }

    self.interactiveInputOffset = offset

    let previousBounds = keyboardView.bounds
    let updatedBounds = CGRect(origin: CGPoint(x: 0.0, y: -offset), size: previousBounds.size)
    keyboardView.layer.bounds = updatedBounds
    if transition.isAnimated {
        transition.animateOffsetAdditive(layer: keyboardView.layer, offset: previousBounds.minY - updatedBounds.minY, completion: completion)
    } else {
        completion()
    }
}

if #available(iOSApplicationExtension 14.2, iOS 14.2, *), UIAccessibility.prefersCrossFadeTransitions {
} else if let keyboardView = strongSelf.statusBarHost?.keyboardView {
    if keyboardFrame.width.isEqual(to: keyboardView.bounds.width) && keyboardFrame.height.isEqual(to: keyboardView.bounds.height) && keyboardFrame.minX.isEqual(to: keyboardView.frame.minX) {
        keyboardFrame.origin.y = keyboardView.frame.minY
    }
}

var minKeyboardY: CGFloat?
if #available(iOSApplicationExtension 16.1, iOS 16.1, *), let screen = notification.object as? UIScreen, let keyboardFrameEnd = notification.userInfo?[UIResponder.keyboardFrameEndUserInfoKey] as? CGRect {
    let fromCoordinateSpace = screen.coordinateSpace
    let toCoordinateSpace: UICoordinateSpace = strongSelf.hostView.eventView
    let convertedKeyboardFrameEnd = fromCoordinateSpace.convert(keyboardFrameEnd, to: toCoordinateSpace)
    minKeyboardY = convertedKeyboardFrameEnd.minY
}

// ...
if keyboardFrame.isEmpty || keyboardFrame.maxY < screenHeight {
    if isWindowed || (isTablet && screenHeight - keyboardFrame.maxY < 5.0) {
        if let minKeyboardY {
            keyboardFrame.origin.y = minKeyboardY
        }
        keyboardHeight = max(0.0, screenHeight - keyboardFrame.minY)

let keyboardGestureBeginLocation = location
let view = self.hostView.containerView
let (firstResponder, accessoryHeight) = getFirstResponderAndAccessoryHeight(view)
if let inputHeight = self.windowLayout.inputHeight, !inputHeight.isZero, keyboardGestureBeginLocation.y < self.windowLayout.size.height - inputHeight - (accessoryHeight ?? 0.0) {
    var enableGesture = true
    if let view = self.hostView.containerView.hitTest(location, with: nil) {
        if doesViewTreeDisableInteractiveTransitionGestureRecognizer(view, keyboardOnly: true) {
            enableGesture = false
        }
    }
    if enableGesture, let _ = firstResponder {
        self.keyboardGestureBeginLocation = keyboardGestureBeginLocation
        self.keyboardGestureAccessoryHeight = accessoryHeight
    }
}
    if let keyboardGestureBeginLocation = self.keyboardGestureBeginLocation {
        let currentLocation = location
        let deltaY = keyboardGestureBeginLocation.y - location.y
        if deltaY * deltaY >= 3.0 * 3.0 || self.windowLayout.upperKeyboardInputPositionBound != nil {
            self.updateLayout {
                $0.update(upperKeyboardInputPositionBound: currentLocation.y + (self.keyboardGestureAccessoryHeight ?? 0.0), transition: .immediate, overrideTransition: false)
            }
        }
    }
}

var canDismiss = false
if let upperKeyboardInputPositionBound = self.windowLayout.upperKeyboardInputPositionBound, upperKeyboardInputPositionBound >= self.windowLayout.size.height - accessoryHeight {
    canDismiss = true
} else if let velocity = velocity, velocity.y > 100.0 {
    canDismiss = true
}

if canDismiss, let inputHeight = self.windowLayout.inputHeight, currentLocation.y + (self.keyboardGestureAccessoryHeight ?? 0.0) > self.windowLayout.size.height - inputHeight {
    // This release spent the finger's downward motion on the keyboard. Published for the
    // duration of the touch sequence so a scroll view released by the SAME finger — its pan
    // reports `.ended` later, in action dispatch — can decline to also fling its content.
    self.dismissedKeyboardByCurrentGestureValue = true

    let springDuration: CGFloat
    if #available(iOS 26.0, *) {
        springDuration = 0.3832
    } else {
        springDuration = 0.25
    }
    self.updateLayout {
        $0.update(upperKeyboardInputPositionBound: self.windowLayout.size.height, transition: .animated(duration: springDuration, curve: .spring), overrideTransition: false)
    }
}

void applyKeyboardAutocorrection(UITextView * _Nonnull textView) {
    NSRange rangeCopy = textView.selectedRange;
    NSRange fakeRange = rangeCopy;
    if (fakeRange.location != 0) {
        fakeRange.location--;
    }
    [textView unmarkText];
    [textView setSelectedRange:fakeRange];
    [textView setSelectedRange:rangeCopy];
}

if let firstResponderView = firstResponderView {
    let containerOrigin = firstResponderView.convert(CGPoint(), to: nil)
    var filteredTranslation = containerOrigin.x
    if firstResponderDisableAutomaticKeyboardHandling.contains(.forward) {
        filteredTranslation = max(0.0, filteredTranslation)
    }
    if firstResponderDisableAutomaticKeyboardHandling.contains(.backward) {
        filteredTranslation = min(0.0, filteredTranslation)
    }
    let horizontalTranslation = CATransform3DMakeTranslation(filteredTranslation, 0.0, 0.0)
    let currentTransform = keyboardWindow.layer.sublayerTransform
    if !CATransform3DEqualToTransform(horizontalTranslation, currentTransform) {
        keyboardWindow.layer.sublayerTransform = horizontalTranslation
    }
} else {
    keyboardWindow.layer.sublayerTransform = CATransform3DIdentity
    if let previousFirstResponderView = previousFirstResponderView {
        if previousFirstResponderView.window == nil {
            keyboardWindow.isHidden = true
            keyboardWindow.layer.cancelAnimationsRecursive(key: "position")
            keyboardWindow.layer.cancelAnimationsRecursive(key: "bounds")
            keyboardWindow.isHidden = false
        }
    }
}

context.withContext { c in
    c.translateBy(x: containingBounds.minX, y: -containingBounds.minY)
    UIGraphicsPushContext(c)
    self.targetView.layer.render(in: c)
    UIGraphicsPopContext()
}

// ...
tintStatusBarItem(context, type: type, style: self.statusBarStyle)
let image = context.generateImage()?.cgImage
self.contentNode.contents = image

let mappedFrame = self.targetView.convert(self.targetView.bounds, to: self.rootView)
self.frame = mappedFrame
self.contentNode.frame = containingBounds

private let foregroundClass: AnyClass? = {
    var nameString = "StatusBar"
    if CFAbsoluteTimeGetCurrent() > 0 {
        nameString += "ForegroundView"
    }
    return NSClassFromString("_UI" + nameString)
}()

private let foregroundClass2: AnyClass? = {
    var nameString = "StatusBar"
    if CFAbsoluteTimeGetCurrent() > 0 {
        nameString += "ForegroundView"
    }
    return NSClassFromString("UI" + nameString)
}()

private let batteryItemClass: AnyClass? = {
    var nameString = "StatusBarBattery"
    if CFAbsoluteTimeGetCurrent() > 0 {
        nameString += "ItemView"
    }
    return NSClassFromString("UI" + nameString)
}()

override var isHidden: Bool {
    get {
        return super.isHidden
    } set(value) {
        if super.isHidden != value {
            super.isHidden = value

            if !value {
                self.updateItems()
                self.timer = Timer(timeInterval: 5.0, target: StatusBarProxyNodeTimerTarget { [weak self] in
                    self?.updateItems()
                }, selector: #selector(StatusBarProxyNodeTimerTarget.tick), userInfo: nil, repeats: true)
                RunLoop.main.add(self.timer!, forMode: .common)
            } else {
                self.timer?.invalidate()
                self.timer = nil
            }
        }
    }
}

private func updateStatusBar(transition: ContainedViewLayoutTransition) {
    var style: UIStatusBarStyle = .default
    var isHidden = false

    if let rootController = self._rootController as? NavigationController {
        let statusBar = rootController.statusBar
        style = statusBar.style
        isHidden = statusBar.isHidden
    }

    if let statusBar = self.presentationContext.statusBar {
        style = statusBar.style
        isHidden = statusBar.isHidden
    }

    if let statusBar = self.topPresentationContext.statusBar {
        style = statusBar.style
        isHidden = statusBar.isHidden
    }

    self.hostView.updateStatusBar(style, isHidden, transition)
}

private func currentPresentationView(underStatusBar: Bool) -> UIView? {
    if let statusBarHost = self.statusBarHost {
        if let keyboardWindow = statusBarHost.keyboardWindow, let keyboardView = statusBarHost.keyboardView, !keyboardView.frame.height.isZero, isViewVisibleInHierarchy(keyboardView) {
            var updateTrackingNode = false
            if let trackingNode = self.currentTrackingNode {
                if trackingNode.layer.superlayer !== keyboardView.layer {
                    updateTrackingNode = true
                }
            } else {
                updateTrackingNode = true
            }

            // ...
            return keyboardWindow
        } else {
            if let view = self.parentView {
                return view
            }
        }
    }
    return nil
}

public func present(_ controller: ContainableController, on level: PresentationSurfaceLevel, blockInteraction: Bool = false, completion: @escaping () -> Void) {
    let controllerReady = controller.ready.get()
    |> filter({ $0 })
    |> take(1)
    |> deliverOnMainQueue
    |> timeout(2.0, queue: Queue.mainQueue(), alternate: .single(true))

    if let _ = self.view, let initialLayout = self.layout {
        if let controller = controller as? ViewController {
            if controller.lockOrientation {
                let orientations: UIInterfaceOrientationMask
                if initialLayout.size.width < initialLayout.size.height {
                    orientations = .portrait
                } else {
                    orientations = .landscape
                }

                controller.supportedOrientations = ViewControllerSupportedOrientations(regularSize: orientations, compactSize: orientations)
            }
        }
        let (controllerLayout, controllerFrame) = self.layoutForController(containerLayout: initialLayout, controller: controller)
        controller.view.frame = controllerFrame
        controller.containerLayoutUpdated(controllerLayout, transition: .immediate)

for view in self.hostView.eventView.subviews.reversed() {
    let classString = NSStringFromClass(type(of: view))

    // The system edit menu is inserted as a top-level subview of the window (== eventView) and must
    // be hit-tested here, otherwise its touches fall through to the content below. Pre-iOS-16 this is
    // a `UICalloutBar`/`...ContextMenuContainerView`; on iOS 16+ `UIEditMenuInteraction` hosts it in a
    // `_UIEditMenuContainerView` (matched via "EditMenu"). Without the iOS-16 case, tapping any item
    // in a UIEditMenuInteraction menu does nothing and the tap passes through to the content.
    if classString == "UITransitionView" || classString.contains("ContextMenuContainerView") || classString.contains("EditMenu") {
        if let result = view.hitTest(point, with: event) {
            return result
        }
    }
}

if let result = self.overlayPresentationContext.hitTest(point, with: event) {
    return result
}

self.isOpaque = false
self.delegate = self
self.scrollsToTop = true
self.contentInsetAdjustmentBehavior = .never
if #available(iOS 17.0, *) {
    self.allowsKeyboardScrolling = false
}

// ...
override var frame: CGRect {
    didSet {
        let frame = self.frame
        self.contentSize = CGSize(width: frame.width, height: frame.height + 1000.0)
        self.contentOffset = CGPoint(x: 0.0, y: 1000.0)
    }
}

@objc func scrollViewShouldScrollToTop(_ scrollView: UIScrollView) -> Bool {
    if let action = self.action {
        action()
    }

    return false
}

private func deviceSafeInsets(deviceMetrics: DeviceMetrics, windowSize: CGSize) -> UIEdgeInsets {
    let screenSize = UIScreen.main.bounds.size
    let portraitWindowSize = CGSize(width: min(windowSize.width, windowSize.height), height: max(windowSize.width, windowSize.height))
    let portraitScreenSize = CGSize(width: min(screenSize.width, screenSize.height), height: max(screenSize.width, screenSize.height))
    if abs(portraitWindowSize.width - portraitScreenSize.width) > 1.0 || abs(portraitWindowSize.height - portraitScreenSize.height) > 1.0 {
        return UIEdgeInsets()
    }
    return deviceMetrics.safeInsets(inLandscape: windowSize.width > windowSize.height)
}

private func windowSafeInsets(hostView: WindowHostView, deviceMetrics: DeviceMetrics, windowSize: CGSize) -> UIEdgeInsets {
    if DeviceMetrics.hasMultipleDisplays {
        let systemInsets = hostView.systemSafeAreaInsets
        return UIEdgeInsets(top: systemInsets.top, left: systemInsets.left, bottom: 0.0, right: systemInsets.right)
    }
    return deviceSafeInsets(deviceMetrics: deviceMetrics, windowSize: windowSize)
}

init(screenSize: CGSize, scale: CGFloat, statusBarHeight: CGFloat, onScreenNavigationHeight: CGFloat?, modelIdentifier: String?) {
    var screenSize = screenSize
    if screenSize.width > screenSize.height {
        screenSize = CGSize(width: screenSize.height, height: screenSize.width)
    }

    let additionalSize = CGSize(width: screenSize.width, height: screenSize.height + 20.0)
    if let modelIdentifier = modelIdentifier {
        for device in DeviceMetrics.profiles(for: modelIdentifier) {
            let deviceScale: CGFloat = device == .iPhoneXr ? 2.0 : 3.0
            if scale == deviceScale && (device.profileScreenSize == screenSize || device.profileScreenSize == additionalSize) {
                self = device
                return
            }
        }
    }

case .iPhone14Pro, .iPhone14ProMax:
    size = CGSize(width: 126.0, height: 112.0 / 3.0)
    top = 11.0
case .iPhone16Pro, .iPhone16ProMax:
    size = CGSize(width: 126.0, height: 112.0 / 3.0)
    top = 41.0 / 3.0
case .iPhone18Pro, .iPhone18ProMax:
    // Temporarily use the iPhone 16 Pro / Pro Max cutout geometry.
    size = CGSize(width: 126.0, height: 112.0 / 3.0)
    top = 41.0 / 3.0
case .iPhoneAir:
    size = CGSize(width: 126.0, height: 112.0 / 3.0)
    top = 59.0 / 3.0
case .iPhone14ProZoomed, .iPhone14ProMaxZoomed:
    let standardDevice: DeviceMetrics = self == .iPhone14ProZoomed ? .iPhone14Pro : .iPhone14ProMax
    guard let standardFrame = standardDevice.cutoutFrame else {
        return nil
    }
    let factor = self.profileScreenSize.width / standardDevice.profileScreenSize.width
    size = CGSize(width: standardFrame.width * factor, height: standardFrame.height * factor)
    top = standardFrame.minY * factor

/// The app's window moves between displays whose sensor housings and system bars differ (iPhone
/// Duo: the outer and the inner display), so no per-model table can describe its insets and they
/// are taken from the system instead. Keyed on the model identifier rather than on the resolved
/// profile, because the profile is matched by screen size and depends on which display was
/// active at launch.
static let hasMultipleDisplays: Bool = DeviceMetrics.currentModelIdentifier == "iPhone19,4"

// ...
private func systemStatusBarHeight() -> CGFloat? {
    let frameHeight = self.statusBarHost?.statusBarFrame.height ?? 0.0
    let screenSize = self.hostView.currentScreenSize
    if frameHeight > 0.0 {
        if let screenSize {
            self.visibleStatusBarHeights[ScreenBoundsKey(screenSize)] = frameHeight
        }
        return frameHeight
    }
    if let screenSize, let height = self.visibleStatusBarHeights[ScreenBoundsKey(screenSize)] {
        return height
    }
    let topInset = self.hostView.systemSafeAreaInsets.top
    return topInset > 0.0 ? topInset : nil
}

var orientations: UIInterfaceOrientationMask = defaultOrientations {
    didSet {
        if oldValue != self.orientations {
            if self.orientations == .portrait {
                if #available(iOSApplicationExtension 16.0, iOS 16.0, *) {
                    let windowScene = UIApplication.shared.connectedScenes.first as? UIWindowScene
                    windowScene?.requestGeometryUpdate(.iOS(interfaceOrientations: .portrait))
                    self.setNeedsUpdateOfSupportedInterfaceOrientations()
                } else if UIDevice.current.orientation != .portrait {
                    let value = UIInterfaceOrientation.portrait.rawValue
                    UIDevice.current.setValue(value, forKey: "orientation")
                }
            } else {
                if #available(iOSApplicationExtension 16.0, iOS 16.0, *) {
                    self.setNeedsUpdateOfSupportedInterfaceOrientations()
                } else {
                    UIViewController.attemptRotationToDeviceOrientation()
                }
            }
        }
    }
}

override var frame: CGRect {
    get {
        return super.frame
    } set(value) {
        let sizeUpdated = super.frame.size != value.size
        var frameTransition: ContainedViewLayoutTransition = .immediate
        if #available(iOSApplicationExtension 9.0, iOS 9.0, *) {
            let duration = UIView.inheritedAnimationDuration
            if !duration.isZero {
                frameTransition = .animated(duration: duration, curve: .easeInOut)
            }
        }
        if sizeUpdated, case let .animated(duration, curve) = frameTransition {
            let previousFrame = super.frame
            super.frame = value
            self.layer.animateFrame(from: previousFrame, to: value, duration: duration, timingFunction: curve.timingFunction)
        } else {
            super.frame = value
        }

        if sizeUpdated {
            self.updateSize?(value.size)
        }
    }
}