1 // Copyright (c) 2013 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 "dbus/object_manager.h" 6 7 #include "base/bind.h" 8 #include "base/logging.h" 9 #include "dbus/bus.h" 10 #include "dbus/message.h" 11 #include "dbus/object_proxy.h" 12 #include "dbus/property.h" 13 14 namespace dbus { 15 16 ObjectManager::Object::Object() 17 : object_proxy(NULL) { 18 } 19 20 ObjectManager::Object::~Object() { 21 } 22 23 ObjectManager::ObjectManager(Bus* bus, 24 const std::string& service_name, 25 const ObjectPath& object_path) 26 : bus_(bus), 27 service_name_(service_name), 28 object_path_(object_path), 29 weak_ptr_factory_(this) { 30 DVLOG(1) << "Creating ObjectManager for " << service_name_ 31 << " " << object_path_.value(); 32 33 DCHECK(bus_); 34 object_proxy_ = bus_->GetObjectProxy(service_name_, object_path_); 35 36 object_proxy_->ConnectToSignal( 37 kObjectManagerInterface, 38 kObjectManagerInterfacesAdded, 39 base::Bind(&ObjectManager::InterfacesAddedReceived, 40 weak_ptr_factory_.GetWeakPtr()), 41 base::Bind(&ObjectManager::InterfacesAddedConnected, 42 weak_ptr_factory_.GetWeakPtr())); 43 44 object_proxy_->ConnectToSignal( 45 kObjectManagerInterface, 46 kObjectManagerInterfacesRemoved, 47 base::Bind(&ObjectManager::InterfacesRemovedReceived, 48 weak_ptr_factory_.GetWeakPtr()), 49 base::Bind(&ObjectManager::InterfacesRemovedConnected, 50 weak_ptr_factory_.GetWeakPtr())); 51 52 GetManagedObjects(); 53 } 54 55 ObjectManager::~ObjectManager() { 56 // Clean up Object structures 57 for (ObjectMap::iterator iter = object_map_.begin(); 58 iter != object_map_.end(); ++iter) { 59 Object* object = iter->second; 60 61 for (Object::PropertiesMap::iterator piter = object->properties_map.begin(); 62 piter != object->properties_map.end(); ++piter) { 63 PropertySet* properties = piter->second; 64 delete properties; 65 } 66 67 delete object; 68 } 69 } 70 71 void ObjectManager::RegisterInterface(const std::string& interface_name, 72 Interface* interface) { 73 interface_map_[interface_name] = interface; 74 } 75 76 void ObjectManager::UnregisterInterface(const std::string& interface_name) { 77 InterfaceMap::iterator iter = interface_map_.find(interface_name); 78 if (iter != interface_map_.end()) 79 interface_map_.erase(iter); 80 } 81 82 std::vector<ObjectPath> ObjectManager::GetObjects() { 83 std::vector<ObjectPath> object_paths; 84 85 for (ObjectMap::iterator iter = object_map_.begin(); 86 iter != object_map_.end(); ++iter) 87 object_paths.push_back(iter->first); 88 89 return object_paths; 90 } 91 92 std::vector<ObjectPath> ObjectManager::GetObjectsWithInterface( 93 const std::string& interface_name) { 94 std::vector<ObjectPath> object_paths; 95 96 for (ObjectMap::iterator oiter = object_map_.begin(); 97 oiter != object_map_.end(); ++oiter) { 98 Object* object = oiter->second; 99 100 Object::PropertiesMap::iterator piter = 101 object->properties_map.find(interface_name); 102 if (piter != object->properties_map.end()) 103 object_paths.push_back(oiter->first); 104 } 105 106 return object_paths; 107 } 108 109 ObjectProxy* ObjectManager::GetObjectProxy(const ObjectPath& object_path) { 110 ObjectMap::iterator iter = object_map_.find(object_path); 111 if (iter == object_map_.end()) 112 return NULL; 113 114 Object* object = iter->second; 115 return object->object_proxy; 116 } 117 118 PropertySet* ObjectManager::GetProperties(const ObjectPath& object_path, 119 const std::string& interface_name) { 120 ObjectMap::iterator iter = object_map_.find(object_path); 121 if (iter == object_map_.end()) 122 return NULL; 123 124 Object* object = iter->second; 125 Object::PropertiesMap::iterator piter = 126 object->properties_map.find(interface_name); 127 if (piter == object->properties_map.end()) 128 return NULL; 129 130 return piter->second; 131 } 132 133 void ObjectManager::GetManagedObjects() { 134 MethodCall method_call(kObjectManagerInterface, 135 kObjectManagerGetManagedObjects); 136 137 object_proxy_->CallMethod( 138 &method_call, 139 ObjectProxy::TIMEOUT_USE_DEFAULT, 140 base::Bind(&ObjectManager::OnGetManagedObjects, 141 weak_ptr_factory_.GetWeakPtr())); 142 } 143 144 void ObjectManager::OnGetManagedObjects(Response* response) { 145 if (response != NULL) { 146 MessageReader reader(response); 147 MessageReader array_reader(NULL); 148 if (!reader.PopArray(&array_reader)) 149 return; 150 151 while (array_reader.HasMoreData()) { 152 MessageReader dict_entry_reader(NULL); 153 ObjectPath object_path; 154 if (!array_reader.PopDictEntry(&dict_entry_reader) || 155 !dict_entry_reader.PopObjectPath(&object_path)) 156 continue; 157 158 UpdateObject(object_path, &dict_entry_reader); 159 } 160 161 } else { 162 LOG(WARNING) << service_name_ << " " << object_path_.value() 163 << ": Failed to get managed objects"; 164 } 165 } 166 167 void ObjectManager::InterfacesAddedReceived(Signal* signal) { 168 DCHECK(signal); 169 MessageReader reader(signal); 170 ObjectPath object_path; 171 if (!reader.PopObjectPath(&object_path)) { 172 LOG(WARNING) << service_name_ << " " << object_path_.value() 173 << ": InterfacesAdded signal has incorrect parameters: " 174 << signal->ToString(); 175 return; 176 } 177 178 UpdateObject(object_path, &reader); 179 } 180 181 void ObjectManager::InterfacesAddedConnected(const std::string& interface_name, 182 const std::string& signal_name, 183 bool success) { 184 LOG_IF(WARNING, !success) << service_name_ << " " << object_path_.value() 185 << ": Failed to connect to InterfacesAdded signal."; 186 } 187 188 void ObjectManager::InterfacesRemovedReceived(Signal* signal) { 189 DCHECK(signal); 190 MessageReader reader(signal); 191 ObjectPath object_path; 192 std::vector<std::string> interface_names; 193 if (!reader.PopObjectPath(&object_path) || 194 !reader.PopArrayOfStrings(&interface_names)) { 195 LOG(WARNING) << service_name_ << " " << object_path_.value() 196 << ": InterfacesRemoved signal has incorrect parameters: " 197 << signal->ToString(); 198 return; 199 } 200 201 for (size_t i = 0; i < interface_names.size(); ++i) 202 RemoveInterface(object_path, interface_names[i]); 203 } 204 205 void ObjectManager::InterfacesRemovedConnected( 206 const std::string& interface_name, 207 const std::string& signal_name, 208 bool success) { 209 LOG_IF(WARNING, !success) << service_name_ << " " << object_path_.value() 210 << ": Failed to connect to " 211 << "InterfacesRemoved signal."; 212 } 213 214 void ObjectManager::UpdateObject(const ObjectPath& object_path, 215 MessageReader* reader) { 216 DCHECK(reader); 217 MessageReader array_reader(NULL); 218 if (!reader->PopArray(&array_reader)) 219 return; 220 221 while (array_reader.HasMoreData()) { 222 MessageReader dict_entry_reader(NULL); 223 std::string interface_name; 224 if (!array_reader.PopDictEntry(&dict_entry_reader) || 225 !dict_entry_reader.PopString(&interface_name)) 226 continue; 227 228 AddInterface(object_path, interface_name, &dict_entry_reader); 229 } 230 } 231 232 233 void ObjectManager::AddInterface(const ObjectPath& object_path, 234 const std::string& interface_name, 235 MessageReader* reader) { 236 InterfaceMap::iterator iiter = interface_map_.find(interface_name); 237 if (iiter == interface_map_.end()) 238 return; 239 Interface* interface = iiter->second; 240 241 ObjectMap::iterator oiter = object_map_.find(object_path); 242 Object* object; 243 if (oiter == object_map_.end()) { 244 object = object_map_[object_path] = new Object; 245 object->object_proxy = bus_->GetObjectProxy(service_name_, object_path); 246 } else 247 object = oiter->second; 248 249 Object::PropertiesMap::iterator piter = 250 object->properties_map.find(interface_name); 251 PropertySet* property_set; 252 const bool interface_added = (piter == object->properties_map.end()); 253 if (interface_added) { 254 property_set = object->properties_map[interface_name] = 255 interface->CreateProperties(object->object_proxy, 256 object_path, interface_name); 257 property_set->ConnectSignals(); 258 } else 259 property_set = piter->second; 260 261 property_set->UpdatePropertiesFromReader(reader); 262 263 if (interface_added) 264 interface->ObjectAdded(object_path, interface_name); 265 } 266 267 void ObjectManager::RemoveInterface(const ObjectPath& object_path, 268 const std::string& interface_name) { 269 ObjectMap::iterator oiter = object_map_.find(object_path); 270 if (oiter == object_map_.end()) 271 return; 272 Object* object = oiter->second; 273 274 Object::PropertiesMap::iterator piter = 275 object->properties_map.find(interface_name); 276 if (piter == object->properties_map.end()) 277 return; 278 279 // Inform the interface before removing the properties structure or object 280 // in case it needs details from them to make its own decisions. 281 InterfaceMap::iterator iiter = interface_map_.find(interface_name); 282 if (iiter != interface_map_.end()) { 283 Interface* interface = iiter->second; 284 interface->ObjectRemoved(object_path, interface_name); 285 } 286 287 object->properties_map.erase(piter); 288 289 if (object->properties_map.empty()) { 290 object_map_.erase(oiter); 291 delete object; 292 } 293 } 294 295 } // namespace dbus 296
