1 // 2 // Copyright (C) 2015 Google, Inc. 3 // 4 // Licensed under the Apache License, Version 2.0 (the "License"); 5 // you may not use this file except in compliance with the License. 6 // You may obtain a copy of the License at: 7 // 8 // http://www.apache.org/licenses/LICENSE-2.0 9 // 10 // Unless required by applicable law or agreed to in writing, software 11 // distributed under the License is distributed on an "AS IS" BASIS, 12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 // See the License for the specific language governing permissions and 14 // limitations under the License. 15 // 16 17 #include "service/adapter.h" 18 19 #include <atomic> 20 #include <mutex> 21 #include <string> 22 #include <unordered_set> 23 24 #include <base/logging.h> 25 #include <base/observer_list.h> 26 27 #include "service/common/bluetooth/util/atomic_string.h" 28 #include "service/gatt_client.h" 29 #include "service/gatt_server.h" 30 #include "service/hal/bluetooth_interface.h" 31 #include "service/logging_helpers.h" 32 #include "service/low_energy_client.h" 33 34 using std::lock_guard; 35 using std::mutex; 36 37 namespace bluetooth { 38 39 // static 40 const char Adapter::kDefaultAddress[] = "00:00:00:00:00:00"; 41 // static 42 const char Adapter::kDefaultName[] = "not-initialized"; 43 44 // TODO(armansito): The following constants come straight from 45 // packages/apps/Bluetooth/src/c/a/b/btservice/AdapterService.java. It would be 46 // nice to know if there were a way to obtain these values from the stack 47 // instead of hardcoding them here. 48 49 // The minimum number of advertising instances required for multi-advertisement 50 // support. 51 const int kMinAdvInstancesForMultiAdv = 5; 52 53 // Used when determining if offloaded scan filtering is supported. 54 const int kMinOffloadedFilters = 10; 55 56 // Used when determining if offloaded scan batching is supported. 57 const int kMinOffloadedScanStorageBytes = 1024; 58 59 void Adapter::Observer::OnAdapterStateChanged(Adapter* adapter, 60 AdapterState prev_state, 61 AdapterState new_state) { 62 // Default implementation does nothing 63 } 64 65 void Adapter::Observer::OnDeviceConnectionStateChanged( 66 Adapter* adapter, const std::string& device_address, bool connected) { 67 // Default implementation does nothing 68 } 69 70 // The real Adapter implementation used in production. 71 class AdapterImpl : public Adapter, 72 public hal::BluetoothInterface::Observer { 73 public: 74 AdapterImpl() 75 : state_(ADAPTER_STATE_OFF), 76 address_(kDefaultAddress), 77 name_(kDefaultName) { 78 memset(&local_le_features_, 0, sizeof(local_le_features_)); 79 hal::BluetoothInterface::Get()->AddObserver(this); 80 ble_client_factory_.reset(new LowEnergyClientFactory(*this)); 81 gatt_client_factory_.reset(new GattClientFactory()); 82 gatt_server_factory_.reset(new GattServerFactory()); 83 hal::BluetoothInterface::Get()->GetHALInterface()->get_adapter_properties(); 84 } 85 86 ~AdapterImpl() override { 87 hal::BluetoothInterface::Get()->RemoveObserver(this); 88 } 89 90 void AddObserver(Adapter::Observer* observer) override { 91 lock_guard<mutex> lock(observers_lock_); 92 observers_.AddObserver(observer); 93 } 94 95 void RemoveObserver(Adapter::Observer* observer) override { 96 lock_guard<mutex> lock(observers_lock_); 97 observers_.RemoveObserver(observer); 98 } 99 100 AdapterState GetState() const override { 101 return state_.load(); 102 } 103 104 bool IsEnabled() const override { 105 return state_.load() == ADAPTER_STATE_ON; 106 } 107 108 bool Enable(bool start_restricted) override { 109 AdapterState current_state = GetState(); 110 if (current_state != ADAPTER_STATE_OFF) { 111 LOG(INFO) << "Adapter not disabled - state: " 112 << AdapterStateToString(current_state); 113 return false; 114 } 115 116 // Set the state before calling enable() as there might be a race between 117 // here and the AdapterStateChangedCallback. 118 state_ = ADAPTER_STATE_TURNING_ON; 119 NotifyAdapterStateChanged(current_state, state_); 120 121 int status = hal::BluetoothInterface::Get()->GetHALInterface()->enable(start_restricted); 122 if (status != BT_STATUS_SUCCESS) { 123 LOG(ERROR) << "Failed to enable Bluetooth - status: " 124 << BtStatusText((const bt_status_t)status); 125 state_ = ADAPTER_STATE_OFF; 126 NotifyAdapterStateChanged(ADAPTER_STATE_TURNING_ON, state_); 127 return false; 128 } 129 130 return true; 131 } 132 133 bool Disable() override { 134 if (!IsEnabled()) { 135 LOG(INFO) << "Adapter is not enabled"; 136 return false; 137 } 138 139 AdapterState current_state = GetState(); 140 141 // Set the state before calling enable() as there might be a race between 142 // here and the AdapterStateChangedCallback. 143 state_ = ADAPTER_STATE_TURNING_OFF; 144 NotifyAdapterStateChanged(current_state, state_); 145 146 int status = hal::BluetoothInterface::Get()->GetHALInterface()->disable(); 147 if (status != BT_STATUS_SUCCESS) { 148 LOG(ERROR) << "Failed to disable Bluetooth - status: " 149 << BtStatusText((const bt_status_t)status); 150 state_ = current_state; 151 NotifyAdapterStateChanged(ADAPTER_STATE_TURNING_OFF, state_); 152 return false; 153 } 154 155 return true; 156 } 157 158 std::string GetName() const override { 159 return name_.Get(); 160 } 161 162 bool SetName(const std::string& name) override { 163 bt_bdname_t hal_name; 164 size_t max_name_len = sizeof(hal_name.name); 165 166 // Include the \0 byte in size measurement. 167 if (name.length() >= max_name_len) { 168 LOG(ERROR) << "Given name \"" << name << "\" is larger than maximum" 169 << " allowed size: " << max_name_len; 170 return false; 171 } 172 173 strncpy(reinterpret_cast<char*>(hal_name.name), name.c_str(), 174 name.length() + 1); 175 176 VLOG(1) << "Setting adapter name: " << name; 177 178 if (!SetAdapterProperty(BT_PROPERTY_BDNAME, &hal_name, sizeof(hal_name))) { 179 LOG(ERROR) << "Failed to set adapter name: " << name; 180 return false; 181 } 182 183 return true; 184 } 185 186 std::string GetAddress() const override { 187 return address_.Get(); 188 } 189 190 bool IsMultiAdvertisementSupported() override { 191 lock_guard<mutex> lock(local_le_features_lock_); 192 return local_le_features_.max_adv_instance >= kMinAdvInstancesForMultiAdv; 193 } 194 195 bool IsDeviceConnected(const std::string& device_address) override { 196 lock_guard<mutex> lock(connected_devices_lock_); 197 return connected_devices_.find(device_address) != connected_devices_.end(); 198 } 199 200 int GetTotalNumberOfTrackableAdvertisements() override { 201 lock_guard<mutex> lock(local_le_features_lock_); 202 return local_le_features_.total_trackable_advertisers; 203 } 204 205 bool IsOffloadedFilteringSupported() override { 206 lock_guard<mutex> lock(local_le_features_lock_); 207 return local_le_features_.max_adv_filter_supported >= kMinOffloadedFilters; 208 } 209 210 bool IsOffloadedScanBatchingSupported() override { 211 lock_guard<mutex> lock(local_le_features_lock_); 212 return local_le_features_.scan_result_storage_size >= 213 kMinOffloadedScanStorageBytes; 214 } 215 216 LowEnergyClientFactory* GetLowEnergyClientFactory() const override { 217 return ble_client_factory_.get(); 218 } 219 220 GattClientFactory* GetGattClientFactory() const override { 221 return gatt_client_factory_.get(); 222 } 223 224 GattServerFactory* GetGattServerFactory() const override { 225 return gatt_server_factory_.get(); 226 } 227 228 // hal::BluetoothInterface::Observer overrides. 229 void AdapterStateChangedCallback(bt_state_t state) override { 230 LOG(INFO) << "Adapter state changed: " << BtStateText(state); 231 232 AdapterState prev_state = GetState(); 233 234 switch (state) { 235 case BT_STATE_OFF: 236 state_ = ADAPTER_STATE_OFF; 237 break; 238 239 case BT_STATE_ON: 240 state_ = ADAPTER_STATE_ON; 241 break; 242 243 default: 244 NOTREACHED(); 245 } 246 247 NotifyAdapterStateChanged(prev_state, GetState()); 248 } 249 250 void AdapterPropertiesCallback(bt_status_t status, 251 int num_properties, 252 bt_property_t* properties) override { 253 LOG(INFO) << "Adapter properties changed"; 254 255 if (status != BT_STATUS_SUCCESS) { 256 LOG(ERROR) << "status: " << BtStatusText(status); 257 return; 258 } 259 260 for (int i = 0; i < num_properties; i++) { 261 bt_property_t* property = properties + i; 262 switch (property->type) { 263 case BT_PROPERTY_BDADDR: { 264 std::string address = BtAddrString(reinterpret_cast<bt_bdaddr_t*>( 265 property->val)); 266 LOG(INFO) << "Adapter address changed: " << address; 267 address_.Set(address); 268 break; 269 } 270 case BT_PROPERTY_BDNAME: { 271 bt_bdname_t* hal_name = reinterpret_cast<bt_bdname_t*>(property->val); 272 std::string name = reinterpret_cast<char*>(hal_name->name); 273 LOG(INFO) << "Adapter name changed: " << name; 274 name_.Set(name); 275 break; 276 } 277 case BT_PROPERTY_LOCAL_LE_FEATURES: { 278 lock_guard<mutex> lock(local_le_features_lock_); 279 if (property->len != sizeof(bt_local_le_features_t)) { 280 LOG(WARNING) << "Malformed value received for property: " 281 << "BT_PROPERTY_LOCAL_LE_FEATURES"; 282 break; 283 } 284 bt_local_le_features_t* features = 285 reinterpret_cast<bt_local_le_features_t*>(property->val); 286 memcpy(&local_le_features_, features, sizeof(*features)); 287 LOG(INFO) << "Supported LE features updated"; 288 break; 289 } 290 default: 291 VLOG(1) << "Unhandled adapter property: " 292 << BtPropertyText(property->type); 293 break; 294 } 295 296 // TODO(armansito): notify others of the updated properties 297 } 298 } 299 300 void AclStateChangedCallback(bt_status_t status, 301 const bt_bdaddr_t& remote_bdaddr, 302 bt_acl_state_t state) override { 303 std::string device_address = BtAddrString(&remote_bdaddr); 304 bool connected = (state == BT_ACL_STATE_CONNECTED); 305 LOG(INFO) << "ACL state changed: " << device_address << " - connected: " 306 << (connected ? "true" : "false"); 307 308 // If this is reported with an error status, I suppose the best thing we can 309 // do is to log it and ignore the event. 310 if (status != BT_STATUS_SUCCESS) { 311 LOG(ERROR) << "status: " << BtStatusText(status); 312 return; 313 } 314 315 // Introduce a scope to manage |connected_devices_lock_| with RAII. 316 { 317 lock_guard<mutex> lock(connected_devices_lock_); 318 if (connected) 319 connected_devices_.insert(device_address); 320 else 321 connected_devices_.erase(device_address); 322 } 323 324 lock_guard<mutex> lock(observers_lock_); 325 FOR_EACH_OBSERVER( 326 Adapter::Observer, observers_, 327 OnDeviceConnectionStateChanged(this, device_address, connected)); 328 } 329 330 // Sends a request to set the given HAL adapter property type and value. 331 bool SetAdapterProperty(bt_property_type_t type, void* value, int length) { 332 CHECK(length > 0); 333 CHECK(value); 334 335 bt_property_t property; 336 property.len = length; 337 property.val = value; 338 property.type = type; 339 340 int status = hal::BluetoothInterface::Get()->GetHALInterface()-> 341 set_adapter_property(&property); 342 if (status != BT_STATUS_SUCCESS) { 343 VLOG(1) << "Failed to set property"; 344 return false; 345 } 346 347 return true; 348 } 349 350 // Helper for invoking the AdapterStateChanged observer method. 351 void NotifyAdapterStateChanged(AdapterState prev_state, 352 AdapterState new_state) { 353 if (prev_state == new_state) 354 return; 355 356 lock_guard<mutex> lock(observers_lock_); 357 FOR_EACH_OBSERVER(Adapter::Observer, observers_, 358 OnAdapterStateChanged(this, prev_state, new_state)); 359 } 360 361 private: 362 // The current adapter state. 363 std::atomic<AdapterState> state_; 364 365 // The Bluetooth device address of the local adapter in string from 366 // (i.e.. XX:XX:XX:XX:XX:XX) 367 util::AtomicString address_; 368 369 // The current local adapter name. 370 util::AtomicString name_; 371 372 // The current set of supported LE features as obtained from the stack. The 373 // values here are all initially set to 0 and updated when the corresponding 374 // adapter property has been received from the stack. 375 std::mutex local_le_features_lock_; 376 bt_local_le_features_t local_le_features_; 377 378 // List of observers that are interested in notifications from us. 379 std::mutex observers_lock_; 380 base::ObserverList<Adapter::Observer> observers_; 381 382 // List of devices addresses that are currently connected. 383 std::mutex connected_devices_lock_; 384 std::unordered_set<std::string> connected_devices_; 385 386 // Factory used to create per-app LowEnergyClient instances. 387 std::unique_ptr<LowEnergyClientFactory> ble_client_factory_; 388 389 // Factory used to create per-app GattClient instances. 390 std::unique_ptr<GattClientFactory> gatt_client_factory_; 391 392 // Factory used to create per-app GattServer instances. 393 std::unique_ptr<GattServerFactory> gatt_server_factory_; 394 395 DISALLOW_COPY_AND_ASSIGN(AdapterImpl); 396 }; 397 398 // static 399 std::unique_ptr<Adapter> Adapter::Create() { 400 return std::unique_ptr<Adapter>(new AdapterImpl()); 401 } 402 403 } // namespace bluetooth 404