device/bluetooth: Update characteristic value D-Bus bindings.

chromeos/dbus/fake_bluetooth_gatt_characteristic_client.cc

 // 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.
 
 #include "chromeos/dbus/fake_bluetooth_gatt_characteristic_client.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
 #include "base/rand_util.h"
 #include "base/time/time.h"
@@ skipping 33 matching lines @@
           callback) {
 }
 
 FakeBluetoothGattCharacteristicClient::Properties::~Properties() {
 }
 
 void FakeBluetoothGattCharacteristicClient::Properties::Get(
     dbus::PropertyBase* property,
     dbus::PropertySet::GetCallback callback) {
   VLOG(1) << "Get " << property->name();
-
-  // TODO(armansito): Return success or failure here based on characteristic
-  // read permission.
   callback.Run(true);
 }
 
 void FakeBluetoothGattCharacteristicClient::Properties::GetAll() {
   VLOG(1) << "GetAll";
 }
 
 void FakeBluetoothGattCharacteristicClient::Properties::Set(
     dbus::PropertyBase* property,
     dbus::PropertySet::SetCallback callback) {
   VLOG(1) << "Set " << property->name();
-  if (property->name() != value.name()) {
-    callback.Run(false);
-    return;
-  }
-
-  // Allow writing to only certain characteristics that are defined with the
-  // write permission.
-  bool write = false;
-  for (std::vector<std::string>::const_iterator iter = flags.value().begin();
-       iter != flags.value().end();
-       ++iter) {
-    if (*iter == bluetooth_gatt_characteristic::kFlagWrite ||
-        *iter == bluetooth_gatt_characteristic::kFlagWriteWithoutResponse ||
-        *iter ==
-            bluetooth_gatt_characteristic::kFlagAuthenticatedSignedWrites ||
-        *iter == bluetooth_gatt_characteristic::kFlagReliableWrite) {
-      write = true;
-      break;
-    }
-  }
-
-  if (!write) {
-    callback.Run(false);
-    return;
-  }
-
-  callback.Run(true);
-  property->ReplaceValueWithSetValue();
+  callback.Run(false);
 }
 
 FakeBluetoothGattCharacteristicClient::FakeBluetoothGattCharacteristicClient()
     : heart_rate_visible_(false),
       calories_burned_(0),
       weak_ptr_factory_(this) {
 }
 
 FakeBluetoothGattCharacteristicClient::
     ~FakeBluetoothGattCharacteristicClient() {
@@ skipping 32 matching lines @@
     DCHECK(body_sensor_location_properties_.get());
     return body_sensor_location_properties_.get();
   }
   if (object_path.value() == heart_rate_control_point_path_) {
     DCHECK(heart_rate_control_point_properties_.get());
     return heart_rate_control_point_properties_.get();
   }
   return NULL;
 }
 
+void FakeBluetoothGattCharacteristicClient::ReadValue(
+    const dbus::ObjectPath& object_path,
+    const ValueCallback& callback,
+    const ErrorCallback& error_callback) {
+  if (!IsHeartRateVisible()) {
+    error_callback.Run(kUnknownCharacteristicError, "");
+    return;
+  }
+
+  if (object_path.value() == heart_rate_measurement_path_ ||
+      object_path.value() == heart_rate_control_point_path_) {
+    error_callback.Run("org.bluez.Error.ReadNotPermitted",
+                       "Reads of this value are not allowed");
+    return;
+  }
+
+  if (object_path.value() != body_sensor_location_path_) {
+    error_callback.Run(kUnknownCharacteristicError, "");
+    return;
+  }
+
+  std::vector<uint8> value;
+  value.push_back(0x06);  // Location is "foot".
+  callback.Run(value);
+}
+
+void FakeBluetoothGattCharacteristicClient::WriteValue(
+    const dbus::ObjectPath& object_path,
+    const std::vector<uint8>& value,
+    const base::Closure& callback,
+    const ErrorCallback& error_callback) {
+  if (!IsHeartRateVisible()) {
+    error_callback.Run(kUnknownCharacteristicError, "");
+    return;
+  }
+
+  if (object_path.value() != heart_rate_control_point_path_) {
+    error_callback.Run("org.bluez.Error.WriteNotPermitted",
+                       "Writes of this value are not allowed");
+    return;
+  }
+
+  DCHECK(heart_rate_control_point_properties_.get());
+  if (value.size() != 1 || value[0] > 1) {
+    error_callback.Run("org.bluez.Error.Failed",
+                       "Invalid value given for write");
+    return;
+  }
+
+  if (value[0] == 1)
+    calories_burned_ = 0;
+
+  callback.Run();
+}
+
 void FakeBluetoothGattCharacteristicClient::ExposeHeartRateCharacteristics(
     const dbus::ObjectPath& service_path) {
   if (IsHeartRateVisible()) {
     VLOG(2) << "Fake Heart Rate characteristics are already visible.";
     return;
   }
 
   VLOG(2) << "Exposing fake Heart Rate characteristics.";
 
   std::vector<std::string> flags;
 
   // ==== Heart Rate Measurement Characteristic ====
   heart_rate_measurement_path_ =
       service_path.value() + "/" + kHeartRateMeasurementPathComponent;
   heart_rate_measurement_properties_.reset(new Properties(base::Bind(
       &FakeBluetoothGattCharacteristicClient::OnPropertyChanged,
       weak_ptr_factory_.GetWeakPtr(),
       dbus::ObjectPath(heart_rate_measurement_path_))));
   heart_rate_measurement_properties_->uuid.ReplaceValue(
       kHeartRateMeasurementUUID);
   heart_rate_measurement_properties_->service.ReplaceValue(service_path);
   flags.push_back(bluetooth_gatt_characteristic::kFlagNotify);
   heart_rate_measurement_properties_->flags.ReplaceValue(flags);
 
-  std::vector<uint8> measurement_value = GetHeartRateMeasurementValue();
-  heart_rate_measurement_properties_->value.ReplaceValue(measurement_value);
-
   // ==== Body Sensor Location Characteristic ====
   body_sensor_location_path_ =
       service_path.value() + "/" + kBodySensorLocationPathComponent;
   body_sensor_location_properties_.reset(new Properties(base::Bind(
       &FakeBluetoothGattCharacteristicClient::OnPropertyChanged,
       weak_ptr_factory_.GetWeakPtr(),
       dbus::ObjectPath(body_sensor_location_path_))));
   body_sensor_location_properties_->uuid.ReplaceValue(kBodySensorLocationUUID);
   body_sensor_location_properties_->service.ReplaceValue(service_path);
   flags.clear();
   flags.push_back(bluetooth_gatt_characteristic::kFlagRead);
   body_sensor_location_properties_->flags.ReplaceValue(flags);
 
-  // The sensor is in the "Other" location.
-  std::vector<uint8> body_sensor_location_value;
-  body_sensor_location_value.push_back(0);
-  body_sensor_location_properties_->value.ReplaceValue(
-      body_sensor_location_value);
-
   // ==== Heart Rate Control Point Characteristic ====
   heart_rate_control_point_path_ =
       service_path.value() + "/" + kHeartRateControlPointPathComponent;
   heart_rate_control_point_properties_.reset(new Properties(base::Bind(
       &FakeBluetoothGattCharacteristicClient::OnPropertyChanged,
       weak_ptr_factory_.GetWeakPtr(),
       dbus::ObjectPath(heart_rate_control_point_path_))));
   heart_rate_control_point_properties_->uuid.ReplaceValue(
       kHeartRateControlPointUUID);
   heart_rate_control_point_properties_->service.ReplaceValue(service_path);
   flags.clear();
   flags.push_back(bluetooth_gatt_characteristic::kFlagWrite);
   heart_rate_control_point_properties_->flags.ReplaceValue(flags);
 
-  // Set the initial value to 0. Whenever this gets set to 1, we will reset the
-  // total calories burned and change the value back to 0.
-  std::vector<uint8> heart_rate_control_point_value;
-  heart_rate_control_point_value.push_back(0);
-  heart_rate_control_point_properties_->value.ReplaceValue(
-      heart_rate_control_point_value);
-
   heart_rate_visible_ = true;
 
   NotifyCharacteristicAdded(dbus::ObjectPath(heart_rate_measurement_path_));
   NotifyCharacteristicAdded(dbus::ObjectPath(body_sensor_location_path_));
   NotifyCharacteristicAdded(dbus::ObjectPath(heart_rate_control_point_path_));
 
   // Set up notifications for heart rate measurement.
   // TODO(armansito): Do this based on the value of the "client characteristic
   // configuration" descriptor. Since it's still unclear how descriptors will
   // be handled by BlueZ, automatically set up notifications for now.
@@ skipping 54 matching lines @@
 
 void FakeBluetoothGattCharacteristicClient::OnPropertyChanged(
     const dbus::ObjectPath& object_path,
     const std::string& property_name) {
   VLOG(2) << "Characteristic property changed: " << object_path.value()
           << ": " << property_name;
 
   FOR_EACH_OBSERVER(BluetoothGattCharacteristicClient::Observer, observers_,
                     GattCharacteristicPropertyChanged(
                         object_path, property_name));
-
-  // If the heart rate control point was set, reset the calories burned.
-  if (object_path.value() != heart_rate_control_point_path_)
-    return;
-  DCHECK(heart_rate_control_point_properties_.get());
-  dbus::Property<std::vector<uint8> >* value_prop =
-      &heart_rate_control_point_properties_->value;
-  if (property_name != value_prop->name())
-    return;
-
-  std::vector<uint8> value = value_prop->value();
-  DCHECK(value.size() == 1);
-  if (value[0] == 0)
-    return;
-
-  DCHECK(value[0] == 1);
-  calories_burned_ = 0;
-  value[0] = 0;
-  value_prop->ReplaceValue(value);
 }
 
 void FakeBluetoothGattCharacteristicClient::NotifyCharacteristicAdded(
     const dbus::ObjectPath& object_path) {
   VLOG(2) << "GATT characteristic added: " << object_path.value();
   FOR_EACH_OBSERVER(BluetoothGattCharacteristicClient::Observer, observers_,
                     GattCharacteristicAdded(object_path));
 }
 
 void FakeBluetoothGattCharacteristicClient::NotifyCharacteristicRemoved(
     const dbus::ObjectPath& object_path) {
   VLOG(2) << "GATT characteristic removed: " << object_path.value();
   FOR_EACH_OBSERVER(BluetoothGattCharacteristicClient::Observer, observers_,
                     GattCharacteristicRemoved(object_path));
 }
 
 void FakeBluetoothGattCharacteristicClient::
     ScheduleHeartRateMeasurementValueChange() {
   if (!IsHeartRateVisible())
     return;
   VLOG(2) << "Updating heart rate value.";
   std::vector<uint8> measurement = GetHeartRateMeasurementValue();
-  heart_rate_measurement_properties_->value.ReplaceValue(measurement);
+
+  FOR_EACH_OBSERVER(
+      BluetoothGattCharacteristicClient::Observer,
+      observers_,
+      GattCharacteristicValueUpdated(
+          dbus::ObjectPath(heart_rate_measurement_path_), measurement));
 
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeBluetoothGattCharacteristicClient::
                      ScheduleHeartRateMeasurementValueChange,
                  weak_ptr_factory_.GetWeakPtr()),
                  base::TimeDelta::FromMilliseconds(
                      kHeartRateMeasurementNotificationIntervalMs));
 }
 
@@ skipping 43 matching lines @@
   DCHECK(heart_rate_visible_ != heart_rate_measurement_path_.empty());
   DCHECK(heart_rate_visible_ != body_sensor_location_path_.empty());
   DCHECK(heart_rate_visible_ != heart_rate_control_point_path_.empty());
   DCHECK(heart_rate_visible_ == !!heart_rate_measurement_properties_.get());
   DCHECK(heart_rate_visible_ == !!body_sensor_location_properties_.get());
   DCHECK(heart_rate_visible_ == !!heart_rate_control_point_properties_.get());
   return heart_rate_visible_;
 }
 
 }  // namespace chromeos