Merge remote-tracking branch 'origin/issue/17214-final-design-touces' into issue/17214-final-design-touces

Author: ovitrif

WordPress/src/jetpack/java/org/wordpress/android/ui/accounts/login/LoginPrologueRevampedViewModel.kt

@@ -11,73 +11,88 @@ import androidx.lifecycle.ViewModel
 import dagger.hilt.android.lifecycle.HiltViewModel
 import dagger.hilt.android.qualifiers.ApplicationContext
 import javax.inject.Inject
-import kotlin.math.exp
-import kotlin.math.ln
+import kotlin.math.PI
 
-// This factor is used to convert the raw values emitted from device sensor to an appropriate scale for the consuming
-// composables.
-private const val ACCELERATION_FACTOR = -0.01425f
+/**
+ * This factor is used to convert the raw values emitted from device sensor to an appropriate scale for the consuming
+ * composables. The range for pitch values is -π/2 to π/2, representing an upright pose and an upside-down pose,
+ * respectively. E.g. Setting this factor to 0.2 / (π/2) will scale this output range to -0.2 to 0.2. The resulting
+ * product is interpreted in units proportional to the repeating child composable's height per second, i.e. at a
+ * velocity of 0.1, it will take 10 seconds for the looping animation to repeat. When applied, the product can also be
+ * thought of as a frequency value in Hz.
+ */
+private const val VELOCITY_FACTOR = (0.2 / (PI / 2)).toFloat()
 
-// The maximum velocity (in either direction)
-private const val MAXIMUM_VELOCITY = 0.1f
-
-// The velocity decay factor (i.e. 1/7th velocity after 1 second)
-private val VELOCITY_DECAY = -ln(7f)
-
-// An additional acceleration applied to make the text scroll when the device is flat on a table
-private const val DRIFT = -0.05f
+/**
+ * This is the default pitch provided for devices lacking support for the sensors used. This is consumed by the model
+ * as a value in radians, but is specified here as -30 degrees for convenience. This represents a device pose that is
+ * slightly upright from flat, approximating a typical usage pattern, and will ensure that the text is animated at
+ * an appropriate velocity when sensors are unavailable.
+ */
+private const val DEFAULT_PITCH = (-30 * PI / 180).toFloat()
 
 @HiltViewModel
 class LoginPrologueRevampedViewModel @Inject constructor(
     @ApplicationContext appContext: Context,
 ) : ViewModel() {
-    private var acceleration = -0.3f // Default value when sensor is off
-    private var velocity = 0f
+    private val accelerometerData = FloatArray(3)
+    private val magnetometerData = FloatArray(3)
+    private val rotationMatrix = FloatArray(9)
+    private val orientationAngles = floatArrayOf(0f, DEFAULT_PITCH, 0f)
     private var position = 0f
 
     /**
      * This function updates the physics model for the interactive animation by applying the elapsed time (in seconds)
      * to update the velocity and position.
      *
-     *  * Velocity is constrained so that it does not fall below -MAXIMUM_VELOCITY and does not exceed MAXIMUM_VELOCITY.
+     *  * Velocity is calculated as proportional to the pitch angle
      *  * Position is constrained so that it always falls between 0 and 1, and represents the relative vertical offset
      *  in terms of the height of the repeated child composable.
      *
      *  @param elapsed the elapsed time (in seconds) since the last frame
      */
     fun updateForFrame(elapsed: Float) {
-        // Update the velocity, (decayed and clamped to the maximum)
-        velocity = (velocity * exp(elapsed * VELOCITY_DECAY) + elapsed * acceleration)
-                .coerceIn(-MAXIMUM_VELOCITY, MAXIMUM_VELOCITY)
-        // Update the position, modulo 1 (ensuring a value greater or equal to 0, and less than 1)
-        position = ((position + elapsed * velocity) % 1 + 1) % 1
+        orientationAngles.let { (_, pitch) ->
+            val velocity = pitch * VELOCITY_FACTOR
+
+            // Update the position, modulo 1 (ensuring a value greater or equal to 0, and less than 1)
+            position = ((position + elapsed * velocity) % 1 + 1) % 1
 
-        _positionData.postValue(position)
+            _positionData.postValue(position)
+        }
     }
 
-    /** This LiveData responds to accelerometer data from the y-axis of the device and emits updated position data. */
+    /**
+     * This LiveData responds to orientation data to calculate the pitch of the device. This is then used to update the
+     * velocity and position for each frame.
+     */
     private val _positionData = object : MutableLiveData<Float>(), SensorEventListener {
         private val sensorManager
             get() = appContext.getSystemService(Context.SENSOR_SERVICE) as SensorManager
 
         override fun onActive() {
             super.onActive()
-            val sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
-            sensorManager.registerListener(this, sensor, SensorManager.SENSOR_DELAY_GAME)
+            sensorManager.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)?.also {
+                sensorManager.registerListener( this, it, SensorManager.SENSOR_DELAY_GAME)
+            }
+            sensorManager.getDefaultSensor(Sensor.TYPE_MAGNETIC_FIELD)?.also {
+                sensorManager.registerListener( this, it, SensorManager.SENSOR_DELAY_GAME)
+            }
         }
 
         override fun onInactive() {
             super.onInactive()
             sensorManager.unregisterListener(this)
         }
 
-        override fun onSensorChanged(event: SensorEvent?) {
-            event?.values?.let { (_, yAxisAcceleration, _) ->
-                acceleration = yAxisAcceleration * ACCELERATION_FACTOR +
-                        (if (yAxisAcceleration >= -0.2f) DRIFT else -DRIFT) // drift shouldn't change scroll direction.
-
-                postValue(position)
+        override fun onSensorChanged(event: SensorEvent) {
+            when (event.sensor.type) {
+                Sensor.TYPE_ACCELEROMETER -> event.values.copyInto(accelerometerData)
+                Sensor.TYPE_MAGNETIC_FIELD -> event.values.copyInto(magnetometerData)
             }
+            // Update the orientation angles when sensor data is updated
+            SensorManager.getRotationMatrix(rotationMatrix, null, accelerometerData, magnetometerData)
+            SensorManager.getOrientation(rotationMatrix, orientationAngles)
         }
 
         override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) = Unit