[Sensors] Improvements in shared buffer managing

device/generic_sensor/android/java/src/org/chromium/device/sensors/PlatformSensor.java

 // Copyright 2016 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.device.sensors;
 
 import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.os.Build;
 
 import org.chromium.base.annotations.CalledByNative;
 import org.chromium.base.annotations.JNINamespace;
 import org.chromium.device.mojom.ReportingMode;
 
-import java.nio.BufferOverflowException;
 import java.nio.ByteBuffer;

[shalamov, 2016/10/06 12:46:09]

not needed anymore.

[Mikhail, 2016/10/07 10:07:01]

Done.

-import java.nio.ByteOrder;
 
 import java.util.List;
 
 /**
  * Implementation of PlatformSensor that uses Android Sensor Framework. Lifetime is controlled by
  * the device::PlatformSensorAndroid.
  */
 @JNINamespace("device")
 public class PlatformSensor implements SensorEventListener {
     private static final double MICROSECONDS_IN_SECOND = 1000000;
-    private static final double MILLISECONDS_IN_NANOSECOND = 0.000001d;
+    private static final double SECONDS_IN_NANOSECOND = 0.000000001d;
 
     /**
      * The SENSOR_FREQUENCY_NORMAL is defined as 5Hz which corresponds to a polling delay
      * @see android.hardware.SensorManager.SENSOR_DELAY_NORMAL value that is defined as 200000
      * microseconds.
      */
     private static final double SENSOR_FREQUENCY_NORMAL = 5.0d;
 
     /**
      * Identifier of device::PlatformSensorAndroid instance.
      */
     private long mNativePlatformSensorAndroid;
 
     /**
-     * Shared buffer that is used to return data to the client.
-     */
-    private ByteBuffer mBuffer;
-
-    /**
-     * Buffer that is filled with sensor reading data and swapped into mBuffer.
-     */
-    private ByteBuffer mSensorReadingData;
-
-    /**
      * Used for fetching sensor reading values and obtaining information about the sensor.
      * @see android.hardware.Sensor
      */
     private final Sensor mSensor;
 
     /**
      * The minimum delay between two readings in microseconds that is supported by the sensor.
      */
     private final int mMinDelayUsec;
 
@@ skipping 36 matching lines @@
         mMinDelayUsec = mSensor.getMinDelay();
     }
 
     /**
      * Initializes PlatformSensor, called by native code.
      *
      * @param nativePlatformSensorAndroid identifier of device::PlatformSensorAndroid instance.
      * @param buffer shared buffer that is used to return data to the client.
      */
     @CalledByNative
-    protected void initPlatformSensorAndroid(long nativePlatformSensorAndroid, ByteBuffer buffer) {
+    protected void initPlatformSensorAndroid(long nativePlatformSensorAndroid) {
         assert nativePlatformSensorAndroid != 0;
-        assert buffer != null;
         mNativePlatformSensorAndroid = nativePlatformSensorAndroid;
-        mBuffer = buffer;
-        mSensorReadingData = ByteBuffer.allocate(mBuffer.capacity());
-        mSensorReadingData.order(ByteOrder.nativeOrder());
     }
 
     /**
      * Fills shared buffer with sensor reading data, throws exception if number of received values
      * is less than the number required for the PlatformSensor.
      */
     private void fillSensorReadingData(SensorEvent event, ByteBuffer buffer)

[shalamov, 2016/10/06 12:46:09]

not needed anymore.

[Mikhail, 2016/10/07 10:07:02]

Done.

             throws IllegalStateException {
         if (event.values.length < mReadingCount) throw new IllegalStateException();
         for (int i = 0; i < mReadingCount; ++i) {
             buffer.putDouble(event.values[i]);
         }
     }
 
     /**
      * Returns reporting mode supported by the sensor.
      *
@@ skipping 72 matching lines @@
     }
 
     /**
      * Converts frequency to sampling period in microseconds.
      */
     private int getSamplingPeriod(double frequency) {
         return (int) ((1 / frequency) * MICROSECONDS_IN_SECOND);
     }
 
     /**
-     * Notifies native device::PlatformSensorAndroid when reading is changed.
-     */
-    protected void sensorReadingChanged() {
-        nativeNotifyPlatformSensorReadingChanged(mNativePlatformSensorAndroid);
-    }
-
-    /**
      * Notifies native device::PlatformSensorAndroid when there is an error.
      */
     protected void sensorError() {
         nativeNotifyPlatformSensorError(mNativePlatformSensorAndroid);
     }
 
+    /**
+     * Updates reading at native device::PlatformSensorAndroid.
+     */
+    protected void updateSensorReading(
+            double timestamp, double value1, double value2, double value3) {
+        nativeUpdatePlatformSensorReading(
+                mNativePlatformSensorAndroid, timestamp, value1, value2, value3);
+    }
+
     @Override
     public void onAccuracyChanged(Sensor sensor, int accuracy) {}
 
     @Override
     public void onSensorChanged(SensorEvent event) {
-        try {
-            mSensorReadingData.mark();
-            // Convert timestamp from nanoseconds to milliseconds.
-            mSensorReadingData.putDouble(event.timestamp * MILLISECONDS_IN_NANOSECOND);
-            fillSensorReadingData(event, mSensorReadingData);
-
-            mSensorReadingData.reset();
-
-            mBuffer.mark();
-            mBuffer.put(mSensorReadingData);
-            mSensorReadingData.reset();
-            mBuffer.reset();
-
-            if (getReportingMode() == ReportingMode.ON_CHANGE) {
-                sensorReadingChanged();
-            }
-        } catch (BufferOverflowException | IllegalStateException e) {
+        if (event.values.length < mReadingCount) {
             sensorError();
             stopSensor();
+            return;
+        }
+
+        double timestamp = event.timestamp * SECONDS_IN_NANOSECOND;
+        switch (event.values.length) {
+            case 1:
+                updateSensorReading(timestamp, event.values[0], 0.0, 0.0);
+                break;
+            case 2:
+                updateSensorReading(timestamp, event.values[0], event.values[1], 0.0);
+                break;
+            default:
+                updateSensorReading(timestamp, event.values[0], event.values[1], event.values[2]);
         }
     }
 
-    private native void nativeNotifyPlatformSensorReadingChanged(long nativePlatformSensorAndroid);
     private native void nativeNotifyPlatformSensorError(long nativePlatformSensorAndroid);
+    private native void nativeUpdatePlatformSensorReading(long nativePlatformSensorAndroid,
+            double timestamp, double value1, double value2, double value3);
 }