Implement Android shared memory data fetcher for Device Motion.

content/browser/device_orientation/data_fetcher_impl_android.cc

 // Copyright (c) 2012 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.
 
 #include "content/browser/device_orientation/data_fetcher_impl_android.h"
 
 #include "base/android/jni_android.h"
 #include "base/logging.h"
 #include "content/browser/device_orientation/orientation.h"
 #include "jni/DeviceMotionAndOrientation_jni.h"
 
 using base::android::AttachCurrentThread;
 
 namespace content {
 
 namespace {
 
 // This should match ProviderImpl::kDesiredSamplingIntervalMs.
 // TODO(husky): Make that constant public so we can use it directly.
 const int kPeriodInMilliseconds = 100;
 
 }  // namespace
 
-DataFetcherImplAndroid::DataFetcherImplAndroid() {
+DataFetcherImplAndroid::DataFetcherImplAndroid()
+    : device_motion_buffer_(0),

[bulach, 2013/07/04 08:23:36]

nit: s/0/NULL/

[timvolodine, 2013/07/04 12:02:52]

Done.

+      is_buffer_ready_(false) {
   device_orientation_.Reset(
       Java_DeviceMotionAndOrientation_getInstance(AttachCurrentThread()));
 }
 
 void DataFetcherImplAndroid::Init(JNIEnv* env) {

[bulach, 2013/07/04 08:23:36]

nit: not related to your patch, but rather than Init, this should be called
"Register"..

[timvolodine, 2013/07/04 12:02:52]

Done.

   bool result = RegisterNativesImpl(env);
   DCHECK(result);
 }
 
-// TODO(timvolodine): Modify this method to be able to distinguish
-// device motion from orientation.
+DataFetcherImplAndroid* DataFetcherImplAndroid::instance() {
+  CR_DEFINE_STATIC_LOCAL(DataFetcherImplAndroid, s_data_fetcher, ());
+  return &s_data_fetcher;
+}
+
+// TODO(timvolodine): Remove this method once orientation also switches to
+// shared memory implementation.
 DataFetcher* DataFetcherImplAndroid::Create() {
-  scoped_ptr<DataFetcherImplAndroid> fetcher(new DataFetcherImplAndroid);
+  DataFetcherImplAndroid* fetcher = DataFetcherImplAndroid::instance();
   if (fetcher->Start(DeviceData::kTypeOrientation, kPeriodInMilliseconds))
-    return fetcher.release();
+    return fetcher;
 
-  LOG(ERROR) << "DataFetcherImplAndroid::Start failed!";
+  DVLOG(2) << "DataFetcherImplAndroid::Start failed!";
   return NULL;
 }
 
 DataFetcherImplAndroid::~DataFetcherImplAndroid() {
   // TODO(timvolodine): Support device motion as well. Only stop
   // the active event type(s).

[bulach, 2013/07/04 08:23:36]

the first part of the TODO seem done :)

[timvolodine, 2013/07/04 12:02:52]

Done.

   Stop(DeviceData::kTypeOrientation);
+  Stop(DeviceData::kTypeMotion);
 }
 
 const DeviceData* DataFetcherImplAndroid::GetDeviceData(
     DeviceData::Type type) {
   if (type != DeviceData::kTypeOrientation)
     return NULL;
   return GetOrientation();
 }
 
 const Orientation* DataFetcherImplAndroid::GetOrientation() {
@@ skipping 16 matching lines @@
   Orientation* orientation = new Orientation();
   orientation->set_alpha(alpha);
   orientation->set_beta(beta);
   orientation->set_gamma(gamma);
   orientation->set_absolute(true);
   next_orientation_ = orientation;
 }
 
 void DataFetcherImplAndroid::GotAcceleration(
     JNIEnv*, jobject, double x, double y, double z) {
-  NOTIMPLEMENTED();
+  device_motion_buffer_->seqlock.WriteBegin();
+  device_motion_buffer_->data.accelerationX = x;
+  device_motion_buffer_->data.hasAccelerationX = true;
+  device_motion_buffer_->data.accelerationY = y;
+  device_motion_buffer_->data.hasAccelerationY = true;
+  device_motion_buffer_->data.accelerationZ = z;
+  device_motion_buffer_->data.hasAccelerationZ = true;
+  device_motion_buffer_->seqlock.WriteEnd();
+
+  if (!is_buffer_ready_) {
+    receivedMotionData[0] = 1;
+    CheckBufferReadyToRead();
+  }
 }
 
 void DataFetcherImplAndroid::GotAccelerationIncludingGravity(
     JNIEnv*, jobject, double x, double y, double z) {
-  NOTIMPLEMENTED();
+  device_motion_buffer_->seqlock.WriteBegin();
+  device_motion_buffer_->data.accelerationIncludingGravityX = x;
+  device_motion_buffer_->data.hasAccelerationIncludingGravityX = true;
+  device_motion_buffer_->data.accelerationIncludingGravityY = y;
+  device_motion_buffer_->data.hasAccelerationIncludingGravityY = true;
+  device_motion_buffer_->data.accelerationIncludingGravityZ = z;
+  device_motion_buffer_->data.hasAccelerationIncludingGravityZ = true;
+  device_motion_buffer_->seqlock.WriteEnd();
+
+  if (!is_buffer_ready_) {
+    receivedMotionData[1] = 1;
+    CheckBufferReadyToRead();
+  }
 }
 
 void DataFetcherImplAndroid::GotRotationRate(
     JNIEnv*, jobject, double alpha, double beta, double gamma) {
-  NOTIMPLEMENTED();
+  device_motion_buffer_->seqlock.WriteBegin();
+  device_motion_buffer_->data.rotationRateAlpha = alpha;
+  device_motion_buffer_->data.hasRotationRateAlpha = true;
+  device_motion_buffer_->data.rotationRateBeta = beta;
+  device_motion_buffer_->data.hasRotationRateBeta = true;
+  device_motion_buffer_->data.rotationRateGamma = gamma;
+  device_motion_buffer_->data.hasRotationRateGamma = true;
+  device_motion_buffer_->seqlock.WriteEnd();
+
+  if (!is_buffer_ready_) {
+    receivedMotionData[2] = 1;
+    CheckBufferReadyToRead();
+  }
 }
 
 bool DataFetcherImplAndroid::Start(
     DeviceData::Type event_type, int rate_in_milliseconds) {
   DCHECK(!device_orientation_.is_null());
   return Java_DeviceMotionAndOrientation_start(
       AttachCurrentThread(), device_orientation_.obj(),
       reinterpret_cast<jint>(this), static_cast<jint>(event_type),
       rate_in_milliseconds);
 }
 
 void DataFetcherImplAndroid::Stop(DeviceData::Type event_type) {
   DCHECK(!device_orientation_.is_null());
   Java_DeviceMotionAndOrientation_stop(
       AttachCurrentThread(), device_orientation_.obj(),
       static_cast<jint>(event_type));
 }
 
 int DataFetcherImplAndroid::GetNumberActiveDeviceMotionSensors() {
   DCHECK(!device_orientation_.is_null());
   return Java_DeviceMotionAndOrientation_getNumberActiveDeviceMotionSensors(
       AttachCurrentThread(), device_orientation_.obj());
 }
 
+
+// ----- New shared memory API methods
+
+bool DataFetcherImplAndroid::FetchDeviceMotionDataIntoBuffer() {
+  // This method should not be called because it is a push based fetcher.
+  DCHECK(NeedsPolling());
+  return false;
+}
+
+void DataFetcherImplAndroid::CheckBufferReadyToRead() {
+  if (receivedMotionData[0] + receivedMotionData[1] + receivedMotionData[2] ==
+      number_active_device_motion_sensors_) {
+    device_motion_buffer_->seqlock.WriteBegin();
+    device_motion_buffer_->data.allAvailableSensorsAreActive = true;

[bulach, 2013/07/04 08:23:36]

just checking:
once it has all three datatypes, the buffer will be ready.
then, if it updates only one of them, the "other side" would still consider the
whole set "fresh" ? or should this flag be per sensor?

[timvolodine, 2013/07/04 12:02:52]

This flag is actually intended for the cases where some of the sensors are not
available (i.e. it is possible for allAvailableSensorsAreActive to be true while
no motion data can be provided in which case Blink would eventually receive an
event with null values). So this flag is not related to freshness rather that
the data is in a sense complete and good to read for the other side.

+    device_motion_buffer_->seqlock.WriteEnd();
+    is_buffer_ready_ = true;
+  }
+}
+
+bool DataFetcherImplAndroid::StartFetchingDeviceMotionData(
+    DeviceMotionHardwareBuffer* buffer) {
+  device_motion_buffer_ = buffer;
+  receivedMotionData[0] = receivedMotionData[1] = receivedMotionData[2] = 0;

[bulach, 2013/07/04 08:23:36]

nit:
memset(received_motion_data, 0, sizeof(received_motion_data));

[timvolodine, 2013/07/04 12:02:52]

Done.

+  number_active_device_motion_sensors_ = 0;
+  is_buffer_ready_ = false;
+  bool success = Start(DeviceData::kTypeMotion, kPeriodInMilliseconds);
+
+  // If no motion data can ever be provided, the number of active device motion
+  // sensors will be zero. In that case flag the shared memory buffer
+  // as ready to read, as it will not change anyway.
+  number_active_device_motion_sensors_ = GetNumberActiveDeviceMotionSensors();
+  CheckBufferReadyToRead();
+  return success;
+}
+
+void DataFetcherImplAndroid::StopFetchingDeviceMotionData() {
+  Stop(DeviceData::kTypeMotion);
+  number_active_device_motion_sensors_ = 0;
+  receivedMotionData[0] = receivedMotionData[1] = receivedMotionData[2] = 0;

[bulach, 2013/07/04 08:23:36]

nit: memset

[timvolodine, 2013/07/04 12:02:52]

Done.

+  is_buffer_ready_ = false;
+}
+
 }  // namespace content