bluez_dbus_manager.cc 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491
  1. // Copyright (c) 2012 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. #include "device/bluetooth/dbus/bluez_dbus_manager.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/command_line.h"
  9. #include "base/feature_list.h"
  10. #include "base/logging.h"
  11. #include "base/memory/ptr_util.h"
  12. #include "base/system/sys_info.h"
  13. #include "base/threading/thread.h"
  14. #include "build/build_config.h"
  15. #include "chromeos/constants/chromeos_features.h"
  16. #include "dbus/bus.h"
  17. #include "dbus/dbus_statistics.h"
  18. #include "dbus/message.h"
  19. #include "dbus/object_manager.h"
  20. #include "dbus/object_proxy.h"
  21. #include "device/base/features.h"
  22. #include "device/bluetooth/dbus/bluetooth_adapter_client.h"
  23. #include "device/bluetooth/dbus/bluetooth_admin_policy_client.h"
  24. #include "device/bluetooth/dbus/bluetooth_advertisement_monitor_manager_client.h"
  25. #include "device/bluetooth/dbus/bluetooth_agent_manager_client.h"
  26. #include "device/bluetooth/dbus/bluetooth_battery_client.h"
  27. #include "device/bluetooth/dbus/bluetooth_debug_manager_client.h"
  28. #include "device/bluetooth/dbus/bluetooth_device_client.h"
  29. #include "device/bluetooth/dbus/bluetooth_gatt_characteristic_client.h"
  30. #include "device/bluetooth/dbus/bluetooth_gatt_descriptor_client.h"
  31. #include "device/bluetooth/dbus/bluetooth_gatt_manager_client.h"
  32. #include "device/bluetooth/dbus/bluetooth_gatt_service_client.h"
  33. #include "device/bluetooth/dbus/bluetooth_input_client.h"
  34. #include "device/bluetooth/dbus/bluetooth_le_advertising_manager_client.h"
  35. #include "device/bluetooth/dbus/bluetooth_profile_manager_client.h"
  36. #include "device/bluetooth/dbus/bluez_dbus_thread_manager.h"
  37. #include "device/bluetooth/floss/floss_dbus_client.h"
  38. #include "device/bluetooth/floss/floss_manager_client.h"
  39. #include "third_party/cros_system_api/dbus/service_constants.h"
  40. namespace bluez {
  41. static BluezDBusManager* g_bluez_dbus_manager = nullptr;
  42. static bool g_using_bluez_dbus_manager_for_testing = false;
  43. BluezDBusManager::BluezDBusManager(dbus::Bus* bus,
  44. dbus::Bus* alternate_bus,
  45. bool use_dbus_fakes)
  46. : bus_(bus),
  47. alternate_bus_(alternate_bus),
  48. object_manager_support_known_(false),
  49. object_manager_supported_(false) {
  50. // On Chrome OS, Bluez might not be ready by the time we initialize the
  51. // BluezDBusManager so we initialize the clients anyway.
  52. bool should_check_object_manager = true;
  53. #if BUILDFLAG(IS_CHROMEOS)
  54. should_check_object_manager = false;
  55. #endif // BUILDFLAG(IS_CHROMEOS)
  56. if (!use_dbus_fakes) {
  57. // Make sure that Floss manager daemon is in agreement with Chrome about the
  58. // state of Floss enable/disable.
  59. dbus::MethodCall floss_method_call(dbus::kObjectManagerInterface,
  60. dbus::kObjectManagerGetManagedObjects);
  61. GetSystemBus()
  62. ->GetObjectProxy(floss::kManagerService, dbus::ObjectPath("/"))
  63. ->CallMethodWithErrorCallback(
  64. &floss_method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
  65. base::BindOnce(&BluezDBusManager::OnFlossObjectManagerSupported,
  66. weak_ptr_factory_.GetWeakPtr()),
  67. base::BindOnce(&BluezDBusManager::OnFlossObjectManagerNotSupported,
  68. weak_ptr_factory_.GetWeakPtr()));
  69. }
  70. if (!should_check_object_manager || use_dbus_fakes) {
  71. client_bundle_ =
  72. std::make_unique<BluetoothDBusClientBundle>(use_dbus_fakes);
  73. InitializeClients();
  74. object_manager_supported_ = true;
  75. object_manager_support_known_ = true;
  76. return;
  77. }
  78. CHECK(GetSystemBus()) << "Can't initialize real clients without DBus.";
  79. dbus::MethodCall method_call(dbus::kObjectManagerInterface,
  80. dbus::kObjectManagerGetManagedObjects);
  81. GetSystemBus()
  82. ->GetObjectProxy(
  83. bluez_object_manager::kBluezObjectManagerServiceName,
  84. dbus::ObjectPath(
  85. bluetooth_object_manager::kBluetoothObjectManagerServicePath))
  86. ->CallMethodWithErrorCallback(
  87. &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
  88. base::BindOnce(&BluezDBusManager::OnObjectManagerSupported,
  89. weak_ptr_factory_.GetWeakPtr()),
  90. base::BindOnce(&BluezDBusManager::OnObjectManagerNotSupported,
  91. weak_ptr_factory_.GetWeakPtr()));
  92. }
  93. BluezDBusManager::~BluezDBusManager() {
  94. // Delete all D-Bus clients before shutting down the system bus.
  95. client_bundle_.reset();
  96. }
  97. dbus::Bus* bluez::BluezDBusManager::GetSystemBus() {
  98. return bus_;
  99. }
  100. void BluezDBusManager::CallWhenObjectManagerSupportIsKnown(
  101. base::OnceClosure callback) {
  102. object_manager_support_known_callback_ = std::move(callback);
  103. }
  104. BluetoothAdapterClient* bluez::BluezDBusManager::GetBluetoothAdapterClient() {
  105. DCHECK(object_manager_support_known_);
  106. return client_bundle_->bluetooth_adapter_client();
  107. }
  108. BluetoothAdminPolicyClient*
  109. bluez::BluezDBusManager::GetBluetoothAdminPolicyClient() {
  110. DCHECK(object_manager_support_known_);
  111. return client_bundle_->bluetooth_admin_policy_client();
  112. }
  113. BluetoothAdvertisementMonitorManagerClient*
  114. bluez::BluezDBusManager::GetBluetoothAdvertisementMonitorManagerClient() {
  115. DCHECK(object_manager_support_known_);
  116. return client_bundle_->bluetooth_advertisement_monitor_manager_client();
  117. }
  118. BluetoothLEAdvertisingManagerClient*
  119. bluez::BluezDBusManager::GetBluetoothLEAdvertisingManagerClient() {
  120. DCHECK(object_manager_support_known_);
  121. return client_bundle_->bluetooth_le_advertising_manager_client();
  122. }
  123. BluetoothAgentManagerClient*
  124. bluez::BluezDBusManager::GetBluetoothAgentManagerClient() {
  125. DCHECK(object_manager_support_known_);
  126. return client_bundle_->bluetooth_agent_manager_client();
  127. }
  128. BluetoothDebugManagerClient*
  129. bluez::BluezDBusManager::GetBluetoothDebugManagerClient() {
  130. DCHECK(object_manager_support_known_);
  131. return client_bundle_->bluetooth_debug_manager_client();
  132. }
  133. BluetoothBatteryClient* bluez::BluezDBusManager::GetBluetoothBatteryClient() {
  134. DCHECK(object_manager_support_known_);
  135. return client_bundle_->bluetooth_battery_client();
  136. }
  137. BluetoothDeviceClient* bluez::BluezDBusManager::GetBluetoothDeviceClient() {
  138. DCHECK(object_manager_support_known_);
  139. return client_bundle_->bluetooth_device_client();
  140. }
  141. BluetoothGattCharacteristicClient*
  142. bluez::BluezDBusManager::GetBluetoothGattCharacteristicClient() {
  143. DCHECK(object_manager_support_known_);
  144. return client_bundle_->bluetooth_gatt_characteristic_client();
  145. }
  146. BluetoothGattDescriptorClient*
  147. bluez::BluezDBusManager::GetBluetoothGattDescriptorClient() {
  148. DCHECK(object_manager_support_known_);
  149. return client_bundle_->bluetooth_gatt_descriptor_client();
  150. }
  151. BluetoothGattManagerClient*
  152. bluez::BluezDBusManager::GetBluetoothGattManagerClient() {
  153. DCHECK(object_manager_support_known_);
  154. return client_bundle_->bluetooth_gatt_manager_client();
  155. }
  156. BluetoothGattServiceClient*
  157. bluez::BluezDBusManager::GetBluetoothGattServiceClient() {
  158. DCHECK(object_manager_support_known_);
  159. return client_bundle_->bluetooth_gatt_service_client();
  160. }
  161. BluetoothInputClient* bluez::BluezDBusManager::GetBluetoothInputClient() {
  162. DCHECK(object_manager_support_known_);
  163. return client_bundle_->bluetooth_input_client();
  164. }
  165. BluetoothProfileManagerClient*
  166. bluez::BluezDBusManager::GetBluetoothProfileManagerClient() {
  167. DCHECK(object_manager_support_known_);
  168. return client_bundle_->bluetooth_profile_manager_client();
  169. }
  170. BluetoothAdapterClient* BluezDBusManager::GetAlternateBluetoothAdapterClient() {
  171. DCHECK(object_manager_support_known_);
  172. return client_bundle_->alternate_bluetooth_adapter_client();
  173. }
  174. BluetoothAdminPolicyClient*
  175. BluezDBusManager::GetAlternateBluetoothAdminPolicyClient() {
  176. DCHECK(object_manager_support_known_);
  177. return client_bundle_->alternate_bluetooth_admin_policy_client();
  178. }
  179. BluetoothDeviceClient* BluezDBusManager::GetAlternateBluetoothDeviceClient() {
  180. DCHECK(object_manager_support_known_);
  181. return client_bundle_->alternate_bluetooth_device_client();
  182. }
  183. void BluezDBusManager::OnObjectManagerSupported(dbus::Response* response) {
  184. DVLOG(1) << "Bluetooth supported. Initializing clients.";
  185. object_manager_supported_ = true;
  186. client_bundle_ =
  187. std::make_unique<BluetoothDBusClientBundle>(false /* use_fakes */);
  188. InitializeClients();
  189. object_manager_support_known_ = true;
  190. if (object_manager_support_known_callback_)
  191. std::move(object_manager_support_known_callback_).Run();
  192. }
  193. void BluezDBusManager::OnObjectManagerNotSupported(
  194. dbus::ErrorResponse* response) {
  195. DVLOG(1) << "Bluetooth not supported.";
  196. object_manager_supported_ = false;
  197. // We don't initialize clients since the clients need ObjectManager.
  198. object_manager_support_known_ = true;
  199. if (object_manager_support_known_callback_)
  200. std::move(object_manager_support_known_callback_).Run();
  201. }
  202. void BluezDBusManager::OnFlossObjectManagerSupported(dbus::Response* response) {
  203. DVLOG(1) << "Floss manager present. Making sure Floss is enabled/disabled.";
  204. floss_manager_client_ = floss::FlossManagerClient::Create();
  205. floss_manager_client_->Init(GetSystemBus(), floss::kManagerInterface,
  206. std::string());
  207. }
  208. void BluezDBusManager::OnFlossObjectManagerNotSupported(
  209. dbus::ErrorResponse* response) {
  210. LOG(WARNING) << "Floss manager not present, cannot set Floss enable/disable.";
  211. }
  212. void BluezDBusManager::InitializeClients() {
  213. std::string bluetooth_service_name =
  214. bluez_object_manager::kBluezObjectManagerServiceName;
  215. client_bundle_->bluetooth_adapter_client()->Init(GetSystemBus(),
  216. bluetooth_service_name);
  217. client_bundle_->bluetooth_admin_policy_client()->Init(GetSystemBus(),
  218. bluetooth_service_name);
  219. #if BUILDFLAG(IS_CHROMEOS)
  220. client_bundle_->bluetooth_advertisement_monitor_manager_client()->Init(
  221. GetSystemBus(), bluetooth_service_name);
  222. #endif // BUILDFLAG(IS_CHROMEOS)
  223. client_bundle_->bluetooth_agent_manager_client()->Init(
  224. GetSystemBus(), bluetooth_service_name);
  225. client_bundle_->bluetooth_device_client()->Init(GetSystemBus(),
  226. bluetooth_service_name);
  227. client_bundle_->bluetooth_gatt_characteristic_client()->Init(
  228. GetSystemBus(), bluetooth_service_name);
  229. client_bundle_->bluetooth_gatt_descriptor_client()->Init(
  230. GetSystemBus(), bluetooth_service_name);
  231. client_bundle_->bluetooth_gatt_manager_client()->Init(GetSystemBus(),
  232. bluetooth_service_name);
  233. client_bundle_->bluetooth_gatt_service_client()->Init(GetSystemBus(),
  234. bluetooth_service_name);
  235. client_bundle_->bluetooth_input_client()->Init(GetSystemBus(),
  236. bluetooth_service_name);
  237. client_bundle_->bluetooth_le_advertising_manager_client()->Init(
  238. GetSystemBus(), bluetooth_service_name);
  239. client_bundle_->bluetooth_profile_manager_client()->Init(
  240. GetSystemBus(), bluetooth_service_name);
  241. client_bundle_->bluetooth_debug_manager_client()->Init(
  242. GetSystemBus(), bluetooth_service_name);
  243. client_bundle_->bluetooth_battery_client()->Init(GetSystemBus(),
  244. bluetooth_service_name);
  245. if (!alternate_bus_)
  246. return;
  247. client_bundle_->alternate_bluetooth_adapter_client()->Init(
  248. alternate_bus_, bluetooth_service_name);
  249. client_bundle_->alternate_bluetooth_admin_policy_client()->Init(
  250. alternate_bus_, bluetooth_service_name);
  251. client_bundle_->alternate_bluetooth_device_client()->Init(
  252. alternate_bus_, bluetooth_service_name);
  253. }
  254. // static
  255. void BluezDBusManager::Initialize(dbus::Bus* system_bus) {
  256. // If we initialize BluezDBusManager twice we may also be shutting it down
  257. // early; do not allow that.
  258. if (g_using_bluez_dbus_manager_for_testing)
  259. return;
  260. CHECK(!g_bluez_dbus_manager);
  261. BluezDBusThreadManager::Initialize();
  262. #if BUILDFLAG(IS_CHROMEOS)
  263. DCHECK(system_bus);
  264. // On ChromeOS, BluetoothSystem needs a separate connection to Bluez, so we
  265. // use BluezDBusThreadManager to get two different connections to the same
  266. // services. This allows us to have two separate sets of clients in the same
  267. // process.
  268. CreateGlobalInstance(system_bus,
  269. BluezDBusThreadManager::Get()->GetSystemBus(),
  270. false /* use_dbus_stubs */);
  271. #elif BUILDFLAG(IS_LINUX)
  272. // BluetoothSystem, the client that needs the extra connection, is not
  273. // implemented on Linux, so no need for an extra Bus.
  274. CreateGlobalInstance(BluezDBusThreadManager::Get()->GetSystemBus(), nullptr,
  275. false /* use_dbus_stubs */);
  276. #else
  277. NOTREACHED();
  278. #endif
  279. }
  280. void BluezDBusManager::InitializeFake() {
  281. if (g_using_bluez_dbus_manager_for_testing)
  282. return;
  283. CHECK(!g_bluez_dbus_manager);
  284. BluezDBusThreadManager::Initialize();
  285. CreateGlobalInstance(nullptr, nullptr, true /* use_dbus_stubs */);
  286. }
  287. // static
  288. std::unique_ptr<BluezDBusManagerSetter>
  289. bluez::BluezDBusManager::GetSetterForTesting() {
  290. if (!g_using_bluez_dbus_manager_for_testing) {
  291. g_using_bluez_dbus_manager_for_testing = true;
  292. CreateGlobalInstance(nullptr, nullptr, true);
  293. }
  294. return base::WrapUnique(new BluezDBusManagerSetter());
  295. }
  296. // static
  297. void BluezDBusManager::CreateGlobalInstance(dbus::Bus* bus,
  298. dbus::Bus* alternate_bus,
  299. bool use_stubs) {
  300. CHECK(!g_bluez_dbus_manager);
  301. g_bluez_dbus_manager = new BluezDBusManager(bus, alternate_bus, use_stubs);
  302. }
  303. // static
  304. bool BluezDBusManager::IsInitialized() {
  305. return g_bluez_dbus_manager != nullptr;
  306. }
  307. // static
  308. void BluezDBusManager::Shutdown() {
  309. // Ensure that we only shutdown BluezDBusManager once.
  310. CHECK(g_bluez_dbus_manager);
  311. BluezDBusManager* dbus_manager = g_bluez_dbus_manager;
  312. g_bluez_dbus_manager = nullptr;
  313. delete dbus_manager;
  314. #if BUILDFLAG(IS_CHROMEOS)
  315. if (!g_using_bluez_dbus_manager_for_testing)
  316. BluezDBusThreadManager::Shutdown();
  317. #endif // BUILDFLAG(IS_CHROMEOS)
  318. g_using_bluez_dbus_manager_for_testing = false;
  319. DVLOG(1) << "BluezDBusManager Shutdown completed";
  320. }
  321. // static
  322. BluezDBusManager* bluez::BluezDBusManager::Get() {
  323. CHECK(g_bluez_dbus_manager)
  324. << "bluez::BluezDBusManager::Get() called before Initialize()";
  325. return g_bluez_dbus_manager;
  326. }
  327. BluezDBusManagerSetter::BluezDBusManagerSetter() = default;
  328. BluezDBusManagerSetter::~BluezDBusManagerSetter() = default;
  329. void BluezDBusManagerSetter::SetBluetoothAdapterClient(
  330. std::unique_ptr<BluetoothAdapterClient> client) {
  331. bluez::BluezDBusManager::Get()->client_bundle_->bluetooth_adapter_client_ =
  332. std::move(client);
  333. }
  334. void BluezDBusManagerSetter::SetBluetoothAdminPolicyClient(
  335. std::unique_ptr<BluetoothAdminPolicyClient> client) {
  336. bluez::BluezDBusManager::Get()
  337. ->client_bundle_->bluetooth_admin_policy_client_ = std::move(client);
  338. }
  339. void BluezDBusManagerSetter::SetBluetoothAdvertisementMonitorManagerClient(
  340. std::unique_ptr<BluetoothAdvertisementMonitorManagerClient> client) {
  341. bluez::BluezDBusManager::Get()
  342. ->client_bundle_->bluetooth_advertisement_monitor_manager_client_ =
  343. std::move(client);
  344. }
  345. void BluezDBusManagerSetter::SetBluetoothLEAdvertisingManagerClient(
  346. std::unique_ptr<BluetoothLEAdvertisingManagerClient> client) {
  347. bluez::BluezDBusManager::Get()
  348. ->client_bundle_->bluetooth_le_advertising_manager_client_ =
  349. std::move(client);
  350. }
  351. void BluezDBusManagerSetter::SetBluetoothAgentManagerClient(
  352. std::unique_ptr<BluetoothAgentManagerClient> client) {
  353. bluez::BluezDBusManager::Get()
  354. ->client_bundle_->bluetooth_agent_manager_client_ = std::move(client);
  355. }
  356. void BluezDBusManagerSetter::SetBluetoothBatteryClient(
  357. std::unique_ptr<BluetoothBatteryClient> client) {
  358. bluez::BluezDBusManager::Get()->client_bundle_->bluetooth_battery_client_ =
  359. std::move(client);
  360. }
  361. void BluezDBusManagerSetter::SetBluetoothDebugManagerClient(
  362. std::unique_ptr<BluetoothDebugManagerClient> client) {
  363. bluez::BluezDBusManager::Get()
  364. ->client_bundle_->bluetooth_debug_manager_client_ = std::move(client);
  365. }
  366. void BluezDBusManagerSetter::SetBluetoothDeviceClient(
  367. std::unique_ptr<BluetoothDeviceClient> client) {
  368. bluez::BluezDBusManager::Get()->client_bundle_->bluetooth_device_client_ =
  369. std::move(client);
  370. }
  371. void BluezDBusManagerSetter::SetBluetoothGattCharacteristicClient(
  372. std::unique_ptr<BluetoothGattCharacteristicClient> client) {
  373. bluez::BluezDBusManager::Get()
  374. ->client_bundle_->bluetooth_gatt_characteristic_client_ =
  375. std::move(client);
  376. }
  377. void BluezDBusManagerSetter::SetBluetoothGattDescriptorClient(
  378. std::unique_ptr<BluetoothGattDescriptorClient> client) {
  379. bluez::BluezDBusManager::Get()
  380. ->client_bundle_->bluetooth_gatt_descriptor_client_ = std::move(client);
  381. }
  382. void BluezDBusManagerSetter::SetBluetoothGattManagerClient(
  383. std::unique_ptr<BluetoothGattManagerClient> client) {
  384. bluez::BluezDBusManager::Get()
  385. ->client_bundle_->bluetooth_gatt_manager_client_ = std::move(client);
  386. }
  387. void BluezDBusManagerSetter::SetBluetoothGattServiceClient(
  388. std::unique_ptr<BluetoothGattServiceClient> client) {
  389. bluez::BluezDBusManager::Get()
  390. ->client_bundle_->bluetooth_gatt_service_client_ = std::move(client);
  391. }
  392. void BluezDBusManagerSetter::SetBluetoothInputClient(
  393. std::unique_ptr<BluetoothInputClient> client) {
  394. bluez::BluezDBusManager::Get()->client_bundle_->bluetooth_input_client_ =
  395. std::move(client);
  396. }
  397. void BluezDBusManagerSetter::SetBluetoothProfileManagerClient(
  398. std::unique_ptr<BluetoothProfileManagerClient> client) {
  399. bluez::BluezDBusManager::Get()
  400. ->client_bundle_->bluetooth_profile_manager_client_ = std::move(client);
  401. }
  402. void BluezDBusManagerSetter::SetAlternateBluetoothAdapterClient(
  403. std::unique_ptr<BluetoothAdapterClient> client) {
  404. bluez::BluezDBusManager::Get()
  405. ->client_bundle_->alternate_bluetooth_adapter_client_ = std::move(client);
  406. }
  407. void BluezDBusManagerSetter::SetAlternateBluetoothAdminPolicyClient(
  408. std::unique_ptr<BluetoothAdminPolicyClient> client) {
  409. bluez::BluezDBusManager::Get()
  410. ->client_bundle_->alternate_bluetooth_admin_policy_client_ =
  411. std::move(client);
  412. }
  413. void BluezDBusManagerSetter::SetAlternateBluetoothDeviceClient(
  414. std::unique_ptr<BluetoothDeviceClient> client) {
  415. bluez::BluezDBusManager::Get()
  416. ->client_bundle_->alternate_bluetooth_device_client_ = std::move(client);
  417. }
  418. } // namespace bluez