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