1 /*
2 * Copyright (c) 2021-2024 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 #ifndef LOG_TAG
16 #define LOG_TAG "AudioPolicyManagerStub"
17 #endif
18
19 #include "audio_policy_manager_stub.h"
20
21 #include "audio_errors.h"
22 #include "audio_policy_log.h"
23 #include "audio_utils.h"
24
25 namespace OHOS {
26 namespace AudioStandard {
27 namespace {
28 constexpr int MAX_PID_COUNT = 1000;
29 const char *g_audioPolicyCodeStrs[] = {
30 "GET_MAX_VOLUMELEVEL",
31 "GET_MIN_VOLUMELEVEL",
32 "SET_SYSTEM_VOLUMELEVEL_LEGACY",
33 "SET_SYSTEM_VOLUMELEVEL",
34 "GET_SYSTEM_ACTIVEVOLUME_TYPE",
35 "GET_SYSTEM_VOLUMELEVEL",
36 "SET_STREAM_MUTE_LEGACY",
37 "SET_STREAM_MUTE",
38 "GET_STREAM_MUTE",
39 "IS_STREAM_ACTIVE",
40 "SET_DEVICE_ACTIVE",
41 "IS_DEVICE_ACTIVE",
42 "GET_ACTIVE_OUTPUT_DEVICE",
43 "GET_ACTIVE_INPUT_DEVICE",
44 "SET_RINGER_MODE_LEGACY",
45 "SET_RINGER_MODE",
46 "GET_RINGER_MODE",
47 "SET_AUDIO_SCENE",
48 "GET_AUDIO_SCENE",
49 "SET_MICROPHONE_MUTE",
50 "SET_MICROPHONE_MUTE_AUDIO_CONFIG",
51 "IS_MICROPHONE_MUTE_LEGACY",
52 "IS_MICROPHONE_MUTE",
53 "SET_CALLBACK",
54 "UNSET_CALLBACK",
55 "SET_QUERY_CLIENT_TYPE_CALLBACK",
56 "ACTIVATE_INTERRUPT",
57 "DEACTIVATE_INTERRUPT",
58 "SET_INTERRUPT_CALLBACK",
59 "UNSET_INTERRUPT_CALLBACK",
60 "REQUEST_AUDIO_FOCUS",
61 "ABANDON_AUDIO_FOCUS",
62 "GET_STREAM_IN_FOCUS",
63 "GET_SESSION_INFO_IN_FOCUS",
64 "GET_DEVICES",
65 "SET_WAKEUP_AUDIOCAPTURER",
66 "QUERY_MICROPHONE_PERMISSION",
67 "SELECT_OUTPUT_DEVICE",
68 "GET_SELECTED_DEVICE_INFO",
69 "SELECT_INPUT_DEVICE",
70 "RECONFIGURE_CHANNEL",
71 "GET_AUDIO_LATENCY",
72 "GET_SINK_LATENCY",
73 "GET_PREFERRED_OUTPUT_STREAM_TYPE",
74 "GET_PREFERRED_INPUT_STREAM_TYPE",
75 "REGISTER_TRACKER",
76 "UPDATE_TRACKER",
77 "GET_RENDERER_CHANGE_INFOS",
78 "GET_CAPTURER_CHANGE_INFOS",
79 "SET_LOW_POWER_STREM_VOLUME",
80 "GET_LOW_POWRR_STREM_VOLUME",
81 "UPDATE_STREAM_STATE",
82 "GET_SINGLE_STREAM_VOLUME",
83 "GET_VOLUME_GROUP_INFO",
84 "GET_NETWORKID_BY_GROUP_ID",
85 #ifdef FEATURE_DTMF_TONE
86 "GET_TONEINFO",
87 "GET_SUPPORTED_TONES",
88 #endif
89 "IS_AUDIO_RENDER_LOW_LATENCY_SUPPORTED",
90 "GET_USING_PEMISSION_FROM_PRIVACY",
91 "GET_ACTIVE_OUTPUT_DEVICE_DESCRIPTORS",
92 "GET_PREFERRED_INTPUT_DEVICE_DESCRIPTORS",
93 "SET_CALLBACKS_ENABLE",
94 "GET_AUDIO_FOCUS_INFO_LIST",
95 "SET_SYSTEM_SOUND_URI",
96 "GET_SYSTEM_SOUND_URI",
97 "GET_MIN_VOLUME_STREAM",
98 "GET_MAX_VOLUME_STREAM",
99 "CHECK_MAX_RENDERER_INSTANCES",
100 "IS_VOLUME_UNADJUSTABLE",
101 "ADJUST_VOLUME_BY_STEP",
102 "ADJUST_SYSTEM_VOLUME_BY_STEP",
103 "GET_SYSTEM_VOLUME_IN_DB",
104 "QUERY_EFFECT_SCENEMODE",
105 "SET_PLAYBACK_CAPTURER_FILTER_INFO",
106 "SET_CAPTURER_SILENT_STATE",
107 "GET_HARDWARE_OUTPUT_SAMPLING_RATE",
108 "GET_AUDIO_CAPTURER_MICROPHONE_DESCRIPTORS",
109 "GET_AVAILABLE_MICROPHONE_DESCRIPTORS",
110 "SET_DEVICE_ABSOLUTE_VOLUME_SUPPORTED",
111 "GET_ABS_VOLUME_SCENE",
112 "GET_VGS_VOLUME_SUPPORTED",
113 "SET_A2DP_DEVICE_VOLUME",
114 "GET_AVAILABLE_DESCRIPTORS",
115 "SET_AVAILABLE_DEVICE_CHANGE_CALLBACK",
116 "UNSET_AVAILABLE_DEVICE_CHANGE_CALLBACK",
117 "IS_SPATIALIZATION_ENABLED",
118 "IS_SPATIALIZATION_ENABLED_FOR_DEVICE",
119 "SET_SPATIALIZATION_ENABLED",
120 "SET_SPATIALIZATION_ENABLED_FOR_DEVICE",
121 "IS_HEAD_TRACKING_ENABLED",
122 "IS_HEAD_TRACKING_ENABLED_FOR_DEVICE",
123 "SET_HEAD_TRACKING_ENABLED",
124 "SET_HEAD_TRACKING_ENABLED_FOR_DEVICE",
125 "GET_SPATIALIZATION_STATE",
126 "IS_SPATIALIZATION_SUPPORTED",
127 "IS_SPATIALIZATION_SUPPORTED_FOR_DEVICE",
128 "IS_HEAD_TRACKING_SUPPORTED",
129 "IS_HEAD_TRACKING_SUPPORTED_FOR_DEVICE",
130 "UPDATE_SPATIAL_DEVICE_STATE",
131 "REGISTER_SPATIALIZATION_STATE_EVENT",
132 "CONFIG_DISTRIBUTED_ROUTING_ROLE",
133 "SET_DISTRIBUTED_ROUTING_ROLE_CALLBACK",
134 "UNSET_DISTRIBUTED_ROUTING_ROLE_CALLBACK",
135 "UNREGISTER_SPATIALIZATION_STATE_EVENT",
136 "REGISTER_POLICY_CALLBACK_CLIENT",
137 "CREATE_AUDIO_INTERRUPT_ZONE",
138 "ADD_AUDIO_INTERRUPT_ZONE_PIDS",
139 "REMOVE_AUDIO_INTERRUPT_ZONE_PIDS",
140 "RELEASE_AUDIO_INTERRUPT_ZONE",
141 "SET_CALL_DEVICE_ACTIVE",
142 "GET_AUDIO_CONVERTER_CONFIG",
143 "GET_ACTIVE_BLUETOOTH_DESCRIPTOR",
144 "FETCH_OUTPUT_DEVICE_FOR_TRACK",
145 "FETCH_INPUT_DEVICE_FOR_TRACK",
146 "IS_HIGH_RESOLUTION_EXIST",
147 "SET_HIGH_RESOLUTION_EXIST",
148 "GET_SPATIALIZATION_SCENE_TYPE",
149 "SET_SPATIALIZATION_SCENE_TYPE",
150 "GET_MAX_AMPLITUDE",
151 "IS_HEAD_TRACKING_DATA_REQUESTED",
152 "SET_AUDIO_DEVICE_REFINER_CALLBACK",
153 "UNSET_AUDIO_DEVICE_REFINER_CALLBACK",
154 "TRIGGER_FETCH_DEVICE",
155 "MOVE_TO_NEW_PIPE",
156 "DISABLE_SAFE_MEDIA_VOLUME",
157 "GET_DEVICES_INNER",
158 "SET_AUDIO_CONCURRENCY_CALLBACK",
159 "UNSET_AUDIO_CONCURRENCY_CALLBACK",
160 "ACTIVATE_AUDIO_CONCURRENCY",
161 "SET_MICROPHONE_MUTE_PERSISTENT",
162 "GET_MICROPHONE_MUTE_PERSISTENT",
163 "INJECT_INTERRUPTION",
164 "ACTIVATE_AUDIO_SESSION",
165 "DEACTIVATE_AUDIO_SESSION",
166 "IS_AUDIO_SESSION_ACTIVATED",
167 "LOAD_SPLIT_MODULE",
168 "SET_DEFAULT_OUTPUT_DEVICE",
169 "SET_VOICE_RINGTONE_MUTE",
170 "SET_PREFERRED_DEVICE",
171 "SAVE_REMOTE_INFO",
172 };
173
174 constexpr size_t codeNums = sizeof(g_audioPolicyCodeStrs) / sizeof(const char *);
175 static_assert(codeNums == (static_cast<size_t> (AudioPolicyInterfaceCode::AUDIO_POLICY_MANAGER_CODE_MAX) + 1),
176 "keep same with AudioPolicyInterfaceCode");
177 }
ReadStreamChangeInfo(MessageParcel & data,const AudioMode & mode,AudioStreamChangeInfo & streamChangeInfo)178 void AudioPolicyManagerStub::ReadStreamChangeInfo(MessageParcel &data, const AudioMode &mode,
179 AudioStreamChangeInfo &streamChangeInfo)
180 {
181 if (mode == AUDIO_MODE_PLAYBACK) {
182 streamChangeInfo.audioRendererChangeInfo.Unmarshalling(data);
183 return;
184 } else {
185 // mode == AUDIO_MODE_RECORDING
186 streamChangeInfo.audioCapturerChangeInfo.Unmarshalling(data);
187 }
188 }
189
GetMaxVolumeLevelInternal(MessageParcel & data,MessageParcel & reply)190 void AudioPolicyManagerStub::GetMaxVolumeLevelInternal(MessageParcel &data, MessageParcel &reply)
191 {
192 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
193 int32_t maxLevel = GetMaxVolumeLevel(volumeType);
194 reply.WriteInt32(maxLevel);
195 }
196
GetMinVolumeLevelInternal(MessageParcel & data,MessageParcel & reply)197 void AudioPolicyManagerStub::GetMinVolumeLevelInternal(MessageParcel &data, MessageParcel &reply)
198 {
199 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
200 int32_t minLevel = GetMinVolumeLevel(volumeType);
201 reply.WriteInt32(minLevel);
202 }
203
SetSystemVolumeLevelLegacyInternal(MessageParcel & data,MessageParcel & reply)204 void AudioPolicyManagerStub::SetSystemVolumeLevelLegacyInternal(MessageParcel &data, MessageParcel &reply)
205 {
206 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
207 int32_t volumeLevel = data.ReadInt32();
208 int result = SetSystemVolumeLevelLegacy(volumeType, volumeLevel);
209 reply.WriteInt32(result);
210 }
211
SetSystemVolumeLevelInternal(MessageParcel & data,MessageParcel & reply)212 void AudioPolicyManagerStub::SetSystemVolumeLevelInternal(MessageParcel &data, MessageParcel &reply)
213 {
214 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
215 int32_t volumeLevel = data.ReadInt32();
216 int32_t volumeFlag = data.ReadInt32();
217 int result = SetSystemVolumeLevel(volumeType, volumeLevel, volumeFlag);
218 reply.WriteInt32(result);
219 }
220
SetRingerModeLegacyInternal(MessageParcel & data,MessageParcel & reply)221 void AudioPolicyManagerStub::SetRingerModeLegacyInternal(MessageParcel &data, MessageParcel &reply)
222 {
223 AudioRingerMode rMode = static_cast<AudioRingerMode>(data.ReadInt32());
224 int32_t result = SetRingerModeLegacy(rMode);
225 reply.WriteInt32(result);
226 }
227
SetRingerModeInternal(MessageParcel & data,MessageParcel & reply)228 void AudioPolicyManagerStub::SetRingerModeInternal(MessageParcel &data, MessageParcel &reply)
229 {
230 AudioRingerMode rMode = static_cast<AudioRingerMode>(data.ReadInt32());
231 int32_t result = SetRingerMode(rMode);
232 reply.WriteInt32(result);
233 }
234
235 #ifdef FEATURE_DTMF_TONE
GetToneInfoInternal(MessageParcel & data,MessageParcel & reply)236 void AudioPolicyManagerStub::GetToneInfoInternal(MessageParcel &data, MessageParcel &reply)
237 {
238 std::shared_ptr<ToneInfo> ltoneInfo = GetToneConfig(data.ReadInt32());
239 CHECK_AND_RETURN_LOG(ltoneInfo != nullptr, "obj is null");
240 ltoneInfo->Marshalling(reply);
241 }
242
GetSupportedTonesInternal(MessageParcel & data,MessageParcel & reply)243 void AudioPolicyManagerStub::GetSupportedTonesInternal(MessageParcel &data, MessageParcel &reply)
244 {
245 int32_t lToneListSize = 0;
246 std::vector<int32_t> lToneList = GetSupportedTones();
247 lToneListSize = static_cast<int32_t>(lToneList.size());
248 reply.WriteInt32(lToneListSize);
249 for (int i = 0; i < lToneListSize; i++) {
250 reply.WriteInt32(lToneList[i]);
251 }
252 }
253 #endif
254
GetRingerModeInternal(MessageParcel & data,MessageParcel & reply)255 void AudioPolicyManagerStub::GetRingerModeInternal(MessageParcel &data, MessageParcel &reply)
256 {
257 AudioRingerMode rMode = GetRingerMode();
258 reply.WriteInt32(static_cast<int>(rMode));
259 }
260
SetAudioSceneInternal(MessageParcel & data,MessageParcel & reply)261 void AudioPolicyManagerStub::SetAudioSceneInternal(MessageParcel &data, MessageParcel &reply)
262 {
263 AudioScene audioScene = static_cast<AudioScene>(data.ReadInt32());
264 int32_t result = SetAudioScene(audioScene);
265 reply.WriteInt32(result);
266 }
267
SetMicrophoneMuteInternal(MessageParcel & data,MessageParcel & reply)268 void AudioPolicyManagerStub::SetMicrophoneMuteInternal(MessageParcel &data, MessageParcel &reply)
269 {
270 bool isMute = data.ReadBool();
271 int32_t result = SetMicrophoneMute(isMute);
272 reply.WriteInt32(result);
273 }
274
SetMicrophoneMuteAudioConfigInternal(MessageParcel & data,MessageParcel & reply)275 void AudioPolicyManagerStub::SetMicrophoneMuteAudioConfigInternal(MessageParcel &data, MessageParcel &reply)
276 {
277 bool isMute = data.ReadBool();
278 int32_t result = SetMicrophoneMuteAudioConfig(isMute);
279 reply.WriteInt32(result);
280 }
281
IsMicrophoneMuteLegacyInternal(MessageParcel & data,MessageParcel & reply)282 void AudioPolicyManagerStub::IsMicrophoneMuteLegacyInternal(MessageParcel &data, MessageParcel &reply)
283 {
284 int32_t result = IsMicrophoneMuteLegacy();
285 reply.WriteBool(result);
286 }
287
IsMicrophoneMuteInternal(MessageParcel & data,MessageParcel & reply)288 void AudioPolicyManagerStub::IsMicrophoneMuteInternal(MessageParcel &data, MessageParcel &reply)
289 {
290 int32_t result = IsMicrophoneMute();
291 reply.WriteBool(result);
292 }
293
GetAudioSceneInternal(MessageParcel &,MessageParcel & reply)294 void AudioPolicyManagerStub::GetAudioSceneInternal(MessageParcel & /* data */, MessageParcel &reply)
295 {
296 AudioScene audioScene = GetAudioScene();
297 reply.WriteInt32(static_cast<int>(audioScene));
298 }
299
GetSystemActiveVolumeTypeInternal(MessageParcel & data,MessageParcel & reply)300 void AudioPolicyManagerStub::GetSystemActiveVolumeTypeInternal(MessageParcel& data, MessageParcel& reply)
301 {
302 int32_t clientUid = data.ReadInt32();
303 AudioStreamType volumeType = GetSystemActiveVolumeType(clientUid);
304 reply.WriteInt32(volumeType);
305 }
306
GetSystemVolumeLevelInternal(MessageParcel & data,MessageParcel & reply)307 void AudioPolicyManagerStub::GetSystemVolumeLevelInternal(MessageParcel &data, MessageParcel &reply)
308 {
309 AudioStreamType streamType = static_cast<AudioStreamType>(data.ReadInt32());
310 int32_t volumeLevel = GetSystemVolumeLevel(streamType);
311 reply.WriteInt32(volumeLevel);
312 }
313
SetLowPowerVolumeInternal(MessageParcel & data,MessageParcel & reply)314 void AudioPolicyManagerStub::SetLowPowerVolumeInternal(MessageParcel &data, MessageParcel &reply)
315 {
316 int32_t streamId = data.ReadInt32();
317 float volume = data.ReadFloat();
318 int result = SetLowPowerVolume(streamId, volume);
319 if (result == SUCCESS)
320 reply.WriteInt32(AUDIO_OK);
321 else
322 reply.WriteInt32(AUDIO_ERR);
323 }
324
GetLowPowerVolumeInternal(MessageParcel & data,MessageParcel & reply)325 void AudioPolicyManagerStub::GetLowPowerVolumeInternal(MessageParcel &data, MessageParcel &reply)
326 {
327 int32_t streamId = data.ReadInt32();
328 float volume = GetLowPowerVolume(streamId);
329 reply.WriteFloat(volume);
330 }
331
GetSingleStreamVolumeInternal(MessageParcel & data,MessageParcel & reply)332 void AudioPolicyManagerStub::GetSingleStreamVolumeInternal(MessageParcel &data, MessageParcel &reply)
333 {
334 int32_t streamId = data.ReadInt32();
335 float volume = GetSingleStreamVolume(streamId);
336 reply.WriteFloat(volume);
337 }
338
SetStreamMuteLegacyInternal(MessageParcel & data,MessageParcel & reply)339 void AudioPolicyManagerStub::SetStreamMuteLegacyInternal(MessageParcel &data, MessageParcel &reply)
340 {
341 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
342 bool mute = data.ReadBool();
343 int result = SetStreamMuteLegacy(volumeType, mute);
344 reply.WriteInt32(result);
345 }
346
SetStreamMuteInternal(MessageParcel & data,MessageParcel & reply)347 void AudioPolicyManagerStub::SetStreamMuteInternal(MessageParcel &data, MessageParcel &reply)
348 {
349 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
350 bool mute = data.ReadBool();
351 int result = SetStreamMute(volumeType, mute);
352 reply.WriteInt32(result);
353 }
354
GetStreamMuteInternal(MessageParcel & data,MessageParcel & reply)355 void AudioPolicyManagerStub::GetStreamMuteInternal(MessageParcel &data, MessageParcel &reply)
356 {
357 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
358 bool mute = GetStreamMute(volumeType);
359 reply.WriteBool(mute);
360 }
361
IsStreamActiveInternal(MessageParcel & data,MessageParcel & reply)362 void AudioPolicyManagerStub::IsStreamActiveInternal(MessageParcel &data, MessageParcel &reply)
363 {
364 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
365 bool isActive = IsStreamActive(volumeType);
366 reply.WriteBool(isActive);
367 }
368
AdjustVolumeByStepInternal(MessageParcel & data,MessageParcel & reply)369 void AudioPolicyManagerStub::AdjustVolumeByStepInternal(MessageParcel &data, MessageParcel &reply)
370 {
371 VolumeAdjustType adjustType = static_cast<VolumeAdjustType>(data.ReadInt32());
372 int32_t result = AdjustVolumeByStep(adjustType);
373 reply.WriteInt32(result);
374 }
375
GetSystemVolumeInDbInternal(MessageParcel & data,MessageParcel & reply)376 void AudioPolicyManagerStub::GetSystemVolumeInDbInternal(MessageParcel &data, MessageParcel &reply)
377 {
378 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
379 int32_t volumeLevel = data.ReadInt32();
380 DeviceType deviceType = static_cast<DeviceType>(data.ReadInt32());
381 float result = GetSystemVolumeInDb(volumeType, volumeLevel, deviceType);
382 reply.WriteFloat(result);
383 }
384
IsVolumeUnadjustableInternal(MessageParcel & data,MessageParcel & reply)385 void AudioPolicyManagerStub::IsVolumeUnadjustableInternal(MessageParcel &data, MessageParcel &reply)
386 {
387 bool isVolumeUnadjustable = IsVolumeUnadjustable();
388 reply.WriteBool(isVolumeUnadjustable);
389 }
390
AdjustSystemVolumeByStepInternal(MessageParcel & data,MessageParcel & reply)391 void AudioPolicyManagerStub::AdjustSystemVolumeByStepInternal(MessageParcel &data, MessageParcel &reply)
392 {
393 AudioVolumeType volumeType = static_cast<AudioVolumeType>(data.ReadInt32());
394 VolumeAdjustType adjustType = static_cast<VolumeAdjustType>(data.ReadInt32());
395 int32_t result = AdjustSystemVolumeByStep(volumeType, adjustType);
396 reply.WriteInt32(result);
397 }
398
GetDevicesInternal(MessageParcel & data,MessageParcel & reply)399 void AudioPolicyManagerStub::GetDevicesInternal(MessageParcel &data, MessageParcel &reply)
400 {
401 int deviceFlag = data.ReadInt32();
402 DeviceFlag deviceFlagConfig = static_cast<DeviceFlag>(deviceFlag);
403 std::vector<sptr<AudioDeviceDescriptor>> devices = GetDevices(deviceFlagConfig);
404 int32_t size = static_cast<int32_t>(devices.size());
405 reply.WriteInt32(size);
406 for (int i = 0; i < size; i++) {
407 devices[i]->Marshalling(reply);
408 }
409 }
410
GetDevicesInnerInternal(MessageParcel & data,MessageParcel & reply)411 void AudioPolicyManagerStub::GetDevicesInnerInternal(MessageParcel &data, MessageParcel &reply)
412 {
413 int deviceFlag = data.ReadInt32();
414 DeviceFlag deviceFlagConfig = static_cast<DeviceFlag>(deviceFlag);
415 std::vector<sptr<AudioDeviceDescriptor>> devices = GetDevicesInner(deviceFlagConfig);
416 int32_t size = static_cast<int32_t>(devices.size());
417 reply.WriteInt32(size);
418 for (int i = 0; i < size; i++) {
419 devices[i]->Marshalling(reply);
420 }
421 }
422
NotifyCapturerAddedInternal(MessageParcel & data,MessageParcel & reply)423 void AudioPolicyManagerStub::NotifyCapturerAddedInternal(MessageParcel &data, MessageParcel &reply)
424 {
425 AudioCapturerInfo capturerInfo;
426 AudioStreamInfo streamInfo;
427 uint32_t sessionId;
428
429 capturerInfo.Unmarshalling(data);
430 streamInfo.Unmarshalling(data);
431 data.ReadUint32(sessionId);
432
433 int32_t result = NotifyCapturerAdded(capturerInfo, streamInfo, sessionId);
434 reply.WriteInt32(result);
435 }
436
GetPreferredOutputDeviceDescriptorsInternal(MessageParcel & data,MessageParcel & reply)437 void AudioPolicyManagerStub::GetPreferredOutputDeviceDescriptorsInternal(MessageParcel &data, MessageParcel &reply)
438 {
439 AudioRendererInfo rendererInfo;
440 rendererInfo.Unmarshalling(data);
441 std::vector<sptr<AudioDeviceDescriptor>> devices = GetPreferredOutputDeviceDescriptors(rendererInfo);
442 int32_t size = static_cast<int32_t>(devices.size());
443 reply.WriteInt32(size);
444 for (int i = 0; i < size; i++) {
445 devices[i]->Marshalling(reply);
446 }
447 }
448
GetPreferredInputDeviceDescriptorsInternal(MessageParcel & data,MessageParcel & reply)449 void AudioPolicyManagerStub::GetPreferredInputDeviceDescriptorsInternal(MessageParcel &data, MessageParcel &reply)
450 {
451 AudioCapturerInfo captureInfo;
452 captureInfo.Unmarshalling(data);
453 std::vector<sptr<AudioDeviceDescriptor>> devices = GetPreferredInputDeviceDescriptors(captureInfo);
454 uint32_t size = static_cast<uint32_t>(devices.size());
455 reply.WriteInt32(size);
456 for (uint32_t i = 0; i < size; i++) {
457 devices[i]->Marshalling(reply);
458 }
459 }
460
SetClientCallbacksEnableInternal(MessageParcel & data,MessageParcel & reply)461 void AudioPolicyManagerStub::SetClientCallbacksEnableInternal(MessageParcel &data, MessageParcel &reply)
462 {
463 CallbackChange callbackchange = static_cast<CallbackChange>(data.ReadInt32());
464 bool enable = data.ReadBool();
465 int32_t result = SetClientCallbacksEnable(callbackchange, enable);
466 reply.WriteInt32(result);
467 }
468
SetDeviceActiveInternal(MessageParcel & data,MessageParcel & reply)469 void AudioPolicyManagerStub::SetDeviceActiveInternal(MessageParcel &data, MessageParcel &reply)
470 {
471 InternalDeviceType deviceType = static_cast<InternalDeviceType>(data.ReadInt32());
472 bool active = data.ReadBool();
473 int32_t result = SetDeviceActive(deviceType, active);
474 if (result == SUCCESS)
475 reply.WriteInt32(AUDIO_OK);
476 else
477 reply.WriteInt32(AUDIO_ERR);
478 }
479
IsDeviceActiveInternal(MessageParcel & data,MessageParcel & reply)480 void AudioPolicyManagerStub::IsDeviceActiveInternal(MessageParcel &data, MessageParcel &reply)
481 {
482 InternalDeviceType deviceType = static_cast<InternalDeviceType>(data.ReadInt32());
483 bool result = IsDeviceActive(deviceType);
484 reply.WriteBool(result);
485 }
486
GetActiveOutputDeviceInternal(MessageParcel & data,MessageParcel & reply)487 void AudioPolicyManagerStub::GetActiveOutputDeviceInternal(MessageParcel &data, MessageParcel &reply)
488 {
489 InternalDeviceType deviceType = GetActiveOutputDevice();
490 reply.WriteInt32(static_cast<int>(deviceType));
491 }
492
GetActiveInputDeviceInternal(MessageParcel & data,MessageParcel & reply)493 void AudioPolicyManagerStub::GetActiveInputDeviceInternal(MessageParcel &data, MessageParcel &reply)
494 {
495 InternalDeviceType deviceType = GetActiveInputDevice();
496 reply.WriteInt32(static_cast<int>(deviceType));
497 }
498
WriteAudioFocusInfo(MessageParcel & reply,const std::pair<AudioInterrupt,AudioFocuState> & focusInfo)499 void AudioPolicyManagerStub::WriteAudioFocusInfo(MessageParcel &reply,
500 const std::pair<AudioInterrupt, AudioFocuState> &focusInfo)
501 {
502 AudioInterrupt::Marshalling(reply, focusInfo.first);
503 reply.WriteInt32(focusInfo.second);
504 }
505
GetAudioFocusInfoListInternal(MessageParcel & data,MessageParcel & reply)506 void AudioPolicyManagerStub::GetAudioFocusInfoListInternal(MessageParcel &data, MessageParcel &reply)
507 {
508 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
509 int32_t zoneID = data.ReadInt32();
510 int32_t result = GetAudioFocusInfoList(focusInfoList, zoneID);
511 int32_t size = static_cast<int32_t>(focusInfoList.size());
512 reply.WriteInt32(result);
513 reply.WriteInt32(size);
514 if (result == SUCCESS) {
515 for (std::pair<AudioInterrupt, AudioFocuState> focusInfo : focusInfoList) {
516 WriteAudioFocusInfo(reply, focusInfo);
517 }
518 }
519 }
520
SelectOutputDeviceInternal(MessageParcel & data,MessageParcel & reply)521 void AudioPolicyManagerStub::SelectOutputDeviceInternal(MessageParcel &data, MessageParcel &reply)
522 {
523 sptr<AudioRendererFilter> audioRendererFilter = AudioRendererFilter::Unmarshalling(data);
524 CHECK_AND_RETURN_LOG(audioRendererFilter != nullptr, "AudioRendererFilter unmarshall fail.");
525
526 int validSize = 20; // Use 20 as limit.
527 int size = data.ReadInt32();
528 if (size <= 0 || size > validSize) {
529 AUDIO_ERR_LOG("SelectOutputDevice get invalid device size.");
530 return;
531 }
532 std::vector<sptr<AudioDeviceDescriptor>> targetOutputDevice;
533 for (int i = 0; i < size; i++) {
534 sptr<AudioDeviceDescriptor> audioDeviceDescriptor = AudioDeviceDescriptor::Unmarshalling(data);
535 CHECK_AND_RETURN_LOG(audioDeviceDescriptor != nullptr, "Unmarshalling fail.");
536 if (IsArmUsbDevice(*audioDeviceDescriptor)) {
537 audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
538 }
539 targetOutputDevice.push_back(audioDeviceDescriptor);
540 }
541
542 int32_t ret = SelectOutputDevice(audioRendererFilter, targetOutputDevice);
543 reply.WriteInt32(ret);
544 }
545
GetSelectedDeviceInfoInternal(MessageParcel & data,MessageParcel & reply)546 void AudioPolicyManagerStub::GetSelectedDeviceInfoInternal(MessageParcel &data, MessageParcel &reply)
547 {
548 int32_t uid = data.ReadInt32();
549 int32_t pid = data.ReadInt32();
550 AudioStreamType streamType = static_cast<AudioStreamType>(data.ReadInt32());
551
552 std::string deviceName = GetSelectedDeviceInfo(uid, pid, streamType);
553 reply.WriteString(deviceName);
554 }
555
SelectInputDeviceInternal(MessageParcel & data,MessageParcel & reply)556 void AudioPolicyManagerStub::SelectInputDeviceInternal(MessageParcel &data, MessageParcel &reply)
557 {
558 sptr<AudioCapturerFilter> audioCapturerFilter = AudioCapturerFilter::Unmarshalling(data);
559 CHECK_AND_RETURN_LOG(audioCapturerFilter != nullptr, "AudioCapturerFilter unmarshall fail.");
560
561 int validSize = 10; // Use 10 as limit.
562 int size = data.ReadInt32();
563 CHECK_AND_RETURN_LOG(size > 0 && size <= validSize, "SelectInputDevice get invalid device size.");
564 std::vector<sptr<AudioDeviceDescriptor>> targetInputDevice;
565 for (int i = 0; i < size; i++) {
566 sptr<AudioDeviceDescriptor> audioDeviceDescriptor = AudioDeviceDescriptor::Unmarshalling(data);
567 CHECK_AND_RETURN_LOG(audioDeviceDescriptor != nullptr, "Unmarshalling fail.");
568 if (IsArmUsbDevice(*audioDeviceDescriptor)) {
569 audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
570 }
571 targetInputDevice.push_back(audioDeviceDescriptor);
572 }
573
574 int32_t ret = SelectInputDevice(audioCapturerFilter, targetInputDevice);
575 reply.WriteInt32(ret);
576 }
577
SetInterruptCallbackInternal(MessageParcel & data,MessageParcel & reply)578 void AudioPolicyManagerStub::SetInterruptCallbackInternal(MessageParcel &data, MessageParcel &reply)
579 {
580 uint32_t sessionID = data.ReadUint32();
581 sptr<IRemoteObject> object = data.ReadRemoteObject();
582 uint32_t zoneID = data.ReadUint32();
583 uint32_t clientUid = data.ReadUint32();
584 CHECK_AND_RETURN_LOG(object != nullptr, "AudioPolicyManagerStub: AudioInterruptCallback obj is null");
585 int32_t result = SetAudioInterruptCallback(sessionID, object, clientUid, zoneID);
586 reply.WriteInt32(result);
587 }
588
UnsetInterruptCallbackInternal(MessageParcel & data,MessageParcel & reply)589 void AudioPolicyManagerStub::UnsetInterruptCallbackInternal(MessageParcel &data, MessageParcel &reply)
590 {
591 int32_t sessionID = data.ReadInt32();
592 int32_t zoneID = data.ReadInt32();
593 int32_t result = UnsetAudioInterruptCallback(sessionID, zoneID);
594 reply.WriteInt32(result);
595 }
596
ActivateInterruptInternal(MessageParcel & data,MessageParcel & reply)597 void AudioPolicyManagerStub::ActivateInterruptInternal(MessageParcel &data, MessageParcel &reply)
598 {
599 int32_t zoneID = data.ReadInt32();
600 bool isUpdatedAudioStrategy = data.ReadBool();
601 AudioInterrupt audioInterrupt = {};
602 AudioInterrupt::Unmarshalling(data, audioInterrupt);
603 int32_t result = ActivateAudioInterrupt(audioInterrupt, zoneID, isUpdatedAudioStrategy);
604 reply.WriteInt32(result);
605 }
606
DeactivateInterruptInternal(MessageParcel & data,MessageParcel & reply)607 void AudioPolicyManagerStub::DeactivateInterruptInternal(MessageParcel &data, MessageParcel &reply)
608 {
609 int32_t zoneID = data.ReadInt32();
610 AudioInterrupt audioInterrupt = {};
611 AudioInterrupt::Unmarshalling(data, audioInterrupt);
612 int32_t result = DeactivateAudioInterrupt(audioInterrupt, zoneID);
613 reply.WriteInt32(result);
614 }
615
SetAudioManagerInterruptCbInternal(MessageParcel & data,MessageParcel & reply)616 void AudioPolicyManagerStub::SetAudioManagerInterruptCbInternal(MessageParcel &data, MessageParcel &reply)
617 {
618 int32_t clientId = data.ReadInt32();
619 sptr<IRemoteObject> object = data.ReadRemoteObject();
620 CHECK_AND_RETURN_LOG(object != nullptr, "AudioPolicyManagerStub: AudioInterruptCallback obj is null");
621 int32_t result = SetAudioManagerInterruptCallback(clientId, object);
622 reply.WriteInt32(result);
623 }
624
UnsetAudioManagerInterruptCbInternal(MessageParcel & data,MessageParcel & reply)625 void AudioPolicyManagerStub::UnsetAudioManagerInterruptCbInternal(MessageParcel &data, MessageParcel &reply)
626 {
627 int32_t clientId = data.ReadInt32();
628 int32_t result = UnsetAudioManagerInterruptCallback(clientId);
629 reply.WriteInt32(result);
630 }
631
RequestAudioFocusInternal(MessageParcel & data,MessageParcel & reply)632 void AudioPolicyManagerStub::RequestAudioFocusInternal(MessageParcel &data, MessageParcel &reply)
633 {
634 AudioInterrupt audioInterrupt = {};
635 int32_t clientId = data.ReadInt32();
636 AudioInterrupt::Unmarshalling(data, audioInterrupt);
637 int32_t result = RequestAudioFocus(clientId, audioInterrupt);
638 reply.WriteInt32(result);
639 }
640
AbandonAudioFocusInternal(MessageParcel & data,MessageParcel & reply)641 void AudioPolicyManagerStub::AbandonAudioFocusInternal(MessageParcel &data, MessageParcel &reply)
642 {
643 AudioInterrupt audioInterrupt = {};
644 int32_t clientId = data.ReadInt32();
645 AudioInterrupt::Unmarshalling(data, audioInterrupt);
646 int32_t result = AbandonAudioFocus(clientId, audioInterrupt);
647 reply.WriteInt32(result);
648 }
649
GetStreamInFocusInternal(MessageParcel & data,MessageParcel & reply)650 void AudioPolicyManagerStub::GetStreamInFocusInternal(MessageParcel &data, MessageParcel &reply)
651 {
652 int32_t zoneID = data.ReadInt32();
653 AudioStreamType streamInFocus = GetStreamInFocus(zoneID);
654 reply.WriteInt32(static_cast<int32_t>(streamInFocus));
655 }
656
GetSessionInfoInFocusInternal(MessageParcel & data,MessageParcel & reply)657 void AudioPolicyManagerStub::GetSessionInfoInFocusInternal(MessageParcel &data, MessageParcel &reply)
658 {
659 uint32_t invalidSessionID = static_cast<uint32_t>(-1);
660 AudioInterrupt audioInterrupt {STREAM_USAGE_UNKNOWN, CONTENT_TYPE_UNKNOWN,
661 {AudioStreamType::STREAM_DEFAULT, SourceType::SOURCE_TYPE_INVALID, true}, invalidSessionID};
662 int32_t zoneID = data.ReadInt32();
663 int32_t ret = GetSessionInfoInFocus(audioInterrupt, zoneID);
664 AudioInterrupt::Marshalling(reply, audioInterrupt);
665 reply.WriteInt32(ret);
666 }
667
CheckRecordingCreateInternal(MessageParcel & data,MessageParcel & reply)668 void AudioPolicyManagerStub::CheckRecordingCreateInternal(MessageParcel &data, MessageParcel &reply)
669 {
670 uint32_t appTokenId = data.ReadUint32();
671 uint64_t appFullTokenId = data.ReadUint64();
672 int32_t appUid = data.ReadInt32();
673 SourceType sourceType = static_cast<SourceType> (data.ReadInt32());
674 bool ret = CheckRecordingCreate(appTokenId, appFullTokenId, appUid, sourceType);
675 reply.WriteBool(ret);
676 }
677
CheckRecordingStateChangeInternal(MessageParcel & data,MessageParcel & reply)678 void AudioPolicyManagerStub::CheckRecordingStateChangeInternal(MessageParcel &data, MessageParcel &reply)
679 {
680 uint32_t appTokenId = data.ReadUint32();
681 uint64_t appFullTokenId = data.ReadUint64();
682 int32_t appUid = data.ReadInt32();
683 AudioPermissionState state = static_cast<AudioPermissionState>(data.ReadInt32());
684 bool ret = CheckRecordingStateChange(appTokenId, appFullTokenId, appUid, state);
685 reply.WriteBool(ret);
686 }
687
GetAudioLatencyFromXmlInternal(MessageParcel & data,MessageParcel & reply)688 void AudioPolicyManagerStub::GetAudioLatencyFromXmlInternal(MessageParcel &data, MessageParcel &reply)
689 {
690 int ret = GetAudioLatencyFromXml();
691 reply.WriteInt32(ret);
692 }
693
GetSinkLatencyFromXmlInternal(MessageParcel & data,MessageParcel & reply)694 void AudioPolicyManagerStub::GetSinkLatencyFromXmlInternal(MessageParcel &data, MessageParcel &reply)
695 {
696 uint32_t ret = GetSinkLatencyFromXml();
697 reply.WriteUint32(ret);
698 }
699
GetPreferredOutputStreamTypeInternal(MessageParcel & data,MessageParcel & reply)700 void AudioPolicyManagerStub::GetPreferredOutputStreamTypeInternal(MessageParcel &data, MessageParcel &reply)
701 {
702 AudioRendererInfo rendererInfo;
703 rendererInfo.Unmarshalling(data);
704 int32_t result = GetPreferredOutputStreamType(rendererInfo);
705 reply.WriteInt32(result);
706 }
707
GetPreferredInputStreamTypeInternal(MessageParcel & data,MessageParcel & reply)708 void AudioPolicyManagerStub::GetPreferredInputStreamTypeInternal(MessageParcel &data, MessageParcel &reply)
709 {
710 AudioCapturerInfo capturerInfo;
711 capturerInfo.Unmarshalling(data);
712 int32_t result = GetPreferredInputStreamType(capturerInfo);
713 reply.WriteInt32(result);
714 }
715
ReconfigureAudioChannelInternal(MessageParcel & data,MessageParcel & reply)716 void AudioPolicyManagerStub::ReconfigureAudioChannelInternal(MessageParcel &data, MessageParcel &reply)
717 {
718 uint32_t count = data.ReadUint32();
719 DeviceType deviceType = static_cast<DeviceType>(data.ReadInt32());
720 int32_t ret = ReconfigureAudioChannel(count, deviceType);
721 reply.WriteInt32(ret);
722 }
723
RegisterTrackerInternal(MessageParcel & data,MessageParcel & reply)724 void AudioPolicyManagerStub::RegisterTrackerInternal(MessageParcel &data, MessageParcel &reply)
725 {
726 AudioStreamChangeInfo streamChangeInfo = {};
727 AudioMode mode = static_cast<AudioMode> (data.ReadInt32());
728 ReadStreamChangeInfo(data, mode, streamChangeInfo);
729 sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
730 CHECK_AND_RETURN_LOG(remoteObject != nullptr, "Client Tracker obj is null");
731
732 int ret = RegisterTracker(mode, streamChangeInfo, remoteObject);
733 reply.WriteInt32(ret);
734 }
735
UpdateTrackerInternal(MessageParcel & data,MessageParcel & reply)736 void AudioPolicyManagerStub::UpdateTrackerInternal(MessageParcel &data, MessageParcel &reply)
737 {
738 AudioStreamChangeInfo streamChangeInfo = {};
739 AudioMode mode = static_cast<AudioMode> (data.ReadInt32());
740 ReadStreamChangeInfo(data, mode, streamChangeInfo);
741 int ret = UpdateTracker(mode, streamChangeInfo);
742 reply.WriteInt32(ret);
743 }
744
GetRendererChangeInfosInternal(MessageParcel & data,MessageParcel & reply)745 void AudioPolicyManagerStub::GetRendererChangeInfosInternal(MessageParcel &data, MessageParcel &reply)
746 {
747 size_t size = 0;
748 std::vector<std::unique_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
749 int ret = GetCurrentRendererChangeInfos(audioRendererChangeInfos);
750 if (ret != SUCCESS) {
751 AUDIO_ERR_LOG("AudioPolicyManagerStub:GetRendererChangeInfos Error!!");
752 reply.WriteInt32(size);
753 return;
754 }
755
756 size = audioRendererChangeInfos.size();
757 reply.WriteInt32(size);
758 for (const std::unique_ptr<AudioRendererChangeInfo> &rendererChangeInfo: audioRendererChangeInfos) {
759 if (!rendererChangeInfo) {
760 AUDIO_ERR_LOG("AudioPolicyManagerStub:Renderer change info null, something wrong!!");
761 continue;
762 }
763 rendererChangeInfo->Marshalling(reply);
764 }
765 }
766
GetCapturerChangeInfosInternal(MessageParcel & data,MessageParcel & reply)767 void AudioPolicyManagerStub::GetCapturerChangeInfosInternal(MessageParcel &data, MessageParcel &reply)
768 {
769 size_t size = 0;
770 std::vector<std::unique_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
771 int32_t ret = GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
772 if (ret != SUCCESS) {
773 AUDIO_ERR_LOG("AudioPolicyManagerStub:GetCapturerChangeInfos Error!!");
774 reply.WriteInt32(size);
775 return;
776 }
777
778 size = audioCapturerChangeInfos.size();
779 reply.WriteInt32(size);
780 for (const std::unique_ptr<AudioCapturerChangeInfo> &capturerChangeInfo: audioCapturerChangeInfos) {
781 if (!capturerChangeInfo) {
782 AUDIO_ERR_LOG("AudioPolicyManagerStub:Capturer change info null, something wrong!!");
783 continue;
784 }
785 capturerChangeInfo->Marshalling(reply);
786 }
787 }
788
UpdateStreamStateInternal(MessageParcel & data,MessageParcel & reply)789 void AudioPolicyManagerStub::UpdateStreamStateInternal(MessageParcel &data, MessageParcel &reply)
790 {
791 int32_t clientUid = data.ReadInt32();
792 StreamSetState streamSetState = static_cast<StreamSetState>(data.ReadInt32());
793 StreamUsage streamUsage = static_cast<StreamUsage>(data.ReadInt32());
794
795 int32_t result = UpdateStreamState(clientUid, streamSetState, streamUsage);
796 reply.WriteInt32(result);
797 }
798
GetVolumeGroupInfoInternal(MessageParcel & data,MessageParcel & reply)799 void AudioPolicyManagerStub::GetVolumeGroupInfoInternal(MessageParcel& data, MessageParcel& reply)
800 {
801 std::string networkId = data.ReadString();
802 std::vector<sptr<VolumeGroupInfo>> groupInfos;
803 int32_t ret = GetVolumeGroupInfos(networkId, groupInfos);
804 int32_t size = static_cast<int32_t>(groupInfos.size());
805 if (ret == SUCCESS && size > 0) {
806 reply.WriteInt32(size);
807 for (int i = 0; i < size; i++) {
808 groupInfos[i]->Marshalling(reply);
809 }
810 } else {
811 reply.WriteInt32(ret);
812 }
813 }
814
GetNetworkIdByGroupIdInternal(MessageParcel & data,MessageParcel & reply)815 void AudioPolicyManagerStub::GetNetworkIdByGroupIdInternal(MessageParcel& data, MessageParcel& reply)
816 {
817 int32_t groupId = data.ReadInt32();
818 std::string networkId;
819 int32_t ret = GetNetworkIdByGroupId(groupId, networkId);
820
821 reply.WriteString(networkId);
822 reply.WriteInt32(ret);
823 }
824
IsAudioRendererLowLatencySupportedInternal(MessageParcel & data,MessageParcel & reply)825 void AudioPolicyManagerStub::IsAudioRendererLowLatencySupportedInternal(MessageParcel &data, MessageParcel &reply)
826 {
827 AudioStreamInfo audioStreamInfo = {};
828 audioStreamInfo.samplingRate = static_cast<AudioSamplingRate>(data.ReadInt32());
829 audioStreamInfo.channels = static_cast<AudioChannel>(data.ReadInt32());
830 audioStreamInfo.format = static_cast<OHOS::AudioStandard::AudioSampleFormat>(data.ReadInt32());
831 audioStreamInfo.encoding = static_cast<AudioEncodingType>(data.ReadInt32());
832 bool isSupported = IsAudioRendererLowLatencySupported(audioStreamInfo);
833 reply.WriteBool(isSupported);
834 }
835
SetSystemSoundUriInternal(MessageParcel & data,MessageParcel & reply)836 void AudioPolicyManagerStub::SetSystemSoundUriInternal(MessageParcel &data, MessageParcel &reply)
837 {
838 std::string key = data.ReadString();
839 std::string value = data.ReadString();
840 int32_t result = SetSystemSoundUri(key, value);
841 reply.WriteInt32(result);
842 }
843
GetSystemSoundUriInternal(MessageParcel & data,MessageParcel & reply)844 void AudioPolicyManagerStub::GetSystemSoundUriInternal(MessageParcel &data, MessageParcel &reply)
845 {
846 std::string key = data.ReadString();
847 std::string result = GetSystemSoundUri(key);
848 reply.WriteString(result);
849 }
850
GetMinStreamVolumeInternal(MessageParcel & data,MessageParcel & reply)851 void AudioPolicyManagerStub::GetMinStreamVolumeInternal(MessageParcel &data, MessageParcel &reply)
852 {
853 float volume = GetMinStreamVolume();
854 reply.WriteFloat(volume);
855 }
856
GetMaxStreamVolumeInternal(MessageParcel & data,MessageParcel & reply)857 void AudioPolicyManagerStub::GetMaxStreamVolumeInternal(MessageParcel &data, MessageParcel &reply)
858 {
859 float volume = GetMaxStreamVolume();
860 reply.WriteFloat(volume);
861 }
862
CheckMaxRendererInstancesInternal(MessageParcel & data,MessageParcel & reply)863 void AudioPolicyManagerStub::CheckMaxRendererInstancesInternal(MessageParcel &data, MessageParcel &reply)
864 {
865 int32_t result = CheckMaxRendererInstances();
866 reply.WriteInt32(result);
867 }
868
PreprocessMode(SupportedEffectConfig & supportedEffectConfig,MessageParcel & reply,int32_t i,int32_t j)869 static void PreprocessMode(SupportedEffectConfig &supportedEffectConfig, MessageParcel &reply, int32_t i, int32_t j)
870 {
871 reply.WriteString(supportedEffectConfig.preProcessNew.stream[i].streamEffectMode[j].mode);
872 uint32_t countDev = supportedEffectConfig.preProcessNew.stream[i].streamEffectMode[j].devicePort.size();
873 reply.WriteInt32(countDev);
874 if (countDev > 0) {
875 for (uint32_t k = 0; k < countDev; k++) {
876 reply.WriteString(supportedEffectConfig.preProcessNew.stream[i].streamEffectMode[j].devicePort[k].type);
877 reply.WriteString(supportedEffectConfig.preProcessNew.stream[i].streamEffectMode[j].devicePort[k].chain);
878 }
879 }
880 }
PreprocessProcess(SupportedEffectConfig & supportedEffectConfig,MessageParcel & reply,int32_t i)881 static void PreprocessProcess(SupportedEffectConfig &supportedEffectConfig, MessageParcel &reply, int32_t i)
882 {
883 reply.WriteString(supportedEffectConfig.preProcessNew.stream[i].scene);
884 uint32_t countMode = supportedEffectConfig.preProcessNew.stream[i].streamEffectMode.size();
885 reply.WriteInt32(countMode);
886 if (countMode > 0) {
887 for (uint32_t j = 0; j < countMode; j++) {
888 PreprocessMode(supportedEffectConfig, reply, i, j);
889 }
890 }
891 }
PostprocessMode(SupportedEffectConfig & supportedEffectConfig,MessageParcel & reply,int32_t i,int32_t j)892 static void PostprocessMode(SupportedEffectConfig &supportedEffectConfig, MessageParcel &reply, int32_t i, int32_t j)
893 {
894 reply.WriteString(supportedEffectConfig.postProcessNew.stream[i].streamEffectMode[j].mode);
895 uint32_t countDev = supportedEffectConfig.postProcessNew.stream[i].streamEffectMode[j].devicePort.size();
896 reply.WriteInt32(countDev);
897 if (countDev > 0) {
898 for (uint32_t k = 0; k < countDev; k++) {
899 reply.WriteString(supportedEffectConfig.postProcessNew.stream[i].streamEffectMode[j].devicePort[k].type);
900 reply.WriteString(supportedEffectConfig.postProcessNew.stream[i].streamEffectMode[j].devicePort[k].chain);
901 }
902 }
903 }
PostprocessProcess(SupportedEffectConfig & supportedEffectConfig,MessageParcel & reply,int32_t i)904 static void PostprocessProcess(SupportedEffectConfig &supportedEffectConfig, MessageParcel &reply, int32_t i)
905 {
906 // i th stream
907 reply.WriteString(supportedEffectConfig.postProcessNew.stream[i].scene);
908 uint32_t countMode = supportedEffectConfig.postProcessNew.stream[i].streamEffectMode.size();
909 reply.WriteInt32(countMode);
910 if (countMode > 0) {
911 for (uint32_t j = 0; j < countMode; j++) {
912 PostprocessMode(supportedEffectConfig, reply, i, j);
913 }
914 }
915 }
916
QueryEffectSceneModeInternal(MessageParcel & data,MessageParcel & reply)917 void AudioPolicyManagerStub::QueryEffectSceneModeInternal(MessageParcel &data, MessageParcel &reply)
918 {
919 uint32_t i;
920 SupportedEffectConfig supportedEffectConfig;
921 int32_t ret = QueryEffectSceneMode(supportedEffectConfig); // audio_policy_server.cpp
922 CHECK_AND_RETURN_LOG(ret != -1, "default mode is unavailable !");
923
924 uint32_t countPre = supportedEffectConfig.preProcessNew.stream.size();
925 uint32_t countPost = supportedEffectConfig.postProcessNew.stream.size();
926 uint32_t countPostMap = supportedEffectConfig.postProcessSceneMap.size();
927 reply.WriteUint32(countPre);
928 reply.WriteUint32(countPost);
929 reply.WriteUint32(countPostMap);
930 if (countPre > 0) {
931 for (i = 0; i < countPre; i++) {
932 PreprocessProcess(supportedEffectConfig, reply, i);
933 }
934 }
935 if (countPost > 0) {
936 for (i = 0; i < countPost; i++) {
937 PostprocessProcess(supportedEffectConfig, reply, i);
938 }
939 }
940 if (countPostMap > 0) {
941 for (i = 0; i < countPostMap; i++) {
942 reply.WriteString(supportedEffectConfig.postProcessSceneMap[i].name);
943 reply.WriteString(supportedEffectConfig.postProcessSceneMap[i].sceneType);
944 }
945 }
946 }
947
SetPlaybackCapturerFilterInfosInternal(MessageParcel & data,MessageParcel & reply)948 void AudioPolicyManagerStub::SetPlaybackCapturerFilterInfosInternal(MessageParcel &data, MessageParcel &reply)
949 {
950 uint32_t maxUsageNum = 30;
951 AudioPlaybackCaptureConfig config;
952 int32_t flag = data.ReadInt32();
953 if (flag == 1) {
954 config.silentCapture = true;
955 }
956 uint32_t ss = data.ReadUint32();
957 if (ss >= maxUsageNum) {
958 reply.WriteInt32(ERROR);
959 return;
960 }
961 for (uint32_t i = 0; i < ss; i++) {
962 int32_t tmp_usage = data.ReadInt32();
963 if (std::find(AUDIO_SUPPORTED_STREAM_USAGES.begin(), AUDIO_SUPPORTED_STREAM_USAGES.end(), tmp_usage) ==
964 AUDIO_SUPPORTED_STREAM_USAGES.end()) {
965 continue;
966 }
967 config.filterOptions.usages.push_back(static_cast<StreamUsage>(tmp_usage));
968 }
969 uint32_t appTokenId = data.ReadUint32();
970
971 int32_t ret = SetPlaybackCapturerFilterInfos(config, appTokenId);
972 reply.WriteInt32(ret);
973 }
974
SetCaptureSilentStateInternal(MessageParcel & data,MessageParcel & reply)975 void AudioPolicyManagerStub::SetCaptureSilentStateInternal(MessageParcel &data, MessageParcel &reply)
976 {
977 bool flag = data.ReadBool();
978
979 int32_t ret = SetCaptureSilentState(flag);
980 reply.WriteInt32(ret);
981 }
982
GetHardwareOutputSamplingRateInternal(MessageParcel & data,MessageParcel & reply)983 void AudioPolicyManagerStub::GetHardwareOutputSamplingRateInternal(MessageParcel &data, MessageParcel &reply)
984 {
985 sptr<AudioDeviceDescriptor> audioDeviceDescriptor = AudioDeviceDescriptor::Unmarshalling(data);
986 CHECK_AND_RETURN_LOG(audioDeviceDescriptor != nullptr, "Unmarshalling fail.");
987
988 if (IsArmUsbDevice(*audioDeviceDescriptor)) {
989 audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
990 }
991 int32_t result = GetHardwareOutputSamplingRate(audioDeviceDescriptor);
992 reply.WriteInt32(result);
993 }
994
GetAudioCapturerMicrophoneDescriptorsInternal(MessageParcel & data,MessageParcel & reply)995 void AudioPolicyManagerStub::GetAudioCapturerMicrophoneDescriptorsInternal(MessageParcel &data, MessageParcel &reply)
996 {
997 int32_t sessionId = data.ReadInt32();
998 std::vector<sptr<MicrophoneDescriptor>> descs = GetAudioCapturerMicrophoneDescriptors(sessionId);
999 int32_t size = static_cast<int32_t>(descs.size());
1000 reply.WriteInt32(size);
1001 for (int i = 0; i < size; i++) {
1002 descs[i]->Marshalling(reply);
1003 }
1004 }
1005
GetAvailableMicrophonesInternal(MessageParcel & data,MessageParcel & reply)1006 void AudioPolicyManagerStub::GetAvailableMicrophonesInternal(MessageParcel &data, MessageParcel &reply)
1007 {
1008 std::vector<sptr<MicrophoneDescriptor>> descs = GetAvailableMicrophones();
1009 int32_t size = static_cast<int32_t>(descs.size());
1010 reply.WriteInt32(size);
1011 for (int i = 0; i < size; i++) {
1012 descs[i]->Marshalling(reply);
1013 }
1014 }
1015
SetDeviceAbsVolumeSupportedInternal(MessageParcel & data,MessageParcel & reply)1016 void AudioPolicyManagerStub::SetDeviceAbsVolumeSupportedInternal(MessageParcel &data, MessageParcel &reply)
1017 {
1018 std::string macAddress = data.ReadString();
1019 bool support = data.ReadBool();
1020 int32_t result = SetDeviceAbsVolumeSupported(macAddress, support);
1021 reply.WriteInt32(result);
1022 }
1023
IsAbsVolumeSceneInternal(MessageParcel & data,MessageParcel & reply)1024 void AudioPolicyManagerStub::IsAbsVolumeSceneInternal(MessageParcel &data, MessageParcel &reply)
1025 {
1026 bool result = IsAbsVolumeScene();
1027 reply.WriteBool(result);
1028 }
1029
IsVgsVolumeSupportedInternal(MessageParcel & data,MessageParcel & reply)1030 void AudioPolicyManagerStub::IsVgsVolumeSupportedInternal(MessageParcel &data, MessageParcel &reply)
1031 {
1032 bool result = IsVgsVolumeSupported();
1033 reply.WriteBool(result);
1034 }
1035
SetA2dpDeviceVolumeInternal(MessageParcel & data,MessageParcel & reply)1036 void AudioPolicyManagerStub::SetA2dpDeviceVolumeInternal(MessageParcel &data, MessageParcel &reply)
1037 {
1038 std::string macAddress = data.ReadString();
1039 int32_t volume = data.ReadInt32();
1040 bool updateUi = data.ReadBool();
1041 int32_t result = SetA2dpDeviceVolume(macAddress, volume, updateUi);
1042 reply.WriteInt32(result);
1043 }
1044
GetAvailableDevicesInternal(MessageParcel & data,MessageParcel & reply)1045 void AudioPolicyManagerStub::GetAvailableDevicesInternal(MessageParcel &data, MessageParcel &reply)
1046 {
1047 AudioDeviceUsage usage = static_cast<AudioDeviceUsage>(data.ReadInt32());
1048 std::vector<std::unique_ptr<AudioDeviceDescriptor>> descs = GetAvailableDevices(usage);
1049 int32_t size = static_cast<int32_t>(descs.size());
1050 reply.WriteInt32(size);
1051 for (int32_t i = 0; i < size; i++) {
1052 descs[i]->Marshalling(reply);
1053 }
1054 }
1055
SetAvailableDeviceChangeCallbackInternal(MessageParcel & data,MessageParcel & reply)1056 void AudioPolicyManagerStub::SetAvailableDeviceChangeCallbackInternal(MessageParcel &data, MessageParcel &reply)
1057 {
1058 int32_t clientId = data.ReadInt32();
1059 AudioDeviceUsage usage = static_cast<AudioDeviceUsage>(data.ReadInt32());
1060 sptr<IRemoteObject> object = data.ReadRemoteObject();
1061 CHECK_AND_RETURN_LOG(object != nullptr, "AudioInterruptCallback obj is null");
1062 int32_t result = SetAvailableDeviceChangeCallback(clientId, usage, object);
1063 reply.WriteInt32(result);
1064 }
1065
UnsetAvailableDeviceChangeCallbackInternal(MessageParcel & data,MessageParcel & reply)1066 void AudioPolicyManagerStub::UnsetAvailableDeviceChangeCallbackInternal(MessageParcel &data, MessageParcel &reply)
1067 {
1068 int32_t clientId = data.ReadInt32();
1069 AudioDeviceUsage usage = static_cast<AudioDeviceUsage>(data.ReadInt32());
1070 int32_t result = UnsetAvailableDeviceChangeCallback(clientId, usage);
1071 reply.WriteInt32(result);
1072 }
1073
ConfigDistributedRoutingRoleInternal(MessageParcel & data,MessageParcel & reply)1074 void AudioPolicyManagerStub::ConfigDistributedRoutingRoleInternal(MessageParcel &data, MessageParcel &reply)
1075 {
1076 sptr<AudioDeviceDescriptor> descriptor = AudioDeviceDescriptor::Unmarshalling(data);
1077 if (IsArmUsbDevice(*descriptor)) {
1078 descriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
1079 }
1080 CastType type = static_cast<CastType>(data.ReadInt32());
1081 int32_t result = ConfigDistributedRoutingRole(descriptor, type);
1082 reply.WriteInt32(result);
1083 }
1084
SetDistributedRoutingRoleCallbackInternal(MessageParcel & data,MessageParcel & reply)1085 void AudioPolicyManagerStub::SetDistributedRoutingRoleCallbackInternal(MessageParcel &data, MessageParcel &reply)
1086 {
1087 sptr<IRemoteObject> object = data.ReadRemoteObject();
1088 CHECK_AND_RETURN_LOG(object != nullptr, "SetDistributedRoutingRoleCallback obj is null");
1089 int32_t result = SetDistributedRoutingRoleCallback(object);
1090 reply.WriteInt32(result);
1091 }
1092
UnsetDistributedRoutingRoleCallbackInternal(MessageParcel & data,MessageParcel & reply)1093 void AudioPolicyManagerStub::UnsetDistributedRoutingRoleCallbackInternal(MessageParcel &data, MessageParcel &reply)
1094 {
1095 int32_t result = UnsetDistributedRoutingRoleCallback();
1096 reply.WriteInt32(result);
1097 }
1098
IsSpatializationEnabledInternal(MessageParcel & data,MessageParcel & reply)1099 void AudioPolicyManagerStub::IsSpatializationEnabledInternal(MessageParcel &data, MessageParcel &reply)
1100 {
1101 bool result = IsSpatializationEnabled();
1102 reply.WriteBool(result);
1103 }
1104
IsSpatializationEnabledForDeviceInternal(MessageParcel & data,MessageParcel & reply)1105 void AudioPolicyManagerStub::IsSpatializationEnabledForDeviceInternal(MessageParcel &data, MessageParcel &reply)
1106 {
1107 std::string address = data.ReadString();
1108 bool result = IsSpatializationEnabled(address);
1109 reply.WriteBool(result);
1110 }
1111
SetSpatializationEnabledInternal(MessageParcel & data,MessageParcel & reply)1112 void AudioPolicyManagerStub::SetSpatializationEnabledInternal(MessageParcel &data, MessageParcel &reply)
1113 {
1114 bool enable = data.ReadBool();
1115 int32_t result = SetSpatializationEnabled(enable);
1116 reply.WriteInt32(result);
1117 }
1118
SetSpatializationEnabledForDeviceInternal(MessageParcel & data,MessageParcel & reply)1119 void AudioPolicyManagerStub::SetSpatializationEnabledForDeviceInternal(MessageParcel &data, MessageParcel &reply)
1120 {
1121 sptr<AudioDeviceDescriptor> audioDeviceDescriptor = AudioDeviceDescriptor::Unmarshalling(data);
1122 CHECK_AND_RETURN_LOG(audioDeviceDescriptor != nullptr, "Unmarshalling fail.");
1123 if (IsArmUsbDevice(*audioDeviceDescriptor)) {
1124 audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
1125 }
1126 bool enable = data.ReadBool();
1127 int32_t result = SetSpatializationEnabled(audioDeviceDescriptor, enable);
1128 reply.WriteInt32(result);
1129 }
1130
IsHeadTrackingEnabledInternal(MessageParcel & data,MessageParcel & reply)1131 void AudioPolicyManagerStub::IsHeadTrackingEnabledInternal(MessageParcel &data, MessageParcel &reply)
1132 {
1133 bool result = IsHeadTrackingEnabled();
1134 reply.WriteBool(result);
1135 }
1136
IsHeadTrackingEnabledForDeviceInternal(MessageParcel & data,MessageParcel & reply)1137 void AudioPolicyManagerStub::IsHeadTrackingEnabledForDeviceInternal(MessageParcel &data, MessageParcel &reply)
1138 {
1139 std::string address = data.ReadString();
1140 bool result = IsHeadTrackingEnabled(address);
1141 reply.WriteBool(result);
1142 }
1143
SetHeadTrackingEnabledInternal(MessageParcel & data,MessageParcel & reply)1144 void AudioPolicyManagerStub::SetHeadTrackingEnabledInternal(MessageParcel &data, MessageParcel &reply)
1145 {
1146 bool enable = data.ReadBool();
1147 int32_t result = SetHeadTrackingEnabled(enable);
1148 reply.WriteInt32(result);
1149 }
1150
SetHeadTrackingEnabledForDeviceInternal(MessageParcel & data,MessageParcel & reply)1151 void AudioPolicyManagerStub::SetHeadTrackingEnabledForDeviceInternal(MessageParcel &data, MessageParcel &reply)
1152 {
1153 sptr<AudioDeviceDescriptor> audioDeviceDescriptor = AudioDeviceDescriptor::Unmarshalling(data);
1154 CHECK_AND_RETURN_LOG(audioDeviceDescriptor != nullptr, "Unmarshalling fail.");
1155
1156 if (IsArmUsbDevice(*audioDeviceDescriptor)) {
1157 audioDeviceDescriptor->deviceType_ = DEVICE_TYPE_USB_ARM_HEADSET;
1158 }
1159 bool enable = data.ReadBool();
1160 int32_t result = SetHeadTrackingEnabled(audioDeviceDescriptor, enable);
1161 reply.WriteInt32(result);
1162 }
1163
GetSpatializationStateInternal(MessageParcel & data,MessageParcel & reply)1164 void AudioPolicyManagerStub::GetSpatializationStateInternal(MessageParcel &data, MessageParcel &reply)
1165 {
1166 StreamUsage streamUsage = static_cast<StreamUsage>(data.ReadInt32());
1167 AudioSpatializationState spatializationState = GetSpatializationState(streamUsage);
1168 reply.WriteBool(spatializationState.spatializationEnabled);
1169 reply.WriteBool(spatializationState.headTrackingEnabled);
1170 }
1171
IsSpatializationSupportedInternal(MessageParcel & data,MessageParcel & reply)1172 void AudioPolicyManagerStub::IsSpatializationSupportedInternal(MessageParcel &data, MessageParcel &reply)
1173 {
1174 bool isSupported = IsSpatializationSupported();
1175 reply.WriteBool(isSupported);
1176 }
1177
IsSpatializationSupportedForDeviceInternal(MessageParcel & data,MessageParcel & reply)1178 void AudioPolicyManagerStub::IsSpatializationSupportedForDeviceInternal(MessageParcel &data, MessageParcel &reply)
1179 {
1180 std::string address = data.ReadString();
1181 bool result = IsSpatializationSupportedForDevice(address);
1182 reply.WriteBool(result);
1183 }
1184
IsHeadTrackingSupportedInternal(MessageParcel & data,MessageParcel & reply)1185 void AudioPolicyManagerStub::IsHeadTrackingSupportedInternal(MessageParcel &data, MessageParcel &reply)
1186 {
1187 bool isSupported = IsHeadTrackingSupported();
1188 reply.WriteBool(isSupported);
1189 }
1190
IsHeadTrackingSupportedForDeviceInternal(MessageParcel & data,MessageParcel & reply)1191 void AudioPolicyManagerStub::IsHeadTrackingSupportedForDeviceInternal(MessageParcel &data, MessageParcel &reply)
1192 {
1193 std::string address = data.ReadString();
1194 bool result = IsHeadTrackingSupportedForDevice(address);
1195 reply.WriteBool(result);
1196 }
1197
UpdateSpatialDeviceStateInternal(MessageParcel & data,MessageParcel & reply)1198 void AudioPolicyManagerStub::UpdateSpatialDeviceStateInternal(MessageParcel &data, MessageParcel &reply)
1199 {
1200 AudioSpatialDeviceState audioSpatialDeviceState;
1201 audioSpatialDeviceState.address = data.ReadString();
1202 audioSpatialDeviceState.isSpatializationSupported = data.ReadBool();
1203 audioSpatialDeviceState.isHeadTrackingSupported = data.ReadBool();
1204 audioSpatialDeviceState.spatialDeviceType = static_cast<AudioSpatialDeviceType>(data.ReadInt32());
1205 int32_t result = UpdateSpatialDeviceState(audioSpatialDeviceState);
1206 reply.WriteInt32(result);
1207 }
1208
RegisterSpatializationStateEventListenerInternal(MessageParcel & data,MessageParcel & reply)1209 void AudioPolicyManagerStub::RegisterSpatializationStateEventListenerInternal(MessageParcel &data,
1210 MessageParcel &reply)
1211 {
1212 uint32_t sessionID = static_cast<uint32_t>(data.ReadInt32());
1213 StreamUsage streamUsage = static_cast<StreamUsage>(data.ReadInt32());
1214 sptr<IRemoteObject> remoteObject = data.ReadRemoteObject();
1215 CHECK_AND_RETURN_LOG(remoteObject != nullptr, "AudioSpatializationStateChangeCallback obj is null");
1216 int32_t ret = RegisterSpatializationStateEventListener(sessionID, streamUsage, remoteObject);
1217 reply.WriteInt32(ret);
1218 }
1219
UnregisterSpatializationStateEventListenerInternal(MessageParcel & data,MessageParcel & reply)1220 void AudioPolicyManagerStub::UnregisterSpatializationStateEventListenerInternal(MessageParcel &data,
1221 MessageParcel &reply)
1222 {
1223 uint32_t sessionID = static_cast<uint32_t>(data.ReadInt32());
1224 int32_t ret = UnregisterSpatializationStateEventListener(sessionID);
1225 reply.WriteInt32(ret);
1226 }
1227
RegisterPolicyCallbackClientInternal(MessageParcel & data,MessageParcel & reply)1228 void AudioPolicyManagerStub::RegisterPolicyCallbackClientInternal(MessageParcel &data, MessageParcel &reply)
1229 {
1230 sptr<IRemoteObject> object = data.ReadRemoteObject();
1231 int32_t zoneID = data.ReadInt32();
1232 CHECK_AND_RETURN_LOG(object != nullptr, "RegisterPolicyCallbackClientInternal obj is null");
1233 int32_t result = RegisterPolicyCallbackClient(object, zoneID);
1234 reply.WriteInt32(result);
1235 }
1236
ActivateAudioSessionInternal(MessageParcel & data,MessageParcel & reply)1237 void AudioPolicyManagerStub::ActivateAudioSessionInternal(MessageParcel &data, MessageParcel &reply)
1238 {
1239 AudioSessionStrategy strategy;
1240 strategy.concurrencyMode = static_cast<AudioConcurrencyMode>(data.ReadInt32());
1241 int32_t result = ActivateAudioSession(strategy);
1242 reply.WriteInt32(result);
1243 }
1244
DeactivateAudioSessionInternal(MessageParcel & data,MessageParcel & reply)1245 void AudioPolicyManagerStub::DeactivateAudioSessionInternal(MessageParcel &data, MessageParcel &reply)
1246 {
1247 int32_t result = DeactivateAudioSession();
1248 reply.WriteInt32(result);
1249 }
1250
IsAudioSessionActivatedInternal(MessageParcel & data,MessageParcel & reply)1251 void AudioPolicyManagerStub::IsAudioSessionActivatedInternal(MessageParcel &data, MessageParcel &reply)
1252 {
1253 bool result = IsAudioSessionActivated();
1254 reply.WriteBool(result);
1255 }
1256
CreateAudioInterruptZoneInternal(MessageParcel & data,MessageParcel & reply)1257 void AudioPolicyManagerStub::CreateAudioInterruptZoneInternal(MessageParcel &data, MessageParcel &reply)
1258 {
1259 std::set<int32_t> pids;
1260 int32_t zoneID = data.ReadInt32();
1261 int32_t pidsSize = data.ReadInt32();
1262 pidsSize = pidsSize > MAX_PID_COUNT ? MAX_PID_COUNT : pidsSize;
1263 if (pidsSize > 0) {
1264 for (int32_t i = 0; i < pidsSize; i ++) {
1265 pids.insert(data.ReadInt32());
1266 }
1267 }
1268 int32_t result = CreateAudioInterruptZone(pids, zoneID);
1269 reply.WriteInt32(result);
1270 }
1271
AddAudioInterruptZonePidsInternal(MessageParcel & data,MessageParcel & reply)1272 void AudioPolicyManagerStub::AddAudioInterruptZonePidsInternal(MessageParcel &data, MessageParcel &reply)
1273 {
1274 std::set<int32_t> pids;
1275 int32_t zoneID = data.ReadInt32();
1276 int32_t pidsSize = data.ReadInt32();
1277 pidsSize = pidsSize > MAX_PID_COUNT ? MAX_PID_COUNT : pidsSize;
1278 if (pidsSize > 0) {
1279 for (int32_t i = 0; i < pidsSize; i ++) {
1280 pids.insert(data.ReadInt32());
1281 }
1282 }
1283 int32_t result = AddAudioInterruptZonePids(pids, zoneID);
1284 reply.WriteInt32(result);
1285 }
1286
RemoveAudioInterruptZonePidsInternal(MessageParcel & data,MessageParcel & reply)1287 void AudioPolicyManagerStub::RemoveAudioInterruptZonePidsInternal(MessageParcel &data, MessageParcel &reply)
1288 {
1289 std::set<int32_t> pids;
1290 int32_t zoneID = data.ReadInt32();
1291 int32_t pidsSize = data.ReadInt32();
1292 pidsSize = pidsSize > MAX_PID_COUNT ? MAX_PID_COUNT : pidsSize;
1293 if (pidsSize > 0) {
1294 for (int32_t i = 0; i < pidsSize; i ++) {
1295 pids.insert(data.ReadInt32());
1296 }
1297 }
1298 int32_t result = RemoveAudioInterruptZonePids(pids, zoneID);
1299 reply.WriteInt32(result);
1300 }
1301
ReleaseAudioInterruptZoneInternal(MessageParcel & data,MessageParcel & reply)1302 void AudioPolicyManagerStub::ReleaseAudioInterruptZoneInternal(MessageParcel &data, MessageParcel &reply)
1303 {
1304 int32_t zoneID = data.ReadInt32();
1305 int32_t result = ReleaseAudioInterruptZone(zoneID);
1306 reply.WriteInt32(result);
1307 }
1308
SetDefaultOutputDeviceInternal(MessageParcel & data,MessageParcel & reply)1309 void AudioPolicyManagerStub::SetDefaultOutputDeviceInternal(MessageParcel &data, MessageParcel &reply)
1310 {
1311 DeviceType deviceType = static_cast<DeviceType>(data.ReadInt32());
1312 uint32_t sessionID = data.ReadUint32();
1313 StreamUsage streamUsage = static_cast<StreamUsage>(data.ReadInt32());
1314 bool isRunning = data.ReadBool();
1315 int32_t result = SetDefaultOutputDevice(deviceType, sessionID, streamUsage, isRunning);
1316 reply.WriteInt32(result);
1317 }
1318
SetQueryClientTypeCallbackInternal(MessageParcel & data,MessageParcel & reply)1319 void AudioPolicyManagerStub::SetQueryClientTypeCallbackInternal(MessageParcel &data, MessageParcel &reply)
1320 {
1321 sptr<IRemoteObject> object = data.ReadRemoteObject();
1322 CHECK_AND_RETURN_LOG(object != nullptr, "AudioInterruptCallback obj is null");
1323 int32_t result = SetQueryClientTypeCallback(object);
1324 reply.WriteInt32(result);
1325 }
1326
OnMiddleNinRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1327 void AudioPolicyManagerStub::OnMiddleNinRemoteRequest(
1328 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1329 {
1330 switch (code) {
1331 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_SPATIALIZATION_ENABLED_FOR_DEVICE):
1332 IsSpatializationEnabledForDeviceInternal(data, reply);
1333 break;
1334 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_SPATIALIZATION_ENABLED_FOR_DEVICE):
1335 SetSpatializationEnabledForDeviceInternal(data, reply);
1336 break;
1337 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_HEAD_TRACKING_ENABLED_FOR_DEVICE):
1338 IsHeadTrackingEnabledForDeviceInternal(data, reply);
1339 break;
1340 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_HEAD_TRACKING_ENABLED_FOR_DEVICE):
1341 SetHeadTrackingEnabledForDeviceInternal(data, reply);
1342 break;
1343 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_DEFAULT_OUTPUT_DEVICE):
1344 SetDefaultOutputDeviceInternal(data, reply);
1345 break;
1346 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_QUERY_CLIENT_TYPE_CALLBACK):
1347 SetQueryClientTypeCallbackInternal(data, reply);
1348 break;
1349 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_VOICE_RINGTONE_MUTE):
1350 SetVoiceRingtoneMuteInternal(data, reply);
1351 break;
1352 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_PREFERRED_DEVICE):
1353 SetPreferredDeviceInternal(data, reply);
1354 break;
1355 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SAVE_REMOTE_INFO):
1356 SaveRemoteInfoInternal(data, reply);
1357 break;
1358 default:
1359 AUDIO_ERR_LOG("default case, need check AudioPolicyManagerStub");
1360 IPCObjectStub::OnRemoteRequest(code, data, reply, option);
1361 break;
1362 }
1363 }
OnMiddleEigRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1364 void AudioPolicyManagerStub::OnMiddleEigRemoteRequest(
1365 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1366 {
1367 switch (code) {
1368 case static_cast<uint32_t>(AudioPolicyInterfaceCode::TRIGGER_FETCH_DEVICE):
1369 TriggerFetchDeviceInternal(data, reply);
1370 break;
1371 case static_cast<uint32_t>(AudioPolicyInterfaceCode::MOVE_TO_NEW_PIPE):
1372 MoveToNewTypeInternal(data, reply);
1373 break;
1374 case static_cast<uint32_t>(AudioPolicyInterfaceCode::DISABLE_SAFE_MEDIA_VOLUME):
1375 DisableSafeMediaVolumeInternal(data, reply);
1376 break;
1377 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_DEVICES_INNER):
1378 GetDevicesInnerInternal(data, reply);
1379 break;
1380 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_AUDIO_CONCURRENCY_CALLBACK):
1381 SetConcurrencyCallbackInternal(data, reply);
1382 break;
1383 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UNSET_AUDIO_CONCURRENCY_CALLBACK):
1384 UnsetConcurrencyCallbackInternal(data, reply);
1385 break;
1386 case static_cast<uint32_t>(AudioPolicyInterfaceCode::ACTIVATE_AUDIO_CONCURRENCY):
1387 ActivateAudioConcurrencyInternal(data, reply);
1388 break;
1389 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_MICROPHONE_MUTE_PERSISTENT):
1390 SetMicrophoneMutePersistentInternal(data, reply);
1391 break;
1392 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_MICROPHONE_MUTE_PERSISTENT):
1393 GetMicrophoneMutePersistentInternal(data, reply);
1394 break;
1395 case static_cast<uint32_t>(AudioPolicyInterfaceCode::INJECT_INTERRUPTION):
1396 InjectInterruptionInternal(data, reply);
1397 break;
1398 case static_cast<uint32_t>(AudioPolicyInterfaceCode::ACTIVATE_AUDIO_SESSION):
1399 ActivateAudioSessionInternal(data, reply);
1400 break;
1401 case static_cast<uint32_t>(AudioPolicyInterfaceCode::DEACTIVATE_AUDIO_SESSION):
1402 DeactivateAudioSessionInternal(data, reply);
1403 break;
1404 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_AUDIO_SESSION_ACTIVATED):
1405 IsAudioSessionActivatedInternal(data, reply);
1406 break;
1407 default:
1408 OnMiddleNinRemoteRequest(code, data, reply, option);
1409 break;
1410 }
1411 }
1412
OnMiddleSevRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1413 void AudioPolicyManagerStub::OnMiddleSevRemoteRequest(
1414 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1415 {
1416 switch (code) {
1417 case static_cast<uint32_t>(AudioPolicyInterfaceCode::RELEASE_AUDIO_INTERRUPT_ZONE):
1418 ReleaseAudioInterruptZoneInternal(data, reply);
1419 break;
1420 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_CALL_DEVICE_ACTIVE):
1421 SetCallDeviceActiveInternal(data, reply);
1422 break;
1423 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_AUDIO_CONVERTER_CONFIG):
1424 GetConverterConfigInternal(data, reply);
1425 break;
1426 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_ACTIVE_BLUETOOTH_DESCRIPTOR):
1427 GetActiveBluetoothDeviceInternal(data, reply);
1428 break;
1429 case static_cast<uint32_t>(AudioPolicyInterfaceCode::FETCH_OUTPUT_DEVICE_FOR_TRACK):
1430 FetchOutputDeviceForTrackInternal(data, reply);
1431 break;
1432 case static_cast<uint32_t>(AudioPolicyInterfaceCode::FETCH_INPUT_DEVICE_FOR_TRACK):
1433 FetchInputDeviceForTrackInternal(data, reply);
1434 break;
1435 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_HIGH_RESOLUTION_EXIST):
1436 IsHighResolutionExistInternal(data, reply);
1437 break;
1438 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_HIGH_RESOLUTION_EXIST):
1439 SetHighResolutionExistInternal(data, reply);
1440 break;
1441 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SPATIALIZATION_SCENE_TYPE):
1442 GetSpatializationSceneTypeInternal(data, reply);
1443 break;
1444 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_SPATIALIZATION_SCENE_TYPE):
1445 SetSpatializationSceneTypeInternal(data, reply);
1446 break;
1447 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_MAX_AMPLITUDE):
1448 GetMaxAmplitudeInternal(data, reply);
1449 break;
1450 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_HEAD_TRACKING_DATA_REQUESTED):
1451 IsHeadTrackingDataRequestedInternal(data, reply);
1452 break;
1453 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_AUDIO_DEVICE_REFINER_CALLBACK):
1454 SetAudioDeviceRefinerCallbackInternal(data, reply);
1455 break;
1456 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UNSET_AUDIO_DEVICE_REFINER_CALLBACK):
1457 UnsetAudioDeviceRefinerCallbackInternal(data, reply);
1458 break;
1459 default:
1460 OnMiddleEigRemoteRequest(code, data, reply, option);
1461 break;
1462 }
1463 }
1464
OnMiddleSixRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1465 void AudioPolicyManagerStub::OnMiddleSixRemoteRequest(
1466 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1467 {
1468 switch (code) {
1469 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_SPATIALIZATION_SUPPORTED_FOR_DEVICE):
1470 IsSpatializationSupportedForDeviceInternal(data, reply);
1471 break;
1472 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_HEAD_TRACKING_SUPPORTED):
1473 IsHeadTrackingSupportedInternal(data, reply);
1474 break;
1475 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_HEAD_TRACKING_SUPPORTED_FOR_DEVICE):
1476 IsHeadTrackingSupportedForDeviceInternal(data, reply);
1477 break;
1478 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UPDATE_SPATIAL_DEVICE_STATE):
1479 UpdateSpatialDeviceStateInternal(data, reply);
1480 break;
1481 case static_cast<uint32_t>(AudioPolicyInterfaceCode::REGISTER_SPATIALIZATION_STATE_EVENT):
1482 RegisterSpatializationStateEventListenerInternal(data, reply);
1483 break;
1484 case static_cast<uint32_t>(AudioPolicyInterfaceCode::CONFIG_DISTRIBUTED_ROUTING_ROLE):
1485 ConfigDistributedRoutingRoleInternal(data, reply);
1486 break;
1487 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_DISTRIBUTED_ROUTING_ROLE_CALLBACK):
1488 SetDistributedRoutingRoleCallbackInternal(data, reply);
1489 break;
1490 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UNSET_DISTRIBUTED_ROUTING_ROLE_CALLBACK):
1491 UnsetDistributedRoutingRoleCallbackInternal(data, reply);
1492 break;
1493 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UNREGISTER_SPATIALIZATION_STATE_EVENT):
1494 UnregisterSpatializationStateEventListenerInternal(data, reply);
1495 break;
1496 case static_cast<uint32_t>(AudioPolicyInterfaceCode::REGISTER_POLICY_CALLBACK_CLIENT):
1497 RegisterPolicyCallbackClientInternal(data, reply);
1498 break;
1499 case static_cast<uint32_t>(AudioPolicyInterfaceCode::CREATE_AUDIO_INTERRUPT_ZONE):
1500 CreateAudioInterruptZoneInternal(data, reply);
1501 break;
1502 case static_cast<uint32_t>(AudioPolicyInterfaceCode::ADD_AUDIO_INTERRUPT_ZONE_PIDS):
1503 AddAudioInterruptZonePidsInternal(data, reply);
1504 break;
1505 case static_cast<uint32_t>(AudioPolicyInterfaceCode::REMOVE_AUDIO_INTERRUPT_ZONE_PIDS):
1506 RemoveAudioInterruptZonePidsInternal(data, reply);
1507 break;
1508 default:
1509 OnMiddleSevRemoteRequest(code, data, reply, option);
1510 break;
1511 }
1512 }
1513
OnMiddleFifRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1514 void AudioPolicyManagerStub::OnMiddleFifRemoteRequest(
1515 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1516 {
1517 switch (code) {
1518 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_AVAILABLE_MICROPHONE_DESCRIPTORS):
1519 GetAvailableMicrophonesInternal(data, reply);
1520 break;
1521 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_DEVICE_ABSOLUTE_VOLUME_SUPPORTED):
1522 SetDeviceAbsVolumeSupportedInternal(data, reply);
1523 break;
1524 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_ABS_VOLUME_SCENE):
1525 IsAbsVolumeSceneInternal(data, reply);
1526 break;
1527 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_A2DP_DEVICE_VOLUME):
1528 SetA2dpDeviceVolumeInternal(data, reply);
1529 break;
1530 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_AVAILABLE_DESCRIPTORS):
1531 GetAvailableDevicesInternal(data, reply);
1532 break;
1533 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_AVAILABLE_DEVICE_CHANGE_CALLBACK):
1534 SetAvailableDeviceChangeCallbackInternal(data, reply);
1535 break;
1536 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UNSET_AVAILABLE_DEVICE_CHANGE_CALLBACK):
1537 UnsetAvailableDeviceChangeCallbackInternal(data, reply);
1538 break;
1539 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_SPATIALIZATION_ENABLED):
1540 IsSpatializationEnabledInternal(data, reply);
1541 break;
1542 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_SPATIALIZATION_ENABLED):
1543 SetSpatializationEnabledInternal(data, reply);
1544 break;
1545 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_HEAD_TRACKING_ENABLED):
1546 IsHeadTrackingEnabledInternal(data, reply);
1547 break;
1548 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_HEAD_TRACKING_ENABLED):
1549 SetHeadTrackingEnabledInternal(data, reply);
1550 break;
1551 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SPATIALIZATION_STATE):
1552 GetSpatializationStateInternal(data, reply);
1553 break;
1554 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_SPATIALIZATION_SUPPORTED):
1555 IsSpatializationSupportedInternal(data, reply);
1556 break;
1557 default:
1558 OnMiddleSixRemoteRequest(code, data, reply, option);
1559 break;
1560 }
1561 }
1562
OnMiddleFouRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1563 void AudioPolicyManagerStub::OnMiddleFouRemoteRequest(
1564 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1565 {
1566 switch (code) {
1567 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SYSTEM_SOUND_URI):
1568 GetSystemSoundUriInternal(data, reply);
1569 break;
1570 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_MIN_VOLUME_STREAM):
1571 GetMinStreamVolumeInternal(data, reply);
1572 break;
1573 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_MAX_VOLUME_STREAM):
1574 GetMaxStreamVolumeInternal(data, reply);
1575 break;
1576 case static_cast<uint32_t>(AudioPolicyInterfaceCode::CHECK_MAX_RENDERER_INSTANCES):
1577 CheckMaxRendererInstancesInternal(data, reply);
1578 break;
1579 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_VOLUME_UNADJUSTABLE):
1580 IsVolumeUnadjustableInternal(data, reply);
1581 break;
1582 case static_cast<uint32_t>(AudioPolicyInterfaceCode::ADJUST_VOLUME_BY_STEP):
1583 AdjustVolumeByStepInternal(data, reply);
1584 break;
1585 case static_cast<uint32_t>(AudioPolicyInterfaceCode::ADJUST_SYSTEM_VOLUME_BY_STEP):
1586 AdjustSystemVolumeByStepInternal(data, reply);
1587 break;
1588 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SYSTEM_VOLUME_IN_DB):
1589 GetSystemVolumeInDbInternal(data, reply);
1590 break;
1591 case static_cast<uint32_t>(AudioPolicyInterfaceCode::QUERY_EFFECT_SCENEMODE):
1592 QueryEffectSceneModeInternal(data, reply);
1593 break;
1594 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_PLAYBACK_CAPTURER_FILTER_INFO):
1595 SetPlaybackCapturerFilterInfosInternal(data, reply);
1596 break;
1597 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_CAPTURER_SILENT_STATE):
1598 SetCaptureSilentStateInternal(data, reply);
1599 break;
1600 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_HARDWARE_OUTPUT_SAMPLING_RATE):
1601 GetHardwareOutputSamplingRateInternal(data, reply);
1602 break;
1603 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_AUDIO_CAPTURER_MICROPHONE_DESCRIPTORS):
1604 GetAudioCapturerMicrophoneDescriptorsInternal(data, reply);
1605 break;
1606 default:
1607 OnMiddleFifRemoteRequest(code, data, reply, option);
1608 break;
1609 }
1610 }
1611
OnMiddleTirRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1612 void AudioPolicyManagerStub::OnMiddleTirRemoteRequest(
1613 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1614 {
1615 switch (code) {
1616 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SINGLE_STREAM_VOLUME):
1617 GetSingleStreamVolumeInternal(data, reply);
1618 break;
1619 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_VOLUME_GROUP_INFO):
1620 GetVolumeGroupInfoInternal(data, reply);
1621 break;
1622 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_NETWORKID_BY_GROUP_ID):
1623 GetNetworkIdByGroupIdInternal(data, reply);
1624 break;
1625 #ifdef FEATURE_DTMF_TONE
1626 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_TONEINFO):
1627 GetToneInfoInternal(data, reply);
1628 break;
1629 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SUPPORTED_TONES):
1630 GetSupportedTonesInternal(data, reply);
1631 break;
1632 #endif
1633 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_AUDIO_RENDER_LOW_LATENCY_SUPPORTED):
1634 IsAudioRendererLowLatencySupportedInternal(data, reply);
1635 break;
1636 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_USING_PEMISSION_FROM_PRIVACY):
1637 CheckRecordingStateChangeInternal(data, reply);
1638 break;
1639 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_ACTIVE_OUTPUT_DEVICE_DESCRIPTORS):
1640 GetPreferredOutputDeviceDescriptorsInternal(data, reply);
1641 break;
1642 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_PREFERRED_INTPUT_DEVICE_DESCRIPTORS):
1643 GetPreferredInputDeviceDescriptorsInternal(data, reply);
1644 break;
1645 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_CALLBACKS_ENABLE):
1646 SetClientCallbacksEnableInternal(data, reply);
1647 break;
1648 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_AUDIO_FOCUS_INFO_LIST):
1649 GetAudioFocusInfoListInternal(data, reply);
1650 break;
1651 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_SYSTEM_SOUND_URI):
1652 SetSystemSoundUriInternal(data, reply);
1653 break;
1654 default:
1655 OnMiddleFouRemoteRequest(code, data, reply, option);
1656 break;
1657 }
1658 }
1659
OnMiddleSecRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1660 void AudioPolicyManagerStub::OnMiddleSecRemoteRequest(
1661 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1662 {
1663 switch (code) {
1664 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SELECT_INPUT_DEVICE):
1665 SelectInputDeviceInternal(data, reply);
1666 break;
1667 case static_cast<uint32_t>(AudioPolicyInterfaceCode::RECONFIGURE_CHANNEL):
1668 ReconfigureAudioChannelInternal(data, reply);
1669 break;
1670 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_AUDIO_LATENCY):
1671 GetAudioLatencyFromXmlInternal(data, reply);
1672 break;
1673 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SINK_LATENCY):
1674 GetSinkLatencyFromXmlInternal(data, reply);
1675 break;
1676 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_PREFERRED_OUTPUT_STREAM_TYPE):
1677 GetPreferredOutputStreamTypeInternal(data, reply);
1678 break;
1679 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_PREFERRED_INPUT_STREAM_TYPE):
1680 GetPreferredInputStreamTypeInternal(data, reply);
1681 break;
1682 case static_cast<uint32_t>(AudioPolicyInterfaceCode::REGISTER_TRACKER):
1683 RegisterTrackerInternal(data, reply);
1684 break;
1685 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UPDATE_TRACKER):
1686 UpdateTrackerInternal(data, reply);
1687 break;
1688 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_RENDERER_CHANGE_INFOS):
1689 GetRendererChangeInfosInternal(data, reply);
1690 break;
1691 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_CAPTURER_CHANGE_INFOS):
1692 GetCapturerChangeInfosInternal(data, reply);
1693 break;
1694 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_LOW_POWER_STREM_VOLUME):
1695 SetLowPowerVolumeInternal(data, reply);
1696 break;
1697 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_LOW_POWRR_STREM_VOLUME):
1698 GetLowPowerVolumeInternal(data, reply);
1699 break;
1700 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UPDATE_STREAM_STATE):
1701 UpdateStreamStateInternal(data, reply);
1702 break;
1703 default:
1704 OnMiddleTirRemoteRequest(code, data, reply, option);
1705 break;
1706 }
1707 }
1708
OnMiddleFirRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1709 void AudioPolicyManagerStub::OnMiddleFirRemoteRequest(
1710 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1711 {
1712 switch (code) {
1713 case static_cast<uint32_t>(AudioPolicyInterfaceCode::ACTIVATE_INTERRUPT):
1714 ActivateInterruptInternal(data, reply);
1715 break;
1716 case static_cast<uint32_t>(AudioPolicyInterfaceCode::DEACTIVATE_INTERRUPT):
1717 DeactivateInterruptInternal(data, reply);
1718 break;
1719 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_INTERRUPT_CALLBACK):
1720 SetAudioManagerInterruptCbInternal(data, reply);
1721 break;
1722 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UNSET_INTERRUPT_CALLBACK):
1723 UnsetAudioManagerInterruptCbInternal(data, reply);
1724 break;
1725 case static_cast<uint32_t>(AudioPolicyInterfaceCode::REQUEST_AUDIO_FOCUS):
1726 RequestAudioFocusInternal(data, reply);
1727 break;
1728 case static_cast<uint32_t>(AudioPolicyInterfaceCode::ABANDON_AUDIO_FOCUS):
1729 AbandonAudioFocusInternal(data, reply);
1730 break;
1731 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_STREAM_IN_FOCUS):
1732 GetStreamInFocusInternal(data, reply);
1733 break;
1734 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SESSION_INFO_IN_FOCUS):
1735 GetSessionInfoInFocusInternal(data, reply);
1736 break;
1737 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_DEVICES):
1738 GetDevicesInternal(data, reply);
1739 break;
1740 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_WAKEUP_AUDIOCAPTURER):
1741 NotifyCapturerAddedInternal(data, reply);
1742 break;
1743 case static_cast<uint32_t>(AudioPolicyInterfaceCode::QUERY_MICROPHONE_PERMISSION):
1744 CheckRecordingCreateInternal(data, reply);
1745 break;
1746 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SELECT_OUTPUT_DEVICE):
1747 SelectOutputDeviceInternal(data, reply);
1748 break;
1749 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SELECTED_DEVICE_INFO):
1750 GetSelectedDeviceInfoInternal(data, reply);
1751 break;
1752 default:
1753 OnMiddleSecRemoteRequest(code, data, reply, option);
1754 break;
1755 }
1756 }
1757
OnMiddlesRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1758 void AudioPolicyManagerStub::OnMiddlesRemoteRequest(
1759 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1760 {
1761 switch (code) {
1762 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_ACTIVE_OUTPUT_DEVICE):
1763 GetActiveOutputDeviceInternal(data, reply);
1764 break;
1765 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_ACTIVE_INPUT_DEVICE):
1766 GetActiveInputDeviceInternal(data, reply);
1767 break;
1768 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_RINGER_MODE_LEGACY):
1769 SetRingerModeLegacyInternal(data, reply);
1770 break;
1771 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_RINGER_MODE):
1772 SetRingerModeInternal(data, reply);
1773 break;
1774 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_RINGER_MODE):
1775 GetRingerModeInternal(data, reply);
1776 break;
1777 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_AUDIO_SCENE):
1778 SetAudioSceneInternal(data, reply);
1779 break;
1780 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_AUDIO_SCENE):
1781 GetAudioSceneInternal(data, reply);
1782 break;
1783 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_MICROPHONE_MUTE):
1784 SetMicrophoneMuteInternal(data, reply);
1785 break;
1786 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_MICROPHONE_MUTE_AUDIO_CONFIG):
1787 SetMicrophoneMuteAudioConfigInternal(data, reply);
1788 break;
1789 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_MICROPHONE_MUTE_LEGACY):
1790 IsMicrophoneMuteLegacyInternal(data, reply);
1791 break;
1792 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_MICROPHONE_MUTE):
1793 IsMicrophoneMuteInternal(data, reply);
1794 break;
1795 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_CALLBACK):
1796 SetInterruptCallbackInternal(data, reply);
1797 break;
1798 case static_cast<uint32_t>(AudioPolicyInterfaceCode::UNSET_CALLBACK):
1799 UnsetInterruptCallbackInternal(data, reply);
1800 break;
1801 default:
1802 OnMiddleFirRemoteRequest(code, data, reply, option);
1803 break;
1804 }
1805 }
1806
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)1807 int AudioPolicyManagerStub::OnRemoteRequest(
1808 uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
1809 {
1810 CHECK_AND_RETURN_RET_LOG(data.ReadInterfaceToken() == GetDescriptor(), -1, "ReadInterfaceToken failed");
1811 Trace trace(code >= codeNums ? "invalid audio policy code" : g_audioPolicyCodeStrs[code]);
1812 if (code <= static_cast<uint32_t>(AudioPolicyInterfaceCode::AUDIO_POLICY_MANAGER_CODE_MAX)) {
1813 switch (code) {
1814 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_MAX_VOLUMELEVEL):
1815 GetMaxVolumeLevelInternal(data, reply);
1816 break;
1817 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_MIN_VOLUMELEVEL):
1818 GetMinVolumeLevelInternal(data, reply);
1819 break;
1820 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_SYSTEM_VOLUMELEVEL_LEGACY):
1821 SetSystemVolumeLevelLegacyInternal(data, reply);
1822 break;
1823 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_SYSTEM_VOLUMELEVEL):
1824 SetSystemVolumeLevelInternal(data, reply);
1825 break;
1826 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SYSTEM_ACTIVEVOLUME_TYPE):
1827 GetSystemActiveVolumeTypeInternal(data, reply);
1828 break;
1829 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_SYSTEM_VOLUMELEVEL):
1830 GetSystemVolumeLevelInternal(data, reply);
1831 break;
1832 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_STREAM_MUTE_LEGACY):
1833 SetStreamMuteLegacyInternal(data, reply);
1834 break;
1835 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_STREAM_MUTE):
1836 SetStreamMuteInternal(data, reply);
1837 break;
1838 case static_cast<uint32_t>(AudioPolicyInterfaceCode::GET_STREAM_MUTE):
1839 GetStreamMuteInternal(data, reply);
1840 break;
1841 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_STREAM_ACTIVE):
1842 IsStreamActiveInternal(data, reply);
1843 break;
1844 case static_cast<uint32_t>(AudioPolicyInterfaceCode::SET_DEVICE_ACTIVE):
1845 SetDeviceActiveInternal(data, reply);
1846 break;
1847 case static_cast<uint32_t>(AudioPolicyInterfaceCode::IS_DEVICE_ACTIVE):
1848 IsDeviceActiveInternal(data, reply);
1849 break;
1850 case static_cast<uint32_t>(AudioPolicyInterfaceCode::LOAD_SPLIT_MODULE):
1851 LoadSplitModuleInternal(data, reply);
1852 break;
1853 default:
1854 OnMiddlesRemoteRequest(code, data, reply, option);
1855 break;
1856 }
1857 return AUDIO_OK;
1858 }
1859 AUDIO_ERR_LOG("default case, need check AudioPolicyManagerStub");
1860 return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
1861 }
1862
SetCallDeviceActiveInternal(MessageParcel & data,MessageParcel & reply)1863 void AudioPolicyManagerStub::SetCallDeviceActiveInternal(MessageParcel &data, MessageParcel &reply)
1864 {
1865 InternalDeviceType deviceType = static_cast<InternalDeviceType>(data.ReadInt32());
1866 bool active = data.ReadBool();
1867 std::string address = data.ReadString();
1868 int32_t result = SetCallDeviceActive(deviceType, active, address);
1869 reply.WriteInt32(result);
1870 }
1871
GetActiveBluetoothDeviceInternal(MessageParcel & data,MessageParcel & reply)1872 void AudioPolicyManagerStub::GetActiveBluetoothDeviceInternal(MessageParcel &data, MessageParcel &reply)
1873 {
1874 std::unique_ptr<AudioDeviceDescriptor> desc = GetActiveBluetoothDevice();
1875 desc->Marshalling(reply);
1876 }
1877
GetConverterConfigInternal(MessageParcel & data,MessageParcel & reply)1878 void AudioPolicyManagerStub::GetConverterConfigInternal(MessageParcel &data, MessageParcel &reply)
1879 {
1880 ConverterConfig result = GetConverterConfig();
1881 reply.WriteString(result.library.name);
1882 reply.WriteString(result.library.path);
1883 reply.WriteUint64(result.outChannelLayout);
1884 }
1885
FetchOutputDeviceForTrackInternal(MessageParcel & data,MessageParcel & reply)1886 void AudioPolicyManagerStub::FetchOutputDeviceForTrackInternal(MessageParcel &data, MessageParcel &reply)
1887 {
1888 AudioStreamChangeInfo streamChangeInfo = {};
1889 streamChangeInfo.audioRendererChangeInfo.Unmarshalling(data);
1890 AudioStreamDeviceChangeReasonExt reason = static_cast<AudioStreamDeviceChangeReasonExt::ExtEnum>(data.ReadInt32());
1891 FetchOutputDeviceForTrack(streamChangeInfo, reason);
1892 }
1893
FetchInputDeviceForTrackInternal(MessageParcel & data,MessageParcel & reply)1894 void AudioPolicyManagerStub::FetchInputDeviceForTrackInternal(MessageParcel &data, MessageParcel &reply)
1895 {
1896 AudioStreamChangeInfo streamChangeInfo = {};
1897 streamChangeInfo.audioCapturerChangeInfo.Unmarshalling(data);
1898 FetchInputDeviceForTrack(streamChangeInfo);
1899 }
1900
IsHighResolutionExistInternal(MessageParcel & data,MessageParcel & reply)1901 void AudioPolicyManagerStub::IsHighResolutionExistInternal(MessageParcel &data, MessageParcel &reply)
1902 {
1903 bool ret = IsHighResolutionExist();
1904 reply.WriteBool(ret);
1905 }
1906
SetHighResolutionExistInternal(MessageParcel & data,MessageParcel & reply)1907 void AudioPolicyManagerStub::SetHighResolutionExistInternal(MessageParcel &data, MessageParcel &reply)
1908 {
1909 bool highResExist = data.ReadBool();
1910 SetHighResolutionExist(highResExist);
1911 }
1912
GetSpatializationSceneTypeInternal(MessageParcel & data,MessageParcel & reply)1913 void AudioPolicyManagerStub::GetSpatializationSceneTypeInternal(MessageParcel &data, MessageParcel &reply)
1914 {
1915 AudioSpatializationSceneType spatializationSceneType = GetSpatializationSceneType();
1916 reply.WriteInt32(static_cast<int32_t>(spatializationSceneType));
1917 }
1918
SetSpatializationSceneTypeInternal(MessageParcel & data,MessageParcel & reply)1919 void AudioPolicyManagerStub::SetSpatializationSceneTypeInternal(MessageParcel &data, MessageParcel &reply)
1920 {
1921 AudioSpatializationSceneType spatializationSceneType = static_cast<AudioSpatializationSceneType>(data.ReadInt32());
1922 int32_t ret = SetSpatializationSceneType(spatializationSceneType);
1923 reply.WriteInt32(ret);
1924 }
1925
GetMaxAmplitudeInternal(MessageParcel & data,MessageParcel & reply)1926 void AudioPolicyManagerStub::GetMaxAmplitudeInternal(MessageParcel &data, MessageParcel &reply)
1927 {
1928 int32_t deviceId = data.ReadInt32();
1929 float result = GetMaxAmplitude(deviceId);
1930 reply.WriteFloat(result);
1931 }
1932
IsHeadTrackingDataRequestedInternal(MessageParcel & data,MessageParcel & reply)1933 void AudioPolicyManagerStub::IsHeadTrackingDataRequestedInternal(MessageParcel &data, MessageParcel &reply)
1934 {
1935 std::string macAddress = data.ReadString();
1936 bool result = IsHeadTrackingDataRequested(macAddress);
1937 reply.WriteBool(result);
1938 }
1939
SetAudioDeviceRefinerCallbackInternal(MessageParcel & data,MessageParcel & reply)1940 void AudioPolicyManagerStub::SetAudioDeviceRefinerCallbackInternal(MessageParcel &data, MessageParcel &reply)
1941 {
1942 sptr<IRemoteObject> object = data.ReadRemoteObject();
1943 int32_t result = SetAudioDeviceRefinerCallback(object);
1944 reply.WriteInt32(result);
1945 }
1946
UnsetAudioDeviceRefinerCallbackInternal(MessageParcel & data,MessageParcel & reply)1947 void AudioPolicyManagerStub::UnsetAudioDeviceRefinerCallbackInternal(MessageParcel &data, MessageParcel &reply)
1948 {
1949 int32_t result = UnsetAudioDeviceRefinerCallback();
1950 reply.WriteInt32(result);
1951 }
1952
TriggerFetchDeviceInternal(MessageParcel & data,MessageParcel & reply)1953 void AudioPolicyManagerStub::TriggerFetchDeviceInternal(MessageParcel &data, MessageParcel &reply)
1954 {
1955 AudioStreamDeviceChangeReasonExt reason(static_cast<AudioStreamDeviceChangeReasonExt::ExtEnum>(data.ReadInt32()));
1956 int32_t result = TriggerFetchDevice(reason);
1957 reply.WriteInt32(result);
1958 }
1959
SetPreferredDeviceInternal(MessageParcel & data,MessageParcel & reply)1960 void AudioPolicyManagerStub::SetPreferredDeviceInternal(MessageParcel &data, MessageParcel &reply)
1961 {
1962 PreferredType preferredType = static_cast<PreferredType>(data.ReadInt32());
1963 sptr<AudioDeviceDescriptor> desc = AudioDeviceDescriptor::Unmarshalling(data);
1964 int32_t result = SetPreferredDevice(preferredType, desc);
1965 reply.WriteInt32(result);
1966 }
1967
SaveRemoteInfoInternal(MessageParcel & data,MessageParcel & reply)1968 void AudioPolicyManagerStub::SaveRemoteInfoInternal(MessageParcel &data, MessageParcel &reply)
1969 {
1970 std::string networkId = data.ReadString();
1971 DeviceType deviceType = static_cast<DeviceType>(data.ReadInt32());
1972 SaveRemoteInfo(networkId, deviceType);
1973 }
1974
MoveToNewTypeInternal(MessageParcel & data,MessageParcel & reply)1975 void AudioPolicyManagerStub::MoveToNewTypeInternal(MessageParcel &data, MessageParcel &reply)
1976 {
1977 uint32_t sessionId = data.ReadUint32();
1978 AudioPipeType pipeType = static_cast<AudioPipeType>(data.ReadInt32());
1979 int32_t result = MoveToNewPipe(sessionId, pipeType);
1980 reply.WriteInt32(result);
1981 }
1982
DisableSafeMediaVolumeInternal(MessageParcel & data,MessageParcel & reply)1983 void AudioPolicyManagerStub::DisableSafeMediaVolumeInternal(MessageParcel &data, MessageParcel &reply)
1984 {
1985 int32_t ret = DisableSafeMediaVolume();
1986 reply.WriteInt32(ret);
1987 }
1988
SetConcurrencyCallbackInternal(MessageParcel & data,MessageParcel & reply)1989 void AudioPolicyManagerStub::SetConcurrencyCallbackInternal(MessageParcel &data, MessageParcel &reply)
1990 {
1991 uint32_t sessionID = data.ReadUint32();
1992 sptr<IRemoteObject> object = data.ReadRemoteObject();
1993 CHECK_AND_RETURN_LOG(object != nullptr, "AudioPolicyManagerStub: AudioInterruptCallback obj is null");
1994 int32_t result = SetAudioConcurrencyCallback(sessionID, object);
1995 reply.WriteInt32(result);
1996 }
1997
UnsetConcurrencyCallbackInternal(MessageParcel & data,MessageParcel & reply)1998 void AudioPolicyManagerStub::UnsetConcurrencyCallbackInternal(MessageParcel &data, MessageParcel &reply)
1999 {
2000 uint32_t sessionID = data.ReadUint32();
2001 int32_t result = UnsetAudioConcurrencyCallback(sessionID);
2002 reply.WriteInt32(result);
2003 }
2004
ActivateAudioConcurrencyInternal(MessageParcel & data,MessageParcel & reply)2005 void AudioPolicyManagerStub::ActivateAudioConcurrencyInternal(MessageParcel &data, MessageParcel &reply)
2006 {
2007 AudioPipeType pipeType = static_cast<AudioPipeType>(data.ReadInt32());
2008 int32_t result = ActivateAudioConcurrency(pipeType);
2009 reply.WriteInt32(result);
2010 }
2011
SetMicrophoneMutePersistentInternal(MessageParcel & data,MessageParcel & reply)2012 void AudioPolicyManagerStub::SetMicrophoneMutePersistentInternal(MessageParcel &data, MessageParcel &reply)
2013 {
2014 bool isMute = data.ReadBool();
2015 PolicyType type = static_cast<PolicyType>(data.ReadInt32());
2016 int32_t result = SetMicrophoneMutePersistent(isMute, type);
2017 reply.WriteInt32(result);
2018 }
2019
GetMicrophoneMutePersistentInternal(MessageParcel & data,MessageParcel & reply)2020 void AudioPolicyManagerStub::GetMicrophoneMutePersistentInternal(MessageParcel &data, MessageParcel &reply)
2021 {
2022 bool result = GetPersistentMicMuteState();
2023 reply.WriteBool(result);
2024 }
2025
InjectInterruptionInternal(MessageParcel & data,MessageParcel & reply)2026 void AudioPolicyManagerStub::InjectInterruptionInternal(MessageParcel &data, MessageParcel &reply)
2027 {
2028 std::string networkId = data.ReadString();
2029 InterruptEvent event;
2030 event.eventType = static_cast<InterruptType>(data.ReadInt32());
2031 event.forceType = static_cast<InterruptForceType>(data.ReadInt32());
2032 event.hintType = static_cast<InterruptHint>(data.ReadInt32());
2033
2034 int32_t result = InjectInterruption(networkId, event);
2035 reply.WriteInt32(result);
2036 }
2037
LoadSplitModuleInternal(MessageParcel & data,MessageParcel & reply)2038 void AudioPolicyManagerStub::LoadSplitModuleInternal(MessageParcel &data, MessageParcel &reply)
2039 {
2040 std::string splitArgs = data.ReadString();
2041 std::string netWorkId = data.ReadString();
2042 int32_t result = LoadSplitModule(splitArgs, netWorkId);
2043 reply.WriteInt32(result);
2044 }
2045
SetVoiceRingtoneMuteInternal(MessageParcel & data,MessageParcel & reply)2046 void AudioPolicyManagerStub::SetVoiceRingtoneMuteInternal(MessageParcel &data, MessageParcel &reply)
2047 {
2048 bool isMute = data.ReadBool();
2049 int32_t result = SetVoiceRingtoneMute(isMute);
2050 reply.WriteInt32(result);
2051 }
2052
2053 } // namespace audio_policy
2054 } // namespace OHOS
2055