Home | History | Annotate | Download | only in dbus 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chromeos/dbus/fake_bluetooth_gatt_manager_client.h"
      6 
      7 #include "base/logging.h"
      8 #include "chromeos/dbus/fake_bluetooth_gatt_characteristic_service_provider.h"
      9 #include "chromeos/dbus/fake_bluetooth_gatt_descriptor_service_provider.h"
     10 #include "chromeos/dbus/fake_bluetooth_gatt_service_service_provider.h"
     11 #include "third_party/cros_system_api/dbus/service_constants.h"
     12 
     13 namespace chromeos {
     14 
     15 FakeBluetoothGattManagerClient::FakeBluetoothGattManagerClient() {
     16 }
     17 
     18 FakeBluetoothGattManagerClient::~FakeBluetoothGattManagerClient() {
     19 }
     20 
     21 // DBusClient override.
     22 void FakeBluetoothGattManagerClient::Init(dbus::Bus* bus) {
     23 }
     24 
     25 // BluetoothGattManagerClient overrides.
     26 void FakeBluetoothGattManagerClient::RegisterService(
     27     const dbus::ObjectPath& service_path,
     28     const Options& options,
     29     const base::Closure& callback,
     30     const ErrorCallback& error_callback) {
     31   VLOG(1) << "Register GATT service: " << service_path.value();
     32 
     33   // If a service provider wasn't created before, return error.
     34   ServiceMap::iterator iter = service_map_.find(service_path);
     35   if (iter == service_map_.end()) {
     36     error_callback.Run(bluetooth_gatt_manager::kErrorInvalidArguments,
     37                        "GATT service doesn't exist: " + service_path.value());
     38     return;
     39   }
     40 
     41   // Check to see if this GATT service was already registered.
     42   ServiceProvider* provider = &iter->second;
     43   if (provider->first) {
     44     error_callback.Run(
     45         bluetooth_gatt_manager::kErrorAlreadyExists,
     46         "GATT service already registered: " + service_path.value());
     47     return;
     48   }
     49 
     50   // Success!
     51   provider->first = true;
     52   callback.Run();
     53 }
     54 
     55 void FakeBluetoothGattManagerClient::UnregisterService(
     56     const dbus::ObjectPath& service_path,
     57     const base::Closure& callback,
     58     const ErrorCallback& error_callback) {
     59   VLOG(1) << "Unregister GATT service: " << service_path.value();
     60 
     61   // If a service provider wasn't created before, return error.
     62   ServiceMap::iterator iter = service_map_.find(service_path);
     63   if (iter == service_map_.end()) {
     64     error_callback.Run(bluetooth_gatt_manager::kErrorInvalidArguments,
     65                        "GATT service doesn't exist: " + service_path.value());
     66     return;
     67   }
     68 
     69   // Return error if the GATT service wasn't registered before.
     70   ServiceProvider* provider = &iter->second;
     71   if (!provider->first) {
     72     error_callback.Run(
     73         bluetooth_gatt_manager::kErrorDoesNotExist,
     74         "GATT service not registered: " + service_path.value());
     75     return;
     76   }
     77 
     78   // Success!
     79   provider->first = false;
     80   callback.Run();
     81 }
     82 
     83 void FakeBluetoothGattManagerClient::RegisterServiceServiceProvider(
     84     FakeBluetoothGattServiceServiceProvider* provider) {
     85   // Ignore, if a service provider is already registered for the object path.
     86   ServiceMap::iterator iter = service_map_.find(provider->object_path());
     87   if (iter != service_map_.end()) {
     88     VLOG(1) << "GATT service service provider already registered for "
     89             << "object path: " << provider->object_path().value();
     90     return;
     91   }
     92   service_map_[provider->object_path()] = std::make_pair(false, provider);
     93 }
     94 
     95 void FakeBluetoothGattManagerClient::RegisterCharacteristicServiceProvider(
     96     FakeBluetoothGattCharacteristicServiceProvider* provider) {
     97   // Ignore, if a service provider is already registered for the object path.
     98   CharacteristicMap::iterator iter =
     99       characteristic_map_.find(provider->object_path());
    100   if (iter != characteristic_map_.end()) {
    101     VLOG(1) << "GATT characteristic service provider already registered for "
    102             << "object path: " << provider->object_path().value();
    103     return;
    104   }
    105   characteristic_map_[provider->object_path()] = provider;
    106 }
    107 
    108 void FakeBluetoothGattManagerClient::RegisterDescriptorServiceProvider(
    109     FakeBluetoothGattDescriptorServiceProvider* provider) {
    110   // Ignore, if a service provider is already registered for the object path.
    111   DescriptorMap::iterator iter =
    112       descriptor_map_.find(provider->object_path());
    113   if (iter != descriptor_map_.end()) {
    114     VLOG(1) << "GATT descriptor service provider already registered for "
    115             << "object path: " << provider->object_path().value();
    116     return;
    117   }
    118   descriptor_map_[provider->object_path()] = provider;
    119 }
    120 
    121 void FakeBluetoothGattManagerClient::UnregisterServiceServiceProvider(
    122     FakeBluetoothGattServiceServiceProvider* provider) {
    123   ServiceMap::iterator iter =
    124       service_map_.find(provider->object_path());
    125   if (iter != service_map_.end() && iter->second.second == provider)
    126     service_map_.erase(iter);
    127 }
    128 
    129 void FakeBluetoothGattManagerClient::UnregisterCharacteristicServiceProvider(
    130     FakeBluetoothGattCharacteristicServiceProvider* provider) {
    131   characteristic_map_.erase(provider->object_path());
    132 }
    133 
    134 void FakeBluetoothGattManagerClient::UnregisterDescriptorServiceProvider(
    135     FakeBluetoothGattDescriptorServiceProvider* provider) {
    136   descriptor_map_.erase(provider->object_path());
    137 }
    138 
    139 FakeBluetoothGattServiceServiceProvider*
    140 FakeBluetoothGattManagerClient::GetServiceServiceProvider(
    141     const dbus::ObjectPath& object_path) const {
    142   ServiceMap::const_iterator iter = service_map_.find(object_path);
    143   if (iter == service_map_.end())
    144     return NULL;
    145   return iter->second.second;
    146 }
    147 
    148 FakeBluetoothGattCharacteristicServiceProvider*
    149 FakeBluetoothGattManagerClient::GetCharacteristicServiceProvider(
    150         const dbus::ObjectPath& object_path) const {
    151   CharacteristicMap::const_iterator iter =
    152       characteristic_map_.find(object_path);
    153   if (iter == characteristic_map_.end())
    154     return NULL;
    155   return iter->second;
    156 }
    157 
    158 FakeBluetoothGattDescriptorServiceProvider*
    159 FakeBluetoothGattManagerClient::GetDescriptorServiceProvider(
    160     const dbus::ObjectPath& object_path) const {
    161   DescriptorMap::const_iterator iter = descriptor_map_.find(object_path);
    162   if (iter == descriptor_map_.end())
    163     return NULL;
    164   return iter->second;
    165 }
    166 
    167 bool FakeBluetoothGattManagerClient::IsServiceRegistered(
    168     const dbus::ObjectPath& object_path) const {
    169   ServiceMap::const_iterator iter = service_map_.find(object_path);
    170   if (iter == service_map_.end())
    171     return false;
    172   return iter->second.first;
    173 }
    174 
    175 }  // namespace chromeos
    176