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 "audio_policy_server.h"
17
18 #include <csignal>
19 #include <memory>
20 #include <unordered_set>
21 #include <vector>
22 #include <condition_variable>
23
24 #include "input_manager.h"
25 #include "key_event.h"
26 #include "key_option.h"
27
28 #include "privacy_kit.h"
29 #include "accesstoken_kit.h"
30 #include "permission_state_change_info.h"
31 #include "token_setproc.h"
32 #include "tokenid_kit.h"
33
34 #include "ipc_skeleton.h"
35 #include "iservice_registry.h"
36 #include "system_ability_definition.h"
37
38 #include "audio_log.h"
39 #include "audio_errors.h"
40 #include "audio_utils.h"
41 #include "audio_policy_manager_listener_proxy.h"
42 #include "audio_routing_manager_listener_proxy.h"
43 #include "audio_ringermode_update_listener_proxy.h"
44 #include "audio_volume_key_event_callback_proxy.h"
45 #include "i_standard_audio_policy_manager_listener.h"
46
47 #include "parameter.h"
48 #include "parameters.h"
49
50 using OHOS::Security::AccessToken::PrivacyKit;
51 using OHOS::Security::AccessToken::TokenIdKit;
52 using namespace std;
53
54 namespace OHOS {
55 namespace AudioStandard {
56 constexpr float DUCK_FACTOR = 0.2f; // 20%
57 constexpr int32_t PARAMS_VOLUME_NUM = 5;
58 constexpr int32_t PARAMS_INTERRUPT_NUM = 4;
59 constexpr int32_t PARAMS_RENDER_STATE_NUM = 2;
60 constexpr int32_t EVENT_DES_SIZE = 60;
61 constexpr int32_t RENDER_STATE_CONTENT_DES_SIZE = 60;
62 constexpr uid_t UID_ROOT = 0;
63 constexpr uid_t UID_MSDP_SA = 6699;
64 constexpr uid_t UID_INTELLIGENT_VOICE_SA = 1042;
65 constexpr uid_t UID_CAAS_SA = 5527;
66 constexpr uid_t UID_DISTRIBUTED_AUDIO_SA = 3055;
67 constexpr uid_t UID_MEDIA_SA = 1013;
68 constexpr uid_t UID_FOUNDATION_SA = 5523;
69
70 REGISTER_SYSTEM_ABILITY_BY_ID(AudioPolicyServer, AUDIO_POLICY_SERVICE_ID, true)
71
72 const map<InterruptHint, AudioFocuState> AudioPolicyServer::HINTSTATEMAP = AudioPolicyServer::CreateStateMap();
73
CreateStateMap()74 map<InterruptHint, AudioFocuState> AudioPolicyServer::CreateStateMap()
75 {
76 map<InterruptHint, AudioFocuState> stateMap;
77 stateMap[INTERRUPT_HINT_PAUSE] = PAUSE;
78 stateMap[INTERRUPT_HINT_DUCK] = DUCK;
79 stateMap[INTERRUPT_HINT_NONE] = ACTIVE;
80 stateMap[INTERRUPT_HINT_RESUME] = ACTIVE;
81 stateMap[INTERRUPT_HINT_UNDUCK] = ACTIVE;
82
83 return stateMap;
84 }
85
86 const std::list<uid_t> AudioPolicyServer::RECORD_ALLOW_BACKGROUND_LIST = {
87 UID_ROOT,
88 UID_MSDP_SA,
89 UID_INTELLIGENT_VOICE_SA,
90 UID_CAAS_SA,
91 UID_DISTRIBUTED_AUDIO_SA,
92 UID_FOUNDATION_SA
93 };
94
95 const std::list<uid_t> AudioPolicyServer::RECORD_PASS_APPINFO_LIST = {
96 UID_MEDIA_SA
97 };
98
AudioPolicyServer(int32_t systemAbilityId,bool runOnCreate)99 AudioPolicyServer::AudioPolicyServer(int32_t systemAbilityId, bool runOnCreate)
100 : SystemAbility(systemAbilityId, runOnCreate),
101 mPolicyService(AudioPolicyService::GetAudioPolicyService())
102 {
103 if (mPolicyService.SetAudioSessionCallback(this)) {
104 AUDIO_DEBUG_LOG("AudioPolicyServer: SetAudioSessionCallback failed");
105 }
106
107 volumeStep_ = system::GetIntParameter("const.multimedia.audio.volumestep", 1);
108 AUDIO_INFO_LOG("Get volumeStep parameter success %{public}d", volumeStep_);
109
110 clientOnFocus_ = 0;
111 focussedAudioInterruptInfo_ = nullptr;
112 }
113
OnDump()114 void AudioPolicyServer::OnDump()
115 {
116 return;
117 }
118
OnStart()119 void AudioPolicyServer::OnStart()
120 {
121 AUDIO_INFO_LOG("AudioPolicyServer OnStart");
122 mPolicyService.Init();
123 AddSystemAbilityListener(DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID);
124 AddSystemAbilityListener(MULTIMODAL_INPUT_SERVICE_ID);
125 AddSystemAbilityListener(AUDIO_DISTRIBUTED_SERVICE_ID);
126 AddSystemAbilityListener(BLUETOOTH_HOST_SYS_ABILITY_ID);
127 AddSystemAbilityListener(ACCESSIBILITY_MANAGER_SERVICE_ID);
128
129 bool res = Publish(this);
130 if (!res) {
131 AUDIO_INFO_LOG("AudioPolicyServer start err");
132 }
133
134 Security::AccessToken::PermStateChangeScope scopeInfo;
135 scopeInfo.permList = {"ohos.permission.MICROPHONE"};
136 auto callbackPtr = std::make_shared<PerStateChangeCbCustomizeCallback>(scopeInfo, this);
137 callbackPtr->ready_ = false;
138 int32_t iRes = Security::AccessToken::AccessTokenKit::RegisterPermStateChangeCallback(callbackPtr);
139 if (iRes < 0) {
140 AUDIO_ERR_LOG("fail to call RegisterPermStateChangeCallback.");
141 }
142 }
143
OnStop()144 void AudioPolicyServer::OnStop()
145 {
146 mPolicyService.Deinit();
147 return;
148 }
149
OnAddSystemAbility(int32_t systemAbilityId,const std::string & deviceId)150 void AudioPolicyServer::OnAddSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
151 {
152 AUDIO_DEBUG_LOG("OnAddSystemAbility systemAbilityId:%{public}d", systemAbilityId);
153 switch (systemAbilityId) {
154 case MULTIMODAL_INPUT_SERVICE_ID:
155 AUDIO_INFO_LOG("OnAddSystemAbility input service start");
156 SubscribeVolumeKeyEvents();
157 break;
158 case DISTRIBUTED_KV_DATA_SERVICE_ABILITY_ID:
159 AUDIO_INFO_LOG("OnAddSystemAbility kv data service start");
160 InitKVStore();
161 RegisterDataObserver();
162 break;
163 case AUDIO_DISTRIBUTED_SERVICE_ID:
164 AUDIO_INFO_LOG("OnAddSystemAbility audio service start");
165 ConnectServiceAdapter();
166 RegisterParamCallback();
167 LoadEffectLibrary();
168 break;
169 case BLUETOOTH_HOST_SYS_ABILITY_ID:
170 AUDIO_INFO_LOG("OnAddSystemAbility bluetooth service start");
171 RegisterBluetoothListener();
172 break;
173 case ACCESSIBILITY_MANAGER_SERVICE_ID:
174 AUDIO_INFO_LOG("OnAddSystemAbility accessibility service start");
175 SubscribeAccessibilityConfigObserver();
176 InitKVStore();
177 RegisterDataObserver();
178 break;
179 default:
180 AUDIO_ERR_LOG("OnAddSystemAbility unhandled sysabilityId:%{public}d", systemAbilityId);
181 break;
182 }
183 }
184
OnRemoveSystemAbility(int32_t systemAbilityId,const std::string & deviceId)185 void AudioPolicyServer::OnRemoveSystemAbility(int32_t systemAbilityId, const std::string& deviceId)
186 {
187 AUDIO_DEBUG_LOG("AudioPolicyServer::OnRemoveSystemAbility systemAbilityId:%{public}d removed", systemAbilityId);
188 }
189
MaxOrMinVolumeOption(const int32_t & volLevel,const int32_t keyType,const AudioStreamType & streamInFocus)190 bool AudioPolicyServer::MaxOrMinVolumeOption(const int32_t &volLevel, const int32_t keyType,
191 const AudioStreamType &streamInFocus)
192 {
193 bool volLevelCheck = (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) ?
194 volLevel >= GetMaxVolumeLevel(streamInFocus) : volLevel <= GetMinVolumeLevel(streamInFocus);
195 if (volLevelCheck) {
196 for (auto it = volumeChangeCbsMap_.begin(); it != volumeChangeCbsMap_.end(); ++it) {
197 std::shared_ptr<VolumeKeyEventCallback> volumeChangeCb = it->second;
198 if (volumeChangeCb == nullptr) {
199 AUDIO_ERR_LOG("volumeChangeCb: nullptr for client : %{public}d", it->first);
200 continue;
201 }
202
203 if (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) {
204 AUDIO_DEBUG_LOG("volume greater than max, trigger cb clientPid : %{public}d", it->first);
205 } else {
206 AUDIO_DEBUG_LOG("volume lower than min, trigger cb clientPid : %{public}d", it->first);
207 }
208 VolumeEvent volumeEvent;
209 volumeEvent.volumeType = (streamInFocus == STREAM_ALL) ? STREAM_MUSIC : streamInFocus;
210 volumeEvent.volume = volLevel;
211 volumeEvent.updateUi = true;
212 volumeEvent.volumeGroupId = 0;
213 volumeEvent.networkId = LOCAL_NETWORK_ID;
214 volumeChangeCb->OnVolumeKeyEvent(volumeEvent);
215 }
216 return true;
217 }
218
219 return false;
220 }
221
RegisterVolumeKeyEvents(const int32_t keyType)222 void AudioPolicyServer::RegisterVolumeKeyEvents(const int32_t keyType)
223 {
224 if ((keyType != OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) && (keyType != OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN)) {
225 AUDIO_ERR_LOG("VolumeKeyEvents: invalid key type : %{public}d", keyType);
226 return;
227 }
228 MMI::InputManager *im = MMI::InputManager::GetInstance();
229 CHECK_AND_RETURN_LOG(im != nullptr, "Failed to obtain INPUT manager");
230
231 std::set<int32_t> preKeys;
232 std::shared_ptr<OHOS::MMI::KeyOption> keyOption = std::make_shared<OHOS::MMI::KeyOption>();
233 CHECK_AND_RETURN_LOG(keyOption != nullptr, "Invalid key option");
234 keyOption->SetPreKeys(preKeys);
235 keyOption->SetFinalKey(keyType);
236 keyOption->SetFinalKeyDown(true);
237 keyOption->SetFinalKeyDownDuration(VOLUME_KEY_DURATION);
238 int32_t keySubId = im->SubscribeKeyEvent(keyOption, [=](std::shared_ptr<MMI::KeyEvent> keyEventCallBack) {
239 AUDIO_INFO_LOG("Receive volume key event: %{public}s.",
240 (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) ? "up" : "down");
241 std::lock_guard<std::mutex> lock(volumeKeyEventMutex_);
242 AudioStreamType streamInFocus = AudioStreamType::STREAM_MUSIC; // use STREAM_MUSIC as default stream type
243 if ((mPolicyService.GetLocalDevicesType().compare("tablet") == 0) ||
244 (mPolicyService.GetLocalDevicesType().compare("2in1") == 0)) {
245 streamInFocus = AudioStreamType::STREAM_ALL;
246 } else {
247 streamInFocus = GetVolumeTypeFromStreamType(GetStreamInFocus());
248 }
249 if (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP && GetStreamMuteInternal(streamInFocus)) {
250 AUDIO_INFO_LOG("VolumeKeyEvents: volumeKey: Up. volumeType %{public}d is mute. Unmute.", streamInFocus);
251 SetStreamMuteInternal(streamInFocus, false, true);
252 return;
253 }
254 int32_t volumeLevelInInt = GetSystemVolumeLevelInternal(streamInFocus, false);
255 if (MaxOrMinVolumeOption(volumeLevelInInt, keyType, streamInFocus)) {
256 return;
257 }
258
259 volumeLevelInInt = (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) ?
260 ++volumeLevelInInt : --volumeLevelInInt;
261 SetSystemVolumeLevelInternal(streamInFocus, volumeLevelInInt, true);
262 });
263 if (keySubId < 0) {
264 AUDIO_ERR_LOG("SubscribeKeyEvent: subscribing for volume key: %{public}s option failed",
265 (keyType == OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP) ? "up" : "down");
266 }
267 }
268
RegisterVolumeKeyMuteEvents()269 void AudioPolicyServer::RegisterVolumeKeyMuteEvents()
270 {
271 MMI::InputManager *im = MMI::InputManager::GetInstance();
272 CHECK_AND_RETURN_LOG(im != nullptr, "Failed to obtain INPUT manager");
273
274 std::shared_ptr<OHOS::MMI::KeyOption> keyOptionMute = std::make_shared<OHOS::MMI::KeyOption>();
275 CHECK_AND_RETURN_LOG(keyOptionMute != nullptr, "keyOptionMute: Invalid key option");
276 std::set<int32_t> preKeys;
277 keyOptionMute->SetPreKeys(preKeys);
278 keyOptionMute->SetFinalKey(OHOS::MMI::KeyEvent::KEYCODE_VOLUME_MUTE);
279 keyOptionMute->SetFinalKeyDown(true);
280 keyOptionMute->SetFinalKeyDownDuration(VOLUME_MUTE_KEY_DURATION);
281 int32_t muteKeySubId = im->SubscribeKeyEvent(keyOptionMute,
282 [this](std::shared_ptr<MMI::KeyEvent> keyEventCallBack) {
283 AUDIO_INFO_LOG("Receive volume key event: mute");
284 std::lock_guard<std::mutex> lock(volumeKeyEventMutex_);
285 bool isMuted = GetStreamMute(AudioStreamType::STREAM_ALL);
286 SetStreamMuteInternal(AudioStreamType::STREAM_ALL, !isMuted, true);
287 });
288 if (muteKeySubId < 0) {
289 AUDIO_ERR_LOG("SubscribeKeyEvent: subscribing for mute failed ");
290 }
291 }
292
SubscribeVolumeKeyEvents()293 void AudioPolicyServer::SubscribeVolumeKeyEvents()
294 {
295 RegisterVolumeKeyEvents(OHOS::MMI::KeyEvent::KEYCODE_VOLUME_UP);
296 RegisterVolumeKeyEvents(OHOS::MMI::KeyEvent::KEYCODE_VOLUME_DOWN);
297 RegisterVolumeKeyMuteEvents();
298 }
299
GetVolumeTypeFromStreamType(AudioStreamType streamType)300 AudioVolumeType AudioPolicyServer::GetVolumeTypeFromStreamType(AudioStreamType streamType)
301 {
302 switch (streamType) {
303 case STREAM_VOICE_CALL:
304 case STREAM_VOICE_MESSAGE:
305 return STREAM_VOICE_CALL;
306 case STREAM_RING:
307 case STREAM_SYSTEM:
308 case STREAM_NOTIFICATION:
309 case STREAM_SYSTEM_ENFORCED:
310 case STREAM_DTMF:
311 return STREAM_RING;
312 case STREAM_MUSIC:
313 case STREAM_MEDIA:
314 case STREAM_MOVIE:
315 case STREAM_GAME:
316 case STREAM_SPEECH:
317 case STREAM_NAVIGATION:
318 return STREAM_MUSIC;
319 case STREAM_VOICE_ASSISTANT:
320 return STREAM_VOICE_ASSISTANT;
321 case STREAM_ALARM:
322 return STREAM_ALARM;
323 case STREAM_ACCESSIBILITY:
324 return STREAM_ACCESSIBILITY;
325 case STREAM_ULTRASONIC:
326 return STREAM_ULTRASONIC;
327 case STREAM_ALL:
328 return STREAM_ALL;
329 default:
330 return STREAM_MUSIC;
331 }
332 }
333
IsVolumeTypeValid(AudioStreamType streamType)334 bool AudioPolicyServer::IsVolumeTypeValid(AudioStreamType streamType)
335 {
336 bool result = false;
337 switch (streamType) {
338 case STREAM_MUSIC:
339 case STREAM_RING:
340 case STREAM_NOTIFICATION:
341 case STREAM_VOICE_CALL:
342 case STREAM_VOICE_ASSISTANT:
343 case STREAM_ALARM:
344 case STREAM_ACCESSIBILITY:
345 case STREAM_ULTRASONIC:
346 case STREAM_ALL:
347 result = true;
348 break;
349 default:
350 result = false;
351 AUDIO_ERR_LOG("IsVolumeTypeValid: streamType[%{public}d] is not supported", streamType);
352 break;
353 }
354 return result;
355 }
356
IsVolumeLevelValid(AudioStreamType streamType,int32_t volumeLevel)357 bool AudioPolicyServer::IsVolumeLevelValid(AudioStreamType streamType, int32_t volumeLevel)
358 {
359 bool result = true;
360 if (volumeLevel < mPolicyService.GetMinVolumeLevel(streamType) ||
361 volumeLevel > mPolicyService.GetMaxVolumeLevel(streamType)) {
362 AUDIO_ERR_LOG("IsVolumeLevelValid: volumeLevel[%{public}d] is out of valid range for streamType[%{public}d]",
363 volumeLevel, streamType);
364 result = false;
365 }
366 return result;
367 }
368
InitKVStore()369 void AudioPolicyServer::InitKVStore()
370 {
371 mPolicyService.InitKVStore();
372 }
373
ConnectServiceAdapter()374 void AudioPolicyServer::ConnectServiceAdapter()
375 {
376 if (!mPolicyService.ConnectServiceAdapter()) {
377 AUDIO_ERR_LOG("ConnectServiceAdapter Error in connecting to audio service adapter");
378 return;
379 }
380 }
381
LoadEffectLibrary()382 void AudioPolicyServer::LoadEffectLibrary()
383 {
384 mPolicyService.LoadEffectLibrary();
385 }
386
GetMaxVolumeLevel(AudioVolumeType volumeType)387 int32_t AudioPolicyServer::GetMaxVolumeLevel(AudioVolumeType volumeType)
388 {
389 return mPolicyService.GetMaxVolumeLevel(volumeType);
390 }
391
GetMinVolumeLevel(AudioVolumeType volumeType)392 int32_t AudioPolicyServer::GetMinVolumeLevel(AudioVolumeType volumeType)
393 {
394 return mPolicyService.GetMinVolumeLevel(volumeType);
395 }
396
SetSystemVolumeLevel(AudioStreamType streamType,int32_t volumeLevel,API_VERSION api_v)397 int32_t AudioPolicyServer::SetSystemVolumeLevel(AudioStreamType streamType, int32_t volumeLevel, API_VERSION api_v)
398 {
399 if (api_v == API_9 && !PermissionUtil::VerifySystemPermission()) {
400 AUDIO_ERR_LOG("SetSystemVolumeLevel: No system permission");
401 return ERR_PERMISSION_DENIED;
402 }
403
404 if (!IsVolumeTypeValid(streamType)) {
405 return ERR_NOT_SUPPORTED;
406 }
407 if (!IsVolumeLevelValid(streamType, volumeLevel)) {
408 return ERR_NOT_SUPPORTED;
409 }
410
411 return SetSystemVolumeLevelInternal(streamType, volumeLevel, false);
412 }
413
GetSystemVolumeLevel(AudioStreamType streamType)414 int32_t AudioPolicyServer::GetSystemVolumeLevel(AudioStreamType streamType)
415 {
416 return GetSystemVolumeLevelInternal(streamType, false);
417 }
418
GetSystemVolumeLevelInternal(AudioStreamType streamType,bool isFromVolumeKey)419 int32_t AudioPolicyServer::GetSystemVolumeLevelInternal(AudioStreamType streamType, bool isFromVolumeKey)
420 {
421 if (streamType == STREAM_ALL) {
422 streamType = STREAM_MUSIC;
423 AUDIO_DEBUG_LOG("GetVolume of STREAM_ALL for streamType = %{public}d ", streamType);
424 }
425 return mPolicyService.GetSystemVolumeLevel(streamType, isFromVolumeKey);
426 }
427
SetLowPowerVolume(int32_t streamId,float volume)428 int32_t AudioPolicyServer::SetLowPowerVolume(int32_t streamId, float volume)
429 {
430 return mPolicyService.SetLowPowerVolume(streamId, volume);
431 }
432
GetLowPowerVolume(int32_t streamId)433 float AudioPolicyServer::GetLowPowerVolume(int32_t streamId)
434 {
435 return mPolicyService.GetLowPowerVolume(streamId);
436 }
437
GetSingleStreamVolume(int32_t streamId)438 float AudioPolicyServer::GetSingleStreamVolume(int32_t streamId)
439 {
440 return mPolicyService.GetSingleStreamVolume(streamId);
441 }
442
IsVolumeUnadjustable()443 bool AudioPolicyServer::IsVolumeUnadjustable()
444 {
445 return mPolicyService.IsVolumeUnadjustable();
446 }
447
AdjustVolumeByStep(VolumeAdjustType adjustType)448 int32_t AudioPolicyServer::AdjustVolumeByStep(VolumeAdjustType adjustType)
449 {
450 AudioStreamType streamInFocus = GetVolumeTypeFromStreamType(GetStreamInFocus());
451 if (streamInFocus == AudioStreamType::STREAM_DEFAULT) {
452 streamInFocus = AudioStreamType::STREAM_MUSIC;
453 }
454
455 int32_t volumeLevelInInt = GetSystemVolumeLevel(streamInFocus);
456 int32_t ret = ERROR;
457 if (adjustType == VolumeAdjustType::VOLUME_UP) {
458 ret = SetSystemVolumeLevelInternal(streamInFocus, volumeLevelInInt + volumeStep_, false);
459 AUDIO_INFO_LOG("AdjustVolumeByStep Up, VolumeLevel is %{public}d", GetSystemVolumeLevel(streamInFocus));
460 }
461
462 if (adjustType == VolumeAdjustType::VOLUME_DOWN) {
463 ret = SetSystemVolumeLevelInternal(streamInFocus, volumeLevelInInt - volumeStep_, false);
464 AUDIO_INFO_LOG("AdjustVolumeByStep Down, VolumeLevel is %{public}d", GetSystemVolumeLevel(streamInFocus));
465 }
466 return ret;
467 }
468
AdjustSystemVolumeByStep(AudioVolumeType volumeType,VolumeAdjustType adjustType)469 int32_t AudioPolicyServer::AdjustSystemVolumeByStep(AudioVolumeType volumeType, VolumeAdjustType adjustType)
470 {
471 int32_t volumeLevelInInt = GetSystemVolumeLevel(volumeType);
472 int32_t ret = ERROR;
473
474 if (adjustType == VolumeAdjustType::VOLUME_UP) {
475 ret = SetSystemVolumeLevelInternal(volumeType, volumeLevelInInt + volumeStep_, false);
476 AUDIO_INFO_LOG("AdjustSystemVolumeByStep Up, VolumeLevel:%{public}d", GetSystemVolumeLevel(volumeType));
477 }
478
479 if (adjustType == VolumeAdjustType::VOLUME_DOWN) {
480 ret = SetSystemVolumeLevelInternal(volumeType, volumeLevelInInt - volumeStep_, false);
481 AUDIO_INFO_LOG("AdjustSystemVolumeByStep Down, VolumeLevel:%{public}d", GetSystemVolumeLevel(volumeType));
482 }
483 return ret;
484 }
485
GetSystemVolumeInDb(AudioVolumeType volumeType,int32_t volumeLevel,DeviceType deviceType)486 float AudioPolicyServer::GetSystemVolumeInDb(AudioVolumeType volumeType, int32_t volumeLevel, DeviceType deviceType)
487 {
488 if (!IsVolumeTypeValid(volumeType)) {
489 return static_cast<float>(ERR_INVALID_PARAM);
490 }
491 if (!IsVolumeLevelValid(volumeType, volumeLevel)) {
492 return static_cast<float>(ERR_INVALID_PARAM);
493 }
494
495 return mPolicyService.GetSystemVolumeInDb(volumeType, volumeLevel, deviceType);
496 }
497
SetStreamMute(AudioStreamType streamType,bool mute,API_VERSION api_v)498 int32_t AudioPolicyServer::SetStreamMute(AudioStreamType streamType, bool mute, API_VERSION api_v)
499 {
500 if (api_v == API_9 && !PermissionUtil::VerifySystemPermission()) {
501 AUDIO_ERR_LOG("SetStreamMute: No system permission");
502 return ERR_PERMISSION_DENIED;
503 }
504
505 return SetStreamMuteInternal(streamType, mute, false);
506 }
507
SetStreamMuteInternal(AudioStreamType streamType,bool mute,bool isUpdateUi)508 int32_t AudioPolicyServer::SetStreamMuteInternal(AudioStreamType streamType, bool mute, bool isUpdateUi)
509 {
510 AUDIO_INFO_LOG("SetStreamMuteInternal streamType: %{public}d, mute: %{public}d, updateUi: %{public}d",
511 streamType, mute, isUpdateUi);
512
513 if (streamType == STREAM_ALL) {
514 for (auto audioStreamType : GET_STREAM_ALL_VOLUME_TYPES) {
515 AUDIO_INFO_LOG("SetMute of STREAM_ALL for StreamType = %{public}d ", audioStreamType);
516 int32_t setResult = SetSingleStreamMute(audioStreamType, mute, isUpdateUi);
517 if (setResult != SUCCESS) {
518 return setResult;
519 }
520 }
521 return SUCCESS;
522 }
523
524 return SetSingleStreamMute(streamType, mute, isUpdateUi);
525 }
526
SetSingleStreamMute(AudioStreamType streamType,bool mute,bool isUpdateUi)527 int32_t AudioPolicyServer::SetSingleStreamMute(AudioStreamType streamType, bool mute, bool isUpdateUi)
528 {
529 if (streamType == AudioStreamType::STREAM_RING && !isUpdateUi) {
530 if (!VerifyPermission(ACCESS_NOTIFICATION_POLICY_PERMISSION)) {
531 AUDIO_ERR_LOG("SetStreamMute permission denied for stream type : %{public}d", streamType);
532 return ERR_PERMISSION_DENIED;
533 }
534 }
535
536 int result = mPolicyService.SetStreamMute(streamType, mute);
537 for (auto it = volumeChangeCbsMap_.begin(); it != volumeChangeCbsMap_.end(); ++it) {
538 std::shared_ptr<VolumeKeyEventCallback> volumeChangeCb = it->second;
539 if (volumeChangeCb == nullptr) {
540 AUDIO_ERR_LOG("volumeChangeCb: nullptr for client : %{public}d", it->first);
541 continue;
542 }
543 AUDIO_DEBUG_LOG("SetStreamMute trigger volumeChangeCb clientPid : %{public}d", it->first);
544 VolumeEvent volumeEvent;
545 volumeEvent.volumeType = streamType;
546 volumeEvent.volume = GetSystemVolumeLevel(streamType);
547 volumeEvent.updateUi = isUpdateUi;
548 volumeEvent.volumeGroupId = 0;
549 volumeEvent.networkId = LOCAL_NETWORK_ID;
550 volumeChangeCb->OnVolumeKeyEvent(volumeEvent);
551 }
552
553 return result;
554 }
555
GetSystemVolumeDb(AudioStreamType streamType)556 float AudioPolicyServer::GetSystemVolumeDb(AudioStreamType streamType)
557 {
558 return mPolicyService.GetSystemVolumeDb(streamType);
559 }
560
SetSystemVolumeLevelInternal(AudioStreamType streamType,int32_t volumeLevel,bool isUpdateUi)561 int32_t AudioPolicyServer::SetSystemVolumeLevelInternal(AudioStreamType streamType, int32_t volumeLevel,
562 bool isUpdateUi)
563 {
564 AUDIO_INFO_LOG("SetSystemVolumeLevelInternal streamType: %{public}d, volumeLevel: %{public}d, updateUi: %{public}d",
565 streamType, volumeLevel, isUpdateUi);
566 if (IsVolumeUnadjustable()) {
567 AUDIO_ERR_LOG("Unadjustable device, not allow set volume");
568 return ERR_OPERATION_FAILED;
569 }
570 if (streamType == STREAM_ALL) {
571 for (auto audioSteamType : GET_STREAM_ALL_VOLUME_TYPES) {
572 AUDIO_INFO_LOG("SetVolume of STREAM_ALL, SteamType = %{public}d ", audioSteamType);
573 int32_t setResult = SetSingleStreamVolume(audioSteamType, volumeLevel, isUpdateUi);
574 if (setResult != SUCCESS) {
575 return setResult;
576 }
577 }
578 return SUCCESS;
579 }
580 return SetSingleStreamVolume(streamType, volumeLevel, isUpdateUi);
581 }
582
SetSingleStreamVolume(AudioStreamType streamType,int32_t volumeLevel,bool isUpdateUi)583 int32_t AudioPolicyServer::SetSingleStreamVolume(AudioStreamType streamType, int32_t volumeLevel, bool isUpdateUi)
584 {
585 if ((streamType == AudioStreamType::STREAM_RING) && !isUpdateUi) {
586 int32_t curRingVolumeLevel = GetSystemVolumeLevel(STREAM_RING);
587 if ((curRingVolumeLevel > 0 && volumeLevel == 0) || (curRingVolumeLevel == 0 && volumeLevel > 0)) {
588 if (!VerifyPermission(ACCESS_NOTIFICATION_POLICY_PERMISSION)) {
589 AUDIO_ERR_LOG("Access policy permission denied for volume type : %{public}d", streamType);
590 return ERR_PERMISSION_DENIED;
591 }
592 }
593 }
594
595 int ret = mPolicyService.SetSystemVolumeLevel(streamType, volumeLevel, isUpdateUi);
596 for (auto it = volumeChangeCbsMap_.begin(); it != volumeChangeCbsMap_.end(); ++it) {
597 std::shared_ptr<VolumeKeyEventCallback> volumeChangeCb = it->second;
598 if (volumeChangeCb == nullptr) {
599 AUDIO_ERR_LOG("volumeChangeCb: nullptr for client : %{public}d", it->first);
600 continue;
601 }
602
603 AUDIO_DEBUG_LOG("SetSystemVolumeLevelInternal trigger volumeChangeCb clientPid : %{public}d", it->first);
604 VolumeEvent volumeEvent;
605 volumeEvent.volumeType = streamType;
606 volumeEvent.volume = GetSystemVolumeLevel(streamType);
607 volumeEvent.updateUi = isUpdateUi;
608 volumeEvent.volumeGroupId = 0;
609 volumeEvent.networkId = LOCAL_NETWORK_ID;
610 volumeChangeCb->OnVolumeKeyEvent(volumeEvent);
611 }
612
613 return ret;
614 }
615
GetStreamMute(AudioStreamType streamType)616 bool AudioPolicyServer::GetStreamMute(AudioStreamType streamType)
617 {
618 if (streamType == AudioStreamType::STREAM_RING) {
619 if (!VerifyPermission(ACCESS_NOTIFICATION_POLICY_PERMISSION)) {
620 AUDIO_ERR_LOG("GetStreamMute permission denied for stream type : %{public}d", streamType);
621 return false;
622 }
623 }
624
625 return GetStreamMuteInternal(streamType);
626 }
627
GetStreamMuteInternal(AudioStreamType streamType)628 bool AudioPolicyServer::GetStreamMuteInternal(AudioStreamType streamType)
629 {
630 if (streamType == STREAM_ALL) {
631 streamType = STREAM_MUSIC;
632 AUDIO_INFO_LOG("GetStreamMute of STREAM_ALL for streamType = %{public}d ", streamType);
633 }
634 return mPolicyService.GetStreamMute(streamType);
635 }
636
SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors)637 int32_t AudioPolicyServer::SelectOutputDevice(sptr<AudioRendererFilter> audioRendererFilter,
638 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors)
639 {
640 if (!PermissionUtil::VerifySystemPermission()) {
641 AUDIO_ERR_LOG("SelectOutputDevice: No system permission");
642 return ERR_PERMISSION_DENIED;
643 }
644
645 int32_t ret = mPolicyService.SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
646 return ret;
647 }
648
GetSelectedDeviceInfo(int32_t uid,int32_t pid,AudioStreamType streamType)649 std::string AudioPolicyServer::GetSelectedDeviceInfo(int32_t uid, int32_t pid, AudioStreamType streamType)
650 {
651 return mPolicyService.GetSelectedDeviceInfo(uid, pid, streamType);
652 }
653
SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors)654 int32_t AudioPolicyServer::SelectInputDevice(sptr<AudioCapturerFilter> audioCapturerFilter,
655 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors)
656 {
657 if (!PermissionUtil::VerifySystemPermission()) {
658 AUDIO_ERR_LOG("SelectInputDevice: No system permission");
659 return ERR_PERMISSION_DENIED;
660 }
661 int32_t ret = mPolicyService.SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
662 return ret;
663 }
664
GetDevices(DeviceFlag deviceFlag)665 std::vector<sptr<AudioDeviceDescriptor>> AudioPolicyServer::GetDevices(DeviceFlag deviceFlag)
666 {
667 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
668 switch (deviceFlag) {
669 case NONE_DEVICES_FLAG:
670 case DISTRIBUTED_OUTPUT_DEVICES_FLAG:
671 case DISTRIBUTED_INPUT_DEVICES_FLAG:
672 case ALL_DISTRIBUTED_DEVICES_FLAG:
673 case ALL_L_D_DEVICES_FLAG:
674 if (!hasSystemPermission) {
675 AUDIO_ERR_LOG("GetDevices: No system permission");
676 std::vector<sptr<AudioDeviceDescriptor>> info = {};
677 return info;
678 }
679 break;
680 default:
681 break;
682 }
683
684 std::vector<sptr<AudioDeviceDescriptor>> deviceDescs = mPolicyService.GetDevices(deviceFlag);
685
686 if (!hasSystemPermission) {
687 for (sptr<AudioDeviceDescriptor> desc : deviceDescs) {
688 desc->networkId_ = "";
689 desc->interruptGroupId_ = GROUP_ID_NONE;
690 desc->volumeGroupId_ = GROUP_ID_NONE;
691 }
692 }
693
694 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
695 if (!hasBTPermission) {
696 mPolicyService.UpdateDescWhenNoBTPermission(deviceDescs);
697 }
698
699 return deviceDescs;
700 }
701
SetWakeUpAudioCapturer(InternalAudioCapturerOptions options)702 int32_t AudioPolicyServer::SetWakeUpAudioCapturer(InternalAudioCapturerOptions options)
703 {
704 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
705 if (!hasSystemPermission) {
706 AUDIO_ERR_LOG("SetWakeUpAudioCapturer: No system permission");
707 return ERR_PERMISSION_DENIED;
708 }
709
710 bool hasManageIntellgentPermission = VerifyPermission(MANAGE_INTELLIGENT_VOICE_PERMISSION);
711 if (!hasManageIntellgentPermission) {
712 AUDIO_ERR_LOG("SetWakeUpAudioCapturer: No permission");
713 return ERR_PERMISSION_DENIED;
714 }
715 return mPolicyService.SetWakeUpAudioCapturer(options);
716 }
717
CloseWakeUpAudioCapturer()718 int32_t AudioPolicyServer::CloseWakeUpAudioCapturer()
719 {
720 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
721 if (!hasSystemPermission) {
722 AUDIO_ERR_LOG("CloseWakeUpAudioCapturer: No system permission");
723 return ERR_PERMISSION_DENIED;
724 }
725
726 bool hasManageIntellgentPermission = VerifyPermission(MANAGE_INTELLIGENT_VOICE_PERMISSION);
727 if (!hasManageIntellgentPermission) {
728 AUDIO_ERR_LOG("CloseWakeUpAudioCapturer: No permission");
729 return ERR_PERMISSION_DENIED;
730 }
731 auto res = mPolicyService.CloseWakeUpAudioCapturer();
732 return res;
733 }
734
GetPreferredOutputDeviceDescriptors(AudioRendererInfo & rendererInfo)735 std::vector<sptr<AudioDeviceDescriptor>> AudioPolicyServer::GetPreferredOutputDeviceDescriptors(
736 AudioRendererInfo &rendererInfo)
737 {
738 std::vector<sptr<AudioDeviceDescriptor>> deviceDescs =
739 mPolicyService.GetPreferredOutputDeviceDescriptors(rendererInfo);
740 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
741 if (!hasBTPermission) {
742 mPolicyService.UpdateDescWhenNoBTPermission(deviceDescs);
743 }
744
745 return deviceDescs;
746 }
747
GetPreferredInputDeviceDescriptors(AudioCapturerInfo & captureInfo)748 std::vector<sptr<AudioDeviceDescriptor>> AudioPolicyServer::GetPreferredInputDeviceDescriptors(
749 AudioCapturerInfo &captureInfo)
750 {
751 std::vector<sptr<AudioDeviceDescriptor>> deviceDescs =
752 mPolicyService.GetPreferredInputDeviceDescriptors(captureInfo);
753 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
754 if (!hasBTPermission) {
755 mPolicyService.UpdateDescWhenNoBTPermission(deviceDescs);
756 }
757
758 return deviceDescs;
759 }
760
IsStreamActive(AudioStreamType streamType)761 bool AudioPolicyServer::IsStreamActive(AudioStreamType streamType)
762 {
763 return mPolicyService.IsStreamActive(streamType);
764 }
765
SetDeviceActive(InternalDeviceType deviceType,bool active)766 int32_t AudioPolicyServer::SetDeviceActive(InternalDeviceType deviceType, bool active)
767 {
768 return mPolicyService.SetDeviceActive(deviceType, active);
769 }
770
IsDeviceActive(InternalDeviceType deviceType)771 bool AudioPolicyServer::IsDeviceActive(InternalDeviceType deviceType)
772 {
773 return mPolicyService.IsDeviceActive(deviceType);
774 }
775
GetActiveOutputDevice()776 InternalDeviceType AudioPolicyServer::GetActiveOutputDevice()
777 {
778 return mPolicyService.GetActiveOutputDevice();
779 }
780
GetActiveInputDevice()781 InternalDeviceType AudioPolicyServer::GetActiveInputDevice()
782 {
783 return mPolicyService.GetActiveInputDevice();
784 }
785
SetRingerMode(AudioRingerMode ringMode,API_VERSION api_v)786 int32_t AudioPolicyServer::SetRingerMode(AudioRingerMode ringMode, API_VERSION api_v)
787 {
788 if (api_v == API_9 && !PermissionUtil::VerifySystemPermission()) {
789 AUDIO_ERR_LOG("SetRingerMode: No system permission");
790 return ERR_PERMISSION_DENIED;
791 }
792 bool isPermissionRequired = false;
793
794 if (ringMode == AudioRingerMode::RINGER_MODE_SILENT) {
795 isPermissionRequired = true;
796 } else {
797 AudioRingerMode currentRingerMode = GetRingerMode();
798 if (currentRingerMode == AudioRingerMode::RINGER_MODE_SILENT) {
799 isPermissionRequired = true;
800 }
801 }
802
803 if (isPermissionRequired) {
804 if (!VerifyPermission(ACCESS_NOTIFICATION_POLICY_PERMISSION)) {
805 AUDIO_ERR_LOG("Access policy permission denied for ringerMode : %{public}d", ringMode);
806 return ERR_PERMISSION_DENIED;
807 }
808 }
809
810 int32_t ret = mPolicyService.SetRingerMode(ringMode);
811
812 std::lock_guard<std::mutex> lock(ringerModeMutex_);
813 if (ret == SUCCESS) {
814 for (auto it = ringerModeCbsMap_.begin(); it != ringerModeCbsMap_.end(); ++it) {
815 std::shared_ptr<AudioRingerModeCallback> ringerModeListenerCb = it->second;
816 if (ringerModeListenerCb == nullptr) {
817 AUDIO_ERR_LOG("ringerModeListenerCb nullptr for client %{public}d", it->first);
818 continue;
819 }
820
821 AUDIO_DEBUG_LOG("ringerModeListenerCb client %{public}d", it->first);
822 ringerModeListenerCb->OnRingerModeUpdated(ringMode);
823 }
824 }
825
826 return ret;
827 }
828
829 #ifdef FEATURE_DTMF_TONE
GetToneConfig(int32_t ltonetype)830 std::shared_ptr<ToneInfo> AudioPolicyServer::GetToneConfig(int32_t ltonetype)
831 {
832 return mPolicyService.GetToneConfig(ltonetype);
833 }
834
GetSupportedTones()835 std::vector<int32_t> AudioPolicyServer::GetSupportedTones()
836 {
837 return mPolicyService.GetSupportedTones();
838 }
839 #endif
840
SetMicrophoneMuteCommon(bool isMute,API_VERSION api_v)841 int32_t AudioPolicyServer::SetMicrophoneMuteCommon(bool isMute, API_VERSION api_v)
842 {
843 AUDIO_INFO_LOG("Entered %{public}s", __func__);
844 std::lock_guard<std::mutex> lock(micStateChangeMutex_);
845 bool isMicrophoneMute = IsMicrophoneMute(api_v);
846 int32_t ret = mPolicyService.SetMicrophoneMute(isMute);
847 if (ret == SUCCESS && isMicrophoneMute != isMute) {
848 for (auto it = micStateChangeCbsMap_.begin(); it != micStateChangeCbsMap_.end(); ++it) {
849 std::shared_ptr<AudioManagerMicStateChangeCallback> micStateChangeListenerCb = it->second;
850 if (micStateChangeListenerCb == nullptr) {
851 AUDIO_ERR_LOG("callback is nullptr for client %{public}d", it->first);
852 continue;
853 }
854 MicStateChangeEvent micStateChangeEvent;
855 micStateChangeEvent.mute = isMute;
856 micStateChangeListenerCb->OnMicStateUpdated(micStateChangeEvent);
857 }
858 }
859 return ret;
860 }
861
SetMicrophoneMute(bool isMute)862 int32_t AudioPolicyServer::SetMicrophoneMute(bool isMute)
863 {
864 AUDIO_INFO_LOG("Entered %{public}s", __func__);
865 if (!VerifyPermission(MICROPHONE_PERMISSION)) {
866 AUDIO_ERR_LOG("SetMicrophoneMute: MICROPHONE permission denied");
867 return ERR_PERMISSION_DENIED;
868 }
869 return SetMicrophoneMuteCommon(isMute, API_7);
870 }
871
SetMicrophoneMuteAudioConfig(bool isMute)872 int32_t AudioPolicyServer::SetMicrophoneMuteAudioConfig(bool isMute)
873 {
874 AUDIO_INFO_LOG("Entered %{public}s", __func__);
875 if (!VerifyPermission(MANAGE_AUDIO_CONFIG)) {
876 AUDIO_ERR_LOG("SetMicrophoneMuteAudioConfig: MANAGE_AUDIO_CONFIG permission denied");
877 return ERR_PERMISSION_DENIED;
878 }
879 return SetMicrophoneMuteCommon(isMute, API_9);
880 }
881
IsMicrophoneMute(API_VERSION api_v)882 bool AudioPolicyServer::IsMicrophoneMute(API_VERSION api_v)
883 {
884 AUDIO_INFO_LOG("Entered %{public}s", __func__);
885 if (api_v == API_7 && !VerifyPermission(MICROPHONE_PERMISSION)) {
886 AUDIO_ERR_LOG("IsMicrophoneMute: MICROPHONE permission denied");
887 return ERR_PERMISSION_DENIED;
888 }
889
890 return mPolicyService.IsMicrophoneMute();
891 }
892
GetRingerMode()893 AudioRingerMode AudioPolicyServer::GetRingerMode()
894 {
895 return mPolicyService.GetRingerMode();
896 }
897
SetAudioScene(AudioScene audioScene)898 int32_t AudioPolicyServer::SetAudioScene(AudioScene audioScene)
899 {
900 if (!PermissionUtil::VerifySystemPermission()) {
901 AUDIO_ERR_LOG("SetAudioScene: No system permission");
902 return ERR_PERMISSION_DENIED;
903 }
904 return mPolicyService.SetAudioScene(audioScene);
905 }
906
GetAudioScene()907 AudioScene AudioPolicyServer::GetAudioScene()
908 {
909 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
910 return mPolicyService.GetAudioScene(hasSystemPermission);
911 }
912
SetRingerModeCallback(const int32_t,const sptr<IRemoteObject> & object,API_VERSION api_v)913 int32_t AudioPolicyServer::SetRingerModeCallback(const int32_t /* clientId */,
914 const sptr<IRemoteObject> &object, API_VERSION api_v)
915 {
916 std::lock_guard<std::mutex> lock(ringerModeMutex_);
917
918 if (api_v == API_8 && !PermissionUtil::VerifySystemPermission()) {
919 AUDIO_ERR_LOG("SetRingerModeCallback: No system permission");
920 return ERR_PERMISSION_DENIED;
921 }
922 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM, "SetRingerModeCallback object is nullptr");
923
924 sptr<IStandardRingerModeUpdateListener> listener = iface_cast<IStandardRingerModeUpdateListener>(object);
925 CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM, "SetRingerModeCallback object cast failed");
926
927 std::shared_ptr<AudioRingerModeCallback> callback = std::make_shared<AudioRingerModeListenerCallback>(listener);
928 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "SetRingerModeCallback failed to create cb obj");
929
930 int32_t clientPid = IPCSkeleton::GetCallingPid();
931 ringerModeCbsMap_[clientPid] = callback;
932
933 return SUCCESS;
934 }
935
UnsetRingerModeCallback(const int32_t)936 int32_t AudioPolicyServer::UnsetRingerModeCallback(const int32_t /* clientId */)
937 {
938 std::lock_guard<std::mutex> lock(ringerModeMutex_);
939
940 int32_t clientPid = IPCSkeleton::GetCallingPid();
941 if (ringerModeCbsMap_.erase(clientPid) == 0) {
942 AUDIO_ERR_LOG("UnsetRingerModeCallback Cb does not exist for client %{public}d", clientPid);
943 return ERR_INVALID_OPERATION;
944 }
945
946 return SUCCESS;
947 }
948
SetMicStateChangeCallback(const int32_t,const sptr<IRemoteObject> & object)949 int32_t AudioPolicyServer::SetMicStateChangeCallback(const int32_t /* clientId */, const sptr<IRemoteObject> &object)
950 {
951 std::lock_guard<std::mutex> lock(micStateChangeMutex_);
952
953 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM,
954 "SetMicStateChangeCallback set listener object is nullptr");
955
956 sptr<IStandardAudioRoutingManagerListener> listener = iface_cast<IStandardAudioRoutingManagerListener>(object);
957 CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM,
958 "SetMicStateChangeCallback listener obj cast failed");
959
960 std::shared_ptr<AudioManagerMicStateChangeCallback> callback =
961 std::make_shared<AudioRoutingManagerListenerCallback>(listener);
962 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
963 "SetMicStateChangeCallback failed to create cb obj");
964
965 int32_t clientPid = IPCSkeleton::GetCallingPid();
966 micStateChangeCbsMap_[clientPid] = callback;
967
968 return SUCCESS;
969 }
970
SetDeviceChangeCallback(const int32_t,const DeviceFlag flag,const sptr<IRemoteObject> & object)971 int32_t AudioPolicyServer::SetDeviceChangeCallback(const int32_t /* clientId */, const DeviceFlag flag,
972 const sptr<IRemoteObject> &object)
973 {
974 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM,
975 "SetDeviceChangeCallback set listener object is nullptr");
976 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
977 switch (flag) {
978 case NONE_DEVICES_FLAG:
979 case DISTRIBUTED_OUTPUT_DEVICES_FLAG:
980 case DISTRIBUTED_INPUT_DEVICES_FLAG:
981 case ALL_DISTRIBUTED_DEVICES_FLAG:
982 case ALL_L_D_DEVICES_FLAG:
983 if (!hasSystemPermission) {
984 AUDIO_ERR_LOG("SetDeviceChangeCallback: No system permission");
985 return ERR_PERMISSION_DENIED;
986 }
987 break;
988 default:
989 break;
990 }
991
992 int32_t clientPid = IPCSkeleton::GetCallingPid();
993 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
994 return mPolicyService.SetDeviceChangeCallback(clientPid, flag, object, hasBTPermission);
995 }
996
UnsetDeviceChangeCallback(const int32_t,DeviceFlag flag)997 int32_t AudioPolicyServer::UnsetDeviceChangeCallback(const int32_t /* clientId */, DeviceFlag flag)
998 {
999 int32_t clientPid = IPCSkeleton::GetCallingPid();
1000 return mPolicyService.UnsetDeviceChangeCallback(clientPid, flag);
1001 }
1002
SetPreferredOutputDeviceChangeCallback(const int32_t,const sptr<IRemoteObject> & object)1003 int32_t AudioPolicyServer::SetPreferredOutputDeviceChangeCallback(const int32_t /* clientId */,
1004 const sptr<IRemoteObject> &object)
1005 {
1006 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM, "object is nullptr");
1007 int32_t clientPid = IPCSkeleton::GetCallingPid();
1008 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
1009 return mPolicyService.SetPreferredOutputDeviceChangeCallback(clientPid, object, hasBTPermission);
1010 }
1011
SetPreferredInputDeviceChangeCallback(const sptr<IRemoteObject> & object)1012 int32_t AudioPolicyServer::SetPreferredInputDeviceChangeCallback(const sptr<IRemoteObject> &object)
1013 {
1014 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM, "object is nullptr");
1015 int32_t clientPid = IPCSkeleton::GetCallingPid();
1016 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
1017 return mPolicyService.SetPreferredInputDeviceChangeCallback(clientPid, object, hasBTPermission);
1018 }
1019
UnsetPreferredOutputDeviceChangeCallback(const int32_t)1020 int32_t AudioPolicyServer::UnsetPreferredOutputDeviceChangeCallback(const int32_t /* clientId */)
1021 {
1022 int32_t clientPid = IPCSkeleton::GetCallingPid();
1023 return mPolicyService.UnsetPreferredOutputDeviceChangeCallback(clientPid);
1024 }
1025
UnsetPreferredInputDeviceChangeCallback()1026 int32_t AudioPolicyServer::UnsetPreferredInputDeviceChangeCallback()
1027 {
1028 int32_t clientPid = IPCSkeleton::GetCallingPid();
1029 return mPolicyService.UnsetPreferredInputDeviceChangeCallback(clientPid);
1030 }
1031
SetAudioInterruptCallback(const uint32_t sessionID,const sptr<IRemoteObject> & object)1032 int32_t AudioPolicyServer::SetAudioInterruptCallback(const uint32_t sessionID, const sptr<IRemoteObject> &object)
1033 {
1034 std::lock_guard<std::mutex> lock(interruptMutex_);
1035
1036 auto callerUid = IPCSkeleton::GetCallingUid();
1037 if (!mPolicyService.IsSessionIdValid(callerUid, sessionID)) {
1038 AUDIO_ERR_LOG("SetAudioInterruptCallback for sessionID %{public}d, id is invalid", sessionID);
1039 return ERR_INVALID_PARAM;
1040 }
1041
1042 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM, "SetAudioInterruptCallback object is nullptr");
1043
1044 sptr<IStandardAudioPolicyManagerListener> listener = iface_cast<IStandardAudioPolicyManagerListener>(object);
1045 CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM, "SetAudioInterruptCallback obj cast failed");
1046
1047 std::shared_ptr<AudioInterruptCallback> callback = std::make_shared<AudioPolicyManagerListenerCallback>(listener);
1048 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM, "SetAudioInterruptCallback create cb failed");
1049
1050 interruptCbsMap_[sessionID] = callback;
1051 AUDIO_DEBUG_LOG("SetAudioInterruptCallback for sessionID %{public}d done", sessionID);
1052
1053 return SUCCESS;
1054 }
1055
UnsetAudioInterruptCallback(const uint32_t sessionID)1056 int32_t AudioPolicyServer::UnsetAudioInterruptCallback(const uint32_t sessionID)
1057 {
1058 std::lock_guard<std::mutex> lock(interruptMutex_);
1059
1060 if (interruptCbsMap_.erase(sessionID) == 0) {
1061 AUDIO_ERR_LOG("UnsetAudioInterruptCallback session %{public}d not present", sessionID);
1062 return ERR_INVALID_OPERATION;
1063 }
1064
1065 return SUCCESS;
1066 }
1067
SetAudioManagerInterruptCallback(const int32_t,const sptr<IRemoteObject> & object)1068 int32_t AudioPolicyServer::SetAudioManagerInterruptCallback(const int32_t /* clientId */,
1069 const sptr<IRemoteObject> &object)
1070 {
1071 std::lock_guard<std::mutex> lock(amInterruptMutex_);
1072
1073 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM,
1074 "SetAudioManagerInterruptCallback object is nullptr");
1075
1076 sptr<IStandardAudioPolicyManagerListener> listener = iface_cast<IStandardAudioPolicyManagerListener>(object);
1077 CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM,
1078 "SetAudioManagerInterruptCallback obj cast failed");
1079
1080 std::shared_ptr<AudioInterruptCallback> callback = std::make_shared<AudioPolicyManagerListenerCallback>(listener);
1081 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
1082 "SetAudioManagerInterruptCallback create cb failed");
1083
1084 int32_t clientPid = IPCSkeleton::GetCallingPid();
1085 amInterruptCbsMap_[clientPid] = callback;
1086 AUDIO_INFO_LOG("SetAudioManagerInterruptCallback for client id %{public}d done", clientPid);
1087
1088 return SUCCESS;
1089 }
1090
UnsetAudioManagerInterruptCallback(const int32_t)1091 int32_t AudioPolicyServer::UnsetAudioManagerInterruptCallback(const int32_t /* clientId */)
1092 {
1093 std::lock_guard<std::mutex> lock(amInterruptMutex_);
1094 int32_t clientPid = IPCSkeleton::GetCallingPid();
1095 if (amInterruptCbsMap_.erase(clientPid) == 0) {
1096 AUDIO_ERR_LOG("UnsetAudioManagerInterruptCallback client %{public}d not present", clientPid);
1097 return ERR_INVALID_OPERATION;
1098 }
1099
1100 return SUCCESS;
1101 }
1102
RequestAudioFocus(const int32_t clientId,const AudioInterrupt & audioInterrupt)1103 int32_t AudioPolicyServer::RequestAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt)
1104 {
1105 AUDIO_INFO_LOG("RequestAudioFocus in");
1106 std::lock_guard<std::recursive_mutex> lock(focussedAudioInterruptInfoMutex_);
1107 if (clientOnFocus_ == clientId) {
1108 AUDIO_INFO_LOG("client already has focus");
1109 NotifyFocusGranted(clientId, audioInterrupt);
1110 return SUCCESS;
1111 }
1112
1113 if (focussedAudioInterruptInfo_ != nullptr) {
1114 AUDIO_INFO_LOG("Existing stream: %{public}d, incoming stream: %{public}d",
1115 (focussedAudioInterruptInfo_->audioFocusType).streamType, audioInterrupt.audioFocusType.streamType);
1116 NotifyFocusAbandoned(clientOnFocus_, *focussedAudioInterruptInfo_);
1117 AbandonAudioFocus(clientOnFocus_, *focussedAudioInterruptInfo_);
1118 }
1119
1120 NotifyFocusGranted(clientId, audioInterrupt);
1121
1122 return SUCCESS;
1123 }
1124
AbandonAudioFocus(const int32_t clientId,const AudioInterrupt & audioInterrupt)1125 int32_t AudioPolicyServer::AbandonAudioFocus(const int32_t clientId, const AudioInterrupt &audioInterrupt)
1126 {
1127 AUDIO_INFO_LOG("AudioPolicyServer: AbandonAudioFocus in");
1128
1129 std::lock_guard<std::recursive_mutex> lock(focussedAudioInterruptInfoMutex_);
1130 if (clientId == clientOnFocus_) {
1131 AUDIO_DEBUG_LOG("AudioPolicyServer: remove app focus");
1132 focussedAudioInterruptInfo_.reset();
1133 focussedAudioInterruptInfo_ = nullptr;
1134 clientOnFocus_ = 0;
1135 }
1136
1137 return SUCCESS;
1138 }
1139
NotifyFocusGranted(const int32_t clientId,const AudioInterrupt & audioInterrupt)1140 void AudioPolicyServer::NotifyFocusGranted(const int32_t clientId, const AudioInterrupt &audioInterrupt)
1141 {
1142 AUDIO_INFO_LOG("Notify focus granted in: %{public}d", clientId);
1143 if (amInterruptCbsMap_.find(clientId) == amInterruptCbsMap_.end()) {
1144 AUDIO_ERR_LOG("Notify focus granted in: %{public}d failed, callback does not exist", clientId);
1145 return;
1146 }
1147 std::shared_ptr<AudioInterruptCallback> interruptCb = amInterruptCbsMap_[clientId];
1148 if (interruptCb == nullptr) {
1149 AUDIO_ERR_LOG("Notify focus granted in: %{public}d failed, callback is nullptr", clientId);
1150 return;
1151 } else {
1152 InterruptEventInternal interruptEvent = {};
1153 interruptEvent.eventType = INTERRUPT_TYPE_END;
1154 interruptEvent.forceType = INTERRUPT_SHARE;
1155 interruptEvent.hintType = INTERRUPT_HINT_NONE;
1156 interruptEvent.duckVolume = 0;
1157
1158 AUDIO_DEBUG_LOG("callback focus granted");
1159 interruptCb->OnInterrupt(interruptEvent);
1160
1161 unique_ptr<AudioInterrupt> tempAudioInterruptInfo = make_unique<AudioInterrupt>();
1162 tempAudioInterruptInfo->streamUsage = audioInterrupt.streamUsage;
1163 tempAudioInterruptInfo->contentType = audioInterrupt.contentType;
1164 (tempAudioInterruptInfo->audioFocusType).streamType = audioInterrupt.audioFocusType.streamType;
1165 tempAudioInterruptInfo->pauseWhenDucked = audioInterrupt.pauseWhenDucked;
1166 focussedAudioInterruptInfo_ = move(tempAudioInterruptInfo);
1167 clientOnFocus_ = clientId;
1168 }
1169 }
1170
NotifyFocusAbandoned(const int32_t clientId,const AudioInterrupt & audioInterrupt)1171 int32_t AudioPolicyServer::NotifyFocusAbandoned(const int32_t clientId, const AudioInterrupt &audioInterrupt)
1172 {
1173 AUDIO_INFO_LOG("Notify focus abandoned in: %{public}d", clientId);
1174 std::shared_ptr<AudioInterruptCallback> interruptCb = nullptr;
1175 interruptCb = amInterruptCbsMap_[clientId];
1176 if (!interruptCb) {
1177 AUDIO_ERR_LOG("Notify failed, callback not present");
1178 return ERR_INVALID_PARAM;
1179 }
1180
1181 InterruptEventInternal interruptEvent = {};
1182 interruptEvent.eventType = INTERRUPT_TYPE_BEGIN;
1183 interruptEvent.forceType = INTERRUPT_SHARE;
1184 interruptEvent.hintType = INTERRUPT_HINT_STOP;
1185 interruptEvent.duckVolume = 0;
1186 AUDIO_DEBUG_LOG("callback focus abandoned");
1187 interruptCb->OnInterrupt(interruptEvent);
1188
1189 return SUCCESS;
1190 }
1191
IsSameAppInShareMode(const AudioInterrupt incomingInterrupt,const AudioInterrupt activateInterrupt)1192 bool AudioPolicyServer::IsSameAppInShareMode(const AudioInterrupt incomingInterrupt,
1193 const AudioInterrupt activateInterrupt)
1194 {
1195 if (incomingInterrupt.mode != SHARE_MODE || activateInterrupt.mode != SHARE_MODE) {
1196 return false;
1197 }
1198 if (incomingInterrupt.pid == DEFAULT_APP_PID || activateInterrupt.pid == DEFAULT_APP_PID) {
1199 return false;
1200 }
1201 return incomingInterrupt.pid == activateInterrupt.pid;
1202 }
1203
ProcessCurrentInterrupt(const AudioInterrupt & incomingInterrupt)1204 void AudioPolicyServer::ProcessCurrentInterrupt(const AudioInterrupt &incomingInterrupt)
1205 {
1206 auto focusMap = mPolicyService.GetAudioFocusMap();
1207 AudioFocusType incomingFocusType = incomingInterrupt.audioFocusType;
1208 for (auto iterActive = audioFocusInfoList_.begin(); iterActive != audioFocusInfoList_.end();) {
1209 if (IsSameAppInShareMode(incomingInterrupt, iterActive->first)) {
1210 ++iterActive;
1211 continue;
1212 }
1213 bool iterActiveErased = false;
1214 AudioFocusType activeFocusType = (iterActive->first).audioFocusType;
1215 std::pair<AudioFocusType, AudioFocusType> audioFocusTypePair =
1216 std::make_pair(activeFocusType, incomingFocusType);
1217 AudioFocusEntry focusEntry = focusMap[audioFocusTypePair];
1218 if (iterActive->second == PAUSE || focusEntry.actionOn != CURRENT) {
1219 ++iterActive;
1220 continue;
1221 }
1222 InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, focusEntry.forceType, focusEntry.hintType, 1.0f};
1223 uint32_t activeSessionID = (iterActive->first).sessionID;
1224 std::shared_ptr<AudioInterruptCallback> policyListenerCb = interruptCbsMap_[activeSessionID];
1225
1226 float volumeDb = 0.0f;
1227 switch (focusEntry.hintType) {
1228 case INTERRUPT_HINT_STOP:
1229 iterActive = audioFocusInfoList_.erase(iterActive);
1230 iterActiveErased = true;
1231 OnAudioFocusInfoChange();
1232 break;
1233 case INTERRUPT_HINT_PAUSE:
1234 iterActive->second = PAUSE;
1235 break;
1236 case INTERRUPT_HINT_DUCK:
1237 iterActive->second = DUCK;
1238 volumeDb = GetSystemVolumeDb(activeFocusType.streamType);
1239 interruptEvent.duckVolume = DUCK_FACTOR * volumeDb;
1240 break;
1241 default:
1242 break;
1243 }
1244 if (policyListenerCb != nullptr && interruptEvent.hintType != INTERRUPT_HINT_NONE) {
1245 AUDIO_INFO_LOG("OnInterrupt for processing sessionID: %{public}d, hintType: %{public}d",
1246 activeSessionID, interruptEvent.hintType);
1247 policyListenerCb->OnInterrupt(interruptEvent);
1248 if (!iterActiveErased) {
1249 OnAudioFocusInfoChange();
1250 }
1251 }
1252 if (!iterActiveErased) {
1253 ++iterActive;
1254 }
1255 }
1256 }
1257
ProcessFocusEntry(const AudioInterrupt & incomingInterrupt)1258 int32_t AudioPolicyServer::ProcessFocusEntry(const AudioInterrupt &incomingInterrupt)
1259 {
1260 auto focusMap = mPolicyService.GetAudioFocusMap();
1261 AudioFocuState incomingState = ACTIVE;
1262 AudioFocusType incomingFocusType = incomingInterrupt.audioFocusType;
1263 std::shared_ptr<AudioInterruptCallback> policyListenerCb = interruptCbsMap_[incomingInterrupt.sessionID];
1264 InterruptEventInternal interruptEvent {INTERRUPT_TYPE_BEGIN, INTERRUPT_FORCE, INTERRUPT_HINT_NONE, 1.0f};
1265 for (auto iterActive = audioFocusInfoList_.begin(); iterActive != audioFocusInfoList_.end(); ++iterActive) {
1266 if (IsSameAppInShareMode(incomingInterrupt, iterActive->first)) {
1267 continue;
1268 }
1269 std::pair<AudioFocusType, AudioFocusType> audioFocusTypePair =
1270 std::make_pair((iterActive->first).audioFocusType, incomingFocusType);
1271
1272 CHECK_AND_RETURN_RET_LOG(focusMap.find(audioFocusTypePair) != focusMap.end(), ERR_INVALID_PARAM,
1273 "ProcessFocusEntry: audio focus type pair is invalid");
1274 AudioFocusEntry focusEntry = focusMap[audioFocusTypePair];
1275 if (iterActive->second == PAUSE || focusEntry.actionOn == CURRENT) {
1276 continue;
1277 }
1278 if (focusEntry.isReject) {
1279 incomingState = STOP;
1280 break;
1281 }
1282 AudioFocuState newState = ACTIVE;
1283 auto pos = HINTSTATEMAP.find(focusEntry.hintType);
1284 if (pos != HINTSTATEMAP.end()) {
1285 newState = pos->second;
1286 }
1287 incomingState = newState > incomingState ? newState : incomingState;
1288 }
1289 if (incomingState == STOP) {
1290 interruptEvent.hintType = INTERRUPT_HINT_STOP;
1291 } else if (incomingState == PAUSE) {
1292 interruptEvent.hintType = INTERRUPT_HINT_PAUSE;
1293 } else if (incomingState == DUCK) {
1294 interruptEvent.hintType = INTERRUPT_HINT_DUCK;
1295 interruptEvent.duckVolume = DUCK_FACTOR * GetSystemVolumeDb(incomingFocusType.streamType);
1296 } else {
1297 ProcessCurrentInterrupt(incomingInterrupt);
1298 }
1299 if (incomingState != STOP) {
1300 audioFocusInfoList_.emplace_back(std::make_pair(incomingInterrupt, incomingState));
1301 OnAudioFocusInfoChange();
1302 }
1303 if (policyListenerCb != nullptr && interruptEvent.hintType != INTERRUPT_HINT_NONE) {
1304 AUDIO_INFO_LOG("OnInterrupt for incoming sessionID: %{public}d, hintType: %{public}d",
1305 incomingInterrupt.sessionID, interruptEvent.hintType);
1306 policyListenerCb->OnInterrupt(interruptEvent);
1307 }
1308 return incomingState >= PAUSE ? ERR_FOCUS_DENIED : SUCCESS;
1309 }
1310
ActivateAudioInterrupt(const AudioInterrupt & audioInterrupt)1311 int32_t AudioPolicyServer::ActivateAudioInterrupt(const AudioInterrupt &audioInterrupt)
1312 {
1313 std::lock_guard<std::mutex> lock(interruptMutex_);
1314
1315 AudioStreamType streamType = audioInterrupt.audioFocusType.streamType;
1316 AUDIO_INFO_LOG("ActivateAudioInterrupt::sessionID: %{public}u, streamType: %{public}d, streamUsage: %{public}d, "\
1317 "sourceType: %{public}d, pid: %{public}d", audioInterrupt.sessionID, streamType, audioInterrupt.streamUsage,
1318 (audioInterrupt.audioFocusType).sourceType, audioInterrupt.pid);
1319
1320 if (audioInterrupt.parallelPlayFlag) {
1321 AUDIO_INFO_LOG("ActivateAudioInterrupt::parallelPlayFlag is true.");
1322 return SUCCESS;
1323 }
1324
1325 if (!mPolicyService.IsAudioInterruptEnabled()) {
1326 AUDIO_WARNING_LOG("AudioInterrupt is not enabled. No need to ActivateAudioInterrupt");
1327 audioFocusInfoList_.emplace_back(std::make_pair(audioInterrupt, ACTIVE));
1328 if (streamType == STREAM_VOICE_CALL || streamType == STREAM_RING) {
1329 UpdateAudioScene(audioInterrupt, ACTIVATE_AUDIO_INTERRUPT);
1330 }
1331 return SUCCESS;
1332 }
1333
1334 uint32_t incomingSessionID = audioInterrupt.sessionID;
1335 if (!audioFocusInfoList_.empty()) {
1336 // If the session is present in audioFocusInfoList_, remove and treat it as a new request
1337 AUDIO_DEBUG_LOG("audioFocusInfoList_ is not empty, check whether the session is present");
1338 audioFocusInfoList_.remove_if([&incomingSessionID](std::pair<AudioInterrupt, AudioFocuState> &audioFocus) {
1339 return (audioFocus.first).sessionID == incomingSessionID;
1340 });
1341 }
1342 if (audioFocusInfoList_.empty()) {
1343 // If audioFocusInfoList_ is empty, directly activate interrupt
1344 AUDIO_INFO_LOG("audioFocusInfoList_ is empty, add the session into it directly");
1345 audioFocusInfoList_.emplace_back(std::make_pair(audioInterrupt, ACTIVE));
1346 OnAudioFocusInfoChange();
1347 if (streamType == STREAM_VOICE_CALL || streamType == STREAM_RING) {
1348 UpdateAudioScene(audioInterrupt, ACTIVATE_AUDIO_INTERRUPT);
1349 }
1350 return SUCCESS;
1351 }
1352
1353 // Process ProcessFocusEntryTable for current audioFocusInfoList_
1354 int32_t ret = ProcessFocusEntry(audioInterrupt);
1355 if (ret) {
1356 AUDIO_ERR_LOG("ActivateAudioInterrupt request rejected");
1357 return ERR_FOCUS_DENIED;
1358 }
1359 if (streamType == STREAM_VOICE_CALL || streamType == STREAM_RING) {
1360 UpdateAudioScene(audioInterrupt, ACTIVATE_AUDIO_INTERRUPT);
1361 }
1362 return SUCCESS;
1363 }
1364
UpdateAudioScene(const AudioInterrupt & audioInterrupt,AudioInterruptChangeType changeType)1365 void AudioPolicyServer::UpdateAudioScene(const AudioInterrupt &audioInterrupt, AudioInterruptChangeType changeType)
1366 {
1367 AudioScene currentAudioScene = GetAudioScene();
1368 AudioStreamType streamType = audioInterrupt.audioFocusType.streamType;
1369 AUDIO_INFO_LOG("UpdateAudioScene::changeType: %{public}d, currentAudioScene: %{public}d, streamType: %{public}d",
1370 changeType, currentAudioScene, streamType);
1371 switch (changeType) {
1372 case ACTIVATE_AUDIO_INTERRUPT:
1373 if (streamType == STREAM_RING && currentAudioScene == AUDIO_SCENE_DEFAULT) {
1374 AUDIO_INFO_LOG("UpdateAudioScene::Ringtone is starting. Change audio scene to RINGING");
1375 SetAudioScene(AUDIO_SCENE_RINGING);
1376 break;
1377 }
1378 if (streamType == STREAM_VOICE_CALL) {
1379 if (audioInterrupt.streamUsage == STREAM_USAGE_VOICE_MODEM_COMMUNICATION
1380 && currentAudioScene != AUDIO_SCENE_PHONE_CALL) {
1381 AUDIO_INFO_LOG("UpdateAudioScene::Phone_call is starting. Change audio scene to PHONE_CALL");
1382 SetAudioScene(AUDIO_SCENE_PHONE_CALL);
1383 break;
1384 }
1385 if (currentAudioScene != AUDIO_SCENE_PHONE_CHAT) {
1386 AUDIO_INFO_LOG("UpdateAudioScene::VOIP is starting. Change audio scene to PHONE_CHAT");
1387 SetAudioScene(AUDIO_SCENE_PHONE_CHAT);
1388 break;
1389 }
1390 }
1391 break;
1392 case DEACTIVATE_AUDIO_INTERRUPT:
1393 if (streamType == STREAM_RING && currentAudioScene == AUDIO_SCENE_RINGING) {
1394 AUDIO_INFO_LOG("UpdateAudioScene::Ringtone is stopping. Change audio scene to DEFAULT");
1395 SetAudioScene(AUDIO_SCENE_DEFAULT);
1396 break;
1397 }
1398 if (streamType == STREAM_VOICE_CALL && (currentAudioScene == AUDIO_SCENE_PHONE_CALL
1399 || currentAudioScene == AUDIO_SCENE_PHONE_CHAT)) {
1400 AUDIO_INFO_LOG("UpdateAudioScene::Voice_call is stopping. Change audio scene to DEFAULT");
1401 SetAudioScene(AUDIO_SCENE_DEFAULT);
1402 break;
1403 }
1404 break;
1405 default:
1406 AUDIO_INFO_LOG("UpdateAudioScene::The audio scene did not change");
1407 break;
1408 }
1409 }
1410
SimulateFocusEntry()1411 std::list<std::pair<AudioInterrupt, AudioFocuState>> AudioPolicyServer::SimulateFocusEntry()
1412 {
1413 std::list<std::pair<AudioInterrupt, AudioFocuState>> newAudioFocuInfoList;
1414 auto focusMap = mPolicyService.GetAudioFocusMap();
1415 for (auto iterActive = audioFocusInfoList_.begin(); iterActive != audioFocusInfoList_.end(); ++iterActive) {
1416 AudioInterrupt incoming = iterActive->first;
1417 AudioFocuState incomingState = ACTIVE;
1418 std::list<std::pair<AudioInterrupt, AudioFocuState>> tmpAudioFocuInfoList = newAudioFocuInfoList;
1419 for (auto iter = newAudioFocuInfoList.begin(); iter != newAudioFocuInfoList.end(); ++iter) {
1420 AudioInterrupt inprocessing = iter->first;
1421 if (iter->second == PAUSE || IsSameAppInShareMode(incoming, inprocessing)) {
1422 continue;
1423 }
1424 AudioFocusType activeFocusType = inprocessing.audioFocusType;
1425 AudioFocusType incomingFocusType = incoming.audioFocusType;
1426 std::pair<AudioFocusType, AudioFocusType> audioFocusTypePair =
1427 std::make_pair(activeFocusType, incomingFocusType);
1428 if (focusMap.find(audioFocusTypePair) == focusMap.end()) {
1429 AUDIO_WARNING_LOG("AudioPolicyServer: SimulateFocusEntry Audio Focus type is invalid");
1430 incomingState = iterActive->second;
1431 break;
1432 }
1433 AudioFocusEntry focusEntry = focusMap[audioFocusTypePair];
1434 auto pos = HINTSTATEMAP.find(focusEntry.hintType);
1435 if (pos == HINTSTATEMAP.end()) {
1436 continue;
1437 }
1438 if (focusEntry.actionOn == CURRENT) {
1439 iter->second = pos->second;
1440 } else {
1441 AudioFocuState newState = pos->second;
1442 incomingState = newState > incomingState ? newState : incomingState;
1443 }
1444 }
1445
1446 if (incomingState == PAUSE) {
1447 newAudioFocuInfoList = tmpAudioFocuInfoList;
1448 }
1449 newAudioFocuInfoList.emplace_back(std::make_pair(incoming, incomingState));
1450 }
1451
1452 return newAudioFocuInfoList;
1453 }
1454
NotifyStateChangedEvent(AudioFocuState oldState,AudioFocuState newState,std::list<std::pair<AudioInterrupt,AudioFocuState>>::iterator & iterActive)1455 void AudioPolicyServer::NotifyStateChangedEvent(AudioFocuState oldState, AudioFocuState newState,
1456 std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator &iterActive)
1457 {
1458 AudioInterrupt audioInterrupt = iterActive->first;
1459 uint32_t sessionID = audioInterrupt.sessionID;
1460 std::shared_ptr<AudioInterruptCallback> policyListenerCb = interruptCbsMap_[sessionID];
1461 if (policyListenerCb == nullptr) {
1462 AUDIO_WARNING_LOG("AudioPolicyServer: sessionID policyListenerCb is null");
1463 return;
1464 }
1465 InterruptEventInternal forceActive {INTERRUPT_TYPE_END, INTERRUPT_FORCE, INTERRUPT_HINT_RESUME, 1.0f};
1466 InterruptEventInternal forceUnduck {INTERRUPT_TYPE_END, INTERRUPT_FORCE, INTERRUPT_HINT_UNDUCK, 1.0f};
1467 InterruptEventInternal forceDuck {INTERRUPT_TYPE_END, INTERRUPT_FORCE, INTERRUPT_HINT_DUCK, 1.0f};
1468 InterruptEventInternal forcePause {INTERRUPT_TYPE_END, INTERRUPT_FORCE, INTERRUPT_HINT_PAUSE, 1.0f};
1469 float volumeDb = GetSystemVolumeDb((audioInterrupt.audioFocusType).streamType);
1470 forceDuck.duckVolume = DUCK_FACTOR * volumeDb;
1471 switch (newState) {
1472 case ACTIVE:
1473 if (oldState == PAUSE) {
1474 policyListenerCb->OnInterrupt(forceActive);
1475 }
1476 if (oldState == DUCK) {
1477 policyListenerCb->OnInterrupt(forceUnduck);
1478 }
1479 break;
1480 case DUCK:
1481 if (oldState == PAUSE) {
1482 policyListenerCb->OnInterrupt(forceActive);
1483 }
1484 policyListenerCb->OnInterrupt(forceDuck);
1485 break;
1486 case PAUSE:
1487 if (oldState == DUCK) {
1488 policyListenerCb->OnInterrupt(forceUnduck);
1489 }
1490 policyListenerCb->OnInterrupt(forcePause);
1491 break;
1492 default:
1493 break;
1494 }
1495 iterActive->second = newState;
1496 }
1497
ResumeAudioFocusList()1498 void AudioPolicyServer::ResumeAudioFocusList()
1499 {
1500 std::list<std::pair<AudioInterrupt, AudioFocuState>> newAudioFocuInfoList = SimulateFocusEntry();
1501 for (auto iterActive = audioFocusInfoList_.begin(), iterNew = newAudioFocuInfoList.begin(); iterActive !=
1502 audioFocusInfoList_.end() && iterNew != newAudioFocuInfoList.end(); ++iterActive, ++iterNew) {
1503 AudioFocuState oldState = iterActive->second;
1504 AudioFocuState newState = iterNew->second;
1505 if (oldState != newState) {
1506 AUDIO_INFO_LOG("ResumeAudioFocusList: State change: sessionID %{public}d, oldstate %{public}d, "\
1507 "newState %{public}d", (iterActive->first).sessionID, oldState, newState);
1508 NotifyStateChangedEvent(oldState, newState, iterActive);
1509 }
1510 }
1511 }
1512
DeactivateAudioInterrupt(const AudioInterrupt & audioInterrupt)1513 int32_t AudioPolicyServer::DeactivateAudioInterrupt(const AudioInterrupt &audioInterrupt)
1514 {
1515 std::lock_guard<std::mutex> lock(interruptMutex_);
1516
1517 AudioStreamType streamType = audioInterrupt.audioFocusType.streamType;
1518 if (!mPolicyService.IsAudioInterruptEnabled()) {
1519 AUDIO_WARNING_LOG("AudioInterrupt is not enabled. No need to DeactivateAudioInterrupt");
1520 uint32_t exitSessionID = audioInterrupt.sessionID;
1521 audioFocusInfoList_.remove_if([&](std::pair<AudioInterrupt, AudioFocuState> &audioFocusInfo) {
1522 if ((audioFocusInfo.first).sessionID != exitSessionID) {
1523 return false;
1524 }
1525 OnAudioFocusInfoChange();
1526 return true;
1527 });
1528 if (streamType == STREAM_VOICE_CALL || streamType == STREAM_RING) {
1529 UpdateAudioScene(audioInterrupt, DEACTIVATE_AUDIO_INTERRUPT);
1530 }
1531 return SUCCESS;
1532 }
1533
1534 AUDIO_INFO_LOG("DeactivateAudioInterrupt::sessionID: %{public}u, streamType: %{public}d, streamUsage: %{public}d, "\
1535 "sourceType: %{public}d, pid: %{public}d", audioInterrupt.sessionID, (audioInterrupt.audioFocusType).streamType,
1536 audioInterrupt.streamUsage, (audioInterrupt.audioFocusType).sourceType, audioInterrupt.pid);
1537
1538 if (audioInterrupt.parallelPlayFlag) {
1539 AUDIO_INFO_LOG("DeactivateAudioInterrupt::parallelPlayFlag is true.");
1540 return SUCCESS;
1541 }
1542
1543 bool isInterruptActive = false;
1544 for (auto it = audioFocusInfoList_.begin(); it != audioFocusInfoList_.end();) {
1545 if ((it->first).sessionID == audioInterrupt.sessionID) {
1546 it = audioFocusInfoList_.erase(it);
1547 isInterruptActive = true;
1548 OnAudioFocusInfoChange();
1549 if (streamType == STREAM_VOICE_CALL || streamType == STREAM_RING) {
1550 UpdateAudioScene(audioInterrupt, DEACTIVATE_AUDIO_INTERRUPT);
1551 }
1552 } else {
1553 ++it;
1554 }
1555 }
1556
1557 // If it was not in the audioFocusInfoList_, no need to take any action on other sessions, just return.
1558 if (!isInterruptActive) {
1559 AUDIO_DEBUG_LOG("DeactivateAudioInterrupt: the stream (sessionID %{public}d) is not active now, return success",
1560 audioInterrupt.sessionID);
1561 return SUCCESS;
1562 }
1563 // resume if other session was forced paused or ducked
1564 ResumeAudioFocusList();
1565
1566 return SUCCESS;
1567 }
1568
OnSessionRemoved(const uint32_t sessionID)1569 void AudioPolicyServer::OnSessionRemoved(const uint32_t sessionID)
1570 {
1571 uint32_t removedSessionID = sessionID;
1572
1573 auto isSessionPresent = [&removedSessionID] (const std::pair<AudioInterrupt, AudioFocuState> &audioFocusInfo) {
1574 return audioFocusInfo.first.sessionID == removedSessionID;
1575 };
1576
1577 std::unique_lock<std::mutex> lock(interruptMutex_);
1578
1579 auto iterActive = std::find_if(audioFocusInfoList_.begin(), audioFocusInfoList_.end(), isSessionPresent);
1580 if (iterActive != audioFocusInfoList_.end()) {
1581 AudioInterrupt removedInterrupt = (*iterActive).first;
1582 lock.unlock();
1583 AUDIO_INFO_LOG("Removed SessionID: %{public}u is present in audioFocusInfoList_", removedSessionID);
1584
1585 (void)DeactivateAudioInterrupt(removedInterrupt);
1586 (void)UnsetAudioInterruptCallback(removedSessionID);
1587 return;
1588 }
1589
1590 // Though it is not present in the owners list, check and clear its entry from callback map
1591 lock.unlock();
1592 (void)UnsetAudioInterruptCallback(removedSessionID);
1593 }
1594
OnPlaybackCapturerStop()1595 void AudioPolicyServer::OnPlaybackCapturerStop()
1596 {
1597 mPolicyService.UnloadLoopback();
1598 }
1599
OnWakeupCapturerStop()1600 void AudioPolicyServer::OnWakeupCapturerStop()
1601 {
1602 mPolicyService.CloseWakeUpAudioCapturer();
1603 }
1604
GetStreamInFocus()1605 AudioStreamType AudioPolicyServer::GetStreamInFocus()
1606 {
1607 AudioStreamType streamInFocus = STREAM_DEFAULT;
1608 for (auto iter = audioFocusInfoList_.begin(); iter != audioFocusInfoList_.end(); ++iter) {
1609 if (iter->second != ACTIVE || (iter->first).audioFocusType.sourceType != SOURCE_TYPE_INVALID) {
1610 // if the steam is not active or the active stream is an audio capturer stream, skip it.
1611 continue;
1612 }
1613 AudioInterrupt audioInterrupt = iter->first;
1614 streamInFocus = audioInterrupt.audioFocusType.streamType;
1615 if (streamInFocus != STREAM_ULTRASONIC) {
1616 break;
1617 }
1618 }
1619
1620 return streamInFocus;
1621 }
1622
GetSessionInfoInFocus(AudioInterrupt & audioInterrupt)1623 int32_t AudioPolicyServer::GetSessionInfoInFocus(AudioInterrupt &audioInterrupt)
1624 {
1625 uint32_t invalidSessionID = static_cast<uint32_t>(-1);
1626 audioInterrupt = {STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN,
1627 {AudioStreamType::STREAM_DEFAULT, SourceType::SOURCE_TYPE_INVALID, true}, invalidSessionID};
1628
1629 for (auto iter = audioFocusInfoList_.begin(); iter != audioFocusInfoList_.end(); ++iter) {
1630 if (iter->second == ACTIVE) {
1631 audioInterrupt = iter->first;
1632 }
1633 }
1634
1635 return SUCCESS;
1636 }
1637
SetVolumeKeyEventCallback(const int32_t,const sptr<IRemoteObject> & object,API_VERSION api_v)1638 int32_t AudioPolicyServer::SetVolumeKeyEventCallback(const int32_t /* clientId */,
1639 const sptr<IRemoteObject> &object, API_VERSION api_v)
1640 {
1641 AUDIO_DEBUG_LOG("SetVolumeKeyEventCallback");
1642
1643 std::lock_guard<std::mutex> lock(volumeKeyEventMutex_);
1644 if (api_v == API_8 && !PermissionUtil::VerifySystemPermission()) {
1645 AUDIO_ERR_LOG("SetVolumeKeyEventCallback: No system permission");
1646 return ERR_PERMISSION_DENIED;
1647 }
1648 CHECK_AND_RETURN_RET_LOG(object != nullptr, ERR_INVALID_PARAM,
1649 "SetVolumeKeyEventCallback listener object is nullptr");
1650
1651 sptr<IAudioVolumeKeyEventCallback> listener = iface_cast<IAudioVolumeKeyEventCallback>(object);
1652 CHECK_AND_RETURN_RET_LOG(listener != nullptr, ERR_INVALID_PARAM,
1653 "SetVolumeKeyEventCallback listener obj cast failed");
1654
1655 std::shared_ptr<VolumeKeyEventCallback> callback = std::make_shared<VolumeKeyEventCallbackListner>(listener);
1656 CHECK_AND_RETURN_RET_LOG(callback != nullptr, ERR_INVALID_PARAM,
1657 "SetVolumeKeyEventCallback failed to create cb obj");
1658
1659 int32_t clientPid = IPCSkeleton::GetCallingPid();
1660 volumeChangeCbsMap_[clientPid] = callback;
1661 return SUCCESS;
1662 }
1663
UnsetVolumeKeyEventCallback(const int32_t)1664 int32_t AudioPolicyServer::UnsetVolumeKeyEventCallback(const int32_t /* clientId */)
1665 {
1666 std::lock_guard<std::mutex> lock(volumeKeyEventMutex_);
1667
1668 int32_t clientPid = IPCSkeleton::GetCallingPid();
1669 if (volumeChangeCbsMap_.erase(clientPid) == 0) {
1670 AUDIO_ERR_LOG("UnsetVolumeKeyEventCallback client %{public}d not present", clientPid);
1671 return ERR_INVALID_OPERATION;
1672 }
1673
1674 return SUCCESS;
1675 }
1676
OnAudioFocusInfoChange()1677 void AudioPolicyServer::OnAudioFocusInfoChange()
1678 {
1679 std::lock_guard<std::mutex> lock(focusInfoChangeMutex_);
1680 AUDIO_DEBUG_LOG("Entered %{public}s", __func__);
1681 for (auto it = focusInfoChangeCbsMap_.begin(); it != focusInfoChangeCbsMap_.end(); ++it) {
1682 it->second->OnAudioFocusInfoChange(audioFocusInfoList_);
1683 }
1684 }
1685
GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt,AudioFocuState>> & focusInfoList)1686 int32_t AudioPolicyServer::GetAudioFocusInfoList(std::list<std::pair<AudioInterrupt, AudioFocuState>> &focusInfoList)
1687 {
1688 AUDIO_DEBUG_LOG("Entered %{public}s", __func__);
1689
1690 focusInfoList = audioFocusInfoList_;
1691 return SUCCESS;
1692 }
1693
RegisterFocusInfoChangeCallback(const int32_t,const sptr<IRemoteObject> & object)1694 int32_t AudioPolicyServer::RegisterFocusInfoChangeCallback(const int32_t /* clientId */,
1695 const sptr<IRemoteObject> &object)
1696 {
1697 AUDIO_DEBUG_LOG("Entered %{public}s", __func__);
1698 std::lock_guard<std::mutex> lock(focusInfoChangeMutex_);
1699
1700 sptr<IStandardAudioPolicyManagerListener> callback = iface_cast<IStandardAudioPolicyManagerListener>(object);
1701 if (callback != nullptr) {
1702 int32_t clientPid = IPCSkeleton::GetCallingPid();
1703 focusInfoChangeCbsMap_[clientPid] = callback;
1704 }
1705
1706 return SUCCESS;
1707 }
1708
UnregisterFocusInfoChangeCallback(const int32_t)1709 int32_t AudioPolicyServer::UnregisterFocusInfoChangeCallback(const int32_t /* clientId */)
1710 {
1711 std::lock_guard<std::mutex> lock(focusInfoChangeMutex_);
1712
1713 int32_t clientPid = IPCSkeleton::GetCallingPid();
1714 if (focusInfoChangeCbsMap_.erase(clientPid) == 0) {
1715 AUDIO_ERR_LOG("UnregisterFocusInfoChangeCallback client %{public}d not present", clientPid);
1716 return ERR_INVALID_OPERATION;
1717 }
1718
1719 return SUCCESS;
1720 }
1721
CheckRootCalling(uid_t callingUid,int32_t appUid)1722 bool AudioPolicyServer::CheckRootCalling(uid_t callingUid, int32_t appUid)
1723 {
1724 if (callingUid == UID_ROOT) {
1725 return true;
1726 }
1727
1728 // check original caller if it pass
1729 if (std::count(RECORD_PASS_APPINFO_LIST.begin(), RECORD_PASS_APPINFO_LIST.end(), callingUid) > 0) {
1730 if (appUid == UID_ROOT) {
1731 return true;
1732 }
1733 }
1734
1735 return false;
1736 }
1737
CheckRecordingCreate(uint32_t appTokenId,uint64_t appFullTokenId,int32_t appUid)1738 bool AudioPolicyServer::CheckRecordingCreate(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid)
1739 {
1740 uid_t callingUid = IPCSkeleton::GetCallingUid();
1741 uint32_t callingTokenId = IPCSkeleton::GetCallingTokenID();
1742 uint64_t callingFullTokenId = IPCSkeleton::GetCallingFullTokenID();
1743
1744 if (CheckRootCalling(callingUid, appUid)) {
1745 AUDIO_INFO_LOG("root user recording");
1746 return true;
1747 }
1748
1749 Security::AccessToken::AccessTokenID targetTokenId = GetTargetTokenId(callingUid, callingTokenId, appTokenId);
1750 if (!VerifyPermission(MICROPHONE_PERMISSION, targetTokenId, true)) {
1751 return false;
1752 }
1753
1754 uint64_t targetFullTokenId = GetTargetFullTokenId(callingUid, callingFullTokenId, appFullTokenId);
1755 if (!CheckAppBackgroundPermission(callingUid, targetFullTokenId, targetTokenId)) {
1756 return false;
1757 }
1758
1759 return true;
1760 }
1761
VerifyPermission(const std::string & permissionName,uint32_t tokenId,bool isRecording)1762 bool AudioPolicyServer::VerifyPermission(const std::string &permissionName, uint32_t tokenId, bool isRecording)
1763 {
1764 AUDIO_DEBUG_LOG("Verify permission [%{public}s]", permissionName.c_str());
1765
1766 if (!isRecording) {
1767 // root user case for auto test
1768 uid_t callingUid = IPCSkeleton::GetCallingUid();
1769 if (callingUid == UID_ROOT) {
1770 return true;
1771 }
1772
1773 tokenId = IPCSkeleton::GetCallingTokenID();
1774 }
1775
1776 int res = Security::AccessToken::AccessTokenKit::VerifyAccessToken(tokenId, permissionName);
1777 if (res != Security::AccessToken::PermissionState::PERMISSION_GRANTED) {
1778 AUDIO_ERR_LOG("Permission denied [%{public}s]", permissionName.c_str());
1779 return false;
1780 }
1781
1782 return true;
1783 }
1784
CheckRecordingStateChange(uint32_t appTokenId,uint64_t appFullTokenId,int32_t appUid,AudioPermissionState state)1785 bool AudioPolicyServer::CheckRecordingStateChange(uint32_t appTokenId, uint64_t appFullTokenId, int32_t appUid,
1786 AudioPermissionState state)
1787 {
1788 uid_t callingUid = IPCSkeleton::GetCallingUid();
1789 uint32_t callingTokenId = IPCSkeleton::GetCallingTokenID();
1790 uint64_t callingFullTokenId = IPCSkeleton::GetCallingFullTokenID();
1791 Security::AccessToken::AccessTokenID targetTokenId = GetTargetTokenId(callingUid, callingTokenId, appTokenId);
1792 uint64_t targetFullTokenId = GetTargetFullTokenId(callingUid, callingFullTokenId, appFullTokenId);
1793
1794 // start recording need to check app state
1795 if (state == AUDIO_PERMISSION_START && !CheckRootCalling(callingUid, appUid)) {
1796 if (!CheckAppBackgroundPermission(callingUid, targetFullTokenId, targetTokenId)) {
1797 return false;
1798 }
1799 }
1800
1801 NotifyPrivacy(targetTokenId, state);
1802 return true;
1803 }
1804
NotifyPrivacy(uint32_t targetTokenId,AudioPermissionState state)1805 void AudioPolicyServer::NotifyPrivacy(uint32_t targetTokenId, AudioPermissionState state)
1806 {
1807 if (state == AUDIO_PERMISSION_START) {
1808 int res = PrivacyKit::StartUsingPermission(targetTokenId, MICROPHONE_PERMISSION);
1809 if (res != 0) {
1810 AUDIO_WARNING_LOG("notice start using perm error");
1811 }
1812 } else {
1813 int res = PrivacyKit::StopUsingPermission(targetTokenId, MICROPHONE_PERMISSION);
1814 if (res != 0) {
1815 AUDIO_WARNING_LOG("notice stop using perm error");
1816 }
1817 }
1818 }
1819
CheckAppBackgroundPermission(uid_t callingUid,uint64_t targetFullTokenId,uint32_t targetTokenId)1820 bool AudioPolicyServer::CheckAppBackgroundPermission(uid_t callingUid, uint64_t targetFullTokenId,
1821 uint32_t targetTokenId)
1822 {
1823 if (TokenIdKit::IsSystemAppByFullTokenID(targetFullTokenId)) {
1824 AUDIO_INFO_LOG("system app recording");
1825 return true;
1826 }
1827 if (std::count(RECORD_ALLOW_BACKGROUND_LIST.begin(), RECORD_ALLOW_BACKGROUND_LIST.end(), callingUid) > 0) {
1828 AUDIO_INFO_LOG("internal sa user directly recording");
1829 return true;
1830 }
1831 return PrivacyKit::IsAllowedUsingPermission(targetTokenId, MICROPHONE_PERMISSION);
1832 }
1833
GetTargetTokenId(uid_t callingUid,uint32_t callingTokenId,uint32_t appTokenId)1834 Security::AccessToken::AccessTokenID AudioPolicyServer::GetTargetTokenId(uid_t callingUid, uint32_t callingTokenId,
1835 uint32_t appTokenId)
1836 {
1837 return (std::count(RECORD_PASS_APPINFO_LIST.begin(), RECORD_PASS_APPINFO_LIST.end(), callingUid) > 0) ?
1838 appTokenId : callingTokenId;
1839 }
1840
GetTargetFullTokenId(uid_t callingUid,uint64_t callingFullTokenId,uint64_t appFullTokenId)1841 uint64_t AudioPolicyServer::GetTargetFullTokenId(uid_t callingUid, uint64_t callingFullTokenId,
1842 uint64_t appFullTokenId)
1843 {
1844 return (std::count(RECORD_PASS_APPINFO_LIST.begin(), RECORD_PASS_APPINFO_LIST.end(), callingUid) > 0) ?
1845 appFullTokenId : callingFullTokenId;
1846 }
1847
ReconfigureAudioChannel(const uint32_t & count,DeviceType deviceType)1848 int32_t AudioPolicyServer::ReconfigureAudioChannel(const uint32_t &count, DeviceType deviceType)
1849 {
1850 // Only root users should have access to this api
1851 if (ROOT_UID != IPCSkeleton::GetCallingUid()) {
1852 AUDIO_INFO_LOG("Unautorized user. Cannot modify channel");
1853 return ERR_PERMISSION_DENIED;
1854 }
1855
1856 return mPolicyService.ReconfigureAudioChannel(count, deviceType);
1857 }
1858
GetPolicyData(PolicyData & policyData)1859 void AudioPolicyServer::GetPolicyData(PolicyData &policyData)
1860 {
1861 policyData.ringerMode = GetRingerMode();
1862 policyData.callStatus = GetAudioScene();
1863
1864 // Get stream volumes
1865 for (int stream = AudioStreamType::STREAM_VOICE_CALL; stream <= AudioStreamType::STREAM_TYPE_MAX; stream++) {
1866 AudioStreamType streamType = (AudioStreamType)stream;
1867
1868 if (AudioServiceDump::IsStreamSupported(streamType)) {
1869 int32_t volume = GetSystemVolumeLevel(streamType);
1870 policyData.streamVolumes.insert({ streamType, volume });
1871 }
1872 }
1873
1874 // Get Audio Focus Information
1875 policyData.audioFocusInfoList = audioFocusInfoList_;
1876 GetDeviceInfo(policyData);
1877 GetGroupInfo(policyData);
1878 GetStreamVolumeInfoMap(policyData.streamVolumeInfos);
1879
1880 // Get Audio Effect Manager Information
1881 mPolicyService.GetEffectManagerInfo(policyData.oriEffectConfig, policyData.availableEffects);
1882 }
1883
GetStreamVolumeInfoMap(StreamVolumeInfoMap & streamVolumeInfos)1884 void AudioPolicyServer::GetStreamVolumeInfoMap(StreamVolumeInfoMap& streamVolumeInfos)
1885 {
1886 mPolicyService.GetStreamVolumeInfoMap(streamVolumeInfos);
1887 }
1888
GetDeviceInfo(PolicyData & policyData)1889 void AudioPolicyServer::GetDeviceInfo(PolicyData& policyData)
1890 {
1891 DeviceFlag deviceFlag = DeviceFlag::INPUT_DEVICES_FLAG;
1892 std::vector<sptr<AudioDeviceDescriptor>> audioDeviceDescriptors = GetDevices(deviceFlag);
1893
1894 for (auto it = audioDeviceDescriptors.begin(); it != audioDeviceDescriptors.end(); it++) {
1895 AudioDeviceDescriptor audioDeviceDescriptor = **it;
1896 DevicesInfo deviceInfo;
1897 deviceInfo.deviceType = audioDeviceDescriptor.deviceType_;
1898 deviceInfo.deviceRole = audioDeviceDescriptor.deviceRole_;
1899 deviceInfo.conneceType = CONNECT_TYPE_LOCAL;
1900 policyData.inputDevices.push_back(deviceInfo);
1901 }
1902
1903 deviceFlag = DeviceFlag::OUTPUT_DEVICES_FLAG;
1904 audioDeviceDescriptors = GetDevices(deviceFlag);
1905
1906 for (auto it = audioDeviceDescriptors.begin(); it != audioDeviceDescriptors.end(); it++) {
1907 AudioDeviceDescriptor audioDeviceDescriptor = **it;
1908 DevicesInfo deviceInfo;
1909 deviceInfo.deviceType = audioDeviceDescriptor.deviceType_;
1910 deviceInfo.deviceRole = audioDeviceDescriptor.deviceRole_;
1911 deviceInfo.conneceType = CONNECT_TYPE_LOCAL;
1912 policyData.outputDevices.push_back(deviceInfo);
1913 }
1914
1915 deviceFlag = DeviceFlag::DISTRIBUTED_INPUT_DEVICES_FLAG;
1916 audioDeviceDescriptors = GetDevices(deviceFlag);
1917
1918 for (auto it = audioDeviceDescriptors.begin(); it != audioDeviceDescriptors.end(); it++) {
1919 AudioDeviceDescriptor audioDeviceDescriptor = **it;
1920 DevicesInfo deviceInfo;
1921 deviceInfo.deviceType = audioDeviceDescriptor.deviceType_;
1922 deviceInfo.deviceRole = audioDeviceDescriptor.deviceRole_;
1923 deviceInfo.conneceType = CONNECT_TYPE_DISTRIBUTED;
1924 policyData.inputDevices.push_back(deviceInfo);
1925 }
1926
1927 deviceFlag = DeviceFlag::DISTRIBUTED_OUTPUT_DEVICES_FLAG;
1928 audioDeviceDescriptors = GetDevices(deviceFlag);
1929
1930 for (auto it = audioDeviceDescriptors.begin(); it != audioDeviceDescriptors.end(); it++) {
1931 AudioDeviceDescriptor audioDeviceDescriptor = **it;
1932 DevicesInfo deviceInfo;
1933 deviceInfo.deviceType = audioDeviceDescriptor.deviceType_;
1934 deviceInfo.deviceRole = audioDeviceDescriptor.deviceRole_;
1935 deviceInfo.conneceType = CONNECT_TYPE_DISTRIBUTED;
1936 policyData.outputDevices.push_back(deviceInfo);
1937 }
1938
1939 policyData.priorityOutputDevice = GetActiveOutputDevice();
1940 policyData.priorityInputDevice = GetActiveInputDevice();
1941 }
1942
GetGroupInfo(PolicyData & policyData)1943 void AudioPolicyServer::GetGroupInfo(PolicyData& policyData)
1944 {
1945 // Get group info
1946 std::vector<sptr<VolumeGroupInfo>> groupInfos = mPolicyService.GetVolumeGroupInfos();
1947
1948 for (auto volumeGroupInfo : groupInfos) {
1949 GroupInfo info;
1950 info.groupId = volumeGroupInfo->volumeGroupId_;
1951 info.groupName = volumeGroupInfo->groupName_;
1952 info.type = volumeGroupInfo->connectType_;
1953 policyData.groupInfos.push_back(info);
1954 }
1955 }
1956
Dump(int32_t fd,const std::vector<std::u16string> & args)1957 int32_t AudioPolicyServer::Dump(int32_t fd, const std::vector<std::u16string> &args)
1958 {
1959 AUDIO_DEBUG_LOG("AudioPolicyServer: Dump Process Invoked");
1960 std::unordered_set<std::u16string> argSets;
1961 std::u16string arg1(u"debug_interrupt_resume");
1962 std::u16string arg2(u"debug_interrupt_pause");
1963 for (decltype(args.size()) index = 0; index < args.size(); ++index) {
1964 argSets.insert(args[index]);
1965 }
1966
1967 std::lock_guard<std::mutex> lock(interruptMutex_);
1968 if (argSets.count(arg1) != 0) {
1969 InterruptType type = INTERRUPT_TYPE_BEGIN;
1970 InterruptForceType forceType = INTERRUPT_SHARE;
1971 InterruptHint hint = INTERRUPT_HINT_RESUME;
1972 InterruptEventInternal interruptEvent {type, forceType, hint, 0.2f};
1973 for (auto it : interruptCbsMap_) {
1974 if (it.second != nullptr) {
1975 it.second->OnInterrupt(interruptEvent);
1976 }
1977 }
1978 }
1979 if (argSets.count(arg2) != 0) {
1980 InterruptType type = INTERRUPT_TYPE_BEGIN;
1981 InterruptForceType forceType = INTERRUPT_SHARE;
1982 InterruptHint hint = INTERRUPT_HINT_PAUSE;
1983 InterruptEventInternal interruptEvent {type, forceType, hint, 0.2f};
1984 for (auto it : interruptCbsMap_) {
1985 if (it.second != nullptr) {
1986 it.second->OnInterrupt(interruptEvent);
1987 }
1988 }
1989 }
1990 std::string dumpString;
1991 PolicyData policyData;
1992 AudioServiceDump dumpObj;
1993
1994 if (dumpObj.Initialize() != AUDIO_DUMP_SUCCESS) {
1995 AUDIO_ERR_LOG("Audio Service Dump Not initialised\n");
1996 return AUDIO_DUMP_INIT_ERR;
1997 }
1998
1999 GetPolicyData(policyData);
2000 dumpObj.AudioDataDump(policyData, dumpString);
2001
2002 return write(fd, dumpString.c_str(), dumpString.size());
2003 }
2004
GetAudioLatencyFromXml()2005 int32_t AudioPolicyServer::GetAudioLatencyFromXml()
2006 {
2007 return mPolicyService.GetAudioLatencyFromXml();
2008 }
2009
GetSinkLatencyFromXml()2010 uint32_t AudioPolicyServer::GetSinkLatencyFromXml()
2011 {
2012 return mPolicyService.GetSinkLatencyFromXml();
2013 }
2014
RegisterAudioRendererEventListener(int32_t clientPid,const sptr<IRemoteObject> & object)2015 int32_t AudioPolicyServer::RegisterAudioRendererEventListener(int32_t clientPid, const sptr<IRemoteObject> &object)
2016 {
2017 clientPid = IPCSkeleton::GetCallingPid();
2018 RegisterClientDeathRecipient(object, LISTENER_CLIENT);
2019 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
2020 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
2021 return mPolicyService.RegisterAudioRendererEventListener(clientPid, object, hasBTPermission, hasSystemPermission);
2022 }
2023
UnregisterAudioRendererEventListener(int32_t clientPid)2024 int32_t AudioPolicyServer::UnregisterAudioRendererEventListener(int32_t clientPid)
2025 {
2026 clientPid = IPCSkeleton::GetCallingPid();
2027 return mPolicyService.UnregisterAudioRendererEventListener(clientPid);
2028 }
2029
RegisterAudioCapturerEventListener(int32_t clientPid,const sptr<IRemoteObject> & object)2030 int32_t AudioPolicyServer::RegisterAudioCapturerEventListener(int32_t clientPid, const sptr<IRemoteObject> &object)
2031 {
2032 clientPid = IPCSkeleton::GetCallingPid();
2033 RegisterClientDeathRecipient(object, LISTENER_CLIENT);
2034 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
2035 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
2036 return mPolicyService.RegisterAudioCapturerEventListener(clientPid, object, hasBTPermission, hasSystemPermission);
2037 }
2038
UnregisterAudioCapturerEventListener(int32_t clientPid)2039 int32_t AudioPolicyServer::UnregisterAudioCapturerEventListener(int32_t clientPid)
2040 {
2041 clientPid = IPCSkeleton::GetCallingPid();
2042 return mPolicyService.UnregisterAudioCapturerEventListener(clientPid);
2043 }
2044
RegisterTracker(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo,const sptr<IRemoteObject> & object)2045 int32_t AudioPolicyServer::RegisterTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo,
2046 const sptr<IRemoteObject> &object)
2047 {
2048 // update the clientUid
2049 auto callerUid = IPCSkeleton::GetCallingUid();
2050 streamChangeInfo.audioRendererChangeInfo.createrUID = callerUid;
2051 streamChangeInfo.audioCapturerChangeInfo.createrUID = callerUid;
2052 AUDIO_INFO_LOG("RegisterTracker: [caller uid: %{public}d]", callerUid);
2053 if (callerUid != MEDIA_SERVICE_UID) {
2054 if (mode == AUDIO_MODE_PLAYBACK) {
2055 streamChangeInfo.audioRendererChangeInfo.clientUID = callerUid;
2056 AUDIO_DEBUG_LOG("Non media service caller, use the uid retrieved. ClientUID:%{public}d]",
2057 streamChangeInfo.audioRendererChangeInfo.clientUID);
2058 } else {
2059 streamChangeInfo.audioCapturerChangeInfo.clientUID = callerUid;
2060 AUDIO_DEBUG_LOG("Non media service caller, use the uid retrieved. ClientUID:%{public}d]",
2061 streamChangeInfo.audioCapturerChangeInfo.clientUID);
2062 }
2063 }
2064 RegisterClientDeathRecipient(object, TRACKER_CLIENT);
2065 return mPolicyService.RegisterTracker(mode, streamChangeInfo, object);
2066 }
2067
UpdateTracker(AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)2068 int32_t AudioPolicyServer::UpdateTracker(AudioMode &mode, AudioStreamChangeInfo &streamChangeInfo)
2069 {
2070 // update the clientUid
2071 auto callerUid = IPCSkeleton::GetCallingUid();
2072 streamChangeInfo.audioRendererChangeInfo.createrUID = callerUid;
2073 streamChangeInfo.audioCapturerChangeInfo.createrUID = callerUid;
2074 AUDIO_INFO_LOG("UpdateTracker: [caller uid: %{public}d]", callerUid);
2075 if (callerUid != MEDIA_SERVICE_UID) {
2076 if (mode == AUDIO_MODE_PLAYBACK) {
2077 streamChangeInfo.audioRendererChangeInfo.clientUID = callerUid;
2078 AUDIO_DEBUG_LOG("Non media service caller, use the uid retrieved. ClientUID:%{public}d]",
2079 streamChangeInfo.audioRendererChangeInfo.clientUID);
2080 } else {
2081 streamChangeInfo.audioCapturerChangeInfo.clientUID = callerUid;
2082 AUDIO_DEBUG_LOG("Non media service caller, use the uid retrieved. ClientUID:%{public}d]",
2083 streamChangeInfo.audioCapturerChangeInfo.clientUID);
2084 }
2085 }
2086 return mPolicyService.UpdateTracker(mode, streamChangeInfo);
2087 }
2088
GetCurrentRendererChangeInfos(vector<unique_ptr<AudioRendererChangeInfo>> & audioRendererChangeInfos)2089 int32_t AudioPolicyServer::GetCurrentRendererChangeInfos(
2090 vector<unique_ptr<AudioRendererChangeInfo>> &audioRendererChangeInfos)
2091 {
2092 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
2093 AUDIO_DEBUG_LOG("GetCurrentRendererChangeInfos: BT use permission: %{public}d", hasBTPermission);
2094 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
2095 AUDIO_DEBUG_LOG("GetCurrentRendererChangeInfos: System use permission: %{public}d", hasSystemPermission);
2096 return mPolicyService.GetCurrentRendererChangeInfos(audioRendererChangeInfos, hasBTPermission, hasSystemPermission);
2097 }
2098
GetCurrentCapturerChangeInfos(vector<unique_ptr<AudioCapturerChangeInfo>> & audioCapturerChangeInfos)2099 int32_t AudioPolicyServer::GetCurrentCapturerChangeInfos(
2100 vector<unique_ptr<AudioCapturerChangeInfo>> &audioCapturerChangeInfos)
2101 {
2102 bool hasBTPermission = VerifyPermission(USE_BLUETOOTH_PERMISSION);
2103 AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos: BT use permission: %{public}d", hasBTPermission);
2104 bool hasSystemPermission = PermissionUtil::VerifySystemPermission();
2105 AUDIO_DEBUG_LOG("GetCurrentCapturerChangeInfos: System use permission: %{public}d", hasSystemPermission);
2106 return mPolicyService.GetCurrentCapturerChangeInfos(audioCapturerChangeInfos, hasBTPermission, hasSystemPermission);
2107 }
2108
RegisterClientDeathRecipient(const sptr<IRemoteObject> & object,DeathRecipientId id)2109 void AudioPolicyServer::RegisterClientDeathRecipient(const sptr<IRemoteObject> &object, DeathRecipientId id)
2110 {
2111 AUDIO_INFO_LOG("Register clients death recipient!!");
2112 std::lock_guard<std::mutex> lock(clientDiedListenerStateMutex_);
2113 CHECK_AND_RETURN_LOG(object != nullptr, "Client proxy obj NULL!!");
2114
2115 pid_t uid = 0;
2116 if (id == TRACKER_CLIENT) {
2117 // Deliberately casting UID to pid_t
2118 uid = static_cast<pid_t>(IPCSkeleton::GetCallingUid());
2119 } else {
2120 uid = IPCSkeleton::GetCallingPid();
2121 }
2122 if (id == TRACKER_CLIENT && std::find(clientDiedListenerState_.begin(), clientDiedListenerState_.end(), uid)
2123 != clientDiedListenerState_.end()) {
2124 AUDIO_INFO_LOG("Tracker has been registered for %{public}d!", uid);
2125 return;
2126 }
2127 sptr<AudioServerDeathRecipient> deathRecipient_ = new(std::nothrow) AudioServerDeathRecipient(uid);
2128 if (deathRecipient_ != nullptr) {
2129 if (id == TRACKER_CLIENT) {
2130 deathRecipient_->SetNotifyCb(std::bind(&AudioPolicyServer::RegisteredTrackerClientDied,
2131 this, std::placeholders::_1));
2132 } else {
2133 AUDIO_INFO_LOG("RegisteredStreamListenerClientDied register!!");
2134 deathRecipient_->SetNotifyCb(std::bind(&AudioPolicyServer::RegisteredStreamListenerClientDied,
2135 this, std::placeholders::_1));
2136 }
2137 bool result = object->AddDeathRecipient(deathRecipient_);
2138 if (result && id == TRACKER_CLIENT) {
2139 clientDiedListenerState_.push_back(uid);
2140 }
2141 if (!result) {
2142 AUDIO_ERR_LOG("failed to add deathRecipient");
2143 }
2144 }
2145 }
2146
RegisteredTrackerClientDied(pid_t pid)2147 void AudioPolicyServer::RegisteredTrackerClientDied(pid_t pid)
2148 {
2149 AUDIO_INFO_LOG("RegisteredTrackerClient died: remove entry, uid %{public}d", pid);
2150 std::lock_guard<std::mutex> lock(clientDiedListenerStateMutex_);
2151 mPolicyService.RegisteredTrackerClientDied(pid);
2152 auto filter = [&pid](int val) {
2153 return pid == val;
2154 };
2155 clientDiedListenerState_.erase(std::remove_if(clientDiedListenerState_.begin(), clientDiedListenerState_.end(),
2156 filter), clientDiedListenerState_.end());
2157 }
2158
RegisteredStreamListenerClientDied(pid_t pid)2159 void AudioPolicyServer::RegisteredStreamListenerClientDied(pid_t pid)
2160 {
2161 AUDIO_INFO_LOG("RegisteredStreamListenerClient died: remove entry, uid %{public}d", pid);
2162 mPolicyService.RegisteredStreamListenerClientDied(pid);
2163 }
2164
UpdateStreamState(const int32_t clientUid,StreamSetState streamSetState,AudioStreamType audioStreamType)2165 int32_t AudioPolicyServer::UpdateStreamState(const int32_t clientUid,
2166 StreamSetState streamSetState, AudioStreamType audioStreamType)
2167 {
2168 constexpr int32_t avSessionUid = 6700; // "uid" : "av_session"
2169 auto callerUid = IPCSkeleton::GetCallingUid();
2170 if (callerUid != avSessionUid) {
2171 // This function can only be used by av_session
2172 AUDIO_ERR_LOG("UpdateStreamState callerUid is error: not av_session");
2173 return ERROR;
2174 }
2175
2176 AUDIO_INFO_LOG("UpdateStreamState::uid:%{public}d streamSetState:%{public}d audioStreamType:%{public}d",
2177 clientUid, streamSetState, audioStreamType);
2178 StreamSetState setState = StreamSetState::STREAM_PAUSE;
2179 if (streamSetState == StreamSetState::STREAM_RESUME) {
2180 setState = StreamSetState::STREAM_RESUME;
2181 } else if (streamSetState != StreamSetState::STREAM_PAUSE) {
2182 AUDIO_ERR_LOG("UpdateStreamState streamSetState value is error");
2183 return ERROR;
2184 }
2185 StreamSetStateEventInternal setStateEvent = {};
2186 setStateEvent.streamSetState = setState;
2187 setStateEvent.audioStreamType = audioStreamType;
2188
2189 return mPolicyService.UpdateStreamState(clientUid, setStateEvent);
2190 }
2191
GetVolumeGroupInfos(std::string networkId,std::vector<sptr<VolumeGroupInfo>> & infos)2192 int32_t AudioPolicyServer::GetVolumeGroupInfos(std::string networkId, std::vector<sptr<VolumeGroupInfo>> &infos)
2193 {
2194 if (!PermissionUtil::VerifySystemPermission()) {
2195 AUDIO_ERR_LOG("GetVolumeGroupInfos: No system permission");
2196 return ERR_PERMISSION_DENIED;
2197 }
2198
2199 infos = mPolicyService.GetVolumeGroupInfos();
2200 auto filter = [&networkId](const sptr<VolumeGroupInfo>& info) {
2201 return networkId != info->networkId_;
2202 };
2203 infos.erase(std::remove_if(infos.begin(), infos.end(), filter), infos.end());
2204
2205 return SUCCESS;
2206 }
2207
GetNetworkIdByGroupId(int32_t groupId,std::string & networkId)2208 int32_t AudioPolicyServer::GetNetworkIdByGroupId(int32_t groupId, std::string &networkId)
2209 {
2210 auto volumeGroupInfos = mPolicyService.GetVolumeGroupInfos();
2211
2212 auto filter = [&groupId](const sptr<VolumeGroupInfo>& info) {
2213 return groupId != info->volumeGroupId_;
2214 };
2215 volumeGroupInfos.erase(std::remove_if(volumeGroupInfos.begin(), volumeGroupInfos.end(), filter),
2216 volumeGroupInfos.end());
2217 if (volumeGroupInfos.size() > 0) {
2218 networkId = volumeGroupInfos[0]->networkId_;
2219 AUDIO_INFO_LOG("GetNetworkIdByGroupId: get networkId %{public}s.", networkId.c_str());
2220 } else {
2221 AUDIO_ERR_LOG("GetNetworkIdByGroupId: has no valid group");
2222 return ERROR;
2223 }
2224
2225 return SUCCESS;
2226 }
2227
RemoteParameterCallback(sptr<AudioPolicyServer> server)2228 AudioPolicyServer::RemoteParameterCallback::RemoteParameterCallback(sptr<AudioPolicyServer> server)
2229 {
2230 server_ = server;
2231 }
2232
OnAudioParameterChange(const std::string networkId,const AudioParamKey key,const std::string & condition,const std::string & value)2233 void AudioPolicyServer::RemoteParameterCallback::OnAudioParameterChange(const std::string networkId,
2234 const AudioParamKey key, const std::string& condition, const std::string& value)
2235 {
2236 AUDIO_INFO_LOG("AudioPolicyServer::OnAudioParameterChange key:%{public}d, condition:%{public}s, value:%{public}s",
2237 key, condition.c_str(), value.c_str());
2238 if (server_ == nullptr) {
2239 AUDIO_ERR_LOG("server_ is nullptr");
2240 return;
2241 }
2242 switch (key) {
2243 case VOLUME:
2244 VolumeOnChange(networkId, condition);
2245 break;
2246 case INTERRUPT:
2247 InterruptOnChange(networkId, condition);
2248 break;
2249 case RENDER_STATE:
2250 StateOnChange(networkId, condition, value);
2251 break;
2252 default:
2253 AUDIO_DEBUG_LOG("[AudioPolicyServer]: No processing");
2254 break;
2255 }
2256 }
2257
VolumeOnChange(const std::string networkId,const std::string & condition)2258 void AudioPolicyServer::RemoteParameterCallback::VolumeOnChange(const std::string networkId,
2259 const std::string& condition)
2260 {
2261 VolumeEvent volumeEvent;
2262 volumeEvent.networkId = networkId;
2263 char eventDes[EVENT_DES_SIZE];
2264 if (sscanf_s(condition.c_str(), "%[^;];AUDIO_STREAM_TYPE=%d;VOLUME_LEVEL=%d;IS_UPDATEUI=%d;VOLUME_GROUP_ID=%d;",
2265 eventDes, EVENT_DES_SIZE, &(volumeEvent.volumeType), &(volumeEvent.volume), &(volumeEvent.updateUi),
2266 &(volumeEvent.volumeGroupId)) < PARAMS_VOLUME_NUM) {
2267 AUDIO_ERR_LOG("[VolumeOnChange]: Failed parse condition");
2268 return;
2269 }
2270
2271 volumeEvent.updateUi = false;
2272 for (auto it = server_->volumeChangeCbsMap_.begin(); it != server_->volumeChangeCbsMap_.end(); ++it) {
2273 std::shared_ptr<VolumeKeyEventCallback> volumeChangeCb = it->second;
2274 if (volumeChangeCb == nullptr) {
2275 AUDIO_ERR_LOG("volumeChangeCb: nullptr for client : %{public}d", it->first);
2276 continue;
2277 }
2278
2279 AUDIO_DEBUG_LOG("trigger volumeChangeCb clientPid : %{public}d", it->first);
2280 volumeChangeCb->OnVolumeKeyEvent(volumeEvent);
2281 }
2282 }
2283
InterruptOnChange(const std::string networkId,const std::string & condition)2284 void AudioPolicyServer::RemoteParameterCallback::InterruptOnChange(const std::string networkId,
2285 const std::string& condition)
2286 {
2287 char eventDes[EVENT_DES_SIZE];
2288 InterruptType type = INTERRUPT_TYPE_BEGIN;
2289 InterruptForceType forceType = INTERRUPT_SHARE;
2290 InterruptHint hint = INTERRUPT_HINT_NONE;
2291
2292 if (sscanf_s(condition.c_str(), "%[^;];EVENT_TYPE=%d;FORCE_TYPE=%d;HINT_TYPE=%d;", eventDes,
2293 EVENT_DES_SIZE, &type, &forceType, &hint) < PARAMS_INTERRUPT_NUM) {
2294 AUDIO_ERR_LOG("[InterruptOnChange]: Failed parse condition");
2295 return;
2296 }
2297
2298 InterruptEventInternal interruptEvent {type, forceType, hint, 0.2f};
2299 for (auto it : server_->interruptCbsMap_) {
2300 if (it.second != nullptr) {
2301 it.second->OnInterrupt(interruptEvent);
2302 }
2303 }
2304 }
2305
StateOnChange(const std::string networkId,const std::string & condition,const std::string & value)2306 void AudioPolicyServer::RemoteParameterCallback::StateOnChange(const std::string networkId,
2307 const std::string& condition, const std::string& value)
2308 {
2309 char eventDes[EVENT_DES_SIZE];
2310 char contentDes[RENDER_STATE_CONTENT_DES_SIZE];
2311 if (sscanf_s(condition.c_str(), "%[^;];%s", eventDes, EVENT_DES_SIZE, contentDes,
2312 RENDER_STATE_CONTENT_DES_SIZE) < PARAMS_RENDER_STATE_NUM) {
2313 AUDIO_ERR_LOG("[StateOnChange]: Failed parse condition");
2314 return;
2315 }
2316 if (!strcmp(eventDes, "ERR_EVENT")) {
2317 server_->mPolicyService.NotifyRemoteRenderState(networkId, condition, value);
2318 }
2319 }
2320
PermStateChangeCallback(Security::AccessToken::PermStateChangeInfo & result)2321 void AudioPolicyServer::PerStateChangeCbCustomizeCallback::PermStateChangeCallback(
2322 Security::AccessToken::PermStateChangeInfo& result)
2323 {
2324 ready_ = true;
2325 Security::AccessToken::HapTokenInfo hapTokenInfo;
2326 int32_t res = Security::AccessToken::AccessTokenKit::GetHapTokenInfo(result.tokenID, hapTokenInfo);
2327 if (res < 0) {
2328 AUDIO_ERR_LOG("Call GetHapTokenInfo fail.");
2329 }
2330 bool bSetMute;
2331 if (result.permStateChangeType > 0) {
2332 bSetMute = false;
2333 } else {
2334 bSetMute = true;
2335 }
2336
2337 int32_t appUid = getUidByBundleName(hapTokenInfo.bundleName, hapTokenInfo.userID);
2338 if (appUid < 0) {
2339 AUDIO_ERR_LOG("fail to get uid.");
2340 } else {
2341 server_->mPolicyService.SetSourceOutputStreamMute(appUid, bSetMute);
2342 AUDIO_DEBUG_LOG("get uid value:%{public}d", appUid);
2343 }
2344 }
2345
getUidByBundleName(std::string bundle_name,int user_id)2346 int32_t AudioPolicyServer::PerStateChangeCbCustomizeCallback::getUidByBundleName(std::string bundle_name, int user_id)
2347 {
2348 auto systemAbilityManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
2349 if (systemAbilityManager == nullptr) {
2350 return ERR_INVALID_PARAM;
2351 }
2352
2353 sptr<IRemoteObject> remoteObject = systemAbilityManager->GetSystemAbility(BUNDLE_MGR_SERVICE_SYS_ABILITY_ID);
2354 if (remoteObject == nullptr) {
2355 return ERR_INVALID_PARAM;
2356 }
2357
2358 sptr<AppExecFwk::IBundleMgr> bundleMgrProxy = OHOS::iface_cast<AppExecFwk::IBundleMgr>(remoteObject);
2359 if (bundleMgrProxy == nullptr) {
2360 return ERR_INVALID_PARAM;
2361 }
2362 int32_t iUid = bundleMgrProxy->GetUidByBundleName(bundle_name, user_id);
2363
2364 return iUid;
2365 }
2366
RegisterParamCallback()2367 void AudioPolicyServer::RegisterParamCallback()
2368 {
2369 AUDIO_INFO_LOG("RegisterParamCallback");
2370 remoteParameterCallback_ = std::make_shared<RemoteParameterCallback>(this);
2371 mPolicyService.SetParameterCallback(remoteParameterCallback_);
2372 // regiest policy provider in audio server
2373 mPolicyService.RegiestPolicy();
2374 }
2375
RegisterBluetoothListener()2376 void AudioPolicyServer::RegisterBluetoothListener()
2377 {
2378 AUDIO_INFO_LOG("RegisterBluetoothListener");
2379 mPolicyService.RegisterBluetoothListener();
2380 }
2381
SubscribeAccessibilityConfigObserver()2382 void AudioPolicyServer::SubscribeAccessibilityConfigObserver()
2383 {
2384 AUDIO_INFO_LOG("SubscribeAccessibilityConfigObserver");
2385 mPolicyService.SubscribeAccessibilityConfigObserver();
2386 }
2387
IsAudioRendererLowLatencySupported(const AudioStreamInfo & audioStreamInfo)2388 bool AudioPolicyServer::IsAudioRendererLowLatencySupported(const AudioStreamInfo &audioStreamInfo)
2389 {
2390 AUDIO_INFO_LOG("IsAudioRendererLowLatencySupported server call");
2391 return true;
2392 }
2393
SetSystemSoundUri(const std::string & key,const std::string & uri)2394 int32_t AudioPolicyServer::SetSystemSoundUri(const std::string &key, const std::string &uri)
2395 {
2396 if (!PermissionUtil::VerifySystemPermission()) {
2397 AUDIO_ERR_LOG("GetVolumeGroupInfos: No system permission");
2398 return ERR_PERMISSION_DENIED;
2399 }
2400 AUDIO_INFO_LOG("SetSystemSoundUri:: key: %{public}s, uri: %{public}s", key.c_str(), uri.c_str());
2401 return mPolicyService.SetSystemSoundUri(key, uri);
2402 }
2403
GetSystemSoundUri(const std::string & key)2404 std::string AudioPolicyServer::GetSystemSoundUri(const std::string &key)
2405 {
2406 if (!PermissionUtil::VerifySystemPermission()) {
2407 AUDIO_ERR_LOG("GetVolumeGroupInfos: No system permission");
2408 return "";
2409 }
2410 AUDIO_INFO_LOG("GetSystemSoundUri:: key: %{public}s", key.c_str());
2411 return mPolicyService.GetSystemSoundUri(key);
2412 }
2413
GetMinStreamVolume()2414 float AudioPolicyServer::GetMinStreamVolume()
2415 {
2416 return mPolicyService.GetMinStreamVolume();
2417 }
2418
GetMaxStreamVolume()2419 float AudioPolicyServer::GetMaxStreamVolume()
2420 {
2421 return mPolicyService.GetMaxStreamVolume();
2422 }
2423
GetMaxRendererInstances()2424 int32_t AudioPolicyServer::GetMaxRendererInstances()
2425 {
2426 AUDIO_INFO_LOG("GetMaxRendererInstances");
2427 return mPolicyService.GetMaxRendererInstances();
2428 }
2429
RegisterDataObserver()2430 void AudioPolicyServer::RegisterDataObserver()
2431 {
2432 mPolicyService.RegisterDataObserver();
2433 }
2434
QueryEffectSceneMode(SupportedEffectConfig & supportedEffectConfig)2435 int32_t AudioPolicyServer::QueryEffectSceneMode(SupportedEffectConfig &supportedEffectConfig)
2436 {
2437 int32_t ret = mPolicyService.QueryEffectManagerSceneMode(supportedEffectConfig);
2438 return ret;
2439 }
2440
SetPlaybackCapturerFilterInfos(const AudioPlaybackCaptureConfig & config,uint32_t appTokenId)2441 int32_t AudioPolicyServer::SetPlaybackCapturerFilterInfos(const AudioPlaybackCaptureConfig &config,
2442 uint32_t appTokenId)
2443 {
2444 for (auto &usg : config.filterOptions.usages) {
2445 if (usg != STREAM_USAGE_VOICE_COMMUNICATION) {
2446 continue;
2447 }
2448
2449 if (!VerifyPermission(CAPTURER_VOICE_DOWNLINK_PERMISSION, appTokenId)) {
2450 AUDIO_ERR_LOG("downlink capturer permission check failed");
2451 return ERR_PERMISSION_DENIED;
2452 }
2453 }
2454 return mPolicyService.SetPlaybackCapturerFilterInfos(config);
2455 }
2456 } // namespace AudioStandard
2457 } // namespace OHOS
2458