1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_log.h"
17 #include "audio_zone.h"
18 #include "audio_zone_client_manager.h"
19 #include "audio_zone_interrupt_reporter.h"
20 #include "audio_zone_service.h"
21
22 using namespace std;
23
24 namespace OHOS {
25 namespace AudioStandard {
26
27 static const uint8_t* RAW_DATA = nullptr;
28 static size_t g_dataSize = 0;
29 static size_t g_pos;
30 const size_t THRESHOLD = 10;
31 typedef void (*TestPtr)();
32
33 class IStandardAudioZoneClientFuzzTest : public IStandardAudioZoneClient {
34 public:
AsObject()35 sptr<IRemoteObject> AsObject() override
36 {
37 return nullptr;
38 }
39
OnAudioZoneAdd(const AudioZoneDescriptor & zoneDescriptor)40 ErrCode OnAudioZoneAdd(const AudioZoneDescriptor &zoneDescriptor) override
41 {
42 recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_ADD_EVENT;
43 Notify();
44 return 0;
45 }
46
OnAudioZoneRemove(int32_t zoneId)47 ErrCode OnAudioZoneRemove(int32_t zoneId) override
48 {
49 recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_REMOVE_EVENT;
50 recvEvent_.zoneId = zoneId;
51 Notify();
52 return 0;
53 }
54
OnAudioZoneChange(int32_t zoneId,const AudioZoneDescriptor & zoneDescriptor,int32_t reason)55 ErrCode OnAudioZoneChange(int32_t zoneId, const AudioZoneDescriptor& zoneDescriptor,
56 int32_t reason) override
57 {
58 recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_CHANGE_EVENT;
59 recvEvent_.zoneId = zoneId;
60 Notify();
61 return 0;
62 }
63
OnInterruptEvent(int32_t zoneId,const std::vector<std::map<AudioInterrupt,int32_t>> & ipcInterrupts,int32_t reason)64 ErrCode OnInterruptEvent(int32_t zoneId,
65 const std::vector<std::map<AudioInterrupt, int32_t>>& ipcInterrupts,
66 int32_t reason) override
67 {
68 recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_INTERRUPT_EVENT;
69 recvEvent_.zoneId = zoneId;
70 Notify();
71 return 0;
72 }
73
OnInterruptEvent(int32_t zoneId,const std::string & deviceTag,const std::vector<std::map<AudioInterrupt,int32_t>> & ipcInterrupts,int32_t reason)74 ErrCode OnInterruptEvent(int32_t zoneId, const std::string& deviceTag,
75 const std::vector<std::map<AudioInterrupt, int32_t>>& ipcInterrupts,
76 int32_t reason) override
77 {
78 recvEvent_.type = AudioZoneEventType::AUDIO_ZONE_INTERRUPT_EVENT;
79 recvEvent_.zoneId = zoneId;
80 recvEvent_.deviceTag = deviceTag;
81 Notify();
82 return 0;
83 }
84
SetSystemVolume(int32_t zoneId,int32_t volumeType,int32_t volumeLevel,int32_t volumeFlag)85 ErrCode SetSystemVolume(int32_t zoneId, int32_t volumeType, int32_t volumeLevel, int32_t volumeFlag) override
86 {
87 volumeLevel_ = volumeLevel;
88 Notify();
89 return 0;
90 }
91
GetSystemVolume(int32_t zoneId,int32_t volumeType,float & outVolume)92 ErrCode GetSystemVolume(int32_t zoneId, int32_t volumeType, float& outVolume) override
93 {
94 Notify();
95 return volumeLevel_;
96 }
97
Notify()98 void Notify()
99 {
100 std::unique_lock<std::mutex> lock(waitLock_);
101 waitStatus_ = 1;
102 waiter_.notify_one();
103 }
104
Wait()105 void Wait()
106 {
107 std::unique_lock<std::mutex> lock(waitLock_);
108 if (waitStatus_ == 0) {
109 waiter_.wait(lock, [this] {
110 return waitStatus_ != 0;
111 });
112 }
113 waitStatus_ = 0;
114 }
115
116 struct AudioZoneEvent recvEvent_;
117 std::condition_variable waiter_;
118 std::mutex waitLock_;
119 int32_t waitStatus_ = 0;
120 int32_t volumeLevel_ = 0;
121 };
122
123 using AudioZoneFocusList = std::list<std::pair<AudioInterrupt, AudioFocuState>>;
124
125 const vector<StreamUsage> g_testStreamUsages = {
126 STREAM_USAGE_INVALID,
127 STREAM_USAGE_UNKNOWN,
128 STREAM_USAGE_MEDIA,
129 STREAM_USAGE_MUSIC,
130 STREAM_USAGE_VOICE_COMMUNICATION,
131 STREAM_USAGE_VOICE_ASSISTANT,
132 STREAM_USAGE_ALARM,
133 STREAM_USAGE_VOICE_MESSAGE,
134 STREAM_USAGE_NOTIFICATION_RINGTONE,
135 STREAM_USAGE_RINGTONE,
136 STREAM_USAGE_NOTIFICATION,
137 STREAM_USAGE_ACCESSIBILITY,
138 STREAM_USAGE_SYSTEM,
139 STREAM_USAGE_MOVIE,
140 STREAM_USAGE_GAME,
141 STREAM_USAGE_AUDIOBOOK,
142 STREAM_USAGE_NAVIGATION,
143 STREAM_USAGE_DTMF,
144 STREAM_USAGE_ENFORCED_TONE,
145 STREAM_USAGE_ULTRASONIC,
146 STREAM_USAGE_VIDEO_COMMUNICATION,
147 STREAM_USAGE_RANGING,
148 STREAM_USAGE_VOICE_MODEM_COMMUNICATION,
149 STREAM_USAGE_VOICE_RINGTONE,
150 STREAM_USAGE_VOICE_CALL_ASSISTANT,
151 STREAM_USAGE_MAX,
152 };
153
154 const vector<RouterType> g_testRouterTypes = {
155 ROUTER_TYPE_NONE,
156 ROUTER_TYPE_DEFAULT,
157 ROUTER_TYPE_STREAM_FILTER,
158 ROUTER_TYPE_PACKAGE_FILTER,
159 ROUTER_TYPE_COCKPIT_PHONE,
160 ROUTER_TYPE_PRIVACY_PRIORITY,
161 ROUTER_TYPE_PUBLIC_PRIORITY,
162 ROUTER_TYPE_PAIR_DEVICE,
163 ROUTER_TYPE_USER_SELECT,
164 ROUTER_TYPE_APP_SELECT,
165 };
166
167 const vector<SourceType> g_testSourceTypes = {
168 SOURCE_TYPE_INVALID,
169 SOURCE_TYPE_MIC,
170 SOURCE_TYPE_VOICE_RECOGNITION,
171 SOURCE_TYPE_PLAYBACK_CAPTURE,
172 SOURCE_TYPE_WAKEUP,
173 SOURCE_TYPE_VOICE_CALL,
174 SOURCE_TYPE_VOICE_COMMUNICATION,
175 SOURCE_TYPE_ULTRASONIC,
176 SOURCE_TYPE_VIRTUAL_CAPTURE,
177 SOURCE_TYPE_VOICE_MESSAGE,
178 SOURCE_TYPE_REMOTE_CAST,
179 SOURCE_TYPE_VOICE_TRANSCRIPTION,
180 SOURCE_TYPE_CAMCORDER,
181 SOURCE_TYPE_UNPROCESSED,
182 SOURCE_TYPE_EC,
183 SOURCE_TYPE_MIC_REF,
184 SOURCE_TYPE_LIVE,
185 SOURCE_TYPE_MAX,
186 };
187
188 template<class T>
GetArrLength(T & arr)189 uint32_t GetArrLength(T& arr)
190 {
191 if (arr == nullptr) {
192 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
193 return 0;
194 }
195 return sizeof(arr) / sizeof(arr[0]);
196 }
197
198 template<class T>
GetData()199 T GetData()
200 {
201 T object {};
202 size_t objectSize = sizeof(object);
203 if (g_dataSize < g_pos) {
204 return object;
205 }
206 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
207 return object;
208 }
209 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
210 if (ret != EOK) {
211 return {};
212 }
213 g_pos += objectSize;
214 return object;
215 }
216
AudioZoneServiceCreateAudioZoneFuzzTest()217 void AudioZoneServiceCreateAudioZoneFuzzTest()
218 {
219 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
220
221 std::string name = "testZone";
222 AudioZoneContext context;
223 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
224 int32_t zoneId = GetData<int32_t>();
225 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
226 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
227 audioZoneService.CreateAudioZone(name, context, 0);
228 }
229
AudioZoneServiceReleaseAudioZoneFuzzTest()230 void AudioZoneServiceReleaseAudioZoneFuzzTest()
231 {
232 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
233
234 audioZoneService.DeInit();
235 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
236 std::make_shared<AudioInterruptService>());
237 std::string name = "testZone";
238 AudioZoneContext context;
239 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
240 int32_t zoneId = GetData<int32_t>();
241 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
242 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
243 audioZoneService.ReleaseAudioZone(zoneId);
244 }
245
AudioZoneServiceGetAllAudioZoneFuzzTest()246 void AudioZoneServiceGetAllAudioZoneFuzzTest()
247 {
248 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
249
250 audioZoneService.DeInit();
251 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
252 std::make_shared<AudioInterruptService>());
253 std::string name = "testZone";
254 AudioZoneContext context;
255 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
256 int32_t zoneId = GetData<int32_t>();
257 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
258 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
259 audioZoneService.GetAllAudioZone();
260 }
261
AudioZoneServiceBindDeviceToAudioZoneFuzzTest()262 void AudioZoneServiceBindDeviceToAudioZoneFuzzTest()
263 {
264 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
265
266 audioZoneService.DeInit();
267 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
268 std::make_shared<AudioInterruptService>());
269 AudioZoneContext context;
270 std::string name = "testZone";
271 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
272 int32_t zoneId = GetData<int32_t>();
273 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
274 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
275 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptor = make_shared<AudioDeviceDescriptor>();
276 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
277 devices.push_back(audioDeviceDescriptor);
278 audioZoneService.BindDeviceToAudioZone(zoneId, devices);
279 }
280
AudioZoneServiceRemoveDeviceFromGlobalFuzzTest()281 void AudioZoneServiceRemoveDeviceFromGlobalFuzzTest()
282 {
283 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
284
285 audioZoneService.DeInit();
286 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
287 std::make_shared<AudioInterruptService>());
288 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptor = make_shared<AudioDeviceDescriptor>();
289 audioZoneService.RemoveDeviceFromGlobal(audioDeviceDescriptor);
290 }
291
AudioZoneServiceUnBindDeviceToAudioZoneFuzzTest()292 void AudioZoneServiceUnBindDeviceToAudioZoneFuzzTest()
293 {
294 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
295
296 audioZoneService.DeInit();
297 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
298 std::make_shared<AudioInterruptService>());
299 AudioZoneContext context;
300 std::string name = "testZone";
301 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
302 int32_t zoneId = GetData<int32_t>();
303 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
304 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
305 std::shared_ptr<AudioDeviceDescriptor> audioDeviceDescriptor = make_shared<AudioDeviceDescriptor>();
306 std::vector<std::shared_ptr<AudioDeviceDescriptor>> devices;
307 devices.push_back(audioDeviceDescriptor);
308 audioZoneService.UnBindDeviceToAudioZone(zoneId, devices);
309 }
310
AudioZoneServiceRegisterAudioZoneClientFuzzTest()311 void AudioZoneServiceRegisterAudioZoneClientFuzzTest()
312 {
313 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
314
315 audioZoneService.DeInit();
316 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
317 std::make_shared<AudioInterruptService>());
318 int32_t clientPid = GetData<int32_t>();
319 sptr<IStandardAudioZoneClient> client = new IStandardAudioZoneClientFuzzTest();
320 audioZoneService.RegisterAudioZoneClient(clientPid, client);
321 }
322
AudioZoneServiceUnRegisterAudioZoneClientFuzzTest()323 void AudioZoneServiceUnRegisterAudioZoneClientFuzzTest()
324 {
325 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
326
327 audioZoneService.DeInit();
328 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
329 std::make_shared<AudioInterruptService>());
330 AudioZoneContext context;
331 std::string name = "testZone";
332 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
333 int32_t zoneId = GetData<int32_t>();
334 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
335 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
336 int32_t clientPid = GetData<int32_t>();
337 audioZoneService.UnRegisterAudioZoneClient(clientPid);
338 }
339
AudioZoneServiceInjectInterruptToAudioZoneFuzzTest()340 void AudioZoneServiceInjectInterruptToAudioZoneFuzzTest()
341 {
342 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
343
344 audioZoneService.DeInit();
345 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
346 std::make_shared<AudioInterruptService>());
347 AudioZoneContext context;
348 std::string name = "testZone";
349 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
350 int32_t zoneId = GetData<int32_t>();
351 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
352 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
353 AudioZoneFocusList interrupts = audioZoneService.GetAudioInterruptForZone(zoneId);
354 audioZoneService.InjectInterruptToAudioZone(zoneId, interrupts);
355 }
356
AudioZoneServiceFetchOutputDevicesFuzzTest()357 void AudioZoneServiceFetchOutputDevicesFuzzTest()
358 {
359 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
360
361 audioZoneService.DeInit();
362 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
363 std::make_shared<AudioInterruptService>());
364 AudioZoneContext context;
365 std::string name = "testZone";
366 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
367 int32_t zoneId = GetData<int32_t>();
368 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
369 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
370 if (g_testStreamUsages.size() == 0 || g_testRouterTypes.size() == 0) {
371 return;
372 }
373 StreamUsage streamUsage = g_testStreamUsages[GetData<uint32_t>() % g_testStreamUsages.size()];
374 int32_t clientUid = GetData<int32_t>();
375 RouterType bypassType = g_testRouterTypes[GetData<uint32_t>() % g_testRouterTypes.size()];
376 audioZoneService.FetchOutputDevices(zoneId, streamUsage, clientUid, bypassType);
377 }
378
AudioZoneServiceFetchInputDeviceFuzzTest()379 void AudioZoneServiceFetchInputDeviceFuzzTest()
380 {
381 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
382
383 audioZoneService.DeInit();
384 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
385 std::make_shared<AudioInterruptService>());
386 AudioZoneContext context;
387 std::string name = "testZone";
388 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
389 int32_t zoneId = GetData<int32_t>();
390 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
391 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
392 if (g_testSourceTypes.size() == 0) {
393 return;
394 }
395 SourceType sourceType = g_testSourceTypes[GetData<uint32_t>() % g_testSourceTypes.size()];
396 int32_t clientUid = GetData<int32_t>();
397 audioZoneService.FetchInputDevice(zoneId, sourceType, clientUid);
398 }
399
AudioZoneServiceGetZoneStringDescriptorFuzzTest()400 void AudioZoneServiceGetZoneStringDescriptorFuzzTest()
401 {
402 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
403
404 audioZoneService.DeInit();
405 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
406 std::make_shared<AudioInterruptService>());
407 AudioZoneContext context;
408 std::string name = "testZone";
409 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
410 int32_t zoneId = GetData<int32_t>();
411 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
412 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
413 audioZoneService.GetZoneStringDescriptor(zoneId);
414 }
415
AudioZoneServiceUpdateDeviceFromGlobalForAllZoneFuzzTest()416 void AudioZoneServiceUpdateDeviceFromGlobalForAllZoneFuzzTest()
417 {
418 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
419
420 audioZoneService.DeInit();
421 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
422 std::make_shared<AudioInterruptService>());
423 AudioZoneContext context;
424 std::string name = "testZone";
425 std::shared_ptr<AudioZoneClientManager> manager = std::make_shared<AudioZoneClientManager>(nullptr);
426 int32_t zoneId = GetData<int32_t>();
427 std::shared_ptr<AudioZone> zone = std::make_shared<AudioZone>(manager, name, context);
428 audioZoneService.zoneMaps_.insert(make_pair(zoneId, zone));
429 std::shared_ptr<AudioDeviceDescriptor> device = make_shared<AudioDeviceDescriptor>();
430 audioZoneService.UpdateDeviceFromGlobalForAllZone(device);
431 }
432
AudioZoneServiceClearAudioFocusBySessionIDFuzzTest()433 void AudioZoneServiceClearAudioFocusBySessionIDFuzzTest()
434 {
435 AudioZoneService &audioZoneService = AudioZoneService::GetInstance();
436
437 audioZoneService.DeInit();
438 audioZoneService.Init(DelayedSingleton<AudioPolicyServerHandler>::GetInstance(),
439 std::make_shared<AudioInterruptService>());
440 int32_t sessionID = GetData<int32_t>();
441 audioZoneService.ClearAudioFocusBySessionID(sessionID);
442 }
443
AudioZoneInterruptReporterEnableInterruptReportFuzzTest()444 void AudioZoneInterruptReporterEnableInterruptReportFuzzTest()
445 {
446 AudioZoneInterruptReporter audioZoneInterruptReporter;
447 pid_t clientPid = GetData<pid_t>();
448 int32_t zoneId = GetData<int32_t>();
449 bool enable = GetData<bool>();
450 std::string deviceTag = "testDeviceTag";
451 AudioZoneInterruptReporter::ReportItemList reportItemList;
452 AudioZoneInterruptReporter::ReportItem item = make_pair(zoneId, deviceTag);
453 reportItemList.push_back(item);
454 audioZoneInterruptReporter.interruptEnableMaps_.insert(make_pair(clientPid, reportItemList));
455 bool isNull = GetData<bool>();
456 if (isNull) {
457 audioZoneInterruptReporter.interruptEnableMaps_.clear();
458 }
459 audioZoneInterruptReporter.EnableInterruptReport(clientPid, zoneId, deviceTag, enable);
460 }
461
AudioZoneInterruptReporterDisableInterruptReportFuzzTest()462 void AudioZoneInterruptReporterDisableInterruptReportFuzzTest()
463 {
464 AudioZoneInterruptReporter audioZoneInterruptReporter;
465 pid_t clientPid = GetData<pid_t>();
466 int32_t zoneId = GetData<int32_t>();
467 std::string deviceTag = "testDeviceTag";
468 AudioZoneInterruptReporter::ReportItemList reportItemList;
469 AudioZoneInterruptReporter::ReportItem item = make_pair(zoneId, deviceTag);
470 reportItemList.push_back(item);
471 audioZoneInterruptReporter.interruptEnableMaps_.insert(make_pair(clientPid, reportItemList));
472 audioZoneInterruptReporter.DisableInterruptReport(clientPid);
473 audioZoneInterruptReporter.DisableAllInterruptReport();
474 }
475
AudioZoneInterruptReporterCreateReporterFuzzTest()476 void AudioZoneInterruptReporterCreateReporterFuzzTest()
477 {
478 AudioZoneInterruptReporter audioZoneInterruptReporter;
479 std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
480 std::shared_ptr<AudioZoneClientManager> zoneClientManager = std::make_shared<AudioZoneClientManager>(nullptr);
481 AudioZoneInterruptReason reason = AudioZoneInterruptReason::UNBIND_APP_FROM_ZONE;
482 pid_t clientPid = GetData<pid_t>();
483 int32_t zoneId = GetData<int32_t>();
484 std::string deviceTag = "testDeviceTag";
485 AudioZoneInterruptReporter::ReportItemList reportItemList;
486 AudioZoneInterruptReporter::ReportItem item = make_pair(zoneId, deviceTag);
487 reportItemList.push_back(item);
488 audioZoneInterruptReporter.interruptEnableMaps_.insert(make_pair(clientPid, reportItemList));
489 audioZoneInterruptReporter.CreateReporter(interruptService, zoneClientManager, reason);
490 }
491
AudioZoneInterruptReporterGetFocusListFuzzTest()492 void AudioZoneInterruptReporterGetFocusListFuzzTest()
493 {
494 AudioZoneInterruptReporter audioZoneInterruptReporter;
495 audioZoneInterruptReporter.interruptService_ = std::make_shared<AudioInterruptService>();
496 audioZoneInterruptReporter.deviceTag_ = "testDeviceTag";
497 bool isClear = GetData<bool>();
498 if (isClear) {
499 audioZoneInterruptReporter.deviceTag_.clear();
500 }
501 audioZoneInterruptReporter.GetFocusList();
502 }
503
AudioZoneInterruptReporterReportInterruptFuzzTest()504 void AudioZoneInterruptReporterReportInterruptFuzzTest()
505 {
506 AudioZoneInterruptReporter audioZoneInterruptReporter;
507 audioZoneInterruptReporter.interruptService_ = std::make_shared<AudioInterruptService>();
508 audioZoneInterruptReporter.zoneClientManager_ = std::make_shared<AudioZoneClientManager>(nullptr);
509 AudioInterrupt audioInterrupt;
510 AudioFocuState focusState = ACTIVE;
511 audioZoneInterruptReporter.oldFocusList_.push_back(make_pair(audioInterrupt, focusState));
512 audioZoneInterruptReporter.ReportInterrupt();
513 }
514
515 TestPtr g_testPtrs[] = {
516 AudioZoneServiceCreateAudioZoneFuzzTest,
517 AudioZoneServiceReleaseAudioZoneFuzzTest,
518 AudioZoneServiceGetAllAudioZoneFuzzTest,
519 AudioZoneServiceBindDeviceToAudioZoneFuzzTest,
520 AudioZoneServiceRemoveDeviceFromGlobalFuzzTest,
521 AudioZoneServiceUnBindDeviceToAudioZoneFuzzTest,
522 AudioZoneServiceRegisterAudioZoneClientFuzzTest,
523 AudioZoneServiceUnRegisterAudioZoneClientFuzzTest,
524 AudioZoneServiceInjectInterruptToAudioZoneFuzzTest,
525 AudioZoneServiceFetchOutputDevicesFuzzTest,
526 AudioZoneServiceFetchInputDeviceFuzzTest,
527 AudioZoneServiceGetZoneStringDescriptorFuzzTest,
528 AudioZoneServiceUpdateDeviceFromGlobalForAllZoneFuzzTest,
529 AudioZoneServiceClearAudioFocusBySessionIDFuzzTest,
530 AudioZoneInterruptReporterEnableInterruptReportFuzzTest,
531 AudioZoneInterruptReporterDisableInterruptReportFuzzTest,
532 AudioZoneInterruptReporterCreateReporterFuzzTest,
533 AudioZoneInterruptReporterGetFocusListFuzzTest,
534 AudioZoneInterruptReporterReportInterruptFuzzTest,
535 };
536
FuzzTest(const uint8_t * rawData,size_t size)537 void FuzzTest(const uint8_t* rawData, size_t size)
538 {
539 if (rawData == nullptr) {
540 return;
541 }
542
543 RAW_DATA = rawData;
544 g_dataSize = size;
545 g_pos = 0;
546
547 uint32_t code = GetData<uint32_t>();
548 uint32_t len = GetArrLength(g_testPtrs);
549 if (len > 0) {
550 g_testPtrs[code % len]();
551 } else {
552 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
553 }
554 return;
555 }
556
557 } // namespace AudioStandard
558 } // namesapce OHOS
559
560 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)561 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
562 {
563 if (size < OHOS::AudioStandard::THRESHOLD) {
564 return 0;
565 }
566 OHOS::AudioStandard::FuzzTest(data, size);
567 return 0;
568 }