react-native-orientation-director 2.6.5 → 3.0.0

package/README.md

@@ -6,7 +6,10 @@
 
 A React Native library that allows you to listen to orientation changes, lock interface orientation
 to a selected one and get current orientation.
-Written in Kotlin, Swift and Typescript. It supports both the Old and New React Native architecture.
+Written in Kotlin, Swift and Typescript.
+
+Kindly note that this library only supports the new architecture since v3.0.0, if you are looking for a version that
+supports the old architecture, please check older versions.
 
 This library takes inspiration from and builds upon the following amazing alternatives:
 
@@ -112,40 +115,20 @@ Nothing else is required for Android.
 
 #### iOS
 
-To properly handle interface orientation changes in iOS, you need to update your AppDelegate file. Since React Native
-0.77, the AppDelegate has been migrated to Swift, so see the instructions below for both Swift and Objective-C.
+To properly handle interface orientation changes in iOS, you need to update your AppDelegate file. Follow the instructions
+below to set it up:
 
-##### Objective-C
+In your AppDelegate.swift file, implement the supportedInterfaceOrientationsFor method as follows:
 
-In your AppDelegate.mm file, import "OrientationDirector.h" and implement supportedInterfaceOrientationsForWindow method as follows:
+```swift
 
-```objc
-#import <OrientationDirector.h>
+import OrientationDirector
 
-- (UIInterfaceOrientationMask)application:(UIApplication *)application supportedInterfaceOrientationsForWindow:(UIWindow *)window
-{
-  return [OrientationDirector getSupportedInterfaceOrientationsForWindow];
+func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
+  return SharedOrientationDirectorImpl.shared.supportedInterfaceOrientations
 }
-```
-
-##### Swift
-
-You need to create a [bridging header](https://developer.apple.com/documentation/swift/importing-objective-c-into-swift#Import-Code-Within-an-App-Target)
-to import the library, as shown below:
 
 ```
-#import "OrientationDirector.h"
-```
-
-Then, in your AppDelegate.swift file, implement the supportedInterfaceOrientationsFor method as follows:
-
-```swift
-override func application(_ application: UIApplication, supportedInterfaceOrientationsFor window: UIWindow?) -> UIInterfaceOrientationMask {
-  return OrientationDirector.getSupportedInterfaceOrientationsForWindow()
-}
-```
-
-Note: if you are targeting react-native > 79.x, you can omit the `override` keyword.
 
 If you need help, you can check the example project.
 
@@ -212,11 +195,6 @@ differently than on iOS, mainly in the following ways:
 
 This behavior allows us to follow Google's best practices related to the Sensors Framework. More [here](https://developer.android.com/develop/sensors-and-location/sensors/sensors_overview#sensors-practices).
 
-## Roadmap
-
-- [ ] Add JS side tests
-- [ ] Add iOS side tests
-
 ## Contributing
 
 See the [contributing guide](CONTRIBUTING.md) to learn how to contribute to the repository and the development workflow.

package/android/build.gradle

@@ -1,6 +1,17 @@
 buildscript {
-  ext.getExtOrDefault = {name ->
-    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['OrientationDirector_' + name]
+  ext.OrientationDirector = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36,
+    targetSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return OrientationDirector[prop]
   }
 
   repositories {
@@ -16,51 +27,19 @@ buildscript {
 }
 
 
-def isNewArchitectureEnabled() {
-  return rootProject.hasProperty("newArchEnabled") && rootProject.getProperty("newArchEnabled") == "true"
-}
-
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
 
-if (isNewArchitectureEnabled()) {
-  apply plugin: "com.facebook.react"
-}
-
-def getExtOrIntegerDefault(name) {
-  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["OrientationDirector_" + name]).toInteger()
-}
-
-def getDefault(name) {
-  return project.properties["OrientationDirector_" + name]
-}
-
-def supportsNamespace() {
-  def parsed = com.android.Version.ANDROID_GRADLE_PLUGIN_VERSION.tokenize('.')
-  def major = parsed[0].toInteger()
-  def minor = parsed[1].toInteger()
-
-  // Namespace support was added in 7.3.0
-  return (major == 7 && minor >= 3) || major >= 8
-}
+apply plugin: "com.facebook.react"
 
 android {
-  if (supportsNamespace()) {
-    namespace "com.orientationdirector"
+  namespace "com.orientationdirector"
 
-    sourceSets {
-      main {
-        manifest.srcFile "src/main/AndroidManifestNew.xml"
-      }
-    }
-  }
-
-  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
 
   defaultConfig {
-    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
-    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
-    buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
+    minSdkVersion getExtOrDefault("minSdkVersion")
+    targetSdkVersion getExtOrDefault("targetSdkVersion")
   }
 
   buildFeatures {
@@ -73,7 +52,7 @@ android {
     }
   }
 
-  lintOptions {
+  lint {
     disable "GradleCompatible"
   }
 
@@ -81,47 +60,8 @@ android {
     sourceCompatibility JavaVersion.VERSION_1_8
     targetCompatibility JavaVersion.VERSION_1_8
   }
-
-  sourceSets {
-    main {
-      if (isNewArchitectureEnabled()) {
-        java.srcDirs += [
-          "src/newarch",
-          // This is needed to build Kotlin project with NewArch enabled
-          "${project.buildDir}/generated/source/codegen/java"
-        ]
-      } else {
-        java.srcDirs += ["src/oldarch"]
-      }
-    }
-  }
-}
-
-repositories {
-  mavenCentral()
-  google()
 }
 
-def kotlin_version = getExtOrDefault("kotlinVersion")
-def junit_version = getDefault("junitVersion")
-def android_x_core_version = getDefault("androidXCoreVersion")
-def robolectric_version = getDefault("robolectricVersion")
-def mockito_core_version = getDefault("mockitoCoreVersion")
-
 dependencies {
   implementation "com.facebook.react:react-android"
-  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
-
-  testImplementation "junit:junit:$junit_version"
-  testImplementation "androidx.test:core:$android_x_core_version"
-  testImplementation "org.robolectric:robolectric:$robolectric_version"
-  testImplementation "org.mockito:mockito-core:$mockito_core_version"
-}
-
-if (isNewArchitectureEnabled()) {
-  react {
-    jsRootDir = file("../src/")
-    libraryName = "OrientationDirector"
-    codegenJavaPackageName = "com.orientationdirector"
-  }
 }

package/android/src/main/AndroidManifest.xml

@@ -1,3 +1,2 @@
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.orientationdirector">
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
 </manifest>

package/android/src/{newarch → main/java/com/orientationdirector}/OrientationDirectorModule.kt

@@ -2,36 +2,33 @@ package com.orientationdirector
 
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.WritableMap
+import com.orientationdirector.implementation.EventManagerDelegate
 import com.orientationdirector.implementation.OrientationDirectorModuleImpl
 
-class OrientationDirectorModule internal constructor(context: ReactApplicationContext) :
-  NativeOrientationDirectorSpec(context) {
+class OrientationDirectorModule(reactContext: ReactApplicationContext) :
+  NativeOrientationDirectorSpec(reactContext), EventManagerDelegate {
 
-  private var implementation = OrientationDirectorModuleImpl(context)
-
-  override fun getName() = OrientationDirectorModuleImpl.NAME
+  override fun getName() = NAME
 
+  private var implementation = OrientationDirectorModuleImpl(reactContext, this)
 
   override fun getInterfaceOrientation(promise: Promise) {
     promise.resolve(implementation.getInterfaceOrientation().ordinal)
   }
 
-
   override fun getDeviceOrientation(promise: Promise) {
     promise.resolve(implementation.getDeviceOrientation().ordinal)
   }
 
-
   override fun lockTo(orientation: Double) {
     implementation.lockTo(orientation.toInt())
   }
 
-
   override fun unlock() {
     implementation.unlock()
   }
 
-
   override fun resetSupportedInterfaceOrientations() {
     implementation.resetSupportedInterfaceOrientations()
   }
@@ -52,8 +49,20 @@ class OrientationDirectorModule internal constructor(context: ReactApplicationCo
     return implementation.disableOrientationSensors()
   }
 
-  override fun addListener(eventName: String) {}
+  override fun sendOnDeviceOrientationChanged(params: WritableMap) {
+    emitOnDeviceOrientationChanged(params)
+  }
 
-  override fun removeListeners(count: Double) {}
+  override fun sendOnInterfaceOrientationChanged(params: WritableMap) {
+    emitOnInterfaceOrientationChanged(params)
+  }
+
+  override fun sendOnLockChanged(params: WritableMap) {
+    emitOnLockChanged(params)
+  }
+
+  companion object {
+    const val NAME = OrientationDirectorModuleImpl.NAME
+  }
 
 }

package/android/src/main/java/com/orientationdirector/OrientationDirectorPackage.kt

@@ -1,35 +1,30 @@
 package com.orientationdirector
 
 import com.facebook.react.BaseReactPackage
-import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.NativeModule
-import com.facebook.react.module.model.ReactModuleInfoProvider
+import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.module.model.ReactModuleInfo
-import com.orientationdirector.implementation.OrientationDirectorModuleImpl
-import java.util.HashMap
+import com.facebook.react.module.model.ReactModuleInfoProvider
 
 class OrientationDirectorPackage : BaseReactPackage() {
-  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
-    return if (name == OrientationDirectorModuleImpl.NAME) {
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    if (name == OrientationDirectorModule.NAME) {
       OrientationDirectorModule(reactContext)
     } else {
       null
     }
-  }
 
-  override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
-    return ReactModuleInfoProvider {
-      val moduleInfos: MutableMap<String, ReactModuleInfo> = HashMap()
-      val isTurboModule: Boolean = BuildConfig.IS_NEW_ARCHITECTURE_ENABLED
-      moduleInfos[OrientationDirectorModuleImpl.NAME] = ReactModuleInfo(
-        OrientationDirectorModuleImpl.NAME,
-        OrientationDirectorModuleImpl.NAME,
-        false,  // canOverrideExistingModule
-        false,  // needsEagerInit
-        false,  // isCxxModule
-        isTurboModule // isTurboModule
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      OrientationDirectorModule.NAME to ReactModuleInfo(
+        name = OrientationDirectorModule.NAME,
+        className = OrientationDirectorModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
       )
-      moduleInfos
-    }
+    )
   }
 }

package/android/src/main/java/com/orientationdirector/implementation/EventManager.kt

@@ -5,39 +5,26 @@ import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 
-enum class Event {
-  DeviceOrientationDidChange,
-  InterfaceOrientationDidChange,
-  LockDidChange,
-}
-
-class EventManager(private val context: ReactApplicationContext) {
-
+class EventManager(private val delegate: EventManagerDelegate) {
   fun sendDeviceOrientationDidChange(orientationValue: Int) {
     val params = Arguments.createMap().apply {
       putInt("orientation", orientationValue)
     }
-    sendEvent(Event.DeviceOrientationDidChange, params)
+    delegate.sendOnDeviceOrientationChanged(params)
   }
 
   fun sendInterfaceOrientationDidChange(orientationValue: Int) {
     val params = Arguments.createMap().apply {
       putInt("orientation", orientationValue)
     }
-    sendEvent(Event.InterfaceOrientationDidChange, params)
+    delegate.sendOnInterfaceOrientationChanged(params)
   }
 
   fun sendLockDidChange(value: Boolean) {
     val params = Arguments.createMap().apply {
       putBoolean("locked", value)
     }
-    sendEvent(Event.LockDidChange, params)
-  }
-
-  private fun sendEvent(eventName: Event, params: WritableMap?) {
-    context
-      .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
-      .emit(eventName.name, params)
+    delegate.sendOnLockChanged(params)
   }
 
   companion object {

package/android/src/main/java/com/orientationdirector/implementation/EventManagerDelegate.kt

@@ -0,0 +1,9 @@
+   package com.orientationdirector.implementation
+
+   import com.facebook.react.bridge.WritableMap
+
+   interface EventManagerDelegate {
+       fun sendOnDeviceOrientationChanged(params: WritableMap)
+       fun sendOnInterfaceOrientationChanged(params: WritableMap)
+       fun sendOnLockChanged(params: WritableMap)
+   }

package/android/src/main/java/com/orientationdirector/implementation/OrientationDirectorModuleImpl.kt

@@ -5,9 +5,9 @@ import android.os.Handler
 import android.os.Looper
 import com.facebook.react.bridge.ReactApplicationContext
 
-class OrientationDirectorModuleImpl internal constructor(private val context: ReactApplicationContext) {
+class OrientationDirectorModuleImpl internal constructor(private val context: ReactApplicationContext, eventManagerDelegate: EventManagerDelegate) {
   private var mUtils = Utils(context)
-  private var mEventManager = EventManager(context)
+  private var mEventManager = EventManager(eventManagerDelegate)
   private var mOrientationSensorsEventListener = OrientationSensorsEventListener(context)
   private var mAutoRotationObserver = AutoRotationObserver(
     context, Handler(
@@ -26,8 +26,8 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
   private var didComputeInitialDeviceOrientation = false;
 
   init {
-    mOrientationSensorsEventListener.setOnOrientationAnglesChangedCallback { orientation ->
-      onOrientationAnglesChanged(orientation)
+    mOrientationSensorsEventListener.setOnDeviceOrientationChangedCallback { orientation ->
+      onDeviceOrientationChanged(orientation)
     }
 
     mAutoRotationObserver.enable()
@@ -151,15 +151,10 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
     ).contains(activity.requestedOrientation)
   }
 
-  private fun onOrientationAnglesChanged(orientationAngles: FloatArray) {
-    val deviceOrientation = mUtils.convertToDeviceOrientationFrom(orientationAngles)
-    if (deviceOrientation == Orientation.UNKNOWN) {
-      return
-    }
+  private fun onDeviceOrientationChanged(deviceOrientation: Orientation) {
+    if (deviceOrientation == Orientation.UNKNOWN) return
 
-    if (lastDeviceOrientation == deviceOrientation) {
-      return
-    }
+    if (lastDeviceOrientation == deviceOrientation) return
 
     mEventManager.sendDeviceOrientationDidChange(deviceOrientation.ordinal)
     lastDeviceOrientation = deviceOrientation
@@ -168,9 +163,8 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
 
     // NOTE(2.init): This is needed to disable sensors if they were needed just for the initial
     //  device computation.
-    if (didComputeInitialDeviceOrientation) {
-      return
-    }
+    if (didComputeInitialDeviceOrientation) return
+
     didComputeInitialDeviceOrientation = true
 
     if (!areOrientationSensorsEnabled) {
@@ -179,13 +173,9 @@ class OrientationDirectorModuleImpl internal constructor(private val context: Re
   }
 
   private fun checkInterfaceOrientation(skipIfAutoRotationIsDisabled: Boolean = true) {
-    if (skipIfAutoRotationIsDisabled && !mAutoRotationObserver.getLastAutoRotationStatus()) {
-      return
-    }
+    if (skipIfAutoRotationIsDisabled && !mAutoRotationObserver.getLastAutoRotationStatus()) return
 
-    if (isLocked) {
-      return
-    }
+    if (isLocked) return
 
     if (lastDeviceOrientation != Orientation.LANDSCAPE_RIGHT && lastDeviceOrientation != Orientation.LANDSCAPE_LEFT) {
       val rotation = mUtils.getInterfaceRotation()

package/android/src/main/java/com/orientationdirector/implementation/OrientationSensorsEventListener.kt

@@ -5,52 +5,32 @@ import android.hardware.Sensor
 import android.hardware.SensorEvent
 import android.hardware.SensorEventListener
 import android.hardware.SensorManager
+import android.view.OrientationEventListener
 import com.facebook.react.bridge.ReactApplicationContext
 
 class OrientationSensorsEventListener(
   context: ReactApplicationContext,
-) : SensorEventListener {
+) : SensorEventListener, OrientationEventListener(context, SensorManager.SENSOR_DELAY_UI) {
+  private val rotationMatrix = FloatArray(9)
+
   private var mSensorManager: SensorManager =
     context.getSystemService(SENSOR_SERVICE) as SensorManager
-
   private var mRotationSensor: Sensor? =
     mSensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR)
-  private var mAccelerometerSensor: Sensor? =
-    mSensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
-  private var mMagneticFieldSensor: Sensor? =
-    mSensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)
-
   private var hasRotationSensor: Boolean =
-   mRotationSensor != null
-  private var hasAccelerometerAndMagneticFieldSensors: Boolean =
-    mAccelerometerSensor != null && mMagneticFieldSensor != null
+    mRotationSensor != null
 
-  private val accelerometerReading = FloatArray(3)
-  private val magnetometerReading = FloatArray(3)
-
-  private var lastComputedOrientationAngles = FloatArray(3)
-  private var onOrientationAnglesChangedCallback: ((orientationAngles: FloatArray) -> Unit)? = null
-
-  fun setOnOrientationAnglesChangedCallback(callback: (orientation: FloatArray) -> Unit) {
-    onOrientationAnglesChangedCallback = callback
-  }
-
-  override fun onSensorChanged(event: SensorEvent?) {
-    if (event == null) {
-      return
-    }
-
-    if (event.sensor.type == Sensor.TYPE_ROTATION_VECTOR) {
-      computeOrientationFromRotationSensor(event.values);
-      return
-    }
+  private var lastComputedDeviceOrientation = Orientation.UNKNOWN
+  private var lastComputedFaceOrientation = Orientation.UNKNOWN
 
-    computeOrientationFromOtherSensors(event)
+  private var onDeviceOrientationChangedCallback: ((deviceOrientation: Orientation) -> Unit)? = null
+  fun setOnDeviceOrientationChangedCallback(callback: (deviceOrientation: Orientation) -> Unit) {
+    onDeviceOrientationChangedCallback = callback
   }
 
-  override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}
+  override fun enable() {
+    super.enable()
 
-  fun enable() {
     if (hasRotationSensor) {
       mSensorManager.registerListener(
         this,
@@ -58,72 +38,85 @@ class OrientationSensorsEventListener(
         SensorManager.SENSOR_DELAY_NORMAL,
         SensorManager.SENSOR_DELAY_UI
       )
-      return
     }
 
-    if (hasAccelerometerAndMagneticFieldSensors) {
-      mSensorManager.registerListener(
-        this,
-        mAccelerometerSensor,
-        SensorManager.SENSOR_DELAY_NORMAL,
-        SensorManager.SENSOR_DELAY_UI
-      )
-      mSensorManager.registerListener(
-        this,
-        mMagneticFieldSensor,
-        SensorManager.SENSOR_DELAY_NORMAL,
-        SensorManager.SENSOR_DELAY_UI
-      )
-      return
-    }
+    lastComputedDeviceOrientation = Orientation.UNKNOWN
+    lastComputedFaceOrientation = Orientation.UNKNOWN
   }
 
-  fun disable() {
-    mSensorManager.unregisterListener(this)
-  }
-
-  private fun computeOrientationFromRotationSensor(values: FloatArray) {
-    val rotationMatrix = FloatArray(9)
-    SensorManager.getRotationMatrixFromVector(rotationMatrix, values)
+  override fun disable() {
+    super.disable()
 
-    val orientationAngles = FloatArray(3)
-    SensorManager.getOrientation(rotationMatrix, orientationAngles)
+    if (hasRotationSensor) {
+      mSensorManager.unregisterListener(this)
+    }
 
-    notifyOrientationAnglesChanged(orientationAngles)
+    lastComputedDeviceOrientation = Orientation.UNKNOWN
+    lastComputedFaceOrientation = Orientation.UNKNOWN
   }
 
-  private fun computeOrientationFromOtherSensors(event: SensorEvent) {
-    if (event.sensor.type == Sensor.TYPE_ACCELEROMETER) {
-      System.arraycopy(event.values, 0, accelerometerReading, 0, accelerometerReading.size)
+  override fun onOrientationChanged(angleDegrees: Int) {
+    if (angleDegrees == ORIENTATION_UNKNOWN) {
+      lastComputedDeviceOrientation = Orientation.UNKNOWN
+      return
     }
 
-    if (event.sensor.type == Sensor.TYPE_MAGNETIC_FIELD) {
-      System.arraycopy(event.values, 0, magnetometerReading, 0, magnetometerReading.size)
+    val currentDeviceOrientation = when (angleDegrees) {
+      in LANDSCAPE_RIGHT_START .. LANDSCAPE_RIGHT_END -> Orientation.LANDSCAPE_RIGHT
+      in PORTRAIT_UPSIDE_DOWN_START..PORTRAIT_UPSIDE_DOWN_END -> Orientation.PORTRAIT_UPSIDE_DOWN
+      in LANDSCAPE_LEFT_START..LANDSCAPE_LEFT_END -> Orientation.LANDSCAPE_LEFT
+      else -> Orientation.PORTRAIT
     }
 
-    val rotationMatrix = FloatArray(9)
-    val didComputeMatrix = SensorManager.getRotationMatrix(
-      rotationMatrix,
-      null,
-      accelerometerReading,
-      magnetometerReading
-    )
-    if (!didComputeMatrix) {
+    if (currentDeviceOrientation == lastComputedDeviceOrientation) return
+
+    notifyDeviceOrientationChanged(currentDeviceOrientation)
+  }
+
+  override fun onSensorChanged(event: SensorEvent) {
+    if (event.sensor.type != Sensor.TYPE_ROTATION_VECTOR) return
+
+    if (lastComputedDeviceOrientation != Orientation.UNKNOWN) {
+      lastComputedFaceOrientation = Orientation.UNKNOWN
       return
     }
 
-    val orientationAngles = FloatArray(3)
-    SensorManager.getOrientation(rotationMatrix, orientationAngles)
+    SensorManager.getRotationMatrixFromVector(rotationMatrix, event.values)
+
+    val zUp = rotationMatrix[8]
+    val currentFaceOrientation = when {
+      zUp > FACE_UP_Z_THRESHOLD -> Orientation.FACE_UP
+      zUp < -FACE_DOWN_Z_THRESHOLD -> Orientation.FACE_DOWN
+      else -> null
+    }
+
+    if (currentFaceOrientation == null) return
+
+    if (currentFaceOrientation == lastComputedFaceOrientation) return
 
-    notifyOrientationAnglesChanged(orientationAngles)
+    notifyFaceOrientationChanged(currentFaceOrientation)
   }
 
-  private fun notifyOrientationAnglesChanged(orientationAngles: FloatArray) {
-    if (lastComputedOrientationAngles.contentEquals(orientationAngles)) {
-      return
-    }
+  private fun notifyDeviceOrientationChanged(deviceOrientation: Orientation) {
+    lastComputedDeviceOrientation = deviceOrientation
+    onDeviceOrientationChangedCallback?.invoke(deviceOrientation)
+  }
+
+  private fun notifyFaceOrientationChanged(faceOrientation: Orientation) {
+    lastComputedFaceOrientation = faceOrientation
+    onDeviceOrientationChangedCallback?.invoke(faceOrientation)
+  }
 
-    onOrientationAnglesChangedCallback?.invoke(orientationAngles)
-    lastComputedOrientationAngles = orientationAngles
+  override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) = Unit
+
+  companion object {
+    private const val LANDSCAPE_RIGHT_START = 45
+    private const val LANDSCAPE_RIGHT_END = 134
+    private const val PORTRAIT_UPSIDE_DOWN_START = 135
+    private const val PORTRAIT_UPSIDE_DOWN_END = 224
+    private const val LANDSCAPE_LEFT_START = 225
+    private const val LANDSCAPE_LEFT_END = 314
+    private const val FACE_UP_Z_THRESHOLD   = 0.906f
+    private const val FACE_DOWN_Z_THRESHOLD = 0.906f
   }
 }