react-native-smooth-clip-view 0.2.9 → 0.4.0

package/android/src/main/cpp/SmoothClipBindings.cpp

@@ -5,6 +5,7 @@
 #include <fbjni/fbjni.h>
 #include <jsi/jsi.h>
 
+#include <algorithm>
 #include <cmath>
 #include <limits>
 #include <memory>
@@ -26,26 +27,80 @@ namespace smoothclip {
 namespace {
 
 constexpr double kMaxSafeJavaScriptInteger = 9007199254740991.0;
+constexpr size_t kPresentationStride = 21;
+constexpr size_t kSnapshotStride = kPresentationStride + 1;
+constexpr size_t kMotionEntryStride = kPresentationStride * 2 + 2;
 
 bool validDriverId(double value) {
   return std::isfinite(value) && value > 0 &&
       value <= kMaxSafeJavaScriptInteger && std::floor(value) == value;
 }
 
-bool finitePresentation(const Presentation &presentation) {
+bool validCurve(double value) {
+  return std::isfinite(value) && std::floor(value) == value &&
+      (value == static_cast<double>(ClipCurve::Circular) ||
+       value == static_cast<double>(ClipCurve::Continuous));
+}
+
+bool validRadiusOverride(double value) {
+  return std::isfinite(value) || std::isnan(value);
+}
+
+bool finiteBasePresentation(const Presentation &presentation) {
   return std::isfinite(presentation.clip.x) &&
       std::isfinite(presentation.clip.y) &&
       std::isfinite(presentation.clip.width) &&
       std::isfinite(presentation.clip.height) &&
       std::isfinite(presentation.clip.radius) &&
+      validRadiusOverride(presentation.clip.topLeftRadius) &&
+      validRadiusOverride(presentation.clip.topRightRadius) &&
+      validRadiusOverride(presentation.clip.bottomRightRadius) &&
+      validRadiusOverride(presentation.clip.bottomLeftRadius) &&
+      (presentation.clip.curve == ClipCurve::Circular ||
+       presentation.clip.curve == ClipCurve::Continuous) &&
       std::isfinite(presentation.contentTranslateX) &&
-      std::isfinite(presentation.contentTranslateY);
+      std::isfinite(presentation.contentTranslateY) &&
+      std::isfinite(presentation.contentScale) &&
+      presentation.contentScale > 0;
+}
+
+bool finitePresentation(const Presentation &presentation) {
+  return finiteBasePresentation(presentation) &&
+      std::isfinite(presentation.clip.topLeftRadius) &&
+      std::isfinite(presentation.clip.topRightRadius) &&
+      std::isfinite(presentation.clip.bottomRightRadius) &&
+      std::isfinite(presentation.clip.bottomLeftRadius) &&
+      std::isfinite(presentation.shadow.red) &&
+      std::isfinite(presentation.shadow.green) &&
+      std::isfinite(presentation.shadow.blue) &&
+      std::isfinite(presentation.shadow.alpha) &&
+      std::isfinite(presentation.shadow.offsetX) &&
+      std::isfinite(presentation.shadow.offsetY) &&
+      std::isfinite(presentation.shadow.blurRadius) &&
+      std::isfinite(presentation.shadow.spreadDistance) &&
+      presentation.shadow.red >= 0 && presentation.shadow.red <= 1 &&
+      presentation.shadow.green >= 0 && presentation.shadow.green <= 1 &&
+      presentation.shadow.blue >= 0 && presentation.shadow.blue <= 1 &&
+      presentation.shadow.alpha >= 0 && presentation.shadow.alpha <= 1 &&
+      presentation.shadow.blurRadius >= 0;
 }
 
 bool boolArg(const Value *args, size_t count, size_t index) {
   return index < count && args[index].isBool() && args[index].getBool();
 }
 
+bool numberAt(
+    Runtime &runtime,
+    const Array &values,
+    size_t index,
+    double &result) {
+  if (index >= values.size(runtime)) return false;
+  const Value value = values.getValueAtIndex(runtime, index);
+  if (!value.isNumber()) return false;
+  result = value.asNumber();
+  return std::isfinite(result);
+}
+
 // Optional trailing start stamp (Reanimated-rule milliseconds captured in the
 // issuing worklet), converted to the registry's CLOCK_MONOTONIC seconds. A
 // missing or non-numeric argument — and the JS side's deliberate NaN fallback
@@ -58,26 +113,89 @@ double startStampArg(const Value *args, size_t count, size_t index) {
       : std::numeric_limits<double>::quiet_NaN();
 }
 
-Presentation presentationFromArgs(const Value *args, size_t offset) {
-  return Presentation{
-      {args[offset].asNumber(),
-       args[offset + 1].asNumber(),
-       args[offset + 2].asNumber(),
-       args[offset + 3].asNumber(),
-       args[offset + 4].asNumber()},
-      args[offset + 5].asNumber(),
-      args[offset + 6].asNumber()};
+bool presentationAt(
+    Runtime &runtime,
+    const Array &values,
+    size_t offset,
+    Presentation &result) {
+  const size_t length = values.size(runtime);
+  if (offset > length || length - offset < kPresentationStride) {
+    return false;
+  }
+  double packet[kPresentationStride];
+  for (size_t index = 0; index < kPresentationStride; index += 1) {
+    const Value value = values.getValueAtIndex(runtime, offset + index);
+    if (!value.isNumber()) return false;
+    packet[index] = value.asNumber();
+  }
+  const double curveCode = packet[8];
+  if (!validCurve(curveCode) ||
+      (packet[12] != 0.0 && packet[12] != 1.0)) {
+    return false;
+  }
+  Geometry geometry{
+      packet[0], packet[1], packet[2], packet[3],
+      0.0};
+  geometry.topLeftRadius = packet[4];
+  geometry.topRightRadius = packet[5];
+  geometry.bottomRightRadius = packet[6];
+  geometry.bottomLeftRadius = packet[7];
+  geometry.curve = curveCode == static_cast<double>(ClipCurve::Continuous)
+      ? ClipCurve::Continuous
+      : ClipCurve::Circular;
+  if (geometry.topLeftRadius == geometry.topRightRadius &&
+      geometry.topLeftRadius == geometry.bottomRightRadius &&
+      geometry.topLeftRadius == geometry.bottomLeftRadius) {
+    geometry.radius = geometry.topLeftRadius;
+  }
+  result = Presentation{
+      geometry,
+      packet[9], packet[10], packet[11],
+      Shadow{
+          packet[12] == 1.0,
+          packet[13], packet[14], packet[15], packet[16],
+          packet[17], packet[18], packet[19], packet[20]}};
+  return finitePresentation(result);
+}
+
+void appendPresentation(
+    Runtime &runtime,
+    Array &result,
+    size_t &offset,
+    const Presentation &presentation) {
+  result.setValueAtIndex(runtime, offset++, presentation.clip.x);
+  result.setValueAtIndex(runtime, offset++, presentation.clip.y);
+  result.setValueAtIndex(runtime, offset++, presentation.clip.width);
+  result.setValueAtIndex(runtime, offset++, presentation.clip.height);
+  result.setValueAtIndex(runtime, offset++, SmoothClipResolvedRadius(
+      presentation.clip.topLeftRadius, presentation.clip.radius));
+  result.setValueAtIndex(runtime, offset++, SmoothClipResolvedRadius(
+      presentation.clip.topRightRadius, presentation.clip.radius));
+  result.setValueAtIndex(runtime, offset++, SmoothClipResolvedRadius(
+      presentation.clip.bottomRightRadius, presentation.clip.radius));
+  result.setValueAtIndex(runtime, offset++, SmoothClipResolvedRadius(
+      presentation.clip.bottomLeftRadius, presentation.clip.radius));
+  result.setValueAtIndex(
+      runtime, offset++, static_cast<double>(presentation.clip.curve));
+  result.setValueAtIndex(runtime, offset++, presentation.contentTranslateX);
+  result.setValueAtIndex(runtime, offset++, presentation.contentTranslateY);
+  result.setValueAtIndex(runtime, offset++, presentation.contentScale);
+  result.setValueAtIndex(
+      runtime, offset++, presentation.shadow.enabled ? 1.0 : 0.0);
+  result.setValueAtIndex(runtime, offset++, presentation.shadow.red);
+  result.setValueAtIndex(runtime, offset++, presentation.shadow.green);
+  result.setValueAtIndex(runtime, offset++, presentation.shadow.blue);
+  result.setValueAtIndex(runtime, offset++, presentation.shadow.alpha);
+  result.setValueAtIndex(runtime, offset++, presentation.shadow.offsetX);
+  result.setValueAtIndex(runtime, offset++, presentation.shadow.offsetY);
+  result.setValueAtIndex(runtime, offset++, presentation.shadow.blurRadius);
+  result.setValueAtIndex(runtime, offset++, presentation.shadow.spreadDistance);
 }
 
 Array presentationArray(Runtime &runtime, const Presentation &presentation) {
-  Array result(runtime, 7);
-  result.setValueAtIndex(runtime, 0, presentation.clip.x);
-  result.setValueAtIndex(runtime, 1, presentation.clip.y);
-  result.setValueAtIndex(runtime, 2, presentation.clip.width);
-  result.setValueAtIndex(runtime, 3, presentation.clip.height);
-  result.setValueAtIndex(runtime, 4, presentation.clip.radius);
-  result.setValueAtIndex(runtime, 5, presentation.contentTranslateX);
-  result.setValueAtIndex(runtime, 6, presentation.contentTranslateY);
+  Array result(runtime, kPresentationStride);
+  size_t offset = 0;
+  appendPresentation(runtime, result, offset, presentation);
   return result;
 }
 
@@ -85,23 +203,78 @@ Array cancelResultArray(
     Runtime &runtime,
     bool handled,
     const Presentation &presentation) {
-  Array result(runtime, 8);
-  // JS checks `values[0] !== 1`, so the handled flag must be a number.
+  Array result(runtime, kSnapshotStride);
   result.setValueAtIndex(runtime, 0, handled ? 1.0 : 0.0);
-  result.setValueAtIndex(runtime, 1, presentation.clip.x);
-  result.setValueAtIndex(runtime, 2, presentation.clip.y);
-  result.setValueAtIndex(runtime, 3, presentation.clip.width);
-  result.setValueAtIndex(runtime, 4, presentation.clip.height);
-  result.setValueAtIndex(runtime, 5, presentation.clip.radius);
-  result.setValueAtIndex(runtime, 6, presentation.contentTranslateX);
-  result.setValueAtIndex(runtime, 7, presentation.contentTranslateY);
+  size_t offset = 1;
+  appendPresentation(runtime, result, offset, presentation);
+  return result;
+}
+
+Array snapshotsArray(
+    Runtime &runtime,
+    const std::vector<DriverSnapshot> &snapshots) {
+  Array result(runtime, snapshots.size() * kSnapshotStride);
+  size_t offset = 0;
+  for (const DriverSnapshot &snapshot : snapshots) {
+    result.setValueAtIndex(runtime, offset++, snapshot.ready ? 1.0 : 0.0);
+    const Presentation &presentation = snapshot.presentation;
+    appendPresentation(runtime, result, offset, presentation);
+  }
   return result;
 }
 
+std::vector<uint64_t> driverIdsFromArray(Runtime &runtime, const Array &values) {
+  std::vector<uint64_t> driverIds;
+  const size_t length = values.size(runtime);
+  driverIds.reserve(length);
+  for (size_t index = 0; index < length; index += 1) {
+    double value;
+    if (!numberAt(runtime, values, index, value) || !validDriverId(value) ||
+        std::find(driverIds.begin(), driverIds.end(),
+                  static_cast<uint64_t>(value)) != driverIds.end()) {
+      return {};
+    }
+    driverIds.push_back(static_cast<uint64_t>(value));
+  }
+  return driverIds;
+}
+
+bool parseGroupMotionEntries(
+    Runtime &runtime,
+    const Array &values,
+    std::vector<GroupMotionEntry> &entries) {
+  const size_t length = values.size(runtime);
+  if (length < kMotionEntryStride || length % kMotionEntryStride != 0) {
+    return false;
+  }
+  entries.reserve(length / kMotionEntryStride);
+  for (size_t index = 0; index < length; index += kMotionEntryStride) {
+    double driverId;
+    double hasFromValue;
+    Presentation from;
+    Presentation target;
+    if (!numberAt(runtime, values, index, driverId) ||
+        !numberAt(runtime, values, index + 1, hasFromValue) ||
+        !presentationAt(runtime, values, index + 2, from) ||
+        !presentationAt(
+            runtime, values, index + 2 + kPresentationStride, target) ||
+        !validDriverId(driverId) ||
+        (hasFromValue != 0.0 && hasFromValue != 1.0) ||
+        !finitePresentation(from) || !finitePresentation(target)) {
+      entries.clear();
+      return false;
+    }
+    entries.push_back(
+        {static_cast<uint64_t>(driverId), hasFromValue == 1.0, from, target});
+  }
+  return true;
+}
+
 struct BindingsState {
   Runtime *runtime = nullptr;
   std::shared_ptr<CallInvoker> callInvoker;
   std::unordered_map<int32_t, std::shared_ptr<Function>> listeners;
+  std::unordered_map<int32_t, std::shared_ptr<Function>> groupListeners;
   int32_t nextListenerId = 0;
 };
 
@@ -137,15 +310,21 @@ void installBindings(
   // against — the new one; the TurboModule invalidate hook releases them
   // while their runtime is still alive, and this is the safety net.
   state->listeners.clear();
+  state->groupListeners.clear();
   state->runtime = &runtime;
   state->callInvoker = callInvoker;
 
   setCompletionCallback(
       state.get(),
-      [state](uint64_t driverId, int32_t animationId, bool finished) {
+      [state](
+          uint64_t driverId,
+          int32_t animationId,
+          int32_t completionTag,
+          bool finished) {
         auto invoker = state->callInvoker;
         if (!invoker) return;
-        invoker->invokeAsync([state, driverId, animationId, finished]() {
+        invoker->invokeAsync(
+            [state, driverId, animationId, completionTag, finished]() {
           if (state->runtime == nullptr) return;
           Runtime &rt = *state->runtime;
           std::vector<std::shared_ptr<Function>> snapshot;
@@ -157,30 +336,260 @@ void installBindings(
             Object result(rt);
             result.setProperty(rt, "driverId", static_cast<double>(driverId));
             result.setProperty(rt, "animationId", animationId);
+            result.setProperty(rt, "completionTag", completionTag);
             result.setProperty(rt, "finished", finished);
             listener->call(rt, std::move(result));
           }
         });
       });
 
+  setGroupCompletionCallback(
+      state.get(),
+      [state](
+          uint64_t controllerId,
+          int32_t groupId,
+          int32_t completionTag,
+          bool finished,
+          std::vector<DriverSnapshot> snapshots) {
+        auto invoker = state->callInvoker;
+        if (!invoker) return;
+        invoker->invokeAsync(
+            [state, controllerId, groupId, completionTag, finished,
+             snapshots = std::move(snapshots)]() {
+              if (state->runtime == nullptr) return;
+              Runtime &rt = *state->runtime;
+              std::vector<std::shared_ptr<Function>> snapshot;
+              snapshot.reserve(state->groupListeners.size());
+              for (const auto &entry : state->groupListeners) {
+                snapshot.push_back(entry.second);
+              }
+              for (const auto &listener : snapshot) {
+                Object result(rt);
+                result.setProperty(
+                    rt, "controllerId", static_cast<double>(controllerId));
+                result.setProperty(rt, "groupId", groupId);
+                result.setProperty(rt, "completionTag", completionTag);
+                result.setProperty(rt, "finished", finished);
+                result.setProperty(
+                    rt, "snapshots", snapshotsArray(rt, snapshots));
+                listener->call(rt, std::move(result));
+              }
+            });
+      });
+
   Object bindings(runtime);
 
   setHostFunction(
-      runtime, bindings, "setClipPresentation", 11,
+      runtime, bindings, "supportsAutonomousComplexPathAnimation", 0,
+      [](Runtime &, const Value &, const Value *, size_t) -> Value {
+        // Static complex clipping is available. Autonomous complex-path
+        // animation is deliberately gated off until physical-device sampling
+        // proves the release tolerance and frame-time requirements.
+        return Value(false);
+      });
+
+  setHostFunction(
+      runtime, bindings, "beginGroupInteraction", 1,
+      [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+        if (count < 1 || !args[0].isObject() ||
+            !args[0].getObject(rt).isArray(rt)) {
+          return Array(rt, 0);
+        }
+        Array values = args[0].getObject(rt).getArray(rt);
+        const std::vector<uint64_t> driverIds = driverIdsFromArray(rt, values);
+        if (driverIds.empty()) return Array(rt, 0);
+        return snapshotsArray(rt, beginGroupInteraction(driverIds));
+      });
+
+  setHostFunction(
+      runtime, bindings, "snapshotGroup", 1,
+      [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+        if (count < 1 || !args[0].isObject() ||
+            !args[0].getObject(rt).isArray(rt)) {
+          return Array(rt, 0);
+        }
+        Array values = args[0].getObject(rt).getArray(rt);
+        const std::vector<uint64_t> driverIds = driverIdsFromArray(rt, values);
+        if (driverIds.empty()) return Array(rt, 0);
+        return snapshotsArray(rt, snapshotGroup(driverIds));
+      });
+
+  setHostFunction(
+      runtime, bindings, "setClipPresentationBatch", 1,
+      [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+        if (count < 1 || !args[0].isObject() ||
+            !args[0].getObject(rt).isArray(rt)) {
+          return Value(false);
+        }
+        Array values = args[0].getObject(rt).getArray(rt);
+        const size_t length = values.size(rt);
+        if (length < kSnapshotStride || length % kSnapshotStride != 0) {
+          return Value(false);
+        }
+        std::vector<BatchEntry> entries;
+        entries.reserve(length / kSnapshotStride);
+        for (size_t index = 0; index < length; index += kSnapshotStride) {
+          double driverId;
+          Presentation presentation;
+          if (!numberAt(rt, values, index, driverId) ||
+              !presentationAt(rt, values, index + 1, presentation) ||
+              !validDriverId(driverId) || !finitePresentation(presentation)) {
+            return Value(false);
+          }
+          entries.push_back(
+              {static_cast<uint64_t>(driverId), presentation});
+        }
+        return Value(setPresentationBatch(entries));
+      });
+
+  setHostFunction(
+      runtime, bindings, "animateTimingGroup", 10,
+      [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+        if (count < 10 || !args[1].isObject() ||
+            !args[1].getObject(rt).isArray(rt)) {
+          return Value(0);
+        }
+        const double controllerId = args[0].asNumber();
+        Array values = args[1].getObject(rt).getArray(rt);
+        std::vector<GroupMotionEntry> entries;
+        const TimingAnimation animation{
+            args[2].asNumber(), args[3].asNumber(), args[4].asNumber(),
+            args[5].asNumber(), args[6].asNumber(),
+            static_cast<int32_t>(args[7].asNumber())};
+        if (!validDriverId(controllerId) ||
+            !parseGroupMotionEntries(rt, values, entries) ||
+            !std::isfinite(animation.durationMs) ||
+            !std::isfinite(animation.controlPoint1X) ||
+            !std::isfinite(animation.controlPoint1Y) ||
+            !std::isfinite(animation.controlPoint2X) ||
+            !std::isfinite(animation.controlPoint2Y) ||
+            !std::isfinite(args[8].asNumber())) {
+          return Value(0);
+        }
+        return Value(animateTimingGroup(
+            static_cast<uint64_t>(controllerId),
+            std::move(entries),
+            animation,
+            static_cast<int32_t>(args[8].asNumber()),
+            startStampArg(args, count, 9)));
+      });
+
+  setHostFunction(
+      runtime, bindings, "animateSpringGroup", 10,
       [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-        if (count < 9) return Value::undefined();
+        if (count < 10 || !args[1].isObject() ||
+            !args[1].getObject(rt).isArray(rt)) {
+          return Value(0);
+        }
+        const double controllerId = args[0].asNumber();
+        Array values = args[1].getObject(rt).getArray(rt);
+        std::vector<GroupMotionEntry> entries;
+        const SpringAnimation animation{
+            args[2].asNumber(), args[3].asNumber(), args[4].asNumber(),
+            args[5].asNumber(), false,
+            static_cast<int32_t>(args[7].asNumber()),
+            args[6].asNumber()};
+        if (!validDriverId(controllerId) ||
+            !parseGroupMotionEntries(rt, values, entries) ||
+            !std::isfinite(animation.mass) ||
+            !std::isfinite(animation.stiffness) ||
+            !std::isfinite(animation.damping) ||
+            !std::isfinite(animation.initialVelocity) || animation.mass <= 0 ||
+            !std::isfinite(animation.energyThreshold) ||
+            !std::isfinite(args[8].asNumber()) || animation.stiffness <= 0 ||
+            animation.damping < 0 || animation.energyThreshold <= 0) {
+          return Value(0);
+        }
+        return Value(animateSpringGroup(
+            static_cast<uint64_t>(controllerId),
+            std::move(entries),
+            animation,
+            static_cast<int32_t>(args[8].asNumber()),
+            startStampArg(args, count, 9)));
+      });
+
+  setHostFunction(
+      runtime, bindings, "cancelAnimationGroup", 2,
+      [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+        if (count < 2 || !args[0].isNumber() || !args[1].isNumber()) {
+          return Array(rt, 0);
+        }
+        const double groupId = args[0].asNumber();
+        const double behavior = args[1].asNumber();
+        if (!std::isfinite(groupId) || groupId <= 0 ||
+            std::floor(groupId) != groupId ||
+            (behavior != static_cast<double>(GroupCancelBehavior::Freeze) &&
+             behavior != static_cast<double>(GroupCancelBehavior::Finish))) {
+          return Array(rt, 0);
+        }
+        return snapshotsArray(
+            rt,
+            cancelAnimationGroup(
+                static_cast<int32_t>(groupId),
+                static_cast<GroupCancelBehavior>(
+                    static_cast<int32_t>(behavior))));
+      });
+
+  setHostFunction(
+      runtime, bindings, "setClipPresentation", 4,
+      [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
+        if (count < 4 || !args[0].isNumber() || !args[1].isObject() ||
+            !args[1].getObject(rt).isArray(rt)) {
+          return Value::undefined();
+        }
+        const double driverId = args[0].asNumber();
+        const Array values = args[1].getObject(rt).getArray(rt);
+        Presentation presentation;
+        if (values.size(rt) == kPresentationStride &&
+            validDriverId(driverId) &&
+            presentationAt(rt, values, 0, presentation)) {
+          setPresentation(
+              static_cast<uint64_t>(driverId), presentation,
+              boolArg(args, count, 2), boolArg(args, count, 3), true);
+        }
+        return Value::undefined();
+      });
+
+  setHostFunction(
+      runtime, bindings, "setClipFrameScalars", 22,
+      [](Runtime &, const Value &, const Value *args, size_t count) -> Value {
+        if (count < 22) return Value::undefined();
         const double driverId = args[0].asNumber();
-        const Presentation presentation = presentationFromArgs(args, 1);
-        const bool takeOwnership = boolArg(args, count, 8);
-        const bool overridePendingAnimation = boolArg(args, count, 9);
-        // Optional trailing flag; absent means record (the pre-flag
-        // behavior), so only an explicit false skips the velocity sample.
-        const bool recordVelocity =
-            !(count > 10 && args[10].isBool() && !args[10].getBool());
-        if (validDriverId(driverId) && finitePresentation(presentation)) {
+        Geometry geometry{
+            args[1].asNumber(), args[2].asNumber(), args[3].asNumber(),
+            args[4].asNumber(), 0};
+        geometry.topLeftRadius = args[5].asNumber();
+        geometry.topRightRadius = args[6].asNumber();
+        geometry.bottomRightRadius = args[7].asNumber();
+        geometry.bottomLeftRadius = args[8].asNumber();
+        geometry.curve = static_cast<ClipCurve>(
+            static_cast<int32_t>(args[9].asNumber()));
+        if (geometry.topLeftRadius == geometry.topRightRadius &&
+            geometry.topLeftRadius == geometry.bottomRightRadius &&
+            geometry.topLeftRadius == geometry.bottomLeftRadius) {
+          geometry.radius = geometry.topLeftRadius;
+        }
+        const Presentation presentation{
+            geometry,
+            args[10].asNumber(),
+            args[11].asNumber(),
+            args[12].asNumber(),
+            {
+                boolArg(args, count, 13),
+                args[14].asNumber(),
+                args[15].asNumber(),
+                args[16].asNumber(),
+                args[17].asNumber(),
+                args[18].asNumber(),
+                args[19].asNumber(),
+                args[20].asNumber(),
+                args[21].asNumber(),
+            }};
+        if (validDriverId(driverId) && validCurve(args[9].asNumber()) &&
+            finitePresentation(presentation)) {
           setPresentation(
-              static_cast<uint64_t>(driverId), presentation, takeOwnership,
-              overridePendingAnimation, recordVelocity);
+              static_cast<uint64_t>(driverId), presentation,
+              true, false, true);
         }
         return Value::undefined();
       });
@@ -196,104 +605,91 @@ void installBindings(
       });
 
   setHostFunction(
-      runtime, bindings, "animateTiming", 23,
+      runtime, bindings, "snapshotCurrent", 1,
       [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-        if (count < 22) return Value(0);
-        const double driverId = args[0].asNumber();
-        const Presentation start = presentationFromArgs(args, 2);
-        const Presentation target = presentationFromArgs(args, 9);
-        const TimingAnimation animation{
-            args[16].asNumber(), args[17].asNumber(), args[18].asNumber(),
-            args[19].asNumber(), args[20].asNumber(),
-            static_cast<int32_t>(args[21].asNumber())};
-        if (!validDriverId(driverId) || !finitePresentation(start) ||
-            !finitePresentation(target) ||
-            !std::isfinite(animation.durationMs)) {
-          return Value(0);
+        if (count < 1 || !validDriverId(args[0].asNumber())) {
+          return presentationArray(rt, {{0, 0, 0, 0, 0}, 0, 0});
         }
-        return Value(animateTiming(
-            static_cast<uint64_t>(driverId),
-            {boolArg(args, count, 1), start, startStampArg(args, count, 22)},
-            target,
-            animation));
+        return presentationArray(
+            rt,
+            snapshotCurrentAndroid(
+                static_cast<uint64_t>(args[0].asNumber())));
       });
 
   setHostFunction(
-      runtime, bindings, "animateSpring", 23,
+      runtime, bindings, "animateTiming", 11,
       [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-        if (count < 22) return Value(0);
+        if (count < 10 || !args[0].isNumber() || !args[1].isObject() ||
+            !args[1].getObject(rt).isArray(rt) || !args[2].isObject() ||
+            !args[2].getObject(rt).isArray(rt) || !args[9].isNumber() ||
+            !std::isfinite(args[9].asNumber())) {
+          return Value(0);
+        }
         const double driverId = args[0].asNumber();
-        const Presentation start = presentationFromArgs(args, 2);
-        const Presentation target = presentationFromArgs(args, 9);
-        const SpringAnimation animation{
-            args[16].asNumber(), args[17].asNumber(), args[18].asNumber(),
-            args[19].asNumber(), boolArg(args, count, 20),
-            static_cast<int32_t>(args[21].asNumber())};
-        if (!validDriverId(driverId) || !finitePresentation(start) ||
-            !finitePresentation(target) || !std::isfinite(animation.mass) ||
-            !std::isfinite(animation.stiffness) ||
-            !std::isfinite(animation.damping) ||
-            !std::isfinite(animation.initialVelocity) ||
-            animation.mass <= 0 || animation.stiffness <= 0 ||
-            animation.damping < 0) {
+        const Array startValues = args[1].getObject(rt).getArray(rt);
+        const Array targetValues = args[2].getObject(rt).getArray(rt);
+        const bool hasInteractiveStart = startValues.size(rt) != 0;
+        Presentation start{};
+        Presentation target;
+        const TimingAnimation animation{
+            args[3].asNumber(), args[4].asNumber(), args[5].asNumber(),
+            args[6].asNumber(), args[7].asNumber(),
+            static_cast<int32_t>(args[8].asNumber())};
+        if (!validDriverId(driverId) ||
+            (hasInteractiveStart &&
+             (startValues.size(rt) != kPresentationStride ||
+              !presentationAt(rt, startValues, 0, start))) ||
+            targetValues.size(rt) != kPresentationStride ||
+            !presentationAt(rt, targetValues, 0, target) ||
+            !std::isfinite(animation.durationMs)) {
           return Value(0);
         }
-        return Value(animateSpring(
+        return Value(animateTiming(
             static_cast<uint64_t>(driverId),
-            {boolArg(args, count, 1), start, startStampArg(args, count, 22)},
+            {hasInteractiveStart, start, startStampArg(args, count, 10)},
             target,
-            animation));
+            animation,
+            static_cast<int32_t>(args[9].asNumber())));
       });
 
   setHostFunction(
-      runtime, bindings, "animateKeyframes", 20,
+      runtime, bindings, "animateSpring", 11,
       [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
-        if (count < 19 || !args[17].isObject() ||
-            !args[17].getObject(rt).isArray(rt)) {
+        if (count < 10 || !args[0].isNumber() || !args[1].isObject() ||
+            !args[1].getObject(rt).isArray(rt) || !args[2].isObject() ||
+            !args[2].getObject(rt).isArray(rt) || !args[9].isNumber() ||
+            !std::isfinite(args[9].asNumber())) {
           return Value(0);
         }
         const double driverId = args[0].asNumber();
-        const Presentation start = presentationFromArgs(args, 2);
-        const Presentation target = presentationFromArgs(args, 9);
-        const double durationMs = args[16].asNumber();
-        const int32_t reduceMotion = static_cast<int32_t>(args[18].asNumber());
-        Array frames = args[17].getObject(rt).getArray(rt);
-        const size_t length = frames.size(rt);
-        if (!validDriverId(driverId) || !finitePresentation(start) ||
-            !finitePresentation(target) || !std::isfinite(durationMs) ||
-            length < 16 || length % 8 != 0) {
-          return Value(0);
-        }
-        std::vector<Keyframe> keyframes;
-        keyframes.reserve(length / 8);
-        double previousOffset = -1;
-        for (size_t index = 0; index < length; index += 8) {
-          const double offset = frames.getValueAtIndex(rt, index).asNumber();
-          const Presentation frame{
-              {frames.getValueAtIndex(rt, index + 1).asNumber(),
-               frames.getValueAtIndex(rt, index + 2).asNumber(),
-               frames.getValueAtIndex(rt, index + 3).asNumber(),
-               frames.getValueAtIndex(rt, index + 4).asNumber(),
-               frames.getValueAtIndex(rt, index + 5).asNumber()},
-              frames.getValueAtIndex(rt, index + 6).asNumber(),
-              frames.getValueAtIndex(rt, index + 7).asNumber()};
-          if (!std::isfinite(offset) || offset < 0 || offset > 1 ||
-              offset <= previousOffset || !finitePresentation(frame)) {
-            return Value(0);
-          }
-          previousOffset = offset;
-          keyframes.push_back({offset, frame});
-        }
-        if (keyframes.front().offset != 0 || keyframes.back().offset != 1) {
+        const Array startValues = args[1].getObject(rt).getArray(rt);
+        const Array targetValues = args[2].getObject(rt).getArray(rt);
+        const bool hasInteractiveStart = startValues.size(rt) != 0;
+        Presentation start{};
+        Presentation target;
+        const SpringAnimation animation{
+            args[3].asNumber(), args[4].asNumber(), args[5].asNumber(),
+            args[6].asNumber(), boolArg(args, count, 7),
+            static_cast<int32_t>(args[8].asNumber())};
+        if (!validDriverId(driverId) ||
+            (hasInteractiveStart &&
+             (startValues.size(rt) != kPresentationStride ||
+              !presentationAt(rt, startValues, 0, start))) ||
+            targetValues.size(rt) != kPresentationStride ||
+            !presentationAt(rt, targetValues, 0, target) ||
+            !std::isfinite(animation.mass) ||
+            !std::isfinite(animation.stiffness) ||
+            !std::isfinite(animation.damping) ||
+            !std::isfinite(animation.initialVelocity) || animation.mass <= 0 ||
+            animation.stiffness <= 0 || animation.damping < 0) {
           return Value(0);
         }
-        return Value(animateKeyframes(
+        return Value(animateSpring(
             static_cast<uint64_t>(driverId),
-            {boolArg(args, count, 1), start, startStampArg(args, count, 19)},
+            {hasInteractiveStart, start, startStampArg(args, count, 10)},
             target,
-            durationMs,
-            std::move(keyframes),
-            reduceMotion));
+            animation,
+            static_cast<int32_t>(args[9].asNumber())));
       });
 
   setHostFunction(
@@ -308,13 +704,15 @@ void installBindings(
       runtime, bindings, "cancelAnimation", 3,
       [](Runtime &rt, const Value &, const Value *args, size_t count) -> Value {
         if (count < 3 || !validDriverId(args[0].asNumber())) {
-          return cancelResultArray(rt, false, {{0, 0, 0, 0, 0}, 0, 0});
+          return cancelResultArray(
+              rt, false, {{0, 0, 0, 0, 0}, 0, 0});
         }
         const CancelResult result = cancelAnimation(
             static_cast<uint64_t>(args[0].asNumber()),
             static_cast<int32_t>(args[1].asNumber()),
             static_cast<int32_t>(args[2].asNumber()) == 1);
-        return cancelResultArray(rt, result.handled, result.presentation);
+        return cancelResultArray(
+            rt, result.handled, result.presentation);
       });
 
   setHostFunction(
@@ -349,6 +747,29 @@ void installBindings(
         return subscription;
       });
 
+  setHostFunction(
+      runtime, bindings, "onClipGroupAnimationComplete", 1,
+      [state](Runtime &rt, const Value &, const Value *args, size_t count)
+          -> Value {
+        if (count < 1 || !args[0].isObject() ||
+            !args[0].getObject(rt).isFunction(rt)) {
+          return Value::undefined();
+        }
+        auto listener = std::make_shared<Function>(
+            args[0].getObject(rt).getFunction(rt));
+        const int32_t listenerId = ++state->nextListenerId;
+        state->groupListeners.emplace(listenerId, std::move(listener));
+        Object subscription(rt);
+        setHostFunction(
+            rt, subscription, "remove", 0,
+            [state, listenerId](
+                Runtime &, const Value &, const Value *, size_t) -> Value {
+              state->groupListeners.erase(listenerId);
+              return Value::undefined();
+            });
+        return subscription;
+      });
+
   runtime.global().setProperty(runtime, "__SmoothClipView", bindings);
 }
 
@@ -359,7 +780,9 @@ void invalidateBindings() {
   // own runtime.
   auto state = bindingsState();
   clearCompletionCallback(state.get());
+  clearGroupCompletionCallback(state.get());
   state->listeners.clear();
+  state->groupListeners.clear();
   state->runtime = nullptr;
   state->callInvoker = nullptr;
 }
@@ -388,19 +811,70 @@ void nativeRegisterView(
     jdouble y,
     jdouble width,
     jdouble height,
-    jdouble radius,
+    jdouble topLeftRadius,
+    jdouble topRightRadius,
+    jdouble bottomRightRadius,
+    jdouble bottomLeftRadius,
+    jint curveCode,
     jdouble contentTranslateX,
     jdouble contentTranslateY,
+    jdouble contentScale,
+    jboolean shadowEnabled,
+    jdouble shadowRed,
+    jdouble shadowGreen,
+    jdouble shadowBlue,
+    jdouble shadowAlpha,
+    jdouble shadowOffsetX,
+    jdouble shadowOffsetY,
+    jdouble shadowBlurRadius,
+    jdouble shadowSpreadDistance,
     jdouble density,
     jdouble widthPx,
     jdouble heightPx,
     jboolean lifecycleVisible) {
-  if (driverId <= 0 || !std::isfinite(driverId)) return;
+  if (driverId <= 0 || !std::isfinite(driverId) || !std::isfinite(x) ||
+      !std::isfinite(y) || !std::isfinite(width) || !std::isfinite(height) ||
+      !std::isfinite(topLeftRadius) || !std::isfinite(topRightRadius) ||
+      !std::isfinite(bottomRightRadius) || !std::isfinite(bottomLeftRadius) ||
+      !std::isfinite(contentTranslateX) ||
+      !std::isfinite(contentTranslateY) || !std::isfinite(contentScale) ||
+      !std::isfinite(shadowRed) || !std::isfinite(shadowGreen) ||
+      !std::isfinite(shadowBlue) || !std::isfinite(shadowAlpha) ||
+      !std::isfinite(shadowOffsetX) ||
+      !std::isfinite(shadowOffsetY) || !std::isfinite(shadowBlurRadius) ||
+      !std::isfinite(shadowSpreadDistance) || contentScale <= 0 ||
+      shadowRed < 0 || shadowRed > 1 || shadowGreen < 0 || shadowGreen > 1 ||
+      shadowBlue < 0 || shadowBlue > 1 || shadowAlpha < 0 || shadowAlpha > 1 ||
+      shadowBlurRadius < 0 ||
+      (curveCode != static_cast<jint>(smoothclip::ClipCurve::Circular) &&
+       curveCode != static_cast<jint>(smoothclip::ClipCurve::Continuous))) {
+    return;
+  }
+  smoothclip::Geometry geometry{x, y, width, height, 0.0};
+  geometry.topLeftRadius = topLeftRadius;
+  geometry.topRightRadius = topRightRadius;
+  geometry.bottomRightRadius = bottomRightRadius;
+  geometry.bottomLeftRadius = bottomLeftRadius;
+  geometry.curve = static_cast<smoothclip::ClipCurve>(curveCode);
+  if (topLeftRadius == topRightRadius && topLeftRadius == bottomRightRadius &&
+      topLeftRadius == bottomLeftRadius) {
+    geometry.radius = topLeftRadius;
+  }
+  smoothclip::Shadow shadow{
+      shadowEnabled != 0,
+      shadowRed,
+      shadowGreen,
+      shadowBlue,
+      shadowAlpha,
+      shadowOffsetX,
+      shadowOffsetY,
+      shadowBlurRadius,
+      shadowSpreadDistance};
   smoothclip::registerViewAndroid(
       static_cast<uint64_t>(driverId),
       view,
       smoothclip::Presentation{
-          {x, y, width, height, radius}, contentTranslateX, contentTranslateY},
+          geometry, contentTranslateX, contentTranslateY, contentScale, shadow},
       density,
       widthPx,
       heightPx,
@@ -427,6 +901,13 @@ void nativeUnregisterView(
   smoothclip::unregisterViewAndroid(static_cast<uint64_t>(driverId), view);
 }
 
+void nativeDestroyDriver(
+    jni::alias_ref<jni::JObject>,
+    jdouble driverId) {
+  if (driverId <= 0 || !std::isfinite(driverId)) return;
+  smoothclip::destroyDriver(static_cast<uint64_t>(driverId));
+}
+
 void nativeSetViewLifecycleVisibility(
     jni::alias_ref<jni::JObject>,
     jdouble driverId,
@@ -457,6 +938,7 @@ JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM *vm, void *) {
             makeNativeMethod(
                 "nativeSetViewHostGeometry", nativeSetViewHostGeometry),
             makeNativeMethod("nativeUnregisterView", nativeUnregisterView),
+            makeNativeMethod("nativeDestroyDriver", nativeDestroyDriver),
             makeNativeMethod(
                 "nativeSetViewLifecycleVisibility",
                 nativeSetViewLifecycleVisibility),