Move //content/browser/device_sensor/ into device/sensors

device/sensors/android/java/src/org/chromium/device/sensors/DeviceSensors.java

 // Copyright 2014 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;
+package org.chromium.device.sensors;
 
 import android.content.Context;
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
 import android.os.Handler;
 import android.os.HandlerThread;
 
 import org.chromium.base.CollectionUtil;
 import org.chromium.base.Log;
 import org.chromium.base.ThreadUtils;
 import org.chromium.base.VisibleForTesting;
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
 /**
  * Android implementation of the device {motion|orientation|light} APIs.
  */
-@JNINamespace("content")
-class DeviceSensors implements SensorEventListener {
-
-    private static final String TAG = "cr.DeviceSensors";
+@JNINamespace("device")
+public class DeviceSensors implements SensorEventListener {
+    private static final String TAG = "DeviceSensors";
 
     // Matches kEnableExperimentalWebPlatformFeatures.
     private static final String EXPERIMENTAL_WEB_PLAFTORM_FEATURES =
             "enable-experimental-web-platform-features";
 
     // These fields are lazily initialized by getHandler().
     private Thread mThread;
     private Handler mHandler;
 
     // A reference to the application context in order to acquire the SensorService.
@@ skipping 21 matching lines @@
     // Holds Euler angles corresponding to the rotation matrix.
     private double[] mRotationAngles;
 
     // Lazily initialized when registering for notifications.
     private SensorManagerProxy mSensorManagerProxy;
 
     // The only instance of that class and its associated lock.
     private static DeviceSensors sSingleton;
     private static Object sSingletonLock = new Object();
 
-    static final Set<Integer> DEVICE_ORIENTATION_SENSORS_A = CollectionUtil.newHashSet(
-            Sensor.TYPE_GAME_ROTATION_VECTOR);
-    static final Set<Integer> DEVICE_ORIENTATION_SENSORS_B = CollectionUtil.newHashSet(
-            Sensor.TYPE_ROTATION_VECTOR);
+    public static final Set<Integer> DEVICE_ORIENTATION_SENSORS_A =

[timvolodine, 2017/01/26 14:01:15]

why does this have to be public? also below and the VisibleForTesting fields and
methods..

[ke.he, 2017/01/26 15:33:22]

With this patch, the package name of this class is changed from
"org.chromium.content.browser" to "org.chromium.device.sensors".
While the DeviceSensorsTest.java are still in org.chromium.content.browser
package. So in this cross package situation I have to
make DeviceSensors to be public to let DeviceSensorsTest be able to find it.

[timvolodine, 2017/01/31 07:13:15]

I assume this is a temporary situation? Is it possible to also move the test to
the new package to avoid publics and the cross package divide?

+            CollectionUtil.newHashSet(Sensor.TYPE_GAME_ROTATION_VECTOR);
+    public static final Set<Integer> DEVICE_ORIENTATION_SENSORS_B =
+            CollectionUtil.newHashSet(Sensor.TYPE_ROTATION_VECTOR);
     // Option C backup sensors are used when options A and B are not available.
-    static final Set<Integer> DEVICE_ORIENTATION_SENSORS_C = CollectionUtil.newHashSet(
-            Sensor.TYPE_ACCELEROMETER,
-            Sensor.TYPE_MAGNETIC_FIELD);
-    static final Set<Integer> DEVICE_ORIENTATION_ABSOLUTE_SENSORS = CollectionUtil.newHashSet(
-            Sensor.TYPE_ROTATION_VECTOR);
-    static final Set<Integer> DEVICE_MOTION_SENSORS = CollectionUtil.newHashSet(
-            Sensor.TYPE_ACCELEROMETER,
-            Sensor.TYPE_LINEAR_ACCELERATION,
-            Sensor.TYPE_GYROSCOPE);
-    static final Set<Integer> DEVICE_LIGHT_SENSORS = CollectionUtil.newHashSet(
-            Sensor.TYPE_LIGHT);
+    public static final Set<Integer> DEVICE_ORIENTATION_SENSORS_C =
+            CollectionUtil.newHashSet(Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_MAGNETIC_FIELD);
+    public static final Set<Integer> DEVICE_ORIENTATION_ABSOLUTE_SENSORS =
+            CollectionUtil.newHashSet(Sensor.TYPE_ROTATION_VECTOR);
+    public static final Set<Integer> DEVICE_MOTION_SENSORS = CollectionUtil.newHashSet(
+            Sensor.TYPE_ACCELEROMETER, Sensor.TYPE_LINEAR_ACCELERATION, Sensor.TYPE_GYROSCOPE);
+    public static final Set<Integer> DEVICE_LIGHT_SENSORS =
+            CollectionUtil.newHashSet(Sensor.TYPE_LIGHT);
 
     @VisibleForTesting
-    final Set<Integer> mActiveSensors = new HashSet<Integer>();
-    final List<Set<Integer>> mOrientationSensorSets;
-    Set<Integer> mDeviceOrientationSensors;
-    boolean mDeviceLightIsActive;
-    boolean mDeviceMotionIsActive;
-    boolean mDeviceOrientationIsActive;
-    boolean mDeviceOrientationIsActiveWithBackupSensors;
-    boolean mDeviceOrientationAbsoluteIsActive;
-    boolean mOrientationNotAvailable;
+    public final Set<Integer> mActiveSensors = new HashSet<Integer>();
+    public final List<Set<Integer>> mOrientationSensorSets;
+    public Set<Integer> mDeviceOrientationSensors;
+    public boolean mDeviceLightIsActive;
+    public boolean mDeviceMotionIsActive;
+    public boolean mDeviceOrientationIsActive;
+    public boolean mDeviceOrientationIsActiveWithBackupSensors;
+    public boolean mDeviceOrientationAbsoluteIsActive;
+    public boolean mOrientationNotAvailable;
 
     protected DeviceSensors(Context context) {
         mAppContext = context.getApplicationContext();
 
         mOrientationSensorSets = CollectionUtil.newArrayList(DEVICE_ORIENTATION_SENSORS_A,
-                                                             DEVICE_ORIENTATION_SENSORS_B,
-                                                             DEVICE_ORIENTATION_SENSORS_C);
+                DEVICE_ORIENTATION_SENSORS_B, DEVICE_ORIENTATION_SENSORS_C);
     }
 
     // For orientation we use a 3-way fallback approach where up to 3 different sets of sensors
     // are attempted if necessary. The sensors to be used for orientation are determined in the
     // following order:
     //   A: GAME_ROTATION_VECTOR (relative)
     //   B: ROTATION_VECTOR (absolute)
     //   C: combination of ACCELEROMETER and MAGNETIC_FIELD (absolute)
     // Some of the sensors may not be available depending on the device and Android version, so
     // the 3-way fallback ensures selection of the best possible option.
@@ skipping 35 matching lines @@
     @CalledByNative
     public boolean start(long nativePtr, int eventType, int rateInMicroseconds) {
         boolean success = false;
         synchronized (mNativePtrLock) {
             switch (eventType) {
                 case ConsumerType.ORIENTATION:
                     success = registerOrientationSensorsWithFallback(rateInMicroseconds);
                     break;
                 case ConsumerType.ORIENTATION_ABSOLUTE:
                     ensureRotationStructuresAllocated();
-                    success = registerSensors(DEVICE_ORIENTATION_ABSOLUTE_SENSORS,
-                            rateInMicroseconds, true);
+                    success = registerSensors(
+                            DEVICE_ORIENTATION_ABSOLUTE_SENSORS, rateInMicroseconds, true);
                     break;
                 case ConsumerType.MOTION:
                     // note: device motion spec does not require all sensors to be available
                     success = registerSensors(DEVICE_MOTION_SENSORS, rateInMicroseconds, false);
                     break;
                 case ConsumerType.LIGHT:
                     success = registerSensors(DEVICE_LIGHT_SENSORS, rateInMicroseconds, true);
                     break;
                 default:
                     Log.e(TAG, "Unknown event type: %d", eventType);
@@ skipping 22 matching lines @@
         if (mDeviceOrientationSensors == DEVICE_ORIENTATION_SENSORS_A) {
             return OrientationSensorType.GAME_ROTATION_VECTOR;
         }
         if (mDeviceOrientationSensors == DEVICE_ORIENTATION_SENSORS_B) {
             return OrientationSensorType.ROTATION_VECTOR;
         }
         if (mDeviceOrientationSensors == DEVICE_ORIENTATION_SENSORS_C) {
             return OrientationSensorType.ACCELEROMETER_MAGNETIC;
         }
 
-        assert false;  // should never happen
+        assert false; // should never happen
         return OrientationSensorType.NOT_AVAILABLE;
     }
 
     /**
      * 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 or DEVICE_LIGHT.
      * We strictly guarantee that the corresponding native*() methods will not be called
@@ skipping 35 matching lines @@
     public void onAccuracyChanged(Sensor sensor, int accuracy) {
         // Nothing
     }
 
     @Override
     public void onSensorChanged(SensorEvent event) {
         sensorChanged(event.sensor.getType(), event.values);
     }
 
     @VisibleForTesting
-    void sensorChanged(int type, float[] values) {
+    public void sensorChanged(int type, float[] values) {
         switch (type) {
             case Sensor.TYPE_ACCELEROMETER:
                 if (mDeviceMotionIsActive) {
                     gotAccelerationIncludingGravity(values[0], values[1], values[2]);
                 }
                 if (mDeviceOrientationIsActiveWithBackupSensors) {
                     getOrientationFromGeomagneticVectors(values, mMagneticFieldVector);
                 }
                 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_ROTATION_VECTOR:
                 if (mDeviceOrientationAbsoluteIsActive) {
                     convertRotationVectorToAngles(values, mRotationAngles);
-                    gotOrientationAbsolute(mRotationAngles[0], mRotationAngles[1],
-                            mRotationAngles[2]);
+                    gotOrientationAbsolute(
+                            mRotationAngles[0], mRotationAngles[1], mRotationAngles[2]);
                 }
                 if (mDeviceOrientationIsActive
                         && mDeviceOrientationSensors == DEVICE_ORIENTATION_SENSORS_B) {
                     if (!mDeviceOrientationAbsoluteIsActive) {
                         // only compute if not already computed for absolute orientation above.
                         convertRotationVectorToAngles(values, mRotationAngles);
                     }
                     gotOrientation(mRotationAngles[0], mRotationAngles[1], mRotationAngles[2]);
                 }
                 break;
             case Sensor.TYPE_GAME_ROTATION_VECTOR:
                 if (mDeviceOrientationIsActive) {
                     convertRotationVectorToAngles(values, mRotationAngles);
                     gotOrientation(mRotationAngles[0], mRotationAngles[1], mRotationAngles[2]);
                 }
                 break;
             case Sensor.TYPE_MAGNETIC_FIELD:
                 if (mDeviceOrientationIsActiveWithBackupSensors) {
                     if (mMagneticFieldVector == null) {
                         mMagneticFieldVector = new float[3];
                     }
-                    System.arraycopy(values, 0, mMagneticFieldVector, 0,
-                            mMagneticFieldVector.length);
+                    System.arraycopy(
+                            values, 0, mMagneticFieldVector, 0, mMagneticFieldVector.length);
                 }
                 break;
             case Sensor.TYPE_LIGHT:
                 if (mDeviceLightIsActive) {
                     gotLight(values[0]);
                 }
                 break;
             default:
                 // Unexpected
                 return;
@@ skipping 42 matching lines @@
             float[] matrixR, double[] values) {
         /*
          * 3x3 (length=9) case:
          *   /  R[ 0]   R[ 1]   R[ 2]  \
          *   |  R[ 3]   R[ 4]   R[ 5]  |
          *   \  R[ 6]   R[ 7]   R[ 8]  /
          *
          */
         if (matrixR.length != 9) return values;
 
-        if (matrixR[8] > 0) {  // cos(beta) > 0
+        if (matrixR[8] > 0) { // cos(beta) > 0
             values[0] = Math.atan2(-matrixR[1], matrixR[4]);
-            values[1] = Math.asin(matrixR[7]);                 // beta (-pi/2, pi/2)
-            values[2] = Math.atan2(-matrixR[6], matrixR[8]);   // gamma (-pi/2, pi/2)
-        } else if (matrixR[8] < 0) {  // cos(beta) < 0
+            values[1] = Math.asin(matrixR[7]); // beta (-pi/2, pi/2)

[timvolodine, 2017/01/26 14:01:15]

the alignment here was actually done on purpose for better readability, so
please keep it

[ke.he, 2017/01/26 15:33:22]

The format is changed by "git cl format", I'll keep this part as original, and
let "git cl format" to format other parts,
do you think it's ok?

+            values[2] = Math.atan2(-matrixR[6], matrixR[8]); // gamma (-pi/2, pi/2)
+        } else if (matrixR[8] < 0) { // cos(beta) < 0
             values[0] = Math.atan2(matrixR[1], -matrixR[4]);
             values[1] = -Math.asin(matrixR[7]);
             values[1] += (values[1] >= 0) ? -Math.PI : Math.PI; // beta [-pi,-pi/2) U (pi/2,pi)
-            values[2] = Math.atan2(matrixR[6], -matrixR[8]);    // gamma (-pi/2, pi/2)
+            values[2] = Math.atan2(matrixR[6], -matrixR[8]); // gamma (-pi/2, pi/2)
         } else { // R[8] == 0
-            if (matrixR[6] > 0) {  // cos(gamma) == 0, cos(beta) > 0
+            if (matrixR[6] > 0) { // cos(gamma) == 0, cos(beta) > 0
                 values[0] = Math.atan2(-matrixR[1], matrixR[4]);
-                values[1] = Math.asin(matrixR[7]);       // beta [-pi/2, pi/2]
-                values[2] = -Math.PI / 2;                // gamma = -pi/2
+                values[1] = Math.asin(matrixR[7]); // beta [-pi/2, pi/2]
+                values[2] = -Math.PI / 2; // gamma = -pi/2
             } else if (matrixR[6] < 0) { // cos(gamma) == 0, cos(beta) < 0
                 values[0] = Math.atan2(matrixR[1], -matrixR[4]);
                 values[1] = -Math.asin(matrixR[7]);
                 values[1] += (values[1] >= 0) ? -Math.PI : Math.PI; // beta [-pi,-pi/2) U (pi/2,pi)
-                values[2] = -Math.PI / 2;                           // gamma = -pi/2
+                values[2] = -Math.PI / 2; // gamma = -pi/2
             } else { // R[6] == 0, cos(beta) == 0
                 // gimbal lock discontinuity
                 values[0] = Math.atan2(matrixR[3], matrixR[0]);
-                values[1] = (matrixR[7] > 0) ? Math.PI / 2 : -Math.PI / 2;  // beta = +-pi/2
-                values[2] = 0;                                              // gamma = 0
+                values[1] = (matrixR[7] > 0) ? Math.PI / 2 : -Math.PI / 2; // beta = +-pi/2
+                values[2] = 0; // gamma = 0
             }
         }
 
         // alpha is in [-pi, pi], make sure it is in [0, 2*pi).
         if (values[0] < 0) {
             values[0] += 2 * Math.PI; // alpha [0, 2*pi)
         }
 
         return values;
     }
 
     /*
      * Converts a given rotation vector to its Euler angles representation. The angles
      * are in degrees.
      */
     public void convertRotationVectorToAngles(float[] rotationVector, double[] angles) {
         if (rotationVector.length > 4) {
             // On some Samsung devices SensorManager.getRotationMatrixFromVector
             // appears to throw an exception if rotation vector has length > 4.
             // For the purposes of this class the first 4 values of the
             // rotation vector are sufficient (see crbug.com/335298 for details).
             System.arraycopy(rotationVector, 0, mTruncatedRotationVector, 0, 4);
-            SensorManager.getRotationMatrixFromVector(mDeviceRotationMatrix,
-                    mTruncatedRotationVector);
+            SensorManager.getRotationMatrixFromVector(
+                    mDeviceRotationMatrix, mTruncatedRotationVector);
         } else {
             SensorManager.getRotationMatrixFromVector(mDeviceRotationMatrix, rotationVector);
         }
         computeDeviceOrientationFromRotationMatrix(mDeviceRotationMatrix, angles);
         for (int i = 0; i < 3; i++) {
             angles[i] = Math.toDegrees(angles[i]);
         }
     }
 
     private void getOrientationFromGeomagneticVectors(float[] acceleration, float[] magnetic) {
         if (acceleration == null || magnetic == null) {
             return;
         }
         if (!SensorManager.getRotationMatrix(mDeviceRotationMatrix, null, acceleration, magnetic)) {
             return;
         }
         computeDeviceOrientationFromRotationMatrix(mDeviceRotationMatrix, mRotationAngles);
 
-        gotOrientation(Math.toDegrees(mRotationAngles[0]),
-                       Math.toDegrees(mRotationAngles[1]),
-                       Math.toDegrees(mRotationAngles[2]));
+        gotOrientation(Math.toDegrees(mRotationAngles[0]), Math.toDegrees(mRotationAngles[1]),
+                Math.toDegrees(mRotationAngles[2]));
     }
 
     private SensorManagerProxy getSensorManagerProxy() {
         if (mSensorManagerProxy != null) {
             return mSensorManagerProxy;
         }
 
         ThreadUtils.assertOnUiThread();
         SensorManager sensorManager =
                 (SensorManager) mAppContext.getSystemService(Context.SENSOR_SERVICE);
 
         if (sensorManager != null) {
             mSensorManagerProxy = new SensorManagerProxyImpl(sensorManager);
         }
         return mSensorManagerProxy;
     }
 
     @VisibleForTesting
-    void setSensorManagerProxy(SensorManagerProxy sensorManagerProxy) {
+    public void setSensorManagerProxy(SensorManagerProxy sensorManagerProxy) {
         mSensorManagerProxy = sensorManagerProxy;
     }
 
     private void setEventTypeActive(int eventType, boolean active) {
         switch (eventType) {
             case ConsumerType.ORIENTATION:
                 mDeviceOrientationIsActive = active;
-                mDeviceOrientationIsActiveWithBackupSensors = active
-                        && (mDeviceOrientationSensors == DEVICE_ORIENTATION_SENSORS_C);
+                mDeviceOrientationIsActiveWithBackupSensors =
+                        active && (mDeviceOrientationSensors == DEVICE_ORIENTATION_SENSORS_C);
                 return;
             case ConsumerType.ORIENTATION_ABSOLUTE:
                 mDeviceOrientationAbsoluteIsActive = active;
                 return;
             case ConsumerType.MOTION:
                 mDeviceMotionIsActive = active;
                 return;
             case ConsumerType.LIGHT:
                 mDeviceLightIsActive = active;
                 return;
@@ skipping 12 matching lines @@
         }
     }
 
     /**
      * @param sensorTypes List of sensors to activate.
      * @param rateInMicroseconds Intended delay (in microseconds) between sensor readings.
      * @param failOnMissingSensor If true the method returns true only if all sensors could be
      *                            activated. When false the method return true if at least one
      *                            sensor in sensorTypes could be activated.
      */
-    private boolean registerSensors(Set<Integer> sensorTypes, int rateInMicroseconds,
-            boolean failOnMissingSensor) {
+    private boolean registerSensors(
+            Set<Integer> sensorTypes, int rateInMicroseconds, boolean failOnMissingSensor) {
         Set<Integer> sensorsToActivate = new HashSet<Integer>(sensorTypes);
         sensorsToActivate.removeAll(mActiveSensors);
         if (sensorsToActivate.isEmpty()) return true;
 
         boolean success = false;
         for (Integer sensorType : sensorsToActivate) {
             boolean result = registerForSensorType(sensorType, rateInMicroseconds);
             if (!result && failOnMissingSensor) {
                 // restore the previous state upon failure
                 unregisterSensors(sensorsToActivate);
@@ skipping 73 matching lines @@
     }
 
     private Handler getHandler() {
         // TODO(timvolodine): Remove the mHandlerLock when sure that getHandler is not called
         // from multiple threads. This will be the case when device motion and device orientation
         // use the same polling thread (also see crbug/234282).
         synchronized (mHandlerLock) {
             if (mHandler == null) {
                 HandlerThread thread = new HandlerThread("DeviceMotionAndOrientation");
                 thread.start();
-                mHandler = new Handler(thread.getLooper());  // blocks on thread start
+                mHandler = new Handler(thread.getLooper()); // blocks on thread start
             }
             return mHandler;
         }
     }
 
     @CalledByNative
     static DeviceSensors getInstance(Context appContext) {
         synchronized (sSingletonLock) {
             if (sSingleton == null) {
                 sSingleton = new DeviceSensors(appContext);
             }
             return sSingleton;
         }
     }
 
     /**
      * Native JNI calls,
-     * see content/browser/device_sensors/sensor_manager_android.cc
+     * see device/sensors/sensor_manager_android.cc
      */
 
     /**
      * Orientation of the device with respect to its reference frame.
      */
     private native void nativeGotOrientation(
-            long nativeSensorManagerAndroid,
-            double alpha, double beta, double gamma);
+            long nativeSensorManagerAndroid, double alpha, double beta, double gamma);
 
     /**
      * Absolute orientation of the device with respect to its reference frame.
      */
     private native void nativeGotOrientationAbsolute(
-            long nativeSensorManagerAndroid,
-            double alpha, double beta, double gamma);
+            long nativeSensorManagerAndroid, double alpha, double beta, double gamma);
 
     /**
      * Linear acceleration without gravity of the device with respect to its body frame.
      */
     private native void nativeGotAcceleration(
-            long nativeSensorManagerAndroid,
-            double x, double y, double z);
+            long nativeSensorManagerAndroid, double x, double y, double z);
 
     /**
      * Acceleration including gravity of the device with respect to its body frame.
      */
     private native void nativeGotAccelerationIncludingGravity(
-            long nativeSensorManagerAndroid,
-            double x, double y, double z);
+            long nativeSensorManagerAndroid, double x, double y, double z);
 
     /**
      * Rotation rate of the device with respect to its body frame.
      */
     private native void nativeGotRotationRate(
-            long nativeSensorManagerAndroid,
-            double alpha, double beta, double gamma);
+            long nativeSensorManagerAndroid, double alpha, double beta, double gamma);
 
     /**
      * Device Light value from Ambient Light sensors.
      */
-    private native void nativeGotLight(
-            long nativeSensorManagerAndroid,
-            double value);
+    private native void nativeGotLight(long nativeSensorManagerAndroid, double value);
 
     /**
      * Need the an interface for SensorManager for testing.
      */
-    interface SensorManagerProxy {
-        public boolean registerListener(SensorEventListener listener, int sensorType, int rate,
-                Handler handler);
+    public interface SensorManagerProxy {
+        public boolean registerListener(
+                SensorEventListener listener, int sensorType, int rate, Handler handler);
         public void unregisterListener(SensorEventListener listener, int sensorType);
     }
 
     static class SensorManagerProxyImpl implements SensorManagerProxy {
         private final SensorManager mSensorManager;
 
         SensorManagerProxyImpl(SensorManager sensorManager) {
             mSensorManager = sensorManager;
         }
 
         @Override
-        public boolean registerListener(SensorEventListener listener, int sensorType, int rate,
-                Handler handler) {
+        public boolean registerListener(
+                SensorEventListener listener, int sensorType, int rate, Handler handler) {
             List<Sensor> sensors = mSensorManager.getSensorList(sensorType);
             if (sensors.isEmpty()) {
                 return false;
             }
             return mSensorManager.registerListener(listener, sensors.get(0), rate, handler);
         }
 
         @Override
         public void unregisterListener(SensorEventListener listener, int sensorType) {
             List<Sensor> sensors = mSensorManager.getSensorList(sensorType);
             if (sensors.isEmpty()) {
                 return;
             }
             try {
                 mSensorManager.unregisterListener(listener, sensors.get(0));
             } catch (IllegalArgumentException e) {
                 // Suppress occasional exception on Digma iDxD* devices:
                 // Receiver not registered: android.hardware.SystemSensorManager$1
                 // See crbug.com/596453.
                 Log.w(TAG, "Failed to unregister device sensor " + sensors.get(0).getName());
             }
         }
     }
-
 }