react-native-webgpu 0.15.1 → 0.15.2

package/android/cpp/cpp-adapter.cpp

@@ -156,9 +156,58 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceChanged(
   }
 }
 
+namespace {
+
+// Weak handle on a Java view and one of its no-argument methods, for native
+// threads to call into it: the fence waiter wakes a WebGPUHardwareBufferView
+// when a frame is ready, the presenting thread reports each frame a
+// SurfaceView shows. Holding the view weakly means a view that RN has dropped
+// is not kept alive by a SurfaceInfo that outlives it (the registry keeps the
+// SurfaceInfo until onDropViewInstance).
+struct WeakViewCall {
+  jweak view = nullptr;
+  jmethodID method = nullptr;
+
+  WeakViewCall(JNIEnv *env, jobject thiz, const char *methodName) {
+    view = env->NewWeakGlobalRef(thiz);
+    jclass cls = env->GetObjectClass(thiz);
+    method = env->GetMethodID(cls, methodName, "()V");
+    env->DeleteLocalRef(cls);
+  }
+
+  ~WeakViewCall() {
+    // May run on any thread; ThreadScope attaches if needed.
+    facebook::jni::ThreadScope scope;
+    JNIEnv *env = facebook::jni::Environment::current();
+    if (env != nullptr && view != nullptr) {
+      env->DeleteWeakGlobalRef(view);
+    }
+  }
+
+  // Called on a native thread, outside the SurfaceInfo locks.
+  void operator()() const {
+    facebook::jni::ThreadScope scope;
+    JNIEnv *env = facebook::jni::Environment::current();
+    if (env == nullptr || method == nullptr) {
+      return;
+    }
+    jobject local = env->NewLocalRef(view);
+    if (local == nullptr) {
+      return; // the view was garbage collected
+    }
+    env->CallVoidMethod(local, method);
+    if (env->ExceptionCheck()) {
+      env->ExceptionClear();
+    }
+    env->DeleteLocalRef(local);
+  }
+};
+
+} // namespace
+
 extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
     JNIEnv *env, jobject thiz, jobject jSurface, jint contextId, jfloat width,
-    jfloat height) {
+    jfloat height, jboolean reportPresents) {
   if (manager == nullptr) {
     return;
   }
@@ -179,6 +228,15 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onSurfaceCreate(
       surface, [](void *nativeSurface) {
         ANativeWindow_release(static_cast<ANativeWindow *>(nativeSurface));
       });
+  // A SurfaceView asks to hear about each presented frame, for its refresh
+  // rate vote (WebGPUView.onFramePresented).
+  if (reportPresents) {
+    auto reporter =
+        std::make_shared<WeakViewCall>(env, thiz, "onFramePresented");
+    info->setFramePresentedCallback([reporter]() { (*reporter)(); });
+  } else {
+    info->setFramePresentedCallback(nullptr);
+  }
   // The attach is adopted at the next frame boundary by the rendering thread;
   // schedule a flush so contexts that are not currently rendering still pick
   // it up (and present their last offscreen frame).
@@ -190,6 +248,7 @@ Java_com_webgpu_WebGPUView_switchToOffscreenSurface(JNIEnv *env, jobject thiz,
                                                     jint contextId) {
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->setFramePresentedCallback(nullptr);
     info->switchToOffscreen();
   }
 }
@@ -202,6 +261,7 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onViewDestroyed(
   // surface; see RNWebGPU::destroyContext for the ownership split.
   auto &registry = rnwgpu::SurfaceRegistry::getInstance();
   if (auto info = registry.getSurfaceInfo(contextId)) {
+    info->setFramePresentedCallback(nullptr);
     info->detachSurface();
   }
   registry.removeSurfaceInfo(contextId);
@@ -210,53 +270,6 @@ extern "C" JNIEXPORT void JNICALL Java_com_webgpu_WebGPUView_onViewDestroyed(
 // --- WebGPUHardwareBufferView (AHB-pool presentation)
 // ---------------------------------
 
-namespace {
-
-// Weak handle on a WebGPUHardwareBufferView used by the native fence waiter to
-// wake the UI thread when a frame is ready. Holding it weakly means a view that
-// RN has dropped is not kept alive by a SurfaceInfo that outlives it (the
-// registry keeps the SurfaceInfo until onDropViewInstance).
-struct HardwareBufferViewWaker {
-  jweak view = nullptr;
-  jmethodID onFrameReady = nullptr;
-
-  HardwareBufferViewWaker(JNIEnv *env, jobject thiz) {
-    view = env->NewWeakGlobalRef(thiz);
-    jclass cls = env->GetObjectClass(thiz);
-    onFrameReady = env->GetMethodID(cls, "onNativeFrameReady", "()V");
-    env->DeleteLocalRef(cls);
-  }
-
-  ~HardwareBufferViewWaker() {
-    // May run on the waiter or JS thread; ThreadScope attaches if needed.
-    facebook::jni::ThreadScope scope;
-    JNIEnv *env = facebook::jni::Environment::current();
-    if (env != nullptr && view != nullptr) {
-      env->DeleteWeakGlobalRef(view);
-    }
-  }
-
-  // Called on the waiter thread, outside the pool lock.
-  void operator()() const {
-    facebook::jni::ThreadScope scope;
-    JNIEnv *env = facebook::jni::Environment::current();
-    if (env == nullptr || onFrameReady == nullptr) {
-      return;
-    }
-    jobject local = env->NewLocalRef(view);
-    if (local == nullptr) {
-      return; // the view was garbage collected
-    }
-    env->CallVoidMethod(local, onFrameReady);
-    if (env->ExceptionCheck()) {
-      env->ExceptionClear();
-    }
-    env->DeleteLocalRef(local);
-  }
-};
-
-} // namespace
-
 // Turn on pool mode for this context. dpW/dpH is the canvas-client (dp) size;
 // the native pool buffers are sized from the canvas drawing buffer lazily.
 extern "C" JNIEXPORT void JNICALL
@@ -267,7 +280,7 @@ Java_com_webgpu_WebGPUHardwareBufferView_nEnablePool(JNIEnv *env, jobject thiz,
   auto info = registry.getSurfaceInfoOrCreate(
       contextId, rnwgpu::WebGPURuntime::shared().instance(),
       static_cast<int>(dpW), static_cast<int>(dpH));
-  auto waker = std::make_shared<HardwareBufferViewWaker>(env, thiz);
+  auto waker = std::make_shared<WeakViewCall>(env, thiz, "onNativeFrameReady");
   info->setPoolFrameReadyCallback([waker]() { (*waker)(); });
   info->enablePool(static_cast<int>(dpW), static_cast<int>(dpH));
 }

package/android/src/main/java/com/webgpu/SurfaceFrameRateVote.java

@@ -0,0 +1,184 @@
+package com.webgpu;
+
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.util.Log;
+import android.view.Display;
+import android.view.Surface;
+import android.view.View;
+
+import androidx.annotation.Nullable;
+
+/**
+ * Votes the display's refresh rate for a SurfaceView canvas while it animates.
+ *
+ * A SurfaceView is composited in a layer of its own, outside the window that
+ * votes for the app's views, so SurfaceFlinger picks the layer's refresh rate
+ * from its present history alone: a canvas drawing every frame on a display
+ * idling at 60 Hz looks like 60 Hz content and never gets more. Since Android
+ * 11 a layer can say what it wants with Surface.setFrameRate. Once the canvas
+ * presents frames back to back, this asks for the highest rate the display can
+ * switch to seamlessly, as the window does for its own views, and takes the
+ * vote back once the animation stops, whether the canvas stops drawing or
+ * drops back to a few redraws a second: a layer with a vote counts as active
+ * for SurfaceFlinger even when it no longer draws.
+ *
+ * attach() and detach() run on the main thread with the surface callbacks;
+ * onFramePresented() runs on whichever thread presents (the JS thread, the
+ * Reanimated UI runtime or a worklet runtime), so the state is locked.
+ */
+final class SurfaceFrameRateVote {
+  private static final String TAG = "SurfaceFrameRateVote";
+
+  // Presents this close together are an animation (faster than 40 fps). The
+  // threshold is absolute rather than relative to the current refresh rate,
+  // so that a canvas that only manages 60 fps at 120 Hz keeps its vote rather
+  // than oscillating between the two rates. A canvas that redraws a few times
+  // a second never votes.
+  private static final long ANIMATING_INTERVAL_NANOS = 25_000_000L;
+
+  // The vote is taken back once the canvas has not animated (no two presents
+  // within ANIMATING_INTERVAL_NANOS) for this long. Measured from the last
+  // back-to-back present rather than the last present, so that a canvas that
+  // slows down to a few redraws a second lets the vote lapse like one that
+  // stops drawing.
+  private static final long IDLE_AFTER_NANOS = 500_000_000L;
+
+  private final View mView;
+  private final Handler mHandler = new Handler(Looper.getMainLooper());
+  private final Runnable mIdleCheck = this::checkIdle;
+
+  @Nullable
+  private Surface mSurface;
+  private boolean mVoting = false;
+  private boolean mIdleCheckPending = false;
+  // 0 before the first present on the surface.
+  private long mLastPresentNanos = 0;
+  // The last present that followed its predecessor within
+  // ANIMATING_INTERVAL_NANOS; 0 until the first.
+  private long mLastAnimatingNanos = 0;
+
+  /** The view the surface belongs to; its display decides the rate to ask for. */
+  SurfaceFrameRateVote(View view) {
+    mView = view;
+  }
+
+  /** The surface was created: it is voted on until detach(). Main thread. */
+  synchronized void attach(Surface surface) {
+    detach();
+    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.R) {
+      return;
+    }
+    mSurface = surface;
+  }
+
+  /** A frame was presented on the surface. Any thread. */
+  synchronized void onFramePresented() {
+    if (mSurface == null) {
+      return;
+    }
+    long now = System.nanoTime();
+    boolean animating = mLastPresentNanos != 0 && now - mLastPresentNanos <= ANIMATING_INTERVAL_NANOS;
+    mLastPresentNanos = now;
+    if (animating) {
+      mLastAnimatingNanos = now;
+      if (!mVoting) {
+        vote();
+      }
+    }
+    if (mVoting && !mIdleCheckPending) {
+      scheduleIdleCheck(IDLE_AFTER_NANOS);
+    }
+  }
+
+  /** The surface is going away (it is still valid here) or the view left its window. Main thread. */
+  synchronized void detach() {
+    if (mSurface == null) {
+      return;
+    }
+    withdraw();
+    mHandler.removeCallbacks(mIdleCheck);
+    mIdleCheckPending = false;
+    mLastPresentNanos = 0;
+    mLastAnimatingNanos = 0;
+    mSurface = null;
+  }
+
+  private void vote() {
+    float refreshRate = resolveMaxRefreshRate();
+    if (refreshRate <= 0 || !mSurface.isValid()) {
+      return;
+    }
+    try {
+      // This form only switches when the display can do so seamlessly, like
+      // the vote the window casts for its own views: a canvas animation is
+      // not worth a blank screen. Surface.setFrameRate is thread-safe.
+      mSurface.setFrameRate(refreshRate, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
+      mVoting = true;
+    } catch (RuntimeException e) {
+      Log.w(TAG, "Could not vote the refresh rate, leaving it to the display", e);
+      detach();
+    }
+  }
+
+  private void withdraw() {
+    if (!mVoting) {
+      return;
+    }
+    mVoting = false;
+    if (mSurface == null || !mSurface.isValid()) {
+      return;
+    }
+    try {
+      mSurface.setFrameRate(0, Surface.FRAME_RATE_COMPATIBILITY_DEFAULT);
+    } catch (RuntimeException e) {
+      Log.w(TAG, "Could not withdraw the refresh rate vote", e);
+    }
+  }
+
+  private void scheduleIdleCheck(long delayNanos) {
+    mIdleCheckPending = true;
+    mHandler.postDelayed(mIdleCheck, (delayNanos + 999_999) / 1_000_000);
+  }
+
+  private synchronized void checkIdle() {
+    mIdleCheckPending = false;
+    if (!mVoting) {
+      return;
+    }
+    long idleNanos = System.nanoTime() - mLastAnimatingNanos;
+    if (idleNanos >= IDLE_AFTER_NANOS) {
+      withdraw();
+    } else {
+      scheduleIdleCheck(IDLE_AFTER_NANOS - idleNanos);
+    }
+  }
+
+  // The highest rate a seamless switch from the current mode can reach, which
+  // is all the vote may ask for. Resolved when the vote is cast, so that it
+  // follows the display the view is on.
+  private float resolveMaxRefreshRate() {
+    Display display = mView.getDisplay();
+    if (display == null) {
+      return 0f;
+    }
+    Display.Mode current = display.getMode();
+    float maxRefreshRate = current.getRefreshRate();
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      for (float refreshRate : current.getAlternativeRefreshRates()) {
+        maxRefreshRate = Math.max(maxRefreshRate, refreshRate);
+      }
+    } else {
+      // Android 11 does not tell which modes are a seamless switch away: the
+      // ones at the current resolution usually are.
+      for (Display.Mode mode : display.getSupportedModes()) {
+        if (mode.getPhysicalWidth() == current.getPhysicalWidth()
+            && mode.getPhysicalHeight() == current.getPhysicalHeight()) {
+          maxRefreshRate = Math.max(maxRefreshRate, mode.getRefreshRate());
+        }
+      }
+    }
+    return maxRefreshRate;
+  }
+}

package/android/src/main/java/com/webgpu/WebGPUView.java

@@ -24,6 +24,9 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
   private boolean mAppliedZOrderOnTop;
   private WebGPUModule mModule;
   private View mView = null;
+  // Only a SurfaceView votes: a TextureView or HardwareBufferView is
+  // composited into the window, which votes for it.
+  private final SurfaceFrameRateVote mFrameRateVote = new SurfaceFrameRateVote(this);
 
   WebGPUView(Context context) {
     super(context);
@@ -134,7 +137,11 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
     float density = getResources().getDisplayMetrics().density;
     float width = getWidth() / density;
     float height = getHeight() / density;
-    onSurfaceCreate(surface, mContextId, width, height);
+    boolean votesFrameRate = mAppliedKind == KIND_SURFACE_VIEW;
+    if (votesFrameRate) {
+      mFrameRateVote.attach(surface);
+    }
+    onSurfaceCreate(surface, mContextId, width, height, votesFrameRate);
   }
 
   @Override
@@ -147,9 +154,20 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
 
   @Override
   public void surfaceOffscreen() {
+    // The surface is still valid here, so the vote can be taken back.
+    mFrameRateVote.detach();
     switchToOffscreenSurface(mContextId);
   }
 
+  /**
+   * Called from native (SurfaceInfo::presentFrame) on the thread that
+   * presented a frame to the surface, only for a SurfaceView.
+   */
+  @DoNotStrip
+  void onFramePresented() {
+    mFrameRateVote.onFramePresented();
+  }
+
   @Override
   public int getContextId() {
     return mContextId;
@@ -160,15 +178,19 @@ public class WebGPUView extends ReactViewGroup implements WebGPUAPI {
    * view: the view dies with its Canvas, so it retires the registry entry.
    */
   public void destroy() {
+    mFrameRateVote.detach();
     onViewDestroyed(mContextId);
   }
 
+  // reportPresents asks native to call onFramePresented() for each frame
+  // presented to this surface.
   @DoNotStrip
   private native void onSurfaceCreate(
     Surface surface,
     int contextId,
     float width,
-    float height
+    float height,
+    boolean reportPresents
   );
 
   @DoNotStrip

package/cpp/rnwgpu/SurfaceRegistry.h

@@ -548,16 +548,27 @@ public:
     if (device) {
       dawn::native::metal::WaitForCommandsToBeScheduled(device.Get());
     }
+#endif
+#if defined(__ANDROID__)
+    std::function<void()> framePresented;
 #endif
     {
       std::unique_lock<std::shared_mutex> lock(_mutex);
       if (_surface && _acquiredFromSurface) {
         _surface.Present();
+#if defined(__ANDROID__)
+        framePresented = _framePresented;
+#endif
       }
       _acquiredFromSurface = false;
       _frameInFlight = false;
       _frameEpoch++;
     }
+#if defined(__ANDROID__)
+    if (framePresented) {
+      framePresented();
+    }
+#endif
     applyPendingAttach();
   }
 
@@ -691,6 +702,16 @@ public:
     std::lock_guard<std::mutex> poolLock(_poolMutex);
     _poolFrameReady = std::move(cb);
   }
+
+  // Invoked from the presenting thread (never under _mutex) after each frame
+  // presentFrame() shows on the attached surface; the blit of the last
+  // offscreen frame onto a newly attached surface does not count. The view
+  // uses it to vote the display's refresh rate while the canvas animates
+  // (see SurfaceFrameRateVote.java). Pass nullptr to unregister.
+  void setFramePresentedCallback(std::function<void()> cb) {
+    std::unique_lock<std::shared_mutex> lock(_mutex);
+    _framePresented = std::move(cb);
+  }
 #endif
 
 private:
@@ -1239,6 +1260,9 @@ private:
   static constexpr int kPoolSize =
       5; // 2 held + 1 rendering + 1 waiting + 1 ready
 
+  // See setFramePresentedCallback(); read under _mutex, called outside it.
+  std::function<void()> _framePresented;
+
   std::atomic<bool> _poolMode{false};
   std::mutex _poolMutex;
   std::condition_variable _freeCv;    // a slot returned to Free

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-webgpu",
-  "version": "0.15.1",
+  "version": "0.15.2",
   "description": "React Native WebGPU",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",