Additions to the Android java-side Device Motion/Orientation fetching

content/public/android/java/src/org/chromium/content/browser/DeviceMotionAndOrientation.java

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package org.chromium.content.browser;
 
 import android.content.Context;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
@@ skipping 30 matching lines @@
     private Object mHandlerLock = new Object();
 
     // Non-zero if and only if we're listening for events.
     // To avoid race conditions on the C++ side, access must be synchronized.
     private int mNativePtr;
 
     // The lock to access the mNativePtr.
     private Object mNativePtrLock = new Object();
 
     // The acceleration vector including gravity expressed in the body frame.
-    private float[] mAccelerationVector;
+    private float[] mAccelerationIncludingGravityVector;
 
     // The geomagnetic vector expressed in the body frame.
     private float[] mMagneticFieldVector;
 
     // Lazily initialized when registering for notifications.
     private SensorManagerProxy mSensorManagerProxy;
 
     // The only instance of that class and its associated lock.
     private static DeviceMotionAndOrientation sSingleton;
     private static Object sSingletonLock = new Object();
@@ skipping 51 matching lines @@
                     return false;
             }
             if (success) {
                 mNativePtr = nativePtr;
                 setEventTypeActive(eventType, true);
             }
             return success;
         }
     }
 
+    @CalledByNative
+    public int getNumberActiveDeviceMotionSensors() {
+        Set<Integer> deviceMotionSensors = Sets.newHashSet(DEVICE_MOTION_SENSORS);
+        deviceMotionSensors.removeAll(mActiveSensors);
+        return DEVICE_MOTION_SENSORS.size() - deviceMotionSensors.size();
+    }
+
     /**
      * Stop listening to sensors for a given event type. Ensures that sensors are not disabled
      * if they are still in use by a different event type.
      *
      * @param eventType Type of event to listen to, can be either DEVICE_ORIENTATION or
      *                  DEVICE_MOTION.
      * We strictly guarantee that the corresponding native*() methods will not be called
      * after this method returns.
      */
     @CalledByNative
@@ skipping 34 matching lines @@
     @Override
     public void onSensorChanged(SensorEvent event) {
         sensorChanged(event.sensor.getType(), event.values);
     }
 
     @VisibleForTesting
     void sensorChanged(int type, float[] values) {
 
         switch (type) {
             case Sensor.TYPE_ACCELEROMETER:
-                if (mAccelerationVector == null) {
-                    mAccelerationVector = new float[3];
+                if (mAccelerationIncludingGravityVector == null) {
+                    mAccelerationIncludingGravityVector = new float[3];
                 }
-                System.arraycopy(values, 0, mAccelerationVector, 0,
-                        mAccelerationVector.length);
+                System.arraycopy(values, 0, mAccelerationIncludingGravityVector,
+                        0, mAccelerationIncludingGravityVector.length);
                 if (mDeviceMotionIsActive) {
-                    gotAccelerationIncludingGravity(mAccelerationVector[0], mAccelerationVector[1],
-                        mAccelerationVector[2]);
+                    gotAccelerationIncludingGravity(
+                            mAccelerationIncludingGravityVector[0],
+                            mAccelerationIncludingGravityVector[1],
+                            mAccelerationIncludingGravityVector[2]);
+                }
+                if (mDeviceOrientationIsActive) {
+                    getOrientationUsingGetRotationMatrix();
                 }
                 break;
             case Sensor.TYPE_LINEAR_ACCELERATION:
                 if (mDeviceMotionIsActive) {
                     gotAcceleration(values[0], values[1], values[2]);
                 }
                 break;
             case Sensor.TYPE_GYROSCOPE:
                 if (mDeviceMotionIsActive) {
                     gotRotationRate(values[0], values[1], values[2]);
                 }
                 break;
             case Sensor.TYPE_MAGNETIC_FIELD:
                 if (mMagneticFieldVector == null) {
                     mMagneticFieldVector = new float[3];
                 }
                 System.arraycopy(values, 0, mMagneticFieldVector, 0,
                         mMagneticFieldVector.length);
+                if (mDeviceOrientationIsActive) {
+                    getOrientationUsingGetRotationMatrix();
+                }
                 break;
             default:
                 // Unexpected
                 return;
         }
-
-        if (mDeviceOrientationIsActive) {
-            getOrientationUsingGetRotationMatrix();
-        }
     }
 
     private void getOrientationUsingGetRotationMatrix() {
-        if (mAccelerationVector == null || mMagneticFieldVector == null) {
+        if (mAccelerationIncludingGravityVector == null || mMagneticFieldVector == null) {
             return;
         }
 
         // Get the rotation matrix.
         // The rotation matrix that transforms from the body frame to the earth
         // frame.
         float[] deviceRotationMatrix = new float[9];
-        if (!SensorManager.getRotationMatrix(deviceRotationMatrix, null, mAccelerationVector,
-                mMagneticFieldVector)) {
+        if (!SensorManager.getRotationMatrix(deviceRotationMatrix, null,
+                mAccelerationIncludingGravityVector, mMagneticFieldVector)) {
             return;
         }
 
         // Convert rotation matrix to rotation angles.
         // Assuming that the rotations are appied in the order listed at
         // http://developer.android.com/reference/android/hardware/SensorEvent.html#values
         // the rotations are applied about the same axes and in the same order as required by the
         // API. The only conversions are sign changes as follows.  The angles are in radians
 
         float[] rotationAngles = new float[3];
@@ skipping 207 matching lines @@
 
         public void unregisterListener(SensorEventListener listener, int sensorType) {
             List<Sensor> sensors = mSensorManager.getSensorList(sensorType);
             if (!sensors.isEmpty()) {
                 mSensorManager.unregisterListener(listener, sensors.get(0));
             }
         }
     }
 
 }