1 /*
2 * Copyright (c) 2021-2022 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 <memory>
17 #include <unistd.h>
18
19 #include "audio_errors.h"
20 #include "media_log.h"
21
22 #include "audio_adapter_manager.h"
23
24 namespace OHOS {
25 namespace AudioStandard {
Init()26 bool AudioAdapterManager::Init()
27 {
28 return true;
29 }
30
ConnectServiceAdapter()31 bool AudioAdapterManager::ConnectServiceAdapter()
32 {
33 std::unique_ptr<AudioAdapterManager> audioAdapterManager(this);
34 std::unique_ptr<PolicyCallbackImpl> policyCallbackImpl = std::make_unique<PolicyCallbackImpl>(audioAdapterManager);
35 mAudioServiceAdapter = AudioServiceAdapter::CreateAudioAdapter(std::move(policyCallbackImpl));
36 if (!mAudioServiceAdapter) {
37 MEDIA_ERR_LOG("[AudioAdapterManager] Error in audio adapter initialization");
38 return false;
39 }
40
41 bool result = mAudioServiceAdapter->Connect();
42 if (!result) {
43 MEDIA_ERR_LOG("[AudioAdapterManager] Error in connecting audio adapter");
44 return false;
45 }
46
47 return true;
48 }
49
50
InitKVStore()51 void AudioAdapterManager::InitKVStore()
52 {
53 bool isFirstBoot = false;
54 InitAudioPolicyKvStore(isFirstBoot);
55 InitVolumeMap(isFirstBoot);
56 InitRingerMode(isFirstBoot);
57 }
58
Deinit(void)59 void AudioAdapterManager::Deinit(void)
60 {
61 if (!mAudioServiceAdapter) {
62 MEDIA_ERR_LOG("[AudioAdapterManager] audio adapter null");
63 return;
64 }
65
66 return mAudioServiceAdapter->Disconnect();
67 }
68
SetAudioSessionCallback(AudioSessionCallback * callback)69 int32_t AudioAdapterManager::SetAudioSessionCallback(AudioSessionCallback *callback)
70 {
71 if (callback == nullptr) {
72 MEDIA_ERR_LOG("[AudioAdapterManager] SetAudioSessionCallback callback == nullptr");
73 return ERR_INVALID_PARAM;
74 }
75
76 sessionCallback_ = callback;
77 return SUCCESS;
78 }
79
SetStreamVolume(AudioStreamType streamType,float volume)80 int32_t AudioAdapterManager::SetStreamVolume(AudioStreamType streamType, float volume)
81 {
82 if (!mAudioServiceAdapter) {
83 MEDIA_ERR_LOG("[AudioAdapterManager] audio adapter null");
84 return ERR_OPERATION_FAILED;
85 }
86
87 // Incase if KvStore didnot connect during bootup
88 if (mAudioPolicyKvStore == nullptr) {
89 bool isFirstBoot = false;
90 InitAudioPolicyKvStore(isFirstBoot);
91 }
92
93 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
94 mVolumeMap[streamForVolumeMap] = volume;
95 WriteVolumeToKvStore(streamType, volume);
96
97 return mAudioServiceAdapter->SetVolume(streamType, volume);
98 }
99
GetStreamVolume(AudioStreamType streamType)100 float AudioAdapterManager::GetStreamVolume(AudioStreamType streamType)
101 {
102 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
103
104 return mVolumeMap[streamForVolumeMap];
105 }
106
SetStreamMute(AudioStreamType streamType,bool mute)107 int32_t AudioAdapterManager::SetStreamMute(AudioStreamType streamType, bool mute)
108 {
109 if (!mAudioServiceAdapter) {
110 MEDIA_ERR_LOG("[AudioAdapterManager] audio adapter null");
111 return ERR_OPERATION_FAILED;
112 }
113
114 return mAudioServiceAdapter->SetMute(streamType, mute);
115 }
116
GetStreamMute(AudioStreamType streamType) const117 bool AudioAdapterManager::GetStreamMute(AudioStreamType streamType) const
118 {
119 if (!mAudioServiceAdapter) {
120 MEDIA_ERR_LOG("[AudioAdapterManager] audio adapter null");
121 return false;
122 }
123
124 return mAudioServiceAdapter->IsMute(streamType);
125 }
126
IsStreamActive(AudioStreamType streamType)127 bool AudioAdapterManager::IsStreamActive(AudioStreamType streamType)
128 {
129 if (!mAudioServiceAdapter) {
130 MEDIA_ERR_LOG("[AudioAdapterManager] audio adapter null");
131 return false;
132 }
133
134 return mAudioServiceAdapter->IsStreamActive(streamType);
135 }
136
SuspendAudioDevice(std::string & portName,bool isSuspend)137 int32_t AudioAdapterManager::SuspendAudioDevice(std::string &portName, bool isSuspend)
138 {
139 if (!mAudioServiceAdapter) {
140 MEDIA_ERR_LOG("[AudioAdapterManager] audio adapter null");
141 return ERR_OPERATION_FAILED;
142 }
143
144 return mAudioServiceAdapter->SuspendAudioDevice(portName, isSuspend);
145 }
146
SetDeviceActive(AudioIOHandle ioHandle,InternalDeviceType deviceType,std::string name,bool active)147 int32_t AudioAdapterManager::SetDeviceActive(AudioIOHandle ioHandle, InternalDeviceType deviceType,
148 std::string name, bool active)
149 {
150 if (!mAudioServiceAdapter) {
151 MEDIA_ERR_LOG("[AudioAdapterManager] audio adapter null");
152 return ERR_OPERATION_FAILED;
153 }
154
155 switch (deviceType) {
156 case InternalDeviceType::DEVICE_TYPE_SPEAKER:
157 case InternalDeviceType::DEVICE_TYPE_WIRED_HEADSET:
158 case InternalDeviceType::DEVICE_TYPE_USB_HEADSET:
159 case InternalDeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
160 case InternalDeviceType::DEVICE_TYPE_BLUETOOTH_SCO: {
161 MEDIA_INFO_LOG("SetDefaultSink %{public}d", deviceType);
162 return mAudioServiceAdapter->SetDefaultSink(name);
163 }
164 case InternalDeviceType::DEVICE_TYPE_MIC: {
165 MEDIA_INFO_LOG("SetDefaultSource %{public}d", deviceType);
166 return mAudioServiceAdapter->SetDefaultSource(name);
167 }
168 default:
169 break;
170 }
171 return SUCCESS;
172 }
173
SetRingerMode(AudioRingerMode ringerMode)174 int32_t AudioAdapterManager::SetRingerMode(AudioRingerMode ringerMode)
175 {
176 mRingerMode = ringerMode;
177
178 // Incase if KvStore didnot connect during bootup
179 if (mAudioPolicyKvStore == nullptr) {
180 bool isFirstBoot = false;
181 InitAudioPolicyKvStore(isFirstBoot);
182 }
183
184 WriteRingerModeToKvStore(ringerMode);
185 return SUCCESS;
186 }
187
GetRingerMode() const188 AudioRingerMode AudioAdapterManager::GetRingerMode() const
189 {
190 return mRingerMode;
191 }
192
OpenAudioPort(const AudioModuleInfo & audioModuleInfo)193 AudioIOHandle AudioAdapterManager::OpenAudioPort(const AudioModuleInfo &audioModuleInfo)
194 {
195 std::string moduleArgs = GetModuleArgs(audioModuleInfo);
196 MEDIA_INFO_LOG("[Adapter load-module] %{public}s %{public}s", audioModuleInfo.lib.c_str(), moduleArgs.c_str());
197 if (audioModuleInfo.lib == PIPE_SOURCE || audioModuleInfo.lib == PIPE_SINK) {
198 if (!audioModuleInfo.fileName.empty() && access(audioModuleInfo.fileName.c_str(), F_OK) == 0) {
199 int32_t ret = std::remove(audioModuleInfo.fileName.c_str());
200 if (ret) {
201 MEDIA_ERR_LOG("Removing pipe file failed!. Ret val: %{public}d", ret);
202 return ERR_OPERATION_FAILED;
203 }
204 }
205 }
206
207 CHECK_AND_RETURN_RET_LOG(mAudioServiceAdapter != nullptr, ERR_OPERATION_FAILED, "ServiceAdapter is null");
208 return mAudioServiceAdapter->OpenAudioPort(audioModuleInfo.lib, moduleArgs.c_str());
209 }
210
CloseAudioPort(AudioIOHandle ioHandle)211 int32_t AudioAdapterManager::CloseAudioPort(AudioIOHandle ioHandle)
212 {
213 CHECK_AND_RETURN_RET_LOG(mAudioServiceAdapter != nullptr, ERR_OPERATION_FAILED, "ServiceAdapter is null");
214 return mAudioServiceAdapter->CloseAudioPort(ioHandle);
215 }
216
UpdateCommonArgs(const AudioModuleInfo & audioModuleInfo,std::string & args)217 void UpdateCommonArgs(const AudioModuleInfo &audioModuleInfo, std::string &args)
218 {
219 if (!audioModuleInfo.rate.empty()) {
220 args = "rate=";
221 args.append(audioModuleInfo.rate);
222 }
223
224 if (!audioModuleInfo.channels.empty()) {
225 args.append(" channels=");
226 args.append(audioModuleInfo.channels);
227 }
228
229 if (!audioModuleInfo.bufferSize.empty()) {
230 args.append(" buffer_size=");
231 args.append(audioModuleInfo.bufferSize);
232 }
233
234 if (!audioModuleInfo.format.empty()) {
235 args.append(" format=");
236 args.append(audioModuleInfo.format);
237 MEDIA_INFO_LOG("[PolicyManager] format: %{public}s", args.c_str());
238 }
239 }
240
241 // Private Members
GetModuleArgs(const AudioModuleInfo & audioModuleInfo) const242 std::string AudioAdapterManager::GetModuleArgs(const AudioModuleInfo &audioModuleInfo) const
243 {
244 std::string args;
245
246 if (audioModuleInfo.lib == HDI_SINK) {
247 UpdateCommonArgs(audioModuleInfo, args);
248 if (!audioModuleInfo.adapterName.empty()) {
249 args.append(" sink_name=");
250 args.append(audioModuleInfo.name);
251 }
252
253 if (!audioModuleInfo.className.empty()) {
254 args.append(" device_class=");
255 args.append(audioModuleInfo.className);
256 }
257 } else if (audioModuleInfo.lib == HDI_SOURCE) {
258 UpdateCommonArgs(audioModuleInfo, args);
259 if (!audioModuleInfo.adapterName.empty()) {
260 args.append(" source_name=");
261 args.append(audioModuleInfo.name);
262 }
263 } else if (audioModuleInfo.lib == PIPE_SINK) {
264 if (!audioModuleInfo.fileName.empty()) {
265 args = "file=";
266 args.append(audioModuleInfo.fileName);
267 }
268 } else if (audioModuleInfo.lib == PIPE_SOURCE) {
269 if (!audioModuleInfo.fileName.empty()) {
270 args = "file=";
271 args.append(audioModuleInfo.fileName);
272 }
273 }
274
275 return args;
276 }
277
GetStreamNameByStreamType(AudioStreamType streamType)278 std::string AudioAdapterManager::GetStreamNameByStreamType(AudioStreamType streamType)
279 {
280 switch (streamType) {
281 case STREAM_MUSIC:
282 return "music";
283 case STREAM_RING:
284 return "ring";
285 case STREAM_SYSTEM:
286 return "system";
287 case STREAM_NOTIFICATION:
288 return "notification";
289 case STREAM_ALARM:
290 return "alarm";
291 case STREAM_DTMF:
292 return "dtmf";
293 case STREAM_VOICE_CALL:
294 return "voice_call";
295 case STREAM_VOICE_ASSISTANT:
296 return "voice_assistant";
297 default:
298 return "";
299 }
300 }
301
GetStreamIDByType(std::string streamType)302 AudioStreamType AudioAdapterManager::GetStreamIDByType(std::string streamType)
303 {
304 AudioStreamType stream = STREAM_MUSIC;
305
306 if (!streamType.compare(std::string("music")))
307 stream = STREAM_MUSIC;
308 else if (!streamType.compare(std::string("ring")))
309 stream = STREAM_RING;
310 else if (!streamType.compare(std::string("voice_call")))
311 stream = STREAM_VOICE_CALL;
312 else if (!streamType.compare(std::string("system")))
313 stream = STREAM_SYSTEM;
314 else if (!streamType.compare(std::string("notification")))
315 stream = STREAM_NOTIFICATION;
316 else if (!streamType.compare(std::string("alarm")))
317 stream = STREAM_ALARM;
318 else if (!streamType.compare(std::string("voice_assistant")))
319 stream = STREAM_VOICE_ASSISTANT;
320
321 return stream;
322 }
323
GetStreamForVolumeMap(AudioStreamType streamType)324 AudioStreamType AudioAdapterManager::GetStreamForVolumeMap(AudioStreamType streamType)
325 {
326 switch (streamType) {
327 case STREAM_MUSIC:
328 return STREAM_MUSIC;
329 case STREAM_NOTIFICATION:
330 case STREAM_DTMF:
331 case STREAM_SYSTEM:
332 case STREAM_RING:
333 return STREAM_RING;
334 case STREAM_ALARM:
335 return STREAM_ALARM;
336 case STREAM_VOICE_CALL:
337 return STREAM_VOICE_CALL;
338 case STREAM_VOICE_ASSISTANT:
339 return STREAM_VOICE_ASSISTANT;
340 default:
341 return STREAM_MUSIC;
342 }
343 }
344
InitAudioPolicyKvStore(bool & isFirstBoot)345 bool AudioAdapterManager::InitAudioPolicyKvStore(bool& isFirstBoot)
346 {
347 DistributedKvDataManager manager;
348 Options options;
349
350 options.createIfMissing = false;
351 options.encrypt = false;
352 options.autoSync = true;
353 options.kvStoreType = KvStoreType::SINGLE_VERSION;
354
355 AppId appId;
356 appId.appId = "policymanager";
357 StoreId storeId;
358 storeId.storeId = "audiopolicy";
359 Status status = Status::SUCCESS;
360
361 // open and initialize kvstore instance.
362 if (mAudioPolicyKvStore == nullptr) {
363 uint32_t retries = 0;
364
365 do {
366 status = manager.GetSingleKvStore(options, appId, storeId, mAudioPolicyKvStore);
367 if (status == Status::STORE_NOT_FOUND) {
368 MEDIA_ERR_LOG("[AudioAdapterManager] InitAudioPolicyKvStore: STORE_NOT_FOUND!");
369 }
370
371 if ((status == Status::SUCCESS) || (status == Status::STORE_NOT_FOUND)) {
372 break;
373 } else {
374 MEDIA_ERR_LOG("[AudioAdapterManager] InitAudioPolicyKvStore: Kvstore Connect failed! Retrying.");
375 retries++;
376 usleep(KVSTORE_CONNECT_RETRY_DELAY_TIME);
377 }
378 } while (retries <= KVSTORE_CONNECT_RETRY_COUNT);
379 }
380
381 if (mAudioPolicyKvStore == nullptr) {
382 if (status == Status::STORE_NOT_FOUND) {
383 MEDIA_INFO_LOG("[AudioAdapterManager] First Boot: Create AudioPolicyKvStore");
384 options.createIfMissing = true;
385 // [create and] open and initialize kvstore instance.
386 status = manager.GetSingleKvStore(options, appId, storeId, mAudioPolicyKvStore);
387 if (status == Status::SUCCESS) {
388 isFirstBoot = true;
389 } else {
390 MEDIA_ERR_LOG("[AudioAdapterManager] Create AudioPolicyKvStore Failed!");
391 }
392 }
393 }
394
395 if (mAudioPolicyKvStore == nullptr) {
396 MEDIA_ERR_LOG("[AudioAdapterManager] InitAudioPolicyKvStore: Failed!");
397 return false;
398 }
399
400 return true;
401 }
402
InitVolumeMap(bool isFirstBoot)403 void AudioAdapterManager::InitVolumeMap(bool isFirstBoot)
404 {
405 if (isFirstBoot == true) {
406 WriteVolumeToKvStore(STREAM_MUSIC, MAX_VOLUME);
407 WriteVolumeToKvStore(STREAM_RING, MAX_VOLUME);
408 WriteVolumeToKvStore(STREAM_VOICE_CALL, MAX_VOLUME);
409 WriteVolumeToKvStore(STREAM_VOICE_ASSISTANT, MAX_VOLUME);
410 MEDIA_INFO_LOG("[AudioAdapterManager] Wrote default stream volumes to KvStore");
411 } else {
412 LoadVolumeMap();
413 }
414 }
415
InitRingerMode(bool isFirstBoot)416 void AudioAdapterManager::InitRingerMode(bool isFirstBoot)
417 {
418 if (mAudioPolicyKvStore == nullptr) {
419 MEDIA_ERR_LOG("[AudioAdapterManager] mAudioPolicyKvStore is null!");
420 return;
421 }
422
423 if (isFirstBoot == true) {
424 mRingerMode = RINGER_MODE_NORMAL;
425 WriteRingerModeToKvStore(RINGER_MODE_NORMAL);
426 MEDIA_INFO_LOG("[AudioAdapterManager] Wrote default ringer mode to KvStore");
427 } else {
428 LoadRingerMode();
429 }
430 }
431
LoadVolumeFromKvStore(AudioStreamType streamType)432 bool AudioAdapterManager::LoadVolumeFromKvStore(AudioStreamType streamType)
433 {
434 Key key;
435 Value value;
436
437 switch (streamType) {
438 case STREAM_MUSIC:
439 key = "music";
440 break;
441 case STREAM_RING:
442 key = "ring";
443 break;
444 case STREAM_VOICE_CALL:
445 key = "voice_call";
446 break;
447 case STREAM_VOICE_ASSISTANT:
448 key = "voice_assistant";
449 break;
450 default:
451 return false;
452 }
453
454 Status status = mAudioPolicyKvStore->Get(key, value);
455 if (status == Status::SUCCESS) {
456 float volume = TransferByteArrayToType<float>(value.Data());
457 mVolumeMap[streamType] = volume;
458 MEDIA_DEBUG_LOG("[AudioAdapterManager] volume from kvStore %{public}f for streamType:%{public}d",
459 volume, streamType);
460 return true;
461 }
462
463 return false;
464 }
465
LoadVolumeMap(void)466 bool AudioAdapterManager::LoadVolumeMap(void)
467 {
468 if (mAudioPolicyKvStore == nullptr) {
469 MEDIA_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: mAudioPolicyKvStore is null!");
470 return false;
471 }
472
473 if (!LoadVolumeFromKvStore(STREAM_MUSIC))
474 MEDIA_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for Music from kvStore!");
475
476 if (!LoadVolumeFromKvStore(STREAM_RING))
477 MEDIA_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for Ring from kvStore!");
478
479 if (!LoadVolumeFromKvStore(STREAM_VOICE_CALL))
480 MEDIA_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for voice_call from kvStore!");
481
482 if (!LoadVolumeFromKvStore(STREAM_VOICE_ASSISTANT))
483 MEDIA_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for voice_assistant from kvStore!");
484
485 return true;
486 }
487
LoadRingerMode(void)488 bool AudioAdapterManager::LoadRingerMode(void)
489 {
490 if (mAudioPolicyKvStore == nullptr) {
491 MEDIA_ERR_LOG("[AudioAdapterManager] LoadRingerMap: mAudioPolicyKvStore is null!");
492 return false;
493 }
494
495 // get ringer mode value from kvstore.
496 Key key = "ringermode";
497 Value value;
498 Status status = mAudioPolicyKvStore->Get(key, value);
499 if (status == Status::SUCCESS) {
500 mRingerMode = static_cast<AudioRingerMode>(TransferByteArrayToType<int>(value.Data()));
501 MEDIA_DEBUG_LOG("[AudioAdapterManager] Ringer Mode from kvStore %{public}d", mRingerMode);
502 }
503
504 return true;
505 }
506
WriteVolumeToKvStore(AudioStreamType streamType,float volume)507 void AudioAdapterManager::WriteVolumeToKvStore(AudioStreamType streamType, float volume)
508 {
509 if (mAudioPolicyKvStore == nullptr)
510 return;
511
512 Key key = GetStreamNameByStreamType(streamType);
513 Value value = Value(TransferTypeToByteArray<float>(volume));
514
515 Status status = mAudioPolicyKvStore->Put(key, value);
516 if (status == Status::SUCCESS) {
517 MEDIA_INFO_LOG("[AudioAdapterManager] volume %{public}f for %{public}s updated in kvStore", volume,
518 GetStreamNameByStreamType(streamType).c_str());
519 } else {
520 MEDIA_ERR_LOG("[AudioAdapterManager] volume %{public}f for %{public}s failed to update in kvStore!", volume,
521 GetStreamNameByStreamType(streamType).c_str());
522 }
523
524 return;
525 }
526
WriteRingerModeToKvStore(AudioRingerMode ringerMode)527 void AudioAdapterManager::WriteRingerModeToKvStore(AudioRingerMode ringerMode)
528 {
529 if (mAudioPolicyKvStore == nullptr)
530 return;
531
532 Key key = "ringermode";
533 Value value = Value(TransferTypeToByteArray<int>(ringerMode));
534
535 Status status = mAudioPolicyKvStore->Put(key, value);
536 if (status == Status::SUCCESS) {
537 MEDIA_INFO_LOG("[AudioAdapterManager] Wrote RingerMode:%d to kvStore", ringerMode);
538 } else {
539 MEDIA_ERR_LOG("[AudioAdapterManager] Writing RingerMode:%d to kvStore failed!", ringerMode);
540 }
541
542 return;
543 }
544 } // namespace AudioStandard
545 } // namespace OHOS
546