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.securityLevel = S1;
582 options.createIfMissing = true;
583 options.encrypt = false;
584 options.autoSync = false;
585 options.kvStoreType = KvStoreType::SINGLE_VERSION;
586 options.area = EL1;
587 options.baseDir = std::string("/data/service/el1/public/database/") + appId.appId;
588
589 StoreId storeId;
590 storeId.storeId = "audiopolicy";
591 Status status = Status::SUCCESS;
592
593 // open and initialize kvstore instance.
594 if (mAudioPolicyKvStore == nullptr) {
595 uint32_t retries = 0;
596
597 do {
598 status = manager.GetSingleKvStore(options, appId, storeId, mAudioPolicyKvStore);
599 if (status == Status::STORE_NOT_FOUND) {
600 AUDIO_ERR_LOG("[AudioAdapterManager] InitAudioPolicyKvStore: STORE_NOT_FOUND!");
601 }
602
603 if ((status == Status::SUCCESS) || (status == Status::STORE_NOT_FOUND)) {
604 break;
605 } else {
606 AUDIO_ERR_LOG("[AudioAdapterManager] InitAudioPolicyKvStore: Kvstore Connect failed! Retrying.");
607 retries++;
608 usleep(KVSTORE_CONNECT_RETRY_DELAY_TIME);
609 }
610 } while (retries <= KVSTORE_CONNECT_RETRY_COUNT);
611 }
612
613 if (mAudioPolicyKvStore == nullptr) {
614 if (status == Status::STORE_NOT_FOUND) {
615 AUDIO_INFO_LOG("[AudioAdapterManager] First Boot: Create AudioPolicyKvStore");
616 options.createIfMissing = true;
617 // [create and] open and initialize kvstore instance.
618 status = manager.GetSingleKvStore(options, appId, storeId, mAudioPolicyKvStore);
619 if (status == Status::SUCCESS) {
620 isFirstBoot = true;
621 } else {
622 AUDIO_ERR_LOG("[AudioAdapterManager] Create AudioPolicyKvStore Failed!");
623 }
624 }
625 }
626
627 if (mAudioPolicyKvStore == nullptr) {
628 AUDIO_ERR_LOG("[AudioAdapterManager] InitAudioPolicyKvStore: Failed!");
629 return false;
630 }
631
632 return true;
633 }
634
InitVolumeMap(bool isFirstBoot)635 void AudioAdapterManager::InitVolumeMap(bool isFirstBoot)
636 {
637 if (isFirstBoot == true) {
638 auto iter = deviceList_.begin();
639 while (iter != deviceList_.end()) {
640 WriteVolumeToKvStore(*iter, STREAM_MUSIC, MAX_VOLUME);
641 WriteVolumeToKvStore(*iter, STREAM_RING, MAX_VOLUME);
642 WriteVolumeToKvStore(*iter, STREAM_VOICE_CALL, MAX_VOLUME);
643 WriteVolumeToKvStore(*iter, STREAM_VOICE_ASSISTANT, MAX_VOLUME);
644 iter++;
645 }
646 AUDIO_INFO_LOG("[AudioAdapterManager] Wrote default stream volumes to KvStore");
647 } else {
648 LoadVolumeMap();
649 }
650 }
651
InitRingerMode(bool isFirstBoot)652 void AudioAdapterManager::InitRingerMode(bool isFirstBoot)
653 {
654 if (mAudioPolicyKvStore == nullptr) {
655 AUDIO_ERR_LOG("[AudioAdapterManager] mAudioPolicyKvStore is null!");
656 return;
657 }
658
659 if (isFirstBoot == true) {
660 mRingerMode = RINGER_MODE_NORMAL;
661 WriteRingerModeToKvStore(RINGER_MODE_NORMAL);
662 AUDIO_INFO_LOG("[AudioAdapterManager] Wrote default ringer mode to KvStore");
663 } else {
664 LoadRingerMode();
665 }
666 }
667
LoadVolumeFromKvStore(DeviceType deviceType,AudioStreamType streamType)668 bool AudioAdapterManager::LoadVolumeFromKvStore(DeviceType deviceType, AudioStreamType streamType)
669 {
670 Key key;
671 Value value;
672 std::string type;
673
674 switch (deviceType) {
675 case DEVICE_TYPE_SPEAKER:
676 type = "primary";
677 break;
678 case DEVICE_TYPE_BLUETOOTH_A2DP:
679 type = "bluetooth";
680 break;
681 case DEVICE_TYPE_WIRED_HEADSET:
682 type = "wired";
683 break;
684 case DEVICE_TYPE_USB_HEADSET:
685 type = "usb";
686 break;
687 default:
688 AUDIO_ERR_LOG("[AudioAdapterManager::LoadVolumeFromKvStore] deivice %{public}d is not supported for kv"
689 "store", deviceType);
690 return false;
691 }
692
693 switch (streamType) {
694 case STREAM_MUSIC:
695 key = type + "music";
696 break;
697 case STREAM_RING:
698 key = type + "ring";
699 break;
700 case STREAM_VOICE_CALL:
701 key = type + "voice_call";
702 break;
703 case STREAM_VOICE_ASSISTANT:
704 key = type + "voice_assistant";
705 break;
706 default:
707 return false;
708 }
709
710 Status status = mAudioPolicyKvStore->Get(key, value);
711 if (status == Status::SUCCESS) {
712 float volume = TransferByteArrayToType<float>(value.Data());
713 mVolumeMap[streamType] = volume;
714 AUDIO_DEBUG_LOG("[AudioAdapterManager] volume from kvStore %{public}f for streamType:%{public}d",
715 volume, streamType);
716 return true;
717 }
718
719 return false;
720 }
721
LoadVolumeMap(void)722 bool AudioAdapterManager::LoadVolumeMap(void)
723 {
724 if (mAudioPolicyKvStore == nullptr) {
725 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: mAudioPolicyKvStore is null!");
726 return false;
727 }
728
729 if (!LoadVolumeFromKvStore(currentActiveDevice_, STREAM_MUSIC))
730 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for Music from kvStore!");
731
732 if (!LoadVolumeFromKvStore(currentActiveDevice_, STREAM_RING))
733 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for Ring from kvStore!");
734
735 if (!LoadVolumeFromKvStore(currentActiveDevice_, STREAM_VOICE_CALL))
736 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for voice_call from kvStore!");
737
738 if (!LoadVolumeFromKvStore(currentActiveDevice_, STREAM_VOICE_ASSISTANT))
739 AUDIO_ERR_LOG("[AudioAdapterManager] LoadVolumeMap: Couldnot load volume for voice_assistant from kvStore!");
740
741 return true;
742 }
743
LoadRingerMode(void)744 bool AudioAdapterManager::LoadRingerMode(void)
745 {
746 if (mAudioPolicyKvStore == nullptr) {
747 AUDIO_ERR_LOG("[AudioAdapterManager] LoadRingerMap: mAudioPolicyKvStore is null!");
748 return false;
749 }
750
751 // get ringer mode value from kvstore.
752 Key key = "ringermode";
753 Value value;
754 Status status = mAudioPolicyKvStore->Get(key, value);
755 if (status == Status::SUCCESS) {
756 mRingerMode = static_cast<AudioRingerMode>(TransferByteArrayToType<int>(value.Data()));
757 AUDIO_DEBUG_LOG("[AudioAdapterManager] Ringer Mode from kvStore %{public}d", mRingerMode);
758 }
759
760 return true;
761 }
762
WriteVolumeToKvStore(DeviceType type,AudioStreamType streamType,float volume)763 void AudioAdapterManager::WriteVolumeToKvStore(DeviceType type, AudioStreamType streamType, float volume)
764 {
765 if (mAudioPolicyKvStore == nullptr)
766 return;
767
768 Key key = GetStreamNameByStreamType(type, streamType);
769 Value value = Value(TransferTypeToByteArray<float>(volume));
770
771 Status status = mAudioPolicyKvStore->Put(key, value);
772 if (status == Status::SUCCESS) {
773 AUDIO_INFO_LOG("[AudioAdapterManager] volume %{public}f for %{public}s updated in kvStore", volume,
774 GetStreamNameByStreamType(type, streamType).c_str());
775 } else {
776 AUDIO_ERR_LOG("[AudioAdapterManager] volume %{public}f for %{public}s failed to update in kvStore!", volume,
777 GetStreamNameByStreamType(type, streamType).c_str());
778 }
779
780 return;
781 }
782
WriteRingerModeToKvStore(AudioRingerMode ringerMode)783 void AudioAdapterManager::WriteRingerModeToKvStore(AudioRingerMode ringerMode)
784 {
785 if (mAudioPolicyKvStore == nullptr)
786 return;
787
788 Key key = "ringermode";
789 Value value = Value(TransferTypeToByteArray<int>(ringerMode));
790
791 Status status = mAudioPolicyKvStore->Put(key, value);
792 if (status == Status::SUCCESS) {
793 AUDIO_INFO_LOG("[AudioAdapterManager] Wrote RingerMode:%d to kvStore", ringerMode);
794 } else {
795 AUDIO_ERR_LOG("[AudioAdapterManager] Writing RingerMode:%d to kvStore failed!", ringerMode);
796 }
797
798 return;
799 }
800
InitMuteStatusMap(bool isFirstBoot)801 void AudioAdapterManager::InitMuteStatusMap(bool isFirstBoot)
802 {
803 if (isFirstBoot == true) {
804 auto iter = deviceList_.begin();
805 while (iter != deviceList_.end()) {
806 WriteMuteStatusToKvStore(*iter, STREAM_MUSIC, 0);
807 WriteMuteStatusToKvStore(*iter, STREAM_RING, 0);
808 WriteMuteStatusToKvStore(*iter, STREAM_VOICE_CALL, 0);
809 WriteMuteStatusToKvStore(*iter, STREAM_VOICE_ASSISTANT, 0);
810 iter++;
811 }
812 AUDIO_INFO_LOG("[AudioAdapterManager] Wrote default mute status to KvStore");
813 } else {
814 LoadMuteStatusMap();
815 }
816 }
817
818
LoadMuteStatusMap(void)819 bool AudioAdapterManager::LoadMuteStatusMap(void)
820 {
821 if (mAudioPolicyKvStore == nullptr) {
822 AUDIO_ERR_LOG("[AudioAdapterManager] LoadMuteStatusMap: mAudioPolicyKvStore is null!");
823 return false;
824 }
825
826 if (!LoadMuteStatusFromKvStore(STREAM_MUSIC))
827 AUDIO_ERR_LOG("[AudioAdapterManager] Could not load mute status for MUSIC from kvStore!");
828
829 if (!LoadMuteStatusFromKvStore(STREAM_RING))
830 AUDIO_ERR_LOG("[AudioAdapterManager] Could not load mute status for RING from kvStore!");
831
832 if (!LoadMuteStatusFromKvStore(STREAM_VOICE_CALL))
833 AUDIO_ERR_LOG("[AudioAdapterManager] Could not load mute status for VOICE_CALL from kvStore!");
834
835 if (!LoadMuteStatusFromKvStore(STREAM_VOICE_ASSISTANT))
836 AUDIO_ERR_LOG("[AudioAdapterManager] Could not load mute status for VOICE_ASSISTANT from kvStore!");
837
838 return true;
839 }
840
LoadMuteStatusFromKvStore(AudioStreamType streamType)841 bool AudioAdapterManager::LoadMuteStatusFromKvStore(AudioStreamType streamType)
842 {
843 Value value;
844
845 switch (streamType) {
846 case STREAM_MUSIC:
847 break;
848 case STREAM_RING:
849 break;
850 case STREAM_VOICE_CALL:
851 break;
852 case STREAM_VOICE_ASSISTANT:
853 break;
854 default:
855 return false;
856 }
857 Key key = GetStreamTypeKeyForMute(DeviceType::DEVICE_TYPE_SPEAKER, streamType);
858 Status status = mAudioPolicyKvStore->Get(key, value);
859 if (status == Status::SUCCESS) {
860 int volumeStatus = TransferByteArrayToType<int>(value.Data());
861 mMuteStatusMap[streamType] = volumeStatus;
862 return true;
863 }
864
865 return false;
866 }
867
GetStreamTypeKeyForMute(DeviceType deviceType,AudioStreamType streamType)868 std::string AudioAdapterManager::GetStreamTypeKeyForMute(DeviceType deviceType, AudioStreamType streamType)
869 {
870 std::string type = "";
871 switch (deviceType) {
872 case DEVICE_TYPE_SPEAKER:
873 type = "primary";
874 break;
875 case DEVICE_TYPE_BLUETOOTH_A2DP:
876 type = "bluetooth";
877 break;
878 case DEVICE_TYPE_WIRED_HEADSET:
879 type = "wired";
880 break;
881 case DEVICE_TYPE_USB_HEADSET:
882 type = "usb";
883 break;
884 default:
885 AUDIO_ERR_LOG("[AudioAdapterManager::GetStreamTypeKeyForMute] deivice %{public}d is not supported for kv"
886 "store", deviceType);
887 return "";
888 }
889
890 switch (streamType) {
891 case STREAM_MUSIC:
892 return type + "music_mute_status";
893 case STREAM_RING:
894 return type + "ring_mute_status";
895 case STREAM_SYSTEM:
896 return type + "system_mute_status";
897 case STREAM_NOTIFICATION:
898 return type + "notification_mute_status";
899 case STREAM_ALARM:
900 return type + "alarm_mute_status";
901 case STREAM_DTMF:
902 return type + "dtmf_mute_status";
903 case STREAM_VOICE_CALL:
904 return type + "voice_call_mute_status";
905 case STREAM_VOICE_ASSISTANT:
906 return type + "voice_assistant_mute_status";
907 default:
908 return "";
909 }
910 }
911
WriteMuteStatusToKvStore(DeviceType deviceType,AudioStreamType streamType,bool muteStatus)912 void AudioAdapterManager::WriteMuteStatusToKvStore(DeviceType deviceType, AudioStreamType streamType,
913 bool muteStatus)
914 {
915 if (mAudioPolicyKvStore == nullptr) {
916 return;
917 }
918
919 Key key = GetStreamTypeKeyForMute(deviceType, streamType);
920 Value value = Value(TransferTypeToByteArray<int>(muteStatus));
921
922 Status status = mAudioPolicyKvStore->Put(key, value);
923 if (status == Status::SUCCESS) {
924 AUDIO_INFO_LOG("[AudioAdapterManager] muteStatus %{public}d for %{public}s updated to kvStore", muteStatus,
925 GetStreamNameByStreamType(deviceType, streamType).c_str());
926 } else {
927 AUDIO_INFO_LOG("[AudioAdapterManager] muteStatus %{public}d for %{public}s update to kvStore failed",
928 muteStatus, GetStreamNameByStreamType(deviceType, streamType).c_str());
929 }
930
931 return;
932 }
933 } // namespace AudioStandard
934 } // namespace OHOS
935