| // Copyright 2014 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/dbus/fake_bluetooth_gatt_manager_client.h" |
| |
| #include <set> |
| #include <string> |
| |
| #include "base/callback.h" |
| #include "base/logging.h" |
| #include "base/strings/string_util.h" |
| #include "third_party/cros_system_api/dbus/service_constants.h" |
| |
| namespace bluez { |
| |
| std::set<dbus::ObjectPath> FakeBluetoothGattManagerClient::FindServiceProviders( |
| dbus::ObjectPath application_path) { |
| std::set<dbus::ObjectPath> services; |
| for (const auto& service : service_map_) { |
| if (base::StartsWith(service.first.value(), application_path.value(), |
| base::CompareCase::SENSITIVE)) |
| services.insert(service.first); |
| } |
| return services; |
| } |
| |
| std::set<dbus::ObjectPath> |
| FakeBluetoothGattManagerClient::FindCharacteristicProviders( |
| dbus::ObjectPath application_path) { |
| std::set<dbus::ObjectPath> characteristics; |
| for (const auto& characteristic : characteristic_map_) { |
| if (base::StartsWith(characteristic.first.value(), application_path.value(), |
| base::CompareCase::SENSITIVE)) { |
| characteristics.insert(characteristic.first); |
| } |
| } |
| return characteristics; |
| } |
| |
| std::set<dbus::ObjectPath> |
| FakeBluetoothGattManagerClient::FindDescriptorProviders( |
| dbus::ObjectPath application_path) { |
| std::set<dbus::ObjectPath> descriptors; |
| for (const auto& descriptor : descriptor_map_) { |
| if (base::StartsWith(descriptor.first.value(), application_path.value(), |
| base::CompareCase::SENSITIVE)) { |
| descriptors.insert(descriptor.first); |
| } |
| } |
| return descriptors; |
| } |
| |
| bool FakeBluetoothGattManagerClient::VerifyProviderHierarchy( |
| FakeBluetoothGattApplicationServiceProvider* application_provider) { |
| dbus::ObjectPath application_path = application_provider->object_path(); |
| std::set<dbus::ObjectPath> services = FindServiceProviders(application_path); |
| std::set<dbus::ObjectPath> characteristics = |
| FindCharacteristicProviders(application_path); |
| std::set<dbus::ObjectPath> descriptors = |
| FindDescriptorProviders(application_path); |
| |
| VLOG(1) << "Verifying " << services.size() |
| << " services in application: " << application_path.value(); |
| |
| for (const auto& descriptor : descriptors) { |
| if (characteristics.count( |
| descriptor_map_[descriptor]->characteristic_path()) != 1) { |
| return false; |
| } |
| VLOG(1) << "Descriptor " << descriptor.value() |
| << " verified, has parent characteristic (" |
| << descriptor_map_[descriptor]->characteristic_path().value() |
| << ") in hierarchy."; |
| } |
| |
| for (const auto& characteristic : characteristics) { |
| if (services.count(characteristic_map_[characteristic]->service_path()) != |
| 1) { |
| return false; |
| } |
| VLOG(1) << "Characteristic " << characteristic.value() |
| << " verified, has parent service (" |
| << characteristic_map_[characteristic]->service_path().value() |
| << ") in hierarchy."; |
| } |
| |
| return true; |
| } |
| |
| FakeBluetoothGattManagerClient::FakeBluetoothGattManagerClient() = default; |
| |
| FakeBluetoothGattManagerClient::~FakeBluetoothGattManagerClient() = default; |
| |
| // DBusClient override. |
| void FakeBluetoothGattManagerClient::Init( |
| dbus::Bus* bus, |
| const std::string& bluetooth_service_name) {} |
| |
| // BluetoothGattManagerClient overrides. |
| void FakeBluetoothGattManagerClient::RegisterApplication( |
| const dbus::ObjectPath& adapter_object_path, |
| const dbus::ObjectPath& application_path, |
| const Options& options, |
| const base::Closure& callback, |
| const ErrorCallback& error_callback) { |
| VLOG(1) << "Register GATT application: " << application_path.value(); |
| ApplicationProvider* provider = |
| GetApplicationServiceProvider(application_path); |
| if (!provider || provider->second) { |
| error_callback.Run(bluetooth_gatt_service::kErrorFailed, ""); |
| return; |
| } |
| if (!VerifyProviderHierarchy(provider->first)) { |
| error_callback.Run(bluetooth_gatt_service::kErrorFailed, ""); |
| return; |
| } |
| provider->second = true; |
| callback.Run(); |
| } |
| |
| // BluetoothGattManagerClient overrides. |
| void FakeBluetoothGattManagerClient::UnregisterApplication( |
| const dbus::ObjectPath& adapter_object_path, |
| const dbus::ObjectPath& application_path, |
| const base::Closure& callback, |
| const ErrorCallback& error_callback) { |
| VLOG(1) << "Unregister GATT application: " << application_path.value(); |
| ApplicationProvider* provider = |
| GetApplicationServiceProvider(application_path); |
| if (!provider || !provider->second) { |
| error_callback.Run(bluetooth_gatt_service::kErrorFailed, ""); |
| return; |
| } |
| provider->second = false; |
| callback.Run(); |
| } |
| |
| void FakeBluetoothGattManagerClient::RegisterApplicationServiceProvider( |
| FakeBluetoothGattApplicationServiceProvider* provider) { |
| application_map_[provider->object_path()] = |
| std::pair<FakeBluetoothGattApplicationServiceProvider*, bool>(provider, |
| false); |
| } |
| |
| void FakeBluetoothGattManagerClient::UnregisterApplicationServiceProvider( |
| FakeBluetoothGattApplicationServiceProvider* provider) { |
| auto iter = application_map_.find(provider->object_path()); |
| if (iter != application_map_.end() && iter->second.first == provider) |
| application_map_.erase(iter); |
| } |
| |
| FakeBluetoothGattManagerClient::ApplicationProvider* |
| FakeBluetoothGattManagerClient::GetApplicationServiceProvider( |
| const dbus::ObjectPath& object_path) { |
| auto iter = application_map_.find(object_path); |
| return (iter != application_map_.end()) ? &iter->second : nullptr; |
| } |
| |
| void FakeBluetoothGattManagerClient::RegisterServiceServiceProvider( |
| FakeBluetoothGattServiceServiceProvider* provider) { |
| // Ignore, if a service provider is already registered for the object path. |
| auto iter = service_map_.find(provider->object_path()); |
| if (iter != service_map_.end()) { |
| VLOG(1) << "GATT service service provider already registered for " |
| << "object path: " << provider->object_path().value(); |
| return; |
| } |
| service_map_[provider->object_path()] = provider; |
| } |
| |
| void FakeBluetoothGattManagerClient::RegisterCharacteristicServiceProvider( |
| FakeBluetoothGattCharacteristicServiceProvider* provider) { |
| // Ignore, if a service provider is already registered for the object path. |
| auto iter = characteristic_map_.find(provider->object_path()); |
| if (iter != characteristic_map_.end()) { |
| VLOG(1) << "GATT characteristic service provider already registered for " |
| << "object path: " << provider->object_path().value(); |
| return; |
| } |
| characteristic_map_[provider->object_path()] = provider; |
| } |
| |
| void FakeBluetoothGattManagerClient::RegisterDescriptorServiceProvider( |
| FakeBluetoothGattDescriptorServiceProvider* provider) { |
| // Ignore, if a service provider is already registered for the object path. |
| auto iter = descriptor_map_.find(provider->object_path()); |
| if (iter != descriptor_map_.end()) { |
| VLOG(1) << "GATT descriptor service provider already registered for " |
| << "object path: " << provider->object_path().value(); |
| return; |
| } |
| descriptor_map_[provider->object_path()] = provider; |
| } |
| |
| void FakeBluetoothGattManagerClient::UnregisterServiceServiceProvider( |
| FakeBluetoothGattServiceServiceProvider* provider) { |
| auto iter = service_map_.find(provider->object_path()); |
| if (iter != service_map_.end() && iter->second == provider) |
| service_map_.erase(iter); |
| } |
| |
| void FakeBluetoothGattManagerClient::UnregisterCharacteristicServiceProvider( |
| FakeBluetoothGattCharacteristicServiceProvider* provider) { |
| characteristic_map_.erase(provider->object_path()); |
| } |
| |
| void FakeBluetoothGattManagerClient::UnregisterDescriptorServiceProvider( |
| FakeBluetoothGattDescriptorServiceProvider* provider) { |
| descriptor_map_.erase(provider->object_path()); |
| } |
| |
| FakeBluetoothGattServiceServiceProvider* |
| FakeBluetoothGattManagerClient::GetServiceServiceProvider( |
| const dbus::ObjectPath& object_path) const { |
| auto iter = service_map_.find(object_path); |
| if (iter == service_map_.end()) |
| return NULL; |
| return iter->second; |
| } |
| |
| FakeBluetoothGattCharacteristicServiceProvider* |
| FakeBluetoothGattManagerClient::GetCharacteristicServiceProvider( |
| const dbus::ObjectPath& object_path) const { |
| auto iter = characteristic_map_.find(object_path); |
| if (iter == characteristic_map_.end()) |
| return NULL; |
| return iter->second; |
| } |
| |
| FakeBluetoothGattDescriptorServiceProvider* |
| FakeBluetoothGattManagerClient::GetDescriptorServiceProvider( |
| const dbus::ObjectPath& object_path) const { |
| auto iter = descriptor_map_.find(object_path); |
| if (iter == descriptor_map_.end()) |
| return NULL; |
| return iter->second; |
| } |
| |
| bool FakeBluetoothGattManagerClient::IsServiceRegistered( |
| const dbus::ObjectPath& service_path) const { |
| const auto& service = service_map_.find(service_path); |
| if (service == service_map_.end()) |
| return false; |
| |
| for (const auto& application : application_map_) { |
| if (base::StartsWith(service_path.value(), |
| application.second.first->object_path().value(), |
| base::CompareCase::SENSITIVE)) { |
| return application.second.second; |
| } |
| } |
| return false; |
| } |
| |
| } // namespace bluez |