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 #include "parameters.h"
23 #include "audio_adapter_manager.h"
24 #include "audio_volume_parser.h"
25
26 using namespace std;
27
28 namespace OHOS {
29 namespace AudioStandard {
30 static const std::vector<AudioStreamType> VOLUME_TYPE_LIST = {
31 // all volume types except STREAM_ALL
32 STREAM_MUSIC,
33 STREAM_RING,
34 STREAM_VOICE_CALL,
35 STREAM_VOICE_ASSISTANT,
36 STREAM_ALARM,
37 STREAM_ACCESSIBILITY,
38 STREAM_ULTRASONIC
39 };
40
41 static const std::vector<DeviceType> DEVICE_TYPE_LIST = {
42 // The three devices represent the three volume groups(build-in, wireless, wired).
43 DEVICE_TYPE_SPEAKER,
44 DEVICE_TYPE_BLUETOOTH_A2DP,
45 DEVICE_TYPE_WIRED_HEADSET
46 };
47
48 static const std::vector<AudioStreamType> VOICE_CALL_VOLUME_TYPE_LIST = {
49 // all stream types for voice call volume type
50 STREAM_VOICE_CALL,
51 STREAM_VOICE_MESSAGE
52 };
53
54 static const std::vector<AudioStreamType> RINGTONE_VOLUME_TYPE_LIST = {
55 // all stream types for ringtone volume type
56 STREAM_RING,
57 STREAM_SYSTEM,
58 STREAM_NOTIFICATION,
59 STREAM_SYSTEM_ENFORCED,
60 STREAM_DTMF
61 };
62
63 static const std::vector<AudioStreamType> MEDIA_VOLUME_TYPE_LIST = {
64 // all stream types for media volume type
65 STREAM_MUSIC,
66 STREAM_MOVIE,
67 STREAM_GAME,
68 STREAM_SPEECH,
69 STREAM_NAVIGATION
70 };
71
Init()72 bool AudioAdapterManager::Init()
73 {
74 char testMode[10] = {0}; // 10 for system parameter usage
75 auto res = GetParameter("debug.audio_service.testmodeon", "0", testMode, sizeof(testMode));
76 if (res == 1 && testMode[0] == '1') {
77 AUDIO_DEBUG_LOG("testMode on");
78 testModeOn_ = true;
79 }
80
81 std::unique_ptr<AudioVolumeParser> audiovolumeParser = make_unique<AudioVolumeParser>();
82 if (!audiovolumeParser->LoadConfig(streamVolumeInfos_)) {
83 AUDIO_INFO_LOG("Audio Volume Config Load Configuration successfully");
84 useNonlinearAlgo_ = 1;
85 UpdateVolumeMapIndex();
86 }
87
88 // init volume before kvstore start by local prop for bootanimation
89 char currentVolumeValue[3] = {0};
90 auto ret = GetParameter("persist.multimedia.audio.mediavolume", "7",
91 currentVolumeValue, sizeof(currentVolumeValue));
92 if (ret > 0) {
93 int32_t mediaVolumeLevel = atoi(currentVolumeValue);
94 volumeLevelMap_[STREAM_MUSIC] = mediaVolumeLevel;
95 AUDIO_INFO_LOG("Init: Get music volume to map success %{public}d", volumeLevelMap_[STREAM_MUSIC]);
96 } else {
97 AUDIO_ERR_LOG("Init: Get volume parameter failed %{public}d", ret);
98 }
99
100 isVolumeUnadjustable_ = system::GetBoolParameter("const.multimedia.audio.fixedvolume", false);
101 AUDIO_INFO_LOG("Get fixdvolume parameter success %{public}d", isVolumeUnadjustable_);
102
103 return true;
104 }
105
ConnectServiceAdapter()106 bool AudioAdapterManager::ConnectServiceAdapter()
107 {
108 std::shared_ptr<AudioAdapterManager> audioAdapterManager(this);
109 std::unique_ptr<PolicyCallbackImpl> policyCallbackImpl = std::make_unique<PolicyCallbackImpl>(audioAdapterManager);
110 audioServiceAdapter_ = AudioServiceAdapter::CreateAudioAdapter(std::move(policyCallbackImpl));
111 if (!audioServiceAdapter_) {
112 AUDIO_ERR_LOG("[AudioAdapterManager] Error in audio adapter initialization");
113 return false;
114 }
115
116 bool result = audioServiceAdapter_->Connect();
117 if (!result) {
118 AUDIO_ERR_LOG("[AudioAdapterManager] Error in connecting audio adapter");
119 return false;
120 }
121
122 return true;
123 }
124
InitKVStore()125 void AudioAdapterManager::InitKVStore()
126 {
127 if (audioPolicyKvStore_ != nullptr) {
128 AUDIO_ERR_LOG("InitKVStore: kv store is not nullptr.");
129 return;
130 }
131
132 AUDIO_INFO_LOG("AudioAdapterManager::%{public}s in", __func__);
133 bool isFirstBoot = false;
134 InitAudioPolicyKvStore(isFirstBoot);
135 InitVolumeMap(isFirstBoot);
136 InitRingerMode(isFirstBoot);
137 InitMuteStatusMap(isFirstBoot);
138 }
139
Deinit(void)140 void AudioAdapterManager::Deinit(void)
141 {
142 if (!audioServiceAdapter_) {
143 AUDIO_ERR_LOG("Deinit audio adapter null");
144 return;
145 }
146
147 return audioServiceAdapter_->Disconnect();
148 }
149
SetAudioSessionCallback(AudioSessionCallback * callback)150 int32_t AudioAdapterManager::SetAudioSessionCallback(AudioSessionCallback *callback)
151 {
152 if (callback == nullptr) {
153 AUDIO_ERR_LOG("SetAudioSessionCallback callback == nullptr");
154 return ERR_INVALID_PARAM;
155 }
156
157 sessionCallback_ = callback;
158 return SUCCESS;
159 }
160
GetMaxVolumeLevel(AudioVolumeType volumeType)161 int32_t AudioAdapterManager::GetMaxVolumeLevel(AudioVolumeType volumeType)
162 {
163 CHECK_AND_RETURN_RET_LOG(volumeType >= STREAM_VOICE_CALL && volumeType <= STREAM_TYPE_MAX,
164 ERR_INVALID_PARAM, "Invalid stream type");
165 return maxVolumeIndexMap_[volumeType];
166 }
167
GetMinVolumeLevel(AudioVolumeType volumeType)168 int32_t AudioAdapterManager::GetMinVolumeLevel(AudioVolumeType volumeType)
169 {
170 CHECK_AND_RETURN_RET_LOG(volumeType >= STREAM_VOICE_CALL && volumeType <= STREAM_TYPE_MAX,
171 ERR_INVALID_PARAM, "Invalid stream type");
172 return minVolumeIndexMap_[volumeType];
173 }
174
SaveMediaVolumeToLocal(AudioStreamType streamType,int32_t volumeLevel)175 void AudioAdapterManager::SaveMediaVolumeToLocal(AudioStreamType streamType, int32_t volumeLevel)
176 {
177 if (streamType == STREAM_MUSIC) {
178 int32_t ret = SetParameter("persist.multimedia.audio.mediavolume", std::to_string(volumeLevel).c_str());
179 if (ret == 0) {
180 AUDIO_INFO_LOG("Save media volume for boot success %{public}d", volumeLevel);
181 } else {
182 AUDIO_ERR_LOG("Save media volume for boot failed, result %{public}d", ret);
183 }
184 }
185 }
186
SetSystemVolumeLevel(AudioStreamType streamType,int32_t volumeLevel,bool)187 int32_t AudioAdapterManager::SetSystemVolumeLevel(AudioStreamType streamType, int32_t volumeLevel,
188 bool /* isFromVolumeKey */)
189 {
190 AUDIO_INFO_LOG("SetSystemVolumeLevel: streamType: %{public}d, deviceType: %{public}d, volumeLevel:%{public}d",
191 streamType, currentActiveDevice_, volumeLevel);
192 if (volumeLevel == 0 &&
193 (streamType == STREAM_VOICE_ASSISTANT || streamType == STREAM_VOICE_CALL ||
194 streamType == STREAM_ALARM || streamType == STREAM_ACCESSIBILITY)) {
195 // these types can not set to mute, but don't return error
196 AUDIO_ERR_LOG("SetSystemVolumeLevel this type can not set mute");
197 return SUCCESS;
198 }
199 if (volumeLevel < GetMinVolumeLevel(streamType) || volumeLevel > GetMaxVolumeLevel(streamType)) {
200 AUDIO_ERR_LOG("volumeLevel not in scope.");
201 return ERR_OPERATION_FAILED;
202 }
203
204 // In case if KvStore didnot connect during bootup
205 if (audioPolicyKvStore_ == nullptr) {
206 InitKVStore();
207 }
208
209 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
210 volumeLevelMap_[streamForVolumeMap] = volumeLevel;
211 WriteVolumeToKvStore(currentActiveDevice_, streamType, volumeLevel);
212
213 UpdateRingerModeForVolume(streamType, volumeLevel);
214
215 UpdateMuteStatusForVolume(streamType, volumeLevel);
216
217 return SetVolumeDb(streamType);
218 }
219
UpdateRingerModeForVolume(AudioStreamType streamType,int32_t volumeLevel)220 void AudioAdapterManager::UpdateRingerModeForVolume(AudioStreamType streamType, int32_t volumeLevel)
221 {
222 //The ringer mode is automatically updated based on the ringtone volume
223 if (streamType != STREAM_RING) {
224 return;
225 }
226 if (volumeLevel > 0 && (ringerMode_ == RINGER_MODE_SILENT || ringerMode_ == RINGER_MODE_VIBRATE)) {
227 // ringtone volume > 0, change the ringer mode to RINGER_MODE_NORMAL
228 SetRingerMode(RINGER_MODE_NORMAL);
229 } else if (volumeLevel == 0 && ringerMode_ == RINGER_MODE_NORMAL) {
230 // ringtone volume == 0, change the ringer mode to RINGER_MODE_VIBRATE
231 SetRingerMode(RINGER_MODE_VIBRATE);
232 }
233 }
234
UpdateMuteStatusForVolume(AudioStreamType streamType,int32_t volumeLevel)235 void AudioAdapterManager::UpdateMuteStatusForVolume(AudioStreamType streamType, int32_t volumeLevel)
236 {
237 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
238
239 //The mute status is automatically updated based on the stream volume
240 if (volumeLevel > 0 && GetStreamMute(streamType)) {
241 muteStatusMap_[streamForVolumeMap] = false;
242 WriteMuteStatusToKvStore(currentActiveDevice_, streamType, false);
243 } else if (volumeLevel == 0 && !GetStreamMute(streamType)) {
244 muteStatusMap_[streamForVolumeMap] = true;
245 WriteMuteStatusToKvStore(currentActiveDevice_, streamType, true);
246 }
247 }
248
SetVolumeDb(AudioStreamType streamType)249 int32_t AudioAdapterManager::SetVolumeDb(AudioStreamType streamType)
250 {
251 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
252 int32_t volumeLevel = volumeLevelMap_[streamForVolumeMap] * (muteStatusMap_[streamForVolumeMap] ? 0 : 1);
253
254 // Save volume in local prop for bootanimation
255 SaveMediaVolumeToLocal(streamType, volumeLevel);
256
257 float volumeDb = 1.0f;
258 if (useNonlinearAlgo_) {
259 volumeDb = CalculateVolumeDbNonlinear(streamType, currentActiveDevice_, volumeLevel);
260 } else {
261 volumeDb = CalculateVolumeDb(volumeLevel);
262 }
263
264 if (!audioServiceAdapter_) {
265 AUDIO_ERR_LOG("SetSystemVolumeLevel audio adapter null");
266 return ERR_OPERATION_FAILED;
267 }
268
269 AUDIO_INFO_LOG("SetVolumeDb: streamType %{public}d, volumeDb %{public}f", streamType, volumeDb);
270 if (streamType == STREAM_VOICE_CALL) {
271 return SetVolumeDbForVolumeTypeGroup(VOICE_CALL_VOLUME_TYPE_LIST, volumeDb);
272 } else if (streamType == STREAM_MUSIC) {
273 return SetVolumeDbForVolumeTypeGroup(MEDIA_VOLUME_TYPE_LIST, volumeDb);
274 } else if (streamType == STREAM_RING) {
275 return SetVolumeDbForVolumeTypeGroup(RINGTONE_VOLUME_TYPE_LIST, volumeDb);
276 }
277
278 return audioServiceAdapter_->SetVolumeDb(streamType, volumeDb);
279 }
280
SetVolumeDbForVolumeTypeGroup(const std::vector<AudioStreamType> & volumeTypeGroup,float volumeDb)281 int32_t AudioAdapterManager::SetVolumeDbForVolumeTypeGroup(const std::vector<AudioStreamType> &volumeTypeGroup,
282 float volumeDb)
283 {
284 int32_t result = SUCCESS;
285 for (auto &streamType: volumeTypeGroup) {
286 result = audioServiceAdapter_->SetVolumeDb(streamType, volumeDb);
287 if (result != SUCCESS) {
288 // The operation of setting volume has failed, return error directly.
289 return result;
290 }
291 }
292 return result;
293 }
294
GetSystemVolumeLevel(AudioStreamType streamType,bool isFromVolumeKey)295 int32_t AudioAdapterManager::GetSystemVolumeLevel(AudioStreamType streamType, bool isFromVolumeKey)
296 {
297 if (!isFromVolumeKey && GetStreamMute(streamType)) {
298 return MIN_VOLUME_LEVEL;
299 }
300 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
301
302 return volumeLevelMap_[streamForVolumeMap];
303 }
304
GetSystemVolumeDb(AudioStreamType streamType)305 float AudioAdapterManager::GetSystemVolumeDb(AudioStreamType streamType)
306 {
307 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
308
309 int32_t volumeLevel = volumeLevelMap_[streamForVolumeMap];
310 return CalculateVolumeDb(volumeLevel);
311 }
312
SetStreamMute(AudioStreamType streamType,bool mute)313 int32_t AudioAdapterManager::SetStreamMute(AudioStreamType streamType, bool mute)
314 {
315 AUDIO_INFO_LOG("SetStreamMute: stream type %{public}d, mute %{public}d", streamType, mute);
316 if (mute &&
317 (streamType == STREAM_VOICE_ASSISTANT || streamType == STREAM_VOICE_CALL ||
318 streamType == STREAM_ALARM || streamType == STREAM_ACCESSIBILITY)) {
319 // these types can not set to mute, but don't return error
320 AUDIO_ERR_LOG("SetStreamMute: this type can not set mute");
321 return SUCCESS;
322 }
323
324 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
325 muteStatusMap_[streamForVolumeMap] = mute;
326 WriteMuteStatusToKvStore(currentActiveDevice_, streamType, mute);
327
328 if (!mute && volumeLevelMap_[streamForVolumeMap] == 0) {
329 AUDIO_INFO_LOG("SetStreamMute: stream type %{public}d is unmuted, but the volume is 0. Set to 1.", streamType);
330 volumeLevelMap_[streamForVolumeMap] = 1;
331 WriteVolumeToKvStore(currentActiveDevice_, streamType, 1);
332 }
333
334 // Achieve the purpose of adjusting the mute status by adjusting the stream volume.
335 return SetVolumeDb(streamType);
336 }
337
SetSourceOutputStreamMute(int32_t uid,bool setMute)338 int32_t AudioAdapterManager::SetSourceOutputStreamMute(int32_t uid, bool setMute)
339 {
340 if (!audioServiceAdapter_) {
341 AUDIO_ERR_LOG("SetSourceOutputStreamMute audio adapter null");
342 return ERR_OPERATION_FAILED;
343 }
344 return audioServiceAdapter_->SetSourceOutputMute(uid, setMute);
345 }
346
GetStreamMute(AudioStreamType streamType)347 bool AudioAdapterManager::GetStreamMute(AudioStreamType streamType)
348 {
349 AudioStreamType streamForVolumeMap = GetStreamForVolumeMap(streamType);
350 return muteStatusMap_[streamForVolumeMap];
351 }
352
IsStreamActive(AudioStreamType streamType)353 bool AudioAdapterManager::IsStreamActive(AudioStreamType streamType)
354 {
355 if (!audioServiceAdapter_) {
356 AUDIO_ERR_LOG("IsStreamActive audio adapter null");
357 return false;
358 }
359
360 if (streamType == STREAM_VOICE_CALL) {
361 return IsStreamActiveForVolumeTypeGroup(VOICE_CALL_VOLUME_TYPE_LIST);
362 } else if (streamType == STREAM_MUSIC) {
363 return IsStreamActiveForVolumeTypeGroup(MEDIA_VOLUME_TYPE_LIST);
364 } else if (streamType == STREAM_RING) {
365 return IsStreamActiveForVolumeTypeGroup(RINGTONE_VOLUME_TYPE_LIST);
366 }
367
368 return audioServiceAdapter_->IsStreamActive(streamType);
369 }
370
371
IsStreamActiveForVolumeTypeGroup(const std::vector<AudioStreamType> & volumeTypeGroup)372 bool AudioAdapterManager::IsStreamActiveForVolumeTypeGroup(const std::vector<AudioStreamType> &volumeTypeGroup)
373 {
374 bool result = false;
375 for (auto &streamType: volumeTypeGroup) {
376 result = audioServiceAdapter_->IsStreamActive(streamType);
377 if (result) {
378 // An active stream has been found, return true directly.
379 return true;
380 }
381 }
382 return false;
383 }
384
GetAllSinks()385 vector<SinkInfo> AudioAdapterManager::GetAllSinks()
386 {
387 if (!audioServiceAdapter_) {
388 AUDIO_ERR_LOG("GetAllSinks audio adapter null");
389 vector<SinkInfo> sinkInputList;
390 return sinkInputList;
391 }
392
393 return audioServiceAdapter_->GetAllSinks();
394 }
395
GetAllSinkInputs()396 vector<SinkInput> AudioAdapterManager::GetAllSinkInputs()
397 {
398 if (!audioServiceAdapter_) {
399 AUDIO_ERR_LOG("GetAllSinkInputs audio adapter null");
400 vector<SinkInput> sinkInputList;
401 return sinkInputList;
402 }
403
404 return audioServiceAdapter_->GetAllSinkInputs();
405 }
406
GetAllSourceOutputs()407 vector<SourceOutput> AudioAdapterManager::GetAllSourceOutputs()
408 {
409 if (!audioServiceAdapter_) {
410 AUDIO_ERR_LOG("GetAllSourceOutputs audio adapter null");
411 vector<SourceOutput> sourceOutputList;
412 return sourceOutputList;
413 }
414
415 return audioServiceAdapter_->GetAllSourceOutputs();
416 }
417
SuspendAudioDevice(std::string & portName,bool isSuspend)418 int32_t AudioAdapterManager::SuspendAudioDevice(std::string &portName, bool isSuspend)
419 {
420 if (!audioServiceAdapter_) {
421 AUDIO_ERR_LOG("SuspendAudioDevice audio adapter null");
422 return ERR_OPERATION_FAILED;
423 }
424
425 return audioServiceAdapter_->SuspendAudioDevice(portName, isSuspend);
426 }
427
SetSinkMute(const std::string & sinkName,bool isMute)428 bool AudioAdapterManager::SetSinkMute(const std::string &sinkName, bool isMute)
429 {
430 if (!audioServiceAdapter_) {
431 AUDIO_ERR_LOG("SetSinkMute audio adapter null");
432 return false;
433 }
434
435 return audioServiceAdapter_->SetSinkMute(sinkName, isMute);
436 }
437
SelectDevice(DeviceRole deviceRole,InternalDeviceType deviceType,std::string name)438 int32_t AudioAdapterManager::SelectDevice(DeviceRole deviceRole, InternalDeviceType deviceType, std::string name)
439 {
440 if (!audioServiceAdapter_) {
441 AUDIO_ERR_LOG("SelectDevice audio adapter null");
442 return ERR_OPERATION_FAILED;
443 }
444 switch (deviceRole) {
445 case DeviceRole::INPUT_DEVICE:
446 return audioServiceAdapter_->SetDefaultSource(name);
447 case DeviceRole::OUTPUT_DEVICE: {
448 AUDIO_INFO_LOG("SetDefaultSink %{public}d", deviceType);
449 return audioServiceAdapter_->SetDefaultSink(name);
450 }
451 default:
452 AUDIO_ERR_LOG("SelectDevice error deviceRole %{public}d", deviceRole);
453 return ERR_OPERATION_FAILED;
454 }
455 return SUCCESS;
456 }
457
SetDeviceActive(AudioIOHandle ioHandle,InternalDeviceType deviceType,std::string name,bool active)458 int32_t AudioAdapterManager::SetDeviceActive(AudioIOHandle ioHandle, InternalDeviceType deviceType,
459 std::string name, bool active)
460 {
461 if (!audioServiceAdapter_) {
462 AUDIO_ERR_LOG("SetDeviceActive audio adapter null");
463 return ERR_OPERATION_FAILED;
464 }
465
466 switch (deviceType) {
467 case InternalDeviceType::DEVICE_TYPE_EARPIECE:
468 case InternalDeviceType::DEVICE_TYPE_SPEAKER:
469 case InternalDeviceType::DEVICE_TYPE_FILE_SINK:
470 case InternalDeviceType::DEVICE_TYPE_WIRED_HEADSET:
471 case InternalDeviceType::DEVICE_TYPE_USB_HEADSET:
472 case InternalDeviceType::DEVICE_TYPE_BLUETOOTH_A2DP:
473 case InternalDeviceType::DEVICE_TYPE_BLUETOOTH_SCO: {
474 AUDIO_INFO_LOG("SetDefaultSink %{public}d", deviceType);
475 return audioServiceAdapter_->SetDefaultSink(name);
476 }
477 case InternalDeviceType::DEVICE_TYPE_FILE_SOURCE:
478 case InternalDeviceType::DEVICE_TYPE_MIC: {
479 AUDIO_INFO_LOG("SetDefaultSource %{public}d", deviceType);
480 return audioServiceAdapter_->SetDefaultSource(name);
481 }
482 case InternalDeviceType::DEVICE_TYPE_WAKEUP: {
483 AUDIO_INFO_LOG("SetDefaultSource %{public}d", deviceType);
484 return audioServiceAdapter_->SetDefaultSource(name);
485 }
486 default:
487 break;
488 }
489 return SUCCESS;
490 }
491
SetVolumeForSwitchDevice(InternalDeviceType deviceType)492 void AudioAdapterManager::SetVolumeForSwitchDevice(InternalDeviceType deviceType)
493 {
494 AUDIO_INFO_LOG("SetVolumeForSwitchDevice: Load volume and mute status for new device %{public}d", deviceType);
495 // Current device must be updated even if kvStore is nullptr.
496 currentActiveDevice_ = deviceType;
497
498 if (audioPolicyKvStore_ == nullptr) {
499 AUDIO_ERR_LOG("SetVolumeForSwitchDevice audioPolicyKvStore_ is null!");
500 return;
501 }
502 LoadVolumeMap();
503 LoadMuteStatusMap();
504
505 auto iter = VOLUME_TYPE_LIST.begin();
506 while (iter != VOLUME_TYPE_LIST.end()) {
507 // update volume level and mute status for each stream type
508 SetVolumeDb(*iter);
509 AUDIO_INFO_LOG("SetVolumeForSwitchDevice: volume: %{public}d, mute: %{public}d for stream type %{public}d",
510 volumeLevelMap_[*iter], muteStatusMap_[*iter], *iter);
511 iter++;
512 }
513 }
514
MoveSinkInputByIndexOrName(uint32_t sinkInputId,uint32_t sinkIndex,std::string sinkName)515 int32_t AudioAdapterManager::MoveSinkInputByIndexOrName(uint32_t sinkInputId, uint32_t sinkIndex, std::string sinkName)
516 {
517 return audioServiceAdapter_->MoveSinkInputByIndexOrName(sinkInputId, sinkIndex, sinkName);
518 }
519
MoveSourceOutputByIndexOrName(uint32_t sourceOutputId,uint32_t sourceIndex,std::string sourceName)520 int32_t AudioAdapterManager::MoveSourceOutputByIndexOrName(uint32_t sourceOutputId, uint32_t sourceIndex,
521 std::string sourceName)
522 {
523 return audioServiceAdapter_->MoveSourceOutputByIndexOrName(sourceOutputId, sourceIndex, sourceName);
524 }
525
SetRingerMode(AudioRingerMode ringerMode)526 int32_t AudioAdapterManager::SetRingerMode(AudioRingerMode ringerMode)
527 {
528 AUDIO_INFO_LOG("SetRingerMode: %{public}d", ringerMode);
529 ringerMode_ = ringerMode;
530
531 switch (ringerMode) {
532 case RINGER_MODE_SILENT:
533 case RINGER_MODE_VIBRATE:
534 SetStreamMute(STREAM_RING, true);
535 break;
536 case RINGER_MODE_NORMAL:
537 SetStreamMute(STREAM_RING, false);
538 break;
539 default:
540 break;
541 }
542
543 // In case if KvStore didnot connect during bootup
544 if (audioPolicyKvStore_ == nullptr) {
545 InitKVStore();
546 }
547
548 WriteRingerModeToKvStore(ringerMode);
549 return SUCCESS;
550 }
551
GetRingerMode() const552 AudioRingerMode AudioAdapterManager::GetRingerMode() const
553 {
554 return ringerMode_;
555 }
556
OpenAudioPort(const AudioModuleInfo & audioModuleInfo)557 AudioIOHandle AudioAdapterManager::OpenAudioPort(const AudioModuleInfo &audioModuleInfo)
558 {
559 std::string moduleArgs = GetModuleArgs(audioModuleInfo);
560 AUDIO_INFO_LOG("[Adapter load-module] %{public}s %{public}s", audioModuleInfo.lib.c_str(), moduleArgs.c_str());
561
562 CHECK_AND_RETURN_RET_LOG(audioServiceAdapter_ != nullptr, ERR_OPERATION_FAILED, "ServiceAdapter is null");
563 return audioServiceAdapter_->OpenAudioPort(audioModuleInfo.lib, moduleArgs.c_str());
564 }
565
LoadLoopback(const LoopbackModuleInfo & moduleInfo)566 AudioIOHandle AudioAdapterManager::LoadLoopback(const LoopbackModuleInfo &moduleInfo)
567 {
568 std::string moduleArgs = GetLoopbackModuleArgs(moduleInfo);
569 AUDIO_INFO_LOG("[Adapter load-module] %{public}s %{public}s", moduleInfo.lib.c_str(), moduleArgs.c_str());
570
571 CHECK_AND_RETURN_RET_LOG(audioServiceAdapter_ != nullptr, ERR_OPERATION_FAILED, "ServiceAdapter is null");
572 return audioServiceAdapter_->OpenAudioPort(moduleInfo.lib, moduleArgs.c_str());
573 }
574
CloseAudioPort(AudioIOHandle ioHandle)575 int32_t AudioAdapterManager::CloseAudioPort(AudioIOHandle ioHandle)
576 {
577 CHECK_AND_RETURN_RET_LOG(audioServiceAdapter_ != nullptr, ERR_OPERATION_FAILED, "ServiceAdapter is null");
578 return audioServiceAdapter_->CloseAudioPort(ioHandle);
579 }
580
UpdateCommonArgs(const AudioModuleInfo & audioModuleInfo,std::string & args)581 void UpdateCommonArgs(const AudioModuleInfo &audioModuleInfo, std::string &args)
582 {
583 if (!audioModuleInfo.rate.empty()) {
584 args = "rate=";
585 args.append(audioModuleInfo.rate);
586 }
587
588 if (!audioModuleInfo.channels.empty()) {
589 args.append(" channels=");
590 args.append(audioModuleInfo.channels);
591 }
592
593 if (!audioModuleInfo.bufferSize.empty()) {
594 args.append(" buffer_size=");
595 args.append(audioModuleInfo.bufferSize);
596 }
597
598 if (!audioModuleInfo.format.empty()) {
599 args.append(" format=");
600 args.append(audioModuleInfo.format);
601 AUDIO_INFO_LOG("[PolicyManager] format: %{public}s", args.c_str());
602 }
603
604 if (!audioModuleInfo.fixedLatency.empty()) {
605 args.append(" fixed_latency=");
606 args.append(audioModuleInfo.fixedLatency);
607 }
608
609 if (!audioModuleInfo.renderInIdleState.empty()) {
610 args.append(" render_in_idle_state=");
611 args.append(audioModuleInfo.renderInIdleState);
612 }
613
614 if (!audioModuleInfo.OpenMicSpeaker.empty()) {
615 args.append(" open_mic_speaker=");
616 args.append(audioModuleInfo.OpenMicSpeaker);
617 }
618 }
619
GetLoopbackModuleArgs(const LoopbackModuleInfo & moduleInfo) const620 std::string AudioAdapterManager::GetLoopbackModuleArgs(const LoopbackModuleInfo &moduleInfo) const
621 {
622 std::string args;
623
624 if (moduleInfo.sink.empty() || moduleInfo.source.empty()) {
625 return "";
626 }
627
628 args.append(" source=");
629 args.append(moduleInfo.source);
630 args.append(" sink=");
631 args.append(moduleInfo.sink);
632 return args;
633 }
634
635 // Private Members
GetModuleArgs(const AudioModuleInfo & audioModuleInfo) const636 std::string AudioAdapterManager::GetModuleArgs(const AudioModuleInfo &audioModuleInfo) const
637 {
638 std::string args;
639
640 if (audioModuleInfo.lib == HDI_SINK) {
641 UpdateCommonArgs(audioModuleInfo, args);
642 if (!audioModuleInfo.name.empty()) {
643 args.append(" sink_name=");
644 args.append(audioModuleInfo.name);
645 }
646
647 if (!audioModuleInfo.adapterName.empty()) {
648 args.append(" adapter_name=");
649 args.append(audioModuleInfo.adapterName);
650 }
651
652 if (!audioModuleInfo.className.empty()) {
653 args.append(" device_class=");
654 args.append(audioModuleInfo.className);
655 }
656
657 if (!audioModuleInfo.fileName.empty()) {
658 args.append(" file_path=");
659 args.append(audioModuleInfo.fileName);
660 }
661 if (!audioModuleInfo.sinkLatency.empty()) {
662 args.append(" sink_latency=");
663 args.append(audioModuleInfo.sinkLatency);
664 }
665 if (testModeOn_) {
666 args.append(" test_mode_on=");
667 args.append("1");
668 }
669 if (!audioModuleInfo.networkId.empty()) {
670 args.append(" network_id=");
671 args.append(audioModuleInfo.networkId);
672 } else {
673 args.append(" network_id=LocalDevice");
674 }
675
676 if (!audioModuleInfo.deviceType.empty()) {
677 args.append(" device_type=");
678 args.append(audioModuleInfo.deviceType);
679 }
680 } else if (audioModuleInfo.lib == HDI_SOURCE) {
681 UpdateCommonArgs(audioModuleInfo, args);
682 if (!audioModuleInfo.name.empty()) {
683 args.append(" source_name=");
684 args.append(audioModuleInfo.name);
685 }
686
687 if (!audioModuleInfo.adapterName.empty()) {
688 args.append(" adapter_name=");
689 args.append(audioModuleInfo.adapterName);
690 }
691
692 if (!audioModuleInfo.className.empty()) {
693 args.append(" device_class=");
694 args.append(audioModuleInfo.className);
695 }
696
697 if (!audioModuleInfo.fileName.empty()) {
698 args.append(" file_path=");
699 args.append(audioModuleInfo.fileName);
700 }
701
702 if (!audioModuleInfo.networkId.empty()) {
703 args.append(" network_id=");
704 args.append(audioModuleInfo.networkId);
705 } else {
706 args.append(" network_id=LocalDevice");
707 }
708
709 if (!audioModuleInfo.deviceType.empty()) {
710 args.append(" device_type=");
711 args.append(audioModuleInfo.deviceType);
712 }
713
714 if (!audioModuleInfo.sourceType.empty()) {
715 args.append(" source_type=");
716 args.append(audioModuleInfo.sourceType);
717 }
718 } else if (audioModuleInfo.lib == PIPE_SINK) {
719 if (!audioModuleInfo.fileName.empty()) {
720 args = "file=";
721 args.append(audioModuleInfo.fileName);
722 }
723 } else if (audioModuleInfo.lib == PIPE_SOURCE) {
724 if (!audioModuleInfo.fileName.empty()) {
725 args = "file=";
726 args.append(audioModuleInfo.fileName);
727 }
728 } else if (audioModuleInfo.lib == CLUSTER_SINK) {
729 UpdateCommonArgs(audioModuleInfo, args);
730 if (!audioModuleInfo.name.empty()) {
731 args.append(" sink_name=");
732 args.append(audioModuleInfo.name);
733 }
734 } else if (audioModuleInfo.lib == EFFECT_SINK) {
735 UpdateCommonArgs(audioModuleInfo, args);
736 if (!audioModuleInfo.name.empty()) {
737 args.append(" sink_name=");
738 args.append(audioModuleInfo.name);
739 }
740 if (!audioModuleInfo.sceneName.empty()) {
741 args.append(" scene_name=");
742 args.append(audioModuleInfo.sceneName);
743 }
744 } else if (audioModuleInfo.lib == INNER_CAPTURER_SINK || audioModuleInfo.lib == RECEIVER_SINK) {
745 if (!audioModuleInfo.name.empty()) {
746 args.append(" sink_name=");
747 args.append(audioModuleInfo.name);
748 }
749 }
750 return args;
751 }
752
GetVolumeKeyForKvStore(DeviceType deviceType,AudioStreamType streamType)753 std::string AudioAdapterManager::GetVolumeKeyForKvStore(DeviceType deviceType, AudioStreamType streamType)
754 {
755 std::string type = "";
756 switch (deviceType) {
757 case DEVICE_TYPE_EARPIECE:
758 case DEVICE_TYPE_SPEAKER:
759 type = "build-in";
760 break;
761 case DEVICE_TYPE_BLUETOOTH_A2DP:
762 case DEVICE_TYPE_BLUETOOTH_SCO:
763 type = "wireless";
764 break;
765 case DEVICE_TYPE_WIRED_HEADSET:
766 case DEVICE_TYPE_USB_HEADSET:
767 type = "wired";
768 break;
769 default:
770 AUDIO_ERR_LOG("GetVolumeKeyForKvStore: deivice %{public}d is not supported for kvStore", deviceType);
771 return "";
772 }
773
774 switch (streamType) {
775 case STREAM_MUSIC:
776 return type + "_music_volume";
777 case STREAM_RING:
778 return type + "_ring_volume";
779 case STREAM_SYSTEM:
780 return type + "_system_volume";
781 case STREAM_NOTIFICATION:
782 return type + "_notification_volume";
783 case STREAM_ALARM:
784 return type + "_alarm_volume";
785 case STREAM_DTMF:
786 return type + "_dtmf_volume";
787 case STREAM_VOICE_CALL:
788 return type + "_voice_call_volume";
789 case STREAM_VOICE_ASSISTANT:
790 return type + "_voice_assistant_volume";
791 case STREAM_ACCESSIBILITY:
792 return type + "_accessibility_volume";
793 case STREAM_ULTRASONIC:
794 return type + "_ultrasonic_volume";
795 case STREAM_WAKEUP:
796 return type + "wakeup";
797 default:
798 AUDIO_ERR_LOG("GetVolumeKeyForKvStore: streamType %{public}d is not supported for kvStore", streamType);
799 return "";
800 }
801 }
802
GetStreamIDByType(std::string streamType)803 AudioStreamType AudioAdapterManager::GetStreamIDByType(std::string streamType)
804 {
805 AudioStreamType stream = STREAM_MUSIC;
806
807 if (!streamType.compare(std::string("music")))
808 stream = STREAM_MUSIC;
809 else if (!streamType.compare(std::string("ring")))
810 stream = STREAM_RING;
811 else if (!streamType.compare(std::string("voice_call")))
812 stream = STREAM_VOICE_CALL;
813 else if (!streamType.compare(std::string("system")))
814 stream = STREAM_SYSTEM;
815 else if (!streamType.compare(std::string("notification")))
816 stream = STREAM_NOTIFICATION;
817 else if (!streamType.compare(std::string("alarm")))
818 stream = STREAM_ALARM;
819 else if (!streamType.compare(std::string("voice_assistant")))
820 stream = STREAM_VOICE_ASSISTANT;
821 else if (!streamType.compare(std::string("accessibility")))
822 stream = STREAM_ACCESSIBILITY;
823 else if (!streamType.compare(std::string("ultrasonic")))
824 stream = STREAM_ULTRASONIC;
825
826 return stream;
827 }
828
GetStreamForVolumeMap(AudioStreamType streamType)829 AudioStreamType AudioAdapterManager::GetStreamForVolumeMap(AudioStreamType streamType)
830 {
831 switch (streamType) {
832 case STREAM_VOICE_CALL:
833 case STREAM_VOICE_MESSAGE:
834 return STREAM_VOICE_CALL;
835 case STREAM_RING:
836 case STREAM_SYSTEM:
837 case STREAM_NOTIFICATION:
838 case STREAM_SYSTEM_ENFORCED:
839 case STREAM_DTMF:
840 return STREAM_RING;
841 case STREAM_MUSIC:
842 case STREAM_MEDIA:
843 case STREAM_MOVIE:
844 case STREAM_GAME:
845 case STREAM_SPEECH:
846 case STREAM_NAVIGATION:
847 return STREAM_MUSIC;
848 case STREAM_VOICE_ASSISTANT:
849 return STREAM_VOICE_ASSISTANT;
850 case STREAM_ALARM:
851 return STREAM_ALARM;
852 case STREAM_ACCESSIBILITY:
853 return STREAM_ACCESSIBILITY;
854 case STREAM_ULTRASONIC:
855 return STREAM_ULTRASONIC;
856 default:
857 return STREAM_MUSIC;
858 }
859 }
860
GetDeviceCategory(DeviceType deviceType)861 DeviceVolumeType AudioAdapterManager::GetDeviceCategory(DeviceType deviceType)
862 {
863 switch (deviceType) {
864 case DEVICE_TYPE_EARPIECE:
865 return EARPIECE_VOLUME_TYPE;
866 case DEVICE_TYPE_SPEAKER:
867 case DEVICE_TYPE_FILE_SOURCE:
868 return SPEAKER_VOLUME_TYPE;
869 case DEVICE_TYPE_WIRED_HEADSET:
870 case DEVICE_TYPE_WIRED_HEADPHONES:
871 case DEVICE_TYPE_BLUETOOTH_SCO:
872 case DEVICE_TYPE_BLUETOOTH_A2DP:
873 case DEVICE_TYPE_USB_HEADSET:
874 return HEADSET_VOLUME_TYPE;
875 default:
876 return SPEAKER_VOLUME_TYPE;
877 }
878 }
879
InitAudioPolicyKvStore(bool & isFirstBoot)880 bool AudioAdapterManager::InitAudioPolicyKvStore(bool& isFirstBoot)
881 {
882 DistributedKvDataManager manager;
883 Options options;
884
885 AppId appId;
886 appId.appId = "audio_policy_manager";
887
888 options.securityLevel = S1;
889 options.createIfMissing = false;
890 options.encrypt = false;
891 options.autoSync = false;
892 options.kvStoreType = KvStoreType::SINGLE_VERSION;
893 options.area = EL1;
894 options.baseDir = std::string("/data/service/el1/public/database/") + appId.appId;
895
896 StoreId storeId;
897 storeId.storeId = "audiopolicy";
898 Status status = Status::SUCCESS;
899
900 // open and initialize kvstore instance.
901 if (audioPolicyKvStore_ == nullptr) {
902 uint32_t retries = 0;
903
904 do {
905 status = manager.GetSingleKvStore(options, appId, storeId, audioPolicyKvStore_);
906 if (status == Status::INVALID_ARGUMENT) {
907 AUDIO_ERR_LOG("InitAudioPolicyKvStore: INVALID_ARGUMENT!");
908 }
909
910 if ((status == Status::SUCCESS) || (status == Status::INVALID_ARGUMENT)) {
911 break;
912 } else {
913 AUDIO_ERR_LOG("InitAudioPolicyKvStore: Kvstore Connect failed! Retrying.");
914 retries++;
915 usleep(KVSTORE_CONNECT_RETRY_DELAY_TIME);
916 }
917 } while (retries <= KVSTORE_CONNECT_RETRY_COUNT);
918 }
919
920 if (audioPolicyKvStore_ == nullptr) {
921 if (status == Status::INVALID_ARGUMENT) {
922 AUDIO_INFO_LOG("First Boot: Create AudioPolicyKvStore");
923 options.createIfMissing = true;
924 // [create and] open and initialize kvstore instance.
925 status = manager.GetSingleKvStore(options, appId, storeId, audioPolicyKvStore_);
926 if (status == Status::SUCCESS) {
927 isFirstBoot = true;
928 } else {
929 AUDIO_ERR_LOG("Create AudioPolicyKvStore Failed!");
930 }
931 }
932 }
933
934 if (audioPolicyKvStore_ == nullptr) {
935 AUDIO_ERR_LOG("InitAudioPolicyKvStore: Failed!");
936 return false;
937 }
938
939 return true;
940 }
941
InitVolumeMap(bool isFirstBoot)942 void AudioAdapterManager::InitVolumeMap(bool isFirstBoot)
943 {
944 if (audioPolicyKvStore_ == nullptr) {
945 AUDIO_ERR_LOG("InitVolumeMap: kvstore is null!");
946 return;
947 }
948 if (isFirstBoot) {
949 AUDIO_INFO_LOG("InitVolumeMap: Wrote default stream volumes to KvStore");
950 for (auto &deviceType: DEVICE_TYPE_LIST) {
951 for (auto &streamType: VOLUME_TYPE_LIST) {
952 WriteVolumeToKvStore(deviceType, streamType, volumeLevelMap_[streamType]);
953 }
954 }
955 } else {
956 LoadVolumeMap();
957 }
958 }
959
InitRingerMode(bool isFirstBoot)960 void AudioAdapterManager::InitRingerMode(bool isFirstBoot)
961 {
962 if (audioPolicyKvStore_ == nullptr) {
963 AUDIO_ERR_LOG("InitRingerMode: kvstore is null!");
964 return;
965 }
966
967 if (isFirstBoot) {
968 AUDIO_INFO_LOG("InitRingerMode Wrote default ringer mode to KvStore");
969 ringerMode_ = RINGER_MODE_NORMAL;
970 WriteRingerModeToKvStore(RINGER_MODE_NORMAL);
971 } else {
972 LoadRingerMode();
973 }
974 }
975
LoadVolumeFromKvStore(DeviceType deviceType,AudioStreamType streamType)976 bool AudioAdapterManager::LoadVolumeFromKvStore(DeviceType deviceType, AudioStreamType streamType)
977 {
978 std::string volumeKey = GetVolumeKeyForKvStore(deviceType, streamType);
979 if (!volumeKey.compare("")) {
980 AUDIO_ERR_LOG("LoadVolumeFromKvStore: [device %{public}d, streamType %{public}d] is not supported for kvStore",
981 deviceType, streamType);
982 return false;
983 }
984
985 Key key = volumeKey;
986 Value value;
987 Status status = audioPolicyKvStore_->Get(key, value);
988 if (status == Status::SUCCESS) {
989 int32_t volumeLevel = TransferByteArrayToType<int>(value.Data());
990 volumeLevelMap_[streamType] = volumeLevel;
991 AUDIO_DEBUG_LOG("LoadVolumeFromKvStore: volumeLevel %{public}d for streamType: %{public}d from kvStore",
992 volumeLevel, streamType);
993 return true;
994 }
995
996 return false;
997 }
998
LoadVolumeMap(void)999 bool AudioAdapterManager::LoadVolumeMap(void)
1000 {
1001 if (audioPolicyKvStore_ == nullptr) {
1002 AUDIO_ERR_LOG("LoadVolumeMap: audioPolicyKvStore_ is null!");
1003 return false;
1004 }
1005
1006 for (auto &streamType: VOLUME_TYPE_LIST) {
1007 bool result = LoadVolumeFromKvStore(currentActiveDevice_, streamType);
1008 if (!result) {
1009 AUDIO_ERR_LOG("LoadVolumeMap: Could not load volume for streamType[%{public}d] from kvStore", streamType);
1010 }
1011 }
1012
1013 return true;
1014 }
1015
LoadRingerMode(void)1016 bool AudioAdapterManager::LoadRingerMode(void)
1017 {
1018 if (audioPolicyKvStore_ == nullptr) {
1019 AUDIO_ERR_LOG("LoadRingerMap: audioPolicyKvStore_ is null!");
1020 return false;
1021 }
1022
1023 // get ringer mode value from kvstore.
1024 Key key = "ringermode";
1025 Value value;
1026 Status status = audioPolicyKvStore_->Get(key, value);
1027 if (status == Status::SUCCESS) {
1028 ringerMode_ = static_cast<AudioRingerMode>(TransferByteArrayToType<int>(value.Data()));
1029 AUDIO_DEBUG_LOG("LoadRingerMode Ringer Mode from kvStore %{public}d", ringerMode_);
1030 }
1031
1032 return true;
1033 }
1034
WriteVolumeToKvStore(DeviceType type,AudioStreamType streamType,int32_t volumeLevel)1035 void AudioAdapterManager::WriteVolumeToKvStore(DeviceType type, AudioStreamType streamType, int32_t volumeLevel)
1036 {
1037 if (audioPolicyKvStore_ == nullptr) {
1038 AUDIO_ERR_LOG("WriteVolumeToKvStore failed: audioPolicyKvStore_ is nullptr");
1039 return;
1040 }
1041
1042 std::string volumeKey = GetVolumeKeyForKvStore(type, streamType);
1043 if (!volumeKey.compare("")) {
1044 AUDIO_ERR_LOG("WriteVolumeToKvStore: [device %{public}d, streamType %{public}d] is not supported for kvStore",
1045 type, streamType);
1046 return;
1047 }
1048
1049 Key key = volumeKey;
1050 Value value = Value(TransferTypeToByteArray<int>(volumeLevel));
1051
1052 Status status = audioPolicyKvStore_->Put(key, value);
1053 if (status == Status::SUCCESS) {
1054 AUDIO_INFO_LOG("WriteVolumeToKvStore: volumeLevel %{public}d for %{public}s", volumeLevel, volumeKey.c_str());
1055 } else {
1056 AUDIO_ERR_LOG("WriteVolumeToKvStore: Failed to write volumeLevel %{public}d for %{public}s to kvStore!",
1057 volumeLevel, volumeKey.c_str());
1058 }
1059
1060 return;
1061 }
1062
WriteRingerModeToKvStore(AudioRingerMode ringerMode)1063 void AudioAdapterManager::WriteRingerModeToKvStore(AudioRingerMode ringerMode)
1064 {
1065 if (audioPolicyKvStore_ == nullptr) {
1066 AUDIO_ERR_LOG("WriteRingerModeToKvStore failed: audioPolicyKvStore_ is nullptr");
1067 return;
1068 }
1069
1070 Key key = "ringermode";
1071 Value value = Value(TransferTypeToByteArray<int>(ringerMode));
1072
1073 Status status = audioPolicyKvStore_->Put(key, value);
1074 if (status == Status::SUCCESS) {
1075 AUDIO_INFO_LOG("WriteRingerModeToKvStore Wrote RingerMode:%d to kvStore", ringerMode);
1076 } else {
1077 AUDIO_ERR_LOG("WriteRingerModeToKvStore Writing RingerMode:%d to kvStore failed!", ringerMode);
1078 }
1079
1080 return;
1081 }
1082
InitMuteStatusMap(bool isFirstBoot)1083 void AudioAdapterManager::InitMuteStatusMap(bool isFirstBoot)
1084 {
1085 if (audioPolicyKvStore_ == nullptr) {
1086 AUDIO_ERR_LOG("InitMuteStatusMap: kvstore is null!");
1087 return;
1088 }
1089 if (isFirstBoot) {
1090 AUDIO_INFO_LOG("InitMuteStatusMap: Wrote default mute status to KvStore");
1091 for (auto &deviceType: DEVICE_TYPE_LIST) {
1092 for (auto &streamType: VOLUME_TYPE_LIST) {
1093 WriteMuteStatusToKvStore(deviceType, streamType, 0);
1094 }
1095 }
1096 } else {
1097 LoadMuteStatusMap();
1098 }
1099 }
1100
1101
LoadMuteStatusMap(void)1102 bool AudioAdapterManager::LoadMuteStatusMap(void)
1103 {
1104 if (audioPolicyKvStore_ == nullptr) {
1105 AUDIO_ERR_LOG("LoadMuteStatusMap: audioPolicyKvStore_ is null");
1106 return false;
1107 }
1108
1109 for (auto &streamType: VOLUME_TYPE_LIST) {
1110 bool result = LoadMuteStatusFromKvStore(currentActiveDevice_, streamType);
1111 if (!result) {
1112 AUDIO_ERR_LOG("Could not load mute status for stream type %{public}d from kvStore", streamType);
1113 }
1114 }
1115 return true;
1116 }
1117
LoadMuteStatusFromKvStore(DeviceType deviceType,AudioStreamType streamType)1118 bool AudioAdapterManager::LoadMuteStatusFromKvStore(DeviceType deviceType, AudioStreamType streamType)
1119 {
1120 std::string muteKey = GetMuteKeyForKvStore(deviceType, streamType);
1121 if (!muteKey.compare("")) {
1122 AUDIO_ERR_LOG("LoadMuteStatusFromKvStore: [device %{public}d, streamType %{public}d] is not supported for "\
1123 "kvStore", deviceType, streamType);
1124 return false;
1125 }
1126
1127 Key key = muteKey;
1128 Value value;
1129
1130 Status status = audioPolicyKvStore_->Get(key, value);
1131 if (status == Status::SUCCESS) {
1132 bool muteStatus = TransferByteArrayToType<int>(value.Data());
1133 muteStatusMap_[streamType] = muteStatus;
1134 return true;
1135 }
1136
1137 return false;
1138 }
1139
GetMuteKeyForKvStore(DeviceType deviceType,AudioStreamType streamType)1140 std::string AudioAdapterManager::GetMuteKeyForKvStore(DeviceType deviceType, AudioStreamType streamType)
1141 {
1142 std::string type = "";
1143 switch (deviceType) {
1144 case DEVICE_TYPE_EARPIECE:
1145 case DEVICE_TYPE_SPEAKER:
1146 type = "build-in";
1147 break;
1148 case DEVICE_TYPE_BLUETOOTH_A2DP:
1149 case DEVICE_TYPE_BLUETOOTH_SCO:
1150 type = "wireless";
1151 break;
1152 case DEVICE_TYPE_WIRED_HEADSET:
1153 case DEVICE_TYPE_USB_HEADSET:
1154 type = "wired";
1155 break;
1156 default:
1157 AUDIO_ERR_LOG("GetMuteKeyForKvStore: device %{public}d is not supported for kvStore", deviceType);
1158 return "";
1159 }
1160
1161 switch (streamType) {
1162 case STREAM_MUSIC:
1163 return type + "_music_mute_status";
1164 case STREAM_RING:
1165 return type + "_ring_mute_status";
1166 case STREAM_SYSTEM:
1167 return type + "_system_mute_status";
1168 case STREAM_NOTIFICATION:
1169 return type + "_notification_mute_status";
1170 case STREAM_ALARM:
1171 return type + "_alarm_mute_status";
1172 case STREAM_DTMF:
1173 return type + "_dtmf_mute_status";
1174 case STREAM_VOICE_CALL:
1175 return type + "_voice_call_mute_status";
1176 case STREAM_VOICE_ASSISTANT:
1177 return type + "_voice_assistant_mute_status";
1178 case STREAM_ACCESSIBILITY:
1179 return type + "_accessibility_mute_status";
1180 case STREAM_ULTRASONIC:
1181 return type + "_unltrasonic_mute_status";
1182 default:
1183 AUDIO_ERR_LOG("GetMuteKeyForKvStore: streamType %{public}d is not supported for kvStore", streamType);
1184 return "";
1185 }
1186 }
1187
WriteMuteStatusToKvStore(DeviceType deviceType,AudioStreamType streamType,bool muteStatus)1188 void AudioAdapterManager::WriteMuteStatusToKvStore(DeviceType deviceType, AudioStreamType streamType,
1189 bool muteStatus)
1190 {
1191 if (audioPolicyKvStore_ == nullptr) {
1192 AUDIO_ERR_LOG("WriteMuteStatusToKvStore failed: audioPolicyKvStore_ is nullptr");
1193 return;
1194 }
1195
1196 std::string muteKey = GetMuteKeyForKvStore(deviceType, streamType);
1197 if (!muteKey.compare("")) {
1198 AUDIO_ERR_LOG("WriteMuteStatusToKvStore: [device %{public}d, streamType %{public}d] is not supported for "\
1199 "kvStore", deviceType, streamType);
1200 return;
1201 }
1202
1203 Key key = muteKey;
1204 Value value = Value(TransferTypeToByteArray<int>(muteStatus));
1205
1206 Status status = audioPolicyKvStore_->Put(key, value);
1207 if (status == Status::SUCCESS) {
1208 AUDIO_INFO_LOG("WriteMuteStatusToKvStore: muteStatus %{public}d for %{public}s", muteStatus, muteKey.c_str());
1209 } else {
1210 AUDIO_ERR_LOG("WriteMuteStatusToKvStore: Failed to write muteStatus %{public}d for %{public}s to kvStore!",
1211 muteStatus, muteKey.c_str());
1212 }
1213
1214 return;
1215 }
1216
CalculateVolumeDb(int32_t volumeLevel)1217 float AudioAdapterManager::CalculateVolumeDb(int32_t volumeLevel)
1218 {
1219 float value = static_cast<float>(volumeLevel) / MAX_VOLUME_LEVEL;
1220 float roundValue = static_cast<int>(value * CONST_FACTOR);
1221
1222 return static_cast<float>(roundValue) / CONST_FACTOR;
1223 }
1224
SetSystemSoundUri(const std::string & key,const std::string & uri)1225 int32_t AudioAdapterManager::SetSystemSoundUri(const std::string &key, const std::string &uri)
1226 {
1227 return WriteSystemSoundUriToKvStore(key, uri);
1228 }
1229
GetSystemSoundUri(const std::string & key)1230 std::string AudioAdapterManager::GetSystemSoundUri(const std::string &key)
1231 {
1232 return LoadSystemSoundUriFromKvStore(key);
1233 }
1234
WriteSystemSoundUriToKvStore(const std::string & key,const std::string & uri)1235 int32_t AudioAdapterManager::WriteSystemSoundUriToKvStore(const std::string &key, const std::string &uri)
1236 {
1237 if (audioPolicyKvStore_ == nullptr) {
1238 AUDIO_ERR_LOG("WriteSystemSoundUriToKvStore failed: audioPolicyKvStore_ is nullptr");
1239 return ERROR;
1240 }
1241
1242 Status status = audioPolicyKvStore_->Put(key, uri);
1243 if (status == Status::SUCCESS) {
1244 AUDIO_INFO_LOG("WriteSystemSoundUriToKvStore: Wrote [%{public}s]: [%{public}s] to kvStore",
1245 key.c_str(), uri.c_str());
1246 } else {
1247 AUDIO_ERR_LOG("WriteSystemSoundUriToKvStore: Writing [%{public}s]: [%{public}s] to kvStore failed",
1248 key.c_str(), uri.c_str());
1249 }
1250
1251 return SUCCESS;
1252 }
1253
LoadSystemSoundUriFromKvStore(const std::string & key)1254 std::string AudioAdapterManager::LoadSystemSoundUriFromKvStore(const std::string &key)
1255 {
1256 std::string uri = "";
1257 if (audioPolicyKvStore_ == nullptr) {
1258 AUDIO_ERR_LOG("LoadSystemSoundUriFromKvStore failed: audioPolicyKvStore_ is nullptr");
1259 return uri;
1260 }
1261 Value value;
1262 Status status = audioPolicyKvStore_->Get(key, value);
1263 if (status == Status::SUCCESS) {
1264 uri = value.ToString();
1265 }
1266 AUDIO_INFO_LOG("LoadSystemSoundUriFromKvStore:: [%{public}s]: [%{public}s]", key.c_str(), uri.c_str());
1267 return uri;
1268 }
1269
GetMinStreamVolume() const1270 float AudioAdapterManager::GetMinStreamVolume() const
1271 {
1272 return MIN_STREAM_VOLUME;
1273 }
1274
GetMaxStreamVolume() const1275 float AudioAdapterManager::GetMaxStreamVolume() const
1276 {
1277 return MAX_STREAM_VOLUME;
1278 }
1279
UpdateSwapDeviceStatus()1280 int32_t AudioAdapterManager::UpdateSwapDeviceStatus()
1281 {
1282 if (!audioServiceAdapter_) {
1283 AUDIO_ERR_LOG("UpdateSwapDeviceStatus audio adapter null");
1284 return ERR_OPERATION_FAILED;
1285 }
1286 return audioServiceAdapter_->UpdateSwapDeviceStatus();
1287 }
1288
IsVolumeUnadjustable()1289 bool AudioAdapterManager::IsVolumeUnadjustable()
1290 {
1291 return isVolumeUnadjustable_;
1292 }
1293
GetSystemVolumeInDb(AudioVolumeType volumeType,int32_t volumeLevel,DeviceType deviceType)1294 float AudioAdapterManager::GetSystemVolumeInDb(AudioVolumeType volumeType, int32_t volumeLevel, DeviceType deviceType)
1295 {
1296 AUDIO_INFO_LOG("GetSystemVolumeInDb for volumeType: %{public}d deviceType:%{public}d volumeLevel:%{public}d",
1297 volumeType, deviceType, volumeLevel);
1298 if (useNonlinearAlgo_) {
1299 getSystemVolumeInDb_ = CalculateVolumeDbNonlinear(volumeType, deviceType, volumeLevel);
1300 } else {
1301 getSystemVolumeInDb_ = CalculateVolumeDb(volumeLevel);
1302 }
1303 AUDIO_INFO_LOG("Get system volume in db success %{public}f", getSystemVolumeInDb_);
1304
1305 return getSystemVolumeInDb_;
1306 }
1307
GetPositionInVolumePoints(std::vector<VolumePoint> & volumePoints,int32_t idx)1308 uint32_t AudioAdapterManager::GetPositionInVolumePoints(std::vector<VolumePoint> &volumePoints, int32_t idx)
1309 {
1310 int32_t leftPos = 0;
1311 int32_t rightPos = volumePoints.size() - 1;
1312 while (leftPos <= rightPos) {
1313 int32_t midPos = leftPos + (rightPos - leftPos)/NUMBER_TWO;
1314 int32_t c = volumePoints[midPos].index - idx;
1315 if (c == 0) {
1316 leftPos = midPos;
1317 break;
1318 } else if (c < 0) {
1319 leftPos = midPos + 1;
1320 } else {
1321 rightPos = midPos - 1;
1322 }
1323 }
1324 return leftPos;
1325 }
1326
CalculateVolumeDbNonlinear(AudioStreamType streamType,DeviceType deviceType,int32_t volumeLevel)1327 float AudioAdapterManager::CalculateVolumeDbNonlinear(AudioStreamType streamType,
1328 DeviceType deviceType, int32_t volumeLevel)
1329 {
1330 AUDIO_INFO_LOG("CalculateVolumeDbNonlinear for stream: %{public}d devicetype:%{public}d volumeLevel:%{public}d",
1331 streamType, deviceType, volumeLevel);
1332 AudioStreamType streamAlias = GetStreamForVolumeMap(streamType);
1333 int32_t minVolIndex = GetMinVolumeLevel(streamAlias);
1334 int32_t maxVolIndex = GetMaxVolumeLevel(streamAlias);
1335 if (minVolIndex < 0 || maxVolIndex < 0 || minVolIndex >= maxVolIndex) {
1336 return 0.0f;
1337 }
1338 if (volumeLevel < minVolIndex) {
1339 volumeLevel = minVolIndex;
1340 }
1341 if (volumeLevel > maxVolIndex) {
1342 volumeLevel = maxVolIndex;
1343 }
1344
1345 DeviceVolumeType deviceCategory = GetDeviceCategory(deviceType);
1346 std::vector<VolumePoint> volumePoints;
1347 GetVolumePoints(streamAlias, deviceCategory, volumePoints);
1348 int32_t pointSize = volumePoints.size();
1349
1350 int32_t volSteps = 1 + volumePoints[pointSize - 1].index - volumePoints[0].index;
1351 int32_t idxRatio = (volSteps * (volumeLevel - minVolIndex)) / (maxVolIndex - minVolIndex);
1352 int32_t position = GetPositionInVolumePoints(volumePoints, idxRatio);
1353 if (position == 0) {
1354 if (minVolIndex != 0) {
1355 AUDIO_INFO_LOG("Min volume index not zero, use min db: %{public}0.1f", volumePoints[0].dbValue / 100.0f);
1356 return exp((volumePoints[0].dbValue / 100.0f) * 0.115129f);
1357 }
1358 AUDIO_INFO_LOG("position = 0, return 0.0");
1359 return 0.0f;
1360 } else if (position >= pointSize) {
1361 AUDIO_INFO_LOG("position > pointSize, return %{public}f", exp(volumePoints[pointSize - 1].dbValue * 0.115129f));
1362 return exp((volumePoints[pointSize - 1].dbValue / 100.0f) * 0.115129f);
1363 }
1364 float indexFactor = ((float)(idxRatio - volumePoints[position-1].index)) /
1365 (float(volumePoints[position].index - volumePoints[position-1].index));
1366
1367 float dbValue = (volumePoints[position-1].dbValue / 100.0f) +
1368 indexFactor * ((volumePoints[position].dbValue / 100.0f) - (volumePoints[position-1].dbValue / 100.0f));
1369
1370 AUDIO_INFO_LOG(" index=[%{public}d, %{public}d, %{public}d]"
1371 "db=[%{public}0.1f %{public}0.1f %{public}0.1f] factor=[%{public}f]",
1372 volumePoints[position-1].index, idxRatio, volumePoints[position].index,
1373 ((float)volumePoints[position - 1].dbValue / 100.0f), dbValue,
1374 ((float)volumePoints[position].dbValue / 100.0f), exp(dbValue * 0.115129f));
1375
1376 return exp(dbValue * 0.115129f);
1377 }
1378
InitVolumeMapIndex()1379 void AudioAdapterManager::InitVolumeMapIndex()
1380 {
1381 useNonlinearAlgo_ = 0;
1382 for (auto streamType : VOLUME_TYPE_LIST) {
1383 minVolumeIndexMap_[streamType] = MIN_VOLUME_LEVEL;
1384 maxVolumeIndexMap_[streamType] = MAX_VOLUME_LEVEL;
1385 volumeLevelMap_[streamType] = DEFAULT_VOLUME_LEVEL;
1386 AUDIO_DEBUG_LOG("streamType %{public}d index = [%{public}d, %{public}d, %{public}d]",
1387 streamType, minVolumeIndexMap_[streamType],
1388 maxVolumeIndexMap_[streamType], volumeLevelMap_[streamType]);
1389 }
1390
1391 volumeLevelMap_[STREAM_ULTRASONIC] = MAX_VOLUME_LEVEL;
1392 }
1393
UpdateVolumeMapIndex()1394 void AudioAdapterManager::UpdateVolumeMapIndex()
1395 {
1396 for (auto streamVolInfoPair : streamVolumeInfos_) {
1397 auto streamVolInfo = streamVolInfoPair.second;
1398 minVolumeIndexMap_[streamVolInfo->streamType] = streamVolInfo->minLevel;
1399 maxVolumeIndexMap_[streamVolInfo->streamType] = streamVolInfo->maxLevel;
1400 volumeLevelMap_[streamVolInfo->streamType] = streamVolInfo->defaultLevel;
1401 AUDIO_DEBUG_LOG("update streamType %{public}d index = [%{public}d, %{public}d, %{public}d]",
1402 streamVolInfo->streamType, minVolumeIndexMap_[streamVolInfo->streamType],
1403 maxVolumeIndexMap_[streamVolInfo->streamType], volumeLevelMap_[streamVolInfo->streamType]);
1404 }
1405 }
1406
GetVolumePoints(AudioVolumeType streamType,DeviceVolumeType deviceType,std::vector<VolumePoint> & volumePoints)1407 void AudioAdapterManager::GetVolumePoints(AudioVolumeType streamType, DeviceVolumeType deviceType,
1408 std::vector<VolumePoint> &volumePoints)
1409 {
1410 auto streamVolInfo = streamVolumeInfos_.find(streamType);
1411 auto deviceVolInfo = streamVolInfo->second->deviceVolumeInfos.find(deviceType);
1412 volumePoints = deviceVolInfo->second->volumePoints;
1413 }
1414
GetStreamVolumeInfoMap(StreamVolumeInfoMap & streamVolumeInfos)1415 void AudioAdapterManager::GetStreamVolumeInfoMap(StreamVolumeInfoMap &streamVolumeInfos)
1416 {
1417 streamVolumeInfos = streamVolumeInfos_;
1418 }
1419
GetActiveDevice()1420 DeviceType AudioAdapterManager::GetActiveDevice()
1421 {
1422 return currentActiveDevice_;
1423 }
1424 } // namespace AudioStandard
1425 } // namespace OHOS
1426