BLE GATT service implementation in Chrome for Windows 8 and later

device/bluetooth/bluetooth_task_manager_win.h

 // 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.
 
 #ifndef DEVICE_BLUETOOTH_BLUETOOTH_TASK_MANAGER_WIN_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_TASK_MANAGER_WIN_H_
 
 #include <stdint.h>
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/observer_list.h"
 #include "base/win/scoped_handle.h"
 #include "device/bluetooth/bluetooth_adapter.h"
 #include "device/bluetooth/bluetooth_export.h"
+#include "device/bluetooth/bluetooth_low_energy_win.h"
 
 namespace base {
 
 class SequencedTaskRunner;
 class SequencedWorkerPool;
 
 }  // namespace base
 
 namespace device {
 
@@ skipping 18 matching lines @@
 
   struct DEVICE_BLUETOOTH_EXPORT ServiceRecordState {
     ServiceRecordState();
     ~ServiceRecordState();
     // Properties common to Bluetooth Classic and LE devices.
     std::string name;
     // Properties specific to Bluetooth Classic devices.
     std::vector<uint8_t> sdp_bytes;
     // Properties specific to Bluetooth LE devices.
     BluetoothUUID gatt_uuid;
+    uint16_t gatt_attribute_handle;
+    base::FilePath path;
   };
 
   struct DEVICE_BLUETOOTH_EXPORT DeviceState {
     DeviceState();
     ~DeviceState();
 
     bool is_bluetooth_classic() const { return path.empty(); }
 
     // Properties common to Bluetooth Classic and LE devices.
     std::string address;  // This uniquely identifies the device.
@@ skipping 36 matching lines @@
       scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner);
   void Shutdown();
 
   void PostSetPoweredBluetoothTask(
       bool powered,
       const base::Closure& callback,
       const BluetoothAdapter::ErrorCallback& error_callback);
   void PostStartDiscoveryTask();
   void PostStopDiscoveryTask();
 
+  // Callbacks of asynchronous operations of GATT services, characteristics and
+  // descriptors.
+  typedef base::Callback<void(HRESULT)> HResultCallback;
+  typedef base::Callback<void(PBTH_LE_GATT_SERVICE, uint16_t, HRESULT)>
+      GetGattIncludedServicesCallback;
+  typedef base::Callback<void(PBTH_LE_GATT_CHARACTERISTIC, uint16_t, HRESULT)>
+      GetGattIncludedCharacteristicsCallback;
+  typedef base::Callback<void(PBTH_LE_GATT_CHARACTERISTIC_VALUE, HRESULT)>
+      ReadCharacteristicValueCallback;
+  typedef base::Callback<void(PBTH_LE_GATT_DESCRIPTOR, uint16_t, HRESULT)>
+      GetGattIncludedDescriptorsCallback;
+  typedef base::Callback<void(PBTH_LE_GATT_DESCRIPTOR_VALUE, HRESULT)>
+      ReadDescriptorValueCallback;
+  typedef base::Callback<void(BLUETOOTH_GATT_EVENT_HANDLE, HRESULT)>
+      GattEventRegistrationCallback;
+
+  // Get all included services of a given service. The service is uniquely
+  // identified by its |uuid| and |attribute_handle| on service device
+  // |service_path|. The result is returned asynchronously through |callback|.
+  void PostGetGattIncludedServices(
+      const base::FilePath& service_path,
+      const BluetoothUUID& uuid,
+      uint16_t attribute_handle,
+      const GetGattIncludedServicesCallback& callback);
+
+  // Get all included characteristics of a given service. The service is
+  // uniquely identified by its |uuid| and |attribute_handle| on service device
+  // |service_path|. The result is returned asynchronously through |callback|.
+  void PostGetGattIncludedCharacteristics(
+      const base::FilePath& service_path,
+      const BluetoothUUID& uuid,
+      uint16_t attribute_handle,
+      const GetGattIncludedCharacteristicsCallback& callback);
+
+  // Read the value of a given |characteristic| in service |service_path|. The
+  // result is returned asynchronously through |callback|.
+  void PostReadCharacteristicValue(
+      const base::FilePath& device_path,
+      const PBTH_LE_GATT_CHARACTERISTIC characteristic,
+      const ReadCharacteristicValueCallback& callback);
+
+  // Write the value of a given |characteristic| in service |service_path| with
+  // the |new_value|. The operation result is returned asynchronously through
+  // |callback|.
+  void PostWriteCharacteristicValue(
+      const base::FilePath& service_path,
+      const PBTH_LE_GATT_CHARACTERISTIC characteristic,
+      const std::vector<uint8_t>& new_value,
+      const HResultCallback& callback);
+
+  // Reliable write the value of a given |characteristic| in service
+  // |service_path| with the |new_value|. The operation result is returned
+  // asynchronously through |callback|.
+  void PostReliableWriteCharacteristicValue(
+      const base::FilePath& service_path,
+      const PBTH_LE_GATT_CHARACTERISTIC characteristic,
+      const std::vector<uint8_t>& new_value,
+      const HResultCallback& callback);
+
+  // Get included descriptors of a given |characterisitc| in service
+  // |service_path|. The result is returned asynchronously through |callback|.
+  void PostGetGattIncludedDescriptors(
+      const base::FilePath& service_path,
+      const PBTH_LE_GATT_CHARACTERISTIC characteristic,
+      const GetGattIncludedDescriptorsCallback& callback);
+
+  // Read a given |descriptor| value in service |service_path|. The result is
+  // returned asynchronously through |callback|.
+  void PostReadDescriptorValue(const base::FilePath& service_path,
+                               const PBTH_LE_GATT_DESCRIPTOR descriptor,
+                               const ReadDescriptorValueCallback& callback);
+
+  // Write a given |descriptor| value in service |service_path| with the
+  // |new_value|. The operation result is returned asynchronously through
+  // |callback|.
+  void PostWriteDescriptorValue(const base::FilePath& service_path,
+                                const PBTH_LE_GATT_DESCRIPTOR descriptor,
+                                const std::vector<uint8_t>& new_value,
+                                const HResultCallback& callback);
+
+  // Register a given |characteristic|'s value change notification of a service
+  // |service_path| with |registered_callback|. |context| is the given void
+  // pointer send back to caller through |registered_callback|. The operation
+  // result is returned asynchronously through |callback|.
+  void PostRegisterCharacteristicValueChangedEvent(
+      const base::FilePath& service_path,
+      const PBTH_LE_GATT_CHARACTERISTIC characteristic,
+      const GattEventRegistrationCallback& callback,
+      PFNBLUETOOTH_GATT_EVENT_CALLBACK registered_callback,
+      void* context);
+
+  // Unregister characteristic value change notification. |event_handle| was
+  // returned by PostRegisterCharacteristicValueChangedEvent.
+  void UnregisterCharacteristicValueChangedEvent(
+      BLUETOOTH_GATT_EVENT_HANDLE event_handle);
+
+  BluetoothUUID BluetoothLowEnergyUuidToBluetoothUuid(
+      const BTH_LE_UUID& bth_le_uuid);
+
  private:
   friend class base::RefCountedThreadSafe<BluetoothTaskManagerWin>;
   friend class BluetoothTaskManagerWinTest;
 
   static const int kPollIntervalMs;
 
   virtual ~BluetoothTaskManagerWin();
 
   // Logs Win32 errors occurring during polling on the worker thread. The method
   // may discard messages to avoid logging being too verbose.
   void LogPollingError(const char* message, int win32_error);
 
   // Notify all Observers of updated AdapterState. Should only be called on the
   // UI thread.
   void OnAdapterStateChanged(const AdapterState* state);
   void OnDiscoveryStarted(bool success);
   void OnDiscoveryStopped();
   void OnDevicesPolled(const ScopedVector<DeviceState>* devices);
 
   // Called on BluetoothTaskRunner.
   void StartPolling();
   void PollAdapter();
   void PostAdapterStateToUi();
   void SetPowered(bool powered,
                   const base::Closure& callback,
                   const BluetoothAdapter::ErrorCallback& error_callback);
 
+  // Gatt services related functions.
+  void GetGattIncludedServices(base::FilePath service_path,
+                               BluetoothUUID uuid,
+                               uint16_t attribute_handle,
+                               const GetGattIncludedServicesCallback& callback);
+  void GetGattIncludedCharacteristics(
+      base::FilePath device_path,
+      BluetoothUUID uuid,
+      uint16_t attribute_handle,
+      const GetGattIncludedCharacteristicsCallback& callback);
+  void ReadCharacteristicValue(base::FilePath service_path,
+                               BTH_LE_GATT_CHARACTERISTIC characteristic,
+                               const ReadCharacteristicValueCallback& callback);
+  void WriteCharacteristicValue(base::FilePath device_path,
+                                BTH_LE_GATT_CHARACTERISTIC characteristic,
+                                std::vector<uint8_t> new_value,
+                                const HResultCallback& callback);
+  void ReliableWriteCharacteristicValue(
+      base::FilePath service_path,
+      BTH_LE_GATT_CHARACTERISTIC characteristic,
+      std::vector<uint8_t> new_value,
+      const HResultCallback& callback);
+  void GetGattIncludedDescriptors(
+      base::FilePath service_path,
+      BTH_LE_GATT_CHARACTERISTIC characteristic,
+      const GetGattIncludedDescriptorsCallback& callback);
+  void ReadDescriptorValue(base::FilePath service_path,
+                           BTH_LE_GATT_DESCRIPTOR descriptor,
+                           const ReadDescriptorValueCallback& callback);
+  void WriteDescriptorValue(base::FilePath service_path,
+                            BTH_LE_GATT_DESCRIPTOR descriptor,
+                            std::vector<uint8_t> new_value,
+                            const HResultCallback& callback);
+  void RegisterCharacteristicValueChangedEvent(
+      base::FilePath service_path,
+      BTH_LE_GATT_CHARACTERISTIC characteristic,
+      const GattEventRegistrationCallback& callback,
+      PFNBLUETOOTH_GATT_EVENT_CALLBACK registered_callback,
+      void* context);
+
   // Starts discovery. Once the discovery starts, it issues a discovery inquiry
   // with a short timeout, then issues more inquiries with greater timeout
   // values. The discovery finishes when StopDiscovery() is called or timeout
   // has reached its maximum value.
   void StartDiscovery();
   void StopDiscovery();
 
   // Issues a device inquiry that runs for |timeout_multiplier| * 1.28 seconds.
   // This posts itself again with |timeout_multiplier| + 1 until
   // |timeout_multiplier| reaches the maximum value or stop discovery call is
@@ skipping 35 matching lines @@
   // Returns a Win32 error code.
   int DiscoverClassicDeviceServicesWorker(
       const std::string& device_address,
       const GUID& protocol_uuid,
       bool search_cached_services_only,
       ScopedVector<ServiceRecordState>* service_record_states);
 
   // Discover Bluetooth Low Energy services for the given |device_path|.
   bool DiscoverLowEnergyDeviceServices(
       const base::FilePath& device_path,
+      const std::string device_address,
       ScopedVector<ServiceRecordState>* service_record_states);
 
+  bool BluetoothUUIDToBLEUUIDWin(const BluetoothUUID& uuid,
+                                 BTH_LE_UUID* win_uuid);
+
   // UI task runner reference.
   scoped_refptr<base::SequencedTaskRunner> ui_task_runner_;
 
   scoped_refptr<base::SequencedWorkerPool> worker_pool_;
   scoped_refptr<base::SequencedTaskRunner> bluetooth_task_runner_;
 
   // List of observers interested in event notifications.
   base::ObserverList<Observer> observers_;
 
   // Adapter handle owned by bluetooth task runner.
   base::win::ScopedHandle adapter_handle_;
 
   // indicates whether the adapter is in discovery mode or not.
   bool discovering_;
 
   // Use for discarding too many log messages.
   base::TimeTicks current_logging_batch_ticks_;
   int current_logging_batch_count_;
 
   DISALLOW_COPY_AND_ASSIGN(BluetoothTaskManagerWin);
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_TASK_MANAGER_WIN_H_