1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_device_manager.h"
17 #include "avsession_log.h"
18 #include "migrate_avsession_constant.h"
19
20 namespace OHOS::AVSession {
GetInstance()21 AudioDeviceManager &AudioDeviceManager::GetInstance()
22 {
23 static AudioDeviceManager instance;
24 return instance;
25 }
26
GetSessionInfoSyncState()27 bool AudioDeviceManager::GetSessionInfoSyncState()
28 {
29 AudioStandard::AudioRoutingManager *audioRoutingManager =
30 AudioStandard::AudioRoutingManager::GetInstance();
31 std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> devices =
32 audioRoutingManager->GetAvailableDevices(AudioStandard::AudioDeviceUsage::MEDIA_OUTPUT_DEVICES);
33 bool isConnected = false;
34 for (auto& device : devices) {
35 if (device != nullptr &&
36 AudioStandard::DeviceCategory::BT_CAR == device->deviceCategory_ &&
37 AudioStandard::DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP == device->deviceType_) {
38 isConnected = true;
39 break;
40 }
41 }
42 bool isSourceAudio = AUDIO_OUTPUT_SOURCE == outputDevice_;
43 return isConnected || isSourceAudio;
44 }
45
InitAudioStateCallback(std::shared_ptr<MigrateAVSessionServer> migrateAVSession,std::string deviceId)46 void AudioDeviceManager::InitAudioStateCallback(std::shared_ptr<MigrateAVSessionServer> migrateAVSession,
47 std::string deviceId)
48 {
49 SLOGI("enter RegisterAudioDeviceChangeCallback");
50 if (isRegistered_) {
51 SLOGW("device change callback already registered");
52 return;
53 }
54 RegisterAudioDeviceChangeCallback();
55 RegisterPreferedOutputDeviceChangeCallback();
56 migrateSession_ = migrateAVSession;
57 isRegistered_ = true;
58 deviceId_ = deviceId;
59 }
60
UnInitAudioStateCallback()61 void AudioDeviceManager::UnInitAudioStateCallback()
62 {
63 UnRegisterAudioDeviceChangeCallback();
64 UnRegisterPreferedOutputDeviceChangeCallback();
65 isRegistered_ = false;
66 }
67
RegisterAudioDeviceChangeCallback()68 void AudioDeviceManager::RegisterAudioDeviceChangeCallback()
69 {
70 SLOGI("enter RegisterAudioDeviceChangeCallback");
71 if (audioDeviceChangeCallback_ == nullptr) {
72 audioDeviceChangeCallback_ = std::make_shared<DeviceChangeCallback>();
73 }
74 AudioStandard::AudioSystemManager *audioSystemManager =
75 AudioStandard::AudioSystemManager::GetInstance();
76 if (audioSystemManager == nullptr) {
77 SLOGE("audioSystemManager is null");
78 return;
79 }
80 audioSystemManager->SetDeviceChangeCallback(AudioStandard::DeviceFlag::OUTPUT_DEVICES_FLAG,
81 audioDeviceChangeCallback_);
82 }
83
UnRegisterAudioDeviceChangeCallback()84 void AudioDeviceManager::UnRegisterAudioDeviceChangeCallback()
85 {
86 SLOGI("enter UnRegisterAudioDeviceChangeCallback");
87 AudioStandard::AudioSystemManager *audioSystemManager =
88 AudioStandard::AudioSystemManager::GetInstance();
89 if (audioSystemManager == nullptr) {
90 SLOGE("audioSystemManager is null");
91 return;
92 }
93 audioSystemManager->UnsetDeviceChangeCallback(AudioStandard::DeviceFlag::OUTPUT_DEVICES_FLAG);
94 }
95
RegisterPreferedOutputDeviceChangeCallback()96 void AudioDeviceManager::RegisterPreferedOutputDeviceChangeCallback()
97 {
98 if (audioPreferedOutputDeviceChangeCallback_ == nullptr) {
99 audioPreferedOutputDeviceChangeCallback_ = std::make_shared<OutputDeviceChangeCallback>();
100 }
101 AudioStandard::AudioRoutingManager *audioRoutingManager =
102 AudioStandard::AudioRoutingManager::GetInstance();
103 if (audioRoutingManager == nullptr) {
104 SLOGE("audioRoutingManager is null");
105 return;
106 }
107 AudioStandard::AudioRendererInfo rendererInfo;
108 rendererInfo.streamUsage = AudioStandard::STREAM_USAGE_MUSIC;
109 audioRoutingManager->SetPreferredOutputDeviceChangeCallback(rendererInfo,
110 audioPreferedOutputDeviceChangeCallback_);
111 }
112
UnRegisterPreferedOutputDeviceChangeCallback()113 void AudioDeviceManager::UnRegisterPreferedOutputDeviceChangeCallback()
114 {
115 SLOGI("enter UnRegisterPreferedOutputDeviceChangeCallback");
116 AudioStandard::AudioRoutingManager *audioRoutingManager = AudioStandard::AudioRoutingManager::GetInstance();
117 if (audioRoutingManager == nullptr) {
118 SLOGE("audioRoutingManger is null");
119 return;
120 }
121 audioRoutingManager->UnsetPreferredOutputDeviceChangeCallback();
122 }
123
SendRemoteAvSessionInfo(const std::string & deviceId)124 void AudioDeviceManager::SendRemoteAvSessionInfo(const std::string &deviceId)
125 {
126 if (migrateSession_ != nullptr) {
127 migrateSession_->SendRemoteControllerList(deviceId);
128 migrateSession_->SendRemoteHistorySessionList(deviceId);
129 }
130 }
131
ClearRemoteAvSessionInfo(const std::string & deviceId)132 void AudioDeviceManager::ClearRemoteAvSessionInfo(const std::string &deviceId)
133 {
134 if (migrateSession_ != nullptr) {
135 migrateSession_->ClearRemoteControllerList(deviceId);
136 migrateSession_->ClearRemoteHistorySessionList(deviceId);
137 }
138 }
139
GetDeviceId()140 std::string AudioDeviceManager::GetDeviceId()
141 {
142 return deviceId_;
143 }
144
GetAudioState()145 int32_t AudioDeviceManager::GetAudioState()
146 {
147 return outputDevice_;
148 }
149
SetAudioState(int32_t state)150 void AudioDeviceManager::SetAudioState(int32_t state)
151 {
152 SLOGI("current set audio is %{public}d", state);
153 outputDevice_ = state;
154 }
155
OnDeviceChange(const AudioStandard::DeviceChangeAction & deviceChangeAction)156 void DeviceChangeCallback::OnDeviceChange(const AudioStandard::DeviceChangeAction &deviceChangeAction)
157 {
158 SLOGI("receive OnDeviceChange");
159 AudioStandard::AudioSystemManager *audioSystemManager =
160 AudioStandard::AudioSystemManager::GetInstance();
161 if (audioSystemManager == nullptr) {
162 SLOGE("audioSystemManager is null");
163 return;
164 }
165 if (AudioStandard::DeviceChangeType::DISCONNECT == deviceChangeAction.type) {
166 std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> deviceDescriptors =
167 deviceChangeAction.deviceDescriptors;
168 for (auto &device : deviceDescriptors) {
169 if (device != nullptr &&
170 AudioStandard::DeviceCategory::BT_CAR == device->deviceCategory_ &&
171 AudioStandard::DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP == device->deviceType_) {
172 AudioDeviceManager::GetInstance().SendRemoteAvSessionInfo(
173 AudioDeviceManager::GetInstance().GetDeviceId());
174 break;
175 }
176 }
177 }
178 }
179
OnPreferredOutputDeviceUpdated(const std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> & desc)180 void OutputDeviceChangeCallback::OnPreferredOutputDeviceUpdated(
181 const std::vector<std::shared_ptr<AudioStandard::AudioDeviceDescriptor>> &desc)
182 {
183 SLOGI("receive OnPreferedOutputDeviceUpdated");
184 if (desc.empty()) {
185 SLOGE("device is empty");
186 return;
187 }
188
189 auto deviceDesc = desc[0];
190 if (deviceDesc == nullptr) {
191 SLOGE("device is null");
192 return;
193 }
194 std::lock_guard lockGuard(lock_);
195 std::string deviceId = AudioDeviceManager::GetInstance().GetDeviceId();
196 if (AudioStandard::LOCAL_NETWORK_ID == deviceDesc->networkId_) {
197 if (AUDIO_OUTPUT_SOURCE == AudioDeviceManager::GetInstance().GetAudioState()) {
198 return;
199 }
200 AudioDeviceManager::GetInstance().ClearRemoteAvSessionInfo(deviceId);
201 AudioDeviceManager::GetInstance().SetAudioState(AUDIO_OUTPUT_SOURCE);
202 } else {
203 if (AUDIO_OUTPUT_SINK == AudioDeviceManager::GetInstance().GetAudioState()) {
204 return;
205 }
206 SLOGI("receive OnPreferedOutputDeviceUpdated send remote session");
207 AudioDeviceManager::GetInstance().SetAudioState(AUDIO_OUTPUT_SINK);
208 AudioDeviceManager::GetInstance().SendRemoteAvSessionInfo(deviceId);
209 }
210 }
211 }