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 "hril_manager.h"
17
18#include <cstring>
19#include "hril_base.h"
20#include "hril_event_map.h"
21#include "hril_notification.h"
22#include "hril_request.h"
23#include "parameter.h"
24
25namespace OHOS {
26namespace Telephony {
27constexpr const char *MODULE_HRIL_CALL = "hrilCall";
28constexpr const char *MODULE_HRIL_DATA = "hrilData";
29constexpr const char *MODULE_HRIL_MODEM = "hrilModem";
30constexpr const char *MODULE_HRIL_SIM = "hrilSim";
31constexpr const char *MODULE_HRIL_NETWORK = "hrilNetwork";
32constexpr const char *MODULE_HRIL_SMS = "hrilSms";
33const std::string RUNNINGLOCK_NAME = "HRilRunningLock";
34static bool g_isHrilManagerDestory = false;
35static std::shared_ptr<HRilManager> g_manager = std::make_shared<HRilManager>();
36static pthread_mutex_t dispatchMutex = PTHREAD_MUTEX_INITIALIZER;
37std::shared_ptr<HRilManager> HRilManager::manager_ = g_manager;
38std::unordered_map<int32_t, int32_t> HRilManager::notificationMap_ = {
39#include "hril_notification_map.h"
40};
41
42#ifdef ABILITY_POWER_SUPPORT
43constexpr int32_t RUNNINGLOCK_TIMEOUTMS_LASTING = -1;
44using namespace OHOS::HDI::Power::V1_2;
45#endif
46
47static bool IsHrilManagerValid()
48{
49    if (g_isHrilManagerDestory || g_manager == nullptr) {
50        return false;
51    }
52    return true;
53}
54
55int32_t HRilManager::GetMaxSimSlotCount()
56{
57    return hrilSimSlotCount_;
58}
59
60ReqDataInfo *HRilManager::CreateHRilRequest(int32_t serial, int32_t slotId, int32_t request)
61{
62    ReqDataInfo *requestInfo = nullptr;
63    HRilSimSlotId simSlotId = (HRilSimSlotId)slotId;
64    requestInfo = (ReqDataInfo *)malloc(sizeof(ReqDataInfo));
65    if (requestInfo == nullptr) {
66        return nullptr;
67    }
68    requestInfo->slotId = simSlotId;
69    requestInfo->request = request;
70    requestInfo->serial = serial;
71    std::lock_guard<std::mutex> lockRequest(requestListLock_);
72    auto iter = requestList_.find(request);
73    if (iter != requestList_.end()) {
74        std::list<ReqDataInfo *> &reqDataSet = iter->second;
75        reqDataSet.push_back(requestInfo);
76        TELEPHONY_LOGD("CreateHRilRequest requestId=%{public}d, list size: %{public}zu", request, reqDataSet.size());
77    } else {
78        TELEPHONY_LOGD("CreateHRilRequest create requestList, requestId=%{public}d", request);
79        std::list<ReqDataInfo *> reqDataSet;
80        reqDataSet.push_back(requestInfo);
81        requestList_.emplace(request, reqDataSet);
82    }
83    return requestInfo;
84}
85
86void HRilManager::ReleaseHRilRequest(int32_t request, ReqDataInfo *requestInfo)
87{
88    std::lock_guard<std::mutex> lockRequest(requestListLock_);
89    auto iter = requestList_.find(request);
90    if (iter != requestList_.end()) {
91        std::list<ReqDataInfo *> &reqDataSet = iter->second;
92        auto it = find(reqDataSet.begin(), reqDataSet.end(), requestInfo);
93        if (it != reqDataSet.end()) {
94            if (*it != nullptr) {
95                free(*it);
96            }
97            reqDataSet.erase(it);
98        }
99    }
100}
101
102template<typename ClassTypePtr, typename FuncType, typename... ParamTypes>
103inline int32_t HRilManager::TaskSchedule(
104    const std::string module, ClassTypePtr &_obj, FuncType &&_func, ParamTypes &&... _args)
105{
106    pthread_mutex_lock(&dispatchMutex);
107    if (_func == nullptr || _obj == nullptr || g_isHrilManagerDestory) {
108        TELEPHONY_LOGE(
109            "%{public}s func or obj is null pointer or destroy %{public}d", module.c_str(), g_isHrilManagerDestory);
110        pthread_mutex_unlock(&dispatchMutex);
111        return HDF_FAILURE;
112    }
113    int32_t ret = (_obj.get()->*(_func))(std::forward<ParamTypes>(_args)...);
114    pthread_mutex_unlock(&dispatchMutex);
115    return ret;
116}
117
118void HRilManager::RegisterCallFuncs(int32_t slotId, const HRilCallReq *callFuncs)
119{
120    if (hrilCall_[slotId] != nullptr) {
121        hrilCall_[slotId]->RegisterCallFuncs(callFuncs);
122    }
123}
124
125void HRilManager::RegisterDataFuncs(int32_t slotId, const HRilDataReq *dataFuncs)
126{
127    if (hrilData_[slotId] != nullptr) {
128        hrilData_[slotId]->RegisterDataFuncs(dataFuncs);
129    }
130}
131
132void HRilManager::RegisterModemFuncs(int32_t slotId, const HRilModemReq *modemFuncs)
133{
134    if (hrilModem_[slotId] != nullptr) {
135        hrilModem_[slotId]->RegisterModemFuncs(modemFuncs);
136    }
137}
138
139void HRilManager::RegisterNetworkFuncs(int32_t slotId, const HRilNetworkReq *networkFuncs)
140{
141    if (hrilNetwork_[slotId] != nullptr) {
142        hrilNetwork_[slotId]->RegisterNetworkFuncs(networkFuncs);
143    }
144}
145
146void HRilManager::RegisterSimFuncs(int32_t slotId, const HRilSimReq *simFuncs)
147{
148    if (hrilSim_[slotId] != nullptr) {
149        hrilSim_[slotId]->RegisterSimFuncs(simFuncs);
150    }
151}
152
153void HRilManager::RegisterSmsFuncs(int32_t slotId, const HRilSmsReq *smsFuncs)
154{
155    if (hrilSms_[slotId] != nullptr) {
156        hrilSms_[slotId]->RegisterSmsFuncs(smsFuncs);
157    }
158}
159
160#ifdef ABILITY_POWER_SUPPORT
161static OHOS::HDI::Power::V1_2::RunningLockInfo FillRunningLockInfo(const std::string &name, int32_t timeoutMs)
162{
163    OHOS::HDI::Power::V1_2::RunningLockInfo filledInfo {};
164    filledInfo.name = name;
165    filledInfo.type = OHOS::HDI::Power::V1_2::RunningLockType::RUNNINGLOCK_BACKGROUND_PHONE;
166    filledInfo.timeoutMs = timeoutMs;
167    filledInfo.uid = static_cast<int32_t>(getuid());
168    filledInfo.pid = static_cast<int32_t>(getpid());
169    return filledInfo;
170}
171
172static void RunningLockCallback(uint8_t *param)
173{
174    if (!IsHrilManagerValid() || param == nullptr) {
175        TELEPHONY_LOGE("check nullptr fail.");
176        return;
177    }
178    int serialNum = *reinterpret_cast<int *>(param);
179    delete param;
180    param = nullptr;
181    std::lock_guard<std::mutex> lockRequest(g_manager->mutexRunningLock_);
182    TELEPHONY_LOGD("RunningLockCallback, serialNum:%{public}d, runningSerialNum_:%{public}d", serialNum,
183        static_cast<int>(g_manager->runningSerialNum_));
184    if (g_manager->powerInterface_ == nullptr || serialNum != static_cast<int>(g_manager->runningSerialNum_)) {
185        return;
186    }
187    g_manager->runningLockCount_ = 0;
188    OHOS::HDI::Power::V1_2::RunningLockInfo filledInfo = FillRunningLockInfo(
189        RUNNINGLOCK_NAME, RUNNINGLOCK_TIMEOUTMS_LASTING);
190    g_manager->powerInterface_->UnholdRunningLock(filledInfo);
191    TELEPHONY_LOGD("RunningLockCallback, UnLock");
192}
193#endif
194
195void HRilManager::ApplyRunningLock(void)
196{
197#ifdef ABILITY_POWER_SUPPORT
198    if (!IsHrilManagerValid() || timerCallback_ == nullptr) {
199        TELEPHONY_LOGE("check nullptr fail.");
200        return;
201    }
202
203    std::lock_guard<std::mutex> lockRequest(mutexRunningLock_);
204    if (powerInterface_ != nullptr) {
205        OHOS::HDI::Power::V1_2::RunningLockInfo filledInfo = FillRunningLockInfo(
206            RUNNINGLOCK_NAME, RUNNINGLOCK_TIMEOUTMS_LASTING);
207        powerInterface_->HoldRunningLock(filledInfo);
208        struct timeval tv = { 0, RUNNING_LOCK_DEFAULT_TIMEOUT_US };
209        runningLockCount_++;
210        runningSerialNum_++;
211        uint8_t *serialNum = reinterpret_cast<uint8_t *>(new int(runningSerialNum_));
212        timerCallback_->HRilSetTimerCallbackInfo(RunningLockCallback, serialNum, &tv);
213        TELEPHONY_LOGD("ApplyRunningLock, runningLockCount_:%{public}d, runningSerialNum_:%{public}d",
214            static_cast<int>(runningLockCount_), static_cast<int>(runningSerialNum_));
215    } else {
216        /* Since the power management subsystem starts slower than the RilAdapter,
217         * the wakelock needs to be recreated.
218         */
219        TELEPHONY_LOGW("The powerInterface_ is nullptr, needs to be recreated.");
220        powerInterface_ = IPowerInterface::Get();
221        if (powerInterface_ == nullptr) {
222            TELEPHONY_LOGE("failed to get power hdi interface");
223        }
224    }
225#endif
226}
227
228void HRilManager::ReleaseRunningLock(void)
229{
230#ifdef ABILITY_POWER_SUPPORT
231    std::lock_guard<std::mutex> lockRequest(mutexRunningLock_);
232    TELEPHONY_LOGD("ReleaseRunningLock, runningLockCount_:%{public}d", static_cast<int>(runningLockCount_));
233    if (powerInterface_ == nullptr) {
234        TELEPHONY_LOGE("powerInterface_ is nullptr");
235        return;
236    }
237    if (runningLockCount_ > 1) {
238        runningLockCount_--;
239    } else {
240        runningLockCount_ = 0;
241        OHOS::HDI::Power::V1_2::RunningLockInfo filledInfo = FillRunningLockInfo(
242            RUNNINGLOCK_NAME, RUNNINGLOCK_TIMEOUTMS_LASTING);
243        powerInterface_->UnholdRunningLock(filledInfo);
244        TELEPHONY_LOGD("ReleaseRunningLock UnLock");
245    }
246#endif
247}
248
249template<typename T>
250void HRilManager::OnReport(std::vector<std::unique_ptr<T>> &subModules, int32_t slotId, const ReportInfo *reportInfo,
251    const uint8_t *response, size_t responseLen)
252{
253    if (reportInfo == nullptr) {
254        TELEPHONY_LOGE("OnReport reportInfo is null!!!");
255        return;
256    }
257    if (slotId < 0 || static_cast<uint32_t>(slotId) >= subModules.size()) {
258        TELEPHONY_LOGE("OnReport subModules out of bounds!!!");
259        return;
260    }
261    switch (reportInfo->type) {
262        case static_cast<int32_t>(ReportType::HRIL_RESPONSE):
263            ReportResponse(subModules, slotId, reportInfo, response, responseLen);
264            break;
265        case static_cast<int32_t>(ReportType::HRIL_NOTIFICATION):
266            ReportNotification(subModules, slotId, reportInfo, response, responseLen);
267            break;
268        default:
269            break;
270    }
271}
272
273template<typename T>
274void HRilManager::ReportResponse(std::vector<std::unique_ptr<T>> &subModules, int32_t slotId,
275    const ReportInfo *reportInfo, const uint8_t *response, size_t responseLen)
276{
277    ReqDataInfo *reqInfo = (ReqDataInfo *)reportInfo->requestInfo;
278    if (reqInfo == nullptr) {
279        TELEPHONY_LOGE("reqInfo is null!!!");
280        return;
281    }
282    auto iter = requestEventMap_.find(reqInfo->request);
283    if (iter != requestEventMap_.end()) {
284        TELEPHONY_LOGI("requestId:%{public}d, event:%{public}s", reqInfo->request, iter->second.c_str());
285    } else {
286        TELEPHONY_LOGD("requestId:%{public}d", reqInfo->request);
287    }
288    HDI::Ril::V1_1::RilRadioResponseInfo responseInfo = {};
289    responseInfo.serial = reqInfo->serial;
290    responseInfo.error = (HDI::Ril::V1_1::RilErrType)reportInfo->error;
291    responseInfo.type = HDI::Ril::V1_1::RIL_RESPONSE_REQUEST;
292    if (HRIL_NEED_ACK == reportInfo->ack) {
293        ApplyRunningLock();
294        responseInfo.type = HDI::Ril::V1_1::RIL_RESPONSE_REQUEST_MUST_ACK;
295    }
296    int32_t requestId = reqInfo->request;
297    ReleaseHRilRequest(requestId, reqInfo);
298    subModules[slotId]->template ProcessResponse<T>(requestId, responseInfo, response, responseLen);
299}
300
301template<typename T>
302void HRilManager::ReportNotification(std::vector<std::unique_ptr<T>> &subModules, int32_t slotId,
303    const ReportInfo *reportInfo, const uint8_t *response, size_t responseLen)
304{
305    int32_t notifyType = HDI::Ril::V1_1::RIL_RESPONSE_NOTICE;
306    auto iter = notificationMap_.find(reportInfo->notifyId);
307    auto event = notificationEventMap_.find(reportInfo->notifyId);
308    if (iter != notificationMap_.end()) {
309        if (reportInfo->notifyId == HNOTI_NETWORK_CS_REG_STATUS_UPDATED ||
310            reportInfo->notifyId == HNOTI_NETWORK_SIGNAL_STRENGTH_UPDATED ||
311            reportInfo->notifyId == HNOTI_CALL_EMERGENCY_NUMBER_REPORT ||
312            reportInfo->notifyId == HNOTI_MODEM_DSDS_MODE_UPDATED) {
313            TELEPHONY_LOGD("notifyId:%{public}d, event:%{public}s", reportInfo->notifyId, event->second.c_str());
314        } else {
315            TELEPHONY_LOGI("notifyId:%{public}d, event:%{public}s", reportInfo->notifyId, event->second.c_str());
316        }
317        if (NEED_LOCK == iter->second) {
318            ApplyRunningLock();
319            notifyType = HDI::Ril::V1_1::RIL_RESPONSE_NOTICE_MUST_ACK;
320        }
321    }
322    subModules[slotId]->template ProcessNotify<T>(notifyType, reportInfo, response, responseLen);
323}
324
325void HRilManager::OnCallReport(
326    int32_t slotId, const ReportInfo *reportInfo, const uint8_t *response, size_t responseLen)
327{
328    OnReport(hrilCall_, slotId, reportInfo, response, responseLen);
329}
330
331void HRilManager::OnDataReport(
332    int32_t slotId, const ReportInfo *reportInfo, const uint8_t *response, size_t responseLen)
333{
334    OnReport(hrilData_, slotId, reportInfo, response, responseLen);
335}
336
337void HRilManager::OnModemReport(
338    int32_t slotId, const ReportInfo *reportInfo, const uint8_t *response, size_t responseLen)
339{
340    OnReport(hrilModem_, slotId, reportInfo, response, responseLen);
341}
342
343void HRilManager::OnNetworkReport(
344    int32_t slotId, const ReportInfo *reportInfo, const uint8_t *response, size_t responseLen)
345{
346    OnReport(hrilNetwork_, slotId, reportInfo, response, responseLen);
347}
348
349void HRilManager::OnSimReport(int32_t slotId, const ReportInfo *reportInfo, const uint8_t *response, size_t responseLen)
350{
351    OnReport(hrilSim_, slotId, reportInfo, response, responseLen);
352}
353
354void HRilManager::OnSmsReport(int32_t slotId, const ReportInfo *reportInfo, const uint8_t *response, size_t responseLen)
355{
356    OnReport(hrilSms_, slotId, reportInfo, response, responseLen);
357}
358
359HRilManager::HRilManager() : hrilSimSlotCount_(GetSimSlotCount())
360{
361    for (int32_t slotId = HRIL_SIM_SLOT_0; slotId < hrilSimSlotCount_; slotId++) {
362        hrilCall_.push_back(std::make_unique<HRilCall>(slotId));
363        hrilModem_.push_back(std::make_unique<HRilModem>(slotId));
364        hrilNetwork_.push_back(std::make_unique<HRilNetwork>(slotId));
365        hrilSim_.push_back(std::make_unique<HRilSim>(slotId));
366        hrilSms_.push_back(std::make_unique<HRilSms>(slotId));
367        hrilData_.push_back(std::make_unique<HRilData>(slotId));
368    }
369    timerCallback_ = std::make_unique<HRilTimerCallback>();
370}
371
372void HRilManager::SetRilCallback(sptr<OHOS::HDI::Ril::V1_3::IRilCallback> callback)
373{
374    TELEPHONY_LOGD("SetRilCallback");
375    for (int32_t slotId = HRIL_SIM_SLOT_0; slotId < hrilSimSlotCount_; slotId++) {
376        hrilCall_[slotId]->SetRilCallback(callback);
377        hrilModem_[slotId]->SetRilCallback(callback);
378        hrilNetwork_[slotId]->SetRilCallback(callback);
379        hrilSim_[slotId]->SetRilCallback(callback);
380        hrilSms_[slotId]->SetRilCallback(callback);
381        hrilData_[slotId]->SetRilCallback(callback);
382        if (callback == nullptr) {
383            continue;
384        }
385        HDI::Ril::V1_1::RilRadioResponseInfo responseInfo = { 0 };
386        responseInfo.slotId = slotId;
387        responseInfo.type = HDI::Ril::V1_1::RIL_RESPONSE_NOTICE;
388        callback->RadioStateUpdated(responseInfo, hrilModem_[slotId]->GetLastRadioState());
389    }
390}
391
392// Call
393int32_t HRilManager::SetEmergencyCallList(
394    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::EmergencyInfoList &emergencyInfoList)
395{
396    return TaskSchedule(
397        MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetEmergencyCallList, serialId, emergencyInfoList);
398}
399
400int32_t HRilManager::GetEmergencyCallList(int32_t slotId, int32_t serialId)
401{
402    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetEmergencyCallList, serialId);
403}
404
405int32_t HRilManager::GetCallList(int32_t slotId, int32_t serialId)
406{
407    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetCallList, serialId);
408}
409
410int32_t HRilManager::Dial(int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::DialInfo &dialInfo)
411{
412    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::Dial, serialId, dialInfo);
413}
414
415int32_t HRilManager::Reject(int32_t slotId, int32_t serialId)
416{
417    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::Reject, serialId);
418}
419
420int32_t HRilManager::Hangup(int32_t slotId, int32_t serialId, int32_t gsmIndex)
421{
422    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::Hangup, serialId, gsmIndex);
423}
424
425int32_t HRilManager::Answer(int32_t slotId, int32_t serialId)
426{
427    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::Answer, serialId);
428}
429
430int32_t HRilManager::HoldCall(int32_t slotId, int32_t serialId)
431{
432    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::HoldCall, serialId);
433}
434
435int32_t HRilManager::UnHoldCall(int32_t slotId, int32_t serialId)
436{
437    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::UnHoldCall, serialId);
438}
439
440int32_t HRilManager::SwitchCall(int32_t slotId, int32_t serialId)
441{
442    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SwitchCall, serialId);
443}
444
445int32_t HRilManager::CombineConference(int32_t slotId, int32_t serialId, int32_t callType)
446{
447    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::CombineConference, serialId, callType);
448}
449
450int32_t HRilManager::SeparateConference(int32_t slotId, int32_t serialId, int32_t callIndex, int32_t callType)
451{
452    return TaskSchedule(
453        MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SeparateConference, serialId, callIndex, callType);
454}
455
456int32_t HRilManager::GetCallWaiting(int32_t slotId, int32_t serialId)
457{
458    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetCallWaiting, serialId);
459}
460
461int32_t HRilManager::SetCallWaiting(int32_t slotId, int32_t serialId, int32_t activate)
462{
463    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetCallWaiting, serialId, activate);
464}
465
466int32_t HRilManager::GetCallTransferInfo(int32_t slotId, int32_t serialId, int32_t reason)
467{
468    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetCallTransferInfo, serialId, reason);
469}
470
471int32_t HRilManager::SetCallTransferInfo(
472    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::CallForwardSetInfo &callForwardSetInfo)
473{
474    return TaskSchedule(
475        MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetCallTransferInfo, serialId, callForwardSetInfo);
476}
477
478int32_t HRilManager::GetCallRestriction(int32_t slotId, int32_t serialId, const std::string &fac)
479{
480    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetCallRestriction, serialId, fac);
481}
482
483int32_t HRilManager::SetCallRestriction(
484    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::CallRestrictionInfo &callRestrictionInfo)
485{
486    return TaskSchedule(
487        MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetCallRestriction, serialId, callRestrictionInfo);
488}
489
490int32_t HRilManager::GetClip(int32_t slotId, int32_t serialId)
491{
492    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetClip, serialId);
493}
494
495int32_t HRilManager::SetClip(int32_t slotId, int32_t serialId, int32_t action)
496{
497    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetClip, serialId, action);
498}
499
500int32_t HRilManager::GetClir(int32_t slotId, int32_t serialId)
501{
502    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetClir, serialId);
503}
504
505int32_t HRilManager::SetClir(int32_t slotId, int32_t serialId, int32_t action)
506{
507    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetClir, serialId, action);
508}
509
510int32_t HRilManager::SetCallPreferenceMode(int32_t slotId, int32_t serialId, int32_t mode)
511{
512    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetCallPreferenceMode, serialId, mode);
513}
514
515int32_t HRilManager::GetCallPreferenceMode(int32_t slotId, int32_t serialId)
516{
517    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetCallPreferenceMode, serialId);
518}
519
520int32_t HRilManager::SetUssd(int32_t slotId, int32_t serialId, const std::string &str)
521{
522    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetUssd, serialId, str);
523}
524
525int32_t HRilManager::GetUssd(int32_t slotId, int32_t serialId)
526{
527    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetUssd, serialId);
528}
529
530int32_t HRilManager::SetMute(int32_t slotId, int32_t serialId, int32_t mute)
531{
532    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetMute, serialId, mute);
533}
534
535int32_t HRilManager::GetMute(int32_t slotId, int32_t serialId)
536{
537    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetMute, serialId);
538}
539
540int32_t HRilManager::GetCallFailReason(int32_t slotId, int32_t serialId)
541{
542    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::GetCallFailReason, serialId);
543}
544
545int32_t HRilManager::CallSupplement(int32_t slotId, int32_t serialId, int32_t type)
546{
547    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::CallSupplement, serialId, type);
548}
549
550int32_t HRilManager::SendDtmf(int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::DtmfInfo &dtmfInfo)
551{
552    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SendDtmf, serialId, dtmfInfo);
553}
554
555int32_t HRilManager::StartDtmf(int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::DtmfInfo &dtmfInfo)
556{
557    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::StartDtmf, serialId, dtmfInfo);
558}
559
560int32_t HRilManager::StopDtmf(int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::DtmfInfo &dtmfInfo)
561{
562    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::StopDtmf, serialId, dtmfInfo);
563}
564
565int32_t HRilManager::SetBarringPassword(
566    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SetBarringInfo &setBarringInfo)
567{
568    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetBarringPassword, serialId, setBarringInfo);
569}
570
571int32_t HRilManager::CloseUnFinishedUssd(int32_t slotId, int32_t serialId)
572{
573    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::CloseUnFinishedUssd, serialId);
574}
575
576int32_t HRilManager::SetVonrSwitch(int32_t slotId, int32_t serialId, int32_t status)
577{
578    return TaskSchedule(MODULE_HRIL_CALL, hrilCall_[slotId], &HRilCall::SetVonrSwitch, serialId, status);
579}
580
581// Data
582int32_t HRilManager::ActivatePdpContext(
583    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::DataCallInfo &dataCallInfo)
584{
585    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::ActivatePdpContext, serialId, dataCallInfo);
586}
587
588int32_t HRilManager::ActivatePdpContextWithApnTypes(
589    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_3::DataCallInfoWithApnTypes &dataCallInfo)
590{
591    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::ActivatePdpContextWithApnTypes,
592        serialId, dataCallInfo, hrilOpsVersion_);
593}
594
595int32_t HRilManager::DeactivatePdpContext(
596    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::UniInfo &uniInfo)
597{
598    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::DeactivatePdpContext, serialId, uniInfo);
599}
600
601int32_t HRilManager::GetPdpContextList(int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::UniInfo &uniInfo)
602{
603    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::GetPdpContextList, serialId, uniInfo);
604}
605
606int32_t HRilManager::SetInitApnInfo(
607    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::DataProfileDataInfo &dataProfileDataInfo)
608{
609    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::SetInitApnInfo, serialId, dataProfileDataInfo);
610}
611
612int32_t HRilManager::GetLinkBandwidthInfo(int32_t slotId, int32_t serialId, int32_t cid)
613{
614    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::GetLinkBandwidthInfo, serialId, cid);
615}
616
617int32_t HRilManager::GetLinkCapability(int32_t slotId, int32_t serialId)
618{
619    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::GetLinkCapability, serialId);
620}
621
622int32_t HRilManager::SetLinkBandwidthReportingRule(int32_t slotId, int32_t serialId,
623    const OHOS::HDI::Ril::V1_1::DataLinkBandwidthReportingRule &dataLinkBandwidthReportingRule)
624{
625    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::SetLinkBandwidthReportingRule, serialId,
626        dataLinkBandwidthReportingRule);
627}
628
629int32_t HRilManager::SetDataPermitted(int32_t slotId, int32_t serialId, int32_t dataPermitted)
630{
631    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::SetDataPermitted, serialId, dataPermitted);
632}
633
634int32_t HRilManager::SetDataProfileInfo(
635    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::DataProfilesInfo &dataProfilesInfo)
636{
637    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::SetDataProfileInfo, serialId, dataProfilesInfo);
638}
639
640int32_t HRilManager::SendDataPerformanceMode(
641    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::DataPerformanceInfo &dataPerformanceInfo)
642{
643    return TaskSchedule(
644        MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::SendDataPerformanceMode, serialId, dataPerformanceInfo);
645}
646
647int32_t HRilManager::SendDataSleepMode(
648    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::DataSleepInfo &dataSleepInfo)
649{
650    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::SendDataSleepMode, serialId, dataSleepInfo);
651}
652
653int32_t HRilManager::CleanAllConnections(int32_t slotId, int32_t serialId)
654{
655    return TaskSchedule(MODULE_HRIL_DATA, hrilData_[slotId], &HRilData::CleanAllConnections, serialId);
656}
657
658// Modem
659int32_t HRilManager::SetRadioState(int32_t slotId, int32_t serialId, int32_t fun, int32_t rst)
660{
661    return TaskSchedule(MODULE_HRIL_MODEM, hrilModem_[slotId], &HRilModem::SetRadioState, serialId, fun, rst);
662}
663
664int32_t HRilManager::GetRadioState(int32_t slotId, int32_t serialId)
665{
666    return TaskSchedule(MODULE_HRIL_MODEM, hrilModem_[slotId], &HRilModem::GetRadioState, serialId);
667}
668
669int32_t HRilManager::GetImei(int32_t slotId, int32_t serialId)
670{
671    return TaskSchedule(MODULE_HRIL_MODEM, hrilModem_[slotId], &HRilModem::GetImei, serialId);
672}
673
674int32_t HRilManager::GetImeiSv(int32_t slotId, int32_t serialId)
675{
676    return TaskSchedule(MODULE_HRIL_MODEM, hrilModem_[slotId], &HRilModem::GetImeiSv, serialId);
677}
678
679int32_t HRilManager::GetMeid(int32_t slotId, int32_t serialId)
680{
681    return TaskSchedule(MODULE_HRIL_MODEM, hrilModem_[slotId], &HRilModem::GetMeid, serialId);
682}
683
684int32_t HRilManager::GetVoiceRadioTechnology(int32_t slotId, int32_t serialId)
685{
686    return TaskSchedule(MODULE_HRIL_MODEM, hrilModem_[slotId], &HRilModem::GetVoiceRadioTechnology, serialId);
687}
688
689int32_t HRilManager::GetBasebandVersion(int32_t slotId, int32_t serialId)
690{
691    return TaskSchedule(MODULE_HRIL_MODEM, hrilModem_[slotId], &HRilModem::GetBasebandVersion, serialId);
692}
693
694int32_t HRilManager::ShutDown(int32_t slotId, int32_t serialId)
695{
696    return TaskSchedule(MODULE_HRIL_MODEM, hrilModem_[slotId], &HRilModem::ShutDown, serialId);
697}
698
699int32_t HRilManager::GetSimIO(int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SimIoRequestInfo &simIO)
700{
701    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::GetSimIO, serialId, simIO);
702}
703
704int32_t HRilManager::GetSimStatus(int32_t slotId, int32_t serialId)
705{
706    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::GetSimStatus, serialId);
707}
708
709int32_t HRilManager::GetImsi(int32_t slotId, int32_t serialId)
710{
711    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::GetImsi, serialId);
712}
713
714int32_t HRilManager::GetSimLockStatus(
715    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SimLockInfo &simLockInfo)
716{
717    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::GetSimLockStatus, serialId, simLockInfo);
718}
719
720int32_t HRilManager::SetSimLock(int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SimLockInfo &simLockInfo)
721{
722    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SetSimLock, serialId, simLockInfo);
723}
724
725int32_t HRilManager::ChangeSimPassword(
726    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SimPasswordInfo &simPassword)
727{
728    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::ChangeSimPassword, serialId, simPassword);
729}
730
731int32_t HRilManager::UnlockPin(int32_t slotId, int32_t serialId, const std::string &pin)
732{
733    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::UnlockPin, serialId, pin);
734}
735
736int32_t HRilManager::UnlockPuk(int32_t slotId, int32_t serialId, const std::string &puk, const std::string &pin)
737{
738    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::UnlockPuk, serialId, puk, pin);
739}
740
741int32_t HRilManager::UnlockPin2(int32_t slotId, int32_t serialId, const std::string &pin2)
742{
743    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::UnlockPin2, serialId, pin2);
744}
745
746int32_t HRilManager::UnlockPuk2(int32_t slotId, int32_t serialId, const std::string &puk2, const std::string &pin2)
747{
748    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::UnlockPuk2, serialId, puk2, pin2);
749}
750
751int32_t HRilManager::SetActiveSim(int32_t slotId, int32_t serialId, int32_t index, int32_t enable)
752{
753    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SetActiveSim, serialId, index, enable);
754}
755
756int32_t HRilManager::SimStkSendTerminalResponse(int32_t slotId, int32_t serialId, const std::string &strCmd)
757{
758    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SimStkSendTerminalResponse, serialId, strCmd);
759}
760
761int32_t HRilManager::SimStkSendEnvelope(int32_t slotId, int32_t serialId, const std::string &strCmd)
762{
763    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SimStkSendEnvelope, serialId, strCmd);
764}
765
766int32_t HRilManager::SimStkSendCallSetupRequestResult(int32_t slotId, int32_t serialId, int32_t accept)
767{
768    return TaskSchedule(
769        MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SimStkSendCallSetupRequestResult, serialId, accept);
770}
771
772int32_t HRilManager::SimStkIsReady(int32_t slotId, int32_t serialId)
773{
774    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SimStkIsReady, serialId);
775}
776
777int32_t HRilManager::GetRadioProtocol(int32_t slotId, int32_t serialId)
778{
779    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::GetRadioProtocol, serialId);
780}
781
782int32_t HRilManager::SetRadioProtocol(
783    int32_t slotId, int32_t serialId, const HDI::Ril::V1_1::RadioProtocol &radioProtocol)
784{
785    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SetRadioProtocol, serialId, radioProtocol);
786}
787
788int32_t HRilManager::SimOpenLogicalChannel(int32_t slotId, int32_t serialId, const std::string &appID, int32_t p2)
789{
790    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SimOpenLogicalChannel, serialId, appID, p2);
791}
792
793int32_t HRilManager::SimCloseLogicalChannel(int32_t slotId, int32_t serialId, int32_t channelId)
794{
795    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SimCloseLogicalChannel, serialId, channelId);
796}
797
798int32_t HRilManager::SimTransmitApduLogicalChannel(
799    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo &apduSimIO)
800{
801    return TaskSchedule(
802        MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SimTransmitApduLogicalChannel, serialId, apduSimIO);
803}
804
805int32_t HRilManager::SimTransmitApduBasicChannel(
806    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::ApduSimIORequestInfo &apduSimIO)
807{
808    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SimTransmitApduBasicChannel, serialId, apduSimIO);
809}
810
811int32_t HRilManager::SimAuthentication(
812    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SimAuthenticationRequestInfo &simAuthInfo)
813{
814    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SimAuthentication, serialId, simAuthInfo);
815}
816
817int32_t HRilManager::UnlockSimLock(int32_t slotId, int32_t serialId, int32_t lockType, const std::string &key)
818{
819    return TaskSchedule(MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::UnlockSimLock, serialId, lockType, key);
820}
821
822int32_t HRilManager::SendSimMatchedOperatorInfo(
823    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_2::NcfgOperatorInfo &ncfgOperatorInfo)
824{
825    return TaskSchedule(
826        MODULE_HRIL_SIM, hrilSim_[slotId], &HRilSim::SendSimMatchedOperatorInfo, serialId, ncfgOperatorInfo);
827}
828
829// Network
830int32_t HRilManager::GetSignalStrength(int32_t slotId, int32_t serialId)
831{
832    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetSignalStrength, serialId);
833}
834
835int32_t HRilManager::GetCsRegStatus(int32_t slotId, int32_t serialId)
836{
837    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetCsRegStatus, serialId);
838}
839
840int32_t HRilManager::GetPsRegStatus(int32_t slotId, int32_t serialId)
841{
842    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetPsRegStatus, serialId);
843}
844
845int32_t HRilManager::GetOperatorInfo(int32_t slotId, int32_t serialId)
846{
847    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetOperatorInfo, serialId);
848}
849
850int32_t HRilManager::GetNetworkSearchInformation(int32_t slotId, int32_t serialId)
851{
852    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetNetworkSearchInformation, serialId);
853}
854
855int32_t HRilManager::GetNetworkSelectionMode(int32_t slotId, int32_t serialId)
856{
857    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetNetworkSelectionMode, serialId);
858}
859
860int32_t HRilManager::SetNetworkSelectionMode(
861    int32_t slotId, int32_t serialId, const HDI::Ril::V1_1::SetNetworkModeInfo &networkModeInfo)
862{
863    return TaskSchedule(
864        MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::SetNetworkSelectionMode, serialId, networkModeInfo);
865}
866
867int32_t HRilManager::GetNeighboringCellInfoList(int32_t slotId, int32_t serialId)
868{
869    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetNeighboringCellInfoList, serialId);
870}
871
872int32_t HRilManager::GetCurrentCellInfo(int32_t slotId, int32_t serialId)
873{
874    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetCurrentCellInfo, serialId);
875}
876
877int32_t HRilManager::SetPreferredNetwork(int32_t slotId, int32_t serialId, int32_t preferredNetworkType)
878{
879    return TaskSchedule(
880        MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::SetPreferredNetwork, serialId, preferredNetworkType);
881}
882
883int32_t HRilManager::GetPreferredNetwork(int32_t slotId, int32_t serialId)
884{
885    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetPreferredNetwork, serialId);
886}
887
888int32_t HRilManager::GetPhysicalChannelConfig(int32_t slotId, int32_t serialId)
889{
890    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetPhysicalChannelConfig, serialId);
891}
892
893int32_t HRilManager::SetLocateUpdates(int32_t slotId, int32_t serialId, const HDI::Ril::V1_1::RilRegNotifyMode mode)
894{
895    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::SetLocateUpdates, serialId, mode);
896}
897
898int32_t HRilManager::SetNotificationFilter(int32_t slotId, int32_t serialId, int32_t newFilter)
899{
900    return TaskSchedule(
901        MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::SetNotificationFilter, serialId, newFilter);
902}
903
904int32_t HRilManager::SetDeviceState(int32_t slotId, int32_t serialId, int32_t deviceStateType, int32_t deviceStateOn)
905{
906    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::SetDeviceState, serialId,
907        deviceStateType, deviceStateOn);
908}
909
910int32_t HRilManager::SetNrOptionMode(int32_t slotId, int32_t serialId, int32_t mode)
911{
912    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::SetNrOptionMode, serialId, mode);
913}
914
915int32_t HRilManager::GetNrOptionMode(int32_t slotId, int32_t serialId)
916{
917    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetNrOptionMode, serialId);
918}
919
920int32_t HRilManager::GetRrcConnectionState(int32_t slotId, int32_t serialId)
921{
922    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetRrcConnectionState, serialId);
923}
924
925int32_t HRilManager::GetNrSsbId(int32_t slotId, int32_t serialId)
926{
927    return TaskSchedule(MODULE_HRIL_NETWORK, hrilNetwork_[slotId], &HRilNetwork::GetNrSsbId, serialId);
928}
929
930// Sms
931int32_t HRilManager::SendGsmSms(
932    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::GsmSmsMessageInfo &gsmSmsMessageInfo)
933{
934    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::SendGsmSms, serialId, gsmSmsMessageInfo);
935}
936
937int32_t HRilManager::SendCdmaSms(
938    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SendCdmaSmsMessageInfo &cdmaSmsMessageInfo)
939{
940    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::SendCdmaSms, serialId, cdmaSmsMessageInfo);
941}
942
943int32_t HRilManager::AddSimMessage(
944    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo &smsMessageIOInfo)
945{
946    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::AddSimMessage, serialId, smsMessageIOInfo);
947}
948
949int32_t HRilManager::DelSimMessage(int32_t slotId, int32_t serialId, int32_t index)
950{
951    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::DelSimMessage, serialId, index);
952}
953
954int32_t HRilManager::UpdateSimMessage(
955    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo &smsMessageIOInfo)
956{
957    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::UpdateSimMessage, serialId, smsMessageIOInfo);
958}
959
960int32_t HRilManager::AddCdmaSimMessage(
961    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo &smsMessageIOInfo)
962{
963    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::AddCdmaSimMessage, serialId, smsMessageIOInfo);
964}
965
966int32_t HRilManager::DelCdmaSimMessage(int32_t slotId, int32_t serialId, int32_t index)
967{
968    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::DelCdmaSimMessage, serialId, index);
969}
970
971int32_t HRilManager::UpdateCdmaSimMessage(
972    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::SmsMessageIOInfo &smsMessageIOInfo)
973{
974    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::UpdateCdmaSimMessage, serialId, smsMessageIOInfo);
975}
976
977int32_t HRilManager::SetSmscAddr(
978    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::ServiceCenterAddress &serviceCenterAddress)
979{
980    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::SetSmscAddr, serialId, serviceCenterAddress);
981}
982
983int32_t HRilManager::GetSmscAddr(int32_t slotId, int32_t serialId)
984{
985    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::GetSmscAddr, serialId);
986}
987
988int32_t HRilManager::SetCBConfig(
989    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::CBConfigInfo &cellBroadcastInfo)
990{
991    return HRilManager::TaskSchedule(
992        MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::SetCBConfig, serialId, cellBroadcastInfo);
993}
994
995int32_t HRilManager::GetCBConfig(int32_t slotId, int32_t serialId)
996{
997    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::GetCBConfig, serialId);
998}
999
1000int32_t HRilManager::SetCdmaCBConfig(
1001    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::CdmaCBConfigInfoList &cdmaCBConfigInfoList)
1002{
1003    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::SetCdmaCBConfig, serialId, cdmaCBConfigInfoList);
1004}
1005
1006int32_t HRilManager::GetCdmaCBConfig(int32_t slotId, int32_t serialId)
1007{
1008    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::GetCdmaCBConfig, serialId);
1009}
1010
1011int32_t HRilManager::SendSmsMoreMode(
1012    int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::GsmSmsMessageInfo &gsmSmsMessageInfo)
1013{
1014    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::SendSmsMoreMode, serialId, gsmSmsMessageInfo);
1015}
1016
1017int32_t HRilManager::SendSmsAck(int32_t slotId, int32_t serialId, const OHOS::HDI::Ril::V1_1::ModeData &modeData)
1018{
1019    return TaskSchedule(MODULE_HRIL_SMS, hrilSms_[slotId], &HRilSms::SendSmsAck, serialId, modeData);
1020}
1021
1022int32_t HRilManager::SendRilAck()
1023{
1024    ReleaseRunningLock();
1025    return HRIL_ERR_SUCCESS;
1026}
1027
1028HRilManager::~HRilManager()
1029{
1030    SetHrilManagerDestroy();
1031    if (timerCallback_ == nullptr || timerCallback_->event_ == nullptr ||
1032        timerCallback_->event_->IsNormalDestory()) {
1033        return;
1034    }
1035    timerCallback_->event_->SetNormalDestory(true);
1036    timerCallback_->OnTriggerEvent();
1037    if (eventLoop_ == nullptr || !eventLoop_->joinable()) {
1038        return;
1039    }
1040    eventLoop_->join();
1041    TELEPHONY_LOGI("~HRilManager end");
1042}
1043
1044void HRilManager::SetHrilManagerDestroy()
1045{
1046    pthread_mutex_lock(&dispatchMutex);
1047    g_isHrilManagerDestory = true;
1048    pthread_mutex_unlock(&dispatchMutex);
1049}
1050
1051#ifdef __cplusplus
1052extern "C" {
1053#endif
1054
1055int32_t GetSimSlotCount()
1056{
1057    char simSlotCount[HRIL_SYSPARA_SIZE] = { 0 };
1058    GetParameter(HRIL_TEL_SIM_SLOT_COUNT, HRIL_DEFAULT_SLOT_COUNT, simSlotCount, HRIL_SYSPARA_SIZE);
1059    int32_t simSlotCountNumber = std::atoi(simSlotCount);
1060    char virtualModemSwitch[HRIL_SYSPARA_SIZE] = {0};
1061    GetParameter(HRIL_VIRTUAL_MODEM_SWITCH, HRIL_VIRTUAL_MODEM_DEFAULT_SWITCH, virtualModemSwitch,
1062        HRIL_SYSPARA_SIZE);
1063    if (strcmp(virtualModemSwitch, "true") == 0 && simSlotCountNumber == 0) {
1064        TELEPHONY_LOGI("virtualModemSwitch on. set simSlotCountNumber 1");
1065        simSlotCountNumber = 1;
1066    }
1067    char vSimModemCount[HRIL_SYSPARA_SIZE] = { 0 };
1068    GetParameter(HRIL_VSIM_MODEM_COUNT_STR, HRIL_DEFAULT_VSIM_MODEM_COUNT, vSimModemCount, HRIL_SYSPARA_SIZE);
1069    int32_t vSimModemCountNumber = std::atoi(vSimModemCount);
1070    if (simSlotCountNumber == DUAL_SLOT_COUNT && vSimModemCountNumber == MAX_SLOT_COUNT) {
1071        simSlotCountNumber = MAX_SLOT_COUNT;
1072    }
1073    TELEPHONY_LOGI("GetSimSlotCount, %{public}d", simSlotCountNumber);
1074    return simSlotCountNumber;
1075}
1076
1077static void HRilBootUpEventLoop()
1078{
1079    if (!IsHrilManagerValid() || g_manager->timerCallback_ == nullptr) {
1080        return;
1081    }
1082    g_manager->timerCallback_->EventLoop();
1083}
1084
1085void HRilInit(void)
1086{
1087    if (!IsHrilManagerValid()) {
1088        TELEPHONY_LOGE("HRilInit: g_manager is nullptr");
1089        return;
1090    }
1091#ifdef ABILITY_POWER_SUPPORT
1092    if (g_manager->powerInterface_ == nullptr) {
1093        g_manager->powerInterface_ = IPowerInterface::Get();
1094        if (g_manager->powerInterface_ == nullptr) {
1095            TELEPHONY_LOGE("failed to get power hdi interface");
1096        }
1097    }
1098#endif
1099    if (g_manager->eventLoop_ != nullptr) {
1100        TELEPHONY_LOGD("eventLoop_ has exit");
1101        return;
1102    }
1103    g_manager->eventLoop_ = std::make_unique<std::thread>(HRilBootUpEventLoop);
1104    pthread_setname_np(g_manager->eventLoop_.get()->native_handle(), "hril_eventLoop");
1105}
1106
1107void HRilRegOps(const HRilOps *hrilOps)
1108{
1109    static HRilOps callBacks = { 0 };
1110    static RegisterState rilRegisterStatus = RIL_REGISTER_IS_NONE;
1111
1112    if (hrilOps == nullptr || !IsHrilManagerValid()) {
1113        TELEPHONY_LOGE("HRilRegOps: param is nullptr");
1114        return;
1115    }
1116    if (rilRegisterStatus > RIL_REGISTER_IS_NONE) {
1117        TELEPHONY_LOGE("HRilRegOps is running!!!!");
1118        return;
1119    }
1120    rilRegisterStatus = RIL_REGISTER_IS_RUNNING;
1121    g_manager->hrilOpsVersion_ = hrilOps->version;
1122    (void)memcpy_s(&callBacks, sizeof(HRilOps), hrilOps, sizeof(HRilOps));
1123    for (int32_t slotId = HRIL_SIM_SLOT_0; slotId < g_manager->GetMaxSimSlotCount(); slotId++) {
1124        if (callBacks.smsOps != nullptr) {
1125            g_manager->RegisterSmsFuncs(slotId, callBacks.smsOps);
1126        }
1127        if (callBacks.callOps != nullptr) {
1128            g_manager->RegisterCallFuncs(slotId, callBacks.callOps);
1129        }
1130        if (callBacks.dataOps != nullptr) {
1131            g_manager->RegisterDataFuncs(slotId, callBacks.dataOps);
1132        }
1133        if (callBacks.modemOps != nullptr) {
1134            g_manager->RegisterModemFuncs(slotId, callBacks.modemOps);
1135        }
1136        if (callBacks.networkOps != nullptr) {
1137            g_manager->RegisterNetworkFuncs(slotId, callBacks.networkOps);
1138        }
1139        if (callBacks.simOps != nullptr) {
1140            g_manager->RegisterSimFuncs(slotId, callBacks.simOps);
1141        }
1142    }
1143}
1144
1145void OnCallReport(int32_t slotId, struct ReportInfo reportInfo, const uint8_t *response, size_t responseLen)
1146{
1147    if (!IsHrilManagerValid()) {
1148        TELEPHONY_LOGE("HrilManager is nullptr, id:%{public}d", slotId);
1149        return;
1150    }
1151    g_manager->OnCallReport(slotId, &reportInfo, response, responseLen);
1152}
1153
1154void OnDataReport(int32_t slotId, struct ReportInfo reportInfo, const uint8_t *response, size_t responseLen)
1155{
1156    if (!IsHrilManagerValid()) {
1157        TELEPHONY_LOGE("HrilManager is nullptr, id:%{public}d", slotId);
1158        return;
1159    }
1160    g_manager->OnDataReport(slotId, &reportInfo, response, responseLen);
1161}
1162
1163void OnModemReport(int32_t slotId, struct ReportInfo reportInfo, const uint8_t *response, size_t responseLen)
1164{
1165    if (!IsHrilManagerValid()) {
1166        TELEPHONY_LOGE("HrilManager is nullptr, id:%{public}d", slotId);
1167        return;
1168    }
1169    g_manager->OnModemReport(slotId, &reportInfo, response, responseLen);
1170}
1171
1172void OnNetworkReport(int32_t slotId, struct ReportInfo reportInfo, const uint8_t *response, size_t responseLen)
1173{
1174    if (!IsHrilManagerValid()) {
1175        TELEPHONY_LOGE("HrilManager is nullptr, id:%{public}d", slotId);
1176        return;
1177    }
1178    g_manager->OnNetworkReport(slotId, &reportInfo, response, responseLen);
1179}
1180
1181void OnSimReport(int32_t slotId, struct ReportInfo reportInfo, const uint8_t *response, size_t responseLen)
1182{
1183    if (!IsHrilManagerValid()) {
1184        TELEPHONY_LOGE("HrilManager is nullptr, id:%{public}d", slotId);
1185        return;
1186    }
1187    g_manager->OnSimReport(slotId, &reportInfo, response, responseLen);
1188}
1189
1190void OnSmsReport(int32_t slotId, struct ReportInfo reportInfo, const uint8_t *response, size_t responseLen)
1191{
1192    if (!IsHrilManagerValid()) {
1193        TELEPHONY_LOGE("HrilManager is nullptr, id:%{public}d", slotId);
1194        return;
1195    }
1196    g_manager->OnSmsReport(slotId, &reportInfo, response, responseLen);
1197}
1198
1199void OnTimerCallback(HRilCallbackFun func, uint8_t *param, const struct timeval *tv)
1200{
1201    if (!IsHrilManagerValid() || g_manager->timerCallback_ == nullptr) {
1202        TELEPHONY_LOGE("HrilManager or timerCallback is nullptr");
1203        return;
1204    }
1205    g_manager->timerCallback_->HRilSetTimerCallbackInfo(func, param, tv);
1206}
1207
1208#ifdef __cplusplus
1209}
1210#endif
1211} // namespace Telephony
1212} // namespace OHOS
1213