Added useAnimatedSensor() (software-mansion#2868)

## Description

Added API to create an animation based on sensor device data in a very simple way.

### Example code

```js
function AnimatedStyleUpdateExample() {

  const animatedSensor = useAnimatedSensor(SensorType.ROTATION, { interval: 10 }); // <- initialization
  const style = useAnimatedStyle(() => {
    const yaw = Math.abs(animatedSensor.sensor.value.yaw);
    const pitch = Math.abs(animatedSensor.sensor.value.pitch);
    return {
      height: withTiming(yaw * 200 + 20, { duration: 100 }), // <- usage
      width: withTiming(pitch * 200 + 20, { duration: 100 }), // <- usage
    };
  });

  return (
    <View style={{ flex: 1, justifyContent: 'center', alignItems: 'center' }}>
      <Animated.View
        style={[
          { width: 100, height: 80, backgroundColor: 'black', margin: 30 },
          style,
        ]}
      />
    </View>
  );
}
```


https://user-images.githubusercontent.com/36106620/158634922-eaad656e-c837-44d5-8d51-8e7fa27c5a16.mp4

Common/cpp/AnimatedSensor/AnimatedSensorModule.cpp

@@ -0,0 +1,72 @@
+#include "AnimatedSensorModule.h"
+#include "MutableValue.h"
+#include "ValueWrapper.h"
+
+namespace reanimated {
+
+AnimatedSensorModule::AnimatedSensorModule(
+    const PlatformDepMethodsHolder &platformDepMethodsHolder,
+    RuntimeManager *runtimeManager)
+    : platformRegisterSensorFunction_(platformDepMethodsHolder.registerSensor),
+      platformUnregisterSensorFunction_(
+          platformDepMethodsHolder.unregisterSensor),
+      runtimeManager_(runtimeManager) {}
+
+AnimatedSensorModule::~AnimatedSensorModule() {
+  // It is called during app reload because app reload doesn't call hooks
+  // unmounting
+  for (auto sensorId : sensorsIds_) {
+    platformUnregisterSensorFunction_(sensorId);
+  }
+}
+
+jsi::Value AnimatedSensorModule::registerSensor(
+    jsi::Runtime &rt,
+    const jsi::Value &sensorType,
+    const jsi::Value &interval,
+    const jsi::Value &sensorDataContainer) {
+  std::shared_ptr<ShareableValue> sensorsData = ShareableValue::adapt(
+      rt, sensorDataContainer.getObject(rt), runtimeManager_);
+  auto &mutableObject =
+      ValueWrapper::asMutableValue(sensorsData->valueContainer);
+
+  std::function<void(double[])> setter;
+  if (sensorType.asNumber() == SensorType::ROTATION_VECTOR) {
+    setter = [&, mutableObject](double newValues[]) {
+      jsi::Runtime &runtime = *runtimeManager_->runtime.get();
+      jsi::Object value(runtime);
+      value.setProperty(runtime, "qw", newValues[0]);
+      value.setProperty(runtime, "qx", newValues[1]);
+      value.setProperty(runtime, "qy", newValues[2]);
+      value.setProperty(runtime, "qz", newValues[3]);
+      value.setProperty(runtime, "yaw", newValues[4]);
+      value.setProperty(runtime, "pitch", newValues[5]);
+      value.setProperty(runtime, "roll", newValues[6]);
+      mutableObject->setValue(runtime, std::move(value));
+    };
+  } else {
+    setter = [&, mutableObject](double newValues[]) {
+      jsi::Runtime &runtime = *runtimeManager_->runtime.get();
+      jsi::Object value(runtime);
+      value.setProperty(runtime, "x", newValues[0]);
+      value.setProperty(runtime, "y", newValues[1]);
+      value.setProperty(runtime, "z", newValues[2]);
+      mutableObject->setValue(runtime, std::move(value));
+    };
+  }
+
+  int sensorId = platformRegisterSensorFunction_(
+      sensorType.asNumber(), interval.asNumber(), setter);
+  if (sensorId != -1) {
+    sensorsIds_.insert(sensorId);
+  }
+  return jsi::Value(sensorId);
+}
+
+void AnimatedSensorModule::unregisterSensor(const jsi::Value &sensorId) {
+  // It is called during sensor hook unmounting
+  sensorsIds_.erase(sensorId.getNumber());
+  platformUnregisterSensorFunction_(sensorId.asNumber());
+}
+
+} // namespace reanimated

Common/cpp/NativeModules/NativeReanimatedModule.cpp

@@ -8,6 +8,7 @@
 #include "JSIStoreValueUser.h"
 #include "Mapper.h"
 #include "MapperRegistry.h"
+#include "MutableValue.h"
 #include "ReanimatedHiddenHeaders.h"
 #include "RuntimeDecorator.h"
 #include "ShareableValue.h"
@@ -71,6 +72,7 @@ NativeReanimatedModule::NativeReanimatedModule(
       eventHandlerRegistry(std::make_shared<EventHandlerRegistry>()),
       requestRender(platformDepMethodsHolder.requestRender),
       propObtainer(propObtainer),
+      animatedSensorModule(platformDepMethodsHolder, this),
       configurePropsPlatformFunction(
           platformDepMethodsHolder.configurePropsFunction) {
   auto requestAnimationFrame = [=](FrameCallback callback) {
@@ -87,6 +89,8 @@ NativeReanimatedModule::NativeReanimatedModule(
       platformDepMethodsHolder.scrollToFunction,
       platformDepMethodsHolder.measuringFunction,
       platformDepMethodsHolder.getCurrentTime,
+      platformDepMethodsHolder.registerSensor,
+      platformDepMethodsHolder.unregisterSensor,
       platformDepMethodsHolder.setGestureStateFunction,
       layoutAnimationsProxy);
   onRenderCallback = [this](double timestampMs) {
@@ -308,4 +312,19 @@ void NativeReanimatedModule::onRender(double timestampMs) {
   }
 }
 
+jsi::Value NativeReanimatedModule::registerSensor(
+    jsi::Runtime &rt,
+    const jsi::Value &sensorType,
+    const jsi::Value &interval,
+    const jsi::Value &sensorDataContainer) {
+  return animatedSensorModule.registerSensor(
+      rt, sensorType, interval, sensorDataContainer);
+}
+
+void NativeReanimatedModule::unregisterSensor(
+    jsi::Runtime &rt,
+    const jsi::Value &sensorId) {
+  animatedSensorModule.unregisterSensor(sensorId);
+}
+
 } // namespace reanimated

Common/cpp/NativeModules/NativeReanimatedModuleSpec.cpp

@@ -108,6 +108,26 @@ static jsi::Value SPEC_PREFIX(enableLayoutAnimations)(
   return jsi::Value::undefined();
 }
 
+static jsi::Value SPEC_PREFIX(registerSensor)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t count) {
+  return static_cast<NativeReanimatedModuleSpec *>(&turboModule)
+      ->registerSensor(
+          rt, std::move(args[0]), std::move(args[1]), std::move(args[2]));
+}
+
+static jsi::Value SPEC_PREFIX(unregisterSensor)(
+    jsi::Runtime &rt,
+    TurboModule &turboModule,
+    const jsi::Value *args,
+    size_t count) {
+  static_cast<NativeReanimatedModuleSpec *>(&turboModule)
+      ->unregisterSensor(rt, std::move(args[0]));
+  return jsi::Value::undefined();
+}
+
 static jsi::Value SPEC_PREFIX(configureProps)(
     jsi::Runtime &rt,
     TurboModule &turboModule,
@@ -139,7 +159,9 @@ NativeReanimatedModuleSpec::NativeReanimatedModuleSpec(
   methodMap_["getViewProp"] = MethodMetadata{3, SPEC_PREFIX(getViewProp)};
   methodMap_["enableLayoutAnimations"] =
       MethodMetadata{2, SPEC_PREFIX(enableLayoutAnimations)};
+  methodMap_["registerSensor"] = MethodMetadata{3, SPEC_PREFIX(registerSensor)};
+  methodMap_["unregisterSensor"] =
+      MethodMetadata{1, SPEC_PREFIX(unregisterSensor)};
   methodMap_["configureProps"] = MethodMetadata{2, SPEC_PREFIX(configureProps)};
 }
-
 } // namespace reanimated

Common/cpp/Tools/RuntimeDecorator.cpp

@@ -109,6 +109,8 @@ void RuntimeDecorator::decorateUIRuntime(
     const ScrollToFunction scrollTo,
     const MeasuringFunction measure,
     const TimeProviderFunction getCurrentTime,
+    const RegisterSensorFunction registerSensor,
+    const UnregisterSensorFunction unregisterSensor,
     const SetGestureStateFunction setGestureState,
     std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy) {
   RuntimeDecorator::decorateRuntime(rt, "UI");

Common/cpp/headers/AnimatedSensor/AnimatedSensorModule.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <jsi/jsi.h>
+#include <unordered_set>
+
+#include "PlatformDepMethodsHolder.h"
+#include "RuntimeManager.h"
+
+namespace reanimated {
+
+using namespace facebook;
+
+enum SensorType {
+  ACCELEROMETER = 1,
+  GYROSCOPE = 2,
+  GRAVITY = 3,
+  MAGNETIC_FIELD = 4,
+  ROTATION_VECTOR = 5,
+};
+
+class AnimatedSensorModule {
+  std::unordered_set<int> sensorsIds_;
+  RegisterSensorFunction platformRegisterSensorFunction_;
+  UnregisterSensorFunction platformUnregisterSensorFunction_;
+  RuntimeManager *runtimeManager_;
+
+ public:
+  AnimatedSensorModule(
+      const PlatformDepMethodsHolder &platformDepMethodsHolder,
+      RuntimeManager *runtimeManager);
+  ~AnimatedSensorModule();
+
+  jsi::Value registerSensor(
+      jsi::Runtime &rt,
+      const jsi::Value &sensorType,
+      const jsi::Value &interval,
+      const jsi::Value &sensorDataContainer);
+  void unregisterSensor(const jsi::Value &sensorId);
+};
+
+} // namespace reanimated

Common/cpp/headers/NativeModules/NativeReanimatedModule.h

@@ -5,6 +5,7 @@
 #include <string>
 #include <vector>
 
+#include "AnimatedSensorModule.h"
 #include "ErrorHandler.h"
 #include "LayoutAnimationsProxy.h"
 #include "NativeReanimatedModuleSpec.h"
@@ -82,6 +83,13 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
   void maybeRequestRender();
   UpdaterFunction updaterFunction;
 
+  jsi::Value registerSensor(
+      jsi::Runtime &rt,
+      const jsi::Value &sensorType,
+      const jsi::Value &interval,
+      const jsi::Value &sensorDataContainer) override;
+  void unregisterSensor(jsi::Runtime &rt, const jsi::Value &sensorId) override;
+
  private:
   std::shared_ptr<MapperRegistry> mapperRegistry;
   std::shared_ptr<EventHandlerRegistry> eventHandlerRegistry;
@@ -93,6 +101,7 @@ class NativeReanimatedModule : public NativeReanimatedModuleSpec,
       propObtainer;
   std::function<void(double)> onRenderCallback;
   std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy;
+  AnimatedSensorModule animatedSensorModule;
   ConfigurePropsFunction configurePropsPlatformFunction;
 };
 

Common/cpp/headers/NativeModules/NativeReanimatedModuleSpec.h

@@ -59,6 +59,16 @@ class JSI_EXPORT NativeReanimatedModuleSpec : public TurboModule {
       const jsi::Value &propName,
       const jsi::Value &callback) = 0;
 
+  // sensors
+  virtual jsi::Value registerSensor(
+      jsi::Runtime &rt,
+      const jsi::Value &sensorType,
+      const jsi::Value &interval,
+      const jsi::Value &sensorDataContainer) = 0;
+  virtual void unregisterSensor(
+      jsi::Runtime &rt,
+      const jsi::Value &sensorId) = 0;
+
   // other
   virtual jsi::Value enableLayoutAnimations(
       jsi::Runtime &rt,

Common/cpp/headers/SharedItems/MutableValue.h

@@ -20,13 +20,16 @@ class MutableValue : public jsi::HostObject,
                      public StoreUser {
  private:
   friend MutableValueSetterProxy;
-  RuntimeManager *runtimeManager;
   friend LayoutAnimationsProxy;
+
+ private:
+  RuntimeManager *runtimeManager;
   std::mutex readWriteMutex;
   std::shared_ptr<ShareableValue> value;
   std::weak_ptr<jsi::Value> animation;
   std::map<unsigned long, std::function<void()>> listeners;
 
+ public:
   void setValue(jsi::Runtime &rt, const jsi::Value &newValue);
   jsi::Value getValue(jsi::Runtime &rt);
 

Common/cpp/headers/SharedItems/ShareableValue.h

@@ -6,6 +6,7 @@
 #include <string>
 #include <unordered_map>
 #include <vector>
+#include "AnimatedSensorModule.h"
 #include "HostFunctionHandler.h"
 #include "JSIStoreValueUser.h"
 #include "LayoutAnimationsProxy.h"
@@ -24,6 +25,8 @@ class ShareableValue : public std::enable_shared_from_this<ShareableValue>,
   friend WorkletsCache;
   friend FrozenObject;
   friend LayoutAnimationsProxy;
+  friend NativeReanimatedModule;
+  friend AnimatedSensorModule;
   friend void extractMutables(
       jsi::Runtime &rt,
       std::shared_ptr<ShareableValue> sv,

Common/cpp/headers/SharedItems/ValueWrapper.h

@@ -12,8 +12,11 @@
 namespace reanimated {
 
 class HostFunctionWrapper;
+class AnimatedSensorModule;
 
 class ValueWrapper {
+  friend AnimatedSensorModule;
+
  public:
   ValueWrapper() {}
   explicit ValueWrapper(ValueType _type) : type(_type) {}

Common/cpp/headers/Tools/PlatformDepMethodsHolder.h

@@ -21,6 +21,10 @@ using ScrollToFunction = std::function<void(int, double, double, bool)>;
 using MeasuringFunction =
     std::function<std::vector<std::pair<std::string, double>>(int)>;
 using TimeProviderFunction = std::function<double(void)>;
+
+using RegisterSensorFunction =
+    std::function<int(int, int, std::function<void(double[])>)>;
+using UnregisterSensorFunction = std::function<void(int)>;
 using SetGestureStateFunction = std::function<void(int, int)>;
 using ConfigurePropsFunction = std::function<void(
     jsi::Runtime &rt,
@@ -33,6 +37,8 @@ struct PlatformDepMethodsHolder {
   ScrollToFunction scrollToFunction;
   MeasuringFunction measuringFunction;
   TimeProviderFunction getCurrentTime;
+  RegisterSensorFunction registerSensor;
+  UnregisterSensorFunction unregisterSensor;
   SetGestureStateFunction setGestureStateFunction;
   ConfigurePropsFunction configurePropsFunction;
 };

Common/cpp/headers/Tools/RuntimeDecorator.h

@@ -36,6 +36,8 @@ class RuntimeDecorator {
       const ScrollToFunction scrollTo,
       const MeasuringFunction measure,
       const TimeProviderFunction getCurrentTime,
+      const RegisterSensorFunction registerSensor,
+      const UnregisterSensorFunction unregisterSensor,
       const SetGestureStateFunction setGestureState,
       std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy);
 

Example/ios/ReanimatedExample/Info.plist

@@ -2,6 +2,8 @@
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
 <plist version="1.0">
 <dict>
+	<key>CADisableMinimumFrameDurationOnPhone</key>
+	<true/>
 	<key>CFBundleDevelopmentRegion</key>
 	<string>en</string>
 	<key>CFBundleDisplayName</key>
@@ -51,7 +53,5 @@
 	</array>
 	<key>UIViewControllerBasedStatusBarAppearance</key>
 	<false/>
-	<key>CADisableMinimumFrameDurationOnPhone</key>
-	<true/>
 </dict>
 </plist>

Example/src/AnimatedSensorExample.tsx

@@ -0,0 +1,46 @@
+import React from 'react';
+import Animated, {
+  withTiming,
+  useAnimatedStyle,
+  useAnimatedSensor,
+  SensorType,
+} from 'react-native-reanimated';
+import { View, Button, StyleSheet } from 'react-native';
+
+export default function AnimatedStyleUpdateExample() {
+  const animatedSensor = useAnimatedSensor(SensorType.ROTATION, {
+    interval: 10,
+  });
+  const style = useAnimatedStyle(() => {
+    const yaw = Math.abs(animatedSensor.sensor.value.yaw);
+    const pitch = Math.abs(animatedSensor.sensor.value.pitch);
+    return {
+      height: withTiming(yaw * 200 + 20, { duration: 100 }),
+      width: withTiming(pitch * 200 + 20, { duration: 100 }),
+    };
+  });
+
+  return (
+    <View style={componentStyle.container}>
+      <Button
+        title={'log data'}
+        onPress={() => console.log(animatedSensor.sensor.value)}
+      />
+      <Animated.View style={[componentStyle.square, style]} />
+    </View>
+  );
+}
+
+const componentStyle = StyleSheet.create({
+  container: {
+    flex: 1,
+    justifyContent: 'center',
+    alignItems: 'center',
+  },
+  square: {
+    width: 50,
+    height: 50,
+    backgroundColor: 'black',
+    margin: 30,
+  },
+});