• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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_stream_collector.h"
17 #include "istandard_client_tracker.h"
18 #include "audio_client_tracker_callback_listener.h"
19 using namespace std;
20 
21 namespace OHOS {
22 namespace AudioStandard {
23 
24 AudioStreamCollector audioStreamCollector_;
25 const int32_t NUM_2 = 2;
26 typedef void (*TestPtr)(const uint8_t *, size_t);
27 
28 const vector<RendererState> g_testRendererState = {
29     RENDERER_INVALID,
30     RENDERER_NEW,
31     RENDERER_PREPARED,
32     RENDERER_RUNNING,
33     RENDERER_STOPPED,
34     RENDERER_RELEASED,
35     RENDERER_PAUSED,
36 };
37 
38 const vector<AudioPipeType> g_testPipeTypes = {
39     PIPE_TYPE_UNKNOWN,
40     PIPE_TYPE_NORMAL_OUT,
41     PIPE_TYPE_NORMAL_IN,
42     PIPE_TYPE_LOWLATENCY_OUT,
43     PIPE_TYPE_LOWLATENCY_IN,
44     PIPE_TYPE_DIRECT_OUT,
45     PIPE_TYPE_DIRECT_IN,
46     PIPE_TYPE_CALL_OUT,
47     PIPE_TYPE_CALL_IN,
48     PIPE_TYPE_OFFLOAD,
49     PIPE_TYPE_MULTICHANNEL,
50     PIPE_TYPE_HIGHRESOLUTION,
51     PIPE_TYPE_SPATIALIZATION,
52     PIPE_TYPE_DIRECT_MUSIC,
53     PIPE_TYPE_DIRECT_VOIP,
54 };
55 
56 const vector<StreamUsage> g_testStreamUsages = {
57     STREAM_USAGE_INVALID,
58     STREAM_USAGE_UNKNOWN,
59     STREAM_USAGE_MEDIA,
60     STREAM_USAGE_MUSIC,
61     STREAM_USAGE_VOICE_COMMUNICATION,
62     STREAM_USAGE_VOICE_ASSISTANT,
63     STREAM_USAGE_ALARM,
64     STREAM_USAGE_VOICE_MESSAGE,
65     STREAM_USAGE_NOTIFICATION_RINGTONE,
66     STREAM_USAGE_RINGTONE,
67     STREAM_USAGE_NOTIFICATION,
68     STREAM_USAGE_ACCESSIBILITY,
69     STREAM_USAGE_SYSTEM,
70     STREAM_USAGE_MOVIE,
71     STREAM_USAGE_GAME,
72     STREAM_USAGE_AUDIOBOOK,
73     STREAM_USAGE_NAVIGATION,
74     STREAM_USAGE_DTMF,
75     STREAM_USAGE_ENFORCED_TONE,
76     STREAM_USAGE_ULTRASONIC,
77     STREAM_USAGE_VIDEO_COMMUNICATION,
78     STREAM_USAGE_RANGING,
79     STREAM_USAGE_VOICE_MODEM_COMMUNICATION,
80     STREAM_USAGE_VOICE_RINGTONE,
81     STREAM_USAGE_VOICE_CALL_ASSISTANT,
82     STREAM_USAGE_MAX,
83 };
84 
85 const vector<DeviceType> g_testDeviceTypes = {
86     DEVICE_TYPE_NONE,
87     DEVICE_TYPE_INVALID,
88     DEVICE_TYPE_EARPIECE,
89     DEVICE_TYPE_SPEAKER,
90     DEVICE_TYPE_WIRED_HEADSET,
91     DEVICE_TYPE_WIRED_HEADPHONES,
92     DEVICE_TYPE_BLUETOOTH_SCO,
93     DEVICE_TYPE_BLUETOOTH_A2DP,
94     DEVICE_TYPE_BLUETOOTH_A2DP_IN,
95     DEVICE_TYPE_MIC,
96     DEVICE_TYPE_WAKEUP,
97     DEVICE_TYPE_USB_HEADSET,
98     DEVICE_TYPE_DP,
99     DEVICE_TYPE_REMOTE_CAST,
100     DEVICE_TYPE_USB_DEVICE,
101     DEVICE_TYPE_ACCESSORY,
102     DEVICE_TYPE_REMOTE_DAUDIO,
103     DEVICE_TYPE_HDMI,
104     DEVICE_TYPE_LINE_DIGITAL,
105     DEVICE_TYPE_NEARLINK,
106     DEVICE_TYPE_NEARLINK_IN,
107     DEVICE_TYPE_FILE_SINK,
108     DEVICE_TYPE_FILE_SOURCE,
109     DEVICE_TYPE_EXTERN_CABLE,
110     DEVICE_TYPE_DEFAULT,
111     DEVICE_TYPE_USB_ARM_HEADSET,
112     DEVICE_TYPE_MAX,
113 };
114 
115 const vector<DeviceRole> g_testDeviceRoles = {
116     DEVICE_ROLE_NONE,
117     INPUT_DEVICE,
118     OUTPUT_DEVICE,
119     DEVICE_ROLE_MAX,
120 };
121 
122 const vector<ContentType> g_testContentTypes = {
123     CONTENT_TYPE_UNKNOWN,
124     CONTENT_TYPE_SPEECH,
125     CONTENT_TYPE_MUSIC,
126     CONTENT_TYPE_MOVIE,
127     CONTENT_TYPE_SONIFICATION,
128     CONTENT_TYPE_RINGTONE,
129     CONTENT_TYPE_PROMPT,
130     CONTENT_TYPE_GAME,
131     CONTENT_TYPE_DTMF,
132     CONTENT_TYPE_ULTRASONIC,
133 };
134 
135 const vector<AudioStreamType> g_testAudioStreamTypes = {
136     STREAM_DEFAULT,
137     STREAM_VOICE_CALL,
138     STREAM_MUSIC,
139     STREAM_RING,
140     STREAM_MEDIA,
141     STREAM_VOICE_ASSISTANT,
142     STREAM_SYSTEM,
143     STREAM_ALARM,
144     STREAM_NOTIFICATION,
145     STREAM_BLUETOOTH_SCO,
146     STREAM_ENFORCED_AUDIBLE,
147     STREAM_DTMF,
148     STREAM_TTS,
149     STREAM_ACCESSIBILITY,
150     STREAM_RECORDING,
151     STREAM_MOVIE,
152     STREAM_GAME,
153     STREAM_SPEECH,
154     STREAM_SYSTEM_ENFORCED,
155     STREAM_ULTRASONIC,
156     STREAM_WAKEUP,
157     STREAM_VOICE_MESSAGE,
158     STREAM_NAVIGATION,
159     STREAM_INTERNAL_FORCE_STOP,
160     STREAM_SOURCE_VOICE_CALL,
161     STREAM_VOICE_COMMUNICATION,
162     STREAM_VOICE_RING,
163     STREAM_VOICE_CALL_ASSISTANT,
164     STREAM_CAMCORDER,
165     STREAM_APP,
166     STREAM_TYPE_MAX,
167     STREAM_ALL,
168 };
169 
170 const vector<SourceType> g_testSourceTypes = {
171     SOURCE_TYPE_INVALID,
172     SOURCE_TYPE_MIC,
173     SOURCE_TYPE_VOICE_RECOGNITION,
174     SOURCE_TYPE_PLAYBACK_CAPTURE,
175     SOURCE_TYPE_WAKEUP,
176     SOURCE_TYPE_VOICE_CALL,
177     SOURCE_TYPE_VOICE_COMMUNICATION,
178     SOURCE_TYPE_ULTRASONIC,
179     SOURCE_TYPE_VIRTUAL_CAPTURE, // only for voice call
180     SOURCE_TYPE_VOICE_MESSAGE,
181     SOURCE_TYPE_REMOTE_CAST,
182     SOURCE_TYPE_VOICE_TRANSCRIPTION,
183     SOURCE_TYPE_CAMCORDER,
184     SOURCE_TYPE_UNPROCESSED,
185     SOURCE_TYPE_EC,
186     SOURCE_TYPE_MIC_REF,
187     SOURCE_TYPE_LIVE,
188     SOURCE_TYPE_MAX,
189 };
190 
191 template<class T>
GetArrLength(T & arr)192 uint32_t GetArrLength(T& arr)
193 {
194     if (arr == nullptr) {
195         AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
196         return 0;
197     }
198     return sizeof(arr) / sizeof(arr[0]);
199 }
200 
AudioStreamCollectorAddRendererStreamFuzzTest(const uint8_t * rawData,size_t size)201 void AudioStreamCollectorAddRendererStreamFuzzTest(const uint8_t *rawData, size_t size)
202 {
203     AudioStreamChangeInfo streamChangeInfo;
204     uint32_t randIntValue = static_cast<uint32_t>(size) % NUM_2;
205     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue;
206     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue++;
207     streamChangeInfo.audioRendererChangeInfo.channelCount = randIntValue++;
208     streamChangeInfo.audioRendererChangeInfo.createrUID = randIntValue--;
209     uint32_t index = static_cast<uint32_t>(size) % g_testRendererState.size();
210     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
211     index = static_cast<uint32_t>(size) % g_testPipeTypes.size();
212     streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = g_testPipeTypes[index];
213     audioStreamCollector_.AddRendererStream(streamChangeInfo);
214 }
215 
AudioStreamCollectorGetRendererStreamInfoFuzzTest(const uint8_t * rawData,size_t size)216 void AudioStreamCollectorGetRendererStreamInfoFuzzTest(const uint8_t *rawData, size_t size)
217 {
218     AudioStreamChangeInfo streamChangeInfo;
219     int32_t randIntValue = static_cast<int32_t>(size);
220     streamChangeInfo.audioCapturerChangeInfo.clientUID = randIntValue;
221     streamChangeInfo.audioCapturerChangeInfo.sessionId = randIntValue + 1;
222     AudioRendererChangeInfo rendererInfo;
223     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
224 
225     rendererChangeInfo->clientUID = randIntValue;
226     rendererChangeInfo->createrUID = randIntValue;
227     rendererChangeInfo->sessionId = randIntValue + 1;
228     audioStreamCollector_.audioRendererChangeInfos_.clear();
229     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
230     audioStreamCollector_.GetRendererStreamInfo(streamChangeInfo, rendererInfo);
231 }
232 
AudioStreamCollectorGetCapturerStreamInfoFuzzTest(const uint8_t * rawData,size_t size)233 void AudioStreamCollectorGetCapturerStreamInfoFuzzTest(const uint8_t *rawData, size_t size)
234 {
235     AudioStreamChangeInfo streamChangeInfo;
236     int32_t randIntValue = static_cast<int32_t>(size);
237     streamChangeInfo.audioCapturerChangeInfo.clientUID = randIntValue;
238     streamChangeInfo.audioCapturerChangeInfo.sessionId = randIntValue + 1;
239     AudioCapturerChangeInfo capturerChangeInfo;
240     shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
241 
242     rendererChangeInfo->clientUID = randIntValue;
243     rendererChangeInfo->createrUID = randIntValue;
244     rendererChangeInfo->sessionId = randIntValue + 1;
245     audioStreamCollector_.audioCapturerChangeInfos_.clear();
246     audioStreamCollector_.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo));
247     audioStreamCollector_.GetCapturerStreamInfo(streamChangeInfo, capturerChangeInfo);
248 }
249 
AudioStreamCollectorGetPipeTypeFuzzTest(const uint8_t * rawData,size_t size)250 void AudioStreamCollectorGetPipeTypeFuzzTest(const uint8_t *rawData, size_t size)
251 {
252     int32_t randIntValue = static_cast<int32_t>(size);
253     int32_t sessionId = randIntValue;
254     uint32_t index = static_cast<uint32_t>(size) % g_testPipeTypes.size();
255     AudioPipeType pipeType = g_testPipeTypes[index];
256     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
257     rendererChangeInfo->clientUID = randIntValue / NUM_2;
258     rendererChangeInfo->createrUID = randIntValue / NUM_2;
259     rendererChangeInfo->sessionId = randIntValue;
260     audioStreamCollector_.audioRendererChangeInfos_.clear();
261     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
262     audioStreamCollector_.GetPipeType(sessionId, pipeType);
263 }
264 
AudioStreamCollectorExistStreamForPipeFuzzTest(const uint8_t * rawData,size_t size)265 void AudioStreamCollectorExistStreamForPipeFuzzTest(const uint8_t *rawData, size_t size)
266 {
267     uint32_t index = static_cast<uint32_t>(size) % g_testPipeTypes.size();
268     AudioPipeType pipeType = g_testPipeTypes[index];
269     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
270     AudioStreamChangeInfo streamChangeInfo;
271     int32_t randIntValue = static_cast<int32_t>(size);
272     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue;
273     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue + 1;
274     index = static_cast<uint32_t>(size) % g_testRendererState.size();
275     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
276 
277     bool result = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
278     if (result) {
279         rendererChangeInfo->createrUID = streamChangeInfo.audioRendererChangeInfo.createrUID;
280         rendererChangeInfo->clientUID = streamChangeInfo.audioRendererChangeInfo.clientUID;
281         audioStreamCollector_.audioRendererChangeInfos_.clear();
282         audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
283         audioStreamCollector_.audioRendererChangeInfos_[0]->rendererInfo.pipeType = pipeType;
284     }
285     audioStreamCollector_.ExistStreamForPipe(pipeType);
286 }
287 
AudioStreamCollectorGetRendererDeviceInfoFuzzTest(const uint8_t * rawData,size_t size)288 void AudioStreamCollectorGetRendererDeviceInfoFuzzTest(const uint8_t *rawData, size_t size)
289 {
290     int32_t randIntValue = static_cast<int32_t>(size);
291     int32_t sessionId = randIntValue;
292     AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
293     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
294 
295     bool result = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
296     if (result) {
297         rendererChangeInfo->clientUID = randIntValue;
298         rendererChangeInfo->createrUID = randIntValue;
299         rendererChangeInfo->sessionId = randIntValue + 1;
300         uint32_t index = static_cast<uint32_t>(size) % g_testPipeTypes.size();
301         rendererChangeInfo->rendererInfo.pipeType = g_testPipeTypes[index];
302         audioStreamCollector_.audioRendererChangeInfos_.clear();
303         audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
304     }
305     audioStreamCollector_.GetRendererDeviceInfo(sessionId, deviceInfo);
306 }
307 
AudioStreamCollectorAddCapturerStreamFuzzTest(const uint8_t * rawData,size_t size)308 void AudioStreamCollectorAddCapturerStreamFuzzTest(const uint8_t *rawData, size_t size)
309 {
310     AudioStreamChangeInfo streamChangeInfo;
311     int32_t randIntValue = static_cast<int32_t>(size) % NUM_2;
312     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue;
313     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue++;
314     streamChangeInfo.audioRendererChangeInfo.channelCount = randIntValue++;
315     streamChangeInfo.audioRendererChangeInfo.createrUID = randIntValue--;
316     uint32_t index = static_cast<uint32_t>(size) % g_testRendererState.size();
317     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
318     index = static_cast<uint32_t>(size) % g_testPipeTypes.size();
319     streamChangeInfo.audioRendererChangeInfo.rendererInfo.pipeType = g_testPipeTypes[index];
320     audioStreamCollector_.AddCapturerStream(streamChangeInfo);
321 }
322 
AudioStreamCollectorSendCapturerInfoEventFuzzTest(const uint8_t * rawData,size_t size)323 void AudioStreamCollectorSendCapturerInfoEventFuzzTest(const uint8_t *rawData, size_t size)
324 {
325     AudioDeviceDescriptor inputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
326     shared_ptr<AudioCapturerChangeInfo> captureChangeInfo = make_shared<AudioCapturerChangeInfo>();
327     int32_t randIntValue = static_cast<int32_t>(size);
328     captureChangeInfo->clientUID = randIntValue;
329     captureChangeInfo->createrUID = randIntValue / NUM_2;
330     captureChangeInfo->sessionId = randIntValue / NUM_2 + 1;
331     captureChangeInfo->inputDeviceInfo = inputDeviceInfo;
332     audioStreamCollector_.audioCapturerChangeInfos_.clear();
333     audioStreamCollector_.audioCapturerChangeInfos_.push_back(captureChangeInfo);
334 
335     std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
336     audioCapturerChangeInfos.push_back(captureChangeInfo);
337     audioStreamCollector_.SendCapturerInfoEvent(audioCapturerChangeInfos);
338 }
339 
AudioStreamCollectorRegisterTrackerFuzzTest(const uint8_t * rawData,size_t size)340 void AudioStreamCollectorRegisterTrackerFuzzTest(const uint8_t *rawData, size_t size)
341 {
342     AudioMode audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
343     AudioStreamChangeInfo streamChangeInfo;
344     int32_t randIntValue = static_cast<int32_t>(size);
345     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue / NUM_2;
346     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue;
347     uint32_t index = static_cast<uint32_t>(size) % g_testRendererState.size();
348     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
349     sptr<IRemoteObject> clientTrackerObj = nullptr;
350 
351     audioStreamCollector_.RegisterTracker(audioMode, streamChangeInfo, clientTrackerObj);
352     audioStreamCollector_.UpdateTracker(audioMode, streamChangeInfo);
353 }
354 
AudioStreamCollectorSetRendererStreamParamFuzzTest(const uint8_t * rawData,size_t size)355 void AudioStreamCollectorSetRendererStreamParamFuzzTest(const uint8_t *rawData, size_t size)
356 {
357     AudioStreamChangeInfo streamChangeInfo;
358     int32_t randIntValue = static_cast<int32_t>(size);
359     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue / NUM_2;
360     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue;
361     uint32_t index = static_cast<uint32_t>(size) % g_testRendererState.size();
362     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
363     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
364 
365     audioStreamCollector_.SetRendererStreamParam(streamChangeInfo, rendererChangeInfo);
366 }
367 
AudioStreamCollectorSetCapturerStreamParamFuzzTest(const uint8_t * rawData,size_t size)368 void AudioStreamCollectorSetCapturerStreamParamFuzzTest(const uint8_t *rawData, size_t size)
369 {
370     AudioStreamChangeInfo streamChangeInfo;
371     int32_t randIntValue = static_cast<int32_t>(size);
372     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue / NUM_2;
373     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue;
374     uint32_t index = static_cast<uint32_t>(size) % g_testRendererState.size();
375     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
376     shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
377 
378     audioStreamCollector_.SetCapturerStreamParam(streamChangeInfo, rendererChangeInfo);
379 }
380 
AudioStreamCollectorResetRendererStreamDeviceInfoFuzzTest(const uint8_t * rawData,size_t size)381 void AudioStreamCollectorResetRendererStreamDeviceInfoFuzzTest(const uint8_t *rawData, size_t size)
382 {
383     AudioDeviceDescriptor outputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
384     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
385 
386     int32_t randIntValue = static_cast<int32_t>(size);
387     rendererChangeInfo->clientUID = randIntValue / NUM_2;
388     rendererChangeInfo->createrUID = randIntValue / NUM_2;
389     rendererChangeInfo->sessionId = randIntValue;
390     uint32_t index = static_cast<uint32_t>(size) % g_testPipeTypes.size();
391     rendererChangeInfo->rendererInfo.pipeType = g_testPipeTypes[index];
392     audioStreamCollector_.audioRendererChangeInfos_.clear();
393     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
394 
395     audioStreamCollector_.ResetRendererStreamDeviceInfo(outputDeviceInfo);
396 }
397 
AudioStreamCollectorResetCapturerStreamDeviceInfoFuzzTest(const uint8_t * rawData,size_t size)398 void AudioStreamCollectorResetCapturerStreamDeviceInfoFuzzTest(const uint8_t *rawData, size_t size)
399 {
400     AudioDeviceDescriptor outputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
401     shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
402 
403     int32_t randIntValue = static_cast<int32_t>(size);
404     rendererChangeInfo->clientUID = randIntValue / NUM_2;
405     rendererChangeInfo->createrUID = randIntValue / NUM_2;
406     rendererChangeInfo->sessionId = randIntValue;
407     audioStreamCollector_.audioCapturerChangeInfos_.clear();
408     audioStreamCollector_.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo));
409     audioStreamCollector_.ResetCapturerStreamDeviceInfo(outputDeviceInfo);
410 }
411 
AudioStreamCollectorCheckRendererStateInfoChangedFuzzTest(const uint8_t * rawData,size_t size)412 void AudioStreamCollectorCheckRendererStateInfoChangedFuzzTest(const uint8_t *rawData, size_t size)
413 {
414     AudioStreamChangeInfo streamChangeInfo;
415     int32_t randIntValue = static_cast<int32_t>(size);
416     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue / NUM_2;
417     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue;
418     uint32_t index = static_cast<uint32_t>(size) % g_testRendererState.size();
419     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
420     audioStreamCollector_.CheckRendererStateInfoChanged(streamChangeInfo);
421 }
422 
AudioStreamCollectorCheckRendererInfoChangedFuzzTest(const uint8_t * rawData,size_t size)423 void AudioStreamCollectorCheckRendererInfoChangedFuzzTest(const uint8_t *rawData, size_t size)
424 {
425     AudioStreamChangeInfo streamChangeInfo;
426     int32_t randIntValue = static_cast<int32_t>(size);
427     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue / NUM_2;
428     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue;
429     uint32_t index = static_cast<uint32_t>(size) % g_testRendererState.size();
430     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
431     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
432 
433     bool result = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
434     if (result) {
435         rendererChangeInfo->createrUID = randIntValue / NUM_2;
436         index = static_cast<uint32_t>(size) % g_testPipeTypes.size();
437         rendererChangeInfo->rendererInfo.pipeType = g_testPipeTypes[index];
438         audioStreamCollector_.audioRendererChangeInfos_.clear();
439         audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
440     }
441 
442     audioStreamCollector_.CheckRendererInfoChanged(streamChangeInfo);
443 }
444 
AudioStreamCollectorResetRingerModeMuteFuzzTest(const uint8_t * rawData,size_t size)445 void AudioStreamCollectorResetRingerModeMuteFuzzTest(const uint8_t *rawData, size_t size)
446 {
447     uint32_t index = static_cast<uint32_t>(size) % g_testRendererState.size();
448     RendererState rendererState = g_testRendererState[index];
449     index = static_cast<uint32_t>(size) % g_testStreamUsages.size();
450     StreamUsage streamUsage = g_testStreamUsages[index];
451     audioStreamCollector_.ResetRingerModeMute(rendererState, streamUsage);
452 }
453 
AudioStreamCollectorUpdateRendererStreamInternalFuzzTest(const uint8_t * rawData,size_t size)454 void AudioStreamCollectorUpdateRendererStreamInternalFuzzTest(const uint8_t *rawData, size_t size)
455 {
456     AudioStreamChangeInfo streamChangeInfo;
457     int32_t randIntValue = static_cast<int32_t>(size);
458     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue / NUM_2;
459     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue;
460     uint32_t index = static_cast<uint32_t>(size) % g_testRendererState.size();
461     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
462     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
463     bool result = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
464     if (result) {
465         rendererChangeInfo->createrUID = randIntValue / NUM_2;
466         index = static_cast<uint32_t>(size) % g_testPipeTypes.size();
467         rendererChangeInfo->rendererInfo.pipeType = g_testPipeTypes[index];
468         audioStreamCollector_.audioRendererChangeInfos_.clear();
469         audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
470     }
471 
472     audioStreamCollector_.UpdateRendererStreamInternal(streamChangeInfo);
473 }
474 
AudioStreamCollectorUpdateCapturerStreamInternalFuzzTest(const uint8_t * rawData,size_t size)475 void AudioStreamCollectorUpdateCapturerStreamInternalFuzzTest(const uint8_t *rawData, size_t size)
476 {
477     AudioStreamChangeInfo streamChangeInfo;
478     int32_t randIntValue = static_cast<int32_t>(size);
479     streamChangeInfo.audioCapturerChangeInfo.clientUID = randIntValue % NUM_2;
480     streamChangeInfo.audioCapturerChangeInfo.sessionId = randIntValue;
481     streamChangeInfo.audioCapturerChangeInfo.prerunningState = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
482     shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_shared<AudioCapturerChangeInfo>();
483 
484     bool result = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
485     if (result) {
486         capturerChangeInfo->clientUID = randIntValue % NUM_2;
487         capturerChangeInfo->sessionId = randIntValue;
488         capturerChangeInfo->prerunningState = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
489         audioStreamCollector_.audioCapturerChangeInfos_.clear();
490         audioStreamCollector_.audioCapturerChangeInfos_.push_back(move(capturerChangeInfo));
491     }
492 
493     audioStreamCollector_.UpdateCapturerStreamInternal(streamChangeInfo);
494 }
495 
AudioStreamCollectorUpdateTrackerFuzzTest(const uint8_t * rawData,size_t size)496 void AudioStreamCollectorUpdateTrackerFuzzTest(const uint8_t *rawData, size_t size)
497 {
498     vector<AudioMode> audioModes = {
499         AUDIO_MODE_PLAYBACK,
500         AUDIO_MODE_RECORD,
501     };
502     uint32_t index = static_cast<uint32_t>(size) % audioModes.size();
503     AudioMode audioMode = audioModes[index];
504     AudioDeviceDescriptor audioDev(AudioDeviceDescriptor::DEVICE_INFO);
505     audioStreamCollector_.UpdateTracker(audioMode, audioDev);
506 
507     int32_t randIntValue = static_cast<int32_t>(size);
508     AudioStreamChangeInfo streamChangeInfo;
509     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue / NUM_2;
510     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue;
511     index = static_cast<uint32_t>(size) % g_testRendererState.size();
512     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index];
513     sptr<IRemoteObject> clientTrackerObj = nullptr;
514 
515     audioStreamCollector_.RegisterTracker(audioMode, streamChangeInfo, clientTrackerObj);
516     audioStreamCollector_.UpdateTracker(audioMode, streamChangeInfo);
517 }
518 
AudioStreamCollectorUpdateRendererDeviceInfoFuzzTest(const uint8_t * rawData,size_t size)519 void AudioStreamCollectorUpdateRendererDeviceInfoFuzzTest(const uint8_t *rawData, size_t size)
520 {
521     shared_ptr<AudioDeviceDescriptor> outputDeviceInfoPtr = make_shared<AudioDeviceDescriptor>(
522         AudioDeviceDescriptor::DEVICE_INFO);
523     uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
524     outputDeviceInfoPtr->deviceType_ = g_testDeviceTypes[index];
525     auto info1 = std::make_unique<AudioRendererChangeInfo>();
526     info1->outputDeviceInfo.deviceType_ = g_testDeviceTypes[index / NUM_2];
527     audioStreamCollector_.audioRendererChangeInfos_.clear();
528     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(info1));
529     auto info2 = std::make_unique<AudioRendererChangeInfo>();
530     info2->outputDeviceInfo.deviceType_ = g_testDeviceTypes[(index + 1) / NUM_2];
531     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(info2));
532     audioStreamCollector_.UpdateRendererDeviceInfo(outputDeviceInfoPtr);
533 
534     AudioDeviceDescriptor outputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
535     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
536     int32_t randIntValue = static_cast<int32_t>(size);
537     int32_t clientUID = randIntValue / NUM_2;
538     int32_t sessionId = randIntValue;
539     rendererChangeInfo->clientUID = randIntValue / NUM_2;
540     rendererChangeInfo->createrUID = randIntValue / NUM_2;
541     rendererChangeInfo->sessionId = randIntValue;
542     rendererChangeInfo->outputDeviceInfo = outputDeviceInfo;
543     audioStreamCollector_.audioRendererChangeInfos_.clear();
544     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
545     audioStreamCollector_.UpdateRendererDeviceInfo(clientUID, sessionId, outputDeviceInfo);
546 }
547 
AudioStreamCollectorUpdateCapturerDeviceInfoFuzzTest(const uint8_t * rawData,size_t size)548 void AudioStreamCollectorUpdateCapturerDeviceInfoFuzzTest(const uint8_t *rawData, size_t size)
549 {
550     shared_ptr<AudioDeviceDescriptor> inputDeviceInfoPtr = make_shared<AudioDeviceDescriptor>(
551         AudioDeviceDescriptor::DEVICE_INFO);
552     uint32_t index = static_cast<uint32_t>(size) % g_testDeviceTypes.size();
553     inputDeviceInfoPtr->deviceType_ = g_testDeviceTypes[index];
554     auto info1 = std::make_unique<AudioCapturerChangeInfo>();
555     info1->inputDeviceInfo.deviceType_ = g_testDeviceTypes[index / NUM_2];
556     audioStreamCollector_.audioCapturerChangeInfos_.clear();
557     audioStreamCollector_.audioCapturerChangeInfos_.push_back(std::move(info1));
558     auto info2 = std::make_unique<AudioCapturerChangeInfo>();
559     info2->inputDeviceInfo.deviceType_ = g_testDeviceTypes[(index + 1) / NUM_2];
560     audioStreamCollector_.audioCapturerChangeInfos_.push_back(std::move(info2));
561     audioStreamCollector_.UpdateCapturerDeviceInfo(inputDeviceInfoPtr);
562 
563     AudioDeviceDescriptor inputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
564     shared_ptr<AudioCapturerChangeInfo> captureChangeInfo = make_shared<AudioCapturerChangeInfo>();
565     int32_t randIntValue = static_cast<int32_t>(size);
566     captureChangeInfo->clientUID = randIntValue / NUM_2;
567     captureChangeInfo->createrUID = randIntValue / NUM_2;
568     captureChangeInfo->sessionId = randIntValue;
569     captureChangeInfo->inputDeviceInfo = inputDeviceInfo;
570     audioStreamCollector_.audioCapturerChangeInfos_.clear();
571     audioStreamCollector_.audioCapturerChangeInfos_.push_back(move(captureChangeInfo));
572     int32_t clientUID = randIntValue / NUM_2;
573     int32_t sessionId = randIntValue;
574     AudioDeviceDescriptor outputDeviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
575     index = static_cast<uint32_t>(size) % g_testDeviceRoles.size();
576     outputDeviceInfo.deviceRole_ = g_testDeviceRoles[index];
577 
578     audioStreamCollector_.UpdateCapturerDeviceInfo(clientUID, sessionId, outputDeviceInfo);
579 }
580 
AudioStreamCollectorUpdateRendererPipeInfoFuzzTest(const uint8_t * rawData,size_t size)581 void AudioStreamCollectorUpdateRendererPipeInfoFuzzTest(const uint8_t *rawData, size_t size)
582 {
583     int32_t randIntValue = static_cast<int32_t>(size);
584     int32_t sessionId = randIntValue;
585     uint32_t index = static_cast<uint32_t>(size) % g_testPipeTypes.size();
586     AudioPipeType normalPipe = g_testPipeTypes[index];
587     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
588 
589     rendererChangeInfo->clientUID = randIntValue / NUM_2;
590     rendererChangeInfo->createrUID = randIntValue / NUM_2;
591     rendererChangeInfo->sessionId = randIntValue;
592     rendererChangeInfo->rendererInfo.pipeType = g_testPipeTypes[index / NUM_2];
593     audioStreamCollector_.audioRendererChangeInfos_.clear();
594     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
595 
596     audioStreamCollector_.UpdateRendererPipeInfo(sessionId, normalPipe);
597 }
598 
AudioStreamCollectorUpdateAppVolumeFuzzTest(const uint8_t * rawData,size_t size)599 void AudioStreamCollectorUpdateAppVolumeFuzzTest(const uint8_t *rawData, size_t size)
600 {
601     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
602     int32_t randIntValue = static_cast<int32_t>(size);
603     rendererChangeInfo->clientUID = randIntValue / NUM_2;
604     rendererChangeInfo->createrUID = randIntValue / NUM_2;
605     rendererChangeInfo->sessionId = randIntValue;
606     rendererChangeInfo->outputDeviceInfo = AudioDeviceDescriptor(AudioDeviceDescriptor::DEVICE_INFO);
607     audioStreamCollector_.audioRendererChangeInfos_.clear();
608     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
609 
610     int32_t appUid = randIntValue / NUM_2;
611     int32_t volume = randIntValue % NUM_2;
612     audioStreamCollector_.UpdateAppVolume(appUid, volume);
613 }
614 
AudioStreamCollectorGetStreamTypeFuzzTest(const uint8_t * rawData,size_t size)615 void AudioStreamCollectorGetStreamTypeFuzzTest(const uint8_t *rawData, size_t size)
616 {
617     uint32_t index = static_cast<uint32_t>(size) % g_testContentTypes.size();
618     ContentType contentType = g_testContentTypes[index];
619     index = static_cast<uint32_t>(size) % g_testStreamUsages.size();
620     StreamUsage streamUsage = g_testStreamUsages[index];
621     audioStreamCollector_.GetStreamType(contentType, streamUsage);
622 
623     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
624     int32_t randIntValue = static_cast<int32_t>(size);
625     rendererChangeInfo->clientUID = randIntValue;
626     rendererChangeInfo->createrUID = randIntValue;
627     rendererChangeInfo->sessionId = randIntValue + 1;
628     audioStreamCollector_.audioRendererChangeInfos_.clear();
629     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
630     int32_t sessionId = randIntValue;
631     audioStreamCollector_.GetStreamType(sessionId);
632 }
633 
AudioStreamCollectorGetSessionIdsOnRemoteDeviceByStreamUsageFuzzTest(const uint8_t * rawData,size_t size)634 void AudioStreamCollectorGetSessionIdsOnRemoteDeviceByStreamUsageFuzzTest(const uint8_t *rawData, size_t size)
635 {
636     vector<InterruptHint> testInterruptHints = {
637         INTERRUPT_HINT_NONE,
638         INTERRUPT_HINT_RESUME,
639         INTERRUPT_HINT_PAUSE,
640         INTERRUPT_HINT_STOP,
641         INTERRUPT_HINT_DUCK,
642         INTERRUPT_HINT_UNDUCK,
643         INTERRUPT_HINT_MUTE,
644         INTERRUPT_HINT_UNMUTE
645     };
646     uint32_t index = static_cast<uint32_t>(size);
647     StreamUsage streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
648     DeviceType deviceType = g_testDeviceTypes[index % g_testDeviceTypes.size()];
649     DeviceRole role = g_testDeviceRoles[index % g_testDeviceRoles.size()];
650     AudioDeviceDescriptor outputDeviceInfo(deviceType, role, 0, 0, "RemoteDevice");
651     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
652     int32_t randIntValue = static_cast<int32_t>(size);
653     rendererChangeInfo->clientUID = randIntValue / NUM_2;
654     rendererChangeInfo->createrUID = randIntValue / NUM_2;
655     rendererChangeInfo->sessionId = randIntValue;
656     rendererChangeInfo->outputDeviceInfo = outputDeviceInfo;
657     rendererChangeInfo->rendererInfo.streamUsage = streamUsage;
658     audioStreamCollector_.audioRendererChangeInfos_.clear();
659     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
660 
661     audioStreamCollector_.GetSessionIdsOnRemoteDeviceByStreamUsage(streamUsage);
662     audioStreamCollector_.GetSessionIdsOnRemoteDeviceByDeviceType(deviceType);
663 }
664 
AudioStreamCollectorIsOffloadAllowedFuzzTest(const uint8_t * rawData,size_t size)665 void AudioStreamCollectorIsOffloadAllowedFuzzTest(const uint8_t *rawData, size_t size)
666 {
667     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
668     int32_t randIntValue = static_cast<int32_t>(size);
669     int32_t sessionId = randIntValue / NUM_2;
670     rendererChangeInfo->createrUID = randIntValue / NUM_2;
671     rendererChangeInfo->clientUID = randIntValue / NUM_2;
672     rendererChangeInfo->sessionId = randIntValue;
673     audioStreamCollector_.audioRendererChangeInfos_.clear();
674     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
675 
676     audioStreamCollector_.IsOffloadAllowed(sessionId);
677 }
678 
AudioStreamCollectorGetChannelCountFuzzTest(const uint8_t * rawData,size_t size)679 void AudioStreamCollectorGetChannelCountFuzzTest(const uint8_t *rawData, size_t size)
680 {
681     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
682     int32_t randIntValue = static_cast<int32_t>(size);
683     int32_t sessionId = randIntValue / NUM_2;
684     rendererChangeInfo->createrUID = randIntValue / NUM_2;
685     rendererChangeInfo->clientUID = randIntValue / NUM_2;
686     rendererChangeInfo->sessionId = randIntValue;
687     audioStreamCollector_.audioRendererChangeInfos_.clear();
688     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
689 
690     audioStreamCollector_.GetChannelCount(sessionId);
691 }
692 
AudioStreamCollectorGetCurrentRendererChangeInfosFuzzTest(const uint8_t * rawData,size_t size)693 void AudioStreamCollectorGetCurrentRendererChangeInfosFuzzTest(const uint8_t *rawData, size_t size)
694 {
695     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
696     std::vector<shared_ptr<AudioRendererChangeInfo>> rendererChangeInfos;
697     int32_t randIntValue = static_cast<int32_t>(size);
698     rendererChangeInfo->createrUID = randIntValue / NUM_2;
699     rendererChangeInfo->clientUID = randIntValue / NUM_2;
700     rendererChangeInfo->sessionId = randIntValue;
701     audioStreamCollector_.audioRendererChangeInfos_.clear();
702     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
703 
704     audioStreamCollector_.GetCurrentRendererChangeInfos(rendererChangeInfos);
705 }
706 
AudioStreamCollectorGetCurrentCapturerChangeInfosFuzzTest(const uint8_t * rawData,size_t size)707 void AudioStreamCollectorGetCurrentCapturerChangeInfosFuzzTest(const uint8_t *rawData, size_t size)
708 {
709     shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
710     std::vector<shared_ptr<AudioCapturerChangeInfo>> rendererChangeInfos;
711     int32_t randIntValue = static_cast<int32_t>(size);
712     rendererChangeInfo->createrUID = randIntValue / NUM_2;
713     rendererChangeInfo->clientUID = randIntValue / NUM_2;
714     rendererChangeInfo->sessionId = randIntValue;
715     audioStreamCollector_.audioCapturerChangeInfos_.clear();
716     audioStreamCollector_.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo));
717     audioStreamCollector_.GetCurrentCapturerChangeInfos(rendererChangeInfos);
718 }
719 
AudioStreamCollectorRegisteredTrackerClientDiedFuzzTest(const uint8_t * rawData,size_t size)720 void AudioStreamCollectorRegisteredTrackerClientDiedFuzzTest(const uint8_t *rawData, size_t size)
721 {
722     int32_t randIntValue = static_cast<int32_t>(size);
723     int32_t uid = randIntValue / NUM_2;
724     int32_t pid = randIntValue / NUM_2;
725     audioStreamCollector_.GetLastestRunningCallStreamUsage();
726     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
727 
728     rendererChangeInfo->clientUID = randIntValue / NUM_2;
729     rendererChangeInfo->createrUID = randIntValue / NUM_2;
730     rendererChangeInfo->clientPid = randIntValue / NUM_2;
731     rendererChangeInfo->sessionId = randIntValue;
732     audioStreamCollector_.audioRendererChangeInfos_.clear();
733     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
734     audioStreamCollector_.RegisteredTrackerClientDied(uid, pid);
735 }
736 
AudioStreamCollectorGetAndCompareStreamTypeFuzzTest(const uint8_t * rawData,size_t size)737 void AudioStreamCollectorGetAndCompareStreamTypeFuzzTest(const uint8_t *rawData, size_t size)
738 {
739     uint32_t index = static_cast<uint32_t>(size);
740     StreamUsage targetUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
741     AudioRendererInfo rendererInfo;
742     rendererInfo.contentType = g_testContentTypes[index % g_testContentTypes.size()];
743     rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
744     audioStreamCollector_.GetAndCompareStreamType(targetUsage, rendererInfo);
745 }
746 
AudioStreamCollectorGetUidFuzzTest(const uint8_t * rawData,size_t size)747 void AudioStreamCollectorGetUidFuzzTest(const uint8_t *rawData, size_t size)
748 {
749     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
750     int32_t randIntValue = static_cast<int32_t>(size);
751     int32_t sessionId = randIntValue;
752 
753     rendererChangeInfo->createrUID = randIntValue / NUM_2;
754     rendererChangeInfo->clientUID = randIntValue / NUM_2;
755     rendererChangeInfo->sessionId = randIntValue;
756     audioStreamCollector_.audioRendererChangeInfos_.clear();
757     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
758     audioStreamCollector_.GetUid(sessionId);
759 }
760 
AudioStreamCollectorResumeStreamStateFuzzTest(const uint8_t * rawData,size_t size)761 void AudioStreamCollectorResumeStreamStateFuzzTest(const uint8_t *rawData, size_t size)
762 {
763     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
764     int32_t randIntValue = static_cast<int32_t>(size);
765     rendererChangeInfo->clientUID = randIntValue / NUM_2;
766     rendererChangeInfo->createrUID = randIntValue / NUM_2;
767     rendererChangeInfo->sessionId = randIntValue;
768     audioStreamCollector_.audioRendererChangeInfos_.clear();
769     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
770     audioStreamCollector_.ResumeStreamState();
771 }
772 
AudioStreamCollectorUpdateStreamStateFuzzTest(const uint8_t * rawData,size_t size)773 void AudioStreamCollectorUpdateStreamStateFuzzTest(const uint8_t *rawData, size_t size)
774 {
775     vector<StreamSetState> testStreamSetState = {
776         STREAM_PAUSE,
777         STREAM_RESUME,
778         STREAM_MUTE,
779         STREAM_UNMUTE,
780     };
781     int32_t randIntValue = static_cast<int32_t>(size);
782     int32_t clientUid = randIntValue / NUM_2;
783     StreamSetStateEventInternal event;
784     uint32_t index = static_cast<uint32_t>(size);
785     event.streamSetState = testStreamSetState[index % testStreamSetState.size()];
786     event.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
787     auto changeInfo = std::make_unique<AudioRendererChangeInfo>();
788     changeInfo->clientUID = clientUid;
789     changeInfo->rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
790     changeInfo->sessionId = randIntValue % NUM_2;
791     audioStreamCollector_.audioRendererChangeInfos_.clear();
792     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(changeInfo));
793     audioStreamCollector_.UpdateStreamState(clientUid, event);
794 }
795 
AudioStreamCollectorHandleAppStateChangeFuzzTest(const uint8_t * rawData,size_t size)796 void AudioStreamCollectorHandleAppStateChangeFuzzTest(const uint8_t *rawData, size_t size)
797 {
798     int32_t randIntValue = static_cast<int32_t>(size);
799     int32_t clientUid = randIntValue / NUM_2;
800     int32_t clientPid = static_cast<int32_t>(size);
801     uint32_t index = static_cast<uint32_t>(size);
802     bool notifyMute = static_cast<bool>(index % NUM_2);
803     auto changeInfo = std::make_unique<AudioRendererChangeInfo>();
804     changeInfo->clientUID = clientUid;
805     changeInfo->clientPid = clientPid;
806     changeInfo->rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
807     changeInfo->sessionId = randIntValue;
808     changeInfo->backMute = static_cast<bool>(index % NUM_2);
809     audioStreamCollector_.audioRendererChangeInfos_.clear();
810     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(changeInfo));
811     bool hasBackTask = static_cast<int32_t>(size) % NUM_2;
812     bool mute = static_cast<bool>(index % NUM_2);
813     audioStreamCollector_.HandleAppStateChange(clientUid, clientPid, mute, notifyMute, hasBackTask);
814 }
815 
AudioStreamCollectorHandleFreezeStateChangeFuzzTest(const uint8_t * rawData,size_t size)816 void AudioStreamCollectorHandleFreezeStateChangeFuzzTest(const uint8_t *rawData, size_t size)
817 {
818     int32_t randIntValue = static_cast<int32_t>(size);
819     int32_t clientPid = randIntValue / NUM_2;
820     uint32_t index = static_cast<uint32_t>(size);
821     bool hasSession = static_cast<bool>(index % NUM_2);
822     auto changeInfo = std::make_unique<AudioRendererChangeInfo>();
823     changeInfo->clientPid = clientPid;
824     changeInfo->rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
825     changeInfo->sessionId = randIntValue / NUM_2;
826     audioStreamCollector_.audioRendererChangeInfos_.clear();
827     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(changeInfo));
828     audioStreamCollector_.HandleFreezeStateChange(clientPid, static_cast<bool>(index % NUM_2), hasSession);
829 }
830 
AudioStreamCollectorHandleBackTaskStateChangeFuzzTest(const uint8_t * rawData,size_t size)831 void AudioStreamCollectorHandleBackTaskStateChangeFuzzTest(const uint8_t *rawData, size_t size)
832 {
833     static uint32_t stepSize = 0;
834     int32_t randIntValue = static_cast<int32_t>(size);
835     int32_t clientUid = randIntValue / NUM_2;
836     uint32_t index = static_cast<uint32_t>(size);
837     bool hasSession = static_cast<bool>(index % NUM_2);
838     auto changeInfo = std::make_unique<AudioRendererChangeInfo>();
839     changeInfo->clientUID = clientUid;
840     changeInfo->rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
841     changeInfo->sessionId = randIntValue / NUM_2;
842 
843     changeInfo->backMute = static_cast<bool>((index + stepSize++) % NUM_2);
844     audioStreamCollector_.audioRendererChangeInfos_.clear();
845     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(changeInfo));
846     audioStreamCollector_.HandleBackTaskStateChange(clientUid, hasSession);
847 }
848 
AudioStreamCollectorHandleStartStreamMuteStateFuzzTest(const uint8_t * rawData,size_t size)849 void AudioStreamCollectorHandleStartStreamMuteStateFuzzTest(const uint8_t *rawData, size_t size)
850 {
851     int32_t randIntValue = static_cast<int32_t>(size);
852     int32_t clientUid = randIntValue;
853     int32_t createrUID = randIntValue;
854     int32_t clientPid = randIntValue;
855     uint32_t index = static_cast<uint32_t>(size);
856     bool mute = static_cast<bool>(index % NUM_2);
857     auto changeInfo = std::make_unique<AudioRendererChangeInfo>();
858     changeInfo->clientUID = clientUid;
859     changeInfo->createrUID = createrUID;
860     changeInfo->clientPid = clientPid;
861     changeInfo->rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
862     changeInfo->sessionId = randIntValue / NUM_2;
863     audioStreamCollector_.audioRendererChangeInfos_.clear();
864     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(changeInfo));
865     audioStreamCollector_.HandleStartStreamMuteState(clientUid, clientPid, mute, mute);
866 }
867 
AudioStreamCollectorIsStreamActiveFuzzTest(const uint8_t * rawData,size_t size)868 void AudioStreamCollectorIsStreamActiveFuzzTest(const uint8_t *rawData, size_t size)
869 {
870     uint32_t index = static_cast<uint32_t>(size);
871     AudioStreamType volumeType = g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()];
872     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
873     int32_t randIntValue = static_cast<int32_t>(size);
874     rendererChangeInfo->createrUID = randIntValue / NUM_2;
875     rendererChangeInfo->clientUID = randIntValue / NUM_2;
876     rendererChangeInfo->sessionId = randIntValue;
877     rendererChangeInfo->rendererState = g_testRendererState[index % g_testRendererState.size()];
878     audioStreamCollector_.audioRendererChangeInfos_.clear();
879     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
880     audioStreamCollector_.IsStreamActive(volumeType);
881 }
882 
AudioStreamCollectorGetRunningStreamFuzzTest(const uint8_t * rawData,size_t size)883 void AudioStreamCollectorGetRunningStreamFuzzTest(const uint8_t *rawData, size_t size)
884 {
885     uint32_t index = static_cast<uint32_t>(size);
886     AudioRendererInfo rendererInfo;
887     rendererInfo.contentType = g_testContentTypes[index % g_testContentTypes.size()];
888     rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
889     std::unique_ptr<AudioRendererChangeInfo> info = std::make_unique<AudioRendererChangeInfo>();
890     int32_t randIntValue = static_cast<int32_t>(size);
891     info->sessionId = randIntValue;
892     info->rendererState = g_testRendererState[index % g_testRendererState.size()];
893     info->rendererInfo = rendererInfo;
894     info->channelCount = randIntValue % NUM_2;
895 
896     audioStreamCollector_.audioRendererChangeInfos_.clear();
897     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(info));
898     audioStreamCollector_.GetRunningStream(g_testAudioStreamTypes[index % g_testAudioStreamTypes.size()], 0);
899 }
900 
AudioStreamCollectorGetStreamTypeFromSourceTypeFuzzTest(const uint8_t * rawData,size_t size)901 void AudioStreamCollectorGetStreamTypeFromSourceTypeFuzzTest(const uint8_t *rawData, size_t size)
902 {
903     uint32_t index = static_cast<uint32_t>(size);
904     audioStreamCollector_.GetStreamTypeFromSourceType(g_testSourceTypes[index % g_testSourceTypes.size()]);
905 }
906 
AudioStreamCollectorSetGetLowPowerVolumeFuzzTest(const uint8_t * rawData,size_t size)907 void AudioStreamCollectorSetGetLowPowerVolumeFuzzTest(const uint8_t *rawData, size_t size)
908 {
909     int32_t randIntValue = static_cast<int32_t>(size);
910     int32_t streamId = randIntValue / NUM_2;
911 
912     audioStreamCollector_.SetLowPowerVolume(streamId, static_cast<float>(size));
913     audioStreamCollector_.GetLowPowerVolume(streamId);
914 }
915 
AudioStreamCollectorSetOffloadModeFuzzTest(const uint8_t * rawData,size_t size)916 void AudioStreamCollectorSetOffloadModeFuzzTest(const uint8_t *rawData, size_t size)
917 {
918     int32_t randIntValue = static_cast<int32_t>(size);
919     int32_t streamId = randIntValue / NUM_2;
920     int32_t state = randIntValue / NUM_2 - 1;
921     bool isAppBack = static_cast<bool>(static_cast<uint32_t>(size) % NUM_2);
922 
923     audioStreamCollector_.SetOffloadMode(streamId, state, isAppBack);
924 }
925 
AudioStreamCollectorUnsetOffloadModeFuzzTest(const uint8_t * rawData,size_t size)926 void AudioStreamCollectorUnsetOffloadModeFuzzTest(const uint8_t *rawData, size_t size)
927 {
928     int32_t randIntValue = static_cast<int32_t>(size);
929     int32_t streamId = randIntValue % NUM_2;
930     AudioStreamChangeInfo streamChangeInfo;
931     streamChangeInfo.audioRendererChangeInfo.clientUID = randIntValue / NUM_2;
932     streamChangeInfo.audioRendererChangeInfo.sessionId = randIntValue;
933     uint32_t index = static_cast<uint32_t>(size);
934     streamChangeInfo.audioRendererChangeInfo.rendererState = g_testRendererState[index % g_testRendererState.size()];
935     sptr<IRemoteObject> object;
936     sptr<IStandardClientTracker> listener = iface_cast<IStandardClientTracker>(object);
937     std::shared_ptr<AudioClientTracker> callback = std::make_shared<ClientTrackerCallbackListener>(listener);
938     int32_t clientId = streamChangeInfo.audioRendererChangeInfo.sessionId;
939     audioStreamCollector_.clientTracker_[clientId] = callback;
940     audioStreamCollector_.UnsetOffloadMode(streamId);
941 }
942 
AudioStreamCollectorGetSingleStreamVolumeFuzzTest(const uint8_t * rawData,size_t size)943 void AudioStreamCollectorGetSingleStreamVolumeFuzzTest(const uint8_t *rawData, size_t size)
944 {
945     int32_t streamId = static_cast<int32_t>(size);
946     audioStreamCollector_.GetSingleStreamVolume(streamId);
947 }
948 
AudioStreamCollectorUpdateCapturerInfoMuteStatusFuzzTest(const uint8_t * rawData,size_t size)949 void AudioStreamCollectorUpdateCapturerInfoMuteStatusFuzzTest(const uint8_t *rawData, size_t size)
950 {
951     auto changeInfo = std::make_unique<AudioCapturerChangeInfo>();
952     int32_t randIntValue = static_cast<int32_t>(size);
953     uint32_t index = static_cast<uint32_t>(size);
954     changeInfo->clientUID = randIntValue;
955     changeInfo->muted = static_cast<bool>(index % NUM_2);
956     changeInfo->sessionId = randIntValue / NUM_2;
957     changeInfo->capturerInfo.sourceType = g_testSourceTypes[index % g_testSourceTypes.size()];
958     changeInfo->inputDeviceInfo.deviceType_ = g_testDeviceTypes[index % g_testDeviceTypes.size()];
959     audioStreamCollector_.audioCapturerChangeInfos_.clear();
960     audioStreamCollector_.audioCapturerChangeInfos_.push_back(std::move(changeInfo));
961     audioStreamCollector_.audioPolicyServerHandler_ = std::make_shared<AudioPolicyServerHandler>();
962     audioStreamCollector_.UpdateCapturerInfoMuteStatus(randIntValue, true);
963 }
964 
AudioStreamCollectorIsCallStreamUsageFuzzTest(const uint8_t * rawData,size_t size)965 void AudioStreamCollectorIsCallStreamUsageFuzzTest(const uint8_t *rawData, size_t size)
966 {
967     uint32_t index = static_cast<uint32_t>(size) % g_testStreamUsages.size();
968     StreamUsage usage = g_testStreamUsages[index];
969 
970     audioStreamCollector_.IsCallStreamUsage(usage);
971 }
972 
AudioStreamCollectorGetRunningStreamUsageNoUltrasonicFuzzTest(const uint8_t * rawData,size_t size)973 void AudioStreamCollectorGetRunningStreamUsageNoUltrasonicFuzzTest(const uint8_t *rawData, size_t size)
974 {
975     uint32_t index = static_cast<uint32_t>(size);
976 
977     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
978     int32_t randIntValue = static_cast<int32_t>(size);
979     rendererChangeInfo->createrUID = randIntValue / NUM_2;
980     rendererChangeInfo->clientUID = randIntValue / NUM_2;
981     rendererChangeInfo->sessionId = randIntValue;
982     rendererChangeInfo->rendererState = g_testRendererState[index % g_testRendererState.size()];
983     rendererChangeInfo->rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
984     audioStreamCollector_.audioRendererChangeInfos_.clear();
985     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
986 
987     audioStreamCollector_.GetRunningStreamUsageNoUltrasonic();
988 }
989 
AudioStreamCollectorGetRunningSourceTypeNoUltrasonicFuzzTest(const uint8_t * rawData,size_t size)990 void AudioStreamCollectorGetRunningSourceTypeNoUltrasonicFuzzTest(const uint8_t *rawData, size_t size)
991 {
992     const vector<CapturerState> testCapturerStates = {
993         CAPTURER_INVALID,
994         CAPTURER_NEW,
995         CAPTURER_PREPARED,
996         CAPTURER_RUNNING,
997         CAPTURER_STOPPED,
998         CAPTURER_RELEASED,
999         CAPTURER_PAUSED,
1000     };
1001     uint32_t index = static_cast<uint32_t>(size);
1002     int32_t randIntValue = static_cast<int32_t>(size);
1003 
1004     auto changeInfo = std::make_unique<AudioCapturerChangeInfo>();
1005     changeInfo->clientUID = randIntValue;
1006     changeInfo->sessionId = randIntValue / NUM_2;
1007     changeInfo->capturerState = testCapturerStates[index % testCapturerStates.size()];
1008     changeInfo->capturerInfo.sourceType = g_testSourceTypes[index % g_testSourceTypes.size()];
1009     audioStreamCollector_.audioCapturerChangeInfos_.clear();
1010     audioStreamCollector_.audioCapturerChangeInfos_.push_back(move(changeInfo));
1011 
1012     audioStreamCollector_.GetRunningSourceTypeNoUltrasonic();
1013 }
1014 
AudioStreamCollectorGetLastestRunningCallStreamUsageFuzzTest(const uint8_t * rawData,size_t size)1015 void AudioStreamCollectorGetLastestRunningCallStreamUsageFuzzTest(const uint8_t *rawData, size_t size)
1016 {
1017     uint32_t index = static_cast<uint32_t>(size);
1018 
1019     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1020     int32_t randIntValue = static_cast<int32_t>(size);
1021     rendererChangeInfo->createrUID = randIntValue / NUM_2;
1022     rendererChangeInfo->clientUID = randIntValue / NUM_2;
1023     rendererChangeInfo->sessionId = randIntValue;
1024     rendererChangeInfo->rendererState = g_testRendererState[index % g_testRendererState.size()];
1025     rendererChangeInfo->rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
1026     audioStreamCollector_.audioRendererChangeInfos_.clear();
1027     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1028 
1029     audioStreamCollector_.GetLastestRunningCallStreamUsage();
1030 }
1031 
AudioStreamCollectorGetAllRendererSessionIDForUIDFuzzTest(const uint8_t * rawData,size_t size)1032 void AudioStreamCollectorGetAllRendererSessionIDForUIDFuzzTest(const uint8_t *rawData, size_t size)
1033 {
1034     int32_t randIntValue = static_cast<int32_t>(size);
1035     int32_t uid = randIntValue / NUM_2;
1036     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1037 
1038     rendererChangeInfo->clientUID = randIntValue /NUM_2;
1039     rendererChangeInfo->createrUID = randIntValue /NUM_2;
1040     rendererChangeInfo->sessionId = randIntValue;
1041     audioStreamCollector_.audioRendererChangeInfos_.clear();
1042     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1043 
1044     audioStreamCollector_.GetAllRendererSessionIDForUID(uid);
1045 }
1046 
AudioStreamCollectorGetAllCapturerSessionIDForUIDFuzzTest(const uint8_t * rawData,size_t size)1047 void AudioStreamCollectorGetAllCapturerSessionIDForUIDFuzzTest(const uint8_t *rawData, size_t size)
1048 {
1049     int32_t randIntValue = static_cast<int32_t>(size);
1050     int32_t uid = randIntValue / NUM_2;
1051     shared_ptr<AudioCapturerChangeInfo> capturerChangeInfo = make_shared<AudioCapturerChangeInfo>();
1052 
1053     capturerChangeInfo->clientUID = randIntValue /NUM_2;
1054     capturerChangeInfo->createrUID = randIntValue /NUM_2;
1055     capturerChangeInfo->sessionId = randIntValue;
1056     audioStreamCollector_.audioCapturerChangeInfos_.clear();
1057     audioStreamCollector_.audioCapturerChangeInfos_.push_back(move(capturerChangeInfo));
1058 
1059     audioStreamCollector_.GetAllCapturerSessionIDForUID(uid);
1060 }
1061 
AudioStreamCollectorChangeVoipCapturerStreamToNormalFuzzTest(const uint8_t * rawData,size_t size)1062 void AudioStreamCollectorChangeVoipCapturerStreamToNormalFuzzTest(const uint8_t *rawData, size_t size)
1063 {
1064     shared_ptr<AudioCapturerChangeInfo> rendererChangeInfo = make_shared<AudioCapturerChangeInfo>();
1065     int32_t randIntValue = static_cast<int32_t>(size);
1066     uint32_t index = static_cast<uint32_t>(size);
1067     rendererChangeInfo->clientUID = randIntValue / NUM_2;
1068     rendererChangeInfo->createrUID = randIntValue / NUM_2;
1069     rendererChangeInfo->sessionId = randIntValue;
1070     rendererChangeInfo->capturerInfo.sourceType = g_testSourceTypes[index % g_testSourceTypes.size()];
1071     audioStreamCollector_.audioCapturerChangeInfos_.clear();
1072     audioStreamCollector_.audioCapturerChangeInfos_.push_back(move(rendererChangeInfo));
1073 
1074     audioStreamCollector_.ChangeVoipCapturerStreamToNormal();
1075 }
1076 
AudioStreamCollectorHasVoipRendererStreamFuzzTest(const uint8_t * rawData,size_t size)1077 void AudioStreamCollectorHasVoipRendererStreamFuzzTest(const uint8_t *rawData, size_t size)
1078 {
1079     int32_t randIntValue = static_cast<int32_t>(size);
1080     int32_t uid = randIntValue / NUM_2;
1081     shared_ptr<AudioRendererChangeInfo> rendererChangeInfo = make_shared<AudioRendererChangeInfo>();
1082 
1083     rendererChangeInfo->clientUID = randIntValue / NUM_2;
1084     rendererChangeInfo->createrUID = randIntValue / NUM_2;
1085     rendererChangeInfo->sessionId = randIntValue;
1086     rendererChangeInfo->rendererInfo.originalFlag = randIntValue % NUM_2;
1087     audioStreamCollector_.audioRendererChangeInfos_.clear();
1088     audioStreamCollector_.audioRendererChangeInfos_.push_back(move(rendererChangeInfo));
1089 
1090     audioStreamCollector_.HasVoipRendererStream();
1091 }
1092 
AudioStreamCollectorIsMediaPlayingFuzzTest(const uint8_t * rawData,size_t size)1093 void AudioStreamCollectorIsMediaPlayingFuzzTest(const uint8_t *rawData, size_t size)
1094 {
1095     uint32_t index = static_cast<uint32_t>(size);
1096     AudioRendererInfo rendererInfo;
1097     rendererInfo.contentType = g_testContentTypes[index % g_testContentTypes.size()];
1098     rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
1099     std::unique_ptr<AudioRendererChangeInfo> info = std::make_unique<AudioRendererChangeInfo>();
1100     int32_t randIntValue = static_cast<int32_t>(size);
1101     info->sessionId = randIntValue % NUM_2;
1102     info->rendererState = g_testRendererState[index % g_testRendererState.size()];
1103     info->rendererInfo = rendererInfo;
1104     info->channelCount = randIntValue % NUM_2;
1105     audioStreamCollector_.audioRendererChangeInfos_.clear();
1106     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(info));
1107     audioStreamCollector_.IsMediaPlaying();
1108 }
1109 
AudioStreamCollectorIsVoipStreamActiveFuzzTest(const uint8_t * rawData,size_t size)1110 void AudioStreamCollectorIsVoipStreamActiveFuzzTest(const uint8_t *rawData, size_t size)
1111 {
1112     uint32_t index = static_cast<uint32_t>(size);
1113     AudioRendererInfo rendererInfo;
1114     rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
1115     std::unique_ptr<AudioRendererChangeInfo> info = std::make_unique<AudioRendererChangeInfo>();
1116     int32_t randIntValue = static_cast<int32_t>(size);
1117     info->sessionId = randIntValue % NUM_2;
1118     info->rendererState = g_testRendererState[index % g_testRendererState.size()];
1119     info->rendererInfo = rendererInfo;
1120     info->channelCount = randIntValue % NUM_2;
1121     audioStreamCollector_.audioRendererChangeInfos_.clear();
1122     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(info));
1123     audioStreamCollector_.IsVoipStreamActive();
1124 }
1125 
AudioStreamCollectorCheckVoiceCallActiveFuzzTest(const uint8_t * rawData,size_t size)1126 void AudioStreamCollectorCheckVoiceCallActiveFuzzTest(const uint8_t *rawData, size_t size)
1127 {
1128     int32_t randIntValue = static_cast<int32_t>(size);
1129     int32_t clientPid = randIntValue / NUM_2;
1130     uint32_t index = static_cast<uint32_t>(size);
1131     auto changeInfo = std::make_unique<AudioRendererChangeInfo>();
1132     changeInfo->clientPid = clientPid;
1133     changeInfo->rendererInfo.streamUsage = g_testStreamUsages[index % g_testStreamUsages.size()];
1134     changeInfo->sessionId = randIntValue / NUM_2;
1135     audioStreamCollector_.audioRendererChangeInfos_.clear();
1136     audioStreamCollector_.audioRendererChangeInfos_.push_back(std::move(changeInfo));
1137     audioStreamCollector_.CheckVoiceCallActive(clientPid);
1138 }
1139 
1140 } // namespace AudioStandard
1141 } // namesapce OHOS
1142 
1143 OHOS::AudioStandard::TestPtr g_testPtrs[] = {
1144     OHOS::AudioStandard::AudioStreamCollectorAddRendererStreamFuzzTest,
1145     OHOS::AudioStandard::AudioStreamCollectorGetRendererStreamInfoFuzzTest,
1146     OHOS::AudioStandard::AudioStreamCollectorGetCapturerStreamInfoFuzzTest,
1147     OHOS::AudioStandard::AudioStreamCollectorGetPipeTypeFuzzTest,
1148     OHOS::AudioStandard::AudioStreamCollectorExistStreamForPipeFuzzTest,
1149     OHOS::AudioStandard::AudioStreamCollectorGetRendererDeviceInfoFuzzTest,
1150     OHOS::AudioStandard::AudioStreamCollectorAddCapturerStreamFuzzTest,
1151     OHOS::AudioStandard::AudioStreamCollectorSendCapturerInfoEventFuzzTest,
1152     OHOS::AudioStandard::AudioStreamCollectorRegisterTrackerFuzzTest,
1153     OHOS::AudioStandard::AudioStreamCollectorSetRendererStreamParamFuzzTest,
1154     OHOS::AudioStandard::AudioStreamCollectorSetCapturerStreamParamFuzzTest,
1155     OHOS::AudioStandard::AudioStreamCollectorResetRendererStreamDeviceInfoFuzzTest,
1156     OHOS::AudioStandard::AudioStreamCollectorResetCapturerStreamDeviceInfoFuzzTest,
1157     OHOS::AudioStandard::AudioStreamCollectorCheckRendererStateInfoChangedFuzzTest,
1158     OHOS::AudioStandard::AudioStreamCollectorCheckRendererInfoChangedFuzzTest,
1159     OHOS::AudioStandard::AudioStreamCollectorResetRingerModeMuteFuzzTest,
1160     OHOS::AudioStandard::AudioStreamCollectorUpdateRendererStreamInternalFuzzTest,
1161     OHOS::AudioStandard::AudioStreamCollectorUpdateCapturerStreamInternalFuzzTest,
1162     OHOS::AudioStandard::AudioStreamCollectorUpdateTrackerFuzzTest,
1163     OHOS::AudioStandard::AudioStreamCollectorUpdateRendererDeviceInfoFuzzTest,
1164     OHOS::AudioStandard::AudioStreamCollectorUpdateCapturerDeviceInfoFuzzTest,
1165     OHOS::AudioStandard::AudioStreamCollectorUpdateRendererPipeInfoFuzzTest,
1166     OHOS::AudioStandard::AudioStreamCollectorUpdateAppVolumeFuzzTest,
1167     OHOS::AudioStandard::AudioStreamCollectorGetStreamTypeFuzzTest,
1168     OHOS::AudioStandard::AudioStreamCollectorGetSessionIdsOnRemoteDeviceByStreamUsageFuzzTest,
1169     OHOS::AudioStandard::AudioStreamCollectorIsOffloadAllowedFuzzTest,
1170     OHOS::AudioStandard::AudioStreamCollectorGetChannelCountFuzzTest,
1171     OHOS::AudioStandard::AudioStreamCollectorGetCurrentRendererChangeInfosFuzzTest,
1172     OHOS::AudioStandard::AudioStreamCollectorGetCurrentCapturerChangeInfosFuzzTest,
1173     OHOS::AudioStandard::AudioStreamCollectorRegisteredTrackerClientDiedFuzzTest,
1174     OHOS::AudioStandard::AudioStreamCollectorGetAndCompareStreamTypeFuzzTest,
1175     OHOS::AudioStandard::AudioStreamCollectorGetUidFuzzTest,
1176     OHOS::AudioStandard::AudioStreamCollectorResumeStreamStateFuzzTest,
1177     OHOS::AudioStandard::AudioStreamCollectorUpdateStreamStateFuzzTest,
1178     OHOS::AudioStandard::AudioStreamCollectorHandleAppStateChangeFuzzTest,
1179     OHOS::AudioStandard::AudioStreamCollectorHandleFreezeStateChangeFuzzTest,
1180     OHOS::AudioStandard::AudioStreamCollectorHandleBackTaskStateChangeFuzzTest,
1181     OHOS::AudioStandard::AudioStreamCollectorHandleStartStreamMuteStateFuzzTest,
1182     OHOS::AudioStandard::AudioStreamCollectorIsStreamActiveFuzzTest,
1183     OHOS::AudioStandard::AudioStreamCollectorGetRunningStreamFuzzTest,
1184     OHOS::AudioStandard::AudioStreamCollectorGetStreamTypeFromSourceTypeFuzzTest,
1185     OHOS::AudioStandard::AudioStreamCollectorSetGetLowPowerVolumeFuzzTest,
1186     OHOS::AudioStandard::AudioStreamCollectorSetOffloadModeFuzzTest,
1187     OHOS::AudioStandard::AudioStreamCollectorUnsetOffloadModeFuzzTest,
1188     OHOS::AudioStandard::AudioStreamCollectorGetSingleStreamVolumeFuzzTest,
1189     OHOS::AudioStandard::AudioStreamCollectorUpdateCapturerInfoMuteStatusFuzzTest,
1190     OHOS::AudioStandard::AudioStreamCollectorIsCallStreamUsageFuzzTest,
1191     OHOS::AudioStandard::AudioStreamCollectorGetRunningStreamUsageNoUltrasonicFuzzTest,
1192     OHOS::AudioStandard::AudioStreamCollectorGetRunningSourceTypeNoUltrasonicFuzzTest,
1193     OHOS::AudioStandard::AudioStreamCollectorGetLastestRunningCallStreamUsageFuzzTest,
1194     OHOS::AudioStandard::AudioStreamCollectorGetAllRendererSessionIDForUIDFuzzTest,
1195     OHOS::AudioStandard::AudioStreamCollectorGetAllCapturerSessionIDForUIDFuzzTest,
1196     OHOS::AudioStandard::AudioStreamCollectorChangeVoipCapturerStreamToNormalFuzzTest,
1197     OHOS::AudioStandard::AudioStreamCollectorHasVoipRendererStreamFuzzTest,
1198     OHOS::AudioStandard::AudioStreamCollectorIsMediaPlayingFuzzTest,
1199     OHOS::AudioStandard::AudioStreamCollectorIsVoipStreamActiveFuzzTest,
1200     OHOS::AudioStandard::AudioStreamCollectorCheckVoiceCallActiveFuzzTest,
1201 };
1202 
1203 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)1204 extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
1205 {
1206     /* Run your code on data */
1207     if (data == nullptr || size <= 1) {
1208         return 0;
1209     }
1210     uint32_t len = OHOS::AudioStandard::GetArrLength(g_testPtrs);
1211     if (len > 0) {
1212         uint8_t firstByte = *data % len;
1213         if (firstByte >= len) {
1214             return 0;
1215         }
1216         data = data + 1;
1217         size = size - 1;
1218         g_testPtrs[firstByte](data, size);
1219     }
1220     return 0;
1221 }