• 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 #undef private
20 #include "audio_info.h"
21 #include "audio_policy_server.h"
22 #include "audio_interrupt_service.h"
23 using namespace std;
24 
25 namespace OHOS {
26 namespace AudioStandard {
27 using namespace std;
28 const int32_t LIMITSIZE = 4;
29 const std::u16string FORMMGR_INTERFACE_TOKEN = u"IAudioPolicy";
30 const uint8_t TESTSIZE = 71;
31 const uint32_t TEST_ID_MODULO = 3;
32 constexpr uint32_t BOOL_MODULO = 2;
33 typedef void (*TestPtr)(const uint8_t *, size_t);
34 
35 class AudioInterruptCallbackFuzzTest : public AudioInterruptCallback {
36 public:
OnInterrupt(const InterruptEventInternal & interruptEvent)37     void OnInterrupt(const InterruptEventInternal &interruptEvent) override {};
38 };
39 
CreateAudioSessionService(shared_ptr<AudioInterruptService> & interruptService,bool isNull,int32_t id)40 static void CreateAudioSessionService(shared_ptr<AudioInterruptService> &interruptService, bool isNull, int32_t id)
41 {
42     if (interruptService == nullptr) {
43         return;
44     }
45     interruptService->sessionService_ = std::make_shared<AudioSessionService>();
46     if (isNull) {
47         interruptService->sessionService_ = nullptr;
48         return;
49     }
50     if (interruptService->sessionService_ == nullptr) {
51         return;
52     }
53     AudioSessionStrategy strategy;
54     interruptService->sessionService_->sessionMap_.insert(
55         std::make_pair(id, std::make_shared<AudioSession>(id, strategy, make_shared<AudioSessionService>())));
56 }
57 
InitFuzzTest(const uint8_t * rawData,size_t size)58 void InitFuzzTest(const uint8_t *rawData, size_t size)
59 {
60     if (rawData == nullptr || size < LIMITSIZE) {
61         return;
62     }
63     sptr<AudioPolicyServer> server = nullptr;
64     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
65 
66     interruptService->Init(server);
67 }
68 
AddDumpInfoFuzzTest(const uint8_t * rawData,size_t size)69 void AddDumpInfoFuzzTest(const uint8_t *rawData, size_t size)
70 {
71     if (rawData == nullptr || size < LIMITSIZE) {
72         return;
73     }
74 
75     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
76     std::unordered_map<int32_t, std::shared_ptr<AudioInterruptZone>> audioInterruptZonesMapDump;
77 
78     interruptService->AddDumpInfo(audioInterruptZonesMapDump);
79 }
80 
SetCallbackHandlerFuzzTest(const uint8_t * rawData,size_t size)81 void SetCallbackHandlerFuzzTest(const uint8_t *rawData, size_t size)
82 {
83     if (rawData == nullptr || size < LIMITSIZE) {
84         return;
85     }
86 
87     std::shared_ptr<AudioPolicyServerHandler> handler = DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
88     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
89 
90     interruptService->SetCallbackHandler(handler);
91 }
92 
SetAudioManagerInterruptCallbackFuzzTest(const uint8_t * rawData,size_t size)93 void SetAudioManagerInterruptCallbackFuzzTest(const uint8_t *rawData, size_t size)
94 {
95     if (rawData == nullptr || size < LIMITSIZE) {
96         return;
97     }
98 
99     MessageParcel data;
100     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
101     data.WriteBuffer(rawData, size);
102     data.RewindRead(0);
103 
104     sptr<IRemoteObject> object = data.ReadRemoteObject();
105     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
106 
107     interruptService->SetAudioManagerInterruptCallback(object);
108 }
109 
ActivateAudioInterruptFuzzTest(const uint8_t * rawData,size_t size)110 void ActivateAudioInterruptFuzzTest(const uint8_t *rawData, size_t size)
111 {
112     if (rawData == nullptr || size < LIMITSIZE) {
113         return;
114     }
115 
116     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
117 
118     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
119     AudioInterrupt audioInterrupt;
120     audioInterrupt.contentType = *reinterpret_cast<const ContentType *>(rawData);
121     audioInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
122     audioInterrupt.audioFocusType.streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
123 
124     interruptService->ActivateAudioInterrupt(zoneId, audioInterrupt);
125 }
126 
DeactivateAudioInterruptFuzzTest(const uint8_t * rawData,size_t size)127 void DeactivateAudioInterruptFuzzTest(const uint8_t *rawData, size_t size)
128 {
129     if (rawData == nullptr || size < LIMITSIZE) {
130         return;
131     }
132 
133     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
134 
135     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
136     AudioInterrupt audioInterrupt;
137     audioInterrupt.contentType = *reinterpret_cast<const ContentType *>(rawData);
138     audioInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
139     audioInterrupt.audioFocusType.streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
140 
141     interruptService->DeactivateAudioInterrupt(zoneId, audioInterrupt);
142 }
143 
CreateAudioInterruptZoneFuzzTest(const uint8_t * rawData,size_t size)144 void CreateAudioInterruptZoneFuzzTest(const uint8_t *rawData, size_t size)
145 {
146     if (rawData == nullptr || size < LIMITSIZE) {
147         return;
148     }
149 
150     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
151 
152     MessageParcel data;
153     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
154     data.WriteBuffer(rawData, size);
155     data.RewindRead(0);
156     std::set<int32_t> pids;
157     pids.insert(data.ReadInt32());
158     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
159 
160     interruptService->CreateAudioInterruptZone(zoneId);
161 }
162 
ReleaseAudioInterruptZoneFuzzTest(const uint8_t * rawData,size_t size)163 void ReleaseAudioInterruptZoneFuzzTest(const uint8_t *rawData, size_t size)
164 {
165     if (rawData == nullptr || size < LIMITSIZE) {
166         return;
167     }
168 
169     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
170 
171     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
172 
173     auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
174         const std::string &streamTag, const StreamUsage &usage)->int32_t {
175         return 0;
176     };
177 
178     interruptService->ReleaseAudioInterruptZone(zoneId, getZoneFunc);
179 }
180 
RemoveAudioInterruptZonePidsFuzzTest(const uint8_t * rawData,size_t size)181 void RemoveAudioInterruptZonePidsFuzzTest(const uint8_t *rawData, size_t size)
182 {
183     if (rawData == nullptr || size < LIMITSIZE) {
184         return;
185     }
186 
187     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
188 
189     MessageParcel data;
190     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
191     data.WriteBuffer(rawData, size);
192     data.RewindRead(0);
193     std::set<int32_t> pids;
194     pids.insert(data.ReadInt32());
195     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
196 
197     auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
198         const std::string &streamTag, const StreamUsage &usage)->int32_t {
199         return 0;
200     };
201     interruptService->MigrateAudioInterruptZone(zoneId, getZoneFunc);
202 }
203 
GetStreamInFocusFuzzTest(const uint8_t * rawData,size_t size)204 void GetStreamInFocusFuzzTest(const uint8_t *rawData, size_t size)
205 {
206     if (rawData == nullptr || size < LIMITSIZE) {
207         return;
208     }
209 
210     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
211 
212     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
213 
214     interruptService->GetStreamInFocus(zoneId);
215 }
216 
GetSessionInfoInFocusFuzzTest(const uint8_t * rawData,size_t size)217 void GetSessionInfoInFocusFuzzTest(const uint8_t *rawData, size_t size)
218 {
219     if (rawData == nullptr || size < LIMITSIZE) {
220         return;
221     }
222 
223     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
224 
225     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
226     AudioInterrupt audioInterrupt;
227     audioInterrupt.contentType = *reinterpret_cast<const ContentType *>(rawData);
228     audioInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
229     audioInterrupt.audioFocusType.streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
230 
231     interruptService->GetSessionInfoInFocus(audioInterrupt, zoneId);
232 }
233 
DispatchInterruptEventWithStreamIdFuzzTest(const uint8_t * rawData,size_t size)234 void DispatchInterruptEventWithStreamIdFuzzTest(const uint8_t *rawData, size_t size)
235 {
236     if (rawData == nullptr || size < LIMITSIZE) {
237         return;
238     }
239 
240     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
241 
242     uint32_t sessionId = *reinterpret_cast<const uint32_t *>(rawData);
243     InterruptEventInternal interruptEvent = {};
244     interruptEvent.eventType = *reinterpret_cast<const InterruptType *>(rawData);
245     interruptEvent.forceType = *reinterpret_cast<const InterruptForceType *>(rawData);
246     interruptEvent.hintType = *reinterpret_cast<const InterruptHint *>(rawData);
247     interruptEvent.duckVolume = 0;
248 
249     interruptService->DispatchInterruptEventWithStreamId(sessionId, interruptEvent);
250 }
251 
RequestAudioFocusFuzzTest(const uint8_t * rawData,size_t size)252 void RequestAudioFocusFuzzTest(const uint8_t *rawData, size_t size)
253 {
254     if (rawData == nullptr || size < LIMITSIZE) {
255         return;
256     }
257 
258     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
259 
260     int32_t clientId = *reinterpret_cast<const int32_t *>(rawData);
261     AudioInterrupt audioInterrupt;
262     audioInterrupt.contentType = *reinterpret_cast<const ContentType *>(rawData);
263     audioInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
264     audioInterrupt.audioFocusType.streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
265 
266     interruptService->RequestAudioFocus(clientId, audioInterrupt);
267 }
268 
AbandonAudioFocusFuzzTest(const uint8_t * rawData,size_t size)269 void AbandonAudioFocusFuzzTest(const uint8_t *rawData, size_t size)
270 {
271     if (rawData == nullptr || size < LIMITSIZE) {
272         return;
273     }
274 
275     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
276 
277     int32_t clientId = *reinterpret_cast<const int32_t *>(rawData);
278     AudioInterrupt audioInterrupt;
279     audioInterrupt.contentType = *reinterpret_cast<const ContentType *>(rawData);
280     audioInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
281     audioInterrupt.audioFocusType.streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
282 
283     interruptService->AbandonAudioFocus(clientId, audioInterrupt);
284 }
285 
SetAudioInterruptCallbackFuzzTest(const uint8_t * rawData,size_t size)286 void SetAudioInterruptCallbackFuzzTest(const uint8_t *rawData, size_t size)
287 {
288     if (rawData == nullptr || size < LIMITSIZE) {
289         return;
290     }
291 
292     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
293 
294     MessageParcel data;
295     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
296     data.WriteBuffer(rawData, size);
297     data.RewindRead(0);
298     sptr<IRemoteObject> object = data.ReadRemoteObject();
299 
300     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
301     uint32_t sessionId = *reinterpret_cast<const uint32_t *>(rawData);
302     uint32_t uid = *reinterpret_cast<const uint32_t *>(rawData);
303 
304     interruptService->SetAudioInterruptCallback(zoneId, sessionId, object, uid);
305 }
306 
UnsetAudioInterruptCallbackFuzzTest(const uint8_t * rawData,size_t size)307 void UnsetAudioInterruptCallbackFuzzTest(const uint8_t *rawData, size_t size)
308 {
309     if (rawData == nullptr || size < LIMITSIZE) {
310         return;
311     }
312 
313     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
314 
315     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
316     uint32_t sessionId = *reinterpret_cast<const uint32_t *>(rawData);
317 
318     interruptService->UnsetAudioInterruptCallback(zoneId, sessionId);
319 }
320 
AddAudioInterruptZonePidsFuzzTest(const uint8_t * rawData,size_t size)321 void AddAudioInterruptZonePidsFuzzTest(const uint8_t *rawData, size_t size)
322 {
323     if (rawData == nullptr || size < LIMITSIZE) {
324         return;
325     }
326 
327     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
328 
329     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
330     MessageParcel data;
331     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
332     data.WriteBuffer(rawData, size);
333     data.RewindRead(0);
334     std::set<int32_t> pids;
335     pids.insert(data.ReadInt32());
336 
337     auto getZoneFunc = [](int32_t uid, const std::string &deviceTag,
338         const std::string &streamTag, const StreamUsage &usage)->int32_t {
339         return 0;
340     };
341     interruptService->MigrateAudioInterruptZone(zoneId, getZoneFunc);
342 }
343 
UpdateAudioSceneFromInterruptFuzzTest(const uint8_t * rawData,size_t size)344 void UpdateAudioSceneFromInterruptFuzzTest(const uint8_t *rawData, size_t size)
345 {
346     if (rawData == nullptr || size < LIMITSIZE) {
347         return;
348     }
349 
350     MessageParcel data;
351     data.WriteInterfaceToken(FORMMGR_INTERFACE_TOKEN);
352     data.WriteBuffer(rawData, size);
353     data.RewindRead(0);
354     AudioScene audioScene = *reinterpret_cast<const AudioScene *>(rawData);
355     AudioInterruptChangeType changeType = *reinterpret_cast<const AudioInterruptChangeType *>(rawData);
356 
357     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
358 
359     interruptService->UpdateAudioSceneFromInterrupt(audioScene, changeType);
360 }
361 
AudioInterruptServiceActivateAudioSessionFuzzTest(const uint8_t * rawData,size_t size)362 void AudioInterruptServiceActivateAudioSessionFuzzTest(const uint8_t *rawData, size_t size)
363 {
364     if (rawData == nullptr || size < LIMITSIZE) {
365         return;
366     }
367 
368     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
369     if (interruptService == nullptr) {
370         return;
371     }
372     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
373     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
374     AudioSessionStrategy strategy;
375     CreateAudioSessionService(interruptService, false, callerPid);
376 
377     interruptService->ActivateAudioSession(zoneId, callerPid, strategy);
378 }
379 
AudioInterruptServiceIsSessionNeedToFetchOutputDeviceFuzzTest(const uint8_t * rawData,size_t size)380 void AudioInterruptServiceIsSessionNeedToFetchOutputDeviceFuzzTest(const uint8_t *rawData, size_t size)
381 {
382     if (rawData == nullptr || size < LIMITSIZE) {
383         return;
384     }
385 
386     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
387     if (interruptService == nullptr) {
388         return;
389     }
390     bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
391     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
392     CreateAudioSessionService(interruptService, !isNullptr, callerPid);
393     interruptService->IsSessionNeedToFetchOutputDevice(callerPid);
394 }
395 
AudioInterruptServiceSetAudioSessionSceneFuzzTest(const uint8_t * rawData,size_t size)396 void AudioInterruptServiceSetAudioSessionSceneFuzzTest(const uint8_t *rawData, size_t size)
397 {
398     if (rawData == nullptr || size < LIMITSIZE) {
399         return;
400     }
401 
402     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
403     if (interruptService == nullptr) {
404         return;
405     }
406     bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
407     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
408     CreateAudioSessionService(interruptService, !isNullptr, callerPid);
409     AudioSessionScene scene = AudioSessionScene::INVALID;
410     interruptService->SetAudioSessionScene(callerPid, scene);
411 }
412 
AudioInterruptServiceAddActiveInterruptToSessionFuzzTest(const uint8_t * rawData,size_t size)413 void AudioInterruptServiceAddActiveInterruptToSessionFuzzTest(const uint8_t *rawData, size_t size)
414 {
415     if (rawData == nullptr || size < LIMITSIZE) {
416         return;
417     }
418 
419     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
420     if (interruptService == nullptr) {
421         return;
422     }
423     bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
424     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
425     CreateAudioSessionService(interruptService, !isNullptr, callerPid);
426     interruptService->AddActiveInterruptToSession(callerPid);
427 }
428 
AudioInterruptServiceDeactivateAudioSessionFuzzTest(const uint8_t * rawData,size_t size)429 void AudioInterruptServiceDeactivateAudioSessionFuzzTest(const uint8_t *rawData, size_t size)
430 {
431     if (rawData == nullptr || size < LIMITSIZE) {
432         return;
433     }
434 
435     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
436     if (interruptService == nullptr) {
437         return;
438     }
439     bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
440     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
441     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
442     CreateAudioSessionService(interruptService, !isNullptr, callerPid);
443     interruptService->zonesMap_.insert(std::make_pair(zoneId, std::make_shared<AudioInterruptZone>()));
444     interruptService->DeactivateAudioSession(zoneId, callerPid);
445 }
446 
AudioInterruptServiceRemovePlaceholderInterruptForSessionFuzzTest(const uint8_t * rawData,size_t size)447 void AudioInterruptServiceRemovePlaceholderInterruptForSessionFuzzTest(const uint8_t *rawData, size_t size)
448 {
449     if (rawData == nullptr || size < LIMITSIZE) {
450         return;
451     }
452 
453     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
454     if (interruptService == nullptr) {
455         return;
456     }
457     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
458     CreateAudioSessionService(interruptService, false, callerPid);
459     bool isSessionTimeout = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
460     interruptService->RemovePlaceholderInterruptForSession(callerPid, isSessionTimeout);
461 }
462 
AudioInterruptServiceIsAudioSessionActivatedFuzzTest(const uint8_t * rawData,size_t size)463 void AudioInterruptServiceIsAudioSessionActivatedFuzzTest(const uint8_t *rawData, size_t size)
464 {
465     if (rawData == nullptr || size < LIMITSIZE) {
466         return;
467     }
468 
469     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
470     if (interruptService == nullptr) {
471         return;
472     }
473     bool isNullptr = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
474 
475     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
476     CreateAudioSessionService(interruptService, !isNullptr, callerPid);
477     interruptService->IsAudioSessionActivated(callerPid);
478 }
479 
AudioInterruptServiceIsCanMixInterruptFuzzTest(const uint8_t * rawData,size_t size)480 void AudioInterruptServiceIsCanMixInterruptFuzzTest(const uint8_t *rawData, size_t size)
481 {
482     if (rawData == nullptr || size < LIMITSIZE) {
483         return;
484     }
485 
486     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
487     if (interruptService == nullptr) {
488         return;
489     }
490     AudioInterrupt incomingInterrupt;
491     AudioInterrupt activeInterrupt;
492     uint32_t testId = *reinterpret_cast<const uint32_t *>(rawData) % TEST_ID_MODULO;
493     if (testId == 0) {
494         incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
495         activeInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
496     } else if (testId == 1) {
497         incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_INVALID;
498         incomingInterrupt.audioFocusType.streamType = STREAM_VOICE_COMMUNICATION;
499         activeInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
500     } else {
501         incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
502         activeInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
503         activeInterrupt.audioFocusType.streamType = STREAM_DEFAULT;
504         incomingInterrupt.audioFocusType.streamType = STREAM_DEFAULT;
505     }
506 
507     interruptService->IsCanMixInterrupt(incomingInterrupt, activeInterrupt);
508 }
509 
AudioInterruptServiceCanMixForSessionFuzzTest(const uint8_t * rawData,size_t size)510 void AudioInterruptServiceCanMixForSessionFuzzTest(const uint8_t *rawData, size_t size)
511 {
512     if (rawData == nullptr || size < LIMITSIZE) {
513         return;
514     }
515 
516     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
517     if (interruptService == nullptr) {
518         return;
519     }
520     AudioInterrupt incomingInterrupt;
521     AudioInterrupt activeInterrupt;
522     incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
523     activeInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
524     activeInterrupt.audioFocusType.streamType = STREAM_DEFAULT;
525     incomingInterrupt.audioFocusType.streamType = STREAM_DEFAULT;
526     AudioFocusEntry focusEntry;
527     focusEntry.isReject = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
528     interruptService->CanMixForSession(incomingInterrupt, activeInterrupt, focusEntry);
529 }
530 
AudioInterruptServiceCanMixForIncomingSessionFuzzTest(const uint8_t * rawData,size_t size)531 void AudioInterruptServiceCanMixForIncomingSessionFuzzTest(const uint8_t *rawData, size_t size)
532 {
533     if (rawData == nullptr || size < LIMITSIZE) {
534         return;
535     }
536 
537     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
538     if (interruptService == nullptr) {
539         return;
540     }
541     AudioInterrupt incomingInterrupt;
542     AudioInterrupt activeInterrupt;
543     incomingInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
544     AudioFocusEntry focusEntry;
545     CreateAudioSessionService(interruptService, false, incomingInterrupt.pid);
546     interruptService->CanMixForIncomingSession(incomingInterrupt, activeInterrupt, focusEntry);
547 }
548 
AudioInterruptServiceIsIncomingStreamLowPriorityFuzzTest(const uint8_t * rawData,size_t size)549 void AudioInterruptServiceIsIncomingStreamLowPriorityFuzzTest(const uint8_t *rawData, size_t size)
550 {
551     if (rawData == nullptr || size < LIMITSIZE) {
552         return;
553     }
554 
555     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
556     if (interruptService == nullptr) {
557         return;
558     }
559     AudioFocusEntry focusEntry;
560     uint32_t testId = *reinterpret_cast<const uint32_t *>(rawData) % TEST_ID_MODULO;
561     if (testId == 0) {
562         focusEntry.isReject = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
563         focusEntry.actionOn = INCOMING;
564         focusEntry.hintType = INTERRUPT_HINT_DUCK;
565     } else if (testId == 1) {
566         focusEntry.isReject = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
567         focusEntry.actionOn = INCOMING;
568         focusEntry.hintType = INTERRUPT_HINT_DUCK;
569     } else {
570         focusEntry.isReject = false;
571         focusEntry.actionOn = BOTH;
572     }
573     interruptService->IsIncomingStreamLowPriority(focusEntry);
574 }
575 
AudioInterruptServiceIsActiveStreamLowPriorityFuzzTest(const uint8_t * rawData,size_t size)576 void AudioInterruptServiceIsActiveStreamLowPriorityFuzzTest(const uint8_t *rawData, size_t size)
577 {
578     if (rawData == nullptr || size < LIMITSIZE) {
579         return;
580     }
581 
582     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
583     if (interruptService == nullptr) {
584         return;
585     }
586     AudioFocusEntry focusEntry;
587     bool testFalse = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
588     if (testFalse) {
589         focusEntry.actionOn = BOTH;
590     } else {
591         focusEntry.actionOn = CURRENT;
592         focusEntry.hintType = INTERRUPT_HINT_DUCK;
593     }
594     interruptService->IsActiveStreamLowPriority(focusEntry);
595 }
596 
AudioInterruptServiceUnsetAudioManagerInterruptCallbackFuzzTest(const uint8_t * rawData,size_t size)597 void AudioInterruptServiceUnsetAudioManagerInterruptCallbackFuzzTest(const uint8_t *rawData, size_t size)
598 {
599     if (rawData == nullptr || size < LIMITSIZE) {
600         return;
601     }
602 
603     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
604     if (interruptService == nullptr) {
605         return;
606     }
607     std::shared_ptr<AudioPolicyServerHandler> handler = DelayedSingleton<AudioPolicyServerHandler>::GetInstance();
608     interruptService->SetCallbackHandler(handler);
609     interruptService->UnsetAudioManagerInterruptCallback();
610 }
611 
AudioInterruptServiceRequestAudioFocusFuzzTest(const uint8_t * rawData,size_t size)612 void AudioInterruptServiceRequestAudioFocusFuzzTest(const uint8_t *rawData, size_t size)
613 {
614     if (rawData == nullptr || size < LIMITSIZE) {
615         return;
616     }
617 
618     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
619     if (interruptService == nullptr) {
620         return;
621     }
622     int32_t clientId = *reinterpret_cast<const int32_t *>(rawData);
623     bool isNotEqual = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
624     if (!isNotEqual) {
625         interruptService->clientOnFocus_ = clientId;
626     }
627     interruptService->focussedAudioInterruptInfo_ = make_unique<AudioInterrupt>();
628     AudioInterrupt audioInterrupt;
629 
630     interruptService->RequestAudioFocus(clientId, audioInterrupt);
631 }
632 
AudioInterruptServiceAbandonAudioFocusFuzzTest(const uint8_t * rawData,size_t size)633 void AudioInterruptServiceAbandonAudioFocusFuzzTest(const uint8_t *rawData, size_t size)
634 {
635     if (rawData == nullptr || size < LIMITSIZE) {
636         return;
637     }
638 
639     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
640     if (interruptService == nullptr) {
641         return;
642     }
643     int32_t clientId = *reinterpret_cast<const int32_t *>(rawData);
644     interruptService->clientOnFocus_ = clientId;
645     AudioInterrupt audioInterrupt;
646     interruptService->AbandonAudioFocus(clientId, audioInterrupt);
647 }
648 
AudioInterruptServiceUnsetAudioInterruptCallbackFuzzTest(const uint8_t * rawData,size_t size)649 void AudioInterruptServiceUnsetAudioInterruptCallbackFuzzTest(const uint8_t *rawData, size_t size)
650 {
651     if (rawData == nullptr || size < LIMITSIZE) {
652         return;
653     }
654 
655     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
656     if (interruptService == nullptr) {
657         return;
658     }
659     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
660     uint32_t streamId = *reinterpret_cast<const uint32_t *>(rawData) + 1;
661     std::shared_ptr<AudioInterruptService::AudioInterruptClient> interruptClient =
662         std::make_shared<AudioInterruptService::AudioInterruptClient>(nullptr, nullptr, nullptr);
663     interruptService->interruptClients_.insert({streamId, interruptClient});
664     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
665     if (zone == nullptr) {
666         return;
667     }
668     zone->interruptCbsMap.insert(std::make_pair(streamId, make_shared<AudioInterruptCallbackFuzzTest>()));
669     interruptService->zonesMap_.insert(std::make_pair(zoneId, zone));
670     interruptService->UnsetAudioInterruptCallback(zoneId, streamId);
671 }
672 
AudioInterruptServiceAudioInterruptIsActiveInFocusListFuzzTest(const uint8_t * rawData,size_t size)673 void AudioInterruptServiceAudioInterruptIsActiveInFocusListFuzzTest(const uint8_t *rawData, size_t size)
674 {
675     if (rawData == nullptr || size < LIMITSIZE) {
676         return;
677     }
678 
679     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
680     if (interruptService == nullptr) {
681         return;
682     }
683     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
684     uint32_t incomingStreamId = *reinterpret_cast<const uint32_t *>(rawData) + 1;
685     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
686     interruptService->zonesMap_.insert(std::make_pair(zoneId, zone));
687 
688     interruptService->AudioInterruptIsActiveInFocusList(zoneId, incomingStreamId);
689 }
690 
AudioInterruptServiceHandleAppStreamTypeFuzzTest(const uint8_t * rawData,size_t size)691 void AudioInterruptServiceHandleAppStreamTypeFuzzTest(const uint8_t *rawData, size_t size)
692 {
693     if (rawData == nullptr || size < LIMITSIZE) {
694         return;
695     }
696 
697     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
698     if (interruptService == nullptr) {
699         return;
700     }
701     AudioInterrupt audioInterrupt;
702     audioInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
703     bool isNull = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
704     CreateAudioSessionService(interruptService, !isNull, audioInterrupt.pid);
705     interruptService->HandleAppStreamType(0, audioInterrupt);
706 }
707 
AudioInterruptServiceActivateAudioInterruptFuzzTest(const uint8_t * rawData,size_t size)708 void AudioInterruptServiceActivateAudioInterruptFuzzTest(const uint8_t *rawData, size_t size)
709 {
710     if (rawData == nullptr || size < LIMITSIZE) {
711         return;
712     }
713 
714     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
715     if (interruptService == nullptr) {
716         return;
717     }
718     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
719     AudioInterrupt audioInterrupt;
720     CreateAudioSessionService(interruptService, false, zoneId);
721     bool isUpdatedAudioStrategy = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
722     interruptService->isPreemptMode_ = !((*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO);
723     interruptService->ActivateAudioInterrupt(zoneId, audioInterrupt, isUpdatedAudioStrategy);
724 }
725 
AudioInterruptServicePrintLogsOfFocusStrategyBaseMusicFuzzTest(const uint8_t * rawData,size_t size)726 void AudioInterruptServicePrintLogsOfFocusStrategyBaseMusicFuzzTest(const uint8_t *rawData, size_t size)
727 {
728     if (rawData == nullptr || size < LIMITSIZE) {
729         return;
730     }
731     static const vector<AudioConcurrencyMode> concurrencyModes = {
732         AudioConcurrencyMode::INVALID,
733         AudioConcurrencyMode::DEFAULT,
734         AudioConcurrencyMode::MIX_WITH_OTHERS,
735         AudioConcurrencyMode::DUCK_OTHERS,
736         AudioConcurrencyMode::PAUSE_OTHERS,
737         AudioConcurrencyMode::SILENT,
738     };
739 
740     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
741     if (interruptService == nullptr || concurrencyModes.empty()) {
742         return;
743     }
744 
745     AudioInterrupt audioInterrupt;
746     CreateAudioSessionService(interruptService, true, 0);
747     AudioFocusType audioFocusType;
748     audioFocusType.streamType = AudioStreamType::STREAM_MUSIC;
749     std::pair<AudioFocusType, AudioFocusType> focusPair = std::make_pair(audioFocusType, audioInterrupt.audioFocusType);
750     AudioFocusEntry focusEntry;
751     focusEntry.hintType = INTERRUPT_HINT_STOP;
752     focusEntry.actionOn = CURRENT;
753     interruptService->focusCfgMap_.insert(std::make_pair(focusPair, focusEntry));
754     uint32_t index = *reinterpret_cast<const uint32_t *>(rawData);
755     audioInterrupt.sessionStrategy.concurrencyMode = concurrencyModes[index % concurrencyModes.size()];
756 
757     interruptService->PrintLogsOfFocusStrategyBaseMusic(audioInterrupt);
758 }
759 
AudioInterruptServiceClearAudioFocusInfoListFuzzTest(const uint8_t * rawData,size_t size)760 void AudioInterruptServiceClearAudioFocusInfoListFuzzTest(const uint8_t *rawData, size_t size)
761 {
762     if (rawData == nullptr || size < LIMITSIZE) {
763         return;
764     }
765 
766     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
767     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
768     if (interruptService == nullptr || zone == nullptr) {
769         return;
770     }
771     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
772     AudioInterrupt audioInterrupt;
773     pair<AudioInterrupt, AudioFocuState> audioFocusInfo = std::make_pair(audioInterrupt, AudioFocuState::MUTED);
774     zone->audioFocusInfoList.emplace_back(audioFocusInfo);
775     interruptService->zonesMap_.insert(std::make_pair(zoneId, zone));
776 
777     interruptService->ClearAudioFocusInfoList();
778 }
779 
AudioInterruptServiceActivatePreemptModeFuzzTest(const uint8_t * rawData,size_t size)780 void AudioInterruptServiceActivatePreemptModeFuzzTest(const uint8_t *rawData, size_t size)
781 {
782     if (rawData == nullptr || size < LIMITSIZE) {
783         return;
784     }
785 
786     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
787     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
788     if (interruptService == nullptr || zone == nullptr) {
789         return;
790     }
791     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
792     interruptService->zonesMap_.insert(std::make_pair(zoneId, zone));
793 
794     interruptService->ActivatePreemptMode();
795     interruptService->DeactivatePreemptMode();
796 }
797 
AudioInterruptServiceInjectInterruptToAudioZoneFuzzTest(const uint8_t * rawData,size_t size)798 void AudioInterruptServiceInjectInterruptToAudioZoneFuzzTest(const uint8_t *rawData, size_t size)
799 {
800     if (rawData == nullptr || size < LIMITSIZE) {
801         return;
802     }
803 
804     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
805     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
806     if (interruptService == nullptr || zone == nullptr) {
807         return;
808     }
809     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
810     AudioInterrupt audioInterrupt;
811     pair<AudioInterrupt, AudioFocuState> audioFocusInfo = std::make_pair(audioInterrupt, AudioFocuState::MUTED);
812     AudioFocusList interrupts;
813     interrupts.emplace_back(audioFocusInfo);
814     interruptService->InjectInterruptToAudioZone(zoneId, interrupts);
815 }
816 
AudioInterruptServiceGetAudioFocusInfoListFuzzTest(const uint8_t * rawData,size_t size)817 void AudioInterruptServiceGetAudioFocusInfoListFuzzTest(const uint8_t *rawData, size_t size)
818 {
819     if (rawData == nullptr || size < LIMITSIZE) {
820         return;
821     }
822 
823     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
824     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
825     if (interruptService == nullptr || zone == nullptr) {
826         return;
827     }
828     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
829     std::string deviceTag = "testdevice";
830     AudioInterrupt audioInterrupt;
831     pair<AudioInterrupt, AudioFocuState> audioFocusInfo = std::make_pair(audioInterrupt, AudioFocuState::MUTED);
832     AudioFocusList interrupts;
833     interrupts.emplace_back(audioFocusInfo);
834     interruptService->GetAudioFocusInfoList(zoneId, deviceTag, interrupts);
835 }
836 
AudioInterruptServiceGetStreamInFocusByUidFuzzTest(const uint8_t * rawData,size_t size)837 void AudioInterruptServiceGetStreamInFocusByUidFuzzTest(const uint8_t *rawData, size_t size)
838 {
839     if (rawData == nullptr || size < LIMITSIZE) {
840         return;
841     }
842 
843     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
844     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
845     if (interruptService == nullptr || zone == nullptr) {
846         return;
847     }
848     int32_t uid = *reinterpret_cast<const int32_t *>(rawData);
849     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
850     AudioInterrupt audioInterrupt;
851     pair<AudioInterrupt, AudioFocuState> audioFocusInfo = std::make_pair(audioInterrupt, AudioFocuState::MUTED);
852     zone->audioFocusInfoList.emplace_back(audioFocusInfo);
853     interruptService->zonesMap_.insert(std::make_pair(zoneId, zone));
854     interruptService->GetStreamInFocusByUid(uid, zoneId);
855 }
856 
AudioInterruptServiceGetSessionInfoInFocusFuzzTest(const uint8_t * rawData,size_t size)857 void AudioInterruptServiceGetSessionInfoInFocusFuzzTest(const uint8_t *rawData, size_t size)
858 {
859     if (rawData == nullptr || size < LIMITSIZE) {
860         return;
861     }
862 
863     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
864     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
865     if (interruptService == nullptr || zone == nullptr) {
866         return;
867     }
868     int32_t uid = *reinterpret_cast<const int32_t *>(rawData);
869     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
870     AudioInterrupt audioInterrupt;
871     pair<AudioInterrupt, AudioFocuState> audioFocusInfo = std::make_pair(audioInterrupt, AudioFocuState::MUTED);
872     zone->audioFocusInfoList.emplace_back(audioFocusInfo);
873     interruptService->zonesMap_.insert(std::make_pair(zoneId, zone));
874     AudioInterrupt interrupt;
875     interruptService->GetSessionInfoInFocus(interrupt, zoneId);
876 }
877 
AudioInterruptServiceIsSameAppInShareModeFuzzTest(const uint8_t * rawData,size_t size)878 void AudioInterruptServiceIsSameAppInShareModeFuzzTest(const uint8_t *rawData, size_t size)
879 {
880     if (rawData == nullptr || size < LIMITSIZE) {
881         return;
882     }
883 
884     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
885     if (interruptService == nullptr) {
886         return;
887     }
888     uint32_t testId = *reinterpret_cast<const uint32_t *>(rawData) % TEST_ID_MODULO;
889     AudioInterrupt incomingInterrupt;
890     AudioInterrupt activeInterrupt;
891     if (testId == 0) {
892         incomingInterrupt.mode = INDEPENDENT_MODE;
893         activeInterrupt.mode = INDEPENDENT_MODE;
894     } else if (testId == 1) {
895         incomingInterrupt.mode = SHARE_MODE;
896         activeInterrupt.mode = SHARE_MODE;
897         incomingInterrupt.pid = AudioInterruptService::DEFAULT_APP_PID;
898         activeInterrupt.pid = AudioInterruptService::DEFAULT_APP_PID;
899     } else {
900         incomingInterrupt.mode = SHARE_MODE;
901         activeInterrupt.mode = SHARE_MODE;
902         incomingInterrupt.pid = AudioInterruptService::STREAM_DEFAULT_PRIORITY;
903         activeInterrupt.pid = AudioInterruptService::STREAM_DEFAULT_PRIORITY;
904     }
905 
906     interruptService->IsSameAppInShareMode(incomingInterrupt, activeInterrupt);
907 }
908 
AudioInterruptServiceCheckAudioSessionExistenceFuzzTest(const uint8_t * rawData,size_t size)909 void AudioInterruptServiceCheckAudioSessionExistenceFuzzTest(const uint8_t *rawData, size_t size)
910 {
911     if (rawData == nullptr || size < LIMITSIZE) {
912         return;
913     }
914 
915     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
916     if (interruptService == nullptr) {
917         return;
918     }
919     AudioInterrupt incomingInterrupt;
920     incomingInterrupt.mode = INDEPENDENT_MODE;
921     incomingInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
922     AudioFocusEntry focusEntry;
923     focusEntry.isReject = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
924     CreateAudioSessionService(interruptService, !focusEntry.isReject, incomingInterrupt.pid);
925 
926     interruptService->CheckAudioSessionExistence(incomingInterrupt, focusEntry);
927 }
928 
AudioInterruptServiceUpdateHintTypeForExistingSessionFuzzTest(const uint8_t * rawData,size_t size)929 void AudioInterruptServiceUpdateHintTypeForExistingSessionFuzzTest(const uint8_t *rawData, size_t size)
930 {
931     if (rawData == nullptr || size < LIMITSIZE) {
932         return;
933     }
934 
935     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
936     if (interruptService == nullptr) {
937         return;
938     }
939     uint32_t testId = *reinterpret_cast<const uint32_t *>(rawData) % TEST_ID_MODULO;
940     AudioInterrupt incomingInterrupt;
941     if (testId == 0) {
942         incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::DUCK_OTHERS;
943     } else if (testId == 1) {
944         incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::PAUSE_OTHERS;
945     } else {
946         incomingInterrupt.sessionStrategy.concurrencyMode = AudioConcurrencyMode::INVALID;
947     }
948     AudioFocusEntry focusEntry;
949     focusEntry.hintType = INTERRUPT_HINT_STOP;
950 
951     interruptService->UpdateHintTypeForExistingSession(incomingInterrupt, focusEntry);
952 }
953 
AudioInterruptServiceProcessRemoteInterruptFuzzTest(const uint8_t * rawData,size_t size)954 void AudioInterruptServiceProcessRemoteInterruptFuzzTest(const uint8_t *rawData, size_t size)
955 {
956     if (rawData == nullptr || size < LIMITSIZE) {
957         return;
958     }
959 
960     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
961     std::shared_ptr<AudioInterruptZone> audioInterruptZone = make_shared<AudioInterruptZone>();
962     if (interruptService == nullptr || audioInterruptZone == nullptr) {
963         return;
964     }
965     int32_t pid = *reinterpret_cast<const int32_t *>(rawData);
966     AudioInterrupt audioInterrupt;
967     audioInterrupt.pid = pid;
968     audioInterrupt.isAudioSessionInterrupt = *reinterpret_cast<const bool *>(rawData);
969     audioInterruptZone->audioFocusInfoList.push_back({audioInterrupt, STOP});
970     interruptService->zonesMap_.insert({pid, audioInterruptZone});
971     InterruptEventInternal interruptEvent;
972     interruptEvent.hintType = *reinterpret_cast<const InterruptHint *>(rawData);
973     std::set<int32_t> sessionIds;
974     interruptService->ProcessRemoteInterrupt(sessionIds, interruptEvent);
975 }
976 
AudioInterruptServiceProcessActiveInterruptFuzzTest(const uint8_t * rawData,size_t size)977 void AudioInterruptServiceProcessActiveInterruptFuzzTest(const uint8_t *rawData, size_t size)
978 {
979     if (rawData == nullptr || size < LIMITSIZE) {
980         return;
981     }
982 
983     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
984     std::shared_ptr<AudioInterruptZone> audioInterruptZone = make_shared<AudioInterruptZone>();
985     if (interruptService == nullptr || audioInterruptZone == nullptr) {
986         return;
987     }
988     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
989     AudioInterrupt audioInterrupt;
990     audioInterrupt.pid = zoneId;
991     audioInterrupt.isAudioSessionInterrupt = *reinterpret_cast<const bool *>(rawData);
992     interruptService->zonesMap_.insert({zoneId, audioInterruptZone});
993     audioInterruptZone->audioFocusInfoList.push_back(
994         {audioInterrupt, *reinterpret_cast<const AudioFocuState *>(rawData)});
995     interruptService->policyServer_ = nullptr;
996     interruptService->ProcessActiveInterrupt(zoneId, audioInterrupt);
997 }
998 
AudioInterruptServiceHandleLowPriorityEventFuzzTest(const uint8_t * rawData,size_t size)999 void AudioInterruptServiceHandleLowPriorityEventFuzzTest(const uint8_t *rawData, size_t size)
1000 {
1001     if (rawData == nullptr || size < LIMITSIZE) {
1002         return;
1003     }
1004 
1005     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1006     std::shared_ptr<AudioSessionService> sessionService = std::make_shared<AudioSessionService>();
1007     if (interruptService == nullptr || sessionService == nullptr) {
1008         return;
1009     }
1010     int32_t pid = *reinterpret_cast<const int32_t *>(rawData);
1011     int32_t streamId = *reinterpret_cast<const int32_t *>(rawData);
1012     sessionService->SetAudioSessionScene(pid, *reinterpret_cast<const AudioSessionScene *>(rawData));
1013     if (sessionService->sessionMap_[pid] == nullptr) {
1014         return;
1015     }
1016     sessionService->sessionMap_[pid]->audioSessionScene_ = *reinterpret_cast<const AudioSessionScene *>(rawData);
1017     sessionService->sessionMap_[pid]->state_ = *reinterpret_cast<const AudioSessionState *>(rawData);
1018     interruptService->sessionService_ = sessionService;
1019     interruptService->handler_ = make_shared<AudioPolicyServerHandler>();
1020     bool isNull = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
1021     if (isNull) {
1022         interruptService->sessionService_ = nullptr;
1023     }
1024     interruptService->HandleLowPriorityEvent(pid, streamId);
1025 }
1026 
AudioInterruptServiceSendActiveInterruptEventFuzzTest(const uint8_t * rawData,size_t size)1027 void AudioInterruptServiceSendActiveInterruptEventFuzzTest(const uint8_t *rawData, size_t size)
1028 {
1029     if (rawData == nullptr || size < LIMITSIZE) {
1030         return;
1031     }
1032 
1033     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1034     if (interruptService == nullptr) {
1035         return;
1036     }
1037     uint32_t streamId = *reinterpret_cast<const uint32_t *>(rawData);
1038     InterruptEventInternal interruptEvent;
1039     interruptEvent.hintType = *reinterpret_cast<const InterruptHint *>(rawData);
1040     AudioInterrupt incomingInterrupt;
1041     AudioInterrupt activeInterrupt;
1042     interruptService->SendActiveInterruptEvent(streamId, interruptEvent, incomingInterrupt, activeInterrupt);
1043 }
1044 
AudioInterruptServiceAudioFocusInfoListRemovalConditionFuzzTest(const uint8_t * rawData,size_t size)1045 void AudioInterruptServiceAudioFocusInfoListRemovalConditionFuzzTest(const uint8_t *rawData, size_t size)
1046 {
1047     if (rawData == nullptr || size < LIMITSIZE) {
1048         return;
1049     }
1050 
1051     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1052     if (interruptService == nullptr) {
1053         return;
1054     }
1055     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
1056     AudioInterrupt audioInterrupt;
1057     audioInterrupt.pid = zoneId;
1058     audioInterrupt.isAudioSessionInterrupt = *reinterpret_cast<const bool *>(rawData);
1059     audioInterrupt.audioFocusType.sourceType = *reinterpret_cast<const SourceType *>(rawData);
1060     AudioFocuState audioFocusState = *reinterpret_cast<const AudioFocuState *>(rawData);
1061     std::pair<AudioInterrupt, AudioFocuState> audioInterruptPair = std::make_pair(audioInterrupt, audioFocusState);
1062 
1063     interruptService->AudioFocusInfoListRemovalCondition(audioInterrupt, audioInterruptPair);
1064 }
1065 
AudioInterruptServiceIsMediaStreamFuzzTest(const uint8_t * rawData,size_t size)1066 void AudioInterruptServiceIsMediaStreamFuzzTest(const uint8_t *rawData, size_t size)
1067 {
1068     if (rawData == nullptr || size < LIMITSIZE) {
1069         return;
1070     }
1071 
1072     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1073     if (interruptService == nullptr) {
1074         return;
1075     }
1076     AudioStreamType audioStreamType = *reinterpret_cast<const AudioStreamType *>(rawData);
1077 
1078     interruptService->IsMediaStream(audioStreamType);
1079 }
1080 
AudioInterruptServiceUpdateAudioFocusStrategyFuzzTest(const uint8_t * rawData,size_t size)1081 void AudioInterruptServiceUpdateAudioFocusStrategyFuzzTest(const uint8_t *rawData, size_t size)
1082 {
1083     if (rawData == nullptr || size < LIMITSIZE) {
1084         return;
1085     }
1086 
1087     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1088     if (interruptService == nullptr) {
1089         return;
1090     }
1091     AudioInterrupt currentInterrupt;
1092     currentInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
1093     AudioInterrupt incomingInterrupt;
1094     incomingInterrupt.uid = *reinterpret_cast<const int32_t *>(rawData);
1095     incomingInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
1096     incomingInterrupt.audioFocusType.sourceType = *reinterpret_cast<const SourceType *>(rawData);
1097     AudioFocusEntry focusEntry;
1098     focusEntry.actionOn = *reinterpret_cast<const ActionTarget *>(rawData);
1099     focusEntry.forceType = *reinterpret_cast<const InterruptForceType *>(rawData);
1100     focusEntry.hintType = *reinterpret_cast<const InterruptHint *>(rawData);
1101     focusEntry.isReject = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
1102     interruptService->policyServer_ = nullptr;
1103 
1104     interruptService->UpdateAudioFocusStrategy(currentInterrupt, incomingInterrupt, focusEntry);
1105 }
1106 
AudioInterruptServiceIsMicSourceFuzzTest(const uint8_t * rawData,size_t size)1107 void AudioInterruptServiceIsMicSourceFuzzTest(const uint8_t *rawData, size_t size)
1108 {
1109     if (rawData == nullptr || size < LIMITSIZE) {
1110         return;
1111     }
1112 
1113     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1114     if (interruptService == nullptr) {
1115         return;
1116     }
1117     SourceType sourceType = *reinterpret_cast<const SourceType *>(rawData);
1118 
1119     interruptService->IsMicSource(sourceType);
1120 }
1121 
AudioInterruptServiceFocusEntryContinueFuzzTest(const uint8_t * rawData,size_t size)1122 void AudioInterruptServiceFocusEntryContinueFuzzTest(const uint8_t *rawData, size_t size)
1123 {
1124     if (rawData == nullptr || size < LIMITSIZE) {
1125         return;
1126     }
1127 
1128     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1129     if (interruptService == nullptr) {
1130         return;
1131     }
1132     AudioInterrupt audioInterrupt;
1133     audioInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
1134     audioInterrupt.uid = AUDIO_ID;
1135     SourceType sourceType = *reinterpret_cast<const SourceType *>(rawData);
1136     audioInterrupt.currencySources.sourcesTypes.push_back(sourceType);
1137     std::list<std::pair<AudioInterrupt, AudioFocuState>> list;
1138     list.push_back({audioInterrupt, ACTIVE});
1139     auto iterActive = list.begin();
1140     AudioFocusEntry focusEntry;
1141     focusEntry.actionOn = *reinterpret_cast<const ActionTarget *>(rawData);
1142     focusEntry.forceType = *reinterpret_cast<const InterruptForceType *>(rawData);
1143     focusEntry.hintType = *reinterpret_cast<const InterruptHint *>(rawData);
1144     focusEntry.isReject = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
1145     AudioInterrupt incomingInterrupt;
1146     incomingInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
1147     interruptService->FocusEntryContinue(iterActive, focusEntry, incomingInterrupt);
1148 }
1149 
AudioInterruptServiceProcessFocusEntryFuzzTest(const uint8_t * rawData,size_t size)1150 void AudioInterruptServiceProcessFocusEntryFuzzTest(const uint8_t *rawData, size_t size)
1151 {
1152     if (rawData == nullptr || size < LIMITSIZE) {
1153         return;
1154     }
1155 
1156     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1157     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
1158     if (interruptService == nullptr || zone == nullptr) {
1159         return;
1160     }
1161     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
1162     AudioInterrupt audioInterrupt;
1163     pair<AudioInterrupt, AudioFocuState> audioFocusInfo = std::make_pair(audioInterrupt, AudioFocuState::MUTED);
1164     zone->audioFocusInfoList.emplace_back(audioFocusInfo);
1165     interruptService->zonesMap_.insert(std::make_pair(zoneId, zone));
1166 
1167     AudioInterrupt incomingInterrupt;
1168     incomingInterrupt.streamUsage = *reinterpret_cast<const StreamUsage *>(rawData);
1169     interruptService->ProcessFocusEntry(zoneId, incomingInterrupt);
1170 }
1171 
GetHighestPriorityAudioSceneFuzzTest(const uint8_t * rawData,size_t size)1172 void GetHighestPriorityAudioSceneFuzzTest(const uint8_t *rawData, size_t size)
1173 {
1174     if (rawData == nullptr || size < LIMITSIZE) {
1175         return;
1176     }
1177     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1178     if (interruptService == nullptr) {
1179         return;
1180     }
1181     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
1182     interruptService->GetHighestPriorityAudioScene(zoneId);
1183 }
1184 
GetStreamTypePriorityFuzzTest(const uint8_t * rawData,size_t size)1185 void GetStreamTypePriorityFuzzTest(const uint8_t *rawData, size_t size)
1186 {
1187     if (rawData == nullptr || size < LIMITSIZE) {
1188         return;
1189     }
1190     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1191     if (interruptService == nullptr) {
1192         return;
1193     }
1194     AudioStreamType streamType = *reinterpret_cast<const AudioStreamType *>(rawData);
1195     interruptService->GetStreamTypePriority(streamType);
1196 }
1197 
DeactivatePreemptModeFuzzTest(const uint8_t * rawData,size_t size)1198 void DeactivatePreemptModeFuzzTest(const uint8_t *rawData, size_t size)
1199 {
1200     if (rawData == nullptr || size < LIMITSIZE) {
1201         return;
1202     }
1203     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1204     if (interruptService == nullptr) {
1205         return;
1206     }
1207     interruptService->DeactivatePreemptMode();
1208 }
1209 
IsCapturerFocusAvailableFuzzTest(const uint8_t * rawData,size_t size)1210 void IsCapturerFocusAvailableFuzzTest(const uint8_t *rawData, size_t size)
1211 {
1212     if (rawData == nullptr || size < LIMITSIZE) {
1213         return;
1214     }
1215     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1216     if (interruptService == nullptr) {
1217         return;
1218     }
1219 
1220     uint32_t zoneId = *reinterpret_cast<const uint32_t *>(rawData);
1221     AudioCapturerInfo capturerInfo;
1222     interruptService->IsCapturerFocusAvailable(zoneId, capturerInfo);
1223 }
1224 
ClearAudioFocusBySessionIDFuzzTest(const uint8_t * rawData,size_t size)1225 void ClearAudioFocusBySessionIDFuzzTest(const uint8_t *rawData, size_t size)
1226 {
1227     if (rawData == nullptr || size < LIMITSIZE) {
1228         return;
1229     }
1230     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1231     if (interruptService == nullptr) {
1232         return;
1233     }
1234     uint32_t sessionID = *reinterpret_cast<const uint32_t *>(rawData);
1235     interruptService->ClearAudioFocusBySessionID(sessionID);
1236 }
1237 
DeactivateAudioSessionInFakeFocusModeFuzzTest(const uint8_t * rawData,size_t size)1238 void DeactivateAudioSessionInFakeFocusModeFuzzTest(const uint8_t *rawData, size_t size)
1239 {
1240     if (rawData == nullptr || size < LIMITSIZE) {
1241         return;
1242     }
1243     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1244     if (interruptService == nullptr) {
1245         return;
1246     }
1247     uint32_t pid = *reinterpret_cast<const int32_t *>(rawData);
1248     InterruptHint hintType = *reinterpret_cast<const InterruptHint *>(rawData);
1249     interruptService->DeactivateAudioSessionInFakeFocusMode(pid, hintType);
1250 }
1251 
DeactivateAudioSessionFakeInterruptFuzzTest(const uint8_t * rawData,size_t size)1252 void DeactivateAudioSessionFakeInterruptFuzzTest(const uint8_t *rawData, size_t size)
1253 {
1254     if (rawData == nullptr || size < LIMITSIZE) {
1255         return;
1256     }
1257     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1258     if (interruptService == nullptr) {
1259         return;
1260     }
1261     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
1262     int32_t callerPid = *reinterpret_cast<const int32_t *>(rawData);
1263     bool isSessionTimeout = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
1264     interruptService->DeactivateAudioSessionFakeInterrupt(zoneId, callerPid, isSessionTimeout);
1265 }
1266 
AudioSessionInfoDumpFuzzTest(const uint8_t * rawData,size_t size)1267 void AudioSessionInfoDumpFuzzTest(const uint8_t *rawData, size_t size)
1268 {
1269     if (rawData == nullptr || size < LIMITSIZE) {
1270         return;
1271     }
1272     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1273     if (interruptService == nullptr) {
1274         return;
1275     }
1276     std::string dumpString = "";
1277     if (interruptService == nullptr) {
1278         return;
1279     }
1280     interruptService->AudioSessionInfoDump(dumpString);
1281 }
1282 
SetSessionMuteStateFuzzTest(const uint8_t * rawData,size_t size)1283 void SetSessionMuteStateFuzzTest(const uint8_t *rawData, size_t size)
1284 {
1285     if (rawData == nullptr || size < LIMITSIZE) {
1286         return;
1287     }
1288     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1289     if (interruptService == nullptr) {
1290         return;
1291     }
1292     uint32_t sessionId = *reinterpret_cast<const uint32_t *>(rawData);
1293     bool insert = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
1294     bool muteFlag = (*reinterpret_cast<const uint32_t *>(rawData)) % BOOL_MODULO;
1295     if (interruptService == nullptr) {
1296         return;
1297     }
1298     interruptService->SetSessionMuteState(sessionId, insert, muteFlag);
1299 }
1300 
SetLatestMuteStateFuzzTest(const uint8_t * rawData,size_t size)1301 void SetLatestMuteStateFuzzTest(const uint8_t *rawData, size_t size)
1302 {
1303     if (rawData == nullptr || size < LIMITSIZE) {
1304         return;
1305     }
1306     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1307     if (interruptService == nullptr) {
1308         return;
1309     }
1310     InterruptEventInternal interruptEvent = {};
1311     interruptEvent.eventType = *reinterpret_cast<const InterruptType *>(rawData);
1312     interruptEvent.forceType = *reinterpret_cast<const InterruptForceType *>(rawData);
1313     interruptEvent.hintType = *reinterpret_cast<const InterruptHint *>(rawData);
1314     interruptEvent.duckVolume = 0;
1315     uint32_t streamId = *reinterpret_cast<const uint32_t *>(rawData);
1316     interruptService->SetLatestMuteState(interruptEvent, streamId);
1317 }
1318 
UpdateMuteAudioFocusStrategyFuzzTest(const uint8_t * rawData,size_t size)1319 void UpdateMuteAudioFocusStrategyFuzzTest(const uint8_t *rawData, size_t size)
1320 {
1321     if (rawData == nullptr || size < LIMITSIZE) {
1322         return;
1323     }
1324     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1325     if (interruptService == nullptr) {
1326         return;
1327     }
1328     AudioInterrupt currentInterrupt;
1329     AudioInterrupt incomingInterrupt;
1330     AudioFocusEntry focusEntry;
1331     focusEntry.hintType = INTERRUPT_HINT_DUCK;
1332     interruptService->UpdateMuteAudioFocusStrategy(currentInterrupt, incomingInterrupt, focusEntry);
1333 }
1334 
ReportRecordGetFocusFailFuzzTest(const uint8_t * rawData,size_t size)1335 void ReportRecordGetFocusFailFuzzTest(const uint8_t *rawData, size_t size)
1336 {
1337     if (rawData == nullptr || size < LIMITSIZE) {
1338         return;
1339     }
1340     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1341     if (interruptService == nullptr) {
1342         return;
1343     }
1344     AudioInterrupt activeInterrupt;
1345     AudioInterrupt incomingInterrupt;
1346     incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
1347     incomingInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
1348     activeInterrupt.audioFocusType.streamType = STREAM_VOICE_CALL;
1349     activeInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
1350     int32_t reason = *reinterpret_cast<const int32_t *>(rawData);
1351     interruptService->ReportRecordGetFocusFail(incomingInterrupt, activeInterrupt, reason);
1352 }
1353 
ProcessActiveStreamFocusFuzzTest(const uint8_t * rawData,size_t size)1354 void ProcessActiveStreamFocusFuzzTest(const uint8_t *rawData, size_t size)
1355 {
1356     if (rawData == nullptr || size < LIMITSIZE) {
1357         return;
1358     }
1359     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1360     shared_ptr<AudioInterruptZone> zone = std::make_shared<AudioInterruptZone>();
1361     if (interruptService == nullptr || zone == nullptr) {
1362         return;
1363     }
1364     int32_t zoneId = *reinterpret_cast<const int32_t *>(rawData);
1365     AudioInterrupt audioInterrupt;
1366     pair<AudioInterrupt, AudioFocuState> audioFocusInfo = std::make_pair(audioInterrupt, AudioFocuState::MUTED);
1367     zone->audioFocusInfoList.emplace_back(audioFocusInfo);
1368     interruptService->zonesMap_.insert(std::make_pair(zoneId, zone));
1369     AudioInterrupt incomingInterrupt;
1370     incomingInterrupt.audioFocusType.sourceType = SOURCE_TYPE_MIC;
1371     incomingInterrupt.audioFocusType.isPlay = false;
1372     AudioFocuState incomingState = MUTED;
1373     std::list<std::pair<AudioInterrupt, AudioFocuState>>::iterator activeInterrupt = zone->audioFocusInfoList.end();
1374     interruptService->ProcessActiveStreamFocus(zone->audioFocusInfoList, incomingInterrupt,
1375         incomingState, activeInterrupt);
1376 }
1377 
CanMixForActiveSessionFuzzTest(const uint8_t * rawData,size_t size)1378 void CanMixForActiveSessionFuzzTest(const uint8_t *rawData, size_t size)
1379 {
1380     if (rawData == nullptr || size < LIMITSIZE) {
1381         return;
1382     }
1383 
1384     std::shared_ptr<AudioInterruptService> interruptService = std::make_shared<AudioInterruptService>();
1385     if (interruptService == nullptr) {
1386         return;
1387     }
1388     AudioInterrupt incomingInterrupt;
1389     AudioInterrupt activeInterrupt;
1390     incomingInterrupt.pid = *reinterpret_cast<const int32_t *>(rawData);
1391     AudioFocusEntry focusEntry;
1392     CreateAudioSessionService(interruptService, false, incomingInterrupt.pid);
1393     interruptService->CanMixForActiveSession(incomingInterrupt, activeInterrupt, focusEntry);
1394 }
1395 } // namespace AudioStandard
1396 } // namesapce OHOS
1397 
1398 OHOS::AudioStandard::TestPtr g_testPtrs[OHOS::AudioStandard::TESTSIZE] = {
1399     OHOS::AudioStandard::InitFuzzTest,
1400     OHOS::AudioStandard::AddDumpInfoFuzzTest,
1401     OHOS::AudioStandard::SetCallbackHandlerFuzzTest,
1402     OHOS::AudioStandard::SetAudioManagerInterruptCallbackFuzzTest,
1403     OHOS::AudioStandard::ActivateAudioInterruptFuzzTest,
1404     OHOS::AudioStandard::DeactivateAudioInterruptFuzzTest,
1405     OHOS::AudioStandard::CreateAudioInterruptZoneFuzzTest,
1406     OHOS::AudioStandard::ReleaseAudioInterruptZoneFuzzTest,
1407     OHOS::AudioStandard::RemoveAudioInterruptZonePidsFuzzTest,
1408     OHOS::AudioStandard::GetStreamInFocusFuzzTest,
1409     OHOS::AudioStandard::GetSessionInfoInFocusFuzzTest,
1410     OHOS::AudioStandard::DispatchInterruptEventWithStreamIdFuzzTest,
1411     OHOS::AudioStandard::RequestAudioFocusFuzzTest,
1412     OHOS::AudioStandard::AbandonAudioFocusFuzzTest,
1413     OHOS::AudioStandard::SetAudioInterruptCallbackFuzzTest,
1414     OHOS::AudioStandard::UnsetAudioInterruptCallbackFuzzTest,
1415     OHOS::AudioStandard::AddAudioInterruptZonePidsFuzzTest,
1416     OHOS::AudioStandard::UpdateAudioSceneFromInterruptFuzzTest,
1417     OHOS::AudioStandard::AudioInterruptServiceActivateAudioSessionFuzzTest,
1418     OHOS::AudioStandard::AudioInterruptServiceIsSessionNeedToFetchOutputDeviceFuzzTest,
1419     OHOS::AudioStandard::AudioInterruptServiceSetAudioSessionSceneFuzzTest,
1420     OHOS::AudioStandard::AudioInterruptServiceAddActiveInterruptToSessionFuzzTest,
1421     OHOS::AudioStandard::AudioInterruptServiceDeactivateAudioSessionFuzzTest,
1422     OHOS::AudioStandard::AudioInterruptServiceRemovePlaceholderInterruptForSessionFuzzTest,
1423     OHOS::AudioStandard::AudioInterruptServiceIsAudioSessionActivatedFuzzTest,
1424     OHOS::AudioStandard::AudioInterruptServiceIsCanMixInterruptFuzzTest,
1425     OHOS::AudioStandard::AudioInterruptServiceCanMixForSessionFuzzTest,
1426     OHOS::AudioStandard::AudioInterruptServiceCanMixForIncomingSessionFuzzTest,
1427     OHOS::AudioStandard::AudioInterruptServiceIsIncomingStreamLowPriorityFuzzTest,
1428     OHOS::AudioStandard::AudioInterruptServiceIsActiveStreamLowPriorityFuzzTest,
1429     OHOS::AudioStandard::AudioInterruptServiceUnsetAudioManagerInterruptCallbackFuzzTest,
1430     OHOS::AudioStandard::AudioInterruptServiceRequestAudioFocusFuzzTest,
1431     OHOS::AudioStandard::AudioInterruptServiceAbandonAudioFocusFuzzTest,
1432     OHOS::AudioStandard::AudioInterruptServiceUnsetAudioInterruptCallbackFuzzTest,
1433     OHOS::AudioStandard::AudioInterruptServiceAudioInterruptIsActiveInFocusListFuzzTest,
1434     OHOS::AudioStandard::AudioInterruptServiceHandleAppStreamTypeFuzzTest,
1435     OHOS::AudioStandard::AudioInterruptServiceActivateAudioInterruptFuzzTest,
1436     OHOS::AudioStandard::AudioInterruptServicePrintLogsOfFocusStrategyBaseMusicFuzzTest,
1437     OHOS::AudioStandard::AudioInterruptServiceClearAudioFocusInfoListFuzzTest,
1438     OHOS::AudioStandard::AudioInterruptServiceActivatePreemptModeFuzzTest,
1439     OHOS::AudioStandard::AudioInterruptServiceInjectInterruptToAudioZoneFuzzTest,
1440     OHOS::AudioStandard::AudioInterruptServiceGetAudioFocusInfoListFuzzTest,
1441     OHOS::AudioStandard::AudioInterruptServiceGetStreamInFocusByUidFuzzTest,
1442     OHOS::AudioStandard::AudioInterruptServiceGetSessionInfoInFocusFuzzTest,
1443     OHOS::AudioStandard::AudioInterruptServiceIsSameAppInShareModeFuzzTest,
1444     OHOS::AudioStandard::AudioInterruptServiceCheckAudioSessionExistenceFuzzTest,
1445     OHOS::AudioStandard::AudioInterruptServiceUpdateHintTypeForExistingSessionFuzzTest,
1446     OHOS::AudioStandard::AudioInterruptServiceProcessRemoteInterruptFuzzTest,
1447     OHOS::AudioStandard::AudioInterruptServiceProcessActiveInterruptFuzzTest,
1448     OHOS::AudioStandard::AudioInterruptServiceHandleLowPriorityEventFuzzTest,
1449     OHOS::AudioStandard::AudioInterruptServiceSendActiveInterruptEventFuzzTest,
1450     OHOS::AudioStandard::AudioInterruptServiceAudioFocusInfoListRemovalConditionFuzzTest,
1451     OHOS::AudioStandard::AudioInterruptServiceIsMediaStreamFuzzTest,
1452     OHOS::AudioStandard::AudioInterruptServiceUpdateAudioFocusStrategyFuzzTest,
1453     OHOS::AudioStandard::AudioInterruptServiceIsMicSourceFuzzTest,
1454     OHOS::AudioStandard::AudioInterruptServiceFocusEntryContinueFuzzTest,
1455     OHOS::AudioStandard::AudioInterruptServiceProcessFocusEntryFuzzTest,
1456     OHOS::AudioStandard::GetHighestPriorityAudioSceneFuzzTest,
1457     OHOS::AudioStandard::GetStreamTypePriorityFuzzTest,
1458     OHOS::AudioStandard::DeactivatePreemptModeFuzzTest,
1459     OHOS::AudioStandard::IsCapturerFocusAvailableFuzzTest,
1460     OHOS::AudioStandard::ClearAudioFocusBySessionIDFuzzTest,
1461     OHOS::AudioStandard::DeactivateAudioSessionInFakeFocusModeFuzzTest,
1462     OHOS::AudioStandard::DeactivateAudioSessionFakeInterruptFuzzTest,
1463     OHOS::AudioStandard::AudioSessionInfoDumpFuzzTest,
1464     OHOS::AudioStandard::SetSessionMuteStateFuzzTest,
1465     OHOS::AudioStandard::SetLatestMuteStateFuzzTest,
1466     OHOS::AudioStandard::UpdateMuteAudioFocusStrategyFuzzTest,
1467     OHOS::AudioStandard::ReportRecordGetFocusFailFuzzTest,
1468     OHOS::AudioStandard::ProcessActiveStreamFocusFuzzTest,
1469     OHOS::AudioStandard::CanMixForActiveSessionFuzzTest,
1470 };
1471 
1472 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1473 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1474 {
1475     /* Run your code on data */
1476     if (data == nullptr || size <= 1) {
1477         return 0;
1478     }
1479     uint8_t firstByte = *data % OHOS::AudioStandard::TESTSIZE;
1480     if (firstByte >= OHOS::AudioStandard::TESTSIZE) {
1481         return 0;
1482     }
1483     data = data + 1;
1484     size = size - 1;
1485     g_testPtrs[firstByte](data, size);
1486     return 0;
1487 }