device/bluetooth/bluetooth_remote_gatt_characteristic_chromeos.h

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef DEVICE_BLUETOOTH_BLUETOOTH_REMOTE_GATT_CHARACTERISTIC_CHROMEOS_H_
   6 #define DEVICE_BLUETOOTH_BLUETOOTH_REMOTE_GATT_CHARACTERISTIC_CHROMEOS_H_
   7
   8 #include <map>
   9 #include <queue>
  10 #include <string>
  11 #include <utility>
  12 #include <vector>
  13
  14 #include "base/memory/weak_ptr.h"
  15 #include "chromeos/dbus/bluetooth_gatt_descriptor_client.h"
  16 #include "dbus/object_path.h"
  17 #include "device/bluetooth/bluetooth_gatt_characteristic.h"
  18 #include "device/bluetooth/bluetooth_uuid.h"
  19
  20 namespace device {
  21
  22 class BluetoothGattDescriptor;
  23 class BluetoothGattService;
  24
  25 }  // namespace device
  26
  27 namespace chromeos {
  28
  29 class BluetoothRemoteGattDescriptorChromeOS;
  30 class BluetoothRemoteGattServiceChromeOS;
  31
  32 // The BluetoothRemoteGattCharacteristicChromeOS class implements
  33 // BluetoothGattCharacteristic for remote GATT characteristics on the Chrome OS
  34 // platform.
  35 class BluetoothRemoteGattCharacteristicChromeOS
  36     : public device::BluetoothGattCharacteristic,
  37       public BluetoothGattDescriptorClient::Observer {
  38  public:
  39   // device::BluetoothGattCharacteristic overrides.
  40   std::string GetIdentifier() const override;
  41   device::BluetoothUUID GetUUID() const override;
  42   bool IsLocal() const override;
  43   const std::vector<uint8>& GetValue() const override;
  44   device::BluetoothGattService* GetService() const override;
  45   Properties GetProperties() const override;
  46   Permissions GetPermissions() const override;
  47   bool IsNotifying() const override;
  48   std::vector<device::BluetoothGattDescriptor*> GetDescriptors() const override;
  49   device::BluetoothGattDescriptor* GetDescriptor(
  50       const std::string& identifier) const override;
  51   bool AddDescriptor(device::BluetoothGattDescriptor* descriptor) override;
  52   bool UpdateValue(const std::vector<uint8>& value) override;
  53   void ReadRemoteCharacteristic(const ValueCallback& callback,
  54                                 const ErrorCallback& error_callback) override;
  55   void WriteRemoteCharacteristic(const std::vector<uint8>& new_value,
  56                                  const base::Closure& callback,
  57                                  const ErrorCallback& error_callback) override;
  58   void StartNotifySession(const NotifySessionCallback& callback,
  59                           const ErrorCallback& error_callback) override;
  60
  61   // Removes one value update session and invokes |callback| on completion. This
  62   // decrements the session reference count by 1 and if the number reaches 0,
  63   // makes a call to the subsystem to stop notifications from this
  64   // characteristic.
  65   void RemoveNotifySession(const base::Closure& callback);
  66
  67   // Object path of the underlying D-Bus characteristic.
  68   const dbus::ObjectPath& object_path() const { return object_path_; }
  69
  70  private:
  71   friend class BluetoothRemoteGattServiceChromeOS;
  72
  73   typedef std::pair<NotifySessionCallback, ErrorCallback>
  74       PendingStartNotifyCall;
  75
  76   BluetoothRemoteGattCharacteristicChromeOS(
  77       BluetoothRemoteGattServiceChromeOS* service,
  78       const dbus::ObjectPath& object_path);
  79   ~BluetoothRemoteGattCharacteristicChromeOS() override;
  80
  81   // BluetoothGattDescriptorClient::Observer overrides.
  82   void GattDescriptorAdded(const dbus::ObjectPath& object_path) override;
  83   void GattDescriptorRemoved(const dbus::ObjectPath& object_path) override;
  84   void GattDescriptorPropertyChanged(const dbus::ObjectPath& object_path,
  85                                      const std::string& property_name) override;
  86
  87   // Called by dbus:: on unsuccessful completion of a request to read or write
  88   // the characteristic value.
  89   void OnError(const ErrorCallback& error_callback,
  90                const std::string& error_name,
  91                const std::string& error_message);
  92
  93   // Called by dbus:: on successful completion of a request to start
  94   // notifications.
  95   void OnStartNotifySuccess(const NotifySessionCallback& callback);
  96
  97   // Called by dbus:: on unsuccessful completion of a request to start
  98   // notifications.
  99   void OnStartNotifyError(const ErrorCallback& error_callback,
 100                           const std::string& error_name,
 101                           const std::string& error_message);
 102
 103   // Called by dbus:: on successful completion of a request to stop
 104   // notifications.
 105   void OnStopNotifySuccess(const base::Closure& callback);
 106
 107   // Called by dbus:: on unsuccessful completion of a request to stop
 108   // notifications.
 109   void OnStopNotifyError(const base::Closure& callback,
 110                          const std::string& error_name,
 111                          const std::string& error_message);
 112
 113   // Calls StartNotifySession for each queued request.
 114   void ProcessStartNotifyQueue();
 115
 116   // Object path of the D-Bus characteristic object.
 117   dbus::ObjectPath object_path_;
 118
 119   // The GATT service this GATT characteristic belongs to.
 120   BluetoothRemoteGattServiceChromeOS* service_;
 121
 122   // The total number of currently active value update sessions.
 123   size_t num_notify_sessions_;
 124
 125   // Calls to StartNotifySession that are pending. This can happen during the
 126   // first remote call to start notifications.
 127   std::queue<PendingStartNotifyCall> pending_start_notify_calls_;
 128
 129   // True, if a Start or Stop notify call to bluetoothd is currently pending.
 130   bool notify_call_pending_;
 131
 132   // Mapping from GATT descriptor object paths to descriptor objects owned by
 133   // this characteristic. Since the Chrome OS implementation uses object paths
 134   // as unique identifiers, we also use this mapping to return descriptors by
 135   // identifier.
 136   typedef std::map<dbus::ObjectPath, BluetoothRemoteGattDescriptorChromeOS*>
 137       DescriptorMap;
 138   DescriptorMap descriptors_;
 139
 140   // Note: This should remain the last member so it'll be destroyed and
 141   // invalidate its weak pointers before any other members are destroyed.
 142   base::WeakPtrFactory<BluetoothRemoteGattCharacteristicChromeOS>
 143       weak_ptr_factory_;
 144
 145   DISALLOW_COPY_AND_ASSIGN(BluetoothRemoteGattCharacteristicChromeOS);
 146 };
 147
 148 }  // namespace chromeos
 149
 150 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_REMOTE_GATT_CHARACTERISTIC_CHROMEOS_H_