service.cc 6.1 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186
  1. // Copyright 2017 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/audio/service.h"
  5. #include <memory>
  6. #include <utility>
  7. #include "base/bind.h"
  8. #include "base/check_op.h"
  9. #include "base/no_destructor.h"
  10. #include "base/system/system_monitor.h"
  11. #include "base/task/deferred_sequenced_task_runner.h"
  12. #include "base/task/single_thread_task_runner.h"
  13. #include "base/time/default_tick_clock.h"
  14. #include "base/trace_event/trace_event.h"
  15. #include "build/build_config.h"
  16. #include "media/audio/audio_manager.h"
  17. #include "media/base/bind_to_current_loop.h"
  18. #include "media/media_buildflags.h"
  19. #include "services/audio/aecdump_recording_manager.h"
  20. #include "services/audio/debug_recording.h"
  21. #include "services/audio/device_notifier.h"
  22. #include "services/audio/log_factory_manager.h"
  23. #include "services/audio/service_metrics.h"
  24. #include "services/audio/system_info.h"
  25. #if BUILDFLAG(IS_APPLE)
  26. #include "media/audio/mac/audio_device_listener_mac.h"
  27. #endif
  28. namespace audio {
  29. Service::Service(std::unique_ptr<AudioManagerAccessor> audio_manager_accessor,
  30. bool enable_remote_client_support,
  31. mojo::PendingReceiver<mojom::AudioService> receiver)
  32. : receiver_(this, std::move(receiver)),
  33. audio_manager_accessor_(std::move(audio_manager_accessor)),
  34. enable_remote_client_support_(enable_remote_client_support) {
  35. DCHECK(audio_manager_accessor_);
  36. if (enable_remote_client_support_) {
  37. CHECK(!base::SystemMonitor::Get());
  38. system_monitor_ = std::make_unique<base::SystemMonitor>();
  39. log_factory_manager_ = std::make_unique<LogFactoryManager>();
  40. audio_manager_accessor_->SetAudioLogFactory(
  41. log_factory_manager_->GetLogFactory());
  42. } else {
  43. // Start device monitoring explicitly if no mojo device notifier will be
  44. // created. This is required for in-process device notifications.
  45. InitializeDeviceMonitor();
  46. }
  47. TRACE_EVENT0("audio", "audio::Service::OnStart");
  48. // This will pre-create AudioManager if AudioManagerAccessor owns it.
  49. CHECK(audio_manager_accessor_->GetAudioManager());
  50. #if BUILDFLAG(CHROME_WIDE_ECHO_CANCELLATION)
  51. aecdump_recording_manager_ = std::make_unique<AecdumpRecordingManager>(
  52. audio_manager_accessor_->GetAudioManager()->GetTaskRunner());
  53. #endif
  54. metrics_ =
  55. std::make_unique<ServiceMetrics>(base::DefaultTickClock::GetInstance());
  56. }
  57. Service::~Service() {
  58. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  59. TRACE_EVENT0("audio", "audio::Service::~Service");
  60. metrics_.reset();
  61. // Stop all streams cleanly before shutting down the audio manager.
  62. stream_factory_.reset();
  63. // Reset |debug_recording_| to disable debug recording before AudioManager
  64. // shutdown.
  65. debug_recording_.reset();
  66. audio_manager_accessor_->Shutdown();
  67. }
  68. // static
  69. base::DeferredSequencedTaskRunner* Service::GetInProcessTaskRunner() {
  70. static const base::NoDestructor<
  71. scoped_refptr<base::DeferredSequencedTaskRunner>>
  72. instance(base::MakeRefCounted<base::DeferredSequencedTaskRunner>());
  73. return instance->get();
  74. }
  75. // static
  76. void Service::SetSystemInfoBinderForTesting(SystemInfoBinder binder) {
  77. GetSystemInfoBinderForTesting() = std::move(binder);
  78. }
  79. // static
  80. void Service::SetTestingApiBinderForTesting(TestingApiBinder binder) {
  81. GetTestingApiBinder() = std::move(binder);
  82. }
  83. void Service::BindSystemInfo(
  84. mojo::PendingReceiver<mojom::SystemInfo> receiver) {
  85. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  86. auto& binder_override = GetSystemInfoBinderForTesting();
  87. if (binder_override) {
  88. binder_override.Run(std::move(receiver));
  89. return;
  90. }
  91. if (!system_info_) {
  92. system_info_ = std::make_unique<SystemInfo>(
  93. audio_manager_accessor_->GetAudioManager());
  94. }
  95. system_info_->Bind(std::move(receiver));
  96. }
  97. void Service::BindDebugRecording(
  98. mojo::PendingReceiver<mojom::DebugRecording> receiver) {
  99. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  100. // Accept only one bind request at a time. Old receiver is overwritten.
  101. // |debug_recording_| must be reset first to disable debug recording, and then
  102. // create a new DebugRecording instance to enable debug recording.
  103. debug_recording_.reset();
  104. debug_recording_ = std::make_unique<DebugRecording>(
  105. std::move(receiver), audio_manager_accessor_->GetAudioManager(),
  106. aecdump_recording_manager_.get());
  107. }
  108. void Service::BindStreamFactory(
  109. mojo::PendingReceiver<media::mojom::AudioStreamFactory> receiver) {
  110. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  111. if (!stream_factory_)
  112. stream_factory_.emplace(audio_manager_accessor_->GetAudioManager(),
  113. aecdump_recording_manager_.get());
  114. stream_factory_->Bind(std::move(receiver));
  115. }
  116. void Service::BindDeviceNotifier(
  117. mojo::PendingReceiver<mojom::DeviceNotifier> receiver) {
  118. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  119. DCHECK(enable_remote_client_support_);
  120. InitializeDeviceMonitor();
  121. if (!device_notifier_)
  122. device_notifier_ = std::make_unique<DeviceNotifier>();
  123. device_notifier_->Bind(std::move(receiver));
  124. }
  125. void Service::BindLogFactoryManager(
  126. mojo::PendingReceiver<mojom::LogFactoryManager> receiver) {
  127. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  128. DCHECK(log_factory_manager_);
  129. DCHECK(enable_remote_client_support_);
  130. log_factory_manager_->Bind(std::move(receiver));
  131. }
  132. void Service::BindTestingApi(
  133. mojo::PendingReceiver<mojom::TestingApi> receiver) {
  134. auto& binder = GetTestingApiBinder();
  135. if (binder)
  136. binder.Run(std::move(receiver));
  137. }
  138. void Service::InitializeDeviceMonitor() {
  139. DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
  140. #if BUILDFLAG(IS_APPLE)
  141. if (audio_device_listener_mac_)
  142. return;
  143. TRACE_EVENT0("audio", "audio::Service::InitializeDeviceMonitor");
  144. audio_device_listener_mac_ = std::make_unique<media::AudioDeviceListenerMac>(
  145. media::BindToCurrentLoop(base::BindRepeating([] {
  146. if (auto* monitor = base::SystemMonitor::Get())
  147. monitor->ProcessDevicesChanged(base::SystemMonitor::DEVTYPE_AUDIO);
  148. })),
  149. true /* monitor_default_input */, true /* monitor_addition_removal */,
  150. true /* monitor_sources */);
  151. #endif
  152. }
  153. } // namespace audio