1/*
2 * Copyright (c) 2022 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 "call_fuzzer.h"
17
18#include <cstddef>
19#include <cstdint>
20#define private public
21#define protected public
22#include "addcalltoken_fuzzer.h"
23#include "cs_call.h"
24#include "ims_call.h"
25#include "ott_call.h"
26#include "satellite_call.h"
27#include "surface_utils.h"
28#include "voip_call.h"
29
30using namespace OHOS::Telephony;
31namespace OHOS {
32constexpr int32_t SLOT_NUM = 2;
33constexpr int32_t BOOL_NUM = 2;
34constexpr int32_t DIAL_TYPE = 3;
35constexpr int32_t CALL_TYPE_NUM = 4;
36constexpr int32_t VIDIO_TYPE_NUM = 2;
37constexpr int32_t TEL_CALL_STATE_NUM = 9;
38constexpr int32_t TEL_CONFERENCE_STATE_NUM = 4;
39constexpr int32_t CALL_RUNNING_STATE_NUM = 8;
40constexpr int32_t CALL_ENDED_TYPE_NUM = 4;
41constexpr int32_t CALL_ANSWER_TYPE_NUM = 3;
42constexpr int32_t INVALID_CALL_ID = -1;
43constexpr int32_t IMS_CALL_MODE_NUM = 5;
44constexpr int32_t CALL_INDEX_MAX_NUM = 8;
45constexpr int32_t VIDEO_REQUEST_RESULT_TYPE_NUM = 102;
46
47void CSCallFunc(const uint8_t *data, size_t size)
48{
49    if (!IsServiceInited()) {
50        return;
51    }
52
53    DialParaInfo dialParaInfo;
54    dialParaInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
55    dialParaInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
56    dialParaInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
57    dialParaInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
58    sptr<CallBase> callObjectPtr = std::make_unique<CSCall>(dialParaInfo).release();
59    int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
60    int32_t mute = static_cast<int32_t>(size % BOOL_NUM);
61    int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
62    TelCallState nextState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
63    TelConferenceState telConferenceState = static_cast<TelConferenceState>(size % TEL_CONFERENCE_STATE_NUM);
64    VideoStateType mediaType = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
65    PolicyFlag flag = static_cast<PolicyFlag>(size);
66    bool needAutoAnswer = static_cast<bool>(size);
67    bool canUnHoldState = static_cast<bool>(size);
68
69    callObjectPtr->AnswerCall(videoState);
70    callObjectPtr->SetMute(mute, slotId);
71    callObjectPtr->StartDtmf(static_cast<char>(*data));
72    callObjectPtr->StopDtmf();
73    callObjectPtr->GetSlotId();
74    callObjectPtr->DialCallBase();
75    callObjectPtr->IncomingCallBase();
76    callObjectPtr->AnswerCallBase();
77    callObjectPtr->RejectCallBase();
78    callObjectPtr->GetCallID();
79    callObjectPtr->GetCallType();
80    callObjectPtr->GetCallRunningState();
81    callObjectPtr->SetTelCallState(nextState);
82    callObjectPtr->GetTelCallState();
83    callObjectPtr->SetTelConferenceState(telConferenceState);
84    callObjectPtr->GetTelConferenceState();
85    callObjectPtr->GetVideoStateType();
86    callObjectPtr->SetVideoStateType(mediaType);
87    callObjectPtr->SetPolicyFlag(flag);
88    callObjectPtr->GetPolicyFlag();
89    callObjectPtr->SetAutoAnswerState(needAutoAnswer);
90    callObjectPtr->GetAutoAnswerState();
91    callObjectPtr->SetCanUnHoldState(canUnHoldState);
92    callObjectPtr->GetCanUnHoldState();
93}
94
95void DialingProcess(const uint8_t *data, size_t size)
96{
97    if (!IsServiceInited()) {
98        return;
99    }
100
101    DialParaInfo paraInfo;
102    paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
103    paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
104    paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
105    paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
106    sptr<CallBase> callObjectPtr = std::make_unique<CSCall>(paraInfo).release();
107
108    callObjectPtr->StartDtmf(static_cast<char>(*data));
109    callObjectPtr->RejectCall();
110    callObjectPtr->HangUpCall();
111    callObjectPtr->HoldCall();
112    callObjectPtr->UnHoldCall();
113    callObjectPtr->SwitchCall();
114    callObjectPtr->DialingProcess();
115    callObjectPtr->CombineConference(); // merge calls
116    callObjectPtr->SeparateConference();
117    callObjectPtr->KickOutFromConference();
118    callObjectPtr->CanSeparateConference();
119    callObjectPtr->CanCombineConference();
120    callObjectPtr->CanKickOutFromConference();
121    callObjectPtr->LaunchConference();
122    callObjectPtr->ExitConference();
123    callObjectPtr->HoldConference();
124    int32_t mainCallId = INVALID_CALL_ID;
125    callObjectPtr->GetMainCallId(mainCallId);
126    std::vector<std::u16string> subCallIdList;
127    callObjectPtr->GetSubCallIdList(subCallIdList);
128    std::vector<std::u16string> callIdList;
129    callObjectPtr->GetCallIdListForConference(callIdList);
130    callObjectPtr->IsSupportConferenceable();
131    callObjectPtr->GetEmergencyState();
132}
133
134void GetCallerInfo(const uint8_t *data, size_t size)
135{
136    if (!IsServiceInited()) {
137        return;
138    }
139
140    DialParaInfo info;
141    info.dialType = static_cast<DialType>(size % DIAL_TYPE);
142    info.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
143    info.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
144    info.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
145    sptr<CallBase> callObjectPtr = std::make_unique<CSCall>(info).release();
146    ContactInfo contactInfo;
147    CallRunningState callRunningState = static_cast<CallRunningState>(size % CALL_RUNNING_STATE_NUM);
148    bool speakerphoneOn = static_cast<bool>(size % BOOL_NUM);
149    std::string phoneNumber(reinterpret_cast<const char *>(data), size);
150    int32_t callId = static_cast<int32_t>(size);
151    CallEndedType callEndedType = static_cast<CallEndedType>(size % CALL_ENDED_TYPE_NUM);
152    CallAnswerType answerType = static_cast<CallAnswerType>(size % CALL_ANSWER_TYPE_NUM);
153    int64_t startTime = static_cast<int64_t>(size);
154    time_t callBeginTime = static_cast<time_t>(size);
155    time_t callCreateTime = static_cast<time_t>(size);
156    time_t callEndTime = static_cast<time_t>(size);
157    time_t ringBeginTime = static_cast<time_t>(size);
158    time_t ringEndTime = static_cast<time_t>(size);
159    callObjectPtr->GetCallerInfo();
160    callObjectPtr->SetCallerInfo(contactInfo);
161    callObjectPtr->SetCallRunningState(callRunningState);
162    callObjectPtr->SetStartTime(startTime);
163    callObjectPtr->SetCallBeginTime(callBeginTime);
164    callObjectPtr->SetCallBeginTime(callCreateTime);
165    callObjectPtr->SetCallEndTime(callEndTime);
166    callObjectPtr->SetRingBeginTime(ringBeginTime);
167    callObjectPtr->SetRingEndTime(ringEndTime);
168    callObjectPtr->SetAnswerType(answerType);
169    callObjectPtr->GetCallEndedType();
170    callObjectPtr->SetCallEndedType(callEndedType);
171    callObjectPtr->SetCallId(callId);
172    callObjectPtr->IsSpeakerphoneEnabled();
173    callObjectPtr->IsCurrentRinging();
174    callObjectPtr->GetAccountNumber();
175    callObjectPtr->SetSpeakerphoneOn(speakerphoneOn);
176    callObjectPtr->IsSpeakerphoneOn();
177    callObjectPtr->CheckVoicemailNumber(phoneNumber);
178    callObjectPtr->IsAliveState();
179}
180
181void IMSCallFunc(const uint8_t *data, size_t size)
182{
183    if (!IsServiceInited()) {
184        return;
185    }
186
187    DialParaInfo paraInfo;
188    paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
189    paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
190    paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
191    paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
192    sptr<IMSCall> callObjectPtr = std::make_unique<IMSCall>(paraInfo).release();
193    int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
194    int32_t mute = static_cast<int32_t>(size % BOOL_NUM);
195    int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
196    std::string msg(reinterpret_cast<const char *>(data), size);
197    std::u16string msgU16 = Str8ToStr16(msg);
198
199    callObjectPtr->InitVideoCall();
200    callObjectPtr->DialingProcess();
201    callObjectPtr->AnswerCall(videoState);
202    callObjectPtr->RejectCall();
203    callObjectPtr->HangUpCall();
204    callObjectPtr->UnHoldCall();
205    callObjectPtr->HoldCall();
206    callObjectPtr->SwitchCall();
207    callObjectPtr->CombineConference();
208    callObjectPtr->SeparateConference();
209    callObjectPtr->KickOutFromConference();
210    callObjectPtr->CanKickOutFromConference();
211    callObjectPtr->CanCombineConference();
212    callObjectPtr->CanSeparateConference();
213    callObjectPtr->LaunchConference();
214    callObjectPtr->ExitConference();
215    callObjectPtr->HoldConference();
216    int32_t mainCallId = INVALID_CALL_ID;
217    callObjectPtr->GetMainCallId(mainCallId);
218    std::vector<std::u16string> subCallIdList;
219    callObjectPtr->GetSubCallIdList(subCallIdList);
220    std::vector<std::u16string> callIdList;
221    callObjectPtr->GetCallIdListForConference(callIdList);
222    callObjectPtr->IsSupportConferenceable();
223    callObjectPtr->StartRtt(msgU16);
224    callObjectPtr->StopRtt();
225    callObjectPtr->SetMute(mute, slotId);
226}
227
228void VoIPCallFunc(const uint8_t *data, size_t size)
229{
230    if (!IsServiceInited()) {
231        return;
232    }
233    CallAttributeInfo info;
234    DialParaInfo dialParaInfo;
235    int32_t mainCallId = 0;
236    VoipCallEventInfo voipcallInfo;
237    std::vector<std::u16string> callIdList;
238    int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
239    sptr<VoIPCall> voipCall = std::make_unique<VoIPCall>(dialParaInfo).release();
240
241    voipCall->DialingProcess();
242    voipCall->AnswerCall(videoState);
243    voipCall->PackVoipCallInfo(voipcallInfo);
244    voipCall->RejectCall();
245    voipCall->HangUpCall();
246    voipCall->HoldCall();
247    voipCall->UnHoldCall();
248    voipCall->SwitchCall();
249    voipCall->SetMute(0, 0);
250    voipCall->GetCallAttributeInfo(info);
251    voipCall->CombineConference();
252    voipCall->HandleCombineConferenceFailEvent();
253    voipCall->SeparateConference();
254    voipCall->KickOutFromConference();
255    voipCall->CanCombineConference();
256    voipCall->CanSeparateConference();
257    voipCall->CanKickOutFromConference();
258    voipCall->GetMainCallId(mainCallId);
259    voipCall->GetSubCallIdList(callIdList);
260    voipCall->GetCallIdListForConference(callIdList);
261    voipCall->IsSupportConferenceable();
262    voipCall->LaunchConference();
263    voipCall->ExitConference();
264    voipCall->HoldConference();
265}
266
267void IMSVideoCallFunc(const uint8_t *data, size_t size)
268{
269    if (!IsServiceInited()) {
270        return;
271    }
272
273    DialParaInfo paraInfo;
274    paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
275    paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
276    paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
277    paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
278    sptr<IMSCall> callObjectPtr = std::make_unique<IMSCall>(paraInfo).release();
279    std::string msg(reinterpret_cast<const char *>(data), size);
280    int32_t callingUid = static_cast<int32_t>(size);
281    int32_t callingPid = static_cast<int32_t>(size);
282    int32_t rotation = static_cast<int32_t>(size);
283    ImsCallMode mode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
284    CallModeReportInfo callModeReportInfo;
285    callModeReportInfo.callIndex = static_cast<int32_t>(size % CALL_INDEX_MAX_NUM);
286    callModeReportInfo.callMode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
287    callModeReportInfo.result = static_cast<VideoRequestResultType>(size % VIDEO_REQUEST_RESULT_TYPE_NUM);
288    callObjectPtr->UpdateImsCallMode(mode);
289    callObjectPtr->SendUpdateCallMediaModeRequest(mode);
290    callObjectPtr->RecieveUpdateCallMediaModeRequest(callModeReportInfo);
291    callObjectPtr->SendUpdateCallMediaModeResponse(mode);
292    callObjectPtr->ReceiveUpdateCallMediaModeResponse(callModeReportInfo);
293    CallMediaModeInfo callMediaModeInfo;
294    callMediaModeInfo.callId = static_cast<int32_t>(size);
295    callMediaModeInfo.isRequestInfo = static_cast<bool>(size % BOOL_NUM);
296    callMediaModeInfo.result = static_cast<VideoRequestResultType>(size % VIDEO_REQUEST_RESULT_TYPE_NUM);
297    callMediaModeInfo.callMode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
298    callObjectPtr->ReportImsCallModeInfo(callMediaModeInfo);
299    callObjectPtr->SwitchVideoState(mode);
300    callObjectPtr->IsSupportVideoCall();
301    callObjectPtr->GetCallVideoState(mode);
302    callObjectPtr->ControlCamera(msg, callingUid, callingPid);
303    callObjectPtr->SetPausePicture(msg);
304    callObjectPtr->SetDeviceDirection(rotation);
305    callObjectPtr->CancelCallUpgrade();
306    callObjectPtr->RequestCameraCapabilities();
307}
308
309void IMSVideoCallWindowFunc(const uint8_t *data, size_t size)
310{
311    if (!IsServiceInited()) {
312        return;
313    }
314
315    DialParaInfo paraInfo;
316    paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
317    paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
318    paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
319    paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
320    sptr<IMSCall> callObjectPtr = std::make_unique<IMSCall>(paraInfo).release();
321    std::string msg(reinterpret_cast<const char *>(data), size);
322    int len = static_cast<int>(msg.length());
323    std::string subSurfaceId = msg;
324    if (len >= 1) {
325        subSurfaceId = msg.substr(0, 1);
326    }
327    if (subSurfaceId.empty() || subSurfaceId[0] < '0' || subSurfaceId[0] > '9') {
328        subSurfaceId = "";
329        callObjectPtr->SetPreviewWindow(subSurfaceId, nullptr);
330        callObjectPtr->SetDisplayWindow(subSurfaceId, nullptr);
331    } else {
332        uint64_t tmpSurfaceId = std::stoull(subSurfaceId);
333        auto surface = SurfaceUtils::GetInstance()->GetSurface(tmpSurfaceId);
334        callObjectPtr->SetPreviewWindow(subSurfaceId, surface);
335        callObjectPtr->SetDisplayWindow(subSurfaceId, surface);
336    }
337}
338
339void OttCallFunc(const uint8_t *data, size_t size)
340{
341    if (!IsServiceInited()) {
342        return;
343    }
344
345    DialParaInfo paraInfo;
346    paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
347    paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
348    paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
349    paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
350    sptr<OTTCall> callObjectPtr = std::make_unique<OTTCall>(paraInfo).release();
351    int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
352    int32_t mute = static_cast<int32_t>(size % BOOL_NUM);
353    int32_t slotId = static_cast<int32_t>(size % SLOT_NUM);
354
355    callObjectPtr->DialingProcess();
356    callObjectPtr->AnswerCall(videoState);
357    callObjectPtr->RejectCall();
358    callObjectPtr->HangUpCall();
359    callObjectPtr->HoldCall();
360    callObjectPtr->UnHoldCall();
361    callObjectPtr->SwitchCall();
362    callObjectPtr->GetEmergencyState();
363    callObjectPtr->StopDtmf();
364    callObjectPtr->GetSlotId();
365    callObjectPtr->CombineConference();
366    callObjectPtr->SeparateConference();
367    callObjectPtr->KickOutFromConference();
368    callObjectPtr->CanCombineConference();
369    callObjectPtr->CanSeparateConference();
370    callObjectPtr->CanKickOutFromConference();
371    callObjectPtr->LaunchConference();
372    callObjectPtr->ExitConference();
373    callObjectPtr->HoldConference();
374    int32_t mainCallId = INVALID_CALL_ID;
375    callObjectPtr->GetMainCallId(mainCallId);
376    std::vector<std::u16string> subCallIdList;
377    callObjectPtr->GetSubCallIdList(subCallIdList);
378    std::vector<std::u16string> callIdList;
379    callObjectPtr->GetCallIdListForConference(callIdList);
380    callObjectPtr->IsSupportConferenceable();
381    callObjectPtr->SetMute(mute, slotId);
382}
383
384void OttVideoCallFunc(const uint8_t *data, size_t size)
385{
386    if (!IsServiceInited()) {
387        return;
388    }
389    DialParaInfo paraInfo;
390    paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
391    paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
392    paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
393    paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
394    sptr<OTTCall> callObjectPtr = std::make_unique<OTTCall>(paraInfo).release();
395    std::string msg(reinterpret_cast<const char *>(data), size);
396    int32_t callingUid = static_cast<int32_t>(size);
397    int32_t callingPid = static_cast<int32_t>(size);
398    int32_t rotation = static_cast<int32_t>(size);
399    callObjectPtr->InitVideoCall();
400    ImsCallMode mode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
401    CallModeReportInfo callModeReportInfo;
402    callModeReportInfo.callIndex = static_cast<int32_t>(size % CALL_INDEX_MAX_NUM);
403    callModeReportInfo.callMode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
404    callModeReportInfo.result = static_cast<VideoRequestResultType>(size % VIDEO_REQUEST_RESULT_TYPE_NUM);
405    callObjectPtr->UpdateImsCallMode(mode);
406    callObjectPtr->SendUpdateCallMediaModeRequest(mode);
407    callObjectPtr->RecieveUpdateCallMediaModeRequest(callModeReportInfo);
408    callObjectPtr->SendUpdateCallMediaModeResponse(mode);
409    callObjectPtr->ReceiveUpdateCallMediaModeResponse(callModeReportInfo);
410    CallMediaModeInfo callMediaModeInfo;
411    callMediaModeInfo.callId = static_cast<int32_t>(size);
412    callMediaModeInfo.isRequestInfo = static_cast<bool>(size % BOOL_NUM);
413    callMediaModeInfo.result = static_cast<VideoRequestResultType>(size % VIDEO_REQUEST_RESULT_TYPE_NUM);
414    callMediaModeInfo.callMode = static_cast<ImsCallMode>(size % IMS_CALL_MODE_NUM);
415    callObjectPtr->ReportImsCallModeInfo(callMediaModeInfo);
416    callObjectPtr->ControlCamera(msg, callingUid, callingPid);
417    callObjectPtr->SetPausePicture(msg);
418    callObjectPtr->SetDeviceDirection(rotation);
419    callObjectPtr->CancelCallUpgrade();
420    callObjectPtr->RequestCameraCapabilities();
421}
422
423void OttVideoCallWindowFunc(const uint8_t *data, size_t size)
424{
425    if (!IsServiceInited()) {
426        return;
427    }
428    DialParaInfo paraInfo;
429    paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
430    paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
431    paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
432    paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
433    sptr<OTTCall> callObjectPtr = std::make_unique<OTTCall>(paraInfo).release();
434    std::string msg(reinterpret_cast<const char *>(data), size);
435    int len = static_cast<int>(msg.length());
436    std::string subSurfaceId = msg;
437    if (len >= 1) {
438        subSurfaceId = msg.substr(0, 1);
439    }
440    if (subSurfaceId.empty() || subSurfaceId[0] < '0' || subSurfaceId[0] > '9') {
441        subSurfaceId = "";
442        callObjectPtr->SetPreviewWindow(subSurfaceId, nullptr);
443        callObjectPtr->SetDisplayWindow(subSurfaceId, nullptr);
444    } else {
445        uint64_t tmpSurfaceId = std::stoull(subSurfaceId);
446        auto surface = SurfaceUtils::GetInstance()->GetSurface(tmpSurfaceId);
447        callObjectPtr->SetPreviewWindow(subSurfaceId, surface);
448        callObjectPtr->SetDisplayWindow(subSurfaceId, surface);
449    }
450}
451
452void SatelliteCallFunc(const uint8_t *data, size_t size)
453{
454    if (!IsServiceInited()) {
455        return;
456    }
457
458    DialParaInfo paraInfo;
459    paraInfo.dialType = static_cast<DialType>(size % DIAL_TYPE);
460    paraInfo.callType = static_cast<CallType>(size % CALL_TYPE_NUM);
461    paraInfo.videoState = static_cast<VideoStateType>(size % VIDIO_TYPE_NUM);
462    paraInfo.callState = static_cast<TelCallState>(size % TEL_CALL_STATE_NUM);
463    sptr<SatelliteCall> callObjectPtr = std::make_unique<SatelliteCall>(paraInfo).release();
464    int32_t videoState = static_cast<int32_t>(size % VIDIO_TYPE_NUM);
465    CallAttributeInfo info;
466
467    callObjectPtr->DialingProcess();
468    callObjectPtr->AnswerCall(videoState);
469    callObjectPtr->RejectCall();
470    callObjectPtr->HangUpCall();
471    callObjectPtr->GetCallAttributeInfo(info);
472}
473
474void DoSomethingInterestingWithMyAPI(const uint8_t *data, size_t size)
475{
476    if (data == nullptr || size == 0) {
477        return;
478    }
479
480    CSCallFunc(data, size);
481    DialingProcess(data, size);
482    GetCallerInfo(data, size);
483    IMSCallFunc(data, size);
484    IMSVideoCallFunc(data, size);
485    IMSVideoCallWindowFunc(data, size);
486    OttCallFunc(data, size);
487    VoIPCallFunc(data, size);
488    OttVideoCallFunc(data, size);
489    OttVideoCallWindowFunc(data, size);
490    SatelliteCallFunc(data, size);
491}
492} // namespace OHOS
493
494/* Fuzzer entry point */
495extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size)
496{
497    OHOS::AddCallTokenFuzzer token;
498    /* Run your code on data */
499    OHOS::DoSomethingInterestingWithMyAPI(data, size);
500    return 0;
501}
502