OLD | NEW |
1 // Copyright 2016 The Chromium Authors. All rights reserved. | 1 // Copyright 2016 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chromeos/components/tether/ble_advertiser.h" | 5 #include "chromeos/components/tether/ble_advertiser.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "chromeos/components/tether/ble_constants.h" | 8 #include "chromeos/components/tether/ble_constants.h" |
9 #include "chromeos/components/tether/local_device_data_provider.h" | 9 #include "chromeos/components/tether/local_device_data_provider.h" |
10 #include "components/cryptauth/proto/cryptauth_api.pb.h" | 10 #include "components/cryptauth/proto/cryptauth_api.pb.h" |
11 #include "components/cryptauth/remote_beacon_seed_fetcher.h" | 11 #include "components/cryptauth/remote_beacon_seed_fetcher.h" |
12 #include "components/proximity_auth/logging/logging.h" | 12 #include "components/proximity_auth/logging/logging.h" |
13 #include "device/bluetooth/bluetooth_advertisement.h" | 13 #include "device/bluetooth/bluetooth_advertisement.h" |
14 | 14 |
15 namespace chromeos { | 15 namespace chromeos { |
16 | 16 |
17 namespace tether { | 17 namespace tether { |
18 | 18 |
19 namespace { | 19 namespace { |
20 uint8_t kInvertedConnectionFlag = 0x01; | 20 uint8_t kInvertedConnectionFlag = 0x01; |
21 } // namespace | 21 } // namespace |
22 | 22 |
| 23 void BleAdvertiser::BleAdvertisementUnregisterHandlerImpl:: |
| 24 OnAdvertisementUnregisterSuccess() {} |
| 25 |
| 26 void BleAdvertiser::BleAdvertisementUnregisterHandlerImpl:: |
| 27 OnAdvertisementUnregisterFailure( |
| 28 device::BluetoothAdvertisement::ErrorCode error_code) { |
| 29 PA_LOG(ERROR) << "Error while unregistering advertisement. Error code: " |
| 30 << error_code; |
| 31 } |
| 32 |
23 BleAdvertiser::IndividualAdvertisement::IndividualAdvertisement( | 33 BleAdvertiser::IndividualAdvertisement::IndividualAdvertisement( |
24 scoped_refptr<device::BluetoothAdapter> adapter, | 34 scoped_refptr<device::BluetoothAdapter> adapter, |
25 std::unique_ptr<cryptauth::EidGenerator::DataWithTimestamp> | 35 std::unique_ptr<cryptauth::EidGenerator::DataWithTimestamp> |
26 advertisement_data) | 36 advertisement_data, |
| 37 std::shared_ptr<BleAdvertisementUnregisterHandler> unregister_handler) |
27 : adapter_(adapter), | 38 : adapter_(adapter), |
28 is_initializing_advertising_(false), | 39 is_initializing_advertising_(false), |
29 advertisement_data_(std::move(advertisement_data)), | 40 advertisement_data_(std::move(advertisement_data)), |
| 41 unregister_handler_(unregister_handler), |
30 advertisement_(nullptr), | 42 advertisement_(nullptr), |
31 weak_ptr_factory_(this) { | 43 weak_ptr_factory_(this) { |
32 adapter_->AddObserver(this); | 44 adapter_->AddObserver(this); |
33 AdvertiseIfPossible(); | 45 AdvertiseIfPossible(); |
34 } | 46 } |
35 | 47 |
36 BleAdvertiser::IndividualAdvertisement::~IndividualAdvertisement() { | 48 BleAdvertiser::IndividualAdvertisement::~IndividualAdvertisement() { |
| 49 if (advertisement_) { |
| 50 advertisement_->Unregister( |
| 51 base::Bind(&BleAdvertisementUnregisterHandler:: |
| 52 OnAdvertisementUnregisterSuccess, |
| 53 base::Unretained(unregister_handler_.get())), |
| 54 base::Bind(&BleAdvertisementUnregisterHandler:: |
| 55 OnAdvertisementUnregisterFailure, |
| 56 base::Unretained(unregister_handler_.get()))); |
| 57 } |
| 58 |
37 adapter_->RemoveObserver(this); | 59 adapter_->RemoveObserver(this); |
38 } | 60 } |
39 | 61 |
40 void BleAdvertiser::IndividualAdvertisement::AdapterPoweredChanged( | 62 void BleAdvertiser::IndividualAdvertisement::AdapterPoweredChanged( |
41 device::BluetoothAdapter* adapter, | 63 device::BluetoothAdapter* adapter, |
42 bool powered) { | 64 bool powered) { |
43 DCHECK(adapter_.get() == adapter); | 65 DCHECK(adapter_.get() == adapter); |
44 AdvertiseIfPossible(); | 66 AdvertiseIfPossible(); |
45 } | 67 } |
46 | 68 |
(...skipping 81 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
128 ss << static_cast<int>(advertisement_data_->data.data()[i]); | 150 ss << static_cast<int>(advertisement_data_->data.data()[i]); |
129 } | 151 } |
130 | 152 |
131 return ss.str(); | 153 return ss.str(); |
132 } | 154 } |
133 | 155 |
134 BleAdvertiser::BleAdvertiser( | 156 BleAdvertiser::BleAdvertiser( |
135 scoped_refptr<device::BluetoothAdapter> adapter, | 157 scoped_refptr<device::BluetoothAdapter> adapter, |
136 const LocalDeviceDataProvider* local_device_data_provider, | 158 const LocalDeviceDataProvider* local_device_data_provider, |
137 const cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher) | 159 const cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher) |
138 : BleAdvertiser(adapter, | 160 : BleAdvertiser( |
139 cryptauth::EidGenerator::GetInstance(), | 161 adapter, |
140 remote_beacon_seed_fetcher, | 162 base::WrapUnique(new BleAdvertisementUnregisterHandlerImpl()), |
141 local_device_data_provider) {} | 163 cryptauth::EidGenerator::GetInstance(), |
| 164 remote_beacon_seed_fetcher, |
| 165 local_device_data_provider) {} |
142 | 166 |
143 BleAdvertiser::~BleAdvertiser() {} | 167 BleAdvertiser::~BleAdvertiser() {} |
144 | 168 |
145 BleAdvertiser::BleAdvertiser( | 169 BleAdvertiser::BleAdvertiser( |
146 scoped_refptr<device::BluetoothAdapter> adapter, | 170 scoped_refptr<device::BluetoothAdapter> adapter, |
| 171 std::unique_ptr<BleAdvertisementUnregisterHandler> unregister_handler, |
147 const cryptauth::EidGenerator* eid_generator, | 172 const cryptauth::EidGenerator* eid_generator, |
148 const cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher, | 173 const cryptauth::RemoteBeaconSeedFetcher* remote_beacon_seed_fetcher, |
149 const LocalDeviceDataProvider* local_device_data_provider) | 174 const LocalDeviceDataProvider* local_device_data_provider) |
150 : adapter_(adapter), | 175 : adapter_(adapter), |
| 176 unregister_handler_(std::move(unregister_handler)), |
151 eid_generator_(eid_generator), | 177 eid_generator_(eid_generator), |
152 remote_beacon_seed_fetcher_(remote_beacon_seed_fetcher), | 178 remote_beacon_seed_fetcher_(remote_beacon_seed_fetcher), |
153 local_device_data_provider_(local_device_data_provider) {} | 179 local_device_data_provider_(local_device_data_provider) {} |
154 | 180 |
155 bool BleAdvertiser::StartAdvertisingToDevice( | 181 bool BleAdvertiser::StartAdvertisingToDevice( |
156 const cryptauth::RemoteDevice& remote_device) { | 182 const cryptauth::RemoteDevice& remote_device) { |
157 if (device_id_to_advertisement_map_.size() >= kMaxConcurrentAdvertisements) { | 183 if (device_id_to_advertisement_map_.size() >= kMaxConcurrentAdvertisements) { |
158 PA_LOG(ERROR) << "Attempted to register a device when the maximum number " | 184 PA_LOG(ERROR) << "Attempted to register a device when the maximum number " |
159 << "of devices have already been registered."; | 185 << "of devices have already been registered."; |
160 return false; | 186 return false; |
(...skipping 29 matching lines...) Expand all Loading... |
190 eid_generator_->GenerateAdvertisement(local_device_public_key, | 216 eid_generator_->GenerateAdvertisement(local_device_public_key, |
191 remote_beacon_seeds); | 217 remote_beacon_seeds); |
192 if (!advertisement) { | 218 if (!advertisement) { |
193 PA_LOG(WARNING) << "Error generating advertisement for device with ID " | 219 PA_LOG(WARNING) << "Error generating advertisement for device with ID " |
194 << remote_device.GetTruncatedDeviceIdForLogs() << ". " | 220 << remote_device.GetTruncatedDeviceIdForLogs() << ". " |
195 << "Cannot advertise."; | 221 << "Cannot advertise."; |
196 return false; | 222 return false; |
197 } | 223 } |
198 | 224 |
199 device_id_to_advertisement_map_[remote_device.GetDeviceId()] = | 225 device_id_to_advertisement_map_[remote_device.GetDeviceId()] = |
200 make_scoped_refptr( | 226 make_scoped_refptr(new IndividualAdvertisement( |
201 new IndividualAdvertisement(adapter_, std::move(advertisement))); | 227 adapter_, std::move(advertisement), unregister_handler_)); |
202 return true; | 228 return true; |
203 } | 229 } |
204 | 230 |
205 bool BleAdvertiser::StopAdvertisingToDevice( | 231 bool BleAdvertiser::StopAdvertisingToDevice( |
206 const cryptauth::RemoteDevice& remote_device) { | 232 const cryptauth::RemoteDevice& remote_device) { |
207 return device_id_to_advertisement_map_.erase(remote_device.GetDeviceId()) > 0; | 233 return device_id_to_advertisement_map_.erase(remote_device.GetDeviceId()) > 0; |
208 } | 234 } |
209 | 235 |
210 } // namespace tether | 236 } // namespace tether |
211 | 237 |
212 } // namespace chromeos | 238 } // namespace chromeos |
OLD | NEW |