1 /*
2 * Copyright (c) 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
16 #include <iostream>
17 #include <cstddef>
18 #include <cstdint>
19 #include <atomic>
20 #include <thread>
21 #include "audio_policy_manager.h"
22 #include "sle_audio_device_manager.h"
23 using namespace std;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 const int32_t LIMITSIZE = 4;
28 bool g_hasPermission = false;
29 bool g_hasServerInit = false;
30 static const uint8_t *RAW_DATA = nullptr;
31 static size_t g_dataSize = 0;
32 static size_t g_pos;
33 const size_t THRESHOLD = 10;
34
35 /*
36 * describe: get data from outside untrusted data(RAW_DATA) which size is according to sizeof(T)
37 * tips: only support basic type
38 */
39 template<class T>
GetData()40 T GetData()
41 {
42 T object {};
43 size_t objectSize = sizeof(object);
44 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
45 return object;
46 }
47 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
48 if (ret != EOK) {
49 return {};
50 }
51 g_pos += objectSize;
52 return object;
53 }
54
55 template<class T>
GetArrLength(T & arr)56 uint32_t GetArrLength(T& arr)
57 {
58 if (arr == nullptr) {
59 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
60 return 0;
61 }
62 return sizeof(arr) / sizeof(arr[0]);
63 }
64
65 class AudioManagerDeviceChangeCallbackFuzzTest : public AudioManagerDeviceChangeCallback {
66 public:
AudioManagerDeviceChangeCallbackFuzzTest()67 AudioManagerDeviceChangeCallbackFuzzTest() {}
OnDeviceChange(const DeviceChangeAction & deviceChangeAction)68 void OnDeviceChange(const DeviceChangeAction &deviceChangeAction) override {}
69 };
70
71 class AudioPreferredOutputDeviceChangeCallbackFuzzTest : public AudioPreferredOutputDeviceChangeCallback {
72 public:
AudioPreferredOutputDeviceChangeCallbackFuzzTest()73 AudioPreferredOutputDeviceChangeCallbackFuzzTest() {}
OnPreferredOutputDeviceUpdated(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> & desc)74 void OnPreferredOutputDeviceUpdated(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> &desc) override {}
75 };
76
77 class AudioPreferredInputDeviceChangeCallbackFuzzTest : public AudioPreferredInputDeviceChangeCallback {
78 public:
AudioPreferredInputDeviceChangeCallbackFuzzTest()79 AudioPreferredInputDeviceChangeCallbackFuzzTest() {}
OnPreferredInputDeviceUpdated(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> & desc)80 void OnPreferredInputDeviceUpdated(const std::vector<std::shared_ptr<AudioDeviceDescriptor>> &desc) override {};
81 };
82
83 class DeviceChangeWithInfoCallbackFuzzTest : public DeviceChangeWithInfoCallback {
84 public:
DeviceChangeWithInfoCallbackFuzzTest()85 DeviceChangeWithInfoCallbackFuzzTest() {}
OnDeviceChangeWithInfo(const uint32_t sessionId,const AudioDeviceDescriptor & deviceInfo,const AudioStreamDeviceChangeReasonExt reason)86 void OnDeviceChangeWithInfo(const uint32_t sessionId, const AudioDeviceDescriptor &deviceInfo,
87 const AudioStreamDeviceChangeReasonExt reason) override {}
88
OnRecreateStreamEvent(const uint32_t sessionId,const int32_t streamFlag,const AudioStreamDeviceChangeReasonExt reason)89 void OnRecreateStreamEvent(const uint32_t sessionId, const int32_t streamFlag,
90 const AudioStreamDeviceChangeReasonExt reason) override {}
91 };
92
93 class AudioManagerAvailableDeviceChangeCallbackFuzzTest : public AudioManagerAvailableDeviceChangeCallback {
94 public:
AudioManagerAvailableDeviceChangeCallbackFuzzTest()95 AudioManagerAvailableDeviceChangeCallbackFuzzTest() {}
OnAvailableDeviceChange(const AudioDeviceUsage usage,const DeviceChangeAction & deviceChangeAction)96 void OnAvailableDeviceChange(const AudioDeviceUsage usage, const DeviceChangeAction &deviceChangeAction) override {}
97 };
98
99 class AudioDeviceAnahsFuzzTest : public AudioDeviceAnahs {
100 public:
AudioDeviceAnahsFuzzTest()101 AudioDeviceAnahsFuzzTest() {}
102
OnExtPnpDeviceStatusChanged(std::string anahsStatus,std::string anahsShowType)103 int32_t OnExtPnpDeviceStatusChanged(std::string anahsStatus, std::string anahsShowType) override
104 {
105 return 0;
106 }
107 };
108
109 class AudioQueryDeviceVolumeBehaviorCallbackFuzzTest : public AudioQueryDeviceVolumeBehaviorCallback {
110 public:
AudioQueryDeviceVolumeBehaviorCallbackFuzzTest()111 AudioQueryDeviceVolumeBehaviorCallbackFuzzTest() {}
OnQueryDeviceVolumeBehavior()112 VolumeBehavior OnQueryDeviceVolumeBehavior() override
113 {
114 VolumeBehavior volumeBehavior;
115 return volumeBehavior;
116 }
117 };
118
AudioPolicyManagerOneFuzzTest()119 void AudioPolicyManagerOneFuzzTest()
120 {
121 bool block = GetData<bool>();
122 sptr<IAudioPolicy> Ap_gsp = AudioPolicyManager::GetInstance().GetAudioPolicyManagerProxy();
123 CallbackChange callbackChange = GetData<CallbackChange>();
124 pid_t pid = GetData<pid_t>();
125 uid_t uid = GetData<uid_t>();
126 AudioServerDiedCallBack func;
127 AudioVolumeType volumeType = GetData<AudioVolumeType>();
128 int32_t volumeLevel = GetData<int32_t>();
129 int32_t volumeFlag = GetData<int32_t>();
130 int32_t appUid = GetData<int32_t>();
131 bool muted = GetData<bool>();
132 bool isMute = GetData<bool>();
133 int32_t zoneId = GetData<int32_t>();
134 uid = GetData<int32_t>();
135 bool isLegacy = GetData<bool>();
136 DeviceType deviceType = GetData<DeviceType>();
137 AudioRingerMode ringMode = GetData<AudioRingerMode>();
138 AudioScene scene = GetData<AudioScene>();
139 PolicyType policyType = GetData<PolicyType>();
140
141 AudioPolicyManager::GetInstance().GetAudioPolicyManagerProxy(block);
142 AudioPolicyManager::GetInstance().RegisterPolicyCallbackClientFunc(Ap_gsp);
143 AudioPolicyManager::GetInstance().RecoverAudioPolicyCallbackClient();
144 AudioPolicyManager::GetInstance().SetCallbackStreamInfo(callbackChange);
145 AudioPolicyManager::GetInstance().AudioPolicyServerDied(pid, uid);
146 AudioPolicyManager::GetInstance().RegisterServerDiedCallBack(func);
147 AudioPolicyManager::GetInstance().GetMaxVolumeLevel(volumeType);
148 AudioPolicyManager::GetInstance().GetMinVolumeLevel(volumeType);
149 AudioPolicyManager::GetInstance().SetSelfAppVolumeLevel(volumeLevel, volumeFlag);
150 AudioPolicyManager::GetInstance().SetAppVolumeLevel(appUid, volumeLevel, volumeFlag);
151 AudioPolicyManager::GetInstance().SetAppVolumeMuted(appUid, muted, volumeFlag);
152 AudioPolicyManager::GetInstance().IsAppVolumeMute(appUid, muted, isMute);
153 AudioPolicyManager::GetInstance().SetAdjustVolumeForZone(zoneId);
154 AudioPolicyManager::GetInstance().SetSystemVolumeLevel(volumeType, volumeLevel, isLegacy, volumeFlag, uid);
155 AudioPolicyManager::GetInstance().SetSystemVolumeLevelWithDevice(volumeType, volumeLevel, deviceType, volumeFlag);
156 AudioPolicyManager::GetInstance().SetRingerModeLegacy(ringMode);
157 AudioPolicyManager::GetInstance().SetRingerMode(ringMode);
158 AudioPolicyManager::GetInstance().GetRingerMode();
159 AudioPolicyManager::GetInstance().SetAudioScene(scene);
160 AudioPolicyManager::GetInstance().SetMicrophoneMute(isMute);
161 AudioPolicyManager::GetInstance().SetMicrophoneMuteAudioConfig(isMute);
162 }
163
AudioPolicyManagerTwoFuzzTest()164 void AudioPolicyManagerTwoFuzzTest()
165 {
166 int32_t volumeLevel = GetData<int32_t>();
167 int32_t appUid = GetData<int32_t>();
168 AudioVolumeType volumeType = GetData<AudioVolumeType>();
169 int32_t uid = GetData<int32_t>();
170 bool mute = GetData<bool>();
171 bool isLegacy = GetData<bool>();
172 DeviceType deviceType = GetData<DeviceType>();
173 int32_t streamId = GetData<int32_t>();
174 float volume = GetData<float>();
175 StreamUsage streamUsage = GetData<StreamUsage>();
176 AudioStreamInfo streamInfo;
177 SourceType source = GetData<SourceType>();
178 std::list<std::pair<AudioInterrupt, AudioFocuState>> focusInfoList;
179 int32_t zoneId = GetData<int32_t>();
180 CallbackChange callbackChange = GetData<CallbackChange>();
181 bool enable = GetData<bool>();
182 bool block = GetData<bool>();
183 AudioRendererInfo rendererInfo;
184 AudioCapturerInfo capturerInfo;
185 int32_t clientId = GetData<int32_t>();
186 std::shared_ptr<AudioFocusInfoChangeCallback> callback;
187
188 AudioPolicyManager::GetInstance().GetSelfAppVolumeLevel(volumeLevel);
189 AudioPolicyManager::GetInstance().GetAppVolumeLevel(appUid, volumeLevel);
190 AudioPolicyManager::GetInstance().GetSystemVolumeLevel(volumeType, uid);
191 AudioPolicyManager::GetInstance().SetStreamMute(volumeType, mute, isLegacy, deviceType);
192 AudioPolicyManager::GetInstance().GetStreamMute(volumeType);
193 AudioPolicyManager::GetInstance().SetLowPowerVolume(streamId, volume);
194 AudioPolicyManager::GetInstance().GetLowPowerVolume(streamId);
195 AudioPolicyManager::GetInstance().GetFastStreamInfo();
196 AudioPolicyManager::GetInstance().GetSingleStreamVolume(streamId);
197 AudioPolicyManager::GetInstance().IsStreamActive(volumeType);
198 AudioPolicyManager::GetInstance().IsStreamActiveByStreamUsage(streamUsage);
199 AudioPolicyManager::GetInstance().IsFastPlaybackSupported(streamInfo, streamUsage);
200 AudioPolicyManager::GetInstance().IsFastRecordingSupported(streamInfo, source);
201 AudioPolicyManager::GetInstance().GetAudioFocusInfoList(focusInfoList, zoneId);
202 AudioPolicyManager::GetInstance().SetClientCallbacksEnable(callbackChange, enable, block);
203 AudioPolicyManager::GetInstance().SetCallbackRendererInfo(rendererInfo);
204 AudioPolicyManager::GetInstance().SetCallbackCapturerInfo(capturerInfo);
205 AudioPolicyManager::GetInstance().RegisterFocusInfoChangeCallback(clientId, callback);
206 AudioPolicyManager::GetInstance().UnregisterFocusInfoChangeCallback(clientId);
207 }
208
AudioPolicyManagerThreeFuzzTest()209 void AudioPolicyManagerThreeFuzzTest()
210 {
211 int32_t appUid = GetData<int32_t>();
212 std::shared_ptr<AudioManagerActiveVolumeTypeChangeCallback> volumeTypeChangeCallback;
213 std::shared_ptr<AudioManagerAppVolumeChangeCallback> appVolumeChangeCallback;
214 int32_t clientId = GetData<int32_t>();
215 std::shared_ptr<AudioRingerModeCallback> ringerModeCallback;
216 API_VERSION api_v = GetData<API_VERSION>();
217 std::shared_ptr<AudioManagerMicrophoneBlockedCallback> microphoneBlockedCallback;
218 std::shared_ptr<AudioManagerAudioSceneChangedCallback> audioSceneChangedCallback;
219 std::shared_ptr<AudioManagerMicStateChangeCallback> micStateChangeCallback;
220 uint32_t sessionID = GetData<uint32_t>();
221 std::shared_ptr<AudioInterruptCallback> interruptCallback;
222 uint32_t clientUid = GetData<int32_t>();
223 int32_t zoneId = GetData<int32_t>();
224 std::shared_ptr<AudioQueryClientTypeCallback> audioQueryClientTypeCallback;
225 std::shared_ptr<AudioQueryBundleNameListCallback> audioQueryBundleNameListCallback;
226 AudioInterrupt audioInterrupt;
227 bool isUpdatedAudioStrategy = GetData<bool>();
228
229 AudioPolicyManager::GetInstance().SetActiveVolumeTypeCallback(volumeTypeChangeCallback);
230 AudioPolicyManager::GetInstance().UnsetActiveVolumeTypeCallback(volumeTypeChangeCallback);
231 AudioPolicyManager::GetInstance().SetSelfAppVolumeChangeCallback(appVolumeChangeCallback);
232 AudioPolicyManager::GetInstance().UnsetSelfAppVolumeCallback(appVolumeChangeCallback);
233 AudioPolicyManager::GetInstance().UnsetAppVolumeCallbackForUid(appVolumeChangeCallback);
234 AudioPolicyManager::GetInstance().SetAppVolumeChangeCallbackForUid(appUid, appVolumeChangeCallback);
235 AudioPolicyManager::GetInstance().SetRingerModeCallback(clientId, ringerModeCallback, api_v);
236 AudioPolicyManager::GetInstance().UnsetRingerModeCallback(clientId);
237 AudioPolicyManager::GetInstance().UnsetRingerModeCallback(clientId, ringerModeCallback);
238 AudioPolicyManager::GetInstance().SetMicrophoneBlockedCallback(clientId, microphoneBlockedCallback);
239 AudioPolicyManager::GetInstance().UnsetMicrophoneBlockedCallback(clientId, microphoneBlockedCallback);
240 AudioPolicyManager::GetInstance().SetAudioSceneChangeCallback(clientId, audioSceneChangedCallback);
241 AudioPolicyManager::GetInstance().UnsetAudioSceneChangeCallback(audioSceneChangedCallback);
242 AudioPolicyManager::GetInstance().SetMicStateChangeCallback(clientId, micStateChangeCallback);
243 AudioPolicyManager::GetInstance().UnsetMicStateChangeCallback(micStateChangeCallback);
244 AudioPolicyManager::GetInstance().SetAudioInterruptCallback(sessionID, interruptCallback, clientUid, zoneId);
245 AudioPolicyManager::GetInstance().UnsetAudioInterruptCallback(sessionID, zoneId);
246 AudioPolicyManager::GetInstance().SetQueryClientTypeCallback(audioQueryClientTypeCallback);
247 AudioPolicyManager::GetInstance().SetQueryBundleNameListCallback(audioQueryBundleNameListCallback);
248 AudioPolicyManager::GetInstance().ActivateAudioInterrupt(audioInterrupt, zoneId, isUpdatedAudioStrategy);
249 AudioPolicyManager::GetInstance().DeactivateAudioInterrupt(audioInterrupt, zoneId);
250 AudioPolicyManager::GetInstance().ActivatePreemptMode();
251 AudioPolicyManager::GetInstance().DeactivatePreemptMode();
252 AudioPolicyManager::GetInstance().SetAudioManagerInterruptCallback(clientId, interruptCallback);
253 AudioPolicyManager::GetInstance().UnsetAudioManagerInterruptCallback(clientId);
254 }
255
AudioPolicyManagerFourFuzzTest()256 void AudioPolicyManagerFourFuzzTest()
257 {
258 int32_t clientId = GetData<int32_t>();
259 AudioInterrupt audioInterrupt;
260 int32_t zoneId = GetData<int32_t>();
261 int32_t clientPid = GetData<int32_t>();
262 int32_t uid = GetData<int32_t>();
263 std::shared_ptr<VolumeKeyEventCallback> volumeKeyEventCallback;
264 API_VERSION api_v = GetData<API_VERSION>();
265 std::shared_ptr<SystemVolumeChangeCallback> systemVolumeChangeCallback;
266 std::shared_ptr<AudioRendererStateChangeCallback> audioRendererStateChangeCallback;
267 std::vector<std::shared_ptr<AudioRendererStateChangeCallback>> audioRendererStateChangeCallbacks;
268 std::shared_ptr<AudioCapturerStateChangeCallback> audioCapturerStateChangeCallback;
269 AudioMode mode = AUDIO_MODE_PLAYBACK;
270 AudioStreamChangeInfo streamChangeInfo;
271 std::shared_ptr<AudioClientTracker> clientTrackerObj;
272 AudioRendererInfo rendererInfo;
273 AudioCapturerInfo capturerInfo;
274 std::shared_ptr<AudioStreamDescriptor> streamDesc;
275 uint32_t flag = GetData<uint32_t>();
276 uint32_t sessionId = GetData<uint32_t>();
277 std::string networkId = "netWorkId";
278
279 AudioPolicyManager::GetInstance().RequestAudioFocus(clientId, audioInterrupt);
280 AudioPolicyManager::GetInstance().AbandonAudioFocus(clientId, audioInterrupt);
281 AudioPolicyManager::GetInstance().GetStreamInFocus(zoneId);
282 AudioPolicyManager::GetInstance().GetStreamInFocusByUid(uid, zoneId);
283 AudioPolicyManager::GetInstance().GetSessionInfoInFocus(audioInterrupt, zoneId);
284 AudioPolicyManager::GetInstance().SetVolumeKeyEventCallback(clientPid, volumeKeyEventCallback, api_v);
285 AudioPolicyManager::GetInstance().UnsetVolumeKeyEventCallback(volumeKeyEventCallback);
286 AudioPolicyManager::GetInstance().SetSystemVolumeChangeCallback(clientPid, systemVolumeChangeCallback);
287 AudioPolicyManager::GetInstance().UnsetSystemVolumeChangeCallback(systemVolumeChangeCallback);
288 AudioPolicyManager::GetInstance().RegisterAudioRendererEventListener(audioRendererStateChangeCallback);
289 AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(audioRendererStateChangeCallbacks);
290 AudioPolicyManager::GetInstance().UnregisterAudioRendererEventListener(audioRendererStateChangeCallback);
291 AudioPolicyManager::GetInstance().RegisterAudioCapturerEventListener(clientPid, audioCapturerStateChangeCallback);
292 AudioPolicyManager::GetInstance().UnregisterAudioCapturerEventListener(clientPid);
293 AudioPolicyManager::GetInstance().RegisterTracker(mode, streamChangeInfo, clientTrackerObj);
294 AudioPolicyManager::GetInstance().UpdateTracker(mode, streamChangeInfo);
295 AudioPolicyManager::GetInstance().GetPreferredOutputStreamType(rendererInfo);
296 AudioPolicyManager::GetInstance().GetPreferredInputStreamType(capturerInfo);
297 AudioPolicyManager::GetInstance().CreateRendererClient(streamDesc, flag, sessionId, networkId);
298 AudioPolicyManager::GetInstance().CreateCapturerClient(streamDesc, flag, sessionId);
299 }
300
AudioPolicyManagerFiveFuzzTest()301 void AudioPolicyManagerFiveFuzzTest()
302 {
303 int32_t clientUid = GetData<int32_t>();
304 StreamSetState streamSetState = GetData<StreamSetState>();
305 StreamUsage streamUsage = GetData<StreamUsage>();
306 std::string networkId = "networkId";
307 std::vector<sptr<VolumeGroupInfo>> infos;
308 int32_t groupId = GetData<int32_t>();
309 std::string key = "key";
310 std::string uri = "uri";
311 int32_t clientPid = GetData<int32_t>();
312 std::shared_ptr<AudioRendererPolicyServiceDiedCallback> audioRendererPolicyServiceDiedCallback;
313 std::shared_ptr<AudioCapturerPolicyServiceDiedCallback> audioCapturerPolicyServiceDiedCallback;
314 std::shared_ptr<AudioStreamPolicyServiceDiedCallback> audioStreamPolicyServiceDiedCallback;
315 VolumeAdjustType adjustType = GetData<VolumeAdjustType>();
316 AudioVolumeType volumeType = GetData<AudioVolumeType>();
317 int32_t volumeLevel = GetData<int32_t>();
318 DeviceType deviceType = GetData<DeviceType>();
319 SupportedEffectConfig supportedEffectConfig;
320 std::shared_ptr<AudioDeviceDescriptor> desc;
321 int32_t sessionId = GetData<int32_t>();
322
323 AudioPolicyManager::GetInstance().UpdateStreamState(clientUid, streamSetState, streamUsage);
324 AudioPolicyManager::GetInstance().GetVolumeGroupInfos(networkId, infos);
325 AudioPolicyManager::GetInstance().GetNetworkIdByGroupId(groupId, networkId);
326 AudioPolicyManager::GetInstance().SetSystemSoundUri(key, uri);
327 AudioPolicyManager::GetInstance().GetSystemSoundUri(key);
328 AudioPolicyManager::GetInstance().GetMinStreamVolume();
329 AudioPolicyManager::GetInstance().GetMaxStreamVolume();
330 AudioPolicyManager::GetInstance().RegisterAudioPolicyServerDiedCb(clientPid,
331 audioRendererPolicyServiceDiedCallback);
332 AudioPolicyManager::GetInstance().RegisterAudioPolicyServerDiedCb(clientPid,
333 audioCapturerPolicyServiceDiedCallback);
334 AudioPolicyManager::GetInstance().UnregisterAudioPolicyServerDiedCb(clientPid);
335 AudioPolicyManager::GetInstance().RegisterAudioStreamPolicyServerDiedCb(audioStreamPolicyServiceDiedCallback);
336 AudioPolicyManager::GetInstance().UnregisterAudioStreamPolicyServerDiedCb(audioStreamPolicyServiceDiedCallback);
337 AudioPolicyManager::GetInstance().GetMaxRendererInstances();
338 AudioPolicyManager::GetInstance().IsVolumeUnadjustable();
339 AudioPolicyManager::GetInstance().AdjustVolumeByStep(adjustType);
340 AudioPolicyManager::GetInstance().AdjustSystemVolumeByStep(volumeType, adjustType);
341 AudioPolicyManager::GetInstance().GetSystemVolumeInDb(volumeType, volumeLevel, deviceType);
342 AudioPolicyManager::GetInstance().QueryEffectSceneMode(supportedEffectConfig);
343 AudioPolicyManager::GetInstance().GetHardwareOutputSamplingRate(desc);
344 AudioPolicyManager::GetInstance().GetAudioCapturerMicrophoneDescriptors(sessionId);
345 AudioPolicyManager::GetInstance().GetAvailableMicrophones();
346 }
347
AudioPolicyManagerSixFuzzTest()348 void AudioPolicyManagerSixFuzzTest()
349 {
350 std::string macAddress = "macAddress";
351 bool support = GetData<bool>();
352 int32_t volume = GetData<int32_t>();
353 bool updateUi = GetData<bool>();
354 AudioVolumeType volumeType = GetData<AudioVolumeType>();
355 std::shared_ptr<AudioDeviceDescriptor> descriptor;
356 CastType castType = GetData<CastType>();
357 std::shared_ptr<AudioDistributedRoutingRoleCallback> audioDistributedRoutingRoleCallback;
358 std::string address = "address";
359 bool enable = GetData<bool>();
360 std::shared_ptr<AudioDeviceDescriptor> selectedAudioDevice;
361 std::shared_ptr<AudioSpatializationEnabledChangeCallback> audioSpatializationEnabledChangeCallback;
362 std::shared_ptr<AudioSpatializationEnabledChangeForCurrentDeviceCallback> currentDeviceCallback;
363 std::shared_ptr<AudioHeadTrackingEnabledChangeCallback> audioHeadTrackingEnabledChangeCallback;
364 std::shared_ptr<AudioNnStateChangeCallback> audioNnStateChangeCallback;
365
366 AudioPolicyManager::GetInstance().SetDeviceAbsVolumeSupported(macAddress, support);
367 AudioPolicyManager::GetInstance().IsAbsVolumeScene();
368 AudioPolicyManager::GetInstance().SetA2dpDeviceVolume(macAddress, volume, updateUi);
369 AudioPolicyManager::GetInstance().SetNearlinkDeviceVolume(macAddress, volumeType, volume, updateUi);
370 AudioPolicyManager::GetInstance().ConfigDistributedRoutingRole(descriptor, castType);
371 AudioPolicyManager::GetInstance().SetDistributedRoutingRoleCallback(audioDistributedRoutingRoleCallback);
372 AudioPolicyManager::GetInstance().UnsetDistributedRoutingRoleCallback();
373 AudioPolicyManager::GetInstance().IsSpatializationEnabled();
374 AudioPolicyManager::GetInstance().IsSpatializationEnabled(address);
375 AudioPolicyManager::GetInstance().IsSpatializationEnabledForCurrentDevice();
376 AudioPolicyManager::GetInstance().SetSpatializationEnabled(enable);
377 AudioPolicyManager::GetInstance().SetSpatializationEnabled(selectedAudioDevice, enable);
378 AudioPolicyManager::GetInstance().IsHeadTrackingEnabled();
379 AudioPolicyManager::GetInstance().IsHeadTrackingEnabled(address);
380 AudioPolicyManager::GetInstance().SetHeadTrackingEnabled(enable);
381 AudioPolicyManager::GetInstance().SetHeadTrackingEnabled(selectedAudioDevice, enable);
382 AudioPolicyManager::GetInstance().RegisterSpatializationEnabledEventListener(
383 audioSpatializationEnabledChangeCallback);
384 AudioPolicyManager::GetInstance().RegisterSpatializationEnabledForCurrentDeviceEventListener(currentDeviceCallback);
385 AudioPolicyManager::GetInstance().RegisterHeadTrackingEnabledEventListener(audioHeadTrackingEnabledChangeCallback);
386 AudioPolicyManager::GetInstance().RegisterNnStateEventListener(audioNnStateChangeCallback);
387 AudioPolicyManager::GetInstance().UnregisterSpatializationEnabledEventListener();
388 AudioPolicyManager::GetInstance().UnregisterSpatializationEnabledForCurrentDeviceEventListener();
389 AudioPolicyManager::GetInstance().UnregisterHeadTrackingEnabledEventListener();
390 AudioPolicyManager::GetInstance().UnregisterNnStateEventListener();
391 }
392
AudioPolicyManagerSevenFuzzTest()393 void AudioPolicyManagerSevenFuzzTest()
394 {
395 std::string address = "address";
396 AudioSpatialDeviceState audioSpatialDeviceState;
397 uint32_t sessionId = GetData<uint32_t>();
398 StreamUsage streamUsage = GetData<StreamUsage>();
399 std::shared_ptr<AudioSpatializationStateChangeCallback> audioSpatializationStateChangeCallback;
400 std::set<int32_t> pids;
401 int32_t pid = GetData<int32_t>();
402 pids.insert(pid);
403 int32_t zoneId = GetData<int32_t>();
404 bool highResExist = GetData<bool>();
405 AudioSessionStrategy strategy;
406 DeviceType deviceType = GetData<DeviceType>();
407 SourceType sourceType = GetData<SourceType>();
408 bool isRunning = GetData<bool>();
409 std::shared_ptr<AudioSessionCallback> audioSessionCallback;
410 AudioSessionScene audioSessionScene = GetData<AudioSessionScene>();
411 std::shared_ptr<AudioSessionStateChangedCallback> stateChangedCallback;
412
413 AudioPolicyManager::GetInstance().IsHeadTrackingSupported();
414 AudioPolicyManager::GetInstance().IsHeadTrackingSupportedForDevice(address);
415 AudioPolicyManager::GetInstance().UpdateSpatialDeviceState(audioSpatialDeviceState);
416 AudioPolicyManager::GetInstance().RegisterSpatializationStateEventListener(sessionId,
417 streamUsage, audioSpatializationStateChangeCallback);
418 AudioPolicyManager::GetInstance().UnregisterSpatializationStateEventListener(sessionId);
419 AudioPolicyManager::GetInstance().CreateAudioInterruptZone(pids, zoneId);
420 AudioPolicyManager::GetInstance().AddAudioInterruptZonePids(pids, zoneId);
421 AudioPolicyManager::GetInstance().RemoveAudioInterruptZonePids(pids, zoneId);
422 AudioPolicyManager::GetInstance().ReleaseAudioInterruptZone(zoneId);
423 AudioPolicyManager::GetInstance().GetConverterConfig();
424 AudioPolicyManager::GetInstance().IsHighResolutionExist();
425 AudioPolicyManager::GetInstance().SetHighResolutionExist(highResExist);
426 AudioPolicyManager::GetInstance().ActivateAudioSession(strategy);
427 AudioPolicyManager::GetInstance().DeactivateAudioSession();
428 AudioPolicyManager::GetInstance().IsAudioSessionActivated();
429 AudioPolicyManager::GetInstance().SetInputDevice(deviceType, sessionId, sourceType, isRunning);
430 AudioPolicyManager::GetInstance().SetAudioSessionCallback(audioSessionCallback);
431 AudioPolicyManager::GetInstance().UnsetAudioSessionCallback();
432 AudioPolicyManager::GetInstance().UnsetAudioSessionCallback(audioSessionCallback);
433 AudioPolicyManager::GetInstance().SetAudioSessionScene(audioSessionScene);
434 AudioPolicyManager::GetInstance().SetAudioSessionStateChangeCallback(stateChangedCallback);
435 AudioPolicyManager::GetInstance().UnsetAudioSessionStateChangeCallback();
436 AudioPolicyManager::GetInstance().UnsetAudioSessionStateChangeCallback(stateChangedCallback);
437 }
438
AudioPolicyManagerEightFuzzTest()439 void AudioPolicyManagerEightFuzzTest()
440 {
441 DeviceType deviceType = GetData<DeviceType>();
442 std::shared_ptr<AudioSessionCurrentDeviceChangedCallback> deviceChangedCallback;
443 AudioSpatializationSceneType spatializationSceneType = GetData<AudioSpatializationSceneType>();
444 int32_t deviceId = GetData<int32_t>();
445 std::string macAddress = "macAddress";
446 std::shared_ptr<HeadTrackingDataRequestedChangeCallback> HTDRcallback;
447 std::shared_ptr<AudioDeviceRefiner> audioDeviceRefiner;
448 std::shared_ptr<AudioClientInfoMgrCallback> audioClientInfoMgrCallback;
449 AudioStreamChangeInfo streamChangeInfo;
450 int32_t sessionId = GetData<int32_t>();
451 bool isMuted = GetData<bool>();
452 int32_t appUid = GetData<int32_t>();
453
454 AudioPolicyManager::GetInstance().GetDefaultOutputDevice(deviceType);
455 AudioPolicyManager::GetInstance().SetDefaultOutputDevice(deviceType);
456 AudioPolicyManager::GetInstance().SetAudioSessionCurrentDeviceChangeCallback(deviceChangedCallback);
457 AudioPolicyManager::GetInstance().UnsetAudioSessionCurrentDeviceChangeCallback();
458 AudioPolicyManager::GetInstance().UnsetAudioSessionCurrentDeviceChangeCallback(deviceChangedCallback);
459 AudioPolicyManager::GetInstance().GetSpatializationSceneType();
460 AudioPolicyManager::GetInstance().SetSpatializationSceneType(spatializationSceneType);
461 AudioPolicyManager::GetInstance().GetMaxAmplitude(deviceId);
462 AudioPolicyManager::GetInstance().DisableSafeMediaVolume();
463 AudioPolicyManager::GetInstance().IsHeadTrackingDataRequested(macAddress);
464 AudioPolicyManager::GetInstance().RegisterHeadTrackingDataRequestedEventListener(macAddress, HTDRcallback);
465 AudioPolicyManager::GetInstance().UnregisterHeadTrackingDataRequestedEventListener(macAddress);
466 AudioPolicyManager::GetInstance().SetAudioDeviceRefinerCallback(audioDeviceRefiner);
467 AudioPolicyManager::GetInstance().UnsetAudioDeviceRefinerCallback();
468 AudioPolicyManager::GetInstance().SetAudioClientInfoMgrCallback(audioClientInfoMgrCallback);
469 AudioPolicyManager::GetInstance().ResetClientTrackerStubMap();
470 AudioPolicyManager::GetInstance().CheckAndRemoveClientTrackerStub(AUDIO_MODE_PLAYBACK, streamChangeInfo);
471 AudioPolicyManager::GetInstance().RemoveClientTrackerStub(sessionId);
472 AudioPolicyManager::GetInstance().SetAppRingMuted(appUid, isMuted);
473 }
474
AudioPolicyManagerNiNeFuzzTest()475 void AudioPolicyManagerNiNeFuzzTest()
476 {
477 bool isMute = GetData<bool>();
478 int32_t clientUid = GetData<int32_t>();
479 PolicyType type = GetData<PolicyType>();
480 std::string countryCode = "countryCode";
481 int32_t ltonetype = GetData<int32_t>();
482 vector<shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
483 vector<shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
484 StreamUsage streamUsage = GetData<StreamUsage>();
485 std::string address = "address";
486 int32_t volumeDegree = GetData<int32_t>();
487 AudioVolumeType volumeType = GetData<AudioVolumeType>();
488 int32_t volumeFlag = GetData<int32_t>();
489 uid_t uid = GetData<uid_t>();
490
491 AudioPolicyManager::GetInstance().SetMicrophoneMutePersistent(isMute, type);
492 AudioPolicyManager::GetInstance().GetPersistentMicMuteState();
493 AudioPolicyManager::GetInstance().IsMicrophoneMute();
494 AudioPolicyManager::GetInstance().GetAudioScene();
495 AudioPolicyManager::GetInstance().GetSystemActiveVolumeType(clientUid);
496 AudioPolicyManager::GetInstance().GetSupportedTones(countryCode);
497 AudioPolicyManager::GetInstance().GetToneConfig(ltonetype, countryCode);
498 AudioPolicyManager::GetInstance().GetCurrentRendererChangeInfos(audioRendererChangeInfos);
499 AudioPolicyManager::GetInstance().GetCurrentCapturerChangeInfos(audioCapturerChangeInfos);
500 AudioPolicyManager::GetInstance().GetSpatializationState(streamUsage);
501 AudioPolicyManager::GetInstance().IsSpatializationSupported();
502 AudioPolicyManager::GetInstance().IsSpatializationSupportedForDevice(address);
503 AudioPolicyManager::GetInstance().SetSystemVolumeDegree(volumeType, volumeDegree, volumeFlag, uid);
504 AudioPolicyManager::GetInstance().GetSystemVolumeDegree(volumeType, uid);
505 AudioPolicyManager::GetInstance().GetMinVolumeDegree(volumeType);
506 }
507
AudioPolicyManagerDeviceOneFuzzTest()508 void AudioPolicyManagerDeviceOneFuzzTest()
509 {
510 sptr<AudioRendererFilter> audioRendererFilter;
511 std::vector<std::shared_ptr<AudioDeviceDescriptor>> audioDeviceDescriptors;
512 int32_t uid = GetData<int32_t>();
513 int32_t pid = GetData<int32_t>();
514 AudioStreamType streamType = GetData<AudioStreamType>();
515 sptr<AudioCapturerFilter> audioCapturerFilter;
516 AudioDeviceUsage audioDevUsage = GetData<AudioDeviceUsage>();
517 DeviceFlag deviceFlag = GetData<DeviceFlag>();
518 AudioRendererInfo rendererInfo;
519 bool forceNoBTPermission = GetData<bool>();
520 AudioCapturerInfo capturerInfo;
521 bool active = GetData<bool>();
522 int32_t clientId = GetData<int32_t>();
523 std::shared_ptr<AudioManagerDeviceChangeCallback> audioManagerDeviceChangeCallback;
524 std::shared_ptr<AudioPreferredOutputDeviceChangeCallback> outputDeviceChangeCallback;
525 std::shared_ptr<AudioPreferredInputDeviceChangeCallback> inputDeviceChangeCallback;
526
527 AudioPolicyManager::GetInstance().SelectOutputDevice(audioRendererFilter, audioDeviceDescriptors);
528 AudioPolicyManager::GetInstance().GetSelectedDeviceInfo(uid, pid, streamType);
529 AudioPolicyManager::GetInstance().SelectInputDevice(audioCapturerFilter, audioDeviceDescriptors);
530 AudioPolicyManager::GetInstance().ExcludeOutputDevices(audioDevUsage, audioDeviceDescriptors);
531 AudioPolicyManager::GetInstance().UnexcludeOutputDevices(audioDevUsage, audioDeviceDescriptors);
532 AudioPolicyManager::GetInstance().GetExcludedDevices(audioDevUsage);
533 AudioPolicyManager::GetInstance().GetDevices(deviceFlag);
534 AudioPolicyManager::GetInstance().GetDevicesInner(deviceFlag);
535 AudioPolicyManager::GetInstance().GetPreferredOutputDeviceDescriptors(rendererInfo, forceNoBTPermission);
536 AudioPolicyManager::GetInstance().GetPreferredInputDeviceDescriptors(capturerInfo);
537 AudioPolicyManager::GetInstance().GetOutputDevice(audioRendererFilter);
538 AudioPolicyManager::GetInstance().GetInputDevice(audioCapturerFilter);
539 AudioPolicyManager::GetInstance().SetDeviceActive(DEVICE_TYPE_SPEAKER, active, uid);
540 AudioPolicyManager::GetInstance().GetActiveOutputDevice();
541 AudioPolicyManager::GetInstance().GetDmDeviceType();
542 AudioPolicyManager::GetInstance().GetActiveInputDevice();
543 AudioPolicyManager::GetInstance().SetDeviceChangeCallback(clientId, deviceFlag, audioManagerDeviceChangeCallback);
544 AudioPolicyManager::GetInstance().UnsetDeviceChangeCallback(clientId, deviceFlag, audioManagerDeviceChangeCallback);
545 AudioPolicyManager::GetInstance().SetPreferredOutputDeviceChangeCallback(rendererInfo, outputDeviceChangeCallback);
546 AudioPolicyManager::GetInstance().SetPreferredInputDeviceChangeCallback(capturerInfo, inputDeviceChangeCallback);
547 AudioPolicyManager::GetInstance().UnsetPreferredOutputDeviceChangeCallback(outputDeviceChangeCallback);
548 AudioPolicyManager::GetInstance().UnsetPreferredInputDeviceChangeCallback(inputDeviceChangeCallback);
549 }
550
AudioPolicyManagerDeviceTwoFuzzTest()551 void AudioPolicyManagerDeviceTwoFuzzTest()
552 {
553 uint32_t sessionId = GetData<uint32_t>();
554 std::weak_ptr<DeviceChangeWithInfoCallback> deviceChangeWithInfoCallback;
555 AudioDeviceUsage audioDevUsage = GetData<AudioDeviceUsage>();
556 int32_t clientId = GetData<int32_t>();
557 std::shared_ptr<AudioManagerAvailableDeviceChangeCallback> AMADCCallback;
558 bool active = GetData<bool>();
559 std::string address = "address";
560 int32_t uid = GetData<int32_t>();
561 AudioStreamChangeInfo streamChangeInfo;
562 AudioStreamDeviceChangeReasonExt reason;
563 PreferredType preferredType = GetData<PreferredType>();
564 std::shared_ptr<AudioDeviceDescriptor> desc;
565 std::shared_ptr<AudioDeviceAnahs> audioDeviceAnahs;
566 AudioPipeType pipeType = GetData<AudioPipeType>();
567 bool isConnected = GetData<bool>();
568 DeviceInfoUpdateCommand command = GetData<DeviceInfoUpdateCommand>();
569 std::shared_ptr<SleAudioOperationCallback> sleAudioOperationCallback;
570
571 AudioPolicyManager::GetInstance().RegisterDeviceChangeWithInfoCallback(sessionId, deviceChangeWithInfoCallback);
572 AudioPolicyManager::GetInstance().UnregisterDeviceChangeWithInfoCallback(sessionId);
573 AudioPolicyManager::GetInstance().GetAvailableDevices(audioDevUsage);
574 AudioPolicyManager::GetInstance().SetAvailableDeviceChangeCallback(clientId, audioDevUsage, AMADCCallback);
575 AudioPolicyManager::GetInstance().UnsetAvailableDeviceChangeCallback(clientId, audioDevUsage);
576 AudioPolicyManager::GetInstance().SetCallDeviceActive(DEVICE_TYPE_SPEAKER, active, address, uid);
577 AudioPolicyManager::GetInstance().GetActiveBluetoothDevice();
578 AudioPolicyManager::GetInstance().FetchOutputDeviceForTrack(streamChangeInfo, reason);
579 AudioPolicyManager::GetInstance().FetchInputDeviceForTrack(streamChangeInfo);
580 AudioPolicyManager::GetInstance().TriggerFetchDevice(reason);
581 AudioPolicyManager::GetInstance().SetPreferredDevice(preferredType, desc, uid);
582 AudioPolicyManager::GetInstance().SetAudioDeviceAnahsCallback(audioDeviceAnahs);
583 AudioPolicyManager::GetInstance().UnsetAudioDeviceAnahsCallback();
584 AudioPolicyManager::GetInstance().MoveToNewPipe(sessionId, pipeType);
585 AudioPolicyManager::GetInstance().SetDeviceConnectionStatus(desc, isConnected);
586 AudioPolicyManager::GetInstance().UpdateDeviceInfo(desc, command);
587 AudioPolicyManager::GetInstance().SetSleAudioOperationCallback(sleAudioOperationCallback);
588 }
589
AudioPolicyManagerIsDeviceActiveFuzzTest()590 void AudioPolicyManagerIsDeviceActiveFuzzTest()
591 {
592 AudioPolicyManager audioPolicyManager;
593 InternalDeviceType deviceType = GetData<InternalDeviceType>();
594 audioPolicyManager.IsDeviceActive(deviceType);
595 }
596
AudioPolicyManagerUnsetDeviceChangeCallbackFuzzTest()597 void AudioPolicyManagerUnsetDeviceChangeCallbackFuzzTest()
598 {
599 AudioPolicyManager audioPolicyManager;
600 int32_t clientId = GetData<int32_t>();
601 DeviceFlag flag = GetData<DeviceFlag>();
602 std::shared_ptr<AudioManagerDeviceChangeCallback> cb = std::make_shared<AudioManagerDeviceChangeCallbackFuzzTest>();
603 audioPolicyManager.audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
604
605 audioPolicyManager.UnsetDeviceChangeCallback(clientId, flag, cb);
606 }
607
AudioPolicyManagerSetPreferredInputDeviceChangeCallbackFuzzTest()608 void AudioPolicyManagerSetPreferredInputDeviceChangeCallbackFuzzTest()
609 {
610 AudioPolicyManager audioPolicyManager;
611
612 std::shared_ptr<AudioPreferredInputDeviceChangeCallback> callback =
613 std::make_shared<AudioPreferredInputDeviceChangeCallbackFuzzTest>();
614 audioPolicyManager.audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
615 AudioCapturerInfo capturerInfo;
616 audioPolicyManager.isAudioPolicyClientRegisted_ = GetData<bool>();
617 audioPolicyManager.SetPreferredInputDeviceChangeCallback(capturerInfo, callback);
618 }
619
AudioPolicyManagerUnsetPreferredOutputDeviceChangeCallbackFuzzTest()620 void AudioPolicyManagerUnsetPreferredOutputDeviceChangeCallbackFuzzTest()
621 {
622 AudioPolicyManager audioPolicyManager;
623 audioPolicyManager.audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
624 std::shared_ptr<AudioPreferredOutputDeviceChangeCallback> callback =
625 std::make_shared<AudioPreferredOutputDeviceChangeCallbackFuzzTest>();
626 audioPolicyManager.UnsetPreferredOutputDeviceChangeCallback(callback);
627 }
628
AudioPolicyManagerUnsetPreferredInputDeviceChangeCallbackFuzzTest()629 void AudioPolicyManagerUnsetPreferredInputDeviceChangeCallbackFuzzTest()
630 {
631 AudioPolicyManager audioPolicyManager;
632 audioPolicyManager.audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
633 std::shared_ptr<AudioPreferredInputDeviceChangeCallback> callback =
634 std::make_shared<AudioPreferredInputDeviceChangeCallbackFuzzTest>();
635 audioPolicyManager.UnsetPreferredInputDeviceChangeCallback(callback);
636 }
637
AudioPolicyManagerRegisterDeviceChangeWithInfoCallbackFuzzTest()638 void AudioPolicyManagerRegisterDeviceChangeWithInfoCallbackFuzzTest()
639 {
640 AudioPolicyManager audioPolicyManager;
641 audioPolicyManager.audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
642 std::shared_ptr<DeviceChangeWithInfoCallback> callbackByshared =
643 std::make_shared<DeviceChangeWithInfoCallbackFuzzTest>();
644 std::weak_ptr<DeviceChangeWithInfoCallback> callback = callbackByshared;
645 uint32_t sessionID = GetData<uint32_t>();
646 audioPolicyManager.isAudioPolicyClientRegisted_ = GetData<bool>();
647 audioPolicyManager.RegisterDeviceChangeWithInfoCallback(sessionID, callback);
648 }
649
AudioPolicyManagerUnregisterDeviceChangeWithInfoCallbackFuzzTest()650 void AudioPolicyManagerUnregisterDeviceChangeWithInfoCallbackFuzzTest()
651 {
652 AudioPolicyManager audioPolicyManager;
653 audioPolicyManager.audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
654 uint32_t sessionID = GetData<uint32_t>();
655 audioPolicyManager.UnregisterDeviceChangeWithInfoCallback(sessionID);
656 }
657
AudioPolicyManagerSetAvailableDeviceChangeCallbackFuzzTest()658 void AudioPolicyManagerSetAvailableDeviceChangeCallbackFuzzTest()
659 {
660 AudioPolicyManager audioPolicyManager;
661 int32_t clientId = GetData<int32_t>();
662 AudioDeviceUsage usage = GetData<AudioDeviceUsage>();
663 std::shared_ptr<AudioManagerAvailableDeviceChangeCallback> callback =
664 make_shared<AudioManagerAvailableDeviceChangeCallbackFuzzTest>();
665
666 audioPolicyManager.SetAvailableDeviceChangeCallback(clientId, usage, callback);
667 }
668
AudioPolicyManagerSetAudioDeviceAnahsCallbackFuzzTest()669 void AudioPolicyManagerSetAudioDeviceAnahsCallbackFuzzTest()
670 {
671 AudioPolicyManager audioPolicyManager;
672 audioPolicyManager.audioPolicyClientStubCB_ = new(std::nothrow) AudioPolicyClientStubImpl();
673 bool isNullptr = GetData<bool>();
674 if (isNullptr) {
675 audioPolicyManager.audioPolicyClientStubCB_ = nullptr;
676 }
677 std::shared_ptr<AudioDeviceAnahs> callback = make_shared<AudioDeviceAnahsFuzzTest>();
678
679 audioPolicyManager.SetAudioDeviceAnahsCallback(callback);
680 }
681
AudioPolicyManagerSetSleAudioOperationCallbackFuzzTest()682 void AudioPolicyManagerSetSleAudioOperationCallbackFuzzTest()
683 {
684 AudioPolicyManager audioPolicyManager;
685 std::shared_ptr<SleAudioOperationCallback> callback = make_shared<SleAudioDeviceManager>();
686
687 audioPolicyManager.SetSleAudioOperationCallback(callback);
688 }
689
690 typedef void (*TestFuncs[21])();
691
692 TestFuncs g_testFuncs = {
693 AudioPolicyManagerOneFuzzTest,
694 AudioPolicyManagerTwoFuzzTest,
695 AudioPolicyManagerThreeFuzzTest,
696 AudioPolicyManagerFourFuzzTest,
697 AudioPolicyManagerFiveFuzzTest,
698 AudioPolicyManagerSixFuzzTest,
699 AudioPolicyManagerSevenFuzzTest,
700 AudioPolicyManagerEightFuzzTest,
701 AudioPolicyManagerNiNeFuzzTest,
702 AudioPolicyManagerDeviceOneFuzzTest,
703 AudioPolicyManagerDeviceTwoFuzzTest,
704 AudioPolicyManagerIsDeviceActiveFuzzTest,
705 AudioPolicyManagerUnsetDeviceChangeCallbackFuzzTest,
706 AudioPolicyManagerSetPreferredInputDeviceChangeCallbackFuzzTest,
707 AudioPolicyManagerUnsetPreferredOutputDeviceChangeCallbackFuzzTest,
708 AudioPolicyManagerUnsetPreferredInputDeviceChangeCallbackFuzzTest,
709 AudioPolicyManagerRegisterDeviceChangeWithInfoCallbackFuzzTest,
710 AudioPolicyManagerUnregisterDeviceChangeWithInfoCallbackFuzzTest,
711 AudioPolicyManagerSetAvailableDeviceChangeCallbackFuzzTest,
712 AudioPolicyManagerSetAudioDeviceAnahsCallbackFuzzTest,
713 AudioPolicyManagerSetSleAudioOperationCallbackFuzzTest,
714 };
715
FuzzTest(const uint8_t * rawData,size_t size)716 bool FuzzTest(const uint8_t* rawData, size_t size)
717 {
718 if (rawData == nullptr) {
719 return false;
720 }
721
722 // initialize data
723 RAW_DATA = rawData;
724 g_dataSize = size;
725 g_pos = 0;
726
727 uint32_t code = GetData<uint32_t>();
728 uint32_t len = GetArrLength(g_testFuncs);
729 if (len > 0) {
730 g_testFuncs[code % len]();
731 } else {
732 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
733 }
734
735 return true;
736 }
737 } // namespace AudioStandard
738 } // namesapce OHOS
739
740 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)741 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
742 {
743 if (size < OHOS::AudioStandard::THRESHOLD) {
744 return 0;
745 }
746
747 OHOS::AudioStandard::FuzzTest(data, size);
748 return 0;
749 }