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 <securec.h>
17 #include "audio_log.h"
18 #include "audio_policy_client_proxy.h"
19 #include "audio_stream_manager.h"
20 #include "audio_client_tracker_callback_service.h"
21 #include "audio_client_tracker_callback_listener.h"
22
23 using namespace std;
24
25 namespace OHOS {
26 namespace AudioStandard {
27
28 static const uint8_t* RAW_DATA = nullptr;
29 static size_t g_dataSize = 0;
30 static size_t g_pos;
31 const size_t THRESHOLD = 10;
32 typedef void (*TestPtr)();
33
34 class RemoteObjectFuzzTestStub : public IRemoteObject {
35 public:
RemoteObjectFuzzTestStub()36 RemoteObjectFuzzTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()37 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)38 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)39 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)40 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)41 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
42
43 DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectFuzzTestStub");
44 };
45
46 class AudioClientTrackerFuzzTest : public AudioClientTracker {
47 public:
48 virtual ~AudioClientTrackerFuzzTest() = default;
MuteStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)49 virtual void MuteStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) {};
UnmuteStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)50 virtual void UnmuteStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) {};
PausedStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)51 virtual void PausedStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) {};
ResumeStreamImpl(const StreamSetStateEventInternal & streamSetStateEventInternal)52 virtual void ResumeStreamImpl(const StreamSetStateEventInternal &streamSetStateEventInternal) {};
SetLowPowerVolumeImpl(float volume)53 virtual void SetLowPowerVolumeImpl(float volume) {};
GetLowPowerVolumeImpl(float & volume)54 virtual void GetLowPowerVolumeImpl(float &volume) {};
GetSingleStreamVolumeImpl(float & volume)55 virtual void GetSingleStreamVolumeImpl(float &volume) {};
SetOffloadModeImpl(int32_t state,bool isAppBack)56 virtual void SetOffloadModeImpl(int32_t state, bool isAppBack) {};
UnsetOffloadModeImpl()57 virtual void UnsetOffloadModeImpl() {};
58 };
59
60 const vector<AudioStreamType> g_testAudioStreamTypes = {
61 STREAM_DEFAULT,
62 STREAM_VOICE_CALL,
63 STREAM_MUSIC,
64 STREAM_RING,
65 STREAM_MEDIA,
66 STREAM_VOICE_ASSISTANT,
67 STREAM_SYSTEM,
68 STREAM_ALARM,
69 STREAM_NOTIFICATION,
70 STREAM_BLUETOOTH_SCO,
71 STREAM_ENFORCED_AUDIBLE,
72 STREAM_DTMF,
73 STREAM_TTS,
74 STREAM_ACCESSIBILITY,
75 STREAM_RECORDING,
76 STREAM_MOVIE,
77 STREAM_GAME,
78 STREAM_SPEECH,
79 STREAM_SYSTEM_ENFORCED,
80 STREAM_ULTRASONIC,
81 STREAM_WAKEUP,
82 STREAM_VOICE_MESSAGE,
83 STREAM_NAVIGATION,
84 STREAM_INTERNAL_FORCE_STOP,
85 STREAM_SOURCE_VOICE_CALL,
86 STREAM_VOICE_COMMUNICATION,
87 STREAM_VOICE_RING,
88 STREAM_VOICE_CALL_ASSISTANT,
89 STREAM_CAMCORDER,
90 STREAM_APP,
91 STREAM_TYPE_MAX,
92 STREAM_ALL,
93 };
94
95 const vector<DeviceFlag> g_testDeviceFlags = {
96 NONE_DEVICES_FLAG,
97 OUTPUT_DEVICES_FLAG,
98 INPUT_DEVICES_FLAG,
99 ALL_DEVICES_FLAG,
100 DISTRIBUTED_OUTPUT_DEVICES_FLAG,
101 DISTRIBUTED_INPUT_DEVICES_FLAG,
102 ALL_DISTRIBUTED_DEVICES_FLAG,
103 ALL_L_D_DEVICES_FLAG,
104 DEVICE_FLAG_MAX
105 };
106
107 const vector<AudioStreamDeviceChangeReason> g_testReasons = {
108 AudioStreamDeviceChangeReason::UNKNOWN,
109 AudioStreamDeviceChangeReason::NEW_DEVICE_AVAILABLE,
110 AudioStreamDeviceChangeReason::OLD_DEVICE_UNAVALIABLE,
111 AudioStreamDeviceChangeReason::OVERRODE,
112 };
113
114 const vector<StreamSetState> g_testStreamSetStates = {
115 STREAM_PAUSE,
116 STREAM_RESUME,
117 STREAM_MUTE,
118 STREAM_UNMUTE,
119 };
120
121 const vector<StreamUsage> g_testAudioStreamUsages = {
122 STREAM_USAGE_INVALID,
123 STREAM_USAGE_UNKNOWN,
124 STREAM_USAGE_MEDIA,
125 STREAM_USAGE_MUSIC,
126 STREAM_USAGE_VOICE_COMMUNICATION,
127 STREAM_USAGE_VOICE_ASSISTANT,
128 STREAM_USAGE_ALARM,
129 STREAM_USAGE_VOICE_MESSAGE,
130 STREAM_USAGE_NOTIFICATION_RINGTONE,
131 STREAM_USAGE_RINGTONE,
132 STREAM_USAGE_NOTIFICATION,
133 STREAM_USAGE_ACCESSIBILITY,
134 STREAM_USAGE_SYSTEM,
135 STREAM_USAGE_MOVIE,
136 STREAM_USAGE_GAME,
137 STREAM_USAGE_AUDIOBOOK,
138 STREAM_USAGE_NAVIGATION,
139 STREAM_USAGE_DTMF,
140 STREAM_USAGE_ENFORCED_TONE,
141 STREAM_USAGE_ULTRASONIC,
142 STREAM_USAGE_VIDEO_COMMUNICATION,
143 STREAM_USAGE_RANGING,
144 STREAM_USAGE_VOICE_MODEM_COMMUNICATION,
145 STREAM_USAGE_VOICE_RINGTONE,
146 STREAM_USAGE_VOICE_CALL_ASSISTANT,
147 STREAM_USAGE_MAX,
148 };
149
150 template<class T>
GetArrLength(T & arr)151 uint32_t GetArrLength(T& arr)
152 {
153 if (arr == nullptr) {
154 AUDIO_INFO_LOG("%{public}s: The array length is equal to 0", __func__);
155 return 0;
156 }
157 return sizeof(arr) / sizeof(arr[0]);
158 }
159
160 template<class T>
GetData()161 T GetData()
162 {
163 T object {};
164 size_t objectSize = sizeof(object);
165 if (RAW_DATA == nullptr || objectSize > g_dataSize - g_pos) {
166 return object;
167 }
168 errno_t ret = memcpy_s(&object, objectSize, RAW_DATA + g_pos, objectSize);
169 if (ret != EOK) {
170 return {};
171 }
172 g_pos += objectSize;
173 return object;
174 }
175
AudioPolicyClientProxyOnVolumeKeyEventFuzzTest()176 void AudioPolicyClientProxyOnVolumeKeyEventFuzzTest()
177 {
178 VolumeEvent volumeEvent;
179 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
180 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
181 audioPolicyClientProxy->OnVolumeKeyEvent(volumeEvent);
182 }
183
AudioPolicyClientProxyOnAudioFocusInfoChangeFuzzTest()184 void AudioPolicyClientProxyOnAudioFocusInfoChangeFuzzTest()
185 {
186 AudioInterrupt audioInterrupt;
187 AudioFocuState audioFocuState = AudioFocuState::ACTIVE;
188 std::vector<std::map<AudioInterrupt, int32_t>> focusInfoList;
189 std::map<AudioInterrupt, int32_t> interruptMap;
190 interruptMap[audioInterrupt] = audioFocuState;
191 focusInfoList.emplace_back(interruptMap);
192
193 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
194 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
195 if (audioPolicyClientProxy == nullptr) {
196 return;
197 }
198 audioPolicyClientProxy->OnAudioFocusInfoChange(focusInfoList);
199 }
200
AudioPolicyClientProxyOnAudioFocusRequestedFuzzTest()201 void AudioPolicyClientProxyOnAudioFocusRequestedFuzzTest()
202 {
203 AudioInterrupt requestFocus;
204 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
205 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
206 if (audioPolicyClientProxy == nullptr) {
207 return;
208 }
209 audioPolicyClientProxy->OnAudioFocusRequested(requestFocus);
210 }
211
AudioPolicyClientProxyOnAudioFocusAbandonedFuzzTest()212 void AudioPolicyClientProxyOnAudioFocusAbandonedFuzzTest()
213 {
214 AudioInterrupt requestFocus;
215 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
216 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
217 if (audioPolicyClientProxy == nullptr) {
218 return;
219 }
220 audioPolicyClientProxy->OnAudioFocusAbandoned(requestFocus);
221 }
222
AudioPolicyClientProxyOnActiveVolumeTypeChangedFuzzTest()223 void AudioPolicyClientProxyOnActiveVolumeTypeChangedFuzzTest()
224 {
225 AudioVolumeType volumeType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
226 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
227 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
228 if (audioPolicyClientProxy == nullptr) {
229 return;
230 }
231 audioPolicyClientProxy->OnActiveVolumeTypeChanged(volumeType);
232 }
233
AudioPolicyClientProxyOnAppVolumeChangedFuzzTest()234 void AudioPolicyClientProxyOnAppVolumeChangedFuzzTest()
235 {
236 AudioVolumeType volType = g_testAudioStreamTypes[GetData<uint32_t>() % g_testAudioStreamTypes.size()];
237 int32_t volLevel = GetData<int32_t>();
238 bool isUiUpdated = GetData<bool>();
239 VolumeEvent volumeEvent(volType, volLevel, isUiUpdated);
240 int32_t appUid = GetData<int32_t>();
241 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
242 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
243 if (audioPolicyClientProxy == nullptr) {
244 return;
245 }
246 audioPolicyClientProxy->OnAppVolumeChanged(appUid, volumeEvent);
247 }
248
AudioPolicyClientProxyOnDeviceChangeFuzzTest()249 void AudioPolicyClientProxyOnDeviceChangeFuzzTest()
250 {
251 static const vector<DeviceChangeType> testDeviceChangeTypes = {
252 CONNECT,
253 DISCONNECT,
254 };
255 DeviceChangeAction deviceChangeAction;
256 deviceChangeAction.type = testDeviceChangeTypes[GetData<uint32_t>() % testDeviceChangeTypes.size()];
257 deviceChangeAction.flag = g_testDeviceFlags[GetData<uint32_t>() % g_testDeviceFlags.size()];
258 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
259 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
260 if (audioPolicyClientProxy == nullptr) {
261 return;
262 }
263 audioPolicyClientProxy->OnDeviceChange(deviceChangeAction);
264 }
265
AudioPolicyClientProxyOnMicrophoneBlockedFuzzTest()266 void AudioPolicyClientProxyOnMicrophoneBlockedFuzzTest()
267 {
268 static const vector<DeviceBlockStatus> testDeviceBlockStatuses = {
269 DEVICE_UNBLOCKED,
270 DEVICE_BLOCKED,
271 };
272 MicrophoneBlockedInfo microphoneBlockedInfo;
273 microphoneBlockedInfo.blockStatus = testDeviceBlockStatuses[GetData<uint32_t>() % testDeviceBlockStatuses.size()];
274 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
275 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
276 if (audioPolicyClientProxy == nullptr) {
277 return;
278 }
279 audioPolicyClientProxy->OnMicrophoneBlocked(microphoneBlockedInfo);
280 }
281
AudioPolicyClientProxyOnRingerModeUpdatedFuzzTest()282 void AudioPolicyClientProxyOnRingerModeUpdatedFuzzTest()
283 {
284 static const vector<AudioRingerMode> testRingerModes = {
285 RINGER_MODE_SILENT,
286 RINGER_MODE_VIBRATE,
287 RINGER_MODE_NORMAL,
288 };
289 AudioRingerMode ringerMode = testRingerModes[GetData<uint32_t>() % testRingerModes.size()];
290 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
291 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
292 if (audioPolicyClientProxy == nullptr) {
293 return;
294 }
295 audioPolicyClientProxy->OnRingerModeUpdated(ringerMode);
296 }
297
AudioPolicyClientProxyOnMicStateUpdatedFuzzTest()298 void AudioPolicyClientProxyOnMicStateUpdatedFuzzTest()
299 {
300 MicStateChangeEvent micStateChangeEvent;
301 micStateChangeEvent.mute = GetData<bool>();
302 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
303 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
304 if (audioPolicyClientProxy == nullptr) {
305 return;
306 }
307 audioPolicyClientProxy->OnMicStateUpdated(micStateChangeEvent);
308 }
309
AudioPolicyClientProxyOnPreferredOutputDeviceUpdatedFuzzTest()310 void AudioPolicyClientProxyOnPreferredOutputDeviceUpdatedFuzzTest()
311 {
312 AudioRendererInfo rendererInfo;
313 const std::vector<std::shared_ptr<AudioDeviceDescriptor>> desc;
314 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
315 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
316 if (audioPolicyClientProxy == nullptr) {
317 return;
318 }
319 audioPolicyClientProxy->OnPreferredOutputDeviceUpdated(rendererInfo, desc);
320 }
321
AudioPolicyClientProxyOnPreferredInputDeviceUpdatedFuzzTest()322 void AudioPolicyClientProxyOnPreferredInputDeviceUpdatedFuzzTest()
323 {
324 AudioCapturerInfo capturerInfo;
325 const std::vector<std::shared_ptr<AudioDeviceDescriptor>> desc;
326 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
327 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
328 if (audioPolicyClientProxy == nullptr) {
329 return;
330 }
331 audioPolicyClientProxy->OnPreferredInputDeviceUpdated(capturerInfo, desc);
332 }
333
AudioPolicyClientProxyOnRendererStateChangeFuzzTest()334 void AudioPolicyClientProxyOnRendererStateChangeFuzzTest()
335 {
336 std::vector<std::shared_ptr<AudioRendererChangeInfo>> audioRendererChangeInfos;
337 bool changeInfoNull = GetData<bool>();
338 std::shared_ptr<AudioRendererChangeInfo> changeInfo = std::make_shared<AudioRendererChangeInfo>();
339 if (changeInfoNull) {
340 changeInfo = nullptr;
341 }
342 audioRendererChangeInfos.push_back(changeInfo);
343 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
344 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
345 if (audioPolicyClientProxy == nullptr) {
346 return;
347 }
348 audioPolicyClientProxy->OnRendererStateChange(audioRendererChangeInfos);
349 }
350
AudioPolicyClientProxyOnCapturerStateChangeFuzzTest()351 void AudioPolicyClientProxyOnCapturerStateChangeFuzzTest()
352 {
353 std::vector<std::shared_ptr<AudioCapturerChangeInfo>> audioCapturerChangeInfos;
354 bool changeInfoNull = GetData<bool>();
355 std::shared_ptr<AudioCapturerChangeInfo> changeInfo = std::make_shared<AudioCapturerChangeInfo>();
356 if (changeInfoNull) {
357 changeInfo = nullptr;
358 }
359 audioCapturerChangeInfos.push_back(changeInfo);
360 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
361 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
362 if (audioPolicyClientProxy == nullptr) {
363 return;
364 }
365 audioPolicyClientProxy->OnCapturerStateChange(audioCapturerChangeInfos);
366 }
367
AudioPolicyClientProxyOnRendererDeviceChangeFuzzTest()368 void AudioPolicyClientProxyOnRendererDeviceChangeFuzzTest()
369 {
370 uint32_t sessionId = GetData<uint32_t>();
371 AudioStreamDeviceChangeReasonExt reason = g_testReasons[GetData<uint32_t>() % g_testReasons.size()];
372 AudioDeviceDescriptor deviceInfo;
373 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
374 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
375 if (audioPolicyClientProxy == nullptr) {
376 return;
377 }
378 audioPolicyClientProxy->OnRendererDeviceChange(sessionId, deviceInfo, reason);
379 }
380
AudioPolicyClientProxyOnRecreateRendererStreamEventFuzzTest()381 void AudioPolicyClientProxyOnRecreateRendererStreamEventFuzzTest()
382 {
383 uint32_t sessionId = GetData<uint32_t>();
384 int32_t streamFlag = GetData<int32_t>();
385 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
386 AudioStreamDeviceChangeReasonExt reason = g_testReasons[GetData<uint32_t>() % g_testReasons.size()];
387 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
388 if (audioPolicyClientProxy == nullptr) {
389 return;
390 }
391 audioPolicyClientProxy->OnRecreateRendererStreamEvent(sessionId, streamFlag, reason);
392 }
393
AudioPolicyClientProxyOnRecreateCapturerStreamEventFuzzTest()394 void AudioPolicyClientProxyOnRecreateCapturerStreamEventFuzzTest()
395 {
396 uint32_t sessionId = GetData<uint32_t>();
397 int32_t streamFlag = GetData<int32_t>();
398 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
399 AudioStreamDeviceChangeReasonExt reason = g_testReasons[GetData<uint32_t>() % g_testReasons.size()];
400 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
401 if (audioPolicyClientProxy == nullptr) {
402 return;
403 }
404 audioPolicyClientProxy->OnRecreateCapturerStreamEvent(sessionId, streamFlag, reason);
405 }
406
AudioPolicyClientProxyOnHeadTrackingDeviceChangeFuzzTest()407 void AudioPolicyClientProxyOnHeadTrackingDeviceChangeFuzzTest()
408 {
409 std::unordered_map<std::string, bool> changeInfo;
410 bool changeInfoBool = GetData<bool>();
411 changeInfo.insert(std::make_pair("testKey", changeInfoBool));
412 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
413 auto audioPolicyClientProxy = std::make_shared<AudioPolicyClientProxy>(impl);
414 if (audioPolicyClientProxy == nullptr) {
415 return;
416 }
417 audioPolicyClientProxy->OnHeadTrackingDeviceChange(changeInfo);
418 }
419
AudioPolicyClientProxyOnSpatializationEnabledChangeFuzzTest()420 void AudioPolicyClientProxyOnSpatializationEnabledChangeFuzzTest()
421 {
422 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
423 std::shared_ptr<IAudioPolicyClient> iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
424 if (iAudioPolicyClient == nullptr) {
425 return;
426 }
427 bool enabled = GetData<bool>();
428 iAudioPolicyClient->OnSpatializationEnabledChange(enabled);
429 }
430
AudioPolicyClientProxyOnSpatializationEnabledChangeForAnyDeviceFuzzTest()431 void AudioPolicyClientProxyOnSpatializationEnabledChangeForAnyDeviceFuzzTest()
432 {
433 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
434 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
435 std::shared_ptr<IAudioPolicyClient> iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
436 if (iAudioPolicyClient == nullptr) {
437 return;
438 }
439 bool enabled = GetData<bool>();
440 iAudioPolicyClient->OnSpatializationEnabledChangeForAnyDevice(deviceDescriptor, enabled);
441 }
442
AudioPolicyClientProxyOnSpatializationEnabledChangeForCurrentDeviceFuzzTest()443 void AudioPolicyClientProxyOnSpatializationEnabledChangeForCurrentDeviceFuzzTest()
444 {
445 bool enabled = GetData<bool>();
446 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
447 std::shared_ptr<IAudioPolicyClient> iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
448 if (iAudioPolicyClient == nullptr) {
449 return;
450 }
451 iAudioPolicyClient->OnSpatializationEnabledChangeForCurrentDevice(enabled);
452 }
453
AudioPolicyClientProxyOnHeadTrackingEnabledChangeFuzzTest()454 void AudioPolicyClientProxyOnHeadTrackingEnabledChangeFuzzTest()
455 {
456 bool enabled = GetData<bool>();
457 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
458 std::shared_ptr<IAudioPolicyClient> iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
459 if (iAudioPolicyClient == nullptr) {
460 return;
461 }
462 iAudioPolicyClient->OnHeadTrackingEnabledChange(enabled);
463 }
464
AudioPolicyClientProxyOnAudioSceneChangeFuzzTest()465 void AudioPolicyClientProxyOnAudioSceneChangeFuzzTest()
466 {
467 static const vector<AudioScene> testAudioScenes = {
468 AUDIO_SCENE_INVALID,
469 AUDIO_SCENE_DEFAULT,
470 AUDIO_SCENE_RINGING,
471 AUDIO_SCENE_PHONE_CALL,
472 AUDIO_SCENE_PHONE_CHAT,
473 AUDIO_SCENE_CALL_START,
474 AUDIO_SCENE_CALL_END,
475 AUDIO_SCENE_VOICE_RINGING,
476 AUDIO_SCENE_MAX,
477 };
478 if (testAudioScenes.size() == 0) {
479 return;
480 }
481 AudioScene audioScene = testAudioScenes[GetData<uint32_t>() % testAudioScenes.size()];
482 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
483 auto iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
484 if (iAudioPolicyClient == nullptr) {
485 return;
486 }
487 iAudioPolicyClient->OnAudioSceneChange(audioScene);
488 }
489
AudioPolicyClientProxyOnHeadTrackingEnabledChangeForAnyDeviceFuzzTest()490 void AudioPolicyClientProxyOnHeadTrackingEnabledChangeForAnyDeviceFuzzTest()
491 {
492 bool enabled = GetData<bool>();
493 std::shared_ptr<AudioDeviceDescriptor> deviceDescriptor = std::make_shared<AudioDeviceDescriptor>();
494 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
495 std::shared_ptr<IAudioPolicyClient> iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
496 if (iAudioPolicyClient == nullptr) {
497 return;
498 }
499 iAudioPolicyClient->OnHeadTrackingEnabledChangeForAnyDevice(deviceDescriptor, enabled);
500 }
501
AudioPolicyClientProxyOnNnStateChangeFuzzTest()502 void AudioPolicyClientProxyOnNnStateChangeFuzzTest()
503 {
504 int32_t state = GetData<int32_t>();
505 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
506 auto iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
507 if (iAudioPolicyClient == nullptr) {
508 return;
509 }
510 iAudioPolicyClient->OnNnStateChange(state);
511 }
512
AudioPolicyClientProxyOnAudioSessionDeactiveFuzzTest()513 void AudioPolicyClientProxyOnAudioSessionDeactiveFuzzTest()
514 {
515 static const vector<AudioSessionDeactiveReason> testDeactiveReasons = {
516 AudioSessionDeactiveReason::LOW_PRIORITY,
517 AudioSessionDeactiveReason::TIMEOUT,
518 };
519 AudioSessionDeactiveEvent deactiveEvent;
520 if (testDeactiveReasons.size() == 0) {
521 return;
522 }
523 deactiveEvent.deactiveReason = testDeactiveReasons[GetData<uint32_t>() % testDeactiveReasons.size()];
524 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
525 auto iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
526 if (iAudioPolicyClient == nullptr) {
527 return;
528 }
529 iAudioPolicyClient->OnAudioSessionDeactive(static_cast<int32_t>(deactiveEvent.deactiveReason));
530 }
531
AudioPolicyClientProxyOnFormatUnsupportedErrorFuzzTest()532 void AudioPolicyClientProxyOnFormatUnsupportedErrorFuzzTest()
533 {
534 static const vector<AudioErrors> errorCodes = {
535 ERROR_INVALID_PARAM,
536 ERROR_NO_MEMORY,
537 ERROR_ILLEGAL_STATE,
538 ERROR_UNSUPPORTED,
539 ERROR_TIMEOUT,
540 ERROR_UNSUPPORTED_FORMAT,
541 ERROR_STREAM_LIMIT,
542 ERROR_SYSTEM,
543 };
544 if (errorCodes.size() == 0) {
545 return;
546 }
547 AudioErrors errorCode = errorCodes[GetData<uint32_t>() % errorCodes.size()];
548 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
549 auto iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
550 if (iAudioPolicyClient == nullptr) {
551 return;
552 }
553 iAudioPolicyClient->OnFormatUnsupportedError(errorCode);
554 }
555
AudioPolicyClientProxyOnStreamVolumeChangeFuzzTest()556 void AudioPolicyClientProxyOnStreamVolumeChangeFuzzTest()
557 {
558 StreamVolumeEvent streamVolumeEvent;
559 VolumeEvent volumeEvent;
560 sptr<IRemoteObject> impl = new RemoteObjectFuzzTestStub();
561 auto iAudioPolicyClient = std::make_shared<AudioPolicyClientProxy>(impl);
562 if (iAudioPolicyClient == nullptr) {
563 return;
564 }
565 iAudioPolicyClient->OnStreamVolumeChange(streamVolumeEvent);
566 iAudioPolicyClient->OnSystemVolumeChange(volumeEvent);
567 }
568
AudioClientTrackerCallbackProxyMuteStreamImplFuzzTest()569 void AudioClientTrackerCallbackProxyMuteStreamImplFuzzTest()
570 {
571 sptr<AudioClientTrackerCallbackService> listener = new AudioClientTrackerCallbackService();
572 std::weak_ptr<AudioClientTrackerFuzzTest> callback = std::make_shared<AudioClientTrackerFuzzTest>();
573 listener->SetClientTrackerCallback(callback);
574 auto clientTrackerCallbackListener = std::make_shared<ClientTrackerCallbackListener>(listener);
575 if (clientTrackerCallbackListener == nullptr || g_testStreamSetStates.size() == 0
576 || g_testAudioStreamUsages.size() == 0) {
577 return;
578 }
579 StreamSetStateEventInternal streamSetStateEventInternal;
580 streamSetStateEventInternal.streamSetState =
581 g_testStreamSetStates[GetData<uint32_t>() % g_testStreamSetStates.size()];
582 streamSetStateEventInternal.streamUsage =
583 g_testAudioStreamUsages[GetData<uint32_t>() % g_testAudioStreamUsages.size()];
584 clientTrackerCallbackListener->MuteStreamImpl(streamSetStateEventInternal);
585 }
586
AudioClientTrackerCallbackProxyUnmuteStreamImplFuzzTest()587 void AudioClientTrackerCallbackProxyUnmuteStreamImplFuzzTest()
588 {
589 sptr<AudioClientTrackerCallbackService> listener = new AudioClientTrackerCallbackService();
590
591 auto clientTrackerCallbackListener = std::make_shared<ClientTrackerCallbackListener>(listener);
592 if (clientTrackerCallbackListener == nullptr || g_testStreamSetStates.size() == 0
593 || g_testAudioStreamUsages.size() == 0) {
594 return;
595 }
596 StreamSetStateEventInternal streamSetStateEventInternal;
597 streamSetStateEventInternal.streamSetState =
598 g_testStreamSetStates[GetData<uint32_t>() % g_testStreamSetStates.size()];
599 streamSetStateEventInternal.streamUsage =
600 g_testAudioStreamUsages[GetData<uint32_t>() % g_testAudioStreamUsages.size()];
601 clientTrackerCallbackListener->UnmuteStreamImpl(streamSetStateEventInternal);
602 }
603
AudioClientTrackerCallbackProxyPausedStreamImplFuzzTest()604 void AudioClientTrackerCallbackProxyPausedStreamImplFuzzTest()
605 {
606 sptr<AudioClientTrackerCallbackService> listener = new AudioClientTrackerCallbackService();
607 auto clientTrackerCallbackListener = std::make_shared<ClientTrackerCallbackListener>(listener);
608 if (clientTrackerCallbackListener == nullptr || g_testStreamSetStates.size() == 0
609 || g_testAudioStreamUsages.size() == 0) {
610 return;
611 }
612 StreamSetStateEventInternal streamSetStateEventInternal;
613 streamSetStateEventInternal.streamSetState =
614 g_testStreamSetStates[GetData<uint32_t>() % g_testStreamSetStates.size()];
615 streamSetStateEventInternal.streamUsage =
616 g_testAudioStreamUsages[GetData<uint32_t>() % g_testAudioStreamUsages.size()];
617 clientTrackerCallbackListener->PausedStreamImpl(streamSetStateEventInternal);
618 }
619
AudioClientTrackerCallbackProxyResumeStreamImplFuzzTest()620 void AudioClientTrackerCallbackProxyResumeStreamImplFuzzTest()
621 {
622 sptr<AudioClientTrackerCallbackService> listener = new AudioClientTrackerCallbackService();
623 auto clientTrackerCallbackListener = std::make_shared<ClientTrackerCallbackListener>(listener);
624 if (clientTrackerCallbackListener == nullptr || g_testStreamSetStates.size() == 0
625 || g_testAudioStreamUsages.size() == 0) {
626 return;
627 }
628 StreamSetStateEventInternal streamSetStateEventInternal;
629 streamSetStateEventInternal.streamSetState =
630 g_testStreamSetStates[GetData<uint32_t>() % g_testStreamSetStates.size()];
631 streamSetStateEventInternal.streamUsage =
632 g_testAudioStreamUsages[GetData<uint32_t>() % g_testAudioStreamUsages.size()];
633 clientTrackerCallbackListener->ResumeStreamImpl(streamSetStateEventInternal);
634 }
635
AudioClientTrackerCallbackProxySetLowPowerVolumeImplFuzzTest()636 void AudioClientTrackerCallbackProxySetLowPowerVolumeImplFuzzTest()
637 {
638 sptr<AudioClientTrackerCallbackService> listener = new AudioClientTrackerCallbackService();
639 auto clientTrackerCallbackListener = std::make_shared<ClientTrackerCallbackListener>(listener);
640 if (clientTrackerCallbackListener == nullptr) {
641 return;
642 }
643 float volume = GetData<float>();
644 clientTrackerCallbackListener->SetLowPowerVolumeImpl(volume);
645 }
646
AudioClientTrackerCallbackProxyGetLowPowerVolumeImplFuzzTest()647 void AudioClientTrackerCallbackProxyGetLowPowerVolumeImplFuzzTest()
648 {
649 sptr<AudioClientTrackerCallbackService> listener = new AudioClientTrackerCallbackService();
650 auto clientTrackerCallbackListener = std::make_shared<ClientTrackerCallbackListener>(listener);
651 if (clientTrackerCallbackListener == nullptr) {
652 return;
653 }
654 float volume = GetData<float>();
655 clientTrackerCallbackListener->GetLowPowerVolumeImpl(volume);
656 }
657
AudioClientTrackerCallbackProxyGetSingleStreamVolumeImplFuzzTest()658 void AudioClientTrackerCallbackProxyGetSingleStreamVolumeImplFuzzTest()
659 {
660 sptr<AudioClientTrackerCallbackService> listener = new AudioClientTrackerCallbackService();
661 auto clientTrackerCallbackListener = std::make_shared<ClientTrackerCallbackListener>(listener);
662 if (clientTrackerCallbackListener == nullptr) {
663 return;
664 }
665 float volume = GetData<float>();
666 clientTrackerCallbackListener->GetSingleStreamVolumeImpl(volume);
667 }
668
AudioClientTrackerCallbackProxySetOffloadModeImplFuzzTest()669 void AudioClientTrackerCallbackProxySetOffloadModeImplFuzzTest()
670 {
671 sptr<AudioClientTrackerCallbackService> listener = new AudioClientTrackerCallbackService();
672 auto clientTrackerCallbackListener = std::make_shared<ClientTrackerCallbackListener>(listener);
673 if (clientTrackerCallbackListener == nullptr) {
674 return;
675 }
676 int32_t state = GetData<int32_t>();
677 bool isAppBack = GetData<bool>();
678 clientTrackerCallbackListener->SetOffloadModeImpl(state, isAppBack);
679 }
680
AudioClientTrackerCallbackProxyUnsetOffloadModeImplFuzzTest()681 void AudioClientTrackerCallbackProxyUnsetOffloadModeImplFuzzTest()
682 {
683 sptr<AudioClientTrackerCallbackService> listener = new AudioClientTrackerCallbackService();
684 auto clientTrackerCallbackListener = std::make_shared<ClientTrackerCallbackListener>(listener);
685 if (clientTrackerCallbackListener == nullptr) {
686 return;
687 }
688 clientTrackerCallbackListener->UnsetOffloadModeImpl();
689 }
690
691 TestPtr g_testPtrs[] = {
692 AudioPolicyClientProxyOnVolumeKeyEventFuzzTest,
693 AudioPolicyClientProxyOnAudioFocusInfoChangeFuzzTest,
694 AudioPolicyClientProxyOnAudioFocusRequestedFuzzTest,
695 AudioPolicyClientProxyOnAudioFocusAbandonedFuzzTest,
696 AudioPolicyClientProxyOnActiveVolumeTypeChangedFuzzTest,
697 AudioPolicyClientProxyOnAppVolumeChangedFuzzTest,
698 AudioPolicyClientProxyOnDeviceChangeFuzzTest,
699 AudioPolicyClientProxyOnMicrophoneBlockedFuzzTest,
700 AudioPolicyClientProxyOnRingerModeUpdatedFuzzTest,
701 AudioPolicyClientProxyOnMicStateUpdatedFuzzTest,
702 AudioPolicyClientProxyOnPreferredOutputDeviceUpdatedFuzzTest,
703 AudioPolicyClientProxyOnPreferredInputDeviceUpdatedFuzzTest,
704 AudioPolicyClientProxyOnRendererStateChangeFuzzTest,
705 AudioPolicyClientProxyOnCapturerStateChangeFuzzTest,
706 AudioPolicyClientProxyOnRendererDeviceChangeFuzzTest,
707 AudioPolicyClientProxyOnRecreateRendererStreamEventFuzzTest,
708 AudioPolicyClientProxyOnRecreateCapturerStreamEventFuzzTest,
709 AudioPolicyClientProxyOnHeadTrackingDeviceChangeFuzzTest,
710 AudioPolicyClientProxyOnSpatializationEnabledChangeFuzzTest,
711 AudioPolicyClientProxyOnSpatializationEnabledChangeForAnyDeviceFuzzTest,
712 AudioPolicyClientProxyOnSpatializationEnabledChangeForCurrentDeviceFuzzTest,
713 AudioPolicyClientProxyOnHeadTrackingEnabledChangeFuzzTest,
714 AudioPolicyClientProxyOnAudioSceneChangeFuzzTest,
715 AudioPolicyClientProxyOnHeadTrackingEnabledChangeForAnyDeviceFuzzTest,
716 AudioPolicyClientProxyOnNnStateChangeFuzzTest,
717 AudioPolicyClientProxyOnAudioSessionDeactiveFuzzTest,
718 AudioPolicyClientProxyOnFormatUnsupportedErrorFuzzTest,
719 AudioPolicyClientProxyOnStreamVolumeChangeFuzzTest,
720 AudioClientTrackerCallbackProxyMuteStreamImplFuzzTest,
721 AudioClientTrackerCallbackProxyUnmuteStreamImplFuzzTest,
722 AudioClientTrackerCallbackProxyPausedStreamImplFuzzTest,
723 AudioClientTrackerCallbackProxyResumeStreamImplFuzzTest,
724 AudioClientTrackerCallbackProxySetLowPowerVolumeImplFuzzTest,
725 AudioClientTrackerCallbackProxyGetSingleStreamVolumeImplFuzzTest,
726 AudioClientTrackerCallbackProxySetOffloadModeImplFuzzTest,
727 AudioClientTrackerCallbackProxyUnsetOffloadModeImplFuzzTest,
728 };
729
FuzzTest(const uint8_t * rawData,size_t size)730 bool FuzzTest(const uint8_t* rawData, size_t size)
731 {
732 if (rawData == nullptr) {
733 return false;
734 }
735
736 RAW_DATA = rawData;
737 g_dataSize = size;
738 g_pos = 0;
739
740 uint32_t code = GetData<uint32_t>();
741 uint32_t len = GetArrLength(g_testPtrs);
742 if (len > 0) {
743 g_testPtrs[code % len]();
744 } else {
745 AUDIO_INFO_LOG("%{public}s: The len length is equal to 0", __func__);
746 }
747 return true;
748 }
749
750 } // namespace AudioStandard
751 } // namesapce OHOS
752
753 /* Fuzzer entry point */
LLVMFuzzerTestOneInput(const uint8_t * data,size_t size)754 extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size)
755 {
756 if (size < OHOS::AudioStandard::THRESHOLD) {
757 return 0;
758 }
759 OHOS::AudioStandard::FuzzTest(data, size);
760 return 0;
761 }