bluetooth: Implement RSSI and Tx Power on macOS and Android

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>
 
@@ skipping 198 matching lines @@
     // authorized. The delegate should decide whether the user should confirm
     // or not, then call ConfirmPairing() on the device to confirm the pairing
     // (whether by user action or by default), RejectPairing() on the device to
     // reject or CancelPairing() on the device to cancel authorization for
     // any other reason.
     virtual void AuthorizePairing(BluetoothDevice* device) = 0;
   };
 
   virtual ~BluetoothDevice();
 
+  static int8_t ClampPower(int power);

[Jeffrey Yasskin, 2016/08/24 04:32:02]

Comment what this does.

[ortuno, 2016/08/24 21:29:09]

Done.

+
   // Returns the Bluetooth class of the device, used by GetDeviceType()
   // and metrics logging,
   virtual uint32_t GetBluetoothClass() const = 0;
 
 #if defined(OS_CHROMEOS) || defined(OS_LINUX)
   // Returns the transport type of the device. Some devices only support one
   // of BR/EDR or LE, and some support both.
   virtual BluetoothTransport GetType() const = 0;
 #endif
 
@@ skipping 95 matching lines @@
   // 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;
 
   // The received signal strength, in dBm. This field is avaliable and valid
   // only during discovery.
-  virtual base::Optional<int8_t> GetInquiryRSSI() const = 0;
+  virtual base::Optional<int8_t> GetInquiryRSSI() const;

[Jeffrey Yasskin, 2016/08/24 04:32:02]

Now that these have concrete implementations, does it make sense to make them
non-virtual?

[ortuno, 2016/08/24 21:29:09]

BlueZ still has a different implementation. I was also thinking that we might
want to keep it virtual so that we can mock it but I guess we wouldn't need it
since we can just call UpdateAdvertisementData().

[Jeffrey Yasskin, 2016/08/24 22:32:07]

Yep. Maybe a TODO to devirtualize once BlueZ is updated?

[ortuno, 2016/08/25 16:42:34]

Done.

 
   // 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.
-  virtual base::Optional<int8_t> GetInquiryTxPower() const = 0;
+  virtual base::Optional<int8_t> GetInquiryTxPower() 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;
 
@@ skipping 155 matching lines @@
   // Returns the |address| in the canonical format: XX:XX:XX:XX:XX:XX, where
   // each 'X' is a hex digit.  If the input |address| is invalid, returns an
   // empty string.
   static std::string CanonicalizeAddress(const std::string& address);
 
   // Return the timestamp for when this device was last seen.
   base::Time GetLastUpdateTime() const { return last_update_time_; }
 
   // Called by BluetoothAdapter when a new Advertisement is seen for this
   // device. This replaces previously seen Advertisement Data.
-  void UpdateAdvertisementData(UUIDList advertised_uuids,
-                               ServiceDataMap service_data);
+  void UpdateAdvertisementData(int8_t rssi,
+                               UUIDList advertised_uuids,
+                               ServiceDataMap service_data,
+                               const int8_t* tx_power);
 
   // Called by BluetoothAdapter when it stops discoverying.
   void ClearAdvertisementData();
 
   // Return associated BluetoothAdapter.
   BluetoothAdapter* GetAdapter() { return adapter_; }
 
  protected:
   // BluetoothGattConnection is a friend to call Add/RemoveGattConnection.
   friend BluetoothGattConnection;
@@ skipping 83 matching lines @@
   // Callbacks for pending success and error result of CreateGattConnection.
   std::vector<GattConnectionCallback> create_gatt_connection_success_callbacks_;
   std::vector<ConnectErrorCallback> create_gatt_connection_error_callbacks_;
 
   // BluetoothGattConnection objects keeping the GATT connection alive.
   std::set<BluetoothGattConnection*> gatt_connections_;
 
   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_;
+
   // 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_;
 
   // 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_