• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 "audio_policy_server.h"
20 #include "audio_policy_service.h"
21 #include "message_parcel.h"
22 #include "accesstoken_kit.h"
23 #include "nativetoken_kit.h"
24 #include "token_setproc.h"
25 #include "access_token.h"
26 using namespace std;
27 
28 namespace OHOS {
29 namespace AudioStandard {
30 bool g_hasPermission = false;
31 constexpr int32_t OFFSET = 4;
32 const int32_t MOD_NUM_TWO = 2;
33 const int32_t CONNECTING_NUMBER = 10;
34 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy";
35 const int32_t SYSTEM_ABILITY_ID = 3009;
36 const bool RUN_ON_CREATE = false;
37 const int32_t LIMITSIZE = 4;
38 const int32_t SHIFT_LEFT_8 = 8;
39 const int32_t SHIFT_LEFT_16 = 16;
40 const int32_t SHIFT_LEFT_24 = 24;
41 const uint32_t LIMIT_ONE = 0;
42 const uint32_t LIMIT_TWO = 30;
43 const uint32_t LIMIT_THREE = 60;
44 const uint32_t LIMIT_FOUR = static_cast<uint32_t>(AudioPolicyInterfaceCode::AUDIO_POLICY_MANAGER_CODE_MAX);
45 bool g_hasServerInit = false;
46 const uint8_t TESTSIZE = 73;
47 typedef void (*TestPtr)(const uint8_t *, size_t);
48 
49 static const uint8_t* RAW_DATA = nullptr;
50 static size_t g_dataSize = 0;
51 static size_t g_pos;
52 static int32_t NUM_2 = 2;
53 
54 typedef void (*TestFuncs)();
55 
56 template<class T>
GetData()57 T GetData()
58 {
59     T object {};
60     size_t objectSize = sizeof(object);
61     if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
62         return object;
63     }
64     errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
65     if (ret != EOK) {
66         return {};
67     }
68     g_pos += objectSize;
69     return object;
70 }
71 
72 class RemoteObjectTestStub : public IRemoteObject {
73 public:
RemoteObjectTestStub()74     RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()75     int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)76     int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)77     bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)78     bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)79     int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
80 
81     DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub");
82 };
83 
GetServerPtr()84 sptr<AudioPolicyServer> GetServerPtr()
85 {
86     static sptr<AudioPolicyServer> server = sptr<AudioPolicyServer>::MakeSptr(SYSTEM_ABILITY_ID, RUN_ON_CREATE);
87     if (!g_hasServerInit && server != nullptr) {
88         server->OnStart();
89         server->OnAddSystemAbility(AUDIO_DISTRIBUTED_SERVICE_ID, "");
90 #ifdef FEATURE_MULTIMODALINPUT_INPUT
91         server->OnAddSystemAbility(MULTIMODAL_INPUT_SERVICE_ID, "");
92 #endif
93         server->OnAddSystemAbility(BLUETOOTH_HOST_SYS_ABILITY_ID, "");
94         server->OnAddSystemAbility(POWER_MANAGER_SERVICE_ID, "");
95         server->OnAddSystemAbility(SUBSYS_ACCOUNT_SYS_ABILITY_ID_BEGIN, "");
96         server->audioPolicyService_.SetDefaultDeviceLoadFlag(true);
97         g_hasServerInit = true;
98     }
99     return server;
100 }
101 
Convert2Uint32(const uint8_t * ptr)102 uint32_t Convert2Uint32(const uint8_t *ptr)
103 {
104     if (ptr == nullptr) {
105         return 0;
106     }
107     /* Move the 0th digit to the left by 24 bits, the 1st digit to the left by 16 bits,
108        the 2nd digit to the left by 8 bits, and the 3rd digit not to the left */
109     return (ptr[0] << SHIFT_LEFT_24) | (ptr[1] << SHIFT_LEFT_16) | (ptr[2] << SHIFT_LEFT_8) | (ptr[3]);
110 }
111 
AudioFuzzTestGetPermission()112 void AudioFuzzTestGetPermission()
113 {
114     if (!g_hasPermission) {
115         uint64_t tokenId;
116         constexpr int perNum = 10;
117         const char *perms[perNum] = {
118             "ohos.permission.MICROPHONE",
119             "ohos.permission.MANAGE_INTELLIGENT_VOICE",
120             "ohos.permission.MANAGE_AUDIO_CONFIG",
121             "ohos.permission.MICROPHONE_CONTROL",
122             "ohos.permission.MODIFY_AUDIO_SETTINGS",
123             "ohos.permission.ACCESS_NOTIFICATION_POLICY",
124             "ohos.permission.USE_BLUETOOTH",
125             "ohos.permission.CAPTURE_VOICE_DOWNLINK_AUDIO",
126             "ohos.permission.RECORD_VOICE_CALL",
127             "ohos.permission.MANAGE_SYSTEM_AUDIO_EFFECTS",
128         };
129 
130         NativeTokenInfoParams infoInstance = {
131             .dcapsNum = 0,
132             .permsNum = 10,
133             .aclsNum = 0,
134             .dcaps = nullptr,
135             .perms = perms,
136             .acls = nullptr,
137             .processName = "audiofuzztest",
138             .aplStr = "system_basic",
139         };
140         tokenId = GetAccessTokenId(&infoInstance);
141         SetSelfTokenID(tokenId);
142         OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
143         g_hasPermission = true;
144     }
145 }
146 
AudioPolicyServiceDumpTest(const uint8_t * rawData,size_t size)147 void AudioPolicyServiceDumpTest(const uint8_t *rawData, size_t size)
148 {
149     if (rawData == nullptr || size < LIMITSIZE) {
150         return;
151     }
152     uint32_t code = Convert2Uint32(rawData) % (LIMIT_TWO - LIMIT_ONE + 1) + LIMIT_ONE;
153 
154     rawData = rawData + OFFSET;
155     size = size - OFFSET;
156 
157     std::string dumpStr = "";
158     GetServerPtr()->audioPolicyDump_.DevicesInfoDump(dumpStr);
159     GetServerPtr()->audioPolicyDump_.AudioModeDump(dumpStr);
160     GetServerPtr()->audioPolicyDump_.AudioPolicyParserDump(dumpStr);
161     GetServerPtr()->audioPolicyDump_.XmlParsedDataMapDump(dumpStr);
162     GetServerPtr()->audioPolicyDump_.StreamVolumesDump(dumpStr);
163     std::map<DeviceVolumeType, std::shared_ptr<DeviceVolumeInfo>> deviceVolumeInfoMap;
164     GetServerPtr()->audioPolicyDump_.DeviceVolumeInfosDump(dumpStr, deviceVolumeInfoMap);
165     GetServerPtr()->audioPolicyDump_.AudioStreamDump(dumpStr);
166     GetServerPtr()->audioPolicyDump_.GetVolumeConfigDump(dumpStr);
167     GetServerPtr()->audioPolicyDump_.GetGroupInfoDump(dumpStr);
168     GetServerPtr()->audioPolicyDump_.GetCallStatusDump(dumpStr);
169     GetServerPtr()->audioPolicyDump_.GetRingerModeDump(dumpStr);
170     GetServerPtr()->audioPolicyDump_.GetMicrophoneDescriptorsDump(dumpStr);
171     GetServerPtr()->audioPolicyDump_.GetCapturerStreamDump(dumpStr);
172     GetServerPtr()->audioPolicyDump_.GetOffloadStatusDump(dumpStr);
173     GetServerPtr()->audioPolicyDump_.EffectManagerInfoDump(dumpStr);
174     GetServerPtr()->audioPolicyDump_.MicrophoneMuteInfoDump(dumpStr);
175     GetServerPtr()->audioPolicyDump_.GetVolumeConfigDump(dumpStr);
176     GetServerPtr()->audioPolicyDump_.GetVolumeConfigDump(dumpStr);
177     GetServerPtr()->audioPolicyDump_.GetVolumeConfigDump(dumpStr);
178 
179     GetServerPtr()->interruptService_->AudioInterruptZoneDump(dumpStr);
180 }
181 
AudioPolicyServiceDeviceTest(const uint8_t * rawData,size_t size)182 void AudioPolicyServiceDeviceTest(const uint8_t *rawData, size_t size)
183 {
184     if (rawData == nullptr || size < LIMITSIZE) {
185         return;
186     }
187     uint8_t num = *reinterpret_cast<const uint8_t *>(rawData);
188     DeviceType deviceType = static_cast<DeviceType>(num % DEVICE_TYPE_FILE_SOURCE);
189     bool isConnected = static_cast<bool>(num % MOD_NUM_TWO);
190     AudioDeviceDescriptor audioDeviceDescriptor;
191     GetServerPtr()->audioPolicyService_.OnPnpDeviceStatusUpdated(audioDeviceDescriptor, isConnected);
192 
193     int32_t state = (num % MOD_NUM_TWO) + CONNECTING_NUMBER; // DATA_LINK_CONNECTING = 10, DATA_LINK_CONNECTED = 11;
194 
195     GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->UpdateOffloadWhenActiveDeviceSwitchFromA2dp();
196     GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->GetA2dpOffloadCodecAndSendToDsp();
197     GetServerPtr()->audioPolicyService_.audioMicrophoneDescriptor_.UpdateAudioCapturerMicrophoneDescriptor(deviceType);
198 
199     // the max value of BluetoothOffloadState is A2DP_OFFLOAD.
200     BluetoothOffloadState flag = static_cast<BluetoothOffloadState>(num % (A2DP_OFFLOAD + 1));
201     GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleA2dpDeviceInOffload(flag);
202     GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->HandleA2dpDeviceOutOffload(flag);
203 
204     uint32_t sessionId = static_cast<uint32_t>(num);
205     // the max value of AudioPipeType is PIPE_TYPE_DIRECT_VOIP.
206     AudioPipeType pipeType = static_cast<AudioPipeType>(num % (PIPE_TYPE_DIRECT_VOIP + 1));
207     GetServerPtr()->audioPolicyService_.audioOffloadStream_.MoveToNewPipeInner(sessionId, pipeType);
208 
209     GetServerPtr()->audioPolicyService_.audioOffloadStream_.LoadMchModule();
210     GetServerPtr()->audioPolicyService_.audioOffloadStream_.ConstructMchAudioModuleInfo(deviceType);
211     GetServerPtr()->audioPolicyService_.audioOffloadStream_.LoadOffloadModule();
212     GetServerPtr()->audioPolicyService_.audioOffloadStream_.UnloadOffloadModule();
213     GetServerPtr()->audioPolicyService_.audioOffloadStream_.ConstructOffloadAudioModuleInfo(deviceType);
214 }
215 
AudioPolicyServiceAccountTest(const uint8_t * rawData,size_t size)216 void AudioPolicyServiceAccountTest(const uint8_t *rawData, size_t size)
217 {
218     if (rawData == nullptr || size < LIMITSIZE) {
219         return;
220     }
221 
222     uint8_t num = *reinterpret_cast<const uint8_t *>(rawData);
223     GetServerPtr()->audioPolicyService_.NotifyAccountsChanged(num);
224 }
225 
AudioPolicyServiceSafeVolumeTest(const uint8_t * rawData,size_t size)226 void AudioPolicyServiceSafeVolumeTest(const uint8_t *rawData, size_t size)
227 {
228     if (rawData == nullptr || size < LIMITSIZE) {
229         return;
230     }
231     uint32_t code = Convert2Uint32(rawData) % (LIMIT_TWO - LIMIT_ONE + 1) + LIMIT_ONE;
232 
233     rawData = rawData + OFFSET;
234     size = size - OFFSET;
235 
236     GetServerPtr()->audioPolicyService_.audioVolumeManager_.SetDeviceSafeVolumeStatus();
237 }
238 
AudioPolicyServiceInterfaceTest(const uint8_t * rawData,size_t size)239 void AudioPolicyServiceInterfaceTest(const uint8_t *rawData, size_t size)
240 {
241     if (rawData == nullptr || size < LIMITSIZE) {
242         return;
243     }
244 
245     bool fuzzBool = *reinterpret_cast<const bool *>(rawData);
246     int32_t fuzzInt32One = *reinterpret_cast<const int8_t *>(rawData);
247     int32_t fuzzInt32Two = *reinterpret_cast<const int8_t *>(rawData);
248     int32_t fuzzInt32Three = *reinterpret_cast<const int8_t *>(rawData);
249     int32_t fuzzFloat = *reinterpret_cast<const float *>(rawData);
250     std::string fuzzNetworkId = "FUZZNETWORKID";
251     std::string fuzzString(reinterpret_cast<const char*>(rawData), size - 1);
252 
253     AudioStreamType fuzzAudioStreamType = *reinterpret_cast<const AudioStreamType *>(rawData);
254     DeviceType fuzzDeviceType = *reinterpret_cast<const DeviceType *>(rawData);
255     DeviceRole fuzzDeviceRole = *reinterpret_cast<const DeviceRole *>(rawData);
256     StreamUsage fuzzStreamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
257 
258     AudioDeviceDescriptor fuzzAudioDeviceDescriptor;
259     std::shared_ptr<AudioDeviceDescriptor> fuzzAudioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
260     std::vector<std::shared_ptr<AudioDeviceDescriptor>> fuzzAudioDeviceDescriptorSptrVector;
261     fuzzAudioDeviceDescriptorSptrVector.push_back(fuzzAudioDeviceDescriptorSptr);
262     sptr<AudioRendererFilter> fuzzAudioRendererFilter = new AudioRendererFilter();
263 
264     // set offload support on for covery
265     GetServerPtr()->audioPolicyService_.audioOffloadStream_.isOffloadAvailable_ = true;
266     GetServerPtr()->audioPolicyService_.audioRecoveryDevice_.HandleRecoveryPreferredDevices(fuzzInt32One,
267         fuzzInt32Two, fuzzInt32Three);
268     GetServerPtr()->audioPolicyService_.audioA2dpOffloadManager_->GetVolumeGroupType(fuzzDeviceType);
269     GetServerPtr()->audioPolicyService_.audioOffloadStream_.SetOffloadMode();
270     GetServerPtr()->audioPolicyService_.audioOffloadStream_.ResetOffloadMode(fuzzInt32One);
271     GetServerPtr()->audioPolicyService_.audioOffloadStream_.OffloadStreamReleaseCheck(fuzzInt32One);
272     GetServerPtr()->audioPolicyService_.audioOffloadStream_.RemoteOffloadStreamRelease(fuzzInt32One);
273     GetServerPtr()->audioPolicyService_.audioActiveDevice_.CheckActiveOutputDeviceSupportOffload();
274     GetServerPtr()->audioPolicyService_.audioOffloadStream_.GetOffloadAvailableFromXml();
275     GetServerPtr()->audioPolicyService_.SetSourceOutputStreamMute(fuzzInt32One, fuzzBool);
276     GetServerPtr()->audioPolicyService_.audioDeviceCommon_.IsDeviceConnected(fuzzAudioDeviceDescriptorSptr);
277     GetServerPtr()->audioPolicyService_.audioDeviceCommon_.DeviceParamsCheck(fuzzDeviceRole,
278         fuzzAudioDeviceDescriptorSptrVector);
279     GetServerPtr()->audioPolicyService_.audioActiveDevice_.NotifyUserSelectionEventToBt(fuzzAudioDeviceDescriptorSptr);
280     GetServerPtr()->audioPolicyService_.audioRecoveryDevice_.SetRenderDeviceForUsage(fuzzStreamUsage,
281         fuzzAudioDeviceDescriptorSptr);
282     GetServerPtr()->audioPolicyService_.audioRecoveryDevice_.SelectOutputDevice(
283         fuzzAudioRendererFilter, fuzzAudioDeviceDescriptorSptrVector);
284     GetServerPtr()->audioPolicyService_.audioRecoveryDevice_.WriteSelectOutputSysEvents(
285         fuzzAudioDeviceDescriptorSptrVector, fuzzStreamUsage);
286     GetServerPtr()->audioPolicyService_.audioRecoveryDevice_.SelectFastOutputDevice(
287         fuzzAudioRendererFilter, fuzzAudioDeviceDescriptorSptr);
288     GetServerPtr()->audioPolicyService_.audioDeviceCommon_.FilterSourceOutputs(fuzzInt32One);
289     GetServerPtr()->audioPolicyService_.OnPnpDeviceStatusUpdated(fuzzAudioDeviceDescriptor, fuzzBool);
290 }
291 
AudioDeviceConnectTest(const uint8_t * rawData,size_t size)292 void AudioDeviceConnectTest(const uint8_t *rawData, size_t size)
293 {
294     if (rawData == nullptr || size < LIMITSIZE) {
295         return;
296     }
297 
298     // Coverage first
299     AudioStreamInfo streamInfo;
300     streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
301     streamInfo.channels = AudioChannel::STEREO;
302     streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
303     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_WIRED_HEADSET, true,
304         "", "fuzzDevice", streamInfo);
305     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_WIRED_HEADSET, false,
306         "", "fuzzDevice", streamInfo);
307 
308     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_USB_HEADSET, true,
309         "", "fuzzDevice", streamInfo);
310     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_USB_HEADSET, false,
311         "", "fuzzDevice", streamInfo);
312 
313     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_DP, true,
314         "", "fuzzDevice", streamInfo);
315     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_DP, false,
316         "", "fuzzDevice", streamInfo);
317 
318     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP, true,
319         "08:00:20:0A:8C:6D", "fuzzBtDevice", streamInfo);
320     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP, false,
321         "08:00:20:0A:8C:6D", "fuzzBtDevice", streamInfo);
322 
323     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, true,
324         "08:00:20:0A:8C:6D", "fuzzBtDevice", streamInfo);
325     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(DeviceType::DEVICE_TYPE_BLUETOOTH_SCO, false,
326         "08:00:20:0A:8C:6D", "fuzzBtDevice", streamInfo);
327 
328     bool fuzzBool = *reinterpret_cast<const bool *>(rawData);
329     std::string fuzzString(reinterpret_cast<const char*>(rawData), size - 1);
330     DeviceType fuzzDeviceType = *reinterpret_cast<const DeviceType *>(rawData);
331     AudioSamplingRate fuzzAudioSamplingRate = *reinterpret_cast<const AudioSamplingRate *>(rawData);
332     AudioChannel fuzzAudioChannel = *reinterpret_cast<const AudioChannel *>(rawData);
333     AudioSampleFormat fuzzAudioSampleFormat = *reinterpret_cast<const AudioSampleFormat *>(rawData);
334     streamInfo.samplingRate = fuzzAudioSamplingRate;
335     streamInfo.channels = fuzzAudioChannel;
336     streamInfo.format = fuzzAudioSampleFormat;
337 
338     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(fuzzDeviceType, fuzzBool, fuzzString,
339         "fuzzDevice", streamInfo);
340 }
341 
AudioPolicyServiceSubscribeSafeVolumeEventFuzztest(const uint8_t * rawData,size_t size)342 void AudioPolicyServiceSubscribeSafeVolumeEventFuzztest(const uint8_t *rawData, size_t size)
343 {
344     if (rawData == nullptr || size < LIMITSIZE) {
345         return;
346     }
347 
348     GetServerPtr()->audioPolicyService_.SubscribeSafeVolumeEvent();
349 }
350 
AudioPolicyServiceOnReceiveEventFuzztest(const uint8_t * rawData,size_t size)351 void AudioPolicyServiceOnReceiveEventFuzztest(const uint8_t *rawData, size_t size)
352 {
353     if (rawData == nullptr || size < LIMITSIZE) {
354         return;
355     }
356     EventFwk::CommonEventData eventData;
357     OHOS::EventFwk::Want want;
358     want.SetAction("usual.event.LOCALE_CHANGED");
359     eventData.SetWant(want);
360     GetServerPtr()->audioPolicyService_.OnReceiveEvent(eventData);
361 }
362 
AudioPolicyServiceSetAppVolumeLevelFuzztest(const uint8_t * rawData,size_t size)363 void AudioPolicyServiceSetAppVolumeLevelFuzztest(const uint8_t *rawData, size_t size)
364 {
365     if (rawData == nullptr || size < LIMITSIZE) {
366         return;
367     }
368 
369     int32_t appUid = GetData<int32_t>() % NUM_2;
370     int32_t volumeLevel = GetData<int32_t>() % NUM_2;
371     GetServerPtr()->audioPolicyService_.SetAppVolumeLevel(appUid, volumeLevel);
372 }
373 
AudioPolicyServiceSetSourceOutputStreamMuteFuzztest(const uint8_t * rawData,size_t size)374 void AudioPolicyServiceSetSourceOutputStreamMuteFuzztest(const uint8_t *rawData, size_t size)
375 {
376     if (rawData == nullptr || size < LIMITSIZE) {
377         return;
378     }
379 
380     int32_t uid = GetData<int32_t>() % NUM_2;
381     bool setMute = true;
382     GetServerPtr()->audioPolicyService_.SetSourceOutputStreamMute(uid, setMute);
383 }
384 
AudioPolicyServiceGetSelectedDeviceInfoFuzztest(const uint8_t * rawData,size_t size)385 void AudioPolicyServiceGetSelectedDeviceInfoFuzztest(const uint8_t *rawData, size_t size)
386 {
387     if (rawData == nullptr || size < LIMITSIZE) {
388         return;
389     }
390 
391     int32_t uid = GetData<int32_t>() % NUM_2;
392     int32_t pid = GetData<int32_t>() % NUM_2;
393     AudioStreamType fuzzAudioStreamType = *reinterpret_cast<const AudioStreamType *>(rawData);
394     GetServerPtr()->audioPolicyService_.GetSelectedDeviceInfo(uid, pid, fuzzAudioStreamType);
395 }
396 
AudioPolicyServiceGetDistributedRoutingRoleInfoFuzztest(const uint8_t * rawData,size_t size)397 void AudioPolicyServiceGetDistributedRoutingRoleInfoFuzztest(const uint8_t *rawData, size_t size)
398 {
399     if (rawData == nullptr || size < LIMITSIZE) {
400         return;
401     }
402 
403     GetServerPtr()->audioPolicyService_.GetDistributedRoutingRoleInfo();
404 }
405 
AudioPolicyServiceNotifyCapturerAddedFuzztest(const uint8_t * rawData,size_t size)406 void AudioPolicyServiceNotifyCapturerAddedFuzztest(const uint8_t *rawData, size_t size)
407 {
408     if (rawData == nullptr || size < LIMITSIZE) {
409         return;
410     }
411 
412     uint32_t sessionId = GetData<uint32_t>() % NUM_2;
413     AudioStreamInfo streamInfo;
414     AudioCapturerInfo capturerInfo;
415     GetServerPtr()->audioPolicyService_.NotifyCapturerAdded(capturerInfo, streamInfo, sessionId);
416 }
417 
AudioPolicyServiceNotifyWakeUpCapturerRemovedFuzztest(const uint8_t * rawData,size_t size)418 void AudioPolicyServiceNotifyWakeUpCapturerRemovedFuzztest(const uint8_t *rawData, size_t size)
419 {
420     if (rawData == nullptr || size < LIMITSIZE) {
421         return;
422     }
423 
424     GetServerPtr()->audioPolicyService_.NotifyWakeUpCapturerRemoved();
425 }
426 
AudioPolicyServiceGetFastStreamInfoFuzztest(const uint8_t * rawData,size_t size)427 void AudioPolicyServiceGetFastStreamInfoFuzztest(const uint8_t *rawData, size_t size)
428 {
429     if (rawData == nullptr || size < LIMITSIZE) {
430         return;
431     }
432 
433     GetServerPtr()->audioPolicyService_.GetFastStreamInfo();
434 }
435 
AudioPolicyServiceIsAbsVolumeSupportedFuzztest(const uint8_t * rawData,size_t size)436 void AudioPolicyServiceIsAbsVolumeSupportedFuzztest(const uint8_t *rawData, size_t size)
437 {
438     if (rawData == nullptr || size < LIMITSIZE) {
439         return;
440     }
441 
442     GetServerPtr()->audioPolicyService_.IsAbsVolumeSupported();
443 }
444 
445 
AudioPolicyServiceGetDevicesFuzztest(const uint8_t * rawData,size_t size)446 void AudioPolicyServiceGetDevicesFuzztest(const uint8_t *rawData, size_t size)
447 {
448     if (rawData == nullptr || size < LIMITSIZE) {
449         return;
450     }
451     DeviceFlag deviceFlag = DeviceFlag::ALL_DEVICES_FLAG;
452     GetServerPtr()->audioPolicyService_.GetDevices(deviceFlag);
453 }
454 
AudioPolicyServiceGetPreferredInputDeviceDescriptorsFuzztest(const uint8_t * rawData,size_t size)455 void AudioPolicyServiceGetPreferredInputDeviceDescriptorsFuzztest(const uint8_t *rawData, size_t size)
456 {
457     if (rawData == nullptr || size < LIMITSIZE) {
458         return;
459     }
460     AudioCapturerInfo captureInfo;
461     std::string networkId = "";
462     GetServerPtr()->audioPolicyService_.GetPreferredInputDeviceDescriptors(captureInfo, networkId);
463 }
464 
AudioPolicyServiceGetPreferredOutputDeviceDescInnerFuzztest(const uint8_t * rawData,size_t size)465 void AudioPolicyServiceGetPreferredOutputDeviceDescInnerFuzztest(const uint8_t *rawData, size_t size)
466 {
467     if (rawData == nullptr || size < LIMITSIZE) {
468         return;
469     }
470     AudioRendererInfo rendererInfo;
471     std::string networkId = "";
472     GetServerPtr()->audioPolicyService_.GetPreferredOutputDeviceDescInner(rendererInfo, networkId);
473 }
474 
AudioPolicyServiceGetOutputDeviceFuzztest(const uint8_t * rawData,size_t size)475 void AudioPolicyServiceGetOutputDeviceFuzztest(const uint8_t *rawData, size_t size)
476 {
477     if (rawData == nullptr || size < LIMITSIZE) {
478         return;
479     }
480     sptr<AudioRendererFilter> fuzzAudioRendererFilter = new AudioRendererFilter();
481     GetServerPtr()->audioPolicyService_.GetOutputDevice(fuzzAudioRendererFilter);
482 }
483 
AudioPolicyServiceGetInputDeviceFuzztest(const uint8_t * rawData,size_t size)484 void AudioPolicyServiceGetInputDeviceFuzztest(const uint8_t *rawData, size_t size)
485 {
486     if (rawData == nullptr || size < LIMITSIZE) {
487         return;
488     }
489     sptr<AudioCapturerFilter> audioCapturerFilter(new AudioCapturerFilter());
490     GetServerPtr()->audioPolicyService_.GetInputDevice(audioCapturerFilter);
491 }
492 
AudioPolicyServiceGetActiveOutputDeviceDescriptorFuzztest(const uint8_t * rawData,size_t size)493 void AudioPolicyServiceGetActiveOutputDeviceDescriptorFuzztest(const uint8_t *rawData, size_t size)
494 {
495     if (rawData == nullptr || size < LIMITSIZE) {
496         return;
497     }
498     GetServerPtr()->audioPolicyService_.GetActiveOutputDeviceDescriptor();
499 }
500 
AudioPolicyServiceOnUpdateAnahsSupportFuzztest(const uint8_t * rawData,size_t size)501 void AudioPolicyServiceOnUpdateAnahsSupportFuzztest(const uint8_t *rawData, size_t size)
502 {
503     if (rawData == nullptr || size < LIMITSIZE) {
504         return;
505     }
506     std::string anahsShowType = "anahsShowType";
507     GetServerPtr()->audioPolicyService_.OnUpdateAnahsSupport(anahsShowType);
508 }
509 
AudioPolicyServiceOnPnpDeviceStatusUpdatedFuzztest(const uint8_t * rawData,size_t size)510 void AudioPolicyServiceOnPnpDeviceStatusUpdatedFuzztest(const uint8_t *rawData, size_t size)
511 {
512     if (rawData == nullptr || size < LIMITSIZE) {
513         return;
514     }
515     bool isConnected = true;
516     AudioDeviceDescriptor audioDeviceDescriptor;
517     GetServerPtr()->audioPolicyService_.OnPnpDeviceStatusUpdated(audioDeviceDescriptor, isConnected);
518 }
519 
AudioPolicyServiceOnDeviceStatusUpdatedFuzztest(const uint8_t * rawData,size_t size)520 void AudioPolicyServiceOnDeviceStatusUpdatedFuzztest(const uint8_t *rawData, size_t size)
521 {
522     if (rawData == nullptr || size < LIMITSIZE) {
523         return;
524     }
525     bool isConnected = true;
526     AudioDeviceDescriptor audioDeviceDescriptor;
527     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(audioDeviceDescriptor, isConnected);
528     DStatusInfo dStatusInfo;
529     GetServerPtr()->audioPolicyService_.OnDeviceStatusUpdated(dStatusInfo, isConnected);
530 }
531 
AudioPolicyServiceUpdateA2dpOffloadFlagBySpatialServiceFuzztest(const uint8_t * rawData,size_t size)532 void AudioPolicyServiceUpdateA2dpOffloadFlagBySpatialServiceFuzztest(const uint8_t *rawData, size_t size)
533 {
534     if (rawData == nullptr || size < LIMITSIZE) {
535         return;
536     }
537     std::string macAddress = "11-22-33-44-55-66";
538     std::unordered_map<uint32_t, bool> sessionIDToSpatializationEnableMap;
539     GetServerPtr()->audioPolicyService_.UpdateA2dpOffloadFlagBySpatialService(macAddress,
540         sessionIDToSpatializationEnableMap);
541 }
542 
AudioPolicyServiceRegisterRemoteDevStatusCallbackFuzztest(const uint8_t * rawData,size_t size)543 void AudioPolicyServiceRegisterRemoteDevStatusCallbackFuzztest(const uint8_t *rawData, size_t size)
544 {
545     if (rawData == nullptr || size < LIMITSIZE) {
546         return;
547     }
548     GetServerPtr()->audioPolicyService_.RegisterRemoteDevStatusCallback();
549 }
550 
AudioPolicyServiceGetAllSinkInputsFuzztest(const uint8_t * rawData,size_t size)551 void AudioPolicyServiceGetAllSinkInputsFuzztest(const uint8_t *rawData, size_t size)
552 {
553     if (rawData == nullptr || size < LIMITSIZE) {
554         return;
555     }
556 
557     std::vector<SinkInput> sinkInputs;
558     GetServerPtr()->audioPolicyService_.GetAllSinkInputs(sinkInputs);
559 }
560 
AudioPolicyServiceRegisterAccessibilityMonitorHelperFuzztest(const uint8_t * rawData,size_t size)561 void AudioPolicyServiceRegisterAccessibilityMonitorHelperFuzztest(const uint8_t *rawData, size_t size)
562 {
563     if (rawData == nullptr || size < LIMITSIZE) {
564         return;
565     }
566 
567     GetServerPtr()->audioPolicyService_.RegisterAccessibilityMonitorHelper();
568 }
569 
AudioPolicyServiceOnServiceConnectedFuzztest(const uint8_t * rawData,size_t size)570 void AudioPolicyServiceOnServiceConnectedFuzztest(const uint8_t *rawData, size_t size)
571 {
572     if (rawData == nullptr || size < LIMITSIZE) {
573         return;
574     }
575 
576     AudioServiceIndex serviceIndex = AudioServiceIndex::HDI_SERVICE_INDEX;
577     GetServerPtr()->audioPolicyService_.OnServiceConnected(serviceIndex);
578 }
579 
AudioPolicyServiceOnServiceDisconnectedFuzztest(const uint8_t * rawData,size_t size)580 void AudioPolicyServiceOnServiceDisconnectedFuzztest(const uint8_t *rawData, size_t size)
581 {
582     if (rawData == nullptr || size < LIMITSIZE) {
583         return;
584     }
585 
586     AudioServiceIndex serviceIndex = AudioServiceIndex::HDI_SERVICE_INDEX;
587     GetServerPtr()->audioPolicyService_.OnServiceDisconnected(serviceIndex);
588 }
589 
AudioPolicyServiceOnForcedDeviceSelectedFuzztest(const uint8_t * rawData,size_t size)590 void AudioPolicyServiceOnForcedDeviceSelectedFuzztest(const uint8_t *rawData, size_t size)
591 {
592     if (rawData == nullptr || size < LIMITSIZE) {
593         return;
594     }
595 
596     DeviceType devType = DeviceType::DEVICE_TYPE_SPEAKER;
597     const std::string macAddress = "11-22-33-44-55-66";
598     GetServerPtr()->audioPolicyService_.OnForcedDeviceSelected(devType, macAddress);
599 }
600 
AudioPolicyServiceSetAvailableDeviceChangeCallbackFuzztest(const uint8_t * rawData,size_t size)601 void AudioPolicyServiceSetAvailableDeviceChangeCallbackFuzztest(const uint8_t *rawData, size_t size)
602 {
603     if (rawData == nullptr || size < LIMITSIZE) {
604         return;
605     }
606 
607     int32_t clientId = GetData<uint32_t>() % NUM_2;
608     AudioDeviceUsage usage = AudioDeviceUsage::MEDIA_OUTPUT_DEVICES;
609     sptr<IRemoteObject> object = nullptr;
610     bool hasBTPermission = true;
611     GetServerPtr()->audioPolicyService_.SetAvailableDeviceChangeCallback(clientId, usage, object, hasBTPermission);
612 }
613 
AudioPolicyServiceSetQueryClientTypeCallbackFuzztest(const uint8_t * rawData,size_t size)614 void AudioPolicyServiceSetQueryClientTypeCallbackFuzztest(const uint8_t *rawData, size_t size)
615 {
616     if (rawData == nullptr || size < LIMITSIZE) {
617         return;
618     }
619 
620     sptr<IRemoteObject> object = nullptr;
621     GetServerPtr()->audioPolicyService_.SetQueryClientTypeCallback(object);
622 }
623 
AudioPolicyServiceSetQueryDeviceVolumeBehaviorCallbackFuzztest(const uint8_t * rawData,size_t size)624 void AudioPolicyServiceSetQueryDeviceVolumeBehaviorCallbackFuzztest(const uint8_t *rawData, size_t size)
625 {
626     if (rawData == nullptr || size < LIMITSIZE) {
627         return;
628     }
629 
630     sptr<IRemoteObject> object = nullptr;
631     GetServerPtr()->audioPolicyService_.SetQueryDeviceVolumeBehaviorCallback(object);
632 }
633 
AudioPolicyServiceUpdateCapturerInfoWhenNoPermissionFuzztest(const uint8_t * rawData,size_t size)634 void AudioPolicyServiceUpdateCapturerInfoWhenNoPermissionFuzztest(const uint8_t *rawData, size_t size)
635 {
636     if (rawData == nullptr || size < LIMITSIZE) {
637         return;
638     }
639 
640     auto audioCapturerChangeInfos = std::shared_ptr<AudioCapturerChangeInfo>();
641     bool hasSystemPermission = true;
642     AudioCoreService::UpdateCapturerInfoWhenNoPermission(audioCapturerChangeInfos, hasSystemPermission);
643 }
644 
AudioPolicyServiceGetCurrentCapturerChangeInfosFuzztest(const uint8_t * rawData,size_t size)645 void AudioPolicyServiceGetCurrentCapturerChangeInfosFuzztest(const uint8_t *rawData, size_t size)
646 {
647     if (rawData == nullptr || size < LIMITSIZE) {
648         return;
649     }
650 
651     vector<shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
652     bool hasSystemPermission = true;
653     bool hasBTPermission = true;
654     GetServerPtr()->audioPolicyService_.GetCurrentCapturerChangeInfos(audioCapturerChangeInfos,
655         hasBTPermission, hasSystemPermission);
656 }
657 
AudioPolicyServiceUpdateDescWhenNoBTPermissionFuzztest(const uint8_t * rawData,size_t size)658 void AudioPolicyServiceUpdateDescWhenNoBTPermissionFuzztest(const uint8_t *rawData, size_t size)
659 {
660     if (rawData == nullptr || size < LIMITSIZE) {
661         return;
662     }
663 
664     std::shared_ptr<AudioDeviceDescriptor> fuzzAudioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
665     std::vector<std::shared_ptr<AudioDeviceDescriptor>> fuzzAudioDeviceDescriptorSptrVector;
666     fuzzAudioDeviceDescriptorSptrVector.push_back(fuzzAudioDeviceDescriptorSptr);
667     GetServerPtr()->audioPolicyService_.UpdateDescWhenNoBTPermission(fuzzAudioDeviceDescriptorSptrVector);
668 }
669 
AudioPolicyServiceGetPreferredOutputStreamTypeFuzztest(const uint8_t * rawData,size_t size)670 void AudioPolicyServiceGetPreferredOutputStreamTypeFuzztest(const uint8_t *rawData, size_t size)
671 {
672     if (rawData == nullptr || size < LIMITSIZE) {
673         return;
674     }
675 
676     AudioRendererInfo rendererInfo;
677     std::string bundleName = "bundleName";
678     GetServerPtr()->audioPolicyService_.GetPreferredOutputStreamType(rendererInfo, bundleName);
679 }
680 
AudioPolicyServiceGetProcessDeviceInfoFuzztest(const uint8_t * rawData,size_t size)681 void AudioPolicyServiceGetProcessDeviceInfoFuzztest(const uint8_t *rawData, size_t size)
682 {
683     if (rawData == nullptr || size < LIMITSIZE) {
684         return;
685     }
686 
687     AudioProcessConfig config;
688     bool lockFlag = true;
689     AudioDeviceDescriptor deviceInfo;
690     GetServerPtr()->audioPolicyService_.GetProcessDeviceInfo(config, lockFlag, deviceInfo);
691 }
692 
AudioPolicyServiceGetVoipDeviceInfoFuzztest(const uint8_t * rawData,size_t size)693 void AudioPolicyServiceGetVoipDeviceInfoFuzztest(const uint8_t *rawData, size_t size)
694 {
695     if (rawData == nullptr || size < LIMITSIZE) {
696         return;
697     }
698 
699     AudioProcessConfig config;
700     bool lockFlag = true;
701     AudioDeviceDescriptor deviceInfo;
702     int32_t type = GetData<uint32_t>() % NUM_2;
703     std::shared_ptr<AudioDeviceDescriptor> fuzzAudioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
704     std::vector<std::shared_ptr<AudioDeviceDescriptor>> preferredDeviceList;
705     preferredDeviceList.push_back(fuzzAudioDeviceDescriptorSptr);
706     GetServerPtr()->audioPolicyService_.GetVoipDeviceInfo(config, deviceInfo, type, preferredDeviceList);
707 }
708 
AudioPolicyServiceInitSharedVolumeFuzztest(const uint8_t * rawData,size_t size)709 void AudioPolicyServiceInitSharedVolumeFuzztest(const uint8_t *rawData, size_t size)
710 {
711     if (rawData == nullptr || size < LIMITSIZE) {
712         return;
713     }
714 
715     std::shared_ptr<AudioSharedMemory> buffer;
716     GetServerPtr()->audioPolicyService_.InitSharedVolume(buffer);
717 }
718 
AudioPolicyServiceDynamicUnloadModuleFuzztest(const uint8_t * rawData,size_t size)719 void AudioPolicyServiceDynamicUnloadModuleFuzztest(const uint8_t *rawData, size_t size)
720 {
721     if (rawData == nullptr || size < LIMITSIZE) {
722         return;
723     }
724 
725     AudioPipeType pipeType = PIPE_TYPE_OFFLOAD;
726     GetServerPtr()->audioPolicyService_.DynamicUnloadModule(pipeType);
727 }
728 
AudioPolicyServiceGetMaxRendererInstancesFuzztest(const uint8_t * rawData,size_t size)729 void AudioPolicyServiceGetMaxRendererInstancesFuzztest(const uint8_t *rawData, size_t size)
730 {
731     if (rawData == nullptr || size < LIMITSIZE) {
732         return;
733     }
734 
735     GetServerPtr()->audioPolicyService_.GetMaxRendererInstances();
736 }
737 
AudioPolicyServiceRegisterBluetoothListenerFuzztest(const uint8_t * rawData,size_t size)738 void AudioPolicyServiceRegisterBluetoothListenerFuzztest(const uint8_t *rawData, size_t size)
739 {
740     if (rawData == nullptr || size < LIMITSIZE) {
741         return;
742     }
743 
744     GetServerPtr()->audioPolicyService_.RegisterBluetoothListener();
745 }
746 
AudioPolicyServiceUnregisterBluetoothListenerFuzztest(const uint8_t * rawData,size_t size)747 void AudioPolicyServiceUnregisterBluetoothListenerFuzztest(const uint8_t *rawData, size_t size)
748 {
749     if (rawData == nullptr || size < LIMITSIZE) {
750         return;
751     }
752 
753     GetServerPtr()->audioPolicyService_.UnregisterBluetoothListener();
754 }
755 
AudioPolicyServiceSubscribeAccessibilityConfigObserverFuzztest(const uint8_t * rawData,size_t size)756 void AudioPolicyServiceSubscribeAccessibilityConfigObserverFuzztest(const uint8_t *rawData, size_t size)
757 {
758     if (rawData == nullptr || size < LIMITSIZE) {
759         return;
760     }
761 
762     GetServerPtr()->audioPolicyService_.SubscribeAccessibilityConfigObserver();
763 }
764 
AudioPolicyServiceQueryEffectManagerSceneModeFuzztest(const uint8_t * rawData,size_t size)765 void AudioPolicyServiceQueryEffectManagerSceneModeFuzztest(const uint8_t *rawData, size_t size)
766 {
767     if (rawData == nullptr || size < LIMITSIZE) {
768     }
769     SupportedEffectConfig supportedEffectConfig;
770     GetServerPtr()->audioPolicyService_.QueryEffectManagerSceneMode(supportedEffectConfig);
771 }
772 
AudioPolicyServiceRegisterDataObserverFuzztest(const uint8_t * rawData,size_t size)773 void AudioPolicyServiceRegisterDataObserverFuzztest(const uint8_t *rawData, size_t size)
774 {
775     if (rawData == nullptr || size < LIMITSIZE) {
776     }
777     GetServerPtr()->audioPolicyService_.RegisterDataObserver();
778 }
779 
AudioPolicyServiceGetHardwareOutputSamplingRateFuzztest(const uint8_t * rawData,size_t size)780 void AudioPolicyServiceGetHardwareOutputSamplingRateFuzztest(const uint8_t *rawData, size_t size)
781 {
782     if (rawData == nullptr || size < LIMITSIZE) {
783     }
784     std::shared_ptr<AudioDeviceDescriptor> fuzzAudioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
785     GetServerPtr()->audioPolicyService_.GetHardwareOutputSamplingRate(fuzzAudioDeviceDescriptorSptr);
786 }
787 
AudioPolicyServiceDeviceFilterByUsageInnerFuzztest(const uint8_t * rawData,size_t size)788 void AudioPolicyServiceDeviceFilterByUsageInnerFuzztest(const uint8_t *rawData, size_t size)
789 {
790     if (rawData == nullptr || size < LIMITSIZE) {
791     }
792     AudioDeviceUsage usage = AudioDeviceUsage::MEDIA_OUTPUT_DEVICES;
793     std::shared_ptr<AudioDeviceDescriptor> fuzzAudioDeviceDescriptorSptr = std::make_shared<AudioDeviceDescriptor>();
794     std::vector<std::shared_ptr<AudioDeviceDescriptor>> descs;
795     descs.push_back(fuzzAudioDeviceDescriptorSptr);
796     GetServerPtr()->audioPolicyService_.DeviceFilterByUsageInner(usage, descs);
797 }
798 
AudioPolicyServiceOffloadStartPlayingFuzztest(const uint8_t * rawData,size_t size)799 void AudioPolicyServiceOffloadStartPlayingFuzztest(const uint8_t *rawData, size_t size)
800 {
801     if (rawData == nullptr || size < LIMITSIZE) {
802     }
803     std::vector<int32_t> sessionIds;
804     GetServerPtr()->audioPolicyService_.OffloadStartPlaying(sessionIds);
805 }
806 
AudioPolicyServiceOffloadStopPlayingFuzztest(const uint8_t * rawData,size_t size)807 void AudioPolicyServiceOffloadStopPlayingFuzztest(const uint8_t *rawData, size_t size)
808 {
809     if (rawData == nullptr || size < LIMITSIZE) {
810     }
811     std::vector<int32_t> sessionIds;
812     GetServerPtr()->audioPolicyService_.OffloadStopPlaying(sessionIds);
813 }
814 
AudioPolicyServiceOffloadGetRenderPositionFuzztest(const uint8_t * rawData,size_t size)815 void AudioPolicyServiceOffloadGetRenderPositionFuzztest(const uint8_t *rawData, size_t size)
816 {
817     if (rawData == nullptr || size < LIMITSIZE) {
818     }
819     uint32_t delayValue = GetData<uint32_t>() % NUM_2;
820     uint64_t sendDataSize = GetData<uint64_t>() % NUM_2;
821     uint32_t timeStamp = GetData<uint32_t>() % NUM_2;
822     GetServerPtr()->audioPolicyService_.OffloadGetRenderPosition(delayValue, sendDataSize, timeStamp);
823 }
824 
AudioPolicyServiceNearlinkGetRenderPositionFuzztest(const uint8_t * rawData,size_t size)825 void AudioPolicyServiceNearlinkGetRenderPositionFuzztest(const uint8_t *rawData, size_t size)
826 {
827     if (rawData == nullptr || size < LIMITSIZE) {
828     }
829     uint32_t delayValue = GetData<uint32_t>() % NUM_2;
830     GetServerPtr()->audioPolicyService_.NearlinkGetRenderPosition(delayValue);
831 }
832 
AudioPolicyServiceGetAndSaveClientTypeFuzztest(const uint8_t * rawData,size_t size)833 void AudioPolicyServiceGetAndSaveClientTypeFuzztest(const uint8_t *rawData, size_t size)
834 {
835     if (rawData == nullptr || size < LIMITSIZE) {
836     }
837     uint32_t uid = GetData<uint32_t>() % NUM_2;
838     std::string bundleName = "bundleName";
839     GetServerPtr()->audioPolicyService_.GetAndSaveClientType(uid, bundleName);
840 }
841 
AudioPolicyServiceOnDeviceInfoUpdatedFuzztest(const uint8_t * rawData,size_t size)842 void AudioPolicyServiceOnDeviceInfoUpdatedFuzztest(const uint8_t *rawData, size_t size)
843 {
844     if (rawData == nullptr || size < LIMITSIZE) {
845     }
846     AudioDeviceDescriptor desc;
847     DeviceInfoUpdateCommand command = ENABLE_UPDATE;
848     GetServerPtr()->audioPolicyService_.OnDeviceInfoUpdated(desc, command);
849 }
850 
AudioPolicyServiceNotifyAccountsChangedFuzztest(const uint8_t * rawData,size_t size)851 void AudioPolicyServiceNotifyAccountsChangedFuzztest(const uint8_t *rawData, size_t size)
852 {
853     if (rawData == nullptr || size < LIMITSIZE) {
854     }
855     int id = GetData<int>() % NUM_2;
856     GetServerPtr()->audioPolicyService_.NotifyAccountsChanged(id);
857 }
858 
AudioPolicyServiceLoadHdiEffectModelFuzztest(const uint8_t * rawData,size_t size)859 void AudioPolicyServiceLoadHdiEffectModelFuzztest(const uint8_t *rawData, size_t size)
860 {
861     if (rawData == nullptr || size < LIMITSIZE) {
862     }
863     GetServerPtr()->audioPolicyService_.LoadHdiEffectModel();
864 }
865 
AudioPolicyServiceGetSupportedAudioEffectPropertyFuzztest(const uint8_t * rawData,size_t size)866 void AudioPolicyServiceGetSupportedAudioEffectPropertyFuzztest(const uint8_t *rawData, size_t size)
867 {
868     if (rawData == nullptr || size < LIMITSIZE) {
869     }
870     AudioEffectPropertyArrayV3 propertyArray;
871     GetServerPtr()->audioPolicyService_.GetSupportedAudioEffectProperty(propertyArray);
872 }
873 
AudioPolicyServiceGetSupportedEffectPropertyFuzztest(const uint8_t * rawData,size_t size)874 void AudioPolicyServiceGetSupportedEffectPropertyFuzztest(const uint8_t *rawData, size_t size)
875 {
876     if (rawData == nullptr || size < LIMITSIZE) {
877     }
878     AudioEffectPropertyArrayV3 propertyArray;
879     GetServerPtr()->audioPolicyService_.GetSupportedEffectProperty(propertyArray);
880 }
881 
AudioPolicyServiceGetSupportedEnhancePropertyFuzztest(const uint8_t * rawData,size_t size)882 void AudioPolicyServiceGetSupportedEnhancePropertyFuzztest(const uint8_t *rawData, size_t size)
883 {
884     if (rawData == nullptr || size < LIMITSIZE) {
885     }
886     AudioEffectPropertyArrayV3 propertyArray;
887     GetServerPtr()->audioPolicyService_.GetSupportedEnhanceProperty(propertyArray);
888 }
889 
AudioPolicyServiceCheckSupportedAudioEffectPropertyFuzztest(const uint8_t * rawData,size_t size)890 void AudioPolicyServiceCheckSupportedAudioEffectPropertyFuzztest(const uint8_t *rawData, size_t size)
891 {
892     if (rawData == nullptr || size < LIMITSIZE) {
893     }
894     AudioEffectPropertyArrayV3 propertyArray;
895     EffectFlag flag = CAPTURE_EFFECT_FLAG;
896     GetServerPtr()->audioPolicyService_.CheckSupportedAudioEffectProperty(propertyArray, flag);
897 }
898 
AudioPolicyServiceSetAudioEffectPropertyFuzztest(const uint8_t * rawData,size_t size)899 void AudioPolicyServiceSetAudioEffectPropertyFuzztest(const uint8_t *rawData, size_t size)
900 {
901     if (rawData == nullptr || size < LIMITSIZE) {
902     }
903     AudioEffectPropertyArrayV3 propertyArray;
904     GetServerPtr()->audioPolicyService_.SetAudioEffectProperty(propertyArray);
905 }
906 
AudioPolicyServiceGetAudioEnhancePropertyFuzztest(const uint8_t * rawData,size_t size)907 void AudioPolicyServiceGetAudioEnhancePropertyFuzztest(const uint8_t *rawData, size_t size)
908 {
909     if (rawData == nullptr || size < LIMITSIZE) {
910     }
911     AudioEffectPropertyArrayV3 propertyArrayv3;
912     GetServerPtr()->audioPolicyService_.GetAudioEnhanceProperty(propertyArrayv3);
913     AudioEnhancePropertyArray propertyArray;
914     GetServerPtr()->audioPolicyService_.GetAudioEnhanceProperty(propertyArray);
915 }
916 
AudioPolicyServiceGetSupportedAudioEnhancePropertyFuzztest(const uint8_t * rawData,size_t size)917 void AudioPolicyServiceGetSupportedAudioEnhancePropertyFuzztest(const uint8_t *rawData, size_t size)
918 {
919     if (rawData == nullptr || size < LIMITSIZE) {
920     }
921     AudioEnhancePropertyArray propertyArray;
922     GetServerPtr()->audioPolicyService_.GetSupportedAudioEnhanceProperty(propertyArray);
923 }
924 
AudioPolicyServiceGetAudioEffectPropertyFuzztest(const uint8_t * rawData,size_t size)925 void AudioPolicyServiceGetAudioEffectPropertyFuzztest(const uint8_t *rawData, size_t size)
926 {
927     if (rawData == nullptr || size < LIMITSIZE) {
928     }
929     AudioEffectPropertyArrayV3 propertyArrayv3;
930     GetServerPtr()->audioPolicyService_.GetAudioEffectProperty(propertyArrayv3);
931     AudioEffectPropertyArray propertyArray;
932     GetServerPtr()->audioPolicyService_.GetAudioEffectProperty(propertyArray);
933 }
934 
AudioPolicyServiceSetAudioEnhancePropertyFuzztest(const uint8_t * rawData,size_t size)935 void AudioPolicyServiceSetAudioEnhancePropertyFuzztest(const uint8_t *rawData, size_t size)
936 {
937     if (rawData == nullptr || size < LIMITSIZE) {
938     }
939     AudioEnhancePropertyArray propertyArray;
940     GetServerPtr()->audioPolicyService_.SetAudioEnhanceProperty(propertyArray);
941 }
942 
AudioPolicyServiceGetA2dpOffloadFlagFuzztest(const uint8_t * rawData,size_t size)943 void AudioPolicyServiceGetA2dpOffloadFlagFuzztest(const uint8_t *rawData, size_t size)
944 {
945     if (rawData == nullptr || size < LIMITSIZE) {
946     }
947     GetServerPtr()->audioPolicyService_.GetA2dpOffloadFlag();
948 }
949 
AudioPolicyServiceSetSleAudioOperationCallbackFuzztest(const uint8_t * rawData,size_t size)950 void AudioPolicyServiceSetSleAudioOperationCallbackFuzztest(const uint8_t *rawData, size_t size)
951 {
952     if (rawData == nullptr || size < LIMITSIZE) {
953     }
954     sptr<IRemoteObject> object = nullptr;
955     GetServerPtr()->audioPolicyService_.SetSleAudioOperationCallback(object);
956 }
957 
AudioPolicyServiceNotifyCapturerRemovedFuzztest(const uint8_t * rawData,size_t size)958 void AudioPolicyServiceNotifyCapturerRemovedFuzztest(const uint8_t *rawData, size_t size)
959 {
960     if (rawData == nullptr || size < LIMITSIZE) {
961     }
962     uint64_t sessionId = GetData<uint64_t>() % NUM_2;
963     GetServerPtr()->audioPolicyService_.NotifyCapturerRemoved(sessionId);
964 }
965 
AudioPolicyServiceUpdateSpatializationSupportedFuzztest(const uint8_t * rawData,size_t size)966 void AudioPolicyServiceUpdateSpatializationSupportedFuzztest(const uint8_t *rawData, size_t size)
967 {
968     if (rawData == nullptr || size < LIMITSIZE) {
969     }
970     std::string macAddress = "11-22-33-44-55-66";
971     bool support = true;
972     GetServerPtr()->audioPolicyService_.UpdateSpatializationSupported(macAddress, support);
973 }
974 
AudioPolicyServiceIsDevicePlaybackSupportedFuzztest(const uint8_t * rawData,size_t size)975 void AudioPolicyServiceIsDevicePlaybackSupportedFuzztest(const uint8_t *rawData, size_t size)
976 {
977     if (rawData == nullptr || size < LIMITSIZE) {
978     }
979     AudioProcessConfig config;
980     AudioDeviceDescriptor deviceInfo;
981     GetServerPtr()->audioPolicyService_.IsDevicePlaybackSupported(config, deviceInfo);
982 }
983 } // namespace AudioStandard
984 } // namesapce OHOS
985 
986 OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = {
987     OHOS::AudioStandard::AudioPolicyServiceDumpTest,
988     OHOS::AudioStandard::AudioPolicyServiceDeviceTest,
989     OHOS::AudioStandard::AudioPolicyServiceAccountTest,
990     OHOS::AudioStandard::AudioPolicyServiceSafeVolumeTest,
991     OHOS::AudioStandard::AudioPolicyServiceInterfaceTest,
992     OHOS::AudioStandard::AudioDeviceConnectTest,
993     OHOS::AudioStandard::AudioPolicyServiceSubscribeSafeVolumeEventFuzztest,
994     OHOS::AudioStandard::AudioPolicyServiceOnReceiveEventFuzztest,
995     OHOS::AudioStandard::AudioPolicyServiceSetAppVolumeLevelFuzztest,
996     OHOS::AudioStandard::AudioPolicyServiceSetSourceOutputStreamMuteFuzztest,
997     OHOS::AudioStandard::AudioPolicyServiceGetSelectedDeviceInfoFuzztest,
998     OHOS::AudioStandard::AudioPolicyServiceGetDistributedRoutingRoleInfoFuzztest,
999     OHOS::AudioStandard::AudioPolicyServiceNotifyCapturerAddedFuzztest,
1000     OHOS::AudioStandard::AudioPolicyServiceNotifyWakeUpCapturerRemovedFuzztest,
1001     OHOS::AudioStandard::AudioPolicyServiceGetFastStreamInfoFuzztest,
1002     OHOS::AudioStandard::AudioPolicyServiceIsAbsVolumeSupportedFuzztest,
1003     OHOS::AudioStandard::AudioPolicyServiceGetDevicesFuzztest,
1004     OHOS::AudioStandard::AudioPolicyServiceGetPreferredInputDeviceDescriptorsFuzztest,
1005     OHOS::AudioStandard::AudioPolicyServiceGetPreferredOutputDeviceDescInnerFuzztest,
1006     OHOS::AudioStandard::AudioPolicyServiceGetOutputDeviceFuzztest,
1007     OHOS::AudioStandard::AudioPolicyServiceGetInputDeviceFuzztest,
1008     OHOS::AudioStandard::AudioPolicyServiceGetActiveOutputDeviceDescriptorFuzztest,
1009     OHOS::AudioStandard::AudioPolicyServiceOnUpdateAnahsSupportFuzztest,
1010     OHOS::AudioStandard::AudioPolicyServiceOnPnpDeviceStatusUpdatedFuzztest,
1011     OHOS::AudioStandard::AudioPolicyServiceOnDeviceStatusUpdatedFuzztest,
1012     OHOS::AudioStandard::AudioPolicyServiceUpdateA2dpOffloadFlagBySpatialServiceFuzztest,
1013     OHOS::AudioStandard::AudioPolicyServiceRegisterRemoteDevStatusCallbackFuzztest,
1014     OHOS::AudioStandard::AudioPolicyServiceGetAllSinkInputsFuzztest,
1015     OHOS::AudioStandard::AudioPolicyServiceRegisterAccessibilityMonitorHelperFuzztest,
1016     OHOS::AudioStandard::AudioPolicyServiceOnServiceConnectedFuzztest,
1017     OHOS::AudioStandard::AudioPolicyServiceOnServiceDisconnectedFuzztest,
1018     OHOS::AudioStandard::AudioPolicyServiceOnForcedDeviceSelectedFuzztest,
1019     OHOS::AudioStandard::AudioPolicyServiceSetAvailableDeviceChangeCallbackFuzztest,
1020     OHOS::AudioStandard::AudioPolicyServiceSetQueryClientTypeCallbackFuzztest,
1021     OHOS::AudioStandard::AudioPolicyServiceSetQueryDeviceVolumeBehaviorCallbackFuzztest,
1022     OHOS::AudioStandard::AudioPolicyServiceUpdateCapturerInfoWhenNoPermissionFuzztest,
1023     OHOS::AudioStandard::AudioPolicyServiceGetCurrentCapturerChangeInfosFuzztest,
1024     OHOS::AudioStandard::AudioPolicyServiceUpdateDescWhenNoBTPermissionFuzztest,
1025     OHOS::AudioStandard::AudioPolicyServiceGetPreferredOutputStreamTypeFuzztest,
1026     OHOS::AudioStandard::AudioPolicyServiceGetProcessDeviceInfoFuzztest,
1027     OHOS::AudioStandard::AudioPolicyServiceGetVoipDeviceInfoFuzztest,
1028     OHOS::AudioStandard::AudioPolicyServiceInitSharedVolumeFuzztest,
1029     OHOS::AudioStandard::AudioPolicyServiceDynamicUnloadModuleFuzztest,
1030     OHOS::AudioStandard::AudioPolicyServiceGetMaxRendererInstancesFuzztest,
1031     OHOS::AudioStandard::AudioPolicyServiceRegisterBluetoothListenerFuzztest,
1032     OHOS::AudioStandard::AudioPolicyServiceUnregisterBluetoothListenerFuzztest,
1033     OHOS::AudioStandard::AudioPolicyServiceSubscribeAccessibilityConfigObserverFuzztest,
1034     OHOS::AudioStandard::AudioPolicyServiceQueryEffectManagerSceneModeFuzztest,
1035     OHOS::AudioStandard::AudioPolicyServiceRegisterDataObserverFuzztest,
1036     OHOS::AudioStandard::AudioPolicyServiceGetHardwareOutputSamplingRateFuzztest,
1037     OHOS::AudioStandard::AudioPolicyServiceDeviceFilterByUsageInnerFuzztest,
1038     OHOS::AudioStandard::AudioPolicyServiceOffloadStartPlayingFuzztest,
1039     OHOS::AudioStandard::AudioPolicyServiceOffloadStopPlayingFuzztest,
1040     OHOS::AudioStandard::AudioPolicyServiceOffloadGetRenderPositionFuzztest,
1041     OHOS::AudioStandard::AudioPolicyServiceNearlinkGetRenderPositionFuzztest,
1042     OHOS::AudioStandard::AudioPolicyServiceGetAndSaveClientTypeFuzztest,
1043     OHOS::AudioStandard::AudioPolicyServiceOnDeviceInfoUpdatedFuzztest,
1044     OHOS::AudioStandard::AudioPolicyServiceNotifyAccountsChangedFuzztest,
1045     OHOS::AudioStandard::AudioPolicyServiceLoadHdiEffectModelFuzztest,
1046     OHOS::AudioStandard::AudioPolicyServiceGetSupportedAudioEffectPropertyFuzztest,
1047     OHOS::AudioStandard::AudioPolicyServiceGetSupportedEffectPropertyFuzztest,
1048     OHOS::AudioStandard::AudioPolicyServiceGetSupportedEffectPropertyFuzztest,
1049     OHOS::AudioStandard::AudioPolicyServiceCheckSupportedAudioEffectPropertyFuzztest,
1050     OHOS::AudioStandard::AudioPolicyServiceSetAudioEffectPropertyFuzztest,
1051     OHOS::AudioStandard::AudioPolicyServiceGetAudioEnhancePropertyFuzztest,
1052     OHOS::AudioStandard::AudioPolicyServiceGetAudioEffectPropertyFuzztest,
1053     OHOS::AudioStandard::AudioPolicyServiceGetSupportedAudioEnhancePropertyFuzztest,
1054     OHOS::AudioStandard::AudioPolicyServiceSetAudioEnhancePropertyFuzztest,
1055     OHOS::AudioStandard::AudioPolicyServiceGetA2dpOffloadFlagFuzztest,
1056     OHOS::AudioStandard::AudioPolicyServiceSetSleAudioOperationCallbackFuzztest,
1057     OHOS::AudioStandard::AudioPolicyServiceNotifyCapturerRemovedFuzztest,
1058     OHOS::AudioStandard::AudioPolicyServiceUpdateSpatializationSupportedFuzztest,
1059     OHOS::AudioStandard::AudioPolicyServiceIsDevicePlaybackSupportedFuzztest,
1060 };
1061 
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1062 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1063 {
1064     /* Run your code on data */
1065     if (data == nullptr || size <= 1) {
1066         return 0;
1067     }
1068     uint8_t firstByte = *data % OHOS::AudioStandard::TESTSIZE;
1069     if (firstByte >= OHOS::AudioStandard::TESTSIZE) {
1070         return 0;
1071     }
1072     data = data + 1;
1073     size = size - 1;
1074     g_testPtrs[firstByte](data, size);
1075     return 0;
1076 }