arc: bluetooth: Expose missing advertise data.

device/bluetooth/bluetooth_device.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_DEVICE_H_
 #define DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <set>
 #include <string>
+#include <unordered_map>
 #include <unordered_set>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/containers/scoped_ptr_hash_map.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/optional.h"
 #include "base/strings/string16.h"
 #include "base/time/time.h"
@@ skipping 71 matching lines @@
     ERROR_WRITE_NOT_PERMITTED,
     NUM_CONNECT_ERROR_CODES  // Keep as last enum.
   };
 
   typedef std::vector<BluetoothUUID> UUIDList;
   typedef std::unordered_set<BluetoothUUID, BluetoothUUIDHash> UUIDSet;
   typedef std::unordered_map<BluetoothUUID,
                              std::vector<uint8_t>,
                              BluetoothUUIDHash>
       ServiceDataMap;
+  typedef uint16_t ManufacturerId;
+  typedef std::unordered_map<ManufacturerId, std::vector<uint8_t>>
+      ManufacturerDataMap;
+  typedef std::unordered_set<ManufacturerId> ManufacturerIDSet;
 
   // Mapping from the platform-specific GATT service identifiers to
   // BluetoothRemoteGattService objects.
   typedef base::ScopedPtrHashMap<std::string,
                                  std::unique_ptr<BluetoothRemoteGattService>>
       GattServiceMap;
 
   // Interface for negotiating pairing of bluetooth devices.
   class PairingDelegate {
    public:
@@ skipping 197 matching lines @@
 
   // Returns the UUIDs of services for which the device advertises Service Data.
   // Returns an empty set if the adapter is not discovering.
   UUIDSet GetServiceDataUUIDs() const;
 
   // Returns a pointer to the Service Data for Service with |uuid|. Returns
   // nullptr if |uuid| has no Service Data.
   const std::vector<uint8_t>* GetServiceDataForUUID(
       const BluetoothUUID& uuid) const;
 
+  // Returns advertised Manufacturer Data. Keys are 16 bits Manufacturer IDs
+  // followed by its byte array value. Returns an empty map if the device
+  // does not advertise any Manufacturer Data.
+  // Returns cached value if the adapter is not discovering.
+  //
+  // Note: On ChromeOS and Linux, BlueZ persists all manufacturer data meaning
+  // if a device stops advertising manufacturer data for a Manufacturer Id, this
+  // function will still return the cached value for that Id.
+  //
+  // TODO(crbug.com/661814) Support this on platforms that don't use BlueZ.
+  // Only BlueZ supports this now. This method returns an empty map on platforms
+  // that don't use BlueZ.
+  const ManufacturerDataMap& GetManufacturerData() const;
+
+  // Returns the Manufacturer Data IDs of Manufacturers for which the device
+  // advertises Manufacturer Data.
+  // Returns cached value if the adapter is not discovering.
+  ManufacturerIDSet GetManufacturerDataIDs() const;
+
+  // Returns a pointer to the Manufacturer Data for Manufacturer with
+  // |manufacturerID|. Returns nullptr if |manufacturerID| has no Manufacturer
+  // Data. Returns cached value if the adapter is not discovering.
+  const std::vector<uint8_t>* GetManufacturerDataForID(
+      const ManufacturerId manufacturerID) const;
+
   // The received signal strength, in dBm. This field is avaliable and valid
   // only during discovery.
   // TODO(http://crbug.com/580406): Devirtualize once BlueZ sets inquiry_rssi_.
   virtual base::Optional<int8_t> GetInquiryRSSI() const;
 
   // The transmitted power level. This field is avaliable only for LE devices
   // that include this field in AD. It is avaliable and valid only during
   // discovery.
   // TODO(http://crbug.com/580406): Devirtualize once BlueZ sets
   // inquiry_tx_power_.
   virtual base::Optional<int8_t> GetInquiryTxPower() const;
 
+  // Returns Advertising Data Flags.
+  // Returns cached value if the adapter is not discovering.
+  //
+  // TODO(crbug.com/661814) Support this on platforms that don't use BlueZ.
+  // Only Chrome OS supports this now. Upstream BlueZ has this feature
+  // as experimental. This method returns base::nullopt on platforms that don't
+  // support this feature.
+  base::Optional<uint8_t> GetAdvertisingDataFlags() const;
+
   // The ErrorCallback is used for methods that can fail in which case it
   // is called, in the success case the callback is simply not called.
   typedef base::Callback<void()> ErrorCallback;
 
   // The ConnectErrorCallback is used for methods that can fail with an error,
   // passed back as an error code argument to this callback.
   // In the success case this callback is not called.
   typedef base::Callback<void(enum ConnectErrorCode)> ConnectErrorCallback;
 
   typedef base::Callback<void(const ConnectionInfo&)> ConnectionInfoCallback;
@@ skipping 268 matching lines @@
 
   GattServiceMap gatt_services_;
   bool gatt_services_discovery_complete_;
 
   // Received Signal Strength Indicator of the advertisement received.
   base::Optional<int8_t> inquiry_rssi_;
 
   // Tx Power advertised by the device.
   base::Optional<int8_t> inquiry_tx_power_;
 
+  // Advertising Data flags of the device.
+  base::Optional<uint8_t> advertising_data_flags_;
+
   // Class that holds the union of Advertised UUIDs and Service UUIDs.
   DeviceUUIDs device_uuids_;
 
   // Map of BluetoothUUIDs to their advertised Service Data.
   ServiceDataMap service_data_;
 
+  // Map of Manufacturer IDs to their advertised Manufacturer Data.
+  ManufacturerDataMap manufacturer_data_;
+
   // Timestamp for when an advertisement was last seen.
   base::Time last_update_time_;
 
  private:
   // Returns a localized string containing the device's bluetooth address and
   // a device type for display when |name_| is empty.
   base::string16 GetAddressWithLocalizedDeviceTypeName() const;
 };
 
 }  // namespace device
 
 #endif  // DEVICE_BLUETOOTH_BLUETOOTH_DEVICE_H_