device_service.cc 16 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431
  1. // Copyright 2016 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 "services/device/device_service.h"
  5. #include <utility>
  6. #include "base/bind.h"
  7. #include "base/memory/weak_ptr.h"
  8. #include "base/task/single_thread_task_runner.h"
  9. #include "base/task/thread_pool.h"
  10. #include "base/threading/thread_task_runner_handle.h"
  11. #include "build/build_config.h"
  12. #include "build/chromeos_buildflags.h"
  13. #include "mojo/public/cpp/bindings/pending_remote.h"
  14. #include "mojo/public/cpp/system/message_pipe.h"
  15. #include "services/device/binder_overrides.h"
  16. #include "services/device/bluetooth/bluetooth_system_factory.h"
  17. #include "services/device/compute_pressure/pressure_manager_impl.h"
  18. #include "services/device/device_posture/device_posture_platform_provider.h"
  19. #include "services/device/device_posture/device_posture_provider_impl.h"
  20. #include "services/device/fingerprint/fingerprint.h"
  21. #include "services/device/generic_sensor/platform_sensor_provider.h"
  22. #include "services/device/generic_sensor/sensor_provider_impl.h"
  23. #include "services/device/geolocation/geolocation_config.h"
  24. #include "services/device/geolocation/geolocation_context.h"
  25. #include "services/device/geolocation/public_ip_address_geolocator.h"
  26. #include "services/device/geolocation/public_ip_address_location_notifier.h"
  27. #include "services/device/power_monitor/power_monitor_message_broadcaster.h"
  28. #include "services/device/public/mojom/battery_monitor.mojom.h"
  29. #include "services/device/serial/serial_port_manager_impl.h"
  30. #include "services/device/time_zone_monitor/time_zone_monitor.h"
  31. #include "services/device/wake_lock/wake_lock_provider.h"
  32. #include "services/network/public/cpp/shared_url_loader_factory.h"
  33. #include "ui/gfx/native_widget_types.h"
  34. #if BUILDFLAG(IS_ANDROID)
  35. #include "base/android/jni_android.h"
  36. #include "services/device/device_service_jni_headers/InterfaceRegistrar_jni.h"
  37. #include "services/device/screen_orientation/screen_orientation_listener_android.h"
  38. #else
  39. #include "services/device/battery/battery_monitor_impl.h"
  40. #include "services/device/battery/battery_status_service.h"
  41. #include "services/device/hid/hid_manager_impl.h"
  42. #include "services/device/vibration/vibration_manager_impl.h"
  43. #endif
  44. #if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) && defined(USE_UDEV)
  45. #include "services/device/hid/input_service_linux.h"
  46. #endif
  47. #if BUILDFLAG(IS_CHROMEOS_LACROS)
  48. #include "chromeos/lacros/lacros_service.h"
  49. #endif
  50. namespace {
  51. #if !BUILDFLAG(IS_ANDROID)
  52. constexpr bool IsLaCrOS() {
  53. #if BUILDFLAG(IS_CHROMEOS_LACROS)
  54. return true;
  55. #else
  56. return false;
  57. #endif
  58. }
  59. #endif
  60. #if !BUILDFLAG(IS_ANDROID)
  61. void BindLaCrOSHidManager(
  62. mojo::PendingReceiver<device::mojom::HidManager> receiver) {
  63. #if BUILDFLAG(IS_CHROMEOS_LACROS)
  64. // LaCrOS does not have direct access to the permission_broker service over
  65. // D-Bus. Use the HidManager interface from ash-chrome instead.
  66. auto* lacros_service = chromeos::LacrosService::Get();
  67. DCHECK(lacros_service);
  68. // If the Hid manager is not available, then the pending receiver is deleted.
  69. if (lacros_service->IsAvailable<device::mojom::HidManager>()) {
  70. lacros_service->GetRemote<device::mojom::HidManager>()->AddReceiver(
  71. std::move(receiver));
  72. }
  73. #endif
  74. }
  75. #endif
  76. } // namespace
  77. namespace device {
  78. DeviceServiceParams::DeviceServiceParams() = default;
  79. DeviceServiceParams::~DeviceServiceParams() = default;
  80. std::unique_ptr<DeviceService> CreateDeviceService(
  81. std::unique_ptr<DeviceServiceParams> params,
  82. mojo::PendingReceiver<mojom::DeviceService> receiver) {
  83. GeolocationProviderImpl::SetGeolocationConfiguration(
  84. params->url_loader_factory, params->geolocation_api_key,
  85. params->custom_location_provider_callback, params->geolocation_manager,
  86. params->use_gms_core_location_provider);
  87. return std::make_unique<DeviceService>(std::move(params),
  88. std::move(receiver));
  89. }
  90. DeviceService::DeviceService(
  91. std::unique_ptr<DeviceServiceParams> params,
  92. mojo::PendingReceiver<mojom::DeviceService> receiver)
  93. : file_task_runner_(std::move(params->file_task_runner)),
  94. io_task_runner_(std::move(params->io_task_runner)),
  95. url_loader_factory_(std::move(params->url_loader_factory)),
  96. network_connection_tracker_(params->network_connection_tracker),
  97. geolocation_api_key_(params->geolocation_api_key),
  98. wake_lock_context_callback_(params->wake_lock_context_callback),
  99. wake_lock_provider_(file_task_runner_,
  100. params->wake_lock_context_callback) {
  101. receivers_.Add(this, std::move(receiver));
  102. #if BUILDFLAG(IS_ANDROID)
  103. java_nfc_delegate_.Reset(params->java_nfc_delegate);
  104. #endif
  105. #if defined(IS_SERIAL_ENABLED_PLATFORM)
  106. serial_port_manager_ = std::make_unique<SerialPortManagerImpl>(
  107. io_task_runner_, base::ThreadTaskRunnerHandle::Get());
  108. #if BUILDFLAG(IS_MAC)
  109. // On macOS the SerialDeviceEnumerator needs to run on the UI thread so that
  110. // it has access to a CFRunLoop where it can register a notification source.
  111. serial_port_manager_task_runner_ = base::ThreadTaskRunnerHandle::Get();
  112. #else
  113. // On other platforms it must be allowed to do blocking IO.
  114. serial_port_manager_task_runner_ =
  115. base::ThreadPool::CreateSequencedTaskRunner(
  116. {base::MayBlock(), base::TaskPriority::BEST_EFFORT});
  117. #endif
  118. #endif // defined(IS_SERIAL_ENABLED_PLATFORM)
  119. #if !BUILDFLAG(IS_ANDROID)
  120. // Ensure that the battery backend is initialized now; otherwise it may end up
  121. // getting initialized on access during destruction, when it's no longer safe
  122. // to initialize.
  123. device::BatteryStatusService::GetInstance();
  124. #endif // !BUILDFLAG(IS_ANDROID)
  125. }
  126. DeviceService::~DeviceService() {
  127. #if !BUILDFLAG(IS_ANDROID) && !BUILDFLAG(IS_CHROMEOS_ASH)
  128. // NOTE: We don't call this on Chrome OS due to https://crbug.com/856771, as
  129. // Shutdown() implicitly depends on DBusThreadManager, which may already be
  130. // destroyed by the time DeviceService is destroyed. Fortunately on Chrome OS
  131. // it's not really important that this runs anyway.
  132. device::BatteryStatusService::GetInstance()->Shutdown();
  133. #endif
  134. #if defined(IS_SERIAL_ENABLED_PLATFORM)
  135. auto* serial_port_manager = serial_port_manager_.release();
  136. if (!serial_port_manager_task_runner_->DeleteSoon(FROM_HERE,
  137. serial_port_manager)) {
  138. // The ThreadPool can be shutdown by the time ~DeviceService is triggered.
  139. // Synchronously delete |serial_port_manager| in that event (which is
  140. // naturally sequenced after the last task on
  141. // |serial_port_manager_task_runner_| per ThreadPool shutdown semantics).
  142. // See crbug.com/1263149#c20 for details.
  143. delete serial_port_manager;
  144. }
  145. #endif // defined(IS_SERIAL_ENABLED_PLATFORM)
  146. }
  147. void DeviceService::AddReceiver(
  148. mojo::PendingReceiver<mojom::DeviceService> receiver) {
  149. receivers_.Add(this, std::move(receiver));
  150. }
  151. void DeviceService::SetPlatformSensorProviderForTesting(
  152. std::unique_ptr<PlatformSensorProvider> provider) {
  153. DCHECK(!sensor_provider_);
  154. sensor_provider_ = std::make_unique<SensorProviderImpl>(std::move(provider));
  155. }
  156. // static
  157. void DeviceService::OverrideGeolocationContextBinderForTesting(
  158. GeolocationContextBinder binder) {
  159. internal::GetGeolocationContextBinderOverride() = std::move(binder);
  160. }
  161. // static
  162. void DeviceService::OverridePressureManagerBinderForTesting(
  163. PressureManagerBinder binder) {
  164. internal::GetPressureManagerBinderOverride() = std::move(binder);
  165. }
  166. void DeviceService::BindBatteryMonitor(
  167. mojo::PendingReceiver<mojom::BatteryMonitor> receiver) {
  168. #if BUILDFLAG(IS_ANDROID)
  169. GetJavaInterfaceProvider()->GetInterface(std::move(receiver));
  170. #else
  171. BatteryMonitorImpl::Create(std::move(receiver));
  172. #endif
  173. }
  174. void DeviceService::BindPressureManager(
  175. mojo::PendingReceiver<mojom::PressureManager> receiver) {
  176. const auto& binder_override = internal::GetPressureManagerBinderOverride();
  177. if (binder_override) {
  178. binder_override.Run(std::move(receiver));
  179. return;
  180. }
  181. if (!pressure_manager_)
  182. pressure_manager_ = PressureManagerImpl::Create();
  183. pressure_manager_->Bind(std::move(receiver));
  184. }
  185. #if BUILDFLAG(IS_ANDROID)
  186. // static
  187. void DeviceService::OverrideNFCProviderBinderForTesting(
  188. NFCProviderBinder binder) {
  189. internal::GetNFCProviderBinderOverride() = std::move(binder);
  190. }
  191. void DeviceService::BindNFCProvider(
  192. mojo::PendingReceiver<mojom::NFCProvider> receiver) {
  193. const auto& binder_override = internal::GetNFCProviderBinderOverride();
  194. if (binder_override)
  195. binder_override.Run(std::move(receiver));
  196. else
  197. GetJavaInterfaceProvider()->GetInterface(std::move(receiver));
  198. }
  199. #endif
  200. void DeviceService::BindVibrationManager(
  201. mojo::PendingReceiver<mojom::VibrationManager> receiver) {
  202. #if BUILDFLAG(IS_ANDROID)
  203. GetJavaInterfaceProvider()->GetInterface(std::move(receiver));
  204. #else
  205. VibrationManagerImpl::Create(std::move(receiver));
  206. #endif
  207. }
  208. #if !BUILDFLAG(IS_ANDROID)
  209. void DeviceService::BindHidManager(
  210. mojo::PendingReceiver<mojom::HidManager> receiver) {
  211. if (IsLaCrOS() && !HidManagerImpl::IsHidServiceTesting()) {
  212. BindLaCrOSHidManager(std::move(receiver));
  213. } else {
  214. if (!hid_manager_)
  215. hid_manager_ = std::make_unique<HidManagerImpl>();
  216. hid_manager_->AddReceiver(std::move(receiver));
  217. }
  218. }
  219. #endif
  220. #if BUILDFLAG(IS_CHROMEOS_ASH)
  221. void DeviceService::BindBluetoothSystemFactory(
  222. mojo::PendingReceiver<mojom::BluetoothSystemFactory> receiver) {
  223. BluetoothSystemFactory::CreateFactory(std::move(receiver));
  224. }
  225. void DeviceService::BindMtpManager(
  226. mojo::PendingReceiver<mojom::MtpManager> receiver) {
  227. if (!mtp_device_manager_)
  228. mtp_device_manager_ = MtpDeviceManager::Initialize();
  229. mtp_device_manager_->AddReceiver(std::move(receiver));
  230. }
  231. #endif
  232. #if (BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS)) && defined(USE_UDEV)
  233. void DeviceService::BindInputDeviceManager(
  234. mojo::PendingReceiver<mojom::InputDeviceManager> receiver) {
  235. file_task_runner_->PostTask(
  236. FROM_HERE,
  237. base::BindOnce(&InputServiceLinux::BindReceiver, std::move(receiver)));
  238. }
  239. #endif
  240. void DeviceService::BindFingerprint(
  241. mojo::PendingReceiver<mojom::Fingerprint> receiver) {
  242. Fingerprint::Create(std::move(receiver));
  243. }
  244. void DeviceService::BindGeolocationConfig(
  245. mojo::PendingReceiver<mojom::GeolocationConfig> receiver) {
  246. GeolocationConfig::Create(std::move(receiver));
  247. }
  248. void DeviceService::BindGeolocationContext(
  249. mojo::PendingReceiver<mojom::GeolocationContext> receiver) {
  250. const auto& binder_override = internal::GetGeolocationContextBinderOverride();
  251. if (binder_override) {
  252. binder_override.Run(std::move(receiver));
  253. return;
  254. }
  255. GeolocationContext::Create(std::move(receiver));
  256. }
  257. void DeviceService::BindGeolocationControl(
  258. mojo::PendingReceiver<mojom::GeolocationControl> receiver) {
  259. GeolocationProviderImpl::GetInstance()->BindGeolocationControlReceiver(
  260. std::move(receiver));
  261. }
  262. void DeviceService::BindPowerMonitor(
  263. mojo::PendingReceiver<mojom::PowerMonitor> receiver) {
  264. if (!power_monitor_message_broadcaster_) {
  265. power_monitor_message_broadcaster_ =
  266. std::make_unique<PowerMonitorMessageBroadcaster>();
  267. }
  268. power_monitor_message_broadcaster_->Bind(std::move(receiver));
  269. }
  270. void DeviceService::BindPublicIpAddressGeolocationProvider(
  271. mojo::PendingReceiver<mojom::PublicIpAddressGeolocationProvider> receiver) {
  272. if (!public_ip_address_geolocation_provider_) {
  273. public_ip_address_geolocation_provider_ =
  274. std::make_unique<PublicIpAddressGeolocationProvider>(
  275. url_loader_factory_, network_connection_tracker_,
  276. geolocation_api_key_);
  277. }
  278. public_ip_address_geolocation_provider_->Bind(std::move(receiver));
  279. }
  280. void DeviceService::BindScreenOrientationListener(
  281. mojo::PendingReceiver<mojom::ScreenOrientationListener> receiver) {
  282. #if BUILDFLAG(IS_ANDROID)
  283. if (io_task_runner_) {
  284. io_task_runner_->PostTask(
  285. FROM_HERE, base::BindOnce(&ScreenOrientationListenerAndroid::Create,
  286. std::move(receiver)));
  287. }
  288. #endif
  289. }
  290. void DeviceService::BindSensorProvider(
  291. mojo::PendingReceiver<mojom::SensorProvider> receiver) {
  292. if (!sensor_provider_) {
  293. auto platform_provider = PlatformSensorProvider::Create();
  294. if (!platform_provider)
  295. return;
  296. sensor_provider_ =
  297. std::make_unique<SensorProviderImpl>(std::move(platform_provider));
  298. }
  299. sensor_provider_->Bind(std::move(receiver));
  300. }
  301. #if BUILDFLAG(IS_ANDROID) || BUILDFLAG(IS_WIN)
  302. void DeviceService::BindDevicePostureProvider(
  303. mojo::PendingReceiver<mojom::DevicePostureProvider> receiver) {
  304. if (!device_posture_provider_) {
  305. auto posture_platform_provider_ = DevicePosturePlatformProvider::Create();
  306. if (!posture_platform_provider_)
  307. return;
  308. device_posture_provider_ = std::make_unique<DevicePostureProviderImpl>(
  309. std::move(posture_platform_provider_));
  310. }
  311. device_posture_provider_->Bind(std::move(receiver));
  312. }
  313. #endif
  314. void DeviceService::BindSerialPortManager(
  315. mojo::PendingReceiver<mojom::SerialPortManager> receiver) {
  316. #if defined(IS_SERIAL_ENABLED_PLATFORM)
  317. // TODO(crbug.com/1109621): SerialPortManagerImpl depends on the
  318. // permission_broker service on Chromium OS. We will need to redirect
  319. // connections for LaCrOS here.
  320. DCHECK(serial_port_manager_task_runner_);
  321. serial_port_manager_task_runner_->PostTask(
  322. FROM_HERE, base::BindOnce(&SerialPortManagerImpl::Bind,
  323. base::Unretained(serial_port_manager_.get()),
  324. std::move(receiver)));
  325. #else // defined(IS_SERIAL_ENABLED_PLATFORM)
  326. NOTREACHED() << "Serial devices not supported on this platform.";
  327. #endif // defined(IS_SERIAL_ENABLED_PLATFORM)
  328. }
  329. void DeviceService::BindTimeZoneMonitor(
  330. mojo::PendingReceiver<mojom::TimeZoneMonitor> receiver) {
  331. if (!time_zone_monitor_)
  332. time_zone_monitor_ = TimeZoneMonitor::Create(file_task_runner_);
  333. time_zone_monitor_->Bind(std::move(receiver));
  334. }
  335. void DeviceService::BindWakeLockProvider(
  336. mojo::PendingReceiver<mojom::WakeLockProvider> receiver) {
  337. wake_lock_provider_.AddBinding(std::move(receiver));
  338. }
  339. void DeviceService::BindUsbDeviceManager(
  340. mojo::PendingReceiver<mojom::UsbDeviceManager> receiver) {
  341. // TODO(crbug.com/1109621): usb::DeviceManagerImpl depends on the
  342. // permission_broker service on Chromium OS. We will need to redirect
  343. // connections for LaCrOS here.
  344. if (!usb_device_manager_)
  345. usb_device_manager_ = std::make_unique<usb::DeviceManagerImpl>();
  346. usb_device_manager_->AddReceiver(std::move(receiver));
  347. }
  348. void DeviceService::BindUsbDeviceManagerTest(
  349. mojo::PendingReceiver<mojom::UsbDeviceManagerTest> receiver) {
  350. // TODO(crbug.com/1109621): usb::DeviceManagerImpl depends on the
  351. // permission_broker service on Chromium OS. We will need to redirect
  352. // connections for LaCrOS here.
  353. if (!usb_device_manager_)
  354. usb_device_manager_ = std::make_unique<usb::DeviceManagerImpl>();
  355. if (!usb_device_manager_test_) {
  356. usb_device_manager_test_ = std::make_unique<usb::DeviceManagerTest>(
  357. usb_device_manager_->GetUsbService());
  358. }
  359. usb_device_manager_test_->BindReceiver(std::move(receiver));
  360. }
  361. #if BUILDFLAG(IS_ANDROID)
  362. service_manager::InterfaceProvider* DeviceService::GetJavaInterfaceProvider() {
  363. if (!java_interface_provider_initialized_) {
  364. mojo::PendingRemote<service_manager::mojom::InterfaceProvider> provider;
  365. JNIEnv* env = base::android::AttachCurrentThread();
  366. Java_InterfaceRegistrar_createInterfaceRegistryForContext(
  367. env,
  368. provider.InitWithNewPipeAndPassReceiver().PassPipe().release().value(),
  369. java_nfc_delegate_);
  370. java_interface_provider_.Bind(std::move(provider));
  371. java_interface_provider_initialized_ = true;
  372. }
  373. return &java_interface_provider_;
  374. }
  375. #endif
  376. } // namespace device