react-native-reanimated 2.3.3 → 2.5.0

package/ios/LayoutReanimation/REAAnimationsManager.m

@@ -14,6 +14,7 @@ typedef NS_ENUM(NSInteger, FrameConfigType) { EnteringFrame, ExitingFrame };
 
 - (void)removeLeftovers;
 - (void)scheduleCleaning;
+- (double)getDoubleOrZero:(NSNumber *)number;
 
 @end
 
@@ -150,6 +151,10 @@ typedef NS_ENUM(NSInteger, FrameConfigType) { EnteringFrame, ExitingFrame };
   NSMutableSet<NSNumber *> *roots = [NSMutableSet new];
   for (NSNumber *viewTag in _toRemove) {
     UIView *view = _viewForTag[viewTag];
+    if (view == nil) {
+      view = [_reaUiManager viewForReactTag:viewTag];
+      _viewForTag[viewTag] = view;
+    }
     [self findRoot:view roots:roots];
   }
   for (NSNumber *viewTag in roots) {
@@ -190,31 +195,40 @@ typedef NS_ENUM(NSInteger, FrameConfigType) { EnteringFrame, ExitingFrame };
   [self setNewProps:[newStyle mutableCopy] forView:_viewForTag[tag] withComponentData:componentData];
 }
 
+- (double)getDoubleOrZero:(NSNumber *)number
+{
+  double doubleValue = [number doubleValue];
+  if (doubleValue != doubleValue) { // NaN != NaN
+    return 0;
+  }
+  return doubleValue;
+}
+
 - (void)setNewProps:(NSMutableDictionary *)newProps
               forView:(UIView *)view
     withComponentData:(RCTComponentData *)componentData
 {
   if (newProps[@"height"]) {
-    double height = [newProps[@"height"] doubleValue];
+    double height = [self getDoubleOrZero:newProps[@"height"]];
     double oldHeight = view.bounds.size.height;
     view.bounds = CGRectMake(0, 0, view.bounds.size.width, height);
     view.center = CGPointMake(view.center.x, view.center.y - oldHeight / 2.0 + view.bounds.size.height / 2.0);
     [newProps removeObjectForKey:@"height"];
   }
   if (newProps[@"width"]) {
-    double width = [newProps[@"width"] doubleValue];
+    double width = [self getDoubleOrZero:newProps[@"width"]];
     double oldWidth = view.bounds.size.width;
     view.bounds = CGRectMake(0, 0, width, view.bounds.size.height);
     view.center = CGPointMake(view.center.x + view.bounds.size.width / 2.0 - oldWidth / 2.0, view.center.y);
     [newProps removeObjectForKey:@"width"];
   }
   if (newProps[@"originX"]) {
-    double originX = [newProps[@"originX"] doubleValue];
+    double originX = [self getDoubleOrZero:newProps[@"originX"]];
     view.center = CGPointMake(originX + view.bounds.size.width / 2.0, view.center.y);
     [newProps removeObjectForKey:@"originX"];
   }
   if (newProps[@"originY"]) {
-    double originY = [newProps[@"originY"] doubleValue];
+    double originY = [self getDoubleOrZero:newProps[@"originY"]];
     view.center = CGPointMake(view.center.x, originY + view.bounds.size.height / 2.0);
     [newProps removeObjectForKey:@"originY"];
   }

package/ios/REAModule.m

@@ -28,6 +28,8 @@ RCT_EXPORT_MODULE(ReanimatedModule);
   return RCTGetUIManagerQueue();
 }
 
+#pragma mark-- Initialize
+
 - (void)setBridge:(RCTBridge *)bridge
 {
   [super setBridge:bridge];
@@ -40,6 +42,11 @@ RCT_EXPORT_MODULE(ReanimatedModule);
   [bridge.uiManager.observerCoordinator addObserver:self];
 }
 
+RCT_EXPORT_METHOD(installTurboModule)
+{
+  // TODO: Move initialization from UIResponder+Reanimated to here
+}
+
 #pragma mark-- Transitioning API
 
 RCT_EXPORT_METHOD(animateNextTransition : (nonnull NSNumber *)rootTag config : (NSDictionary *)config)
@@ -119,15 +126,6 @@ RCT_EXPORT_METHOD(detachEvent
   }];
 }
 
-RCT_EXPORT_METHOD(configureProps
-                  : (nonnull NSArray<NSString *> *)nativeProps uiProps
-                  : (nonnull NSArray<NSString *> *)uiProps)
-{
-  [self addOperationBlock:^(REANodesManager *nodesManager) {
-    [nodesManager configureProps:[NSSet setWithArray:nativeProps] uiProps:[NSSet setWithArray:uiProps]];
-  }];
-}
-
 RCT_EXPORT_METHOD(setValue : (nonnull NSNumber *)nodeID newValue : (nonnull NSNumber *)newValue)
 {
   [self addOperationBlock:^(REANodesManager *nodesManager) {
@@ -153,6 +151,7 @@ RCT_EXPORT_METHOD(triggerRender)
 
 - (void)uiManagerWillPerformMounting:(RCTUIManager *)uiManager
 {
+  [_nodesManager maybeFlushUpdateBuffer];
   if (_operations.count == 0) {
     return;
   }

package/ios/REANodesManager.h

@@ -64,7 +64,8 @@ typedef void (^REAEventHandler)(NSString *eventName, id<RCTEvent> event);
 
 // configuration
 
-- (void)configureProps:(nonnull NSSet<NSString *> *)nativeProps uiProps:(nonnull NSSet<NSString *> *)uiProps;
+- (void)configureUiProps:(nonnull NSSet<NSString *> *)uiPropsSet
+          andNativeProps:(nonnull NSSet<NSString *> *)nativePropsSet;
 
 - (void)updateProps:(nonnull NSDictionary *)props
       ofViewWithTag:(nonnull NSNumber *)viewTag
@@ -78,4 +79,6 @@ typedef void (^REAEventHandler)(NSString *eventName, id<RCTEvent> event);
 
 - (void)setValueForNodeID:(nonnull NSNumber *)nodeID value:(nonnull NSNumber *)newValue;
 
+- (void)maybeFlushUpdateBuffer;
+
 @end

package/ios/REANodesManager.m

@@ -3,6 +3,7 @@
 #import <React/RCTConvert.h>
 
 #import <React/RCTShadowView.h>
+#import <stdatomic.h>
 #import "Nodes/REAAlwaysNode.h"
 #import "Nodes/REABezierNode.h"
 #import "Nodes/REABlockNode.h"
@@ -46,6 +47,17 @@
 
 @end
 
+@interface ComponentUpdate : NSObject
+
+@property (nonnull) NSMutableDictionary *props;
+@property (nonnull) NSNumber *viewTag;
+@property (nonnull) NSString *viewName;
+
+@end
+
+@implementation ComponentUpdate
+@end
+
 @implementation RCTUIManager (SyncUpdates)
 
 - (BOOL)hasEnqueuedUICommands
@@ -99,6 +111,9 @@
   BOOL _tryRunBatchUpdatesSynchronously;
   REAEventHandler _eventHandler;
   volatile void (^_mounting)(void);
+  NSMutableDictionary<NSNumber *, ComponentUpdate *> *_componentUpdateBuffer;
+  volatile atomic_bool _shouldFlushUpdateBuffer;
+  NSMutableDictionary<NSNumber *, UIView *> *_viewRegistry;
 }
 
 - (instancetype)initWithModule:(REAModule *)reanimatedModule uiManager:(RCTUIManager *)uiManager
@@ -113,6 +128,9 @@
     _wantRunUpdates = NO;
     _onAnimationCallbacks = [NSMutableArray new];
     _operationsInBatch = [NSMutableArray new];
+    _componentUpdateBuffer = [NSMutableDictionary new];
+    _viewRegistry = [_uiManager valueForKey:@"_viewRegistry"];
+    _shouldFlushUpdateBuffer = false;
   }
 
   _displayLink = [CADisplayLink displayLinkWithTarget:self selector:@selector(onAnimationFrame:)];
@@ -486,10 +504,16 @@
   }
 }
 
-- (void)configureProps:(NSSet<NSString *> *)nativeProps uiProps:(NSSet<NSString *> *)uiProps
+- (void)configureUiProps:(nonnull NSSet<NSString *> *)uiPropsSet
+          andNativeProps:(nonnull NSSet<NSString *> *)nativePropsSet
 {
-  _uiProps = uiProps;
-  _nativeProps = nativeProps;
+  _uiProps = uiPropsSet;
+  _nativeProps = nativePropsSet;
+}
+
+- (BOOL)isNotNativeViewFullyMounted:(NSNumber *)viewTag
+{
+  return _viewRegistry[viewTag].superview == nil;
 }
 
 - (void)setValueForNodeID:(nonnull NSNumber *)nodeID value:(nonnull NSNumber *)newValue
@@ -506,6 +530,24 @@
       ofViewWithTag:(nonnull NSNumber *)viewTag
            withName:(nonnull NSString *)viewName
 {
+  ComponentUpdate *lastSnapshot = _componentUpdateBuffer[viewTag];
+  if ([self isNotNativeViewFullyMounted:viewTag] || lastSnapshot != nil) {
+    if (lastSnapshot == nil) {
+      ComponentUpdate *propsSnapshot = [ComponentUpdate new];
+      propsSnapshot.props = [props mutableCopy];
+      propsSnapshot.viewTag = viewTag;
+      propsSnapshot.viewName = viewName;
+      _componentUpdateBuffer[viewTag] = propsSnapshot;
+      atomic_store(&_shouldFlushUpdateBuffer, true);
+    } else {
+      NSMutableDictionary *lastProps = lastSnapshot.props;
+      for (NSString *key in props) {
+        [lastProps setValue:props[key] forKey:key];
+      }
+    }
+    return;
+  }
+
   // TODO: refactor PropsNode to also use this function
   NSMutableDictionary *uiProps = [NSMutableDictionary new];
   NSMutableDictionary *nativeProps = [NSMutableDictionary new];
@@ -553,4 +595,34 @@
   return result;
 }
 
+- (void)maybeFlushUpdateBuffer
+{
+  RCTAssertUIManagerQueue();
+  bool shouldFlushUpdateBuffer = atomic_load(&_shouldFlushUpdateBuffer);
+  if (!shouldFlushUpdateBuffer) {
+    return;
+  }
+
+  __weak typeof(self) weakSelf = self;
+  [_uiManager addUIBlock:^(__unused RCTUIManager *manager, __unused NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+    __typeof__(self) strongSelf = weakSelf;
+    if (strongSelf == nil) {
+      return;
+    }
+    atomic_store(&strongSelf->_shouldFlushUpdateBuffer, false);
+    NSMutableDictionary *componentUpdateBuffer = [strongSelf->_componentUpdateBuffer copy];
+    strongSelf->_componentUpdateBuffer = [NSMutableDictionary new];
+    for (NSNumber *tag in componentUpdateBuffer) {
+      ComponentUpdate *componentUpdate = componentUpdateBuffer[tag];
+      if (componentUpdate == Nil) {
+        continue;
+      }
+      [strongSelf updateProps:componentUpdate.props
+                ofViewWithTag:componentUpdate.viewTag
+                     withName:componentUpdate.viewName];
+    }
+    [strongSelf performOperations];
+  }];
+}
+
 @end

package/ios/native/NativeMethods.h

@@ -1,11 +1,11 @@
 #import <Foundation/Foundation.h>
+#import <RNGestureHandlerStateManager.h>
 #import <React/RCTUIManager.h>
 #include <string>
 #import <string>
 #include <utility>
 #include <vector>
 #import <vector>
-#import "RNGestureHandlerStateManager.h"
 
 namespace reanimated {
 

package/ios/native/NativeProxy.mm

@@ -1,8 +1,12 @@
+#if TARGET_IPHONE_SIMULATOR
+#import <dlfcn.h>
+#endif
 
 #import <React/RCTFollyConvert.h>
 #import <React/RCTUIManager.h>
 #import <folly/json.h>
 
+#import <RNGestureHandlerStateManager.h>
 #import "LayoutAnimationsProxy.h"
 #import "NativeMethods.h"
 #import "NativeProxy.h"
@@ -12,7 +16,7 @@
 #import "REAModule.h"
 #import "REANodesManager.h"
 #import "REAUIManager.h"
-#import "RNGestureHandlerStateManager.h"
+#import "ReanimatedSensorContainer.h"
 
 #if __has_include(<reacthermes/HermesExecutorFactory.h>)
 #import <reacthermes/HermesExecutorFactory.h>
@@ -27,6 +31,41 @@ namespace reanimated {
 using namespace facebook;
 using namespace react;
 
+static CGFloat SimAnimationDragCoefficient(void)
+{
+  static float (*UIAnimationDragCoefficient)(void) = NULL;
+#if TARGET_IPHONE_SIMULATOR
+  static dispatch_once_t onceToken;
+  dispatch_once(&onceToken, ^{
+    UIAnimationDragCoefficient = (float (*)(void))dlsym(RTLD_DEFAULT, "UIAnimationDragCoefficient");
+  });
+#endif
+  return UIAnimationDragCoefficient ? UIAnimationDragCoefficient() : 1.f;
+}
+
+static CFTimeInterval calculateTimestampWithSlowAnimations(CFTimeInterval currentTimestamp)
+{
+#if TARGET_IPHONE_SIMULATOR
+  static CFTimeInterval dragCoefChangedTimestamp = CACurrentMediaTime();
+  static CGFloat previousDragCoef = SimAnimationDragCoefficient();
+
+  const CGFloat dragCoef = SimAnimationDragCoefficient();
+  if (previousDragCoef != dragCoef) {
+    previousDragCoef = dragCoef;
+    dragCoefChangedTimestamp = CACurrentMediaTime();
+  }
+
+  const bool areSlowAnimationsEnabled = dragCoef != 1.f;
+  if (areSlowAnimationsEnabled) {
+    return (dragCoefChangedTimestamp + (currentTimestamp - dragCoefChangedTimestamp) / dragCoef);
+  } else {
+    return currentTimestamp;
+  }
+#else
+  return currentTimestamp;
+#endif
+}
+
 // COPIED FROM RCTTurboModule.mm
 static id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &value);
 
@@ -87,6 +126,17 @@ static id convertJSIValueToObjCObject(jsi::Runtime &runtime, const jsi::Value &v
   throw std::runtime_error("Unsupported jsi::jsi::Value kind");
 }
 
+static NSSet *convertProps(jsi::Runtime &rt, const jsi::Value &props)
+{
+  NSMutableSet *propsSet = [[NSMutableSet alloc] init];
+  jsi::Array propsNames = props.asObject(rt).asArray(rt);
+  for (int i = 0; i < propsNames.size(rt); i++) {
+    NSString *propName = @(propsNames.getValueAtIndex(rt, i).asString(rt).utf8(rt).c_str());
+    [propsSet addObject:propName];
+  }
+  return propsSet;
+}
+
 std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     RCTBridge *bridge,
     std::shared_ptr<CallInvoker> jsInvoker)
@@ -149,7 +199,7 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
 
   auto requestRender = [reanimatedModule, &module](std::function<void(double)> onRender, jsi::Runtime &rt) {
     [reanimatedModule.nodesManager postOnAnimation:^(CADisplayLink *displayLink) {
-      double frameTimestamp = displayLink.targetTimestamp * 1000;
+      double frameTimestamp = calculateTimestampWithSlowAnimations(displayLink.targetTimestamp) * 1000;
       jsi::Object global = rt.global();
       jsi::String frameTimestampName = jsi::String::createFromAscii(rt, "_frameTimestamp");
       global.setProperty(rt, frameTimestampName, frameTimestamp);
@@ -158,7 +208,7 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     }];
   };
 
-  auto getCurrentTime = []() { return CACurrentMediaTime() * 1000; };
+  auto getCurrentTime = []() { return calculateTimestampWithSlowAnimations(CACurrentMediaTime()) * 1000; };
 
   // Layout Animations start
   REAUIManager *reaUiManagerNoCast = [bridge moduleForClass:[REAUIManager class]];
@@ -179,6 +229,13 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
     }
   };
 
+  auto configurePropsFunction = [reanimatedModule](
+                                    jsi::Runtime &rt, const jsi::Value &uiProps, const jsi::Value &nativeProps) {
+    NSSet *uiPropsSet = convertProps(rt, uiProps);
+    NSSet *nativePropsSet = convertProps(rt, nativeProps);
+    [reanimatedModule.nodesManager configureUiProps:uiPropsSet andNativeProps:nativePropsSet];
+  };
+
   std::shared_ptr<LayoutAnimationsProxy> layoutAnimationsProxy =
       std::make_shared<LayoutAnimationsProxy>(notifyAboutProgress, notifyAboutEnd);
   std::weak_ptr<jsi::Runtime> wrt = animatedRuntime;
@@ -224,14 +281,29 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
 
   // Layout Animations end
 
+  // sensors
+  ReanimatedSensorContainer *reanimatedSensorContainer = [[ReanimatedSensorContainer alloc] init];
+  auto registerSensorFunction = [=](int sensorType, int interval, std::function<void(double[])> setter) -> int {
+    return [reanimatedSensorContainer registerSensor:(ReanimatedSensorType)sensorType
+                                            interval:interval
+                                              setter:^(double *data) {
+                                                setter(data);
+                                              }];
+  };
+
+  auto unregisterSensorFunction = [=](int sensorId) { [reanimatedSensorContainer unregisterSensor:sensorId]; };
+  // end sensors
+
   PlatformDepMethodsHolder platformDepMethodsHolder = {
       requestRender,
       propUpdater,
       scrollToFunction,
       measuringFunction,
       getCurrentTime,
+      registerSensorFunction,
+      unregisterSensorFunction,
       setGestureStateFunction,
-  };
+      configurePropsFunction};
 
   module = std::make_shared<NativeReanimatedModule>(
       jsInvoker,
@@ -246,7 +318,15 @@ std::shared_ptr<NativeReanimatedModule> createReanimatedModule(
 
   [reanimatedModule.nodesManager registerEventHandler:^(NSString *eventName, id<RCTEvent> event) {
     std::string eventNameString([eventName UTF8String]);
-    std::string eventAsString = folly::toJson(convertIdToFollyDynamic([event arguments][2]));
+
+    std::string eventAsString;
+    try {
+      eventAsString = folly::toJson(convertIdToFollyDynamic([event arguments][2]));
+    } catch (std::exception &) {
+      // Events from other libraries may contain NaN or INF values which cannot be represented in JSON.
+      // See https://github.com/software-mansion/react-native-reanimated/issues/1776 for details.
+      return;
+    }
 
     eventAsString = "{ NativeMap:" + eventAsString + "}";
     jsi::Object global = module->runtime->global();

package/ios/sensor/ReanimatedSensor.h

@@ -0,0 +1,21 @@
+#import <CoreMotion/CoreMotion.h>
+#import "ReanimatedSensorType.h"
+
+@interface ReanimatedSensor : NSObject {
+  ReanimatedSensorType _sensorType;
+  double _interval;
+  double _lastTimestamp;
+  CMMotionManager *_motionManager;
+  void (^_setter)(double[]);
+}
+
+- (instancetype)init:(ReanimatedSensorType)sensorType interval:(int)interval setter:(void (^)(double[]))setter;
+- (bool)initialize;
+- (bool)initializeGyroscope;
+- (bool)initializeAccelerometer;
+- (bool)initializeGravity;
+- (bool)initializeMagnetometer;
+- (bool)initializeOrientation;
+- (void)cancel;
+
+@end

package/ios/sensor/ReanimatedSensor.m

@@ -0,0 +1,169 @@
+#import "ReanimatedSensor.h"
+
+@implementation ReanimatedSensor
+
+- (instancetype)init:(ReanimatedSensorType)sensorType interval:(int)interval setter:(void (^)(double[]))setter
+{
+  self = [super init];
+  _sensorType = sensorType;
+  _interval = interval / 1000; // in seconds
+  _setter = setter;
+  _motionManager = [[CMMotionManager alloc] init];
+  return self;
+}
+
+- (bool)initialize
+{
+  if (_sensorType == ACCELEROMETER) {
+    return [self initializeAccelerometer];
+  } else if (_sensorType == GYROSCOPE) {
+    return [self initializeGyroscope];
+  } else if (_sensorType == GRAVITY) {
+    return [self initializeGravity];
+  } else if (_sensorType == MAGNETIC_FIELD) {
+    return [self initializeMagnetometer];
+  } else if (_sensorType == ROTATION_VECTOR) {
+    return [self initializeOrientation];
+  }
+
+  return false;
+}
+
+- (bool)initializeGyroscope
+{
+  if (![_motionManager isGyroAvailable]) {
+    return false;
+  }
+  [_motionManager setGyroUpdateInterval:_interval];
+  [_motionManager startGyroUpdates];
+  [_motionManager
+      startGyroUpdatesToQueue:[NSOperationQueue mainQueue]
+                  withHandler:^(CMGyroData *sensorData, NSError *error) {
+                    double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                    if (currentTime - self->_lastTimestamp < self->_interval) {
+                      return;
+                    }
+                    double data[] = {sensorData.rotationRate.x, sensorData.rotationRate.y, sensorData.rotationRate.z};
+                    self->_setter(data);
+                    self->_lastTimestamp = currentTime;
+                  }];
+
+  return true;
+}
+
+- (bool)initializeAccelerometer
+{
+  if (![_motionManager isAccelerometerAvailable]) {
+    return false;
+  }
+  [_motionManager setAccelerometerUpdateInterval:_interval];
+  [_motionManager startAccelerometerUpdates];
+  [_motionManager
+      startAccelerometerUpdatesToQueue:[NSOperationQueue mainQueue]
+                           withHandler:^(CMAccelerometerData *sensorData, NSError *error) {
+                             double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                             if (currentTime - self->_lastTimestamp < self->_interval) {
+                               return;
+                             }
+                             double data[] = {
+                                 sensorData.acceleration.x, sensorData.acceleration.y, sensorData.acceleration.z};
+                             self->_setter(data);
+                             self->_lastTimestamp = currentTime;
+                           }];
+
+  return true;
+}
+
+- (bool)initializeGravity
+{
+  if (![_motionManager isDeviceMotionAvailable]) {
+    return false;
+  }
+  [_motionManager setDeviceMotionUpdateInterval:_interval];
+  [_motionManager setShowsDeviceMovementDisplay:YES];
+  [_motionManager
+      startDeviceMotionUpdatesToQueue:[NSOperationQueue mainQueue]
+                          withHandler:^(CMDeviceMotion *sensorData, NSError *error) {
+                            double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                            if (currentTime - self->_lastTimestamp < self->_interval) {
+                              return;
+                            }
+                            double data[] = {sensorData.gravity.x, sensorData.gravity.y, sensorData.gravity.z};
+                            self->_setter(data);
+                            self->_lastTimestamp = currentTime;
+                          }];
+
+  return true;
+}
+
+- (bool)initializeMagnetometer
+{
+  if (![_motionManager isMagnetometerAvailable]) {
+    return false;
+  }
+  [_motionManager setMagnetometerUpdateInterval:_interval];
+  [_motionManager startMagnetometerUpdates];
+  [_motionManager
+      startMagnetometerUpdatesToQueue:[NSOperationQueue mainQueue]
+                          withHandler:^(CMMagnetometerData *sensorData, NSError *error) {
+                            double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                            if (currentTime - self->_lastTimestamp < self->_interval) {
+                              return;
+                            }
+                            double data[] = {
+                                sensorData.magneticField.x, sensorData.magneticField.y, sensorData.magneticField.z};
+                            self->_setter(data);
+                            self->_lastTimestamp = currentTime;
+                          }];
+
+  return true;
+}
+
+- (bool)initializeOrientation
+{
+  if (![_motionManager isDeviceMotionAvailable]) {
+    return false;
+  }
+  [_motionManager setDeviceMotionUpdateInterval:_interval];
+
+  [_motionManager setShowsDeviceMovementDisplay:YES];
+  [_motionManager startDeviceMotionUpdatesUsingReferenceFrame:CMAttitudeReferenceFrameXTrueNorthZVertical
+                                                      toQueue:[NSOperationQueue mainQueue]
+                                                  withHandler:^(CMDeviceMotion *sensorData, NSError *error) {
+                                                    double currentTime = [[NSProcessInfo processInfo] systemUptime];
+                                                    if (currentTime - self->_lastTimestamp < self->_interval) {
+                                                      return;
+                                                    }
+                                                    CMAttitude *attitude = sensorData.attitude;
+                                                    double data[] = {
+                                                        attitude.quaternion.x,
+                                                        attitude.quaternion.y,
+                                                        attitude.quaternion.z,
+                                                        attitude.quaternion.w,
+                                                        attitude.pitch,
+                                                        attitude.roll,
+                                                        attitude.yaw,
+                                                    };
+                                                    self->_setter(data);
+                                                    self->_lastTimestamp = currentTime;
+                                                  }];
+
+  return true;
+}
+
+- (void)cancel
+{
+  if (_sensorType == ACCELEROMETER) {
+    [_motionManager stopAccelerometerUpdates];
+  } else if (_sensorType == GYROSCOPE) {
+    [_motionManager stopGyroUpdates];
+  } else if (_sensorType == GRAVITY) {
+    [_motionManager stopDeviceMotionUpdates];
+  } else if (_sensorType == MAGNETIC_FIELD) {
+    [_motionManager stopMagnetometerUpdates];
+  } else if (_sensorType == ROTATION_VECTOR) {
+    [_motionManager stopDeviceMotionUpdates];
+  }
+}
+
+@end

package/ios/sensor/ReanimatedSensorContainer.h

@@ -0,0 +1,13 @@
+#import <CoreMotion/CoreMotion.h>
+#import "ReanimatedSensorType.h"
+
+@interface ReanimatedSensorContainer : NSObject {
+  NSNumber *_nextSensorId;
+  NSMutableDictionary *_sensors;
+}
+
+- (instancetype)init;
+- (int)registerSensor:(ReanimatedSensorType)sensorType interval:(int)interval setter:(void (^)(double[]))setter;
+- (void)unregisterSensor:(int)sensorId;
+
+@end

package/ios/sensor/ReanimatedSensorContainer.m

@@ -0,0 +1,41 @@
+#import "ReanimatedSensorContainer.h"
+#import <CoreMotion/CoreMotion.h>
+#import <Foundation/Foundation.h>
+#import "ReanimatedSensor.h"
+
+static NSNumber *_nextSensorId = nil;
+
+@implementation ReanimatedSensorContainer
+
+- (instancetype)init
+{
+  self = [super init];
+  _sensors = [[NSMutableDictionary alloc] init];
+  _nextSensorId = @0;
+  return self;
+}
+
+- (int)registerSensor:(ReanimatedSensorType)sensorType interval:(int)interval setter:(void (^)(double[]))setter
+{
+  ReanimatedSensor *sensor = [[ReanimatedSensor alloc] init:sensorType interval:interval setter:setter];
+  if ([sensor initialize]) {
+    NSNumber *sensorId = [_nextSensorId copy];
+    _nextSensorId = [NSNumber numberWithInt:[_nextSensorId intValue] + 1];
+    [_sensors setObject:sensor forKey:sensorId];
+    return [sensorId intValue];
+  } else {
+    return -1;
+  }
+}
+
+- (void)unregisterSensor:(int)sensorId
+{
+  NSNumber *_sensorId = [NSNumber numberWithInt:sensorId];
+  if (_sensors[_sensorId] == nil) {
+    return;
+  }
+  [_sensors[_sensorId] cancel];
+  [_sensors removeObjectForKey:_sensorId];
+}
+
+@end

package/ios/sensor/ReanimatedSensorType.h

@@ -0,0 +1,7 @@
+typedef NS_ENUM(NSUInteger, ReanimatedSensorType) {
+  ACCELEROMETER = 1,
+  GYROSCOPE = 2,
+  GRAVITY = 3,
+  MAGNETIC_FIELD = 4,
+  ROTATION_VECTOR = 5,
+};