一、簡介

二、基礎知識

1. 短彩信框架圖

2. 代碼結構

/base/telephony/sms_mms├─ frameworks        # 短彩信內部框架接口層├─ interfaces        # 對外暴露的接口│ ├─ innerkits│ └─ kits├─ sa_profile        # 啟動配置文件├─ services         # 服務內部代碼│ ├─ include        # 頭文件目錄│ ├─ cdma         # CDMA制式源文件│ └─ gsm          # GSM制式源文件├─ test           # 單元測試目錄└─utils#通用工具相關

3. 電話子系統(sms) 核心類

短彩信模塊業務流程涉及到的比較重要的核心類成員；包括 sms_mms 服務，依賴的 core_service 和 ril_adapter 關鍵類。

4. 短信發送時序圖

應用程序調用 API 發送短信，經過參數判斷、鑒權、長短信拆分、PDU 編碼；添加到發送隊列，調用 RIL 發送短信接口發送短信到接收端。并將發送狀態返回應用調用者，完成一次短信發送過程。

1.上層應用調用發送短信的 API JS 接口，調用 JS Napi 接口；

2.JS Napi 調用 Native 層 C++ SendMessage 跨 IPC 到 SmsInterfaceManager 對象；

3.SmsInterfaceManager 根據過濾策略來過濾掉短信和參數合法性檢查；

4.SmsInterfaceManager 進行鑒權檢查；

5.SmsInterfaceManager 調用 TextBasedSmsDelivery 或 TextBasedSmsDelivery 到 SmsSendManager；

6.SmsSendManager 調用搜網服務來獲取 SIM 卡和網絡狀態；

7.GSM 網絡將創建 GsmSmsSender，CDMA 網絡將創建 CdmaSmsSender；

8.GsmSmsSender 或 CdmaSmsSender 將短信拆分并進行 PDU 編碼然后放到隊列中；

9.通過接口將短信發送到 RIL 層；

10.如果返回的狀態失敗將啟動重發機制；

11.返回應用層發送的狀態信息；

5. 短信接收時序圖

6. 相關倉

https://gitee.com/openharmony/telephony_sms_mms

https://gitee.com/openharmony/telephony_core_service

https://gitee.com/openharmony/telephony_ril_adapter

三、源碼解析

1. SmsService 啟動

服務入口類 SmsService.cpp 繼承 safwk 組件的 SystemAblility 類；由 SA 系統服務管理框架（samgr）拉起服務。采用 telephony.cfg + profile.xml + libtel_sms_mms.z.so 的方式由 init 進程執行對應的 telephony.cfg 文件拉起 SmsService SystemAbility 對應的 telephony 進程，并執行 void SmsService::OnStart()。

class SmsService : public SystemAbility, public SmsInterfaceStub {    DECLARE_DELAYED_SINGLETON(SmsService)    DECLARE_SYSTEM_ABILITY(SmsService) // necessarypublic:    void OnStart() override;    void OnStop() override;private:    constexpr static uint32_t CONNECT_SERVICE_WAIT_TIME = 2000; // ms    bool Init();    bool registerToService_ = false;    ServiceRunningState state_ = ServiceRunningState::STATE_NOT_START;};} // namespace Telephony}//namespaceOHOS

2. 模塊初始化

SmsService 服務啟動后，調用 OnStart() 函數；并創建服務內部類，初始化內部資源，包括 SmsInterfaceManager、SmsSendManager、SmsReceiveManager 對象創建和初始化。

void SmsService::OnStart() {    TELEPHONY_LOGI("SmsService::OnStart start service Enter.");    if (state_ == ServiceRunningState::STATE_RUNNING) {        TELEPHONY_LOGE("msService has already started.");        return;    }    if (!Init()) {        TELEPHONY_LOGE("failed to init SmsService");        return;    }    state_ = ServiceRunningState::STATE_RUNNING;    TELEPHONY_LOGI("SmsService::OnStart start service Exit.");}
bool SmsService::Init(){    if (!registerToService_) {        WaitCoreServiceToInit();    }    return true;}//等待核心服務完成初始化，并調用InitModule 初始化內部內部代碼void SmsService::WaitCoreServiceToInit(){    std::thread connectTask([&]() {        while (true) {            TELEPHONY_LOGI("connect core service ...");            if (CoreManagerInner::GetInstance().IsInitFinished()) {                InitModule();                TELEPHONY_LOGI("SmsService Connection successful");                break;           }       std::sleep_for(milliseconds(CONNECT_SERVICE_WAIT_TIME));       }    });    connectTask.detach();}

3. Native IPC 接口實現

SmsService.cpp 繼承 SmsInterfaceStub.cpp ；SmsInterfaceStub 是 native 層對外接口 IPC 服務端代碼，繼承了并實現了 IPC 對外接口 ISmsServiceInterface 用于跨進程對外提供 navtive C++ API 接口；OnRemoteRequest() 是服務端的請求入口，通過請求 Id 遍歷 memberFuncMap_ 調用對應的實現方法。

int SmsInterfaceStub::OnRemoteRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option){    int32_t result = 0;    std::u16string myDescripter = SmsInterfaceStub::GetDescriptor();    std::u16string remoteDescripter = data.ReadInterfaceToken();    if (myDescripter == remoteDescripter) {        auto itFunc = memberFuncMap_.find(code);        if (itFunc != memberFuncMap_.end()) {            auto memberFunc = itFunc->second;            if (memberFunc != nullptr) {                (this->*memberFunc)(data, reply, option);            } else {                TELEPHONY_LOGE("memberFunc is nullptr");            }        } else {            TELEPHONY_LOGE("itFunc was not found");        }    } else {        TELEPHONY_LOGE("descriptor checked fail");        return result;}
// 添加memberFuncMap 請求處理函數SmsInterfaceStub::SmsInterfaceStub(){    memberFuncMap_[TEXT_BASED_SMS_DELIVERY] =&SmsInterfaceStub::OnSendSmsTextRequest;    memberFuncMap_[DATA_BASED_SMS_DELIVERY] = &SmsInterfaceStub::OnSendSmsDataRequest;    memberFuncMap_[SET_SMSC_ADDRESS] = &SmsInterfaceStub::OnSetSmscAddr;    memberFuncMap_[GET_SMSC_ADDRESS] = &SmsInterfaceStub::OnGetSmscAddr;    memberFuncMap_[ADD_SIM_MESSAGE] = &SmsInterfaceStub::OnAddSimMessage;    memberFuncMap_[DEL_SIM_MESSAGE] = &SmsInterfaceStub::OnDelSimMessage;    memberFuncMap_[UPDATE_SIM_MESSAGE] = &SmsInterfaceStub::OnUpdateSimMessage;    memberFuncMap_[GET_ALL_SIM_MESSAGE] = &SmsInterfaceStub::OnGetAllSimMessages;    memberFuncMap_[SET_CB_CONFIG] = &SmsInterfaceStub::OnSetCBConfig;    memberFuncMap_[SET_DEFAULT_SMS_SLOT_ID] = &SmsInterfaceStub::OnSetDefaultSmsSlotId;    memberFuncMap_[GET_DEFAULT_SMS_SLOT_ID] = &SmsInterfaceStub::OnGetDefaultSmsSlotId;    memberFuncMap_[SPLIT_MESSAGE] = &SmsInterfaceStub::OnSplitMessage;    memberFuncMap_[GET_SMS_SEGMENTS_INFO] = &SmsInterfaceStub::OnGetSmsSegmentsInfo;    memberFuncMap_[GET_IMS_SHORT_MESSAGE_FORMAT] = &SmsInterfaceStub::OnGetImsShortMessageFormat;    memberFuncMap_[IS_IMS_SMS_SUPPORTED] = &SmsInterfaceStub::OnIsImsSmsSupported;    memberFuncMap_[HAS_SMS_CAPABILITY] = &SmsInterfaceStub::OnHasSmsCapability;}

4. 多卡方案實現

根據卡槽數量創建對應的 SmsInterfaceManager 對象，并用 slotSmsInterfaceManagerMap_ 管理。

服務啟動后會調用 InitModule() 方法并根據卡槽數量創建多個 SmsInterfaceManager 每個 SmsInterfaceManager 對象代碼每一個卡槽。

void SmsInterfaceStub::InitModule() {    static bool bInitModule = false;    if (!bInitModule) {        bInitModule = true;        std::lock_guard lock(mutex_);        for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; ++slotId) {            slotSmsInterfaceManagerMap_[slotId] = std::make_shared(slotId);            if (slotSmsInterfaceManagerMap_[slotId] == nullptr) {                return;            }            slotSmsInterfaceManagerMap_[slotId]->InitInterfaceManager();            TELEPHONY_LOGI("SmsInterfaceStub InitModule slotId = %{public}d",slotId);        }    }}

5. 短信發送流程

JS 調用發送短信示例代碼， 導入 SDK sms 包并構造 SendMessageOptions 對象參數。

import sms from "@ohos.telephony.sms"; //導入短彩信包let msg: SendMessageOptions = {  slotId: 0,  destinationHost: '123xxxxxxxx',  content: '這是一封短信',  sendCallback: (err, data) => {    if (err) {      // 接口調用失敗，err非空      console.error(`failed to send message because ${err.message}`);      return;    }    // 接口調用成功，err為空    console.log(`success to send message: ${data.result}`);  }}// 調用接口sms.sendMessage(msg);

static napi_value SendMessage(napi_env env, napi_callback_info info){    size_t parameterCount = 1;    napi_value parameters[1] = {0};    napi_value thisVar = nullptr;    void *data = nullptr;    napi_get_cb_info(env, info, ¶meterCount, parameters, &thisVar, &data);    int32_t messageMatchResult = MatchSendMessageParameters(env, parameters,parameterCount);    NAPI_ASSERT(env, messageMatchResult != MESSAGE_PARAMETER_NOT_MATCH, "type mismatch");    auto asyncContext = std::make_unique().release();    if (asyncContext == nullptr) {        std::string errorCode = std::to_string(napi_generic_failure);        std::string errorMessage = "error at SendMessageContext is nullptr";        NAPI_CALL(env, napi_throw_error(env, errorCode.c_str(), errorMessage.c_str()));        return nullptr;    }    ParseMessageParameter(messageMatchResult, env, parameters[0], *asyncContext);    napi_create_reference(env, thisVar, DEFAULT_REF_COUNT, &asyncContext->thisVarRef);    napi_value resourceName = nullptr;    napi_create_string_utf8(env, "SendMessage", NAPI_AUTO_LENGTH, &resourceName);    napi_create_async_work(env, nullptr, resourceName, NativeSendMessage, SendMessageCallback,        (void *)asyncContext, &(asyncContext->work));    napi_queue_async_work(env, asyncContext->work);    return NapiUtil::CreateUndefined(env);}

SendMessage 最終會調用 sms_mms/frameworks/js/napi/src/napi_sms.cpp ActuallySendMessage 函數；

ActuallySendMessage 調用 Native C++ 提供發送短信的單例類 SmsServiceManagerClient 這個類是現實了 OpenHarmony 系統 IPC 通訊框架的客戶端；

用于 C/S 架構與 SmsService 服務通訊。SmsServiceManagerClient SendMessage() 接口需要兩個回調對象分別是 SendCallback 和 DeliveryCallback 用于返回服務發送短信的狀態結果回調。

static bool ActuallySendMessage(napi_env env, SendMessageContext ¶meter){    std::unique_ptr sendCallback =        std::make_unique(hasSendCallback, env, parameter.thisVarRef, parameter.sendCallbackRef);    std::unique_ptr deliveryCallback = std::make_unique(        hasDeliveryCallback, env, parameter.thisVarRef, parameter.deliveryCallbackRef);    //文本類型的短信    if (parameter.messageType == TEXT_MESSAGE_PARAMETER_MATCH) {        int32_t sendResult = DelayedSingleton::GetInstance()->SendMessage(            parameter.slotId, parameter.destinationHost, parameter.serviceCenter, parameter.textContent,            sendCallback.release(), deliveryCallback.release());        TELEPHONY_LOGI("NativeSendMessage SendTextMessage execResult = %{public}d", sendResult);    }     // 數據類型的短信    else if (parameter.messageType == RAW_DATA_MESSAGE_PARAMETER_MATCH) {        if (parameter.rawDataContent.size() > 0) {            uint16_t arrayLength = static_cast(parameter.rawDataContent.size());            int32_t sendResult = DelayedSingleton::GetInstance()->                SendMessage(parameter.slotId, parameter.destinationHost, parameter.serviceCenter,                parameter.destinationPort, ¶meter.rawDataContent[0],                arrayLength, sendCallback.release(), deliveryCallback.release());            TELEPHONY_LOGI("NativeSendMessage SendRawDataMessage execResult = %{public}d", sendResult);        }    }    return false;}
//Native C++ 發送短信接口函數int32_t SmsServiceManagerClient::SendMessage(int32_t slotId, const std::u16string desAddr,    const std::u16string scAddr, const std::u16string text, const sptr &callback,    const sptr &deliveryCallback){    if (InitSmsServiceProxy()) {        smsServiceInterface_->SendMessage(slotId, desAddr, scAddr, text, callback, deliveryCallback);        TELEPHONY_LOGI("execute SendMessage
");        return ERROR_NONE;    }    return ERROR_SERVICE_UNAVAILABLE;}
// InitSmsServiceProxy 用于初始化與SmsService IPC 通許連接工作bool SmsServiceManagerClient::InitSmsServiceProxy(){    if (smsServiceInterface_ == nullptr) {        std::lock_guard lock(mutex_);        sptr systemAbilityManager =            SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();        if (!systemAbilityManager) {            TELEPHONY_LOGE(" Get system ability mgr failed.");            return false;        }        sptr remoteObject = systemAbilityManager->GetSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID);        if (!remoteObject) {            TELEPHONY_LOGE("Get SMS Service Failed.");            return false;        }        smsServiceInterface_ = iface_cast(remoteObject);        if ((!smsServiceInterface_) || (!smsServiceInterface_->AsObject())) {            TELEPHONY_LOGE("Get SMS Service Proxy Failed.");            return false;        }        recipient_ = new SmsServiceInterfaceDeathRecipient();        if (!recipient_) {            TELEPHONY_LOGE("Failed to create death Recipient ptr SmsServiceInterfaceDeathRecipient!");            return false;        }        smsServiceInterface_->AsObject()->AddDeathRecipient(recipient_);    }    return true;}

通過 SmsServiceManagerClient 的 SendMessage 調用最終會通過 IPC 調用到 sms_mms/services/sms_interface_stub.cpp 的 OnRemoteRequest() 函數；

通過定義的 codeId 從 memberFuncMap_ 遍歷出 OnSendSmsTextRequest() 方法并執行；

OnSendSmsTextRequest 主要是 IPC 數據的反序列號并調用 SmsService 實現的 SendMessage（） 方法。

void SmsInterfaceStub::OnSendSmsTextRequest(MessageParcel &data, MessageParcel &reply, MessageOption &option){    int32_t result = 0;    sptr sendCallback = nullptr;    sptr deliveryCallback = nullptr;    int32_t slotId = data.ReadInt32();    u16string desAddr = data.ReadString16();    u16string scAddr = data.ReadString16();    u16string text = data.ReadString16();    sptr remoteSendCallback = data.ReadRemoteObject();    sptr remoteDeliveryCallback = data.ReadRemoteObject();    if (remoteSendCallback != nullptr) {        sendCallback = iface_cast(remoteSendCallback);    }    if (remoteDeliveryCallback != nullptr) {        deliveryCallback = iface_cast(remoteDeliveryCallback);    }    TELEPHONY_LOGI("MessageID::TEXT_BASED_SMS_DELIVERY %{public}d", slotId);    SendMessage(slotId, desAddr, scAddr, text, sendCallback, deliveryCallback);    reply.WriteInt32(result);}
void SmsService::SendMessage(int32_t slotId, const u16string desAddr, const u16string scAddr,    const u16string text, const sptr &sendCallback,    const sptr &deliveryCallback){  // 權限校驗    if (!TelephonyPermission::SEND_MESSAGES)) {        SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);        TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Send Messages Permisson.");        return;    }    // 獲取對應slotId 對應的SmsInterfaceManager 對象    std::shared_ptr interfaceManager = GetSmsInterfaceManager(slotId);    ............    interfaceManager->TextBasedSmsDelivery(StringUtils::ToUtf8(desAddr), StringUtils::ToUtf8(scAddr),        StringUtils::ToUtf8(text), sendCallback, deliveryCallback);}

SmsInterfaceManager 對象 TextBasedSmsDelivery 用于發送短信接口調用 SmsSendManager 對象的 TextBasedSmsDelivery（）；根據當前 sloidId 卡的網絡狀態 調用 Gsm 或者 Cdma 來進一步發送短信處理。

void SmsSendManager::TextBasedSmsDelivery(const string &desAddr, const string &scAddr, const string &text,    const sptr &sendCallback,    const sptr &deliveryCallback){    ......此處省略.....    NetWorkType netWorkType = networkManager_->GetNetWorkType();    TELEPHONY_LOGI("netWorkType = %{public}d.", netWorkType);    if (netWorkType == NetWorkType::NET_TYPE_GSM) {        gsmSmsSender_->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);    } else if (netWorkType == NetWorkType::NET_TYPE_CDMA) {        cdmaSmsSender_->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);    } else {        SmsSender::SendResultCallBack(            sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE);        TELEPHONY_LOGI("network unknown send error.");    }}

Gsm 或者 Cdma 長短信分段和 PDU 的編碼過程，入口函數 GsmSmsSender::TextBasedSmsDelivery(）。

或者 CdmaSmsSender::TextBasedSmsDelivery() 并構造 SmsSendIndexer 對象添加到 Map 隊列中，并調用 CoreService 提供的發送短信接口發送，等待發送結果；拿 Gsm 制式的來分析，代碼如下：

void GsmSmsSender::TextBasedSmsDelivery(const string &desAddr, const string &scAddr, const string &text,    const sptr &sendCallback, const sptr &deliveryCallback){    bool isMore = false;    bool isStatusReport = false;    int ret = 0;    int headerCnt;    int cellsInfosSize;    unsigned char msgRef8bit;    SmsCodingScheme codingType;    GsmSmsMessage gsmSmsMessage;    std::vector cellsInfos;    // 長短信分段拆分    gsmSmsMessage.SplitMessage(cellsInfos, text, CheckForce7BitEncodeType(), codingType);    isStatusReport = (deliveryCallback == nullptr) ? false : true;    std::shared_ptr tpdu =        gsmSmsMessage.CreateDefaultSubmitSmsTpdu(desAddr, scAddr, text, isStatusReport, codingType);
  ....部分代碼省略.........    std::unique_lock lock(mutex_);    for (int i = 0; i < cellsInfosSize; i++) {        std::shared_ptr indexer = nullptr;        std::string segmentText;        segmentText.append((char *)(cellsInfos[i].encodeData.data()),cellsInfos[i].encodeData.size());   ....部分代碼省略.........   // 編碼PDU        std::shared_ptr encodeInfo = gsmSmsMessage.GetSubmitEncodeInfo(scAddr, isMore);        if (encodeInfo == nullptr) {            SendResultCallBack(indexer, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);            TELEPHONY_LOGE("create encodeInfo encodeInfo nullptr error.");            continue;        }        // 構造填充SmsSendIndexer對象        SetSendIndexerInfo(indexer, encodeInfo, msgRef8bit);        indexer->SetUnSentCellCount(unSentCellCount);        indexer->SetHasCellFailed(hasCellFailed);        SendSmsToRil(indexer);    }}
//判斷是否是IMS網絡域，調用CoreService 不同的接口進行發送void GsmSmsSender::SendSmsToRil(const shared_ptr &smsIndexer){  ....部分代碼省略.........    GsmSimMessageParam smsData;    smsData.refId = refId;    smsData.smscPdu = StringUtils::StringToHex(smsIndexer->GetEncodeSmca());    if (!isImsNetDomain_ && smsIndexer->GetPsResendCount() == 0) {        uint8_t tryCount = smsIndexer->GetCsResendCount();        if (tryCount > 0) {            smsIndexer->UpdatePduForResend();        }        smsData.pdu = StringUtils::StringToHex(smsIndexer->GetEncodePdu());        if (tryCount == 0 && smsIndexer->GetHasMore()) {            TELEPHONY_LOGI("SendSmsMoreMode pdu len = %{public}zu", smsIndexer->GetEncodePdu().size());            CoreManagerInner::GetInstance().SendSmsMoreMode(slotId_,                RadioEvent::RADIO_SEND_SMS_EXPECT_MORE, smsData, shared_from_this());        } else {            TELEPHONY_LOGI("SendSms pdu len = %{public}zu", smsIndexer->GetEncodePdu().size());            CoreManagerInner::GetInstance().SendGsmSms(slotId_,                RadioEvent::RADIO_SEND_SMS, smsData, shared_from_this());        }    } else {        TELEPHONY_LOGI("ims network domain send sms interface.!");        smsIndexer->SetPsResendCount(smsIndexer->GetPsResendCount() + 1);        smsData.pdu = StringUtils::StringToHex(smsIndexer->GetEncodePdu());        if (smsIndexer->GetHasMore()) {            CoreManagerInner::GetInstance().SendSmsMoreMode(slotId_,                RadioEvent::RADIO_SEND_SMS_EXPECT_MORE, smsData, shared_from_this());        } else {            CoreManagerInner::GetInstance().SendGsmSms(slotId_,                RadioEvent::RADIO_SEND_SMS, smsData, shared_from_this());        }    }}

6. 核心服務下發流程

由于 core_service 服務和短彩信服務在同一個進程中，所以我們通過 CoreManagerInner::GetInstance() 來獲取核心服務的單例對象，調用 SendGsmSms 或 SendCdmaSms 函數發送短信。

int32_t CoreManagerInner::SendGsmSms(int32_t slotId, int32_t eventId, GsmSimMessageParam &gsmMessage,    const std::shared_ptr &handler){    if (telRilManager_ == nullptr) {        TELEPHONY_LOGE("telRilManager is null!");        return TELEPHONY_ERR_LOCAL_PTR_NULL;    }    AppExecFwk::Pointer response = AppExecFwk::Get(eventId, gsmMessage.refId);    response->SetOwner(handler);    return telRilManager_->SendGsmSms(slotId, gsmMessage.smscPdu, gsmMessage.pdu, response);}

SendGsmSms 函數將 eventId、refId 和 handler 對象封裝到 response 對象中再轉發到 telRilManager 的 SendGsmSms 函數。

/*********************** TelRilNetwork end ****************************//*********************** TelRilSms start ******************************/int32_t TelRilManager::SendGsmSms(    int32_t slotId, std::string smscPdu, std::string pdu, const AppExecFwk::Pointer &response){    return TaskSchedule(response, "TelRilSms", GetTelRilSms(slotId), &TelRilSms::SendGsmSms, smscPdu, pdu);}

TelRilManager::SendGsmSms 里面只有一個 TaskSchedule 函數調用，其實 TaskSchedule 是個模板函數，就是為了統一下所有任務調用。

template    inline int32_t TaskSchedule(ResponsePtr &_result, const std::string _module, ClassTypePtr &_obj,    FuncType &&_func, ParamTypes &&..._args) const{        if (_func != nullptr) {            // The reason for using native member function access here is to            //   remove std::unique_ptr to prevent copying.            // The reason for not directly using pointers to access member functions is:            //   _obj is a smart pointer, not a native pointer.            return (_obj.*(_func))(std::forward(_args)..., _result);        } else {            TELEPHONY_LOGE("%{public}s - this %{public}p: %{public}s", _module.c_str(), &_obj, "null pointer");            return HRIL_ERR_NULL_POINT;        }}

這個模板函數最終會調用 TelRilSms::SendGsmSms 并且將 response 插入到函數的最后一個參數中。

int32_t TelRilSms::string &smsPdu, std::string &pdu, const AppExecFwk::Pointer &response){    std::shared_ptr telRilRequest = CreateTelRilRequest(HREQ_SMS_SEND_GSM_SMS, response);    if (telRilRequest == nullptr) {        TELEPHONY_LOGE("telRilRequest is nullptr");        return TELEPHONY_ERR_LOCAL_PTR_NULL;    }    TELEPHONY_LOGI("telRilRequest->serialId_:%{public}d", telRilRequest->serialId_);    MessageParcel data;    data.WriteInt32(slotId_);    GsmSmsMessageInfo mGsmSmsMessageInfo = ConstructGsmSendSmsRequestLinkList(smsPdu, pdu);    mGsmSmsMessageInfo.serial = telRilRequest->serialId_;    mGsmSmsMessageInfo.Marshalling(data);    MessageParcel reply;    OHOS::MessageOption option = {OHOS::TF_ASYNC};    if (cellularRadio_->SendRequest(HREQ_SMS_SEND_GSM_SMS, data, reply, option)) {        TELEPHONY_LOGE("cellularRadio_->SendRequest fail");    }    return TELEPHONY_ERR_SUCCESS;}

在 TelRilSms::SendGsmSms 函數中我們調用 CreateTelRilRequest 來將 serialId、response 和 HREQ_SMS_SEND_GSM_SMS 等保存到一個 map 中方便我們后續將短信發送的狀態上報到短彩信服務中。下面 MessageParcel data 將 pdu、smscpdu、serialId 序列化到 data 中，最后通過 cellularRadio_->SendRequest 通過 IPC 將數據發送到 ril_adapter 服務中。進入 Ril 層我們分析 serviceshril_hdfsrchril_hdf.c 這個文件，hril_hdf.c 是 ril_adapter 層加載 vendor 庫、注冊發送和響應函數、啟動讀寫線程、事件調度的入口。

static int32_t RilAdapterDispatch(struct HdfDeviceIoClient *client, int32_t cmd, struct HdfSBuf *data, struct HdfSBuf *reply){    int32_t ret;    static pthread_mutex_t dispatchMutex = PTHREAD_MUTEX_INITIALIZER;    pthread_mutex_lock(&dispatchMutex);    TELEPHONY_LOGI("RilAdapterDispatch cmd:%{public}d", cmd);    ret = DispatchRequest(cmd, data);    pthread_mutex_unlock(&dispatchMutex);    return ret;}
static struct IDeviceIoService g_rilAdapterService = {    .Dispatch = RilAdapterDispatch,    .Open = NULL,    .Release = NULL,};

我們看到 .Dispatch = RilAdapterDispatch 說明事件調度入口就是進入 RilAdapterDispatch 函數。RilAdapterDispatch 函數里面主要加互斥鎖調用 DispatchRequest(cmd, data) 這個事件分發最終調用到 hril_sms 文件的 HRilSms::SendGsmSms 函數。

int32_t HRilSms::SendGsmSms(struct HdfSBuf *data){    struct GsmSmsMessageInfo message;    MessageParcel *parcel = nullptr;    const int32_t COUNT_STRINGS_VALUE = 2;    if (SbufToParcel(data, &parcel)) {        TELEPHONY_LOGE("RilAdapter failed to do SbufToParcel");        return HRIL_ERR_INVALID_PARAMETER;    }    if (parcel == nullptr) {        TELEPHONY_LOGE("parcel int32_t SendGsmSms is nullptr!");        return HRIL_ERR_INVALID_PARAMETER;    }    if (!message.ReadFromParcel(*parcel)) {        TELEPHONY_LOGE("RilAdapter failed to do ReadFromParcel!");        return HRIL_ERR_INVALID_PARAMETER;    }    return RequestWithStrings(        message.serial, HREQ_SMS_SEND_GSM_SMS, COUNT_STRINGS_VALUE, message.smscPdu.c_str(), message.pdu.c_str());}

HRilSms::SendGsmSms 函數將 core_service 發送下來的數據反序列化到 struct GsmSmsMessageInfo message 中，最后調用 RequestWithStrings 函數。最后將數據轉發到 vendor 庫的 at_sms.c 文件的 ReqSendGsmSms 函數。

void ReqSendGsmSms(const ReqDataInfo *requestInfo, const char *const *data, size_t dataLen){//省略非核心代碼//向modem發送AT +CMGS指令    err = SendCommandSmsLock(cmd, smsPdu, "+CMGS:", 0, &responseInfo);    if (err != 0 || (responseInfo != NULL && !responseInfo->success)) {        HandlerSmsResult(&response, &reportInfo, requestInfo, &err, responseInfo);        return;   }//獲取發送后狀態  HandleResult(&err, result, responseInfo, &response);   reportInfo = CreateReportInfo(requestInfo, err, HRIL_RESPONSE, 0);    //上報發送后的狀態   OnSmsReport(GetSlotId(requestInfo), reportInfo, (const uint8_t *)&response, sizeof(HRilSmsResponse));    FreeResponseInfo(responseInfo);}

ReqSendGsmSms 函數將 AT 指令下發到 modem 并且將發送的狀態上報。上報流程和下發流程類似不做具體分析。

7. 核心服務主動上報

首先打開 vendor_adapter.c 我們可以看到 EventListeners 函數。

static void EventListeners(void){    int32_t waitNextTryTime = SLEEP_TIME;    const char *devicePath = DEVICE_PATH;    char atTtyPath[PARAMETER_SIZE] = {0};
    usleep(DELAY_WAIT_MS); // Prevent slow loading of system properties.    if (GetParameter(AT_TTY_PATH, "", atTtyPath, PARAMETER_SIZE) > 0) {        devicePath = atTtyPath;    }
    TELEPHONY_LOGI("opening AT interface %{public}s", devicePath);    AtSetOnUnusual(AtOnUnusual);    for (;;) {        while (g_fd < 0) {            if (devicePath != NULL) {                g_fd = open(devicePath, O_RDWR);            }            if (g_fd >= 0 && !memcmp(devicePath, DEVICE_PATH_DEFAULT, sizeof(DEVICE_PATH_DEFAULT) - 1)) {                struct termios ios;                tcgetattr(g_fd, &ios);                ios.c_lflag = 0;                tcsetattr(g_fd, TCSANOW, &ios);            }            if (g_fd < 0) {                TELEPHONY_LOGE("ril vendorlib,opening AT interface. retrying...");                sleep(waitNextTryTime);            }        }        g_atStatus = 0;        int32_t ret = ATStartReadLoop(g_fd, OnNotifyOps);        if (ret < 0) {            TELEPHONY_LOGE("AtRead error %d
", ret);            return;        }        ModemInit();        sleep(1);        WaitAtClose();    }}

EventListeners 中主要是 ATStartReadLoop 函數將創建一個線程讀取 modem 上報的內容，在 OnNotifyOps 中短信上報內容是 AT +CMT 指令。將調用到 OnSmsReport 函數。

void OnNotifyOps(const char *s, const char *smsPdu){    //省略非核心代碼    if (IsCallNoticeCmd(s)) {        CallReportInfoProcess(s);    } else if (ReportStrWith(s, "+CMT:")) {        HRilSmsResponse smsResponse = {};        smsResponse.pdu = (char *)smsPdu;        reportInfo.notifyId = HNOTI_SMS_NEW_SMS;        OnSmsReport(GetSlotId(NULL), reportInfo, (const uint8_t *)&smsResponse, strlen(smsResponse.pdu));//省略非核心代碼}

OnReport 最終會調到 hril_manager.c 中的 OnSmsReport 函數。

void HRilManager::OnSmsReport(    int32_t slotId, const ReportInfo *reportInfo, const uint8_t *response, size_t responseLen){    OnReport(hrilSms_, slotId, reportInfo, response, responseLen);}

在 OnReport 函數中查找 notiMemberFuncMap 的 HNOTI_SMS_NEW_SMS 對應的函數指針。

// Notification    notiMemberFuncMap_[HNOTI_SMS_NEW_SMS] = &HRilSms::NewSmsNotify;    notiMemberFuncMap_[HNOTI_SMS_NEW_CDMA_SMS] =&HRilSms::NewCdmaSmsNotify;    notiMemberFuncMap_[HNOTI_SMS_STATUS_REPORT] = &HRilSms::SmsStatusReportNotify;    notiMemberFuncMap_[HNOTI_SMS_NEW_SMS_STORED_ON_SIM] = &HRilSms::NewSmsStoredOnSimNotify;    notiMemberFuncMap_[HNOTI_CB_CONFIG_REPORT] = &HRilSms::CBConfigNotify;
int32_t HRilSms::NewSmsNotify(int32_t indType, const HRilErrNumber e, const void *response, size_t responseLen){    //省略部分代碼    std::unique_ptr parcel = std::make_unique();    if (parcel == nullptr) {        TELEPHONY_LOGE("parcel in NewSmsNotify is nullptr!");        return HRIL_ERR_GENERIC_FAILURE;    }    if (!parcel->WriteInterfaceToken(HRIL_INTERFACE_TOKEN)) {        TELEPHONY_LOGE("write interface token failed.");        return HRIL_ERR_GENERIC_FAILURE;    }    struct HdfSBuf *dataSbuf = ParcelToSbuf(parcel.get());    HRilResponseHeadInfo headInfo = {0};    headInfo.slotId = GetSlotId();    headInfo.type = (HRilResponseTypes)indType;    if (!HdfSbufWriteUnpadBuffer(dataSbuf, (const uint8_t *)&headInfo, sizeof(HRilResponseHeadInfo))) {        HdfSbufRecycle(dataSbuf);        return HRIL_ERR_GENERIC_FAILURE;    }    smsMessageInfo.Marshalling(*parcel.get());    indType = static_cast(ConvertIntToRadioNoticeType(indType));   //通過IPC上報數據到core_service   if (DataSbuf(dataSbuf, indType) == HRIL_ERR_GENERIC_FAILURE) {        TELEPHONY_LOGE("DataSbuf in NewSmsNotify is failed!");        return HRIL_ERR_GENERIC_FAILURE;    }    return HRIL_ERR_SUCCESS;}

在 NewSmsNotify 函數我們主要將短信 PDU、ID、類型序列化通過 IPC 上傳到 core_service。core_service 在收到上報數據也只是轉發到短彩信服務，這部分內容自行分析即可。

四、總結

開源項目的輸出就是為了給開發者提供更多的學習途徑，文本詳細介紹了 OpenHarmony 電話子系統短彩信模塊，從 JS 到 Framework 短彩信服務，以及跟 CoreService(核心服務)、RilAdapter 交互流程分析；提取出比較重要的代碼片段分析了短信發送和短信接收流程，最終完成了整個框架層的調用過程。希望通過對 OpenHarmony 短彩信 Framework 層代碼的分析和解讀，能幫助廣大開發者更全面地認識 OpenHarmony 短彩信模塊的功能業務流程，更容易地適配自家的 modem 硬件，以此達到快速開發和優化功能的目的。

作為 OpenHarmony 開源項目的共建單位之一，深開鴻有責任、有義務、更有能力持續完善 OpenHarmony 的技術能力、不斷以創新技術加速開源生態建設的布局。希望有更多的開發者參與到 OpenHarmony 生態的共建，共同推動生態繁榮。

審核編輯 ：李倩