Connect drawer: the content picks up the fling on the fling's own clock

The carried momentum started the moment the finger lifted, ahead of the
sheet, and on Android the same carry-over read as a phantom flick once the
sheet had stopped. Time the pick-up like one fling instead: the content
starts at the moment the fling would have covered the sheet's remaining
travel (closed form on UIScrollView's exponential deceleration), or when
the sheet arrives if that comes first, and continues the curve from there.
The momentum driver takes the delay and holds until the display link
reaches it.

Author: bitprecipice

app/network/Main/Connect/ConnectSheetMomentum.swift

@@ -53,6 +53,23 @@ enum ConnectSheetMomentum {
         return speed / 1000 * decelerationRate / (1 - decelerationRate)
     }
 
+    /// How long, in seconds on the fling's own clock, a fling of `speed`
+    /// takes to cover `travelled` points; nil when it would stop short.
+    static func travelTime(speed: CGFloat, travelled: CGFloat, decelerationRate: CGFloat) -> TimeInterval? {
+        guard speed > 0, 0 < decelerationRate, decelerationRate < 1 else {
+            return nil
+        }
+        guard travelled > 0 else {
+            return 0
+        }
+        let total = projectedDistance(speed: speed, decelerationRate: decelerationRate)
+        guard travelled < total else {
+            return nil
+        }
+        // distance(t) = total * (1 - rate^t) with t in milliseconds
+        return log(1 - travelled / total) / log(decelerationRate) / 1000
+    }
+
     /// The speed a fling of `speed` has left after covering `travelled`
     /// points; zero when it would have stopped within that distance.
     static func residualSpeed(speed: CGFloat, travelled: CGFloat, decelerationRate: CGFloat) -> CGFloat {

app/network/Main/Connect/ConnectView-iOS.swift

@@ -84,6 +84,9 @@ struct ConnectView_iOS: View {
     // and the top of the tab bar at the collapsed peek — the same 12pt on
     // every device, matching the Android drawer
     private let sheetFoldGap: CGFloat = 12
+    // how long the sheet takes to reach its expanded position after a
+    // release (the spring below settles visibly within this)
+    private let sheetOpenDuration: TimeInterval = 0.3
 
 
     init(
@@ -630,11 +633,17 @@ struct ConnectView_iOS: View {
         }
     }
 
+    // The content picks up the fling on the fling's own clock: at the moment
+    // the fling would have covered the sheet's remaining travel, or when the
+    // sheet arrives if that comes first, so it never sets off on its own
+    // after the sheet has visibly stopped.
     private func carryFlingIntoSheetContent(speed: CGFloat, afterTravelling travelled: CGFloat, maxHeight: CGFloat) {
         guard let scrollView = sheetScrollRef.scrollView else { return }
         let rate = UIScrollView.DecelerationRate.normal.rawValue
         let residual = ConnectSheetMomentum.residualSpeed(speed: speed, travelled: travelled, decelerationRate: rate)
         guard residual > 0 else { return }
+        let travelTime = ConnectSheetMomentum.travelTime(speed: speed, travelled: travelled, decelerationRate: rate) ?? 0
+        let delay = min(travelTime, sheetOpenDuration)
         // the sheet is still growing to its expanded height, so the far end
         // of the scroll is measured against the expanded content area, not
         // the bounds of this instant
@@ -644,7 +653,8 @@ struct ConnectView_iOS: View {
             scrollView: scrollView,
             speed: residual,
             maxOffset: maxOffset,
-            decelerationRate: rate
+            decelerationRate: rate,
+            delay: delay
         )
     }
 

app/network/Shared/Views/Components/SheetScrollMomentum.swift

@@ -79,17 +79,21 @@ final class ScrollMomentumDriver {
     private var maxOffset: CGFloat = 0
     private var decelerationRate: CGFloat = UIScrollView.DecelerationRate.normal.rawValue
     private var lastTimestamp: CFTimeInterval = 0
+    private var startAt: CFTimeInterval = 0
 
-    /// Starts scrolling `scrollView` downward at `speed` points per second,
-    /// never past `maxOffset`.
-    func start(scrollView: UIScrollView, speed: CGFloat, maxOffset: CGFloat, decelerationRate: CGFloat) {
+    /// Starts scrolling `scrollView` downward at `speed` points per second
+    /// after `delay` seconds, never past `maxOffset`. The delay lets the
+    /// content pick up a fling exactly where the fling's own clock says the
+    /// sheet's travel ends, so the motion reads as one scroll.
+    func start(scrollView: UIScrollView, speed: CGFloat, maxOffset: CGFloat, decelerationRate: CGFloat, delay: TimeInterval = 0) {
         stop()
         guard speed > 0, maxOffset > scrollView.contentOffset.y else { return }
         self.scrollView = scrollView
         self.speed = speed
         self.maxOffset = maxOffset
         self.decelerationRate = decelerationRate
         lastTimestamp = 0
+        startAt = CACurrentMediaTime() + max(0, delay)
         let link = CADisplayLink(target: self, selector: #selector(step(_:)))
         link.add(to: .main, forMode: .common)
         displayLink = link
@@ -107,6 +111,9 @@ final class ScrollMomentumDriver {
             stop()
             return
         }
+        if link.timestamp < startAt {
+            return
+        }
         if lastTimestamp == 0 {
             lastTimestamp = link.timestamp
             return