Adding Hashed Address to BluetoothLowEnergyDeviceMac

device/bluetooth/bluetooth_low_energy_device_mac.mm

 // Copyright 2015 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 "device/bluetooth/bluetooth_low_energy_device_mac.h"
 
 #import <CoreFoundation/CoreFoundation.h>
 
 #include "base/mac/mac_util.h"
 #include "base/mac/scoped_cftyperef.h"
 #include "base/mac/sdk_forward_declarations.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/sys_string_conversions.h"
 #include "device/bluetooth/bluetooth_adapter_mac.h"
+#include "device/bluetooth/bluetooth_device.h"
 
 using device::BluetoothDevice;
 using device::BluetoothLowEnergyDeviceMac;
 
 namespace {
 
 // Converts a CBUUID to a BluetoothUUID.
 device::BluetoothUUID BluetoothUUIDWithCBUUID(CBUUID* uuid) {
   // UUIDString only available OS X >= 10.8.
   DCHECK(base::mac::IsOSMountainLionOrLater());
   std::string uuid_c_string = base::SysNSStringToUTF8([uuid UUIDString]);
   return device::BluetoothUUID(uuid_c_string);
 }
 
 }  // namespace
 
 BluetoothLowEnergyDeviceMac::BluetoothLowEnergyDeviceMac(
     CBPeripheral* peripheral,
     NSDictionary* advertisementData,
     int rssi) {
   DCHECK(BluetoothAdapterMac::IsLowEnergyAvailable());
+  identifier_ = GetPeripheralIdentifier(peripheral);
+  hash_address_ = GetPeripheralHashAddress(peripheral);
   Update(peripheral, advertisementData, rssi);
 }
 
 BluetoothLowEnergyDeviceMac::~BluetoothLowEnergyDeviceMac() {
 }
 
 void BluetoothLowEnergyDeviceMac::Update(CBPeripheral* peripheral,
                                          NSDictionary* advertisementData,
                                          int rssi) {
   last_update_time_.reset([[NSDate date] retain]);
   peripheral_.reset([peripheral retain]);
   rssi_ = rssi;
   ClearServiceData();
   NSNumber* nbConnectable =
       [advertisementData objectForKey:CBAdvertisementDataIsConnectable];
   connectable_ = [nbConnectable boolValue];
   NSDictionary* serviceData =
       [advertisementData objectForKey:CBAdvertisementDataServiceDataKey];
   for (CBUUID* uuid in serviceData) {
     NSData* data = [serviceData objectForKey:uuid];
     BluetoothUUID serviceUUID = BluetoothUUIDWithCBUUID(uuid);
     SetServiceData(serviceUUID, (const char*)[data bytes], [data length]);
   }
 }
 
 std::string BluetoothLowEnergyDeviceMac::GetIdentifier() const {
-  return GetPeripheralIdentifier(peripheral_);
+  return identifier_;
 }
 
 uint32 BluetoothLowEnergyDeviceMac::GetBluetoothClass() const {
   return 0;
 }
 
 std::string BluetoothLowEnergyDeviceMac::GetAddress() const {
-  return std::string();
+  return hash_address_;
 }
 
 BluetoothDevice::VendorIDSource BluetoothLowEnergyDeviceMac::GetVendorIDSource()
     const {
   return VENDOR_ID_UNKNOWN;
 }
 
 uint16 BluetoothLowEnergyDeviceMac::GetVendorID() const {
   return 0;
 }
 
 uint16 BluetoothLowEnergyDeviceMac::GetProductID() const {
   return 0;
 }
 
 uint16 BluetoothLowEnergyDeviceMac::GetDeviceID() const {
   return 0;
 }
 
 int BluetoothLowEnergyDeviceMac::GetRSSI() const {
   return rssi_;
 }
 
 bool BluetoothLowEnergyDeviceMac::IsPaired() const {
   return false;
 }
 
 bool BluetoothLowEnergyDeviceMac::IsConnected() const {
-  return [peripheral_ isConnected];
+  return (GetPeripheralState() == CBPeripheralStateConnected);
 }
 
 bool BluetoothLowEnergyDeviceMac::IsConnectable() const {
   return connectable_;
 }
 
 bool BluetoothLowEnergyDeviceMac::IsConnecting() const {
   return false;
 }
 
@@ skipping 93 matching lines @@
 }
 
 // static
 std::string BluetoothLowEnergyDeviceMac::GetPeripheralIdentifier(
     CBPeripheral* peripheral) {
   DCHECK(BluetoothAdapterMac::IsLowEnergyAvailable());
   NSUUID* uuid = [peripheral identifier];
   NSString* uuidString = [uuid UUIDString];
   return base::SysNSStringToUTF8(uuidString);
 }
+
+// static
+std::string BluetoothLowEnergyDeviceMac::GetPeripheralHashAddress(
+    CBPeripheral* peripheral) {
+  const size_t kCanonicalAddressNumberOfBytes = 6;
+  char raw[kCanonicalAddressNumberOfBytes];
+  crypto::SHA256HashString(GetPeripheralIdentifier(peripheral), raw,
+                           sizeof(raw));
+  std::string hash = base::HexEncode(raw, sizeof(raw));
+  return BluetoothDevice::CanonicalizeAddress(hash);
+}
+
+CBPeripheralState BluetoothLowEnergyDeviceMac::GetPeripheralState() const {
+  Class peripheral_class = NSClassFromString(@"CBPeripheral");
+  base::scoped_nsobject<NSMethodSignature> signature([[peripheral_class
+      instanceMethodSignatureForSelector:@selector(state)] retain]);
+  base::scoped_nsobject<NSInvocation> invocation(
+      [[NSInvocation invocationWithMethodSignature:signature] retain]);
+  [invocation setTarget:peripheral_];
+  [invocation setSelector:@selector(state)];
+  [invocation invoke];
+  CBPeripheralState state = CBPeripheralStateDisconnected;
+  [invocation getReturnValue:&state];
+  return state;
+}