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