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