@onekeyfe/react-native-native-sheet 3.0.128 → 3.0.130

package/ios/NativeSheetContainerView.swift

@@ -1,6 +1,98 @@
 import React
 import UIKit
 
+private enum NativeSheetQuickAnimation {
+  static func makeAnimator() -> UIViewPropertyAnimator {
+    let timing = UISpringTimingParameters(
+      mass: 0.1,
+      stiffness: 100,
+      damping: 20,
+      initialVelocity: .zero
+    )
+    return UIViewPropertyAnimator(duration: 0, timingParameters: timing)
+  }
+
+  static var duration: TimeInterval {
+    makeAnimator().duration
+  }
+}
+
+private final class NativeSheetTransitionAnimator: NSObject,
+  UIViewControllerAnimatedTransitioning {
+  private let presenting: Bool
+  private var animator: UIViewPropertyAnimator?
+
+  init(presenting: Bool) {
+    self.presenting = presenting
+  }
+
+  func transitionDuration(
+    using transitionContext: UIViewControllerContextTransitioning?
+  ) -> TimeInterval {
+    NativeSheetQuickAnimation.duration
+  }
+
+  func animateTransition(using transitionContext: UIViewControllerContextTransitioning) {
+    let animator = interruptibleAnimator(using: transitionContext)
+    animator.startAnimation()
+  }
+
+  func interruptibleAnimator(
+    using transitionContext: UIViewControllerContextTransitioning
+  ) -> UIViewImplicitlyAnimating {
+    if let animator {
+      return animator
+    }
+
+    let key: UITransitionContextViewKey = presenting ? .to : .from
+    guard let sheetView = transitionContext.view(forKey: key) else {
+      transitionContext.completeTransition(false)
+      return NativeSheetQuickAnimation.makeAnimator()
+    }
+    let controllerKey: UITransitionContextViewControllerKey = presenting ? .to : .from
+    guard let sheetController = transitionContext.viewController(forKey: controllerKey)
+      as? NativeSheetViewController else {
+      transitionContext.completeTransition(false)
+      return NativeSheetQuickAnimation.makeAnimator()
+    }
+    let container = transitionContext.containerView
+    let finalFrame = presenting
+      ? transitionContext.finalFrame(for: sheetController)
+      : sheetView.frame
+    let travel = max(container.bounds.maxY - finalFrame.minY, sheetView.bounds.height)
+    let offscreenTransform = CGAffineTransform(translationX: 0, y: travel)
+
+    if presenting {
+      sheetView.frame = finalFrame
+      sheetView.transform = offscreenTransform
+      sheetController.setDimmingAlpha(0)
+      if sheetView.superview == nil {
+        container.addSubview(sheetView)
+      }
+    }
+
+    let animator = NativeSheetQuickAnimation.makeAnimator()
+    animator.addAnimations {
+      sheetView.transform = self.presenting ? .identity : offscreenTransform
+      sheetController.setDimmingAlpha(self.presenting ? sheetController.resolvedDimAmount : 0)
+    }
+    animator.addCompletion { position in
+      let completed = position == .end && !transitionContext.transitionWasCancelled
+      if !completed {
+        sheetView.transform = self.presenting ? offscreenTransform : .identity
+        sheetController.setDimmingAlpha(self.presenting ? 0 : sheetController.resolvedDimAmount)
+      }
+      transitionContext.completeTransition(completed)
+    }
+    self.animator = animator
+    return animator
+  }
+
+  func animationEnded(_ transitionCompleted: Bool) {
+    animator = nil
+  }
+}
+
 private final class WeakSheetHost {
   weak var value: NativeSheetContainerView?
 
@@ -105,10 +197,14 @@ private final class NativeSheetPresentationCoordinator {
     }
     pending.removeFirst()
     guard host.shouldPresent else {
+      host.finishFailedPresentation(
+        reason: host.securityBlocked ? "security" : (host.open ? "system" : "programmatic")
+      )
       processPending()
       return
     }
     guard let presenter = topViewController() else {
+      host.finishFailedPresentation(reason: "system")
       processPending()
       return
     }
@@ -191,9 +287,12 @@ private final class NativeSheetPresentationCoordinator {
 
 private final class NativeSheetViewController: UIViewController,
   UIAdaptivePresentationControllerDelegate,
-  UIGestureRecognizerDelegate {
+  UIViewControllerTransitioningDelegate {
   let host: NativeSheetContainerView
-  private let lockedHeight: CGFloat
+  private let detentIdentifier = UISheetPresentationController.Detent.Identifier(
+    "onekey.nativeSheet.fixed"
+  )
+  private var targetHeight: CGFloat
   private let backgroundColorValue: UIColor
   private let cornerRadiusValue: CGFloat
   private let showHandleValue: Bool
@@ -201,6 +300,12 @@ private final class NativeSheetViewController: UIViewController,
   private let dimAmountValue: CGFloat
   private var backdropTap: UITapGestureRecognizer?
   private var dimmingView: UIView?
+  private var heightAnimator: UIViewPropertyAnimator?
+  private var shadowSuppressionDisplayLink: CADisplayLink?
+
+  fileprivate var resolvedDimAmount: CGFloat {
+    dimAmountValue
+  }
 
   init(
     host: NativeSheetContainerView,
@@ -212,7 +317,7 @@ private final class NativeSheetViewController: UIViewController,
     dimAmount: CGFloat
   ) {
     self.host = host
-    self.lockedHeight = height
+    self.targetHeight = height
     self.backgroundColorValue = backgroundColor
     self.cornerRadiusValue = cornerRadius
     self.showHandleValue = showHandle
@@ -220,6 +325,7 @@ private final class NativeSheetViewController: UIViewController,
     self.dimAmountValue = min(max(dimAmount, 0), 1)
     super.init(nibName: nil, bundle: nil)
     modalPresentationStyle = .pageSheet
+    transitioningDelegate = self
   }
 
   @available(*, unavailable)
@@ -235,6 +341,7 @@ private final class NativeSheetViewController: UIViewController,
   }
 
   deinit {
+    shadowSuppressionDisplayLink?.invalidate()
     dimmingView?.removeFromSuperview()
     if isViewLoaded {
       host.detachTouchHandler(from: view)
@@ -245,14 +352,13 @@ private final class NativeSheetViewController: UIViewController,
     super.viewDidLoad()
     host.moveContent(to: view)
     guard let sheet = sheetPresentationController else { return }
-    let identifier = UISheetPresentationController.Detent.Identifier("onekey.nativeSheet.fixed")
     sheet.detents = [
-      .custom(identifier: identifier) { [lockedHeight] context in
-        min(max(lockedHeight, 1), context.maximumDetentValue)
+      .custom(identifier: detentIdentifier) { [weak self] context in
+        min(max(self?.targetHeight ?? 1, 1), context.maximumDetentValue)
       },
     ]
-    sheet.selectedDetentIdentifier = identifier
-    sheet.largestUndimmedDetentIdentifier = identifier
+    sheet.selectedDetentIdentifier = detentIdentifier
+    sheet.largestUndimmedDetentIdentifier = detentIdentifier
     sheet.prefersGrabberVisible = showHandleValue
     sheet.preferredCornerRadius = cornerRadiusValue
     sheet.prefersScrollingExpandsWhenScrolledToEdge = false
@@ -262,29 +368,98 @@ private final class NativeSheetViewController: UIViewController,
     isModalInPresentation = !host.dismissOnPanDown
   }
 
-  override func viewDidAppear(_ animated: Bool) {
-    super.viewDidAppear(animated)
-    installDimmingView()
-    guard dismissOnBackdropPressValue,
-          backdropTap == nil,
-          let container = presentationController?.containerView else {
+  func updateHeight(_ height: CGFloat, animated: Bool) {
+    let nextHeight = max(height, 1)
+    guard abs(nextHeight - targetHeight) >= 0.5 else { return }
+    guard isViewLoaded, let sheet = sheetPresentationController else {
+      targetHeight = nextHeight
       return
     }
-    let recognizer = UITapGestureRecognizer(target: self, action: #selector(handleBackdropTap(_:)))
-    recognizer.cancelsTouchesInView = false
-    recognizer.delegate = self
-    container.addGestureRecognizer(recognizer)
-    backdropTap = recognizer
+    let changes = { [weak self, weak sheet] in
+      guard let self, let sheet else { return }
+      self.targetHeight = nextHeight
+      sheet.invalidateDetents()
+      sheet.selectedDetentIdentifier = self.detentIdentifier
+      sheet.containerView?.layoutIfNeeded()
+    }
+    guard animated else {
+      changes()
+      return
+    }
+
+    if let heightAnimator {
+      heightAnimator.stopAnimation(false)
+      heightAnimator.finishAnimation(at: .current)
+    }
+    sheet.containerView?.layoutIfNeeded()
+    let animator = NativeSheetQuickAnimation.makeAnimator()
+    heightAnimator = animator
+    animator.addAnimations(changes)
+    animator.addCompletion { [weak self, weak animator] _ in
+      guard let self, self.heightAnimator === animator else { return }
+      self.heightAnimator = nil
+    }
+    animator.startAnimation()
+  }
+
+  func animationController(
+    forPresented presented: UIViewController,
+    presenting: UIViewController,
+    source: UIViewController
+  ) -> UIViewControllerAnimatedTransitioning? {
+    NativeSheetTransitionAnimator(presenting: true)
+  }
+
+  func animationController(
+    forDismissed dismissed: UIViewController
+  ) -> UIViewControllerAnimatedTransitioning? {
+    NativeSheetTransitionAnimator(presenting: false)
+  }
+
+  override func viewWillAppear(_ animated: Bool) {
+    super.viewWillAppear(animated)
+    installDimmingView()
+    installBackdropTap()
+    startSuppressingPresentationShadow()
+    setDimmingVisible(true, animated: animated)
+  }
+
+  override func viewDidAppear(_ animated: Bool) {
+    super.viewDidAppear(animated)
+    stopSuppressingPresentationShadow()
+  }
+
+  override func viewWillDisappear(_ animated: Bool) {
+    super.viewWillDisappear(animated)
+    stopSuppressingPresentationShadow()
+    setDimmingVisible(false, animated: animated)
   }
 
   override func viewDidDisappear(_ animated: Bool) {
     super.viewDidDisappear(animated)
+    if let backdropTap {
+      dimmingView?.removeGestureRecognizer(backdropTap)
+    }
+    backdropTap = nil
     dimmingView?.removeFromSuperview()
     dimmingView = nil
   }
 
+  private func installBackdropTap() {
+    guard dismissOnBackdropPressValue,
+          backdropTap == nil,
+          let dimmingView else {
+      return
+    }
+    let recognizer = UITapGestureRecognizer(target: self, action: #selector(handleBackdropTap(_:)))
+    recognizer.cancelsTouchesInView = true
+    dimmingView.addGestureRecognizer(recognizer)
+    backdropTap = recognizer
+  }
+
   override func viewDidLayoutSubviews() {
     super.viewDidLayoutSubviews()
+    removePresentationShadow()
     host.layoutPresentedContent(in: view.bounds)
   }
 
@@ -296,12 +471,6 @@ private final class NativeSheetViewController: UIViewController,
     NativeSheetPresentationCoordinator.shared.didDismissInteractively(host, reason: "pan")
   }
 
-  func gestureRecognizer(_ gestureRecognizer: UIGestureRecognizer, shouldReceive touch: UITouch) -> Bool {
-    guard let container = presentationController?.containerView else { return false }
-    let point = touch.location(in: container)
-    return !view.frame.contains(point)
-  }
-
   @objc private func handleBackdropTap(_ recognizer: UITapGestureRecognizer) {
     guard recognizer.state == .ended else { return }
     NativeSheetPresentationCoordinator.shared.dismiss(host, reason: "backdrop", animated: true)
@@ -314,11 +483,135 @@ private final class NativeSheetViewController: UIViewController,
     }
     let dimmingView = UIView(frame: container.bounds)
     dimmingView.autoresizingMask = [.flexibleWidth, .flexibleHeight]
-    dimmingView.backgroundColor = UIColor.black.withAlphaComponent(dimAmountValue)
-    dimmingView.isUserInteractionEnabled = false
+    dimmingView.backgroundColor = .black
+    dimmingView.alpha = 0
+    // Always consume backdrop touches. When dismissal is disabled there is no
+    // recognizer, but taps still cannot reach the sheet below or the app page.
+    dimmingView.isUserInteractionEnabled = true
     container.insertSubview(dimmingView, at: 0)
     self.dimmingView = dimmingView
   }
+
+  fileprivate func setDimmingAlpha(_ alpha: CGFloat) {
+    dimmingView?.alpha = alpha
+  }
+
+  private func removePresentationShadow() {
+    guard let container = presentationController?.containerView else { return }
+    var ancestor = view.superview
+    while let current = ancestor, current !== container {
+      clearShadow(on: current)
+      ancestor = current.superview
+    }
+    removeDropShadowViews(in: container)
+  }
+
+  private func removeDropShadowViews(in candidate: UIView) {
+    guard candidate !== view else { return }
+    let className = NSStringFromClass(type(of: candidate))
+    guard className.hasPrefix("UI") || className.hasPrefix("_UI") else { return }
+    if className.contains("DropShadowView") {
+      clearShadow(on: candidate)
+    }
+    for subview in candidate.subviews {
+      removeDropShadowViews(in: subview)
+    }
+  }
+
+  private func clearShadow(on shadowView: UIView) {
+    CATransaction.begin()
+    CATransaction.setDisableActions(true)
+    shadowView.layer.shadowOpacity = 0
+    shadowView.layer.shadowRadius = 0
+    shadowView.layer.shadowColor = UIColor.clear.cgColor
+    shadowView.layer.shadowPath = nil
+    CATransaction.commit()
+  }
+
+  private func startSuppressingPresentationShadow() {
+    shadowSuppressionDisplayLink?.invalidate()
+    removePresentationShadow()
+    let displayLink = CADisplayLink(
+      target: self,
+      selector: #selector(suppressPresentationShadowForCurrentFrame)
+    )
+    displayLink.add(to: .main, forMode: .common)
+    shadowSuppressionDisplayLink = displayLink
+
+    if let transitionCoordinator {
+      transitionCoordinator.animate(alongsideTransition: nil) { [weak self] _ in
+        self?.stopSuppressingPresentationShadow()
+      }
+    } else {
+      DispatchQueue.main.asyncAfter(
+        deadline: .now() + NativeSheetQuickAnimation.duration
+      ) { [weak self] in
+        self?.stopSuppressingPresentationShadow()
+      }
+    }
+  }
+
+  private func stopSuppressingPresentationShadow() {
+    shadowSuppressionDisplayLink?.invalidate()
+    shadowSuppressionDisplayLink = nil
+    removePresentationShadow()
+  }
+
+  @objc private func suppressPresentationShadowForCurrentFrame() {
+    removePresentationShadow()
+  }
+
+  private func setDimmingVisible(_ visible: Bool, animated: Bool) {
+    guard let dimmingView else { return }
+    let targetAlpha = visible ? dimAmountValue : 0
+    let animations = {
+      dimmingView.alpha = targetAlpha
+    }
+    guard animated else {
+      animations()
+      return
+    }
+    if let transitionCoordinator {
+      transitionCoordinator.animate(alongsideTransition: { _ in
+        animations()
+      }, completion: { context in
+        dimmingView.alpha = context.isCancelled
+          ? (visible ? 0 : self.dimAmountValue)
+          : targetAlpha
+      })
+    } else {
+      UIView.animate(
+        withDuration: 0.25,
+        delay: 0,
+        options: [.beginFromCurrentState, .curveEaseInOut],
+        animations: animations
+      )
+    }
+  }
+}
+
+private final class NativeSheetContentWrapperView: UIView {
+  private weak var contentChild: UIView?
+
+  func setContentChild(_ child: UIView?) {
+    if contentChild !== child {
+      contentChild?.autoresizingMask = []
+      contentChild?.removeFromSuperview()
+    }
+    contentChild = child
+    guard let child else { return }
+    child.autoresizingMask = []
+    if child.superview !== self {
+      child.removeFromSuperview()
+      addSubview(child)
+    }
+    setNeedsLayout()
+  }
+
+  override func layoutSubviews() {
+    super.layoutSubviews()
+    contentChild?.frame = bounds
+  }
 }
 
 @objc final class NativeSheetContainerView: UIView {
@@ -342,6 +635,11 @@ private final class NativeSheetViewController: UIViewController,
   }
 
   private weak var contentChild: UIView?
+  private let contentWrapperView: NativeSheetContentWrapperView = {
+    let view = NativeSheetContentWrapperView()
+    view.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    return view
+  }()
   private var committedOpen = false
   private var dismissedForCurrentOpen = false
   private var dismissNotified = false
@@ -358,34 +656,34 @@ private final class NativeSheetViewController: UIViewController,
   override func layoutSubviews() {
     super.layoutSubviews()
     if presentedController == nil {
-      contentChild?.frame = bounds
+      contentWrapperView.frame = bounds
     }
   }
 
   @objc func insertChild(_ child: UIView, atIndex index: Int) {
-    if contentChild !== child {
-      contentChild?.removeFromSuperview()
-    }
+    contentWrapperView.setContentChild(child)
     contentChild = child
     if let controller = presentedController {
       moveContent(to: controller.view)
     } else {
-      child.removeFromSuperview()
-      addSubview(child)
-      child.frame = bounds
-      child.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+      moveContent(to: self)
     }
   }
 
   @objc func removeChild(_ child: UIView) {
     guard contentChild === child else { return }
-    child.removeFromSuperview()
+    contentWrapperView.setContentChild(nil)
+    contentWrapperView.removeFromSuperview()
+    child.autoresizingMask = []
     contentChild = nil
   }
 
   @objc func commitConfiguration() {
     let openChanged = committedOpen != open
     committedOpen = open
+    if openChanged && open {
+      dismissNotified = false
+    }
     if !open {
       dismissedForCurrentOpen = false
     }
@@ -399,6 +697,10 @@ private final class NativeSheetViewController: UIViewController,
               (openChanged || presentedController == nil),
               !dismissedForCurrentOpen {
       NativeSheetPresentationCoordinator.shared.present(self)
+    } else if let controller = presentedController, !dismissedForCurrentOpen {
+      let shouldAnimate = controller.presentingViewController != nil
+        && !controller.isBeingPresented
+      controller.updateHeight(sheetHeight, animated: shouldAnimate)
     }
   }
 
@@ -428,12 +730,17 @@ private final class NativeSheetViewController: UIViewController,
     onPresented?(["height": min(sheetHeight, controller.view.bounds.height)])
   }
 
+  fileprivate func finishFailedPresentation(reason: String) {
+    dismissedForCurrentOpen = committedOpen
+    guard !dismissNotified else { return }
+    dismissNotified = true
+    onDismiss?(["reason": reason])
+  }
+
   fileprivate func finishDismiss(reason: String) {
     if let child = contentChild {
-      child.removeFromSuperview()
-      addSubview(child)
-      child.frame = bounds
-      child.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+      child.autoresizingMask = []
+      moveContent(to: self)
     }
     let hadController = presentedController != nil
     presentedController = nil
@@ -446,14 +753,17 @@ private final class NativeSheetViewController: UIViewController,
 
   fileprivate func moveContent(to parent: UIView) {
     guard let child = contentChild else { return }
-    child.removeFromSuperview()
-    parent.addSubview(child)
-    child.frame = parent.bounds
-    child.autoresizingMask = [.flexibleWidth, .flexibleHeight]
+    child.autoresizingMask = []
+    contentWrapperView.setContentChild(child)
+    if contentWrapperView.superview !== parent {
+      contentWrapperView.removeFromSuperview()
+      parent.addSubview(contentWrapperView)
+    }
+    contentWrapperView.frame = parent.bounds
   }
 
   fileprivate func layoutPresentedContent(in bounds: CGRect) {
-    contentChild?.frame = bounds
+    contentWrapperView.frame = bounds
   }
 
   fileprivate func attachTouchHandler(to view: UIView) {

package/lib/module/NativeSheetHeight.js

@@ -0,0 +1,43 @@
+"use strict";
+
+export function resolveNativeSheetLayoutConstraints({
+  lockedHeight,
+  maxHeight,
+  shouldAutoMeasure
+}) {
+  if (shouldAutoMeasure) {
+    return {
+      hostMaxHeight: maxHeight,
+      shouldFillHost: false
+    };
+  }
+  if (lockedHeight !== undefined) {
+    return {
+      hostHeight: lockedHeight,
+      shouldFillHost: true
+    };
+  }
+  return {
+    hostMaxHeight: maxHeight,
+    shouldFillHost: false
+  };
+}
+export function resolveNativeSheetHeight({
+  currentHeight,
+  explicitHeight,
+  measuredHeight,
+  maxHeight,
+  shouldAutoMeasure
+}) {
+  if (explicitHeight !== undefined && explicitHeight > 0) {
+    return Math.min(explicitHeight, maxHeight);
+  }
+  if (explicitHeight === undefined && shouldAutoMeasure && measuredHeight !== undefined && measuredHeight > 0) {
+    return Math.min(measuredHeight, maxHeight);
+  }
+  if (currentHeight !== undefined && currentHeight > maxHeight) {
+    return maxHeight;
+  }
+  return currentHeight;
+}
+//# sourceMappingURL=NativeSheetHeight.js.map

package/lib/module/NativeSheetHeight.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["resolveNativeSheetLayoutConstraints","lockedHeight","maxHeight","shouldAutoMeasure","hostMaxHeight","shouldFillHost","undefined","hostHeight","resolveNativeSheetHeight","currentHeight","explicitHeight","measuredHeight","Math","min"],"sourceRoot":"../../src","sources":["NativeSheetHeight.ts"],"mappings":";;AAoBA,OAAO,SAASA,mCAAmCA,CAAC;EAClDC,YAAY;EACZC,SAAS;EACTC;AAC0C,CAAC,EAAgC;EAC3E,IAAIA,iBAAiB,EAAE;IACrB,OAAO;MACLC,aAAa,EAAEF,SAAS;MACxBG,cAAc,EAAE;IAClB,CAAC;EACH;EACA,IAAIJ,YAAY,KAAKK,SAAS,EAAE;IAC9B,OAAO;MACLC,UAAU,EAAEN,YAAY;MACxBI,cAAc,EAAE;IAClB,CAAC;EACH;EACA,OAAO;IACLD,aAAa,EAAEF,SAAS;IACxBG,cAAc,EAAE;EAClB,CAAC;AACH;AAEA,OAAO,SAASG,wBAAwBA,CAAC;EACvCC,aAAa;EACbC,cAAc;EACdC,cAAc;EACdT,SAAS;EACTC;AAC+B,CAAC,EAAsB;EACtD,IAAIO,cAAc,KAAKJ,SAAS,IAAII,cAAc,GAAG,CAAC,EAAE;IACtD,OAAOE,IAAI,CAACC,GAAG,CAACH,cAAc,EAAER,SAAS,CAAC;EAC5C;EACA,IACEQ,cAAc,KAAKJ,SAAS,IAC5BH,iBAAiB,IACjBQ,cAAc,KAAKL,SAAS,IAC5BK,cAAc,GAAG,CAAC,EAClB;IACA,OAAOC,IAAI,CAACC,GAAG,CAACF,cAAc,EAAET,SAAS,CAAC;EAC5C;EACA,IAAIO,aAAa,KAAKH,SAAS,IAAIG,aAAa,GAAGP,SAAS,EAAE;IAC5D,OAAOA,SAAS;EAClB;EACA,OAAOO,aAAa;AACtB","ignoreList":[]}