Use CADisplayLink.targetTimestamp value as an argument for frameClock.sendFrame

compose/ui/ui/src/uikitMain/kotlin/androidx/compose/ui/window/ComposeWindow.uikit.kt

@@ -38,7 +38,9 @@ import androidx.compose.ui.platform.*
 import androidx.compose.ui.text.input.PlatformTextInputService
 import androidx.compose.ui.uikit.*
 import androidx.compose.ui.unit.*
+import kotlin.math.floor
 import kotlin.math.roundToInt
+import kotlin.math.roundToLong
 import kotlinx.cinterop.CValue
 import kotlinx.cinterop.ExportObjCClass
 import kotlinx.cinterop.ObjCAction
@@ -47,7 +49,6 @@ import kotlinx.cinterop.useContents
 import org.jetbrains.skia.Surface
 import org.jetbrains.skiko.SkikoKeyboardEvent
 import org.jetbrains.skiko.SkikoPointerEvent
-import org.jetbrains.skiko.currentNanoTime
 import platform.CoreGraphics.CGAffineTransformIdentity
 import platform.CoreGraphics.CGAffineTransformInvert
 import platform.CoreGraphics.CGPoint
@@ -637,8 +638,16 @@ internal actual class ComposeWindow : UIViewController {
  override fun retrieveCATransactionCommands(): List<() -> Unit> =
  interopContext.getActionsAndClear()
 
- override fun draw(surface: Surface) {
- scene.render(surface.canvas, currentNanoTime())
+ override fun draw(surface: Surface, targetTimestamp: NSTimeInterval) {
+ // The calculation is split in two instead of
+ // `(targetTimestamp * 1e9).toLong()`
+ // to avoid losing precision for fractional part
+ val integral = floor(targetTimestamp)
+ val fractional = targetTimestamp - integral
+ val secondsToNanos = 1_000_000_000L
+ val nanos = integral.roundToLong() * secondsToNanos + (fractional * 1e9).roundToLong()
+
+ scene.render(surface.canvas, nanos)
  }
  }
 

compose/ui/ui/src/uikitMain/kotlin/androidx/compose/ui/window/MetalRedrawer.kt

@@ -31,6 +31,7 @@ import platform.UIKit.UIApplicationWillEnterForegroundNotification
 import platform.darwin.*
 import kotlin.math.roundToInt
 import platform.Foundation.NSThread
+import platform.Foundation.NSTimeInterval
 
 private class DisplayLinkConditions(
  val setPausedCallback: (Boolean) -> Unit
@@ -116,30 +117,39 @@ private class ApplicationStateListener(
  }
 }
 
-private enum class DrawReason {
- DISPLAY_LINK_CALLBACK, SYNCHRONOUS_DRAW_REQUEST
+internal interface MetalRedrawerCallbacks {
+ /**
+ * Draw into a surface.
+ *
+ * @param surface The surface to be drawn.
+ * @param targetTimestamp Timestamp indicating the expected draw result presentation time. Implementation should forward its internal time clock to this targetTimestamp to achieve smooth visual change cadence.
+ */
+ fun draw(surface: Surface, targetTimestamp: NSTimeInterval)
+
+ /**
+ * Retrieve a list of pending actions which need to be synchronized with Metal rendering using CATransaction mechanism.
+ */
+ fun retrieveCATransactionCommands(): List<() -> Unit>
 }
 
 internal class MetalRedrawer(
  private val metalLayer: CAMetalLayer,
- private val drawCallback: (Surface) -> Unit,
- private val retrieveCATransactionCommands: () -> List<() -> Unit>,
-
- // Used for tests, access to NSRunLoop crashes in test environment
- addDisplayLinkToRunLoop: ((CADisplayLink) -> Unit)? = null,
- private val disposeCallback: (MetalRedrawer) -> Unit = { }
+ private val callbacks: MetalRedrawerCallbacks,
 ) {
  // Workaround for KN compiler bug
  // Type mismatch: inferred type is objcnames.protocols.MTLDeviceProtocol but platform.Metal.MTLDeviceProtocol was expected
  @Suppress("USELESS_CAST")
  private val device = metalLayer.device as platform.Metal.MTLDeviceProtocol?
  ?: throw IllegalStateException("CAMetalLayer.device can not be null")
- private val queue = device.newCommandQueue() ?: throw IllegalStateException("Couldn't create Metal command queue")
+ private val queue = device.newCommandQueue()
+ ?: throw IllegalStateException("Couldn't create Metal command queue")
  private val context = DirectContext.makeMetal(device.objcPtr(), queue.objcPtr())
  private val inflightCommandBuffers = mutableListOf<MTLCommandBufferProtocol>()
+ private var lastRenderTimestamp: NSTimeInterval = CACurrentMediaTime()
 
  // Semaphore for preventing command buffers count more than swapchain size to be scheduled/executed at the same time
- private val inflightSemaphore = dispatch_semaphore_create(metalLayer.maximumDrawableCount.toLong())
+ private val inflightSemaphore =
+ dispatch_semaphore_create(metalLayer.maximumDrawableCount.toLong())
 
  var isForcedToPresentWithTransactionEveryFrame = false
 
@@ -159,6 +169,9 @@ internal class MetalRedrawer(
  displayLinkConditions.needsToBeProactive = value
  }
 
+ /**
+ * null after [dispose] call
+ */
  private var caDisplayLink: CADisplayLink? = CADisplayLink.displayLinkWithTarget(
  target = DisplayLinkProxy {
  this.handleDisplayLinkTick()
@@ -184,25 +197,21 @@ internal class MetalRedrawer(
  }
 
  init {
- val caDisplayLink = caDisplayLink ?: throw IllegalStateException("caDisplayLink is null during redrawer init")
+ val caDisplayLink = caDisplayLink
+ ?: throw IllegalStateException("caDisplayLink is null during redrawer init")
 
  // UIApplication can be in UIApplicationStateInactive state (during app launch before it gives control back to run loop)
  // and won't receive UIApplicationWillEnterForegroundNotification
  // so we compare the state with UIApplicationStateBackground instead of UIApplicationStateActive
- displayLinkConditions.isApplicationActive = UIApplication.sharedApplication.applicationState != UIApplicationState.UIApplicationStateBackground
+ displayLinkConditions.isApplicationActive =
+ UIApplication.sharedApplication.applicationState != UIApplicationState.UIApplicationStateBackground
 
- if (addDisplayLinkToRunLoop == null) {
- caDisplayLink.addToRunLoop(NSRunLoop.mainRunLoop, NSRunLoop.mainRunLoop.currentMode)
- } else {
- addDisplayLinkToRunLoop.invoke(caDisplayLink)
- }
+ caDisplayLink.addToRunLoop(NSRunLoop.mainRunLoop, NSRunLoop.mainRunLoop.currentMode)
  }
 
  fun dispose() {
  check(caDisplayLink != null) { "MetalRedrawer.dispose() was called more than once" }
 
- disposeCallback(this)
-
  applicationStateListener.dispose()
 
  caDisplayLink?.invalidate()
@@ -224,25 +233,27 @@ internal class MetalRedrawer(
  if (displayLinkConditions.needsRedrawOnNextVsync) {
  displayLinkConditions.needsRedrawOnNextVsync = false
 
- draw(DrawReason.DISPLAY_LINK_CALLBACK)
+ val targetTimestamp = caDisplayLink?.targetTimestamp ?: return
+
+ draw(waitUntilCompletion = false, targetTimestamp)
  }
  }
 
  /**
  * Immediately dispatch draw and block the thread until it's finished and presented on the screen.
  */
  fun drawSynchronously() {
- draw(DrawReason.SYNCHRONOUS_DRAW_REQUEST)
+ if (caDisplayLink == null) {
+ return
+ }
+
+ draw(waitUntilCompletion = true, CACurrentMediaTime())
  }
 
- private fun draw(reason: DrawReason) {
+ private fun draw(waitUntilCompletion: Boolean, targetTimestamp: NSTimeInterval) {
  check(NSThread.isMainThread)
 
- if (caDisplayLink == null) {
- // TODO: anomaly, log
- // Logger.warn { "caDisplayLink callback called after it was invalidated " }
- return
- }
+ lastRenderTimestamp = maxOf(targetTimestamp, lastRenderTimestamp)
 
  autoreleasepool {
  val (width, height) = metalLayer.drawableSize.useContents {
@@ -264,7 +275,8 @@ internal class MetalRedrawer(
  return@autoreleasepool
  }
 
- val renderTarget = BackendRenderTarget.makeMetal(width, height, metalDrawable.texture.objcPtr())
+ val renderTarget =
+ BackendRenderTarget.makeMetal(width, height, metalDrawable.texture.objcPtr())
 
  val surface = Surface.makeFromBackendRenderTarget(
  context,
@@ -285,11 +297,12 @@ internal class MetalRedrawer(
  }
 
  surface.canvas.clear(Color.WHITE)
- drawCallback(surface)
+ callbacks.draw(surface, lastRenderTimestamp)
  surface.flushAndSubmit()
 
- val caTransactionCommands = retrieveCATransactionCommands()
- val presentsWithTransaction = isForcedToPresentWithTransactionEveryFrame || caTransactionCommands.isNotEmpty()
+ val caTransactionCommands = callbacks.retrieveCATransactionCommands()
+ val presentsWithTransaction =
+ isForcedToPresentWithTransactionEveryFrame || caTransactionCommands.isNotEmpty()
 
  metalLayer.presentsWithTransaction = presentsWithTransaction
 
@@ -327,7 +340,7 @@ internal class MetalRedrawer(
 
  inflightCommandBuffers.add(commandBuffer)
 
- if (reason == DrawReason.SYNCHRONOUS_DRAW_REQUEST) {
+ if (waitUntilCompletion) {
  commandBuffer.waitUntilCompleted()
  }
  }

compose/ui/ui/src/uikitMain/kotlin/androidx/compose/ui/window/SkikoUIView.kt

@@ -51,7 +51,7 @@ internal interface SkikoUIViewDelegate {
 
  fun retrieveCATransactionCommands(): List<() -> Unit>
 
- fun draw(surface: Surface)
+ fun draw(surface: Surface, targetTimestamp: NSTimeInterval)
 }
 
 @Suppress("CONFLICTING_OVERLOADS")
@@ -78,11 +78,13 @@ internal class SkikoUIView : UIView, UIKeyInputProtocol, UITextInputProtocol {
  private var _currentTextMenuActions: TextActions? = null
  private val _redrawer: MetalRedrawer = MetalRedrawer(
  _metalLayer,
- drawCallback = { surface: Surface ->
- delegate?.draw(surface)
- },
- retrieveCATransactionCommands = {
- delegate?.retrieveCATransactionCommands() ?: listOf()
+ callbacks = object : MetalRedrawerCallbacks {
+ override fun draw(surface: Surface, targetTimestamp: NSTimeInterval) {
+ delegate?.draw(surface, targetTimestamp)
+ }
+
+ override fun retrieveCATransactionCommands(): List<() -> Unit> =
+ delegate?.retrieveCATransactionCommands() ?: listOf()
  }
  )