react-native-reanimated 3.0.0-rc.8 → 3.0.0

package/android/src/main/java/com/swmansion/reanimated/layoutReanimation/Snapshot.java

@@ -8,12 +8,14 @@ import com.facebook.react.uimanager.ViewManager;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.HashMap;
+import java.util.List;
 
 public class Snapshot {
   public static final String WIDTH = "width";
   public static final String HEIGHT = "height";
   public static final String ORIGIN_X = "originX";
   public static final String ORIGIN_Y = "originY";
+  public static final String TRANSFORM_MATRIX = "transformMatrix";
   public static final String GLOBAL_ORIGIN_X = "globalOriginX";
   public static final String GLOBAL_ORIGIN_Y = "globalOriginY";
 
@@ -21,6 +23,7 @@ public class Snapshot {
   public static final String CURRENT_HEIGHT = "currentHeight";
   public static final String CURRENT_ORIGIN_X = "currentOriginX";
   public static final String CURRENT_ORIGIN_Y = "currentOriginY";
+  public static final String CURRENT_TRANSFORM_MATRIX = "currentTransformMatrix";
   public static final String CURRENT_GLOBAL_ORIGIN_X = "currentGlobalOriginX";
   public static final String CURRENT_GLOBAL_ORIGIN_Y = "currentGlobalOriginY";
 
@@ -28,6 +31,7 @@ public class Snapshot {
   public static final String TARGET_HEIGHT = "targetHeight";
   public static final String TARGET_ORIGIN_X = "targetOriginX";
   public static final String TARGET_ORIGIN_Y = "targetOriginY";
+  public static final String TARGET_TRANSFORM_MATRIX = "targetTransformMatrix";
   public static final String TARGET_GLOBAL_ORIGIN_X = "targetGlobalOriginX";
   public static final String TARGET_GLOBAL_ORIGIN_Y = "targetGlobalOriginY";
 
@@ -41,9 +45,30 @@ public class Snapshot {
   public int originY;
   public int globalOriginX;
   public int globalOriginY;
+  public List<Float> transformMatrix =
+      new ArrayList<>(Arrays.asList(1f, 0f, 0f, 0f, 1f, 0f, 0f, 0f, 1f));
+  public int originXByParent;
+  public int originYByParent;
+  private float[] identityMatrix = {1, 0, 0, 0, 1, 0, 0, 0, 1};
 
-  public static ArrayList<String> targetKeysToTransform;
-  public static ArrayList<String> currentKeysToTransform;
+  public static ArrayList<String> targetKeysToTransform =
+      new ArrayList<>(
+          Arrays.asList(
+              Snapshot.TARGET_WIDTH,
+              Snapshot.TARGET_HEIGHT,
+              Snapshot.TARGET_ORIGIN_X,
+              Snapshot.TARGET_ORIGIN_Y,
+              Snapshot.TARGET_GLOBAL_ORIGIN_X,
+              Snapshot.TARGET_GLOBAL_ORIGIN_Y));
+  public static ArrayList<String> currentKeysToTransform =
+      new ArrayList<>(
+          Arrays.asList(
+              Snapshot.CURRENT_WIDTH,
+              Snapshot.CURRENT_HEIGHT,
+              Snapshot.CURRENT_ORIGIN_X,
+              Snapshot.CURRENT_ORIGIN_Y,
+              Snapshot.CURRENT_GLOBAL_ORIGIN_X,
+              Snapshot.CURRENT_GLOBAL_ORIGIN_Y));
 
   Snapshot(View view, NativeViewHierarchyManager viewHierarchyManager) {
     parent = (ViewGroup) view.getParent();
@@ -62,25 +87,34 @@ public class Snapshot {
     view.getLocationOnScreen(location);
     globalOriginX = location[0];
     globalOriginY = location[1];
+  }
+
+  public Snapshot(View view) {
+    int[] location = new int[2];
+    view.getLocationOnScreen(location);
+    originX = location[0];
+    originY = location[1];
+    width = view.getWidth();
+    height = view.getHeight();
+
+    View transformedView = findTransformedView(view);
+    if (transformedView != null) {
+      float[] transformMatrixArray = new float[9];
+      transformedView.getMatrix().getValues(transformMatrixArray);
+      transformMatrix = new ArrayList<>();
+      for (int i = 0; i < 9; i++) {
+        transformMatrix.add(transformMatrixArray[i]);
+      }
+      transformMatrix.set(0, transformedView.getScaleX());
+      transformMatrix.set(4, transformedView.getScaleY());
+      transformMatrix.set(2, transformedView.getTranslationX());
+      transformMatrix.set(5, transformedView.getTranslationY());
 
-    targetKeysToTransform =
-        new ArrayList<>(
-            Arrays.asList(
-                Snapshot.TARGET_WIDTH,
-                Snapshot.TARGET_HEIGHT,
-                Snapshot.TARGET_ORIGIN_X,
-                Snapshot.TARGET_ORIGIN_Y,
-                Snapshot.TARGET_GLOBAL_ORIGIN_X,
-                Snapshot.TARGET_GLOBAL_ORIGIN_Y));
-    currentKeysToTransform =
-        new ArrayList<>(
-            Arrays.asList(
-                Snapshot.CURRENT_WIDTH,
-                Snapshot.CURRENT_HEIGHT,
-                Snapshot.CURRENT_ORIGIN_X,
-                Snapshot.CURRENT_ORIGIN_Y,
-                Snapshot.CURRENT_GLOBAL_ORIGIN_X,
-                Snapshot.CURRENT_GLOBAL_ORIGIN_Y));
+      originX -= (width - width * transformedView.getScaleX()) / 2;
+      originY -= (height - height * transformedView.getScaleY()) / 2;
+    }
+    originXByParent = view.getLeft();
+    originYByParent = view.getTop();
   }
 
   private void addTargetConfig(HashMap<String, Object> data) {
@@ -90,6 +124,7 @@ public class Snapshot {
     data.put(Snapshot.TARGET_GLOBAL_ORIGIN_X, globalOriginX);
     data.put(Snapshot.TARGET_HEIGHT, height);
     data.put(Snapshot.TARGET_WIDTH, width);
+    data.put(Snapshot.TARGET_TRANSFORM_MATRIX, transformMatrix);
   }
 
   private void addCurrentConfig(HashMap<String, Object> data) {
@@ -99,6 +134,17 @@ public class Snapshot {
     data.put(Snapshot.CURRENT_GLOBAL_ORIGIN_X, globalOriginX);
     data.put(Snapshot.CURRENT_HEIGHT, height);
     data.put(Snapshot.CURRENT_WIDTH, width);
+    data.put(Snapshot.CURRENT_TRANSFORM_MATRIX, transformMatrix);
+  }
+
+  private void addBasicConfig(HashMap<String, Object> data) {
+    data.put(Snapshot.ORIGIN_Y, originY);
+    data.put(Snapshot.ORIGIN_X, originX);
+    data.put(Snapshot.GLOBAL_ORIGIN_Y, globalOriginY);
+    data.put(Snapshot.GLOBAL_ORIGIN_X, globalOriginX);
+    data.put(Snapshot.HEIGHT, height);
+    data.put(Snapshot.WIDTH, width);
+    data.put(Snapshot.TRANSFORM_MATRIX, transformMatrix);
   }
 
   public HashMap<String, Object> toTargetMap() {
@@ -113,9 +159,33 @@ public class Snapshot {
     return data;
   }
 
-  public HashMap<String, Object> toLayoutMap(Snapshot target) {
-    HashMap<String, Object> data = target.toTargetMap();
-    addCurrentConfig(data);
+  public HashMap<String, Object> toBasicMap() {
+    HashMap<String, Object> data = new HashMap<>();
+    addBasicConfig(data);
     return data;
   }
+
+  private View findTransformedView(View view) {
+    View transformedView = null;
+    boolean isTransformed = false;
+    do {
+      if (transformedView == null) {
+        transformedView = view;
+      } else {
+        if (!(transformedView.getParent() instanceof View)) {
+          break;
+        }
+        transformedView = (View) transformedView.getParent();
+      }
+      if (transformedView == null) {
+        break;
+      }
+      float[] transformArray = new float[9];
+      transformedView.getMatrix().getValues(transformArray);
+      isTransformed = !Arrays.equals(transformArray, identityMatrix);
+    } while (!isTransformed
+        && transformedView != null
+        && !transformedView.getClass().getSimpleName().equals("Screen"));
+    return (isTransformed && transformedView != null) ? transformedView : null;
+  }
 }

package/android/src/main/java/com/swmansion/reanimated/nativeProxy/AnimationFrameCallback.java

@@ -0,0 +1,19 @@
+package com.swmansion.reanimated.nativeProxy;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.swmansion.reanimated.NodesManager;
+
+@DoNotStrip
+public class AnimationFrameCallback implements NodesManager.OnAnimationFrame {
+
+  @DoNotStrip private final HybridData mHybridData;
+
+  @DoNotStrip
+  private AnimationFrameCallback(HybridData hybridData) {
+    mHybridData = hybridData;
+  }
+
+  @Override
+  public native void onAnimationFrame(double timestampMs);
+}

package/android/src/main/java/com/swmansion/reanimated/nativeProxy/EventHandler.java

@@ -0,0 +1,35 @@
+package com.swmansion.reanimated.nativeProxy;
+
+import androidx.annotation.Nullable;
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.uimanager.UIManagerModule;
+import com.facebook.react.uimanager.events.RCTEventEmitter;
+
+@DoNotStrip
+public class EventHandler implements RCTEventEmitter {
+
+  @DoNotStrip private final HybridData mHybridData;
+  UIManagerModule.CustomEventNamesResolver mCustomEventNamesResolver;
+
+  @DoNotStrip
+  private EventHandler(HybridData hybridData) {
+    mHybridData = hybridData;
+  }
+
+  @Override
+  public void receiveEvent(int targetTag, String eventName, @Nullable WritableMap event) {
+    String resolvedEventName = mCustomEventNamesResolver.resolveCustomEventName(eventName);
+    receiveEvent(targetTag + resolvedEventName, event);
+  }
+
+  public native void receiveEvent(String eventKey, @Nullable WritableMap event);
+
+  @Override
+  public void receiveTouches(
+      String eventName, WritableArray touches, WritableArray changedIndices) {
+    // not interested in processing touch events this way, we process raw events only
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/nativeProxy/KeyboardEventDataUpdater.java

@@ -0,0 +1,16 @@
+package com.swmansion.reanimated.nativeProxy;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public class KeyboardEventDataUpdater {
+  @DoNotStrip private final HybridData mHybridData;
+
+  @DoNotStrip
+  private KeyboardEventDataUpdater(HybridData hybridData) {
+    mHybridData = hybridData;
+  }
+
+  public native void keyboardEventDataUpdater(int keyboardState, int height);
+}

package/android/src/main/java/com/swmansion/reanimated/nativeProxy/NativeProxyCommon.java

@@ -0,0 +1,206 @@
+package com.swmansion.reanimated.nativeProxy;
+
+import android.os.SystemClock;
+import android.util.Log;
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+import com.facebook.react.ReactApplication;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.ReadableNativeArray;
+import com.facebook.react.devsupport.interfaces.DevSupportManager;
+import com.facebook.soloader.SoLoader;
+import com.swmansion.common.GestureHandlerStateManager;
+import com.swmansion.reanimated.NativeProxy;
+import com.swmansion.reanimated.NodesManager;
+import com.swmansion.reanimated.ReanimatedModule;
+import com.swmansion.reanimated.Scheduler;
+import com.swmansion.reanimated.Utils;
+import com.swmansion.reanimated.keyboardObserver.ReanimatedKeyboardEventListener;
+import com.swmansion.reanimated.layoutReanimation.AnimationsManager;
+import com.swmansion.reanimated.layoutReanimation.LayoutAnimations;
+import com.swmansion.reanimated.sensor.ReanimatedSensorContainer;
+import com.swmansion.reanimated.sensor.ReanimatedSensorType;
+import java.lang.ref.WeakReference;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+
+public abstract class NativeProxyCommon {
+  static {
+    SoLoader.loadLibrary("reanimated");
+  }
+
+  protected NodesManager mNodesManager;
+  protected final WeakReference<ReactApplicationContext> mContext;
+  protected Scheduler mScheduler;
+  private ReanimatedSensorContainer reanimatedSensorContainer;
+  private final GestureHandlerStateManager gestureHandlerStateManager;
+  private ReanimatedKeyboardEventListener reanimatedKeyboardEventListener;
+  private Long firstUptime = SystemClock.uptimeMillis();
+  private boolean slowAnimationsEnabled = false;
+
+  protected NativeProxyCommon(ReactApplicationContext context) {
+    mScheduler = new Scheduler(context);
+    mContext = new WeakReference<>(context);
+    reanimatedSensorContainer = new ReanimatedSensorContainer(mContext);
+    reanimatedKeyboardEventListener = new ReanimatedKeyboardEventListener(mContext);
+    addDevMenuOption();
+
+    GestureHandlerStateManager tempHandlerStateManager;
+    try {
+      Class<NativeModule> gestureHandlerModuleClass =
+          (Class<NativeModule>)
+              Class.forName("com.swmansion.gesturehandler.react.RNGestureHandlerModule");
+      tempHandlerStateManager =
+          (GestureHandlerStateManager) context.getNativeModule(gestureHandlerModuleClass);
+    } catch (ClassCastException | ClassNotFoundException e) {
+      tempHandlerStateManager = null;
+    }
+    gestureHandlerStateManager = tempHandlerStateManager;
+  }
+
+  public Scheduler getScheduler() {
+    return mScheduler;
+  }
+
+  private void toggleSlowAnimations() {
+    slowAnimationsEnabled = !slowAnimationsEnabled;
+    if (slowAnimationsEnabled) {
+      firstUptime = SystemClock.uptimeMillis();
+    }
+  }
+
+  private void addDevMenuOption() {
+    // In Expo, `ApplicationContext` is not an instance of `ReactApplication`
+    if (mContext.get().getApplicationContext() instanceof ReactApplication) {
+      final DevSupportManager devSupportManager =
+          ((ReactApplication) mContext.get().getApplicationContext())
+              .getReactNativeHost()
+              .getReactInstanceManager()
+              .getDevSupportManager();
+
+      devSupportManager.addCustomDevOption(
+          "Toggle slow animations (Reanimated)", this::toggleSlowAnimations);
+    }
+  }
+
+  @DoNotStrip
+  private void requestRender(AnimationFrameCallback callback) {
+    mNodesManager.postOnAnimation(callback);
+  }
+
+  @DoNotStrip
+  private void updateProps(int viewTag, Map<String, Object> props) {
+    mNodesManager.updateProps(viewTag, props);
+  }
+
+  @DoNotStrip
+  private void synchronouslyUpdateUIProps(int viewTag, ReadableMap uiProps) {
+    mNodesManager.synchronouslyUpdateUIProps(viewTag, uiProps);
+  }
+
+  @DoNotStrip
+  private String obtainProp(int viewTag, String propName) {
+    return mNodesManager.obtainProp(viewTag, propName);
+  }
+
+  @DoNotStrip
+  private void scrollTo(int viewTag, double x, double y, boolean animated) {
+    mNodesManager.scrollTo(viewTag, x, y, animated);
+  }
+
+  @DoNotStrip
+  private void setGestureState(int handlerTag, int newState) {
+    if (gestureHandlerStateManager != null) {
+      gestureHandlerStateManager.setGestureHandlerState(handlerTag, newState);
+    }
+  }
+
+  @DoNotStrip
+  private long getCurrentTime() {
+    if (slowAnimationsEnabled) {
+      final long ANIMATIONS_DRAG_FACTOR = 10;
+      return this.firstUptime
+          + (SystemClock.uptimeMillis() - this.firstUptime) / ANIMATIONS_DRAG_FACTOR;
+    } else {
+      return SystemClock.uptimeMillis();
+    }
+  }
+
+  @DoNotStrip
+  private float[] measure(int viewTag) {
+    return mNodesManager.measure(viewTag);
+  }
+
+  @DoNotStrip
+  private void configureProps(ReadableNativeArray uiProps, ReadableNativeArray nativeProps) {
+    Set<String> uiPropsSet = convertProps(uiProps);
+    Set<String> nativePropsSet = convertProps(nativeProps);
+    mNodesManager.configureProps(uiPropsSet, nativePropsSet);
+  }
+
+  private Set<String> convertProps(ReadableNativeArray props) {
+    Set<String> propsSet = new HashSet<>();
+    ArrayList<Object> propsList = props.toArrayList();
+    for (int i = 0; i < propsList.size(); i++) {
+      propsSet.add((String) propsList.get(i));
+    }
+    return propsSet;
+  }
+
+  @DoNotStrip
+  private void registerEventHandler(EventHandler handler) {
+    handler.mCustomEventNamesResolver = mNodesManager.getEventNameResolver();
+    mNodesManager.registerEventHandler(handler);
+  }
+
+  @DoNotStrip
+  private int registerSensor(int sensorType, int interval, SensorSetter setter) {
+    return reanimatedSensorContainer.registerSensor(
+        ReanimatedSensorType.getInstanceById(sensorType), interval, setter);
+  }
+
+  @DoNotStrip
+  private void unregisterSensor(int sensorId) {
+    reanimatedSensorContainer.unregisterSensor(sensorId);
+  }
+
+  @DoNotStrip
+  private int subscribeForKeyboardEvents(
+      KeyboardEventDataUpdater keyboardEventDataUpdater, boolean isStatusBarTranslucent) {
+    return reanimatedKeyboardEventListener.subscribeForKeyboardEvents(
+        keyboardEventDataUpdater, isStatusBarTranslucent);
+  }
+
+  @DoNotStrip
+  private void unsubscribeFromKeyboardEvents(int listenerId) {
+    reanimatedKeyboardEventListener.unsubscribeFromKeyboardEvents(listenerId);
+  }
+
+  protected abstract HybridData getHybridData();
+
+  public void onCatalystInstanceDestroy() {
+    mScheduler.deactivate();
+    getHybridData().resetNative();
+  }
+
+  public void prepareLayoutAnimations(LayoutAnimations layoutAnimations) {
+    if (Utils.isChromeDebugger) {
+      Log.w("[REANIMATED]", "You can not use LayoutAnimation with enabled Chrome Debugger");
+      return;
+    }
+    mNodesManager = mContext.get().getNativeModule(ReanimatedModule.class).getNodesManager();
+
+    AnimationsManager animationsManager =
+        mContext
+            .get()
+            .getNativeModule(ReanimatedModule.class)
+            .getNodesManager()
+            .getAnimationsManager();
+
+    animationsManager.setNativeMethods(NativeProxy.createNativeMethodsHolder(layoutAnimations));
+  }
+}

package/android/src/main/java/com/swmansion/reanimated/nativeProxy/SensorSetter.java

@@ -0,0 +1,17 @@
+package com.swmansion.reanimated.nativeProxy;
+
+import com.facebook.jni.HybridData;
+import com.facebook.proguard.annotations.DoNotStrip;
+
+@DoNotStrip
+public class SensorSetter {
+
+  @DoNotStrip private final HybridData mHybridData;
+
+  @DoNotStrip
+  private SensorSetter(HybridData hybridData) {
+    mHybridData = hybridData;
+  }
+
+  public native void sensorSetter(float[] value, int orientationDegrees);
+}

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensor.java

@@ -1,9 +1,13 @@
 package com.swmansion.reanimated.sensor;
 
+import static android.content.Context.WINDOW_SERVICE;
+
 import android.hardware.Sensor;
 import android.hardware.SensorManager;
+import android.view.Display;
+import android.view.WindowManager;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.swmansion.reanimated.NativeProxy;
+import com.swmansion.reanimated.nativeProxy.SensorSetter;
 import java.lang.ref.WeakReference;
 
 public class ReanimatedSensor {
@@ -18,8 +22,10 @@ public class ReanimatedSensor {
       WeakReference<ReactApplicationContext> reactContext,
       ReanimatedSensorType sensorType,
       int interval,
-      NativeProxy.SensorSetter setter) {
-    listener = new ReanimatedSensorListener(setter, interval);
+      SensorSetter setter) {
+    WindowManager wm = (WindowManager) reactContext.get().getSystemService(WINDOW_SERVICE);
+    Display display = wm.getDefaultDisplay();
+    listener = new ReanimatedSensorListener(setter, interval, display);
     sensorManager =
         (SensorManager) reactContext.get().getSystemService(reactContext.get().SENSOR_SERVICE);
     this.sensorType = sensorType;

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensorContainer.java

@@ -2,7 +2,7 @@ package com.swmansion.reanimated.sensor;
 
 import android.util.Log;
 import com.facebook.react.bridge.ReactApplicationContext;
-import com.swmansion.reanimated.NativeProxy;
+import com.swmansion.reanimated.nativeProxy.SensorSetter;
 import java.lang.ref.WeakReference;
 import java.util.HashMap;
 
@@ -16,14 +16,13 @@ public class ReanimatedSensorContainer {
     this.reactContext = reactContext;
   }
 
-  public int registerSensor(
-      ReanimatedSensorType sensorType, int interval, NativeProxy.SensorSetter setter) {
+  public int registerSensor(ReanimatedSensorType sensorType, int interval, SensorSetter setter) {
     ReanimatedSensor sensor = new ReanimatedSensor(reactContext, sensorType, interval, setter);
     int sensorId = -1;
     if (sensor.initialize()) {
       sensorId = nextSensorId;
       nextSensorId++;
-      sensors.put(sensorId, new ReanimatedSensor(reactContext, sensorType, interval, setter));
+      sensors.put(sensorId, sensor);
     }
     return sensorId;
   }

package/android/src/main/java/com/swmansion/reanimated/sensor/ReanimatedSensorListener.java

@@ -4,11 +4,13 @@ import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
-import com.swmansion.reanimated.NativeProxy;
+import android.view.Display;
+import android.view.Surface;
+import com.swmansion.reanimated.nativeProxy.SensorSetter;
 
 public class ReanimatedSensorListener implements SensorEventListener {
 
-  private NativeProxy.SensorSetter setter;
+  private SensorSetter setter;
   private double lastRead = (double) System.currentTimeMillis();
   private final double interval;
 
@@ -16,9 +18,12 @@ public class ReanimatedSensorListener implements SensorEventListener {
   private float[] orientation = new float[3];
   private float[] quaternion = new float[4];
 
-  ReanimatedSensorListener(NativeProxy.SensorSetter setter, double interval) {
+  private final Display display;
+
+  ReanimatedSensorListener(SensorSetter setter, double interval, Display display) {
     this.setter = setter;
     this.interval = interval;
+    this.display = display;
   }
 
   @Override
@@ -29,6 +34,23 @@ public class ReanimatedSensorListener implements SensorEventListener {
     }
     int sensorType = event.sensor.getType();
     lastRead = current;
+
+    int orientationDegrees;
+    switch (display.getRotation()) {
+      case Surface.ROTATION_90:
+        orientationDegrees = 90;
+        break;
+      case Surface.ROTATION_180:
+        orientationDegrees = 180;
+        break;
+      case Surface.ROTATION_270:
+        orientationDegrees = 270;
+        break;
+      default:
+        orientationDegrees = 0;
+        break;
+    }
+
     if (sensorType == Sensor.TYPE_ROTATION_VECTOR) {
       SensorManager.getQuaternionFromVector(quaternion, event.values);
       SensorManager.getRotationMatrixFromVector(rotation, event.values);
@@ -39,13 +61,15 @@ public class ReanimatedSensorListener implements SensorEventListener {
             quaternion[2], // qy
             quaternion[3], // qz
             quaternion[0], // qw
-            orientation[0], // yaw
-            orientation[1], // pitch
+            // make Android consistent with iOS, which is better documented here:
+            // https://developer.apple.com/documentation/coremotion/getting_processed_device-motion_data/understanding_reference_frames_and_device_attitude
+            -orientation[0], // yaw
+            -orientation[1], // pitch
             orientation[2] // roll
           };
-      setter.sensorSetter(data);
+      setter.sensorSetter(data, orientationDegrees);
     } else {
-      setter.sensorSetter(event.values);
+      setter.sensorSetter(event.values, orientationDegrees);
     }
   }