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 "audio_log.h"
21 #include "parameter.h"
22
23 #include "audio_adapter_manager.h"
24
25 using namespace std;
26
27 namespace OHOS {
28 namespace AudioStandard {
Init()29 bool AudioAdapterManager::Init()
30 {
31 char testMode[10] = {0}; // 10 for system parameter usage
32 auto res = GetParameter("debug.audio_service.testmodeon", "0", testMode, sizeof(testMode));
33 if (res == 1 && testMode[0] == '1') {
34 AUDIO_DEBUG_LOG("testMode on");
35 testModeOn_ = true;
36 }
37
38 char currentVolumeValue[3] = {0};
39 auto ret = GetParameter("persist.multimedia.audio.mediavolume", "15",
40 currentVolumeValue, sizeof(currentVolumeValue));
41 if (ret > 0) {
42 int32_t valueNumber = atoi(currentVolumeValue);
43 mVolumeMap[STREAM_MUSIC] = AudioGroupManager::MapVolumeToHDI(valueNumber);
44 AUDIO_INFO_LOG("[AudioAdapterManager] Get music volume to map success %{public}f", mVolumeMap[STREAM_MUSIC]);
45 } else {
46 AUDIO_ERR_LOG("[AudioAdapterManager] Get volume parameter failed %{public}d", ret);
47 }
48
49 return true;
50 }
51
ConnectServiceAdapter()52 bool AudioAdapterManager::ConnectServiceAdapter()
53 {
54 std::shared_ptr<AudioAdapterManager> audioAdapterManager(this);
55 std::unique_ptr<PolicyCallbackImpl> policyCallbackImpl = std::make_unique<PolicyCallbackImpl>(audioAdapterManager);
56 mAudioServiceAdapter = AudioServiceAdapter::CreateAudioAdapter(std::move(policyCallbackImpl));
57 if (!mAudioServiceAdapter) {
58 AUDIO_ERR_LOG("[AudioAdapterManager] Error in audio adapter initialization");
59 return false;
60 }
61
62 bool result = mAudioServiceAdapter->Connect();
63 if (!result) {
64 AUDIO_ERR_LOG("[AudioAdapterManager] Error in connecting audio adapter");
65 return false;
66 }
67
68 return true;
69 }
70
71
InitKVStore()72 void AudioAdapterManager::InitKVStore()
73 {
74 bool isFirstBoot = false;
75 InitAudioPolicyKvStore(isFirstBoot);
76 InitVolumeMap(isFirstBoot);
77 InitRingerMode(isFirstBoot);
78 InitMuteStatusMap(isFirstBoot);
79 }
80
Deinit(void)81 void AudioAdapterManager::Deinit(void)
82 {
83 if (!mAudioServiceAdapter) {
84 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
85 return;
86 }
87
88 return mAudioServiceAdapter->Disconnect();
89 }
90
SetAudioSessionCallback(AudioSessionCallback * callback)91 int32_t AudioAdapterManager::SetAudioSessionCallback(AudioSessionCallback *callback)
92 {
93 if (callback == nullptr) {
94 AUDIO_ERR_LOG("[AudioAdapterManager] SetAudioSessionCallback callback == nullptr");
95 return ERR_INVALID_PARAM;
96 }
97
98 sessionCallback_ = callback;
99 return SUCCESS;
100 }
101
SetStreamVolume(AudioStreamType streamType,float volume)102 int32_t AudioAdapterManager::SetStreamVolume(AudioStreamType streamType, float volume)
103 {
104 if (FLOAT_COMPARE_EQ(volume, 0.0f) &&
105 (streamType == STREAM_VOICE_ASSISTANT || streamType == STREAM_VOICE_CALL)) {
106 // these types can not set to mute, but don't return error
107 AUDIO_ERR_LOG("SetStreamVolume this type can not set mute");
108 return SUCCESS;
109 }
110
111 if (!mAudioServiceAdapter) {
112 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
113 return ERR_OPERATION_FAILED;
114 }
115
116 // In case if KvStore didnot connect during bootup
117 if (mAudioPolicyKvStore == nullptr) {
118 bool isFirstBoot = false;
119 InitAudioPolicyKvStore(isFirstBoot);
120 }
121
122 if (GetStreamMute(streamType) && volume > 0.0f) {
123 SetStreamMute(streamType, 0);
124 }
125 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
126 mVolumeMap[streamForVolumeMap] = volume;
127 WriteVolumeToKvStore(currentActiveDevice_, streamType, volume);
128
129 // Set the power on default volume to the database
130 if (streamType == STREAM_MUSIC) {
131 int32_t maxMediaVolume = 15; // The max volume is 15;
132 int32_t volumeInt = (int) round(volume * maxMediaVolume);
133 AUDIO_INFO_LOG("[AudioAdapterManager] Start set volume value to %{public}d", volumeInt);
134 int ret = SetParameter("persist.multimedia.audio.mediavolume", std::to_string(volumeInt).c_str());
135 if (ret == 0) {
136 AUDIO_INFO_LOG("[AudioAdapterManager] Save media volume success %{public}d", volumeInt);
137 } else {
138 AUDIO_ERR_LOG("[AudioAdapterManager] Save media volume failed, result %{public}d", ret);
139 }
140 }
141
142 return mAudioServiceAdapter->SetVolume(streamType, volume);
143 }
144
GetStreamVolume(AudioStreamType streamType)145 float AudioAdapterManager::GetStreamVolume(AudioStreamType streamType)
146 {
147 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
148
149 return mVolumeMap[streamForVolumeMap];
150 }
151
SetStreamMute(AudioStreamType streamType,bool mute)152 int32_t AudioAdapterManager::SetStreamMute(AudioStreamType streamType, bool mute)
153 {
154 if (mute &&
155 (streamType == STREAM_VOICE_ASSISTANT || streamType == STREAM_VOICE_CALL)) {
156 // these types can not set to mute, but don't return error
157 AUDIO_ERR_LOG("SetStreamMute: this type can not set mute");
158 return SUCCESS;
159 }
160
161 if (!mAudioServiceAdapter) {
162 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
163 return ERR_OPERATION_FAILED;
164 }
165 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
166 mMuteStatusMap[streamForVolumeMap] = mute;
167 WriteMuteStatusToKvStore(currentActiveDevice_, streamType, mute);
168 return mAudioServiceAdapter->SetMute(streamType, mute);
169 }
170
SetSourceOutputStreamMute(int32_t uid,bool setMute)171 int32_t AudioAdapterManager::SetSourceOutputStreamMute(int32_t uid, bool setMute)
172 {
173 if (!mAudioServiceAdapter) {
174 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
175 return ERR_OPERATION_FAILED;
176 }
177 return mAudioServiceAdapter->SetSourceOutputMute(uid, setMute);
178 }
179
GetStreamMute(AudioStreamType streamType)180 bool AudioAdapterManager::GetStreamMute(AudioStreamType streamType)
181 {
182 if (!mAudioServiceAdapter) {
183 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
184 return false;
185 }
186 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
187 return mMuteStatusMap[streamForVolumeMap];
188 }
189
IsStreamActive(AudioStreamType streamType)190 bool AudioAdapterManager::IsStreamActive(AudioStreamType streamType)
191 {
192 if (!mAudioServiceAdapter) {
193 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
194 return false;
195 }
196
197 return mAudioServiceAdapter->IsStreamActive(streamType);
198 }
199
GetAllSinkInputs()200 vector<SinkInput> AudioAdapterManager::GetAllSinkInputs()
201 {
202 if (!mAudioServiceAdapter) {
203 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
204 vector<SinkInput> sinkInputList;
205 return sinkInputList;
206 }
207
208 return mAudioServiceAdapter->GetAllSinkInputs();
209 }
210
GetAllSourceOutputs()211 vector<SourceOutput> AudioAdapterManager::GetAllSourceOutputs()
212 {
213 if (!mAudioServiceAdapter) {
214 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
215 vector<SourceOutput> sourceOutputList;
216 return sourceOutputList;
217 }
218
219 return mAudioServiceAdapter->GetAllSourceOutputs();
220 }
221
SuspendAudioDevice(std::string & portName,bool isSuspend)222 int32_t AudioAdapterManager::SuspendAudioDevice(std::string &portName, bool isSuspend)
223 {
224 if (!mAudioServiceAdapter) {
225 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
226 return ERR_OPERATION_FAILED;
227 }
228
229 return mAudioServiceAdapter->SuspendAudioDevice(portName, isSuspend);
230 }
231
SelectDevice(DeviceRole deviceRole,InternalDeviceType deviceType,std::string name)232 int32_t AudioAdapterManager::SelectDevice(DeviceRole deviceRole, InternalDeviceType deviceType, std::string name)
233 {
234 if (!mAudioServiceAdapter) {
235 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
236 return ERR_OPERATION_FAILED;
237 }
238 switch (deviceRole) {
239 case DeviceRole::INPUT_DEVICE:
240 return mAudioServiceAdapter->SetDefaultSource(name);
241 case DeviceRole::OUTPUT_DEVICE: {
242 SetVolumeForSwitchDevice(deviceType);
243 AUDIO_INFO_LOG("SetDefaultSink %{public}d", deviceType);
244 return mAudioServiceAdapter->SetDefaultSink(name);
245 }
246 default:
247 AUDIO_ERR_LOG("[AudioAdapterManager] error deviceRole %{public}d", deviceRole);
248 return ERR_OPERATION_FAILED;
249 }
250 return SUCCESS;
251 }
252
SetDeviceActive(AudioIOHandle ioHandle,InternalDeviceType deviceType,std::string name,bool active)253 int32_t AudioAdapterManager::SetDeviceActive(AudioIOHandle ioHandle, InternalDeviceType deviceType,
254 std::string name, bool active)
255 {
256 if (!mAudioServiceAdapter) {
257 AUDIO_ERR_LOG("[AudioAdapterManager] audio adapter null");
258 return ERR_OPERATION_FAILED;
259 }
260
261 switch (deviceType) {
262 case InternalDeviceType::DEVICE_TYPE_SPEAKER:
263 case InternalDeviceType::DEVICE_TYPE_FILE_SINK:
264 case InternalDeviceType::DEVICE_TYPE_WIRED_HEADSET:
265 case InternalDeviceType::DEVICE_TYPE_USB_HEADSET:
266 case InternalDeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
267 case InternalDeviceType::DEVICE_TYPE_BLUETOOTH_SCO: {
268 SetVolumeForSwitchDevice(deviceType);
269 AUDIO_INFO_LOG("SetDefaultSink %{public}d", deviceType);
270 return mAudioServiceAdapter->SetDefaultSink(name);
271 }
272 case InternalDeviceType::DEVICE_TYPE_FILE_SOURCE:
273 case InternalDeviceType::DEVICE_TYPE_MIC: {
274 AUDIO_INFO_LOG("SetDefaultSource %{public}d", deviceType);
275 return mAudioServiceAdapter->SetDefaultSource(name);
276 }
277 default:
278 break;
279 }
280 return SUCCESS;
281 }
282
SetVolumeForSwitchDevice(InternalDeviceType deviceType)283 void AudioAdapterManager::SetVolumeForSwitchDevice(InternalDeviceType deviceType)
284 {
285 if (mAudioPolicyKvStore == nullptr) {
286 AUDIO_ERR_LOG("[AudioAdapterManager] mAudioPolicyKvStore is null!");
287 return;
288 }
289 currentActiveDevice_ = deviceType;
290 LoadVolumeMap();
291 std::vector<AudioStreamType> streamTypeList = {
292 STREAM_MUSIC,
293 STREAM_RING,
294 STREAM_VOICE_CALL,
295 STREAM_VOICE_ASSISTANT
296 };
297 auto iter = streamTypeList.begin();
298 while (iter != streamTypeList.end()) {
299 Key key = GetStreamNameByStreamType(deviceType, *iter);
300 Value value = Value(TransferTypeToByteArray<float>(0));
301 Status status = mAudioPolicyKvStore->Get(key, value);
302 if (status == SUCCESS) {
303 float volume = TransferByteArrayToType<float>(value.Data());
304 SetStreamVolume(*iter, volume);
305 }
306 iter++;
307 }
308 }
309
MoveSinkInputByIndexOrName(uint32_t sinkInputId,uint32_t sinkIndex,std::string sinkName)310 int32_t AudioAdapterManager::MoveSinkInputByIndexOrName(uint32_t sinkInputId, uint32_t sinkIndex, std::string sinkName)
311 {
312 return mAudioServiceAdapter->MoveSinkInputByIndexOrName(sinkInputId, sinkIndex, sinkName);
313 }
314
MoveSourceOutputByIndexOrName(uint32_t sourceOutputId,uint32_t sourceIndex,std::string sourceName)315 int32_t AudioAdapterManager::MoveSourceOutputByIndexOrName(uint32_t sourceOutputId, uint32_t sourceIndex,
316 std::string sourceName)
317 {
318 return mAudioServiceAdapter->MoveSourceOutputByIndexOrName(sourceOutputId, sourceIndex, sourceName);
319 }
320
SetRingerMode(AudioRingerMode ringerMode)321 int32_t AudioAdapterManager::SetRingerMode(AudioRingerMode ringerMode)
322 {
323 mRingerMode = ringerMode;
324
325 // In case if KvStore didnot connect during bootup
326 if (mAudioPolicyKvStore == nullptr) {
327 bool isFirstBoot = false;
328 InitAudioPolicyKvStore(isFirstBoot);
329 }
330
331 WriteRingerModeToKvStore(ringerMode);
332 return SUCCESS;
333 }
334
GetRingerMode() const335 AudioRingerMode AudioAdapterManager::GetRingerMode() const
336 {
337 return mRingerMode;
338 }
339
OpenAudioPort(const AudioModuleInfo & audioModuleInfo)340 AudioIOHandle AudioAdapterManager::OpenAudioPort(const AudioModuleInfo &audioModuleInfo)
341 {
342 std::string moduleArgs = GetModuleArgs(audioModuleInfo);
343 AUDIO_INFO_LOG("[Adapter load-module] %{public}s %{public}s", audioModuleInfo.lib.c_str(), moduleArgs.c_str());
344
345 CHECK_AND_RETURN_RET_LOG(mAudioServiceAdapter != nullptr, ERR_OPERATION_FAILED, "ServiceAdapter is null");
346 return mAudioServiceAdapter->OpenAudioPort(audioModuleInfo.lib, moduleArgs.c_str());
347 }
348
CloseAudioPort(AudioIOHandle ioHandle)349 int32_t AudioAdapterManager::CloseAudioPort(AudioIOHandle ioHandle)
350 {
351 CHECK_AND_RETURN_RET_LOG(mAudioServiceAdapter != nullptr, ERR_OPERATION_FAILED, "ServiceAdapter is null");
352 return mAudioServiceAdapter->CloseAudioPort(ioHandle);
353 }
354
UpdateCommonArgs(const AudioModuleInfo & audioModuleInfo,std::string & args)355 void UpdateCommonArgs(const AudioModuleInfo &audioModuleInfo, std::string &args)
356 {
357 if (!audioModuleInfo.rate.empty()) {
358 args = "rate=";
359 args.append(audioModuleInfo.rate);
360 }
361
362 if (!audioModuleInfo.channels.empty()) {
363 args.append(" channels=");
364 args.append(audioModuleInfo.channels);
365 }
366
367 if (!audioModuleInfo.bufferSize.empty()) {
368 args.append(" buffer_size=");
369 args.append(audioModuleInfo.bufferSize);
370 }
371
372 if (!audioModuleInfo.format.empty()) {
373 args.append(" format=");
374 args.append(audioModuleInfo.format);
375 AUDIO_INFO_LOG("[PolicyManager] format: %{public}s", args.c_str());
376 }
377
378 if (!audioModuleInfo.fixedLatency.empty()) {
379 args.append(" fixed_latency=");
380 args.append(audioModuleInfo.fixedLatency);
381 }
382
383 if (!audioModuleInfo.renderInIdleState.empty()) {
384 args.append(" render_in_idle_state=");
385 args.append(audioModuleInfo.renderInIdleState);
386 }
387
388 if (!audioModuleInfo.OpenMicSpeaker.empty()) {
389 args.append(" open_mic_speaker=");
390 args.append(audioModuleInfo.OpenMicSpeaker);
391 }
392 }
393
394 // Private Members
GetModuleArgs(const AudioModuleInfo & audioModuleInfo) const395 std::string AudioAdapterManager::GetModuleArgs(const AudioModuleInfo &audioModuleInfo) const
396 {
397 std::string args;
398
399 if (audioModuleInfo.lib == HDI_SINK) {
400 UpdateCommonArgs(audioModuleInfo, args);
401 if (!audioModuleInfo.name.empty()) {
402 args.append(" sink_name=");
403 args.append(audioModuleInfo.name);
404 }
405
406 if (!audioModuleInfo.adapterName.empty()) {
407 args.append(" adapter_name=");
408 args.append(audioModuleInfo.adapterName);
409 }
410
411 if (!audioModuleInfo.className.empty()) {
412 args.append(" device_class=");
413 args.append(audioModuleInfo.className);
414 }
415
416 if (!audioModuleInfo.fileName.empty()) {
417 args.append(" file_path=");
418 args.append(audioModuleInfo.fileName);
419 }
420 if (!audioModuleInfo.sinkLatency.empty()) {
421 args.append(" sink_latency=");
422 args.append(audioModuleInfo.sinkLatency);
423 }
424 if (testModeOn_) {
425 args.append(" test_mode_on=");
426 args.append("1");
427 }
428 if (!audioModuleInfo.networkId.empty()) {
429 args.append(" network_id=");
430 args.append(audioModuleInfo.networkId);
431 } else {
432 args.append(" network_id=LocalDevice");
433 }
434
435 if (!audioModuleInfo.deviceType.empty()) {
436 args.append(" device_type=");
437 args.append(audioModuleInfo.deviceType);
438 }
439 } else if (audioModuleInfo.lib == HDI_SOURCE) {
440 UpdateCommonArgs(audioModuleInfo, args);
441 if (!audioModuleInfo.name.empty()) {
442 args.append(" source_name=");
443 args.append(audioModuleInfo.name);
444 }
445
446 if (!audioModuleInfo.adapterName.empty()) {
447 args.append(" adapter_name=");
448 args.append(audioModuleInfo.adapterName);
449 }
450
451 if (!audioModuleInfo.className.empty()) {
452 args.append(" device_class=");
453 args.append(audioModuleInfo.className);
454 }
455
456 if (!audioModuleInfo.fileName.empty()) {
457 args.append(" file_path=");
458 args.append(audioModuleInfo.fileName);
459 }
460
461 if (!audioModuleInfo.networkId.empty()) {
462 args.append(" network_id=");
463 args.append(audioModuleInfo.networkId);
464 } else {
465 args.append(" network_id=LocalDevice");
466 }
467
468 if (!audioModuleInfo.deviceType.empty()) {
469 args.append(" device_type=");
470 args.append(audioModuleInfo.deviceType);
471 }
472 } else if (audioModuleInfo.lib == PIPE_SINK) {
473 if (!audioModuleInfo.fileName.empty()) {
474 args = "file=";
475 args.append(audioModuleInfo.fileName);
476 }
477 } else if (audioModuleInfo.lib == PIPE_SOURCE) {
478 if (!audioModuleInfo.fileName.empty()) {
479 args = "file=";
480 args.append(audioModuleInfo.fileName);
481 }
482 }
483 return args;
484 }
485
GetStreamNameByStreamType(DeviceType deviceType,AudioStreamType streamType)486 std::string AudioAdapterManager::GetStreamNameByStreamType(DeviceType deviceType, AudioStreamType streamType)
487 {
488 std::string type;
489 switch (deviceType) {
490 case DEVICE_TYPE_SPEAKER:
491 type = "primary";
492 break;
493 case DEVICE_TYPE_BLUETOOTH_A2DP:
494 type = "bluetooth";
495 break;
496 case DEVICE_TYPE_WIRED_HEADSET:
497 type = "wired";
498 break;
499 case DEVICE_TYPE_USB_HEADSET:
500 type = "usb";
501 break;
502 default:
503 AUDIO_ERR_LOG("[AudioAdapterManager::GetStreamNameByStreamType] deivice %{public}d is not supported for kv"
504 " store", deviceType);
505 return "";
506 }
507
508 switch (streamType) {
509 case STREAM_MUSIC:
510 return type + "music";
511 case STREAM_RING:
512 return type + "ring";
513 case STREAM_SYSTEM:
514 return type + "system";
515 case STREAM_NOTIFICATION:
516 return type + "notification";
517 case STREAM_ALARM:
518 return type + "alarm";
519 case STREAM_DTMF:
520 return type + "dtmf";
521 case STREAM_VOICE_CALL:
522 return type + "voice_call";
523 case STREAM_VOICE_ASSISTANT:
524 return type + "voice_assistant";
525 default:
526 return "";
527 }
528 }
529
GetStreamIDByType(std::string streamType)530 AudioStreamType AudioAdapterManager::GetStreamIDByType(std::string streamType)
531 {
532 AudioStreamType stream = STREAM_MUSIC;
533
534 if (!streamType.compare(std::string("music")))
535 stream = STREAM_MUSIC;
536 else if (!streamType.compare(std::string("ring")))
537 stream = STREAM_RING;
538 else if (!streamType.compare(std::string("voice_call")))
539 stream = STREAM_VOICE_CALL;
540 else if (!streamType.compare(std::string("system")))
541 stream = STREAM_SYSTEM;
542 else if (!streamType.compare(std::string("notification")))
543 stream = STREAM_NOTIFICATION;
544 else if (!streamType.compare(std::string("alarm")))
545 stream = STREAM_ALARM;
546 else if (!streamType.compare(std::string("voice_assistant")))
547 stream = STREAM_VOICE_ASSISTANT;
548
549 return stream;
550 }
551
GetStreamForVolumeMap(AudioStreamType streamType)552 AudioStreamType AudioAdapterManager::GetStreamForVolumeMap(AudioStreamType streamType)
553 {
554 switch (streamType) {
555 case STREAM_MUSIC:
556 return STREAM_MUSIC;
557 case STREAM_NOTIFICATION:
558 case STREAM_DTMF:
559 case STREAM_SYSTEM:
560 case STREAM_RING:
561 return STREAM_RING;
562 case STREAM_ALARM:
563 return STREAM_ALARM;
564 case STREAM_VOICE_CALL:
565 return STREAM_VOICE_CALL;
566 case STREAM_VOICE_ASSISTANT:
567 return STREAM_VOICE_ASSISTANT;
568 default:
569 return STREAM_MUSIC;
570 }
571 }
572
InitAudioPolicyKvStore(bool & isFirstBoot)573 bool AudioAdapterManager::InitAudioPolicyKvStore(bool& isFirstBoot)
574 {
575 DistributedKvDataManager manager;
576 Options options;
577
578 AppId appId;
579 appId.appId = "audio_policy_manager";
580
581 options.createIfMissing = true;
582 options.encrypt = false;
583 options.autoSync = false;
584 options.kvStoreType = KvStoreType::SINGLE_VERSION;
585 options.area = EL1;
586 options.baseDir = std::string("/data/service/el1/public/database/") + appId.appId;
587
588 StoreId storeId;
589 storeId.storeId = "audiopolicy";
590 Status status = Status::SUCCESS;
591
592 // open and initialize kvstore instance.
593 if (mAudioPolicyKvStore == nullptr) {
594 uint32_t retries = 0;
595
596 do {
597 status = manager.GetSingleKvStore(options, appId, storeId, mAudioPolicyKvStore);
598 if (status == Status::STORE_NOT_FOUND) {
599 AUDIO_ERR_LOG("[AudioAdapterManager] InitAudioPolicyKvStore: STORE_NOT_FOUND!");
600 }
601
602 if ((status == Status::SUCCESS) || (status == Status::STORE_NOT_FOUND)) {
603 break;
604 } else {
605 AUDIO_ERR_LOG("[AudioAdapterManager] InitAudioPolicyKvStore: Kvstore Connect failed! Retrying.");
606 retries++;
607 usleep(KVSTORE_CONNECT_RETRY_DELAY_TIME);
608 }
609 } while (retries <= KVSTORE_CONNECT_RETRY_COUNT);
610 }
611
612 if (mAudioPolicyKvStore == nullptr) {
613 if (status == Status::STORE_NOT_FOUND) {
614 AUDIO_INFO_LOG("[AudioAdapterManager] First Boot: Create AudioPolicyKvStore");
615 options.createIfMissing = true;
616 // [create and] open and initialize kvstore instance.
617 status = manager.GetSingleKvStore(options, appId, storeId, mAudioPolicyKvStore);
618 if (status == Status::SUCCESS) {
619 isFirstBoot = true;
620 } else {
621 AUDIO_ERR_LOG("[AudioAdapterManager] Create AudioPolicyKvStore Failed!");
622 }
623 }
624 }
625
626 if (mAudioPolicyKvStore == nullptr) {
627 AUDIO_ERR_LOG("[AudioAdapterManager] InitAudioPolicyKvStore: Failed!");
628 return false;
629 }
630
631 return true;
632 }
633
InitVolumeMap(bool isFirstBoot)634 void AudioAdapterManager::InitVolumeMap(bool isFirstBoot)
635 {
636 if (isFirstBoot == true) {
637 auto iter = deviceList_.begin();
638 while (iter != deviceList_.end()) {
639 WriteVolumeToKvStore(*iter, STREAM_MUSIC, MAX_VOLUME);
640 WriteVolumeToKvStore(*iter, STREAM_RING, MAX_VOLUME);
641 WriteVolumeToKvStore(*iter, STREAM_VOICE_CALL, MAX_VOLUME);
642 WriteVolumeToKvStore(*iter, STREAM_VOICE_ASSISTANT, MAX_VOLUME);
643 iter++;
644 }
645 AUDIO_INFO_LOG("[AudioAdapterManager] Wrote default stream volumes to KvStore");
646 } else {
647 LoadVolumeMap();
648 }
649 }
650
InitRingerMode(bool isFirstBoot)651 void AudioAdapterManager::InitRingerMode(bool isFirstBoot)
652 {
653 if (mAudioPolicyKvStore == nullptr) {
654 AUDIO_ERR_LOG("[AudioAdapterManager] mAudioPolicyKvStore is null!");
655 return;
656 }
657
658 if (isFirstBoot == true) {
659 mRingerMode = RINGER_MODE_NORMAL;
660 WriteRingerModeToKvStore(RINGER_MODE_NORMAL);
661 AUDIO_INFO_LOG("[AudioAdapterManager] Wrote default ringer mode to KvStore");
662 } else {
663 LoadRingerMode();
664 }
665 }
666
LoadVolumeFromKvStore(DeviceType deviceType,AudioStreamType streamType)667 bool AudioAdapterManager::LoadVolumeFromKvStore(DeviceType deviceType, AudioStreamType streamType)
668 {
669 Key key;
670 Value value;
671 std::string type;
672
673 switch (deviceType) {
674 case DEVICE_TYPE_SPEAKER:
675 type = "primary";
676 break;
677 case DEVICE_TYPE_BLUETOOTH_A2DP:
678 type = "bluetooth";
679 break;
680 case DEVICE_TYPE_WIRED_HEADSET:
681 type = "wired";
682 break;
683 case DEVICE_TYPE_USB_HEADSET:
684 type = "usb";
685 break;
686 default:
687 AUDIO_ERR_LOG("[AudioAdapterManager::LoadVolumeFromKvStore] deivice %{public}d is not supported for kv"
688 "store", deviceType);
689 return false;
690 }
691
692 switch (streamType) {
693 case STREAM_MUSIC:
694 key = type + "music";
695 break;
696 case STREAM_RING:
697 key = type + "ring";
698 break;
699 case STREAM_VOICE_CALL:
700 key = type + "voice_call";
701 break;
702 case STREAM_VOICE_ASSISTANT:
703 key = type + "voice_assistant";
704 break;
705 default:
706 return false;
707 }
708
709 Status status = mAudioPolicyKvStore->Get(key, value);
710 if (status == Status::SUCCESS) {
711 float volume = TransferByteArrayToType<float>(value.Data());
712 mVolumeMap[streamType] = volume;
713 AUDIO_DEBUG_LOG("[AudioAdapterManager] volume from kvStore %{public}f for streamType:%{public}d",
714 volume, streamType);
715 return true;
716 }
717
718 return false;
719 }
720
LoadVolumeMap(void)721 bool AudioAdapterManager::LoadVolumeMap(void)
722 {
723 if (mAudioPolicyKvStore == nullptr) {
724 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: mAudioPolicyKvStore is null!");
725 return false;
726 }
727
728 if (!LoadVolumeFromKvStore(currentActiveDevice_, STREAM_MUSIC))
729 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for Music from kvStore!");
730
731 if (!LoadVolumeFromKvStore(currentActiveDevice_, STREAM_RING))
732 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for Ring from kvStore!");
733
734 if (!LoadVolumeFromKvStore(currentActiveDevice_, STREAM_VOICE_CALL))
735 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for voice_call from kvStore!");
736
737 if (!LoadVolumeFromKvStore(currentActiveDevice_, STREAM_VOICE_ASSISTANT))
738 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for voice_assistant from kvStore!");
739
740 return true;
741 }
742
LoadRingerMode(void)743 bool AudioAdapterManager::LoadRingerMode(void)
744 {
745 if (mAudioPolicyKvStore == nullptr) {
746 AUDIO_ERR_LOG("[AudioAdapterManager] LoadRingerMap: mAudioPolicyKvStore is null!");
747 return false;
748 }
749
750 // get ringer mode value from kvstore.
751 Key key = "ringermode";
752 Value value;
753 Status status = mAudioPolicyKvStore->Get(key, value);
754 if (status == Status::SUCCESS) {
755 mRingerMode = static_cast<AudioRingerMode>(TransferByteArrayToType<int>(value.Data()));
756 AUDIO_DEBUG_LOG("[AudioAdapterManager] Ringer Mode from kvStore %{public}d", mRingerMode);
757 }
758
759 return true;
760 }
761
WriteVolumeToKvStore(DeviceType type,AudioStreamType streamType,float volume)762 void AudioAdapterManager::WriteVolumeToKvStore(DeviceType type, AudioStreamType streamType, float volume)
763 {
764 if (mAudioPolicyKvStore == nullptr)
765 return;
766
767 Key key = GetStreamNameByStreamType(type, streamType);
768 Value value = Value(TransferTypeToByteArray<float>(volume));
769
770 Status status = mAudioPolicyKvStore->Put(key, value);
771 if (status == Status::SUCCESS) {
772 AUDIO_INFO_LOG("[AudioAdapterManager] volume %{public}f for %{public}s updated in kvStore", volume,
773 GetStreamNameByStreamType(type, streamType).c_str());
774 } else {
775 AUDIO_ERR_LOG("[AudioAdapterManager] volume %{public}f for %{public}s failed to update in kvStore!", volume,
776 GetStreamNameByStreamType(type, streamType).c_str());
777 }
778
779 return;
780 }
781
WriteRingerModeToKvStore(AudioRingerMode ringerMode)782 void AudioAdapterManager::WriteRingerModeToKvStore(AudioRingerMode ringerMode)
783 {
784 if (mAudioPolicyKvStore == nullptr)
785 return;
786
787 Key key = "ringermode";
788 Value value = Value(TransferTypeToByteArray<int>(ringerMode));
789
790 Status status = mAudioPolicyKvStore->Put(key, value);
791 if (status == Status::SUCCESS) {
792 AUDIO_INFO_LOG("[AudioAdapterManager] Wrote RingerMode:%d to kvStore", ringerMode);
793 } else {
794 AUDIO_ERR_LOG("[AudioAdapterManager] Writing RingerMode:%d to kvStore failed!", ringerMode);
795 }
796
797 return;
798 }
799
InitMuteStatusMap(bool isFirstBoot)800 void AudioAdapterManager::InitMuteStatusMap(bool isFirstBoot)
801 {
802 if (isFirstBoot == true) {
803 auto iter = deviceList_.begin();
804 while (iter != deviceList_.end()) {
805 WriteMuteStatusToKvStore(*iter, STREAM_MUSIC, 0);
806 WriteMuteStatusToKvStore(*iter, STREAM_RING, 0);
807 WriteMuteStatusToKvStore(*iter, STREAM_VOICE_CALL, 0);
808 WriteMuteStatusToKvStore(*iter, STREAM_VOICE_ASSISTANT, 0);
809 iter++;
810 }
811 AUDIO_INFO_LOG("[AudioAdapterManager] Wrote default mute status to KvStore");
812 } else {
813 LoadMuteStatusMap();
814 }
815 }
816
817
LoadMuteStatusMap(void)818 bool AudioAdapterManager::LoadMuteStatusMap(void)
819 {
820 if (mAudioPolicyKvStore == nullptr) {
821 AUDIO_ERR_LOG("[AudioAdapterManager] LoadMuteStatusMap: mAudioPolicyKvStore is null!");
822 return false;
823 }
824
825 if (!LoadMuteStatusFromKvStore(STREAM_MUSIC))
826 AUDIO_ERR_LOG("[AudioAdapterManager] Could not load mute status for MUSIC from kvStore!");
827
828 if (!LoadMuteStatusFromKvStore(STREAM_RING))
829 AUDIO_ERR_LOG("[AudioAdapterManager] Could not load mute status for RING from kvStore!");
830
831 if (!LoadMuteStatusFromKvStore(STREAM_VOICE_CALL))
832 AUDIO_ERR_LOG("[AudioAdapterManager] Could not load mute status for VOICE_CALL from kvStore!");
833
834 if (!LoadMuteStatusFromKvStore(STREAM_VOICE_ASSISTANT))
835 AUDIO_ERR_LOG("[AudioAdapterManager] Could not load mute status for VOICE_ASSISTANT from kvStore!");
836
837 return true;
838 }
839
LoadMuteStatusFromKvStore(AudioStreamType streamType)840 bool AudioAdapterManager::LoadMuteStatusFromKvStore(AudioStreamType streamType)
841 {
842 Value value;
843
844 switch (streamType) {
845 case STREAM_MUSIC:
846 break;
847 case STREAM_RING:
848 break;
849 case STREAM_VOICE_CALL:
850 break;
851 case STREAM_VOICE_ASSISTANT:
852 break;
853 default:
854 return false;
855 }
856 Key key = GetStreamTypeKeyForMute(DeviceType::DEVICE_TYPE_SPEAKER, streamType);
857 Status status = mAudioPolicyKvStore->Get(key, value);
858 if (status == Status::SUCCESS) {
859 int volumeStatus = TransferByteArrayToType<int>(value.Data());
860 mMuteStatusMap[streamType] = volumeStatus;
861 return true;
862 }
863
864 return false;
865 }
866
GetStreamTypeKeyForMute(DeviceType deviceType,AudioStreamType streamType)867 std::string AudioAdapterManager::GetStreamTypeKeyForMute(DeviceType deviceType, AudioStreamType streamType)
868 {
869 std::string type = "";
870 switch (deviceType) {
871 case DEVICE_TYPE_SPEAKER:
872 type = "primary";
873 break;
874 case DEVICE_TYPE_BLUETOOTH_A2DP:
875 type = "bluetooth";
876 break;
877 case DEVICE_TYPE_WIRED_HEADSET:
878 type = "wired";
879 break;
880 case DEVICE_TYPE_USB_HEADSET:
881 type = "usb";
882 break;
883 default:
884 AUDIO_ERR_LOG("[AudioAdapterManager::GetStreamTypeKeyForMute] deivice %{public}d is not supported for kv"
885 "store", deviceType);
886 return "";
887 }
888
889 switch (streamType) {
890 case STREAM_MUSIC:
891 return type + "music_mute_status";
892 case STREAM_RING:
893 return type + "ring_mute_status";
894 case STREAM_SYSTEM:
895 return type + "system_mute_status";
896 case STREAM_NOTIFICATION:
897 return type + "notification_mute_status";
898 case STREAM_ALARM:
899 return type + "alarm_mute_status";
900 case STREAM_DTMF:
901 return type + "dtmf_mute_status";
902 case STREAM_VOICE_CALL:
903 return type + "voice_call_mute_status";
904 case STREAM_VOICE_ASSISTANT:
905 return type + "voice_assistant_mute_status";
906 default:
907 return "";
908 }
909 }
910
WriteMuteStatusToKvStore(DeviceType deviceType,AudioStreamType streamType,bool muteStatus)911 void AudioAdapterManager::WriteMuteStatusToKvStore(DeviceType deviceType, AudioStreamType streamType,
912 bool muteStatus)
913 {
914 if (mAudioPolicyKvStore == nullptr) {
915 return;
916 }
917
918 Key key = GetStreamTypeKeyForMute(deviceType, streamType);
919 Value value = Value(TransferTypeToByteArray<int>(muteStatus));
920
921 Status status = mAudioPolicyKvStore->Put(key, value);
922 if (status == Status::SUCCESS) {
923 AUDIO_INFO_LOG("[AudioAdapterManager] muteStatus %{public}d for %{public}s updated to kvStore", muteStatus,
924 GetStreamNameByStreamType(deviceType, streamType).c_str());
925 } else {
926 AUDIO_INFO_LOG("[AudioAdapterManager] muteStatus %{public}d for %{public}s update to kvStore failed",
927 muteStatus, GetStreamNameByStreamType(deviceType, streamType).c_str());
928 }
929
930 return;
931 }
932 } // namespace AudioStandard
933 } // namespace OHOS
934