1/*
2 * Copyright (C) 2021-2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 *     http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16#include "at_call.h"
17
18#include "hril_notification.h"
19#include "securec.h"
20#include "vendor_report.h"
21#include "vendor_util.h"
22
23#undef DEFAULT_TIMEOUT
24#define DEFAULT_TIMEOUT 5000
25#define DEFAULT_TIMEOUT_CLCK 50000
26
27CallNotify g_callNotifyTab[] = {
28    {"^CCALLSTATE:", ReportCallStateUpdated},
29    {"+CUSD:", ReportCallUssdNotice},
30    {"+CIREPH:", ReportSrvccStatusUpdate},
31    {"^CSCHANNELINFO:", ReportCsChannelInfo},
32    {"^XLEMA:", ReportEmergencyNumberList},
33};
34
35static int32_t lastCcCause = HRIL_ERR_CALL_CAUSE;
36static const int32_t MAX_CALL_NUM = 100;
37
38static void OnCallReportErrorMessages(const ReqDataInfo *requestInfo, int32_t err, ResponseInfo *pResponse)
39{
40    int32_t errorNo = HRIL_ERR_SUCCESS;
41    ModemReportErrorInfo errInfo = GetReportErrorInfo(pResponse);
42    errorNo = (err != HRIL_ERR_SUCCESS) ? err : errInfo.errorNo;
43    TELEPHONY_LOGW("Report error! ret:%{public}d", errorNo);
44    FreeResponseInfo(pResponse);
45    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, errorNo, HRIL_RESPONSE, 0);
46    reportInfo.modemErrInfo = errInfo;
47    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
48}
49
50static int32_t ParseDiffPart(int32_t isAllInfo, char **pLine, HRilCallInfo *outCall)
51{
52    if (outCall == NULL) {
53        return HRIL_ERR_NULL_POINT;
54    }
55    int32_t tmp = 0;
56    if (isAllInfo) {
57        if (NextInt(pLine, &outCall->voiceDomain) < 0) {
58            return HRIL_ERR_NULL_POINT;
59        }
60        if (NextInt(pLine, &outCall->callType) < 0) {
61            return HRIL_ERR_NULL_POINT;
62        }
63        NextInt(pLine, &tmp); // ignore
64    } else {
65        outCall->voiceDomain = INT_DEFAULT_VALUE;
66        outCall->callType = INT_DEFAULT_VALUE;
67    }
68    return 0;
69}
70
71static int32_t CallCmdCLCC(const char *lineCmd, HRilCallInfo *outCall)
72{
73    char *pLine = (char *)lineCmd;
74    int32_t state;
75    int32_t mode;
76
77    if (pLine == NULL || outCall == NULL) {
78        TELEPHONY_LOGE("src or desc pointer is null.");
79        return HRIL_ERR_NULL_POINT;
80    }
81    int32_t isAllInfo = ReportStrWith(pLine, "^CLCC:");
82    if (SkipATPrefix(&pLine) < 0) {
83        return HRIL_ERR_NULL_POINT;
84    }
85    if (NextInt(&pLine, &outCall->index) < 0) {
86        return HRIL_ERR_NULL_POINT;
87    }
88    if (NextInt(&pLine, &outCall->dir) < 0) {
89        return HRIL_ERR_NULL_POINT;
90    }
91    if (NextInt(&pLine, &state) < 0) {
92        return HRIL_ERR_NULL_POINT;
93    }
94    outCall->state = (HRilCallState)state;
95    if (NextInt(&pLine, &mode) < 0) {
96        return HRIL_ERR_NULL_POINT;
97    }
98    outCall->mode = (HRilCallMode)mode;
99    if (NextInt(&pLine, &outCall->mpty) < 0) {
100        return HRIL_ERR_NULL_POINT;
101    }
102    if (ParseDiffPart(isAllInfo, &pLine, outCall)) {
103        return HRIL_ERR_NULL_POINT;
104    }
105    if (NextStr(&pLine, &outCall->number) < 0) {
106        return HRIL_ERR_NULL_POINT;
107    }
108    if (NextInt(&pLine, &outCall->type) < 0) {
109        return HRIL_ERR_NULL_POINT;
110    }
111
112    if (pLine != NULL) { // The data returned by some modules does not have this alpha data.
113        if (NextStr(&pLine, &outCall->alpha) < 0) {
114            return HRIL_ERR_NULL_POINT;
115        }
116    }
117    return HRIL_ERR_SUCCESS;
118}
119
120void ReportCallStateUpdated(const char *str)
121{
122    int32_t err = HRIL_ERR_SUCCESS;
123    char *pStr = (char *)str;
124    int callId = 0;
125    int voiceDomain = 0;
126    int state = 0;
127    ReqDataInfo requestInfo = {0};
128    ModemReportErrorInfo errInfo = InitModemReportErrorInfo();
129
130    if (SkipATPrefix(&pStr) < 0) {
131        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
132    }
133    if (NextInt(&pStr, &callId) < 0) {
134        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
135    }
136    if (NextInt(&pStr, &state) < 0) {
137        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
138    }
139    if (NextInt(&pStr, &voiceDomain) < 0) {
140        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
141    }
142
143    struct ReportInfo reportInfo = CreateReportInfo(&requestInfo, err, HRIL_NOTIFICATION, HNOTI_CALL_STATE_UPDATED);
144    reportInfo.modemErrInfo = errInfo;
145    OnCallReport(GetSlotId(NULL), reportInfo, NULL, 0);
146}
147
148void ReportSrvccStatusUpdate(const char *str)
149{
150    int32_t err = HRIL_ERR_SUCCESS;
151    char *pStr = (char *)str;
152    HRilCallSrvccStatus srvccStatus = {0};
153    ReqDataInfo requestInfo = {0};
154    ModemReportErrorInfo errInfo = InitModemReportErrorInfo();
155
156    if (SkipATPrefix(&pStr) < 0) {
157        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
158    }
159    if (err == HRIL_ERR_SUCCESS && NextInt(&pStr, &srvccStatus.status) < 0) {
160        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
161    }
162
163    struct ReportInfo reportInfo =
164        CreateReportInfo(&requestInfo, err, HRIL_NOTIFICATION, HNOTI_CALL_SRVCC_STATUS_REPORT);
165    reportInfo.modemErrInfo = errInfo;
166    OnCallReport(GetSlotId(NULL), reportInfo, (const uint8_t *)&srvccStatus, sizeof(HRilCallSrvccStatus));
167}
168
169void ReportCsChannelInfo(const char *str)
170{
171    int32_t err = HRIL_ERR_SUCCESS;
172    char *pStr = (char *)str;
173    HRilCallCsChannelInfo csChannelInfo = {0};
174    ReqDataInfo requestInfo = {0};
175    ModemReportErrorInfo errInfo = InitModemReportErrorInfo();
176    /* 0 network alerting; 1 local alerting */
177    int32_t ringbackVoiceFlag = 0;
178
179    if (SkipATPrefix(&pStr) < 0) {
180        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
181    }
182    if (err == HRIL_ERR_SUCCESS && NextInt(&pStr, &csChannelInfo.status) < 0) {
183        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
184    }
185    if (err == HRIL_ERR_SUCCESS && NextInt(&pStr, &csChannelInfo.voiceDomain) < 0) {
186        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
187    }
188
189    ringbackVoiceFlag = !csChannelInfo.status;
190    struct ReportInfo reportInfo =
191        CreateReportInfo(&requestInfo, err, HRIL_NOTIFICATION, HNOTI_CALL_RINGBACK_VOICE_REPORT);
192    reportInfo.modemErrInfo = errInfo;
193    OnCallReport(GetSlotId(NULL), reportInfo, (const uint8_t *)&ringbackVoiceFlag, sizeof(int32_t));
194}
195
196int32_t IsCallNoticeCmd(const char *str)
197{
198    int32_t tabSize = sizeof(g_callNotifyTab) / sizeof(CallNotify);
199    for (int32_t i = 0; i < tabSize; i++) {
200        if (ReportStrWith(str, g_callNotifyTab[i].cmd)) {
201            return 1;
202        }
203    }
204    return 0;
205}
206
207void CallReportInfoProcess(const char *str)
208{
209    int32_t tabSize = sizeof(g_callNotifyTab) / sizeof(CallNotify);
210    for (int32_t i = 0; i < tabSize; i++) {
211        if (ReportStrWith(str, g_callNotifyTab[i].cmd)) {
212            g_callNotifyTab[i].function(str);
213            break;
214        }
215    }
216}
217
218void ReportEmergencyNumberList(const char *str)
219{
220    int32_t err = HRIL_ERR_SUCCESS;
221    char *pStr = (char *)str;
222    HRilEmergencyInfo pEmergencyInfo = {0};
223    ReqDataInfo requestInfo = {0};
224    ModemReportErrorInfo errInfo = InitModemReportErrorInfo();
225
226    if (SkipATPrefix(&pStr) < 0) {
227        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
228    }
229    if (NextInt(&pStr, &pEmergencyInfo.index) < 0) {
230        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
231    }
232    if (NextInt(&pStr, &pEmergencyInfo.total) < 0) {
233        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
234    }
235    if (NextStr(&pStr, &pEmergencyInfo.eccNum) < 0) {
236        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
237    }
238    if (NextInt(&pStr, &pEmergencyInfo.category) < 0) {
239        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
240    }
241    if (NextInt(&pStr, &pEmergencyInfo.simpresent) < 0) {
242        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
243    }
244    if (NextStr(&pStr, &pEmergencyInfo.mcc) < 0) {
245        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
246    }
247    if (NextInt(&pStr, &pEmergencyInfo.abnormalService) < 0) {
248        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
249    }
250
251    struct ReportInfo reportInfo =
252        CreateReportInfo(&requestInfo, err, HRIL_NOTIFICATION, HNOTI_CALL_EMERGENCY_NUMBER_REPORT);
253    reportInfo.modemErrInfo = errInfo;
254    OnCallReport(GetSlotId(NULL), reportInfo, (const uint8_t *)&pEmergencyInfo, sizeof(pEmergencyInfo));
255}
256
257void ReportCallUssdNotice(const char *str)
258{
259    int32_t err = HRIL_ERR_SUCCESS;
260    char *pStr = (char *)str;
261    HRilUssdNoticeInfo ussdNoticeInfo = {0};
262    ReqDataInfo requestInfo = {0};
263    ModemReportErrorInfo errInfo = InitModemReportErrorInfo();
264
265    if (SkipATPrefix(&pStr) < 0) {
266        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
267    }
268    if (NextInt(&pStr, &ussdNoticeInfo.m) < 0) {
269        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
270    }
271    if (NextStr(&pStr, &ussdNoticeInfo.str) < 0) {
272        err = HRIL_ERR_INVALID_MODEM_PARAMETER;
273    }
274    struct ReportInfo reportInfo = CreateReportInfo(&requestInfo, err, HRIL_NOTIFICATION, HNOTI_CALL_USSD_REPORT);
275    reportInfo.modemErrInfo = errInfo;
276    OnCallReport(GetSlotId(NULL), reportInfo, (const uint8_t *)&ussdNoticeInfo, sizeof(HRilUssdNoticeInfo));
277}
278
279static int32_t InitCallListCmdBuffer(const ResponseInfo *pResponse, int32_t *callNum, HRilCallInfo **pCalls)
280{
281    int32_t ret;
282    int32_t callNumTmp = 0;
283    Line *pLine = NULL;
284    HRilCallInfo *pCallsTmp = NULL;
285
286    if (pResponse == NULL || pCalls == NULL || callNum == NULL) {
287        TELEPHONY_LOGE("params: %{public}p,%{public}p,%{public}p", pResponse, callNum, pCalls);
288        return HRIL_ERR_NULL_POINT;
289    }
290
291    *callNum = 0;
292    *pCalls = NULL;
293
294    for (pLine = pResponse->head; pLine != NULL; pLine = pLine->next) {
295        callNumTmp++;
296    }
297    if (!callNumTmp) {
298        callNumTmp++; // Malloc size cannot be 0.
299    }
300    if (callNumTmp > MAX_CALL_NUM) {
301        TELEPHONY_LOGE("callNumTmp is invalid");
302        return HRIL_ERR_INVALID_PARAMETER;
303    }
304    pCallsTmp = (HRilCallInfo *)malloc(callNumTmp * sizeof(HRilCallInfo));
305    if (pCallsTmp == NULL) {
306        TELEPHONY_LOGE("ReqGetCallList malloc pCalls failure");
307        return HRIL_ERR_MEMORY_FULL;
308    }
309    ret = memset_s(pCallsTmp, callNumTmp * sizeof(HRilCallInfo), 0, callNumTmp * sizeof(HRilCallInfo));
310    if (ret != EOK) {
311        TELEPHONY_LOGE("memset_s is failed!");
312        free(pCallsTmp);
313        pCallsTmp = NULL;
314        return ret;
315    }
316
317    *pCalls = pCallsTmp;
318    *callNum = callNumTmp;
319
320    return HRIL_ERR_SUCCESS;
321}
322
323int32_t BuildCallInfoList(const ReqDataInfo *requestInfo, ResponseInfo *response)
324{
325    int32_t ret = 0;
326    int32_t callNum = 0;
327    int32_t validCallNum = 0;
328    int32_t err = HRIL_ERR_SUCCESS;
329    Line *pLine = NULL;
330    ResponseInfo *pResponse = response;
331    HRilCallInfo *pCalls = NULL;
332
333    if (pResponse == NULL || requestInfo == NULL) {
334        TELEPHONY_LOGE("response or requestInfo is null.");
335        return HRIL_ERR_NULL_POINT;
336    }
337    if (pResponse->success == 0) {
338        TELEPHONY_LOGE("send cmd return ERROR");
339        err = HRIL_ERR_GENERIC_FAILURE;
340    }
341
342    ret = InitCallListCmdBuffer(pResponse, &callNum, &pCalls);
343    if (ret != HRIL_ERR_SUCCESS) {
344        TELEPHONY_LOGE("init command failed: %{public}d", ret);
345        return ret;
346    }
347
348    for (pLine = pResponse->head; pLine != NULL && validCallNum < callNum; pLine = pLine->next) {
349        ret = CallCmdCLCC(pLine->data, pCalls + validCallNum);
350        if (ret != 0) {
351            TELEPHONY_LOGE("Parse CLCC data is fail. ret:%{public}d", ret);
352            continue;
353        }
354        validCallNum++;
355    }
356
357    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
358    OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)pCalls, sizeof(HRilCallInfo) * validCallNum);
359    FreeResponseInfo(pResponse);
360    free(pCalls);
361    return HRIL_ERR_SUCCESS;
362}
363
364void ReqGetCallList(const ReqDataInfo *requestInfo)
365{
366    int32_t ret;
367    ResponseInfo *pResponse = NULL;
368    int32_t err = HRIL_ERR_SUCCESS;
369    long timeOut = DEFAULT_TIMEOUT;
370
371    ret = SendCommandLock("AT+CLCC", "+CLCC:", timeOut, &pResponse);
372    if (ret || (pResponse != NULL && !pResponse->success)) {
373        err = ret ? ret : err;
374        TELEPHONY_LOGE("cmd send failed, err:%{public}d", err);
375        if (err < HRIL_ERR_SUCCESS) {
376            err = HRIL_ERR_GENERIC_FAILURE;
377        }
378        OnCallReportErrorMessages(requestInfo, err, pResponse);
379        return;
380    }
381    err = BuildCallInfoList(requestInfo, pResponse);
382    if (err != HRIL_ERR_SUCCESS) {
383        if (err < HRIL_ERR_SUCCESS) {
384            err = HRIL_ERR_GENERIC_FAILURE;
385        }
386        TELEPHONY_LOGE("Build Call Info List is failed.");
387        OnCallReportErrorMessages(requestInfo, err, pResponse);
388    }
389}
390
391void ReqDial(const ReqDataInfo *requestInfo, const HRilDial *data, size_t dataLen)
392{
393    HRilDial *pDial = NULL;
394    char cmd[MAX_CMD_LENGTH] = {0};
395    const char *clir = NULL;
396    int32_t ret;
397    int32_t err = HRIL_ERR_SUCCESS;
398    ResponseInfo *pResponse = NULL;
399
400    if (data == NULL) {
401        TELEPHONY_LOGE("data is null!!!");
402        return;
403    }
404
405    pDial = (HRilDial *)data;
406    switch (pDial->clir) {
407        case CALL_CLIR_INVOCATION:
408            clir = "I";
409            break; /* invocation */
410        case CALL_CLIR_SUPPRESSION:
411            clir = "i";
412            break; /* suppression */
413        case CALL_CLIR_SUBSCRIPTION_DEFAULT:
414        default:
415            clir = "";
416            break; /* subscription default */
417    }
418
419    ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "ATD%s%s;", pDial->address, clir);
420    if (ret < 0) {
421        TELEPHONY_LOGE("GenerateCommand is failed!");
422        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
423        return;
424    }
425    ret = SendCommandLock(cmd, NULL, 0, &pResponse);
426    if (ret != 0) {
427        err = HRIL_ERR_CMD_SEND_FAILURE;
428        TELEPHONY_LOGE("ATD send failed");
429    } else {
430        if (pResponse == NULL || !pResponse->success) {
431            TELEPHONY_LOGE("ReqDial return ERROR");
432            err = HRIL_ERR_CMD_NO_CARRIER;
433        }
434    }
435
436    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
437    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
438    FreeResponseInfo(pResponse);
439}
440
441void ReqHangup(const ReqDataInfo *requestInfo, const uint32_t *data, size_t dataLen)
442{
443    const int32_t *pLine = NULL;
444    int32_t ret;
445    int32_t err = HRIL_ERR_SUCCESS;
446    char cmd[MAX_CMD_LENGTH] = {0};
447    ResponseInfo *pResponse = NULL;
448
449    if (data == NULL) {
450        TELEPHONY_LOGE("data is null!!!");
451        return;
452    }
453    pLine = (const int32_t *)data;
454    ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CHLD=1%d", pLine[0]);
455    if (ret < 0) {
456        TELEPHONY_LOGE("GenerateCommand is failed!");
457        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
458        return;
459    }
460    ret = SendCommandLock(cmd, NULL, 0, &pResponse);
461    if (ret != HRIL_ERR_SUCCESS || pResponse == NULL || !pResponse->success) {
462        TELEPHONY_LOGE("AT+CHLD send failed");
463        err = HRIL_ERR_GENERIC_FAILURE;
464    }
465
466    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
467    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
468    FreeResponseInfo(pResponse);
469}
470
471void ReqReject(const ReqDataInfo *requestInfo)
472{
473    ResponseInfo *pResponse = NULL;
474    int32_t ret;
475    int32_t err = HRIL_ERR_SUCCESS;
476
477    ret = SendCommandLock("ATH", NULL, 0, &pResponse);
478    if (ret != HRIL_ERR_SUCCESS || pResponse == NULL || !pResponse->success) {
479        TELEPHONY_LOGE("ATH send failed");
480        err = HRIL_ERR_GENERIC_FAILURE;
481    }
482
483    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
484    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
485    FreeResponseInfo(pResponse);
486}
487
488void ReqAnswer(const ReqDataInfo *requestInfo)
489{
490    int32_t ret;
491    int32_t err = HRIL_ERR_SUCCESS;
492    ResponseInfo *pResponse = NULL;
493
494    ret = SendCommandLock("ATA", NULL, 0, &pResponse);
495    if (ret != HRIL_ERR_SUCCESS || pResponse == NULL || !pResponse->success) {
496        err = HRIL_ERR_GENERIC_FAILURE;
497    }
498
499    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
500    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
501    FreeResponseInfo(pResponse);
502}
503
504// Calling line identification presentation
505void ReqGetClip(const ReqDataInfo *requestInfo)
506{
507    HRilGetClipResult result = {0};
508    int32_t err = HRIL_ERR_SUCCESS;
509    ResponseInfo *pResponse = NULL;
510
511    err = SendCommandLock("AT+CLIP?", "+CLIP", 0, &pResponse);
512    if (err == HRIL_ERR_SUCCESS) {
513        if (pResponse == NULL || !pResponse->success) {
514            TELEPHONY_LOGE("CLIP return ERROR");
515            err = HRIL_ERR_GENERIC_FAILURE;
516        } else {
517            if (pResponse->head != NULL) {
518                char *line = pResponse->head->data;
519                SkipATPrefix(&line);
520                NextInt(&line, &result.action);
521                NextInt(&line, &result.clipStat);
522            } else {
523                TELEPHONY_LOGE("ERROR: ReqGetClip pResponse->head is null");
524                err = HRIL_ERR_GENERIC_FAILURE;
525            }
526        }
527        struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
528        OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&result, sizeof(result));
529        FreeResponseInfo(pResponse);
530    } else {
531        TELEPHONY_LOGE("ReqGetClip send failed");
532        struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_CMD_SEND_FAILURE, HRIL_RESPONSE, 0);
533        OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&result, 0);
534    }
535}
536
537void ReqSetClip(const ReqDataInfo *requestInfo, int32_t action)
538{
539    char cmd[MAX_CMD_LENGTH] = {0};
540    int32_t err = HRIL_ERR_SUCCESS;
541    ResponseInfo *pResponse = NULL;
542
543    int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CLIP=%d", action);
544    if (ret < 0) {
545        TELEPHONY_LOGE("GenerateCommand is failed!");
546        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
547        return;
548    }
549    err = SendCommandLock(cmd, NULL, 0, &pResponse);
550    if (err == HRIL_ERR_SUCCESS) {
551        if (pResponse == NULL || !pResponse->success) {
552            TELEPHONY_LOGE("ReqSetClip return ERROR");
553            err = HRIL_ERR_GENERIC_FAILURE;
554        }
555
556        FreeResponseInfo(pResponse);
557    } else {
558        TELEPHONY_LOGE("ReqSetClip send failed");
559        err = HRIL_ERR_GENERIC_FAILURE;
560    }
561    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
562    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
563}
564
565void ReqGetClir(const ReqDataInfo *requestInfo)
566{
567    HRilGetCallClirResult result = {0};
568    int32_t err = HRIL_ERR_SUCCESS;
569    ResponseInfo *pResponse = NULL;
570
571    err = SendCommandLock("AT+CLIR?", "+CLIR", 0, &pResponse);
572    if (err == HRIL_ERR_SUCCESS) {
573        if (pResponse == NULL || !pResponse->success) {
574            TELEPHONY_LOGE("CLIR return ERROR");
575            err = HRIL_ERR_GENERIC_FAILURE;
576        } else {
577            if (pResponse->head != NULL) {
578                char *line = pResponse->head->data;
579                SkipATPrefix(&line);
580                NextInt(&line, &result.action);
581                NextInt(&line, &result.clirStat);
582            } else {
583                TELEPHONY_LOGE("ERROR: ReqGetClir pResponse->head is null");
584                err = HRIL_ERR_GENERIC_FAILURE;
585            }
586        }
587        struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
588        OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&result, sizeof(result));
589        FreeResponseInfo(pResponse);
590    } else {
591        TELEPHONY_LOGE("ReqGetClir send failed");
592        err = HRIL_ERR_CMD_SEND_FAILURE;
593        OnCallReportErrorMessages(requestInfo, err, pResponse);
594    }
595}
596
597void ReqSetClir(const ReqDataInfo *requestInfo, int32_t action)
598{
599    char cmd[MAX_CMD_LENGTH] = {0};
600    int32_t err = HRIL_ERR_SUCCESS;
601    ResponseInfo *pResponse = NULL;
602
603    int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CLIR=%d", action);
604    if (ret < 0) {
605        TELEPHONY_LOGE("GenerateCommand is failed!");
606        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
607        return;
608    }
609    err = SendCommandLock(cmd, NULL, 0, &pResponse);
610    if (err != HRIL_ERR_SUCCESS || pResponse == NULL || !pResponse->success) {
611        TELEPHONY_LOGE("ReqSetClir send failed");
612        err = HRIL_ERR_GENERIC_FAILURE;
613    }
614    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
615    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
616    FreeResponseInfo(pResponse);
617}
618
619void ReqStartDtmf(const ReqDataInfo *requestInfo, CallDtmfInfo info)
620{
621    char cmd[MAX_CMD_LENGTH] = {0};
622    int32_t err = HRIL_ERR_SUCCESS;
623    ResponseInfo *pResponse = NULL;
624
625    int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT^DTMF=%d,%c,1,0", info.callId, info.dtmfKey[0]);
626    if (ret < 0) {
627        TELEPHONY_LOGE("GenerateCommand is failed!");
628        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
629        return;
630    }
631    err = SendCommandLock(cmd, NULL, 0, &pResponse);
632    if (err != HRIL_ERR_SUCCESS || pResponse == NULL || !pResponse->success) {
633        TELEPHONY_LOGE("ReqStartDtmf send failed");
634        err = HRIL_ERR_GENERIC_FAILURE;
635    }
636    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
637    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
638    FreeResponseInfo(pResponse);
639}
640
641void ReqSendDtmf(const ReqDataInfo *requestInfo, CallDtmfInfo info)
642{
643    char cmd[MAX_CMD_LENGTH] = {0};
644    int32_t err = HRIL_ERR_SUCCESS;
645    ResponseInfo *pResponse = NULL;
646    int32_t stringLength = 0;
647    int32_t ret;
648
649    if (info.dtmfKey == NULL) {
650        err = HRIL_ERR_NULL_POINT;
651        OnCallReportErrorMessages(requestInfo, err, NULL);
652        return;
653    }
654
655    for (stringLength = 0; stringLength < info.stringLength; stringLength++) {
656        ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT^DTMF=%d,%c,%d,%d", info.callId, info.dtmfKey[stringLength],
657            info.onLength, info.offLength);
658        if (ret < 0) {
659            TELEPHONY_LOGE("GenerateCommand is failed!");
660            continue;
661        }
662        err = SendCommandLock(cmd, NULL, 0, &pResponse);
663        if (err != HRIL_ERR_SUCCESS || pResponse == NULL || !pResponse->success) {
664            TELEPHONY_LOGE("ReqSendDtmf send failed");
665            err = HRIL_ERR_GENERIC_FAILURE;
666            break;
667        }
668    }
669    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
670    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
671    FreeResponseInfo(pResponse);
672}
673
674void ReqStopDtmf(const ReqDataInfo *requestInfo, CallDtmfInfo info)
675{
676    char cmd[MAX_CMD_LENGTH] = {0};
677    int32_t err = HRIL_ERR_SUCCESS;
678    ResponseInfo *pResponse = NULL;
679
680    int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT^DTMF=%d,%c,0,0", info.callId, info.dtmfKey[0]);
681    if (ret < 0) {
682        TELEPHONY_LOGE("GenerateCommand is failed!");
683        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
684        return;
685    }
686    err = SendCommandLock(cmd, NULL, 0, &pResponse);
687    if (err != HRIL_ERR_SUCCESS || pResponse == NULL || !pResponse->success) {
688        TELEPHONY_LOGE("ReqStopDtmf send failed");
689        err = HRIL_ERR_GENERIC_FAILURE;
690    }
691    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
692    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
693    FreeResponseInfo(pResponse);
694}
695
696static void HoldCallAndUnHoldCallAtSend(const ReqDataInfo *requestInfo)
697{
698    int32_t ret;
699    int32_t err = HRIL_ERR_SUCCESS;
700    ResponseInfo *pResponse = NULL;
701
702    ret = SendCommandLock("AT+CHLD=2", NULL, 0, &pResponse);
703    if (ret != HRIL_ERR_SUCCESS || pResponse == NULL || !pResponse->success) {
704        TELEPHONY_LOGE("ATA send failed");
705        err = HRIL_ERR_GENERIC_FAILURE;
706    }
707
708    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
709    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
710    FreeResponseInfo(pResponse);
711}
712
713void ReqHoldCall(const ReqDataInfo *requestInfo)
714{
715    HoldCallAndUnHoldCallAtSend(requestInfo);
716}
717
718void ReqUnHoldCall(const ReqDataInfo *requestInfo)
719{
720    HoldCallAndUnHoldCallAtSend(requestInfo);
721}
722
723void ReqSwitchCall(const ReqDataInfo *requestInfo)
724{
725    HoldCallAndUnHoldCallAtSend(requestInfo);
726}
727
728void ReqCombineConference(const ReqDataInfo *requestInfo, int32_t callType)
729{
730    char cmd[MAX_CMD_LENGTH] = {0};
731    int32_t ret = 0;
732    int32_t count = 3;
733    int32_t err = HRIL_ERR_SUCCESS;
734
735    /* call type
736     * 0: Voice call
737     * 1: Video call: send one-way video, two-way voice
738     * 2: Video call: one-way receiving video, two-way voice
739     * 3: Video call: two-way video, two-way voice
740     */
741    ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CHLD=3");
742    if (ret < 0) {
743        TELEPHONY_LOGE("GenerateCommand is failed!");
744        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
745        return;
746    }
747    // "Adds a held call to the conversation"
748    if (callType >= 0 && callType <= count) {
749        long timeout = DEFAULT_TIMEOUT;
750        ret = SendCommandLock(cmd, NULL, timeout, NULL);
751        if (ret != HRIL_ERR_SUCCESS) {
752            TELEPHONY_LOGE("ATA send failed");
753            err = HRIL_ERR_CMD_SEND_FAILURE;
754        }
755    } else {
756        TELEPHONY_LOGE("onRequest HREQ_CALL_COMBINE_CONFERENCE args error!!! \n");
757        err = HRIL_ERR_INVALID_PARAMETER;
758    }
759    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
760    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
761}
762
763void ReqSeparateConference(const ReqDataInfo *requestInfo, int32_t callIndex, int32_t callType)
764{
765    char cmd[MAX_CMD_LENGTH] = {0};
766    int32_t ret = 0;
767    int32_t count = 3;
768    int32_t err = HRIL_ERR_SUCCESS;
769    ResponseInfo *pResponse = NULL;
770
771    // Make sure that party is in a valid range.
772    // (Note: The Telephony middle layer imposes a range of 1 to 7.
773    // It's sufficient for us to just make sure it's single digit.)
774    if ((callIndex > 0) && (callType >= 0 && callType <= count)) {
775        ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CHLD=2%d", callIndex);
776        if (ret < 0) {
777            TELEPHONY_LOGE("GenerateCommand is failed!");
778            OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
779            return;
780        }
781        ret = SendCommandLock(cmd, NULL, 0, &pResponse);
782        if (ret != HRIL_ERR_SUCCESS) {
783            TELEPHONY_LOGE("ATA send failed");
784            err = HRIL_ERR_CMD_SEND_FAILURE;
785        } else {
786            if (pResponse == NULL || !pResponse->success) {
787                TELEPHONY_LOGE("ATA send failed");
788                err = HRIL_ERR_GENERIC_FAILURE;
789            }
790        }
791    } else {
792        TELEPHONY_LOGE("onRequest req split args error!!!");
793        err = HRIL_ERR_INVALID_PARAMETER;
794    }
795    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
796    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
797    FreeResponseInfo(pResponse);
798}
799
800void ReqCallSupplement(const ReqDataInfo *requestInfo, int32_t type)
801{
802    char cmd[MAX_CMD_LENGTH] = {0};
803    int32_t ret = 0;
804    int32_t err = HRIL_ERR_SUCCESS;
805    ResponseInfo *pResponse = NULL;
806
807    switch (type) {
808        case TYPE_HANG_UP_HOLD_WAIT: {
809            ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CHLD=0");
810            if (ret < 0) {
811                TELEPHONY_LOGE("GenerateCommand is failed!");
812                OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
813                return;
814            }
815            break;
816        }
817        case TYPE_HANG_UP_ACTIVE: {
818            ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CHLD=1");
819            if (ret < 0) {
820                TELEPHONY_LOGE("GenerateCommand is failed!");
821                OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
822                return;
823            }
824            break;
825        }
826        default: {
827            TELEPHONY_LOGW("ReqCallSupplement warring, type is invalid");
828            struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_INVALID_PARAMETER, HRIL_RESPONSE, 0);
829            OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
830            FreeResponseInfo(pResponse);
831            return;
832        }
833    }
834
835    const long timeout = 3000;
836    ret = SendCommandLock(cmd, NULL, timeout, &pResponse);
837    if (ret != HRIL_ERR_SUCCESS) {
838        TELEPHONY_LOGE("ReqCallSupplement cmd send failed");
839        err = HRIL_ERR_CMD_SEND_FAILURE;
840    } else {
841        if (pResponse == NULL || !pResponse->success) {
842            TELEPHONY_LOGE("cmd send return error");
843            err = HRIL_ERR_GENERIC_FAILURE;
844        }
845    }
846
847    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
848    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
849    FreeResponseInfo(pResponse);
850}
851
852void ReqGetCallWaiting(const ReqDataInfo *requestInfo)
853{
854    int32_t err = HRIL_ERR_SUCCESS;
855    ResponseInfo *pResponse = NULL;
856    HRilCallWaitResult hrilCallWaitResult = {0};
857    char *line = NULL;
858    const long timeout = 80000;
859    err = SendCommandLock("AT+CCWA=1,2,1", "+CCWA:", timeout, &pResponse);
860    if (err != HRIL_ERR_SUCCESS) {
861        TELEPHONY_LOGE("ReqGetCallWaiting return, CCWA send failed");
862        err = HRIL_ERR_CMD_SEND_FAILURE;
863        struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
864        OnCallReport(
865            GetSlotId(requestInfo), reportInfo, (const uint8_t *)&hrilCallWaitResult, sizeof(HRilCallWaitResult));
866        return;
867    }
868    if (pResponse == NULL || !pResponse->success) {
869        TELEPHONY_LOGE("Get CCWA return ERROR");
870        err = HRIL_ERR_GENERIC_FAILURE;
871    } else {
872        if (pResponse->head != NULL) {
873            line = pResponse->head->data;
874            SkipATPrefix(&line);
875            NextInt(&line, &hrilCallWaitResult.status);
876            NextInt(&line, &hrilCallWaitResult.classCw);
877        } else {
878            TELEPHONY_LOGE("ERROR: ReqGetCallWaiting pResponse->head is null");
879            err = HRIL_ERR_GENERIC_FAILURE;
880        }
881    }
882    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
883    OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&hrilCallWaitResult, sizeof(HRilCallWaitResult));
884    FreeResponseInfo(pResponse);
885}
886
887void ReqSetCallWaiting(const ReqDataInfo *requestInfo, int32_t active)
888{
889    char cmd[MAX_CMD_LENGTH] = {0};
890    int32_t err = HRIL_ERR_SUCCESS;
891    ResponseInfo *pResponse = NULL;
892    const long timeout = 500;
893
894    int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CCWA=1,%d,1", active);
895    if (ret < 0) {
896        TELEPHONY_LOGE("GenerateCommand is failed!");
897        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
898        return;
899    }
900    err = SendCommandLock(cmd, NULL, timeout, &pResponse);
901    if (err != HRIL_ERR_SUCCESS) {
902        TELEPHONY_LOGE("ReqSetCallWaiting return, CCWA send failed");
903        err = HRIL_ERR_CMD_SEND_FAILURE;
904    } else {
905        if (pResponse == NULL || !pResponse->success) {
906            err = HRIL_ERR_GENERIC_FAILURE;
907        }
908    }
909    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
910    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
911    FreeResponseInfo(pResponse);
912}
913
914void ReqSetCallTransferInfo(const ReqDataInfo *requestInfo, HRilCFInfo info)
915{
916    int32_t numType;
917    const int32_t NUM_F = 145;
918    const int32_t NUM_S = 129;
919    int32_t err = HRIL_ERR_SUCCESS;
920    ResponseInfo *pResponse = NULL;
921    char cmd[MAX_CMD_LENGTH] = {0};
922
923    if (info.reason > CALL_FORWARD_REASON_ALL_CCF || info.mode > CALL_FORWARD_MODE_ERASURE) {
924        TELEPHONY_LOGE("ReqSetCallTransferInfo call forwarding parameter err!!");
925        struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_INVALID_PARAMETER, HRIL_RESPONSE, 0);
926        OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
927        return;
928    }
929
930    if (info.number != NULL && info.number[0] == '+') {
931        numType = NUM_F;
932    } else {
933        numType = NUM_S;
934    }
935
936    int32_t ret = GenerateCommand(
937        cmd, MAX_CMD_LENGTH, "AT+CCFC=%d,%d,\"%s\",%d,%d", info.reason, info.mode, info.number, numType, info.classx);
938    if (ret < 0) {
939        TELEPHONY_LOGE("GenerateCommand is failed!");
940        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
941        return;
942    }
943    err = SendCommandLock(cmd, NULL, 0, &pResponse);
944    if (err != HRIL_ERR_SUCCESS) {
945        TELEPHONY_LOGE("CCFC send failed");
946        err = HRIL_ERR_CMD_SEND_FAILURE;
947    } else {
948        if (pResponse == NULL || !pResponse->success) {
949            err = HRIL_ERR_GENERIC_FAILURE;
950        }
951    }
952    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
953    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
954    FreeResponseInfo(pResponse);
955}
956
957void ReqGetCallTransferInfo(const ReqDataInfo *requestInfo, int32_t reason)
958{
959    char cmd[MAX_CMD_LENGTH] = {0};
960    int32_t err = HRIL_ERR_SUCCESS;
961    ResponseInfo *pResponse = NULL;
962    HRilCFQueryInfo queryInfo = {0};
963    char *line = NULL;
964
965    if (reason > CALL_FORWARD_REASON_ALL_CCF) {
966        TELEPHONY_LOGE("ReqGetCallTransferInfo call forwarding parameter err!!");
967        struct ReportInfo reportInfo = CreateReportInfo(requestInfo, HRIL_ERR_INVALID_PARAMETER, HRIL_RESPONSE, 0);
968        OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
969        return;
970    }
971    int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CCFC=%d,2", reason);
972    if (ret < 0) {
973        TELEPHONY_LOGE("GenerateCommand is failed!");
974        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
975        return;
976    }
977    err = SendCommandLock(cmd, "+CCFC", 0, &pResponse);
978    if (err != HRIL_ERR_SUCCESS) {
979        TELEPHONY_LOGE("CCFC send failed");
980        err = HRIL_ERR_CMD_SEND_FAILURE;
981    } else if (pResponse != NULL) {
982        if (!pResponse->success) {
983            TELEPHONY_LOGE("CCFC send and return ERROR");
984            err = HRIL_ERR_GENERIC_FAILURE;
985        } else {
986            if (pResponse->head) {
987                line = pResponse->head->data;
988                SkipATPrefix(&line);
989                NextInt(&line, &queryInfo.status);
990                NextInt(&line, &queryInfo.classx);
991                NextStr(&line, &queryInfo.number);
992                NextInt(&line, &queryInfo.type);
993            } else {
994                TELEPHONY_LOGE("ERROR: ReqGetCallTransferInfo pResponse->head is null");
995                err = HRIL_ERR_GENERIC_FAILURE;
996            }
997        }
998    } else {
999        TELEPHONY_LOGE("ERROR: ReqGetCallTransferInfo pResponse is null");
1000        err = HRIL_ERR_GENERIC_FAILURE;
1001    }
1002    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1003    OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&queryInfo, sizeof(queryInfo));
1004    FreeResponseInfo(pResponse);
1005}
1006
1007void ReqGetCallRestriction(const ReqDataInfo *requestInfo, const char *fac)
1008{
1009    long long timeOut = DEFAULT_TIMEOUT_CLCK;
1010    int32_t err = HRIL_ERR_SUCCESS;
1011    ResponseInfo *pResponse = NULL;
1012    HRilCallRestrictionResult result = {0};
1013    char *line = NULL;
1014    char cmd[MAX_CMD_LENGTH] = {0};
1015
1016    int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CLCK=\"%s\",2", fac);
1017    if (ret < 0) {
1018        TELEPHONY_LOGE("GenerateCommand is failed!");
1019        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
1020        return;
1021    }
1022    err = SendCommandLock(cmd, "+CLCK:", timeOut, &pResponse);
1023    if (err != HRIL_ERR_SUCCESS) {
1024        TELEPHONY_LOGE("CLCK send failed err = %{public}d", err);
1025        err = HRIL_ERR_CMD_SEND_FAILURE;
1026    } else if (pResponse != NULL) {
1027        if (!pResponse->success) {
1028            TELEPHONY_LOGE("ERROR: ReqGetCallRestriction return ERROR");
1029            err = HRIL_ERR_GENERIC_FAILURE;
1030        } else {
1031            if (pResponse->head) {
1032                line = pResponse->head->data;
1033                SkipATPrefix(&line);
1034                NextInt(&line, &result.status);
1035                NextInt(&line, &result.classCw);
1036            } else {
1037                TELEPHONY_LOGE("ERROR: ReqGetCallRestriction pResponse->head is null");
1038                err = HRIL_ERR_GENERIC_FAILURE;
1039            }
1040        }
1041    } else {
1042        TELEPHONY_LOGE("ERROR: ReqGetCallRestriction pResponse is null");
1043        err = HRIL_ERR_GENERIC_FAILURE;
1044    }
1045    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1046    OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&result, sizeof(HRilCallRestrictionResult));
1047    FreeResponseInfo(pResponse);
1048}
1049
1050void ReqSetCallRestriction(const ReqDataInfo *requestInfo, CallRestrictionInfo info)
1051{
1052    long long timeOut = DEFAULT_TIMEOUT;
1053    char cmd[MAX_CMD_LENGTH] = {0};
1054    int32_t err = HRIL_ERR_SUCCESS;
1055    ResponseInfo *pResponse = NULL;
1056
1057    int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CLCK=\"%s\",%d,\"%s\"", info.fac, info.mode, info.password);
1058    if (ret < 0) {
1059        TELEPHONY_LOGE("GenerateCommand is failed!");
1060        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
1061        return;
1062    }
1063    err = SendCommandLock(cmd, NULL, timeOut, &pResponse);
1064    if (err != HRIL_ERR_SUCCESS) {
1065        TELEPHONY_LOGE("CLCK send failed");
1066        err = HRIL_ERR_CMD_SEND_FAILURE;
1067    } else {
1068        if (pResponse == NULL || !pResponse->success) {
1069            err = HRIL_ERR_GENERIC_FAILURE;
1070        }
1071    }
1072    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1073    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
1074    FreeResponseInfo(pResponse);
1075}
1076
1077void ReqSetBarringPassword(const ReqDataInfo *requestInfo, HRilSetBarringInfo info)
1078{
1079    long long timeOut = DEFAULT_TIMEOUT;
1080    char cmd[MAX_CMD_LENGTH] = { 0 };
1081    ResponseInfo *pResponse = NULL;
1082
1083    int32_t ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CPWD=\"%s\",\"%s\",\"%s\"", info.fac,
1084        info.oldPassword, info.newPassword);
1085    if (ret < 0) {
1086        TELEPHONY_LOGE("GenerateCommand is failed!");
1087        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
1088        return;
1089    }
1090    int32_t err = SendCommandLock(cmd, NULL, timeOut, &pResponse);
1091    if (err != HRIL_ERR_SUCCESS) {
1092        TELEPHONY_LOGE("CPWD send failed");
1093        err = HRIL_ERR_CMD_SEND_FAILURE;
1094    } else if (pResponse != NULL) {
1095        if (!pResponse->success) {
1096            TELEPHONY_LOGE("ERROR: ReqSetBarringPassword return ERROR");
1097            err = HRIL_ERR_GENERIC_FAILURE;
1098        }
1099    } else {
1100        TELEPHONY_LOGE("ERROR: ReqSetBarringPassword pResponse is null");
1101        err = HRIL_ERR_GENERIC_FAILURE;
1102    }
1103    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1104    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
1105    FreeResponseInfo(pResponse);
1106}
1107
1108void ReqGetCallPreferenceMode(const ReqDataInfo *requestInfo)
1109{
1110    char *line = NULL;
1111    int32_t mode = VENDOR_FAIL;
1112    int32_t ret = VENDOR_FAIL;
1113    int32_t err = HRIL_ERR_SUCCESS;
1114    ResponseInfo *pResponse = NULL;
1115
1116    ModemReportErrorInfo errInfo = InitModemReportErrorInfo();
1117    ret = SendCommandLock("AT+CEVDP?", "+CEVDP:", 0, &pResponse);
1118    if (ret || pResponse == NULL || !pResponse->success) {
1119        err = (ret != HRIL_ERR_SUCCESS) ? HRIL_ERR_CMD_SEND_FAILURE : err;
1120        TELEPHONY_LOGE("cmd send failed, err:%{public}d", err);
1121        OnCallReportErrorMessages(requestInfo, err, pResponse);
1122        return;
1123    }
1124    if (pResponse->head) {
1125        line = pResponse->head->data;
1126        err = SkipATPrefix(&line);
1127        if (err == 0) {
1128            err = NextInt(&line, &mode);
1129            TELEPHONY_LOGI("mode:%{public}d", mode);
1130        } else {
1131            TELEPHONY_LOGE("response error");
1132        }
1133    } else {
1134        TELEPHONY_LOGE("ERROR: pResponse->head is null");
1135        err = HRIL_ERR_GENERIC_FAILURE;
1136    }
1137    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1138    reportInfo.modemErrInfo = errInfo;
1139    OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&mode, sizeof(mode));
1140    FreeResponseInfo(pResponse);
1141}
1142
1143void ReqSetCallPreferenceMode(const ReqDataInfo *requestInfo, int32_t mode)
1144{
1145    int32_t ret = VENDOR_FAIL;
1146    int32_t err = HRIL_ERR_SUCCESS;
1147    int32_t value = HRIL_CALL_MODE_CS_1ST_PS_2ND;
1148    char cmd[MAX_CMD_LENGTH] = {0};
1149    ResponseInfo *pResponse = NULL;
1150
1151    ModemReportErrorInfo errInfo = InitModemReportErrorInfo();
1152    value = mode;
1153    ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CEVDP=%d", value);
1154    if (ret < 0) {
1155        TELEPHONY_LOGE("GenerateCommand is failed!");
1156        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
1157        return;
1158    }
1159    ret = SendCommandLock(cmd, NULL, 0, &pResponse);
1160    if (ret || (pResponse != NULL && !pResponse->success)) {
1161        errInfo = GetReportErrorInfo(pResponse);
1162        err = errInfo.errorNo;
1163        TELEPHONY_LOGE("cmd send failed, err:%{public}d", ret ? ret : err);
1164    }
1165    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1166    reportInfo.modemErrInfo = errInfo;
1167    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
1168    FreeResponseInfo(pResponse);
1169}
1170
1171void ReqSetUssd(const ReqDataInfo *requestInfo, const char *str)
1172{
1173    int32_t ret;
1174    int32_t err = HRIL_ERR_SUCCESS;
1175    char cmd[MAX_CMD_LENGTH] = {0};
1176    ResponseInfo *pResponse = NULL;
1177    ModemReportErrorInfo errInfo = {};
1178
1179    ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CUSD=1, \"% s\" , 15", str);
1180    if (ret < 0) {
1181        TELEPHONY_LOGE("GenerateCommand is failed!");
1182        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
1183        return;
1184    }
1185    ret = SendCommandLock(cmd, NULL, 0, &pResponse);
1186    if (ret || (pResponse != NULL && !pResponse->success)) {
1187        errInfo = GetReportErrorInfo(pResponse);
1188        err = errInfo.errorNo;
1189        TELEPHONY_LOGE("cmd send failed, err:%{public}d", ret ? ret : err);
1190    }
1191    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1192    reportInfo.modemErrInfo = errInfo;
1193    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
1194    FreeResponseInfo(pResponse);
1195}
1196
1197void ReqCloseUnFinishedUssd(const ReqDataInfo *requestInfo)
1198{
1199    int32_t ret;
1200    int32_t err = HRIL_ERR_SUCCESS;
1201    ResponseInfo *pResponse = NULL;
1202    ModemReportErrorInfo errInfo = {};
1203
1204    ret = SendCommandLock("AT+CUSD=2", NULL, 0, &pResponse);
1205    if (ret || (pResponse != NULL && !pResponse->success)) {
1206        errInfo = GetReportErrorInfo(pResponse);
1207        err = errInfo.errorNo;
1208        TELEPHONY_LOGE("cmd send failed, err:%{public}d", ret ? ret : err);
1209    }
1210    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1211    reportInfo.modemErrInfo = errInfo;
1212    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
1213    FreeResponseInfo(pResponse);
1214}
1215
1216void ReqGetUssd(const ReqDataInfo *requestInfo)
1217{
1218    int32_t ret;
1219    char *line = NULL;
1220    int32_t cusd = 0;
1221    int32_t err = HRIL_ERR_SUCCESS;
1222    ResponseInfo *pResponse = NULL;
1223    ModemReportErrorInfo errInfo = {};
1224
1225    ret = SendCommandLock("AT+CUSD?", "+CUSD:", 0, &pResponse);
1226    if (ret || pResponse == NULL || !pResponse->success) {
1227        err = ret ? ret : err;
1228        TELEPHONY_LOGE("cmd send failed, err:%{public}d", err);
1229        OnCallReportErrorMessages(requestInfo, err, pResponse);
1230        return;
1231    }
1232    if (pResponse->head) {
1233        line = pResponse->head->data;
1234        err = SkipATPrefix(&line);
1235        if (err == 0) {
1236            err = NextInt(&line, &cusd);
1237            TELEPHONY_LOGI("+CUSD:%{public}d", cusd);
1238        } else {
1239            TELEPHONY_LOGE("response error");
1240        }
1241    } else {
1242        TELEPHONY_LOGE("ERROR: pResponse->head is null");
1243        err = HRIL_ERR_GENERIC_FAILURE;
1244    }
1245    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1246    reportInfo.modemErrInfo = errInfo;
1247    OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&cusd, sizeof(cusd));
1248    FreeResponseInfo(pResponse);
1249}
1250
1251void ReqSetMute(const ReqDataInfo *requestInfo, int32_t mute)
1252{
1253    int32_t ret;
1254    int32_t err = HRIL_ERR_SUCCESS;
1255    char cmd[MAX_CMD_LENGTH] = {0};
1256    ResponseInfo *pResponse = NULL;
1257    ModemReportErrorInfo errInfo = {};
1258
1259    ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT+CMUT=%d ", mute);
1260    if (ret < 0) {
1261        TELEPHONY_LOGE("GenerateCommand is failed!");
1262        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
1263        return;
1264    }
1265    ret = SendCommandLock(cmd, NULL, 0, &pResponse);
1266    if (ret || (pResponse != NULL && !pResponse->success)) {
1267        errInfo = GetReportErrorInfo(pResponse);
1268        err = errInfo.errorNo;
1269        TELEPHONY_LOGE("cmd send failed, err:%{public}d", ret ? ret : err);
1270    }
1271    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1272    reportInfo.modemErrInfo = errInfo;
1273    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
1274    FreeResponseInfo(pResponse);
1275}
1276
1277void ReqGetMute(const ReqDataInfo *requestInfo)
1278{
1279    int32_t ret;
1280    char *line = NULL;
1281    int32_t mute = 0;
1282    int32_t err = HRIL_ERR_SUCCESS;
1283    ResponseInfo *pResponse = NULL;
1284    ModemReportErrorInfo errInfo = {};
1285
1286    ret = SendCommandLock("AT+CMUT?", "+CMUT:", 0, &pResponse);
1287    if (ret || pResponse == NULL || !pResponse->success) {
1288        err = ret ? ret : err;
1289        TELEPHONY_LOGE("cmd send failed, err:%{public}d", err);
1290        OnCallReportErrorMessages(requestInfo, err, pResponse);
1291        return;
1292    }
1293    if (pResponse->head) {
1294        line = pResponse->head->data;
1295        err = SkipATPrefix(&line);
1296        if (err == 0) {
1297            err = NextInt(&line, &mute);
1298            TELEPHONY_LOGI("+CMUT:%{public}d", mute);
1299        } else {
1300            TELEPHONY_LOGE("response error");
1301        }
1302    } else {
1303        TELEPHONY_LOGE("ERROR: pResponse->head is null");
1304        err = HRIL_ERR_GENERIC_FAILURE;
1305    }
1306    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1307    reportInfo.modemErrInfo = errInfo;
1308    OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&mute, sizeof(mute));
1309    FreeResponseInfo(pResponse);
1310}
1311
1312static int32_t CallCmdXLEMA(const char *lineCmd, HRilEmergencyInfo *outCall)
1313{
1314    char *pLine = (char *)lineCmd;
1315
1316    if (pLine == NULL || outCall == NULL) {
1317        TELEPHONY_LOGE("src or desc pointer is null.");
1318        return HRIL_ERR_NULL_POINT;
1319    }
1320
1321    if (SkipATPrefix(&pLine) < 0) {
1322        return HRIL_ERR_NULL_POINT;
1323    }
1324    if (NextInt(&pLine, &outCall->index) < 0) {
1325        return HRIL_ERR_NULL_POINT;
1326    }
1327    if (NextInt(&pLine, &outCall->total) < 0) {
1328        return HRIL_ERR_NULL_POINT;
1329    }
1330    if (NextStr(&pLine, &outCall->eccNum) < 0) {
1331        return HRIL_ERR_NULL_POINT;
1332    }
1333    if (NextInt(&pLine, &outCall->category) < 0) {
1334        return HRIL_ERR_NULL_POINT;
1335    }
1336    if (NextInt(&pLine, &outCall->simpresent) < 0) {
1337        return HRIL_ERR_NULL_POINT;
1338    }
1339    if (NextStr(&pLine, &outCall->mcc) < 0) {
1340        return HRIL_ERR_NULL_POINT;
1341    }
1342    if (NextInt(&pLine, &outCall->abnormalService) < 0) {
1343        return HRIL_ERR_NULL_POINT;
1344    }
1345    return HRIL_ERR_SUCCESS;
1346}
1347
1348static int32_t InitGetEmergencyCallList(const ResponseInfo *pResponse, int32_t *callNum,
1349    HRilEmergencyInfo **pEmergencyCalls)
1350{
1351    int32_t ret;
1352    int32_t callNumTmp = 0;
1353    Line *pLine = NULL;
1354    HRilEmergencyInfo *pEmergencyCallsTmp = NULL;
1355
1356    if (pResponse == NULL || pEmergencyCalls == NULL || callNum == NULL) {
1357        TELEPHONY_LOGE("params: %{public}p,%{public}p,%{public}p", pResponse, callNum, pEmergencyCalls);
1358        return HRIL_ERR_NULL_POINT;
1359    }
1360
1361    *callNum = 0;
1362    *pEmergencyCalls = NULL;
1363
1364    for (pLine = pResponse->head; pLine != NULL; pLine = pLine->next) {
1365        callNumTmp++;
1366    }
1367    if (!callNumTmp) {
1368        callNumTmp++; // Malloc size cannot be 0.
1369    }
1370    pEmergencyCallsTmp = (HRilEmergencyInfo *)malloc(callNumTmp * sizeof(HRilEmergencyInfo));
1371    if (pEmergencyCallsTmp == NULL) {
1372        TELEPHONY_LOGE("ReqGetCallList malloc pCalls failure");
1373        return HRIL_ERR_MEMORY_FULL;
1374    }
1375    ret = memset_s(
1376        pEmergencyCallsTmp, callNumTmp * sizeof(HRilEmergencyInfo), 0, callNumTmp * sizeof(HRilEmergencyInfo));
1377    if (ret != EOK) {
1378        TELEPHONY_LOGE("memset_s is failed!");
1379        free(pEmergencyCallsTmp);
1380        pEmergencyCallsTmp = NULL;
1381        return ret;
1382    }
1383
1384    *pEmergencyCalls = pEmergencyCallsTmp;
1385    *callNum = callNumTmp;
1386
1387    return HRIL_ERR_SUCCESS;
1388}
1389
1390int32_t BuildGetEmergencyCallList(const ReqDataInfo *requestInfo, ResponseInfo *response)
1391{
1392    int32_t ret = 0;
1393    int32_t callNum = 0;
1394    int32_t validCallNum = 0;
1395    int32_t err = HRIL_ERR_SUCCESS;
1396    Line *pLine = NULL;
1397    ResponseInfo *pResponse = response;
1398    HRilEmergencyInfo *pEmergencyCalls = NULL;
1399
1400    if (pResponse == NULL || requestInfo == NULL) {
1401        TELEPHONY_LOGE("response or requestInfo is null.");
1402        return HRIL_ERR_NULL_POINT;
1403    }
1404    if (pResponse->success == 0) {
1405        TELEPHONY_LOGE("send cmd return ERROR");
1406        err = HRIL_ERR_GENERIC_FAILURE;
1407    }
1408
1409    ret = InitGetEmergencyCallList(pResponse, &callNum, &pEmergencyCalls);
1410    if (ret != HRIL_ERR_SUCCESS) {
1411        TELEPHONY_LOGE("init command failed: %{public}d", ret);
1412        return ret;
1413    }
1414
1415    for (pLine = pResponse->head; pLine != NULL && validCallNum < callNum; pLine = pLine->next) {
1416        ret = CallCmdXLEMA(pLine->data, pEmergencyCalls + validCallNum);
1417        if (ret != 0) {
1418            TELEPHONY_LOGE("Parse CLCC data is fail. ret:%{public}d", ret);
1419            continue;
1420        }
1421        validCallNum++;
1422    }
1423
1424    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1425    OnCallReport(
1426        GetSlotId(requestInfo), reportInfo, (const uint8_t *)pEmergencyCalls, sizeof(HRilEmergencyInfo) * validCallNum);
1427    FreeResponseInfo(pResponse);
1428    free(pEmergencyCalls);
1429    return HRIL_ERR_SUCCESS;
1430}
1431
1432void ReqGetEmergencyCallList(const ReqDataInfo *requestInfo)
1433{
1434    int32_t ret;
1435    ResponseInfo *pResponse = NULL;
1436    int32_t err = HRIL_ERR_SUCCESS;
1437    long timeOut = DEFAULT_TIMEOUT;
1438
1439    ret = SendCommandLock("AT^XLEMA?", "^XLEMA:", timeOut, &pResponse);
1440    if (ret || (pResponse != NULL && !pResponse->success)) {
1441        err = (ret != HRIL_ERR_SUCCESS) ? HRIL_ERR_CMD_SEND_FAILURE : err;
1442        TELEPHONY_LOGE("cmd send failed, err:%{public}d", err);
1443        OnCallReportErrorMessages(requestInfo, err, pResponse);
1444        return;
1445    }
1446    err = BuildGetEmergencyCallList(requestInfo, pResponse);
1447    if (err != HRIL_ERR_SUCCESS) {
1448        TELEPHONY_LOGE("Build Call Info List is failed.");
1449        OnCallReportErrorMessages(requestInfo, err, pResponse);
1450    }
1451}
1452
1453void ReqSetEmergencyCallList(const ReqDataInfo *requestInfo, HRilEmergencyInfo *emergencyInfo, const int len)
1454{
1455    TELEPHONY_LOGI("ReqSetEmergencyCallList start");
1456    int32_t ret = 0;
1457    int32_t err = HRIL_ERR_SUCCESS;
1458    char cmd[MAX_CMD_LENGTH] = {0};
1459    ResponseInfo *pResponse = NULL;
1460    ModemReportErrorInfo errInfo = {};
1461    for (int i = 0; i  < len; i++) {
1462        ret = GenerateCommand(cmd, MAX_CMD_LENGTH, "AT^NVM=%d,%d,\"%s\",%d,%d,%s,%d", emergencyInfo[i].index,
1463            emergencyInfo[i].total, emergencyInfo[i].eccNum, emergencyInfo[i].category, emergencyInfo[i].simpresent,
1464            emergencyInfo[i].mcc, emergencyInfo[i].abnormalService);
1465        if (ret < 0) {
1466            TELEPHONY_LOGE("GenerateCommand is failed!");
1467            OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
1468            return;
1469        }
1470        ret = SendCommandLock(cmd, NULL, 0, &pResponse);
1471        if (ret || (pResponse != NULL && !pResponse->success)) {
1472            errInfo = GetReportErrorInfo(pResponse);
1473            err = errInfo.errorNo;
1474            TELEPHONY_LOGE("cmd send failed, err:%{public}d", ret ? ret : err);
1475        }
1476    }
1477    TELEPHONY_LOGI("ReqSetEmergencyCallList end");
1478    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1479    reportInfo.modemErrInfo = errInfo;
1480    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
1481    FreeResponseInfo(pResponse);
1482}
1483
1484void ReqGetCallFailReason(const ReqDataInfo *requestInfo)
1485{
1486    int32_t err = HRIL_ERR_SUCCESS;
1487    ResponseInfo *pResponse = NULL;
1488    ModemReportErrorInfo errInfo = {};
1489
1490    if (lastCcCause == HRIL_ERR_CALL_CAUSE) {
1491        TELEPHONY_LOGE("lastCcCause is none!");
1492        OnCallReportErrorMessages(requestInfo, HRIL_ERR_GENERIC_FAILURE, NULL);
1493        return;
1494    }
1495
1496    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1497    reportInfo.modemErrInfo = errInfo;
1498    OnCallReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&lastCcCause, sizeof(lastCcCause));
1499    FreeResponseInfo(pResponse);
1500}
1501
1502void ReqSetVonrSwitch(const ReqDataInfo *requestInfo, int32_t status)
1503{
1504    int32_t err = HRIL_ERR_SUCCESS;
1505    ResponseInfo *pResponse = NULL;
1506
1507    struct ReportInfo reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);
1508    OnCallReport(GetSlotId(requestInfo), reportInfo, NULL, 0);
1509    FreeResponseInfo(pResponse);
1510}
1511