1 /*
2 * Copyright (C) 2021 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 "cdma_sms_receive_handler.h"
17
18 #include "cdma_sms_message.h"
19 #include "cdma_sms_sender.h"
20 #include "cdma_sms_types.h"
21 #include "common_event.h"
22 #include "common_event_manager.h"
23 #include "common_event_support.h"
24 #include "core_manager_inner.h"
25 #include "radio_event.h"
26 #include "singleton.h"
27 #include "sms_hisysevent.h"
28 #include "string_utils.h"
29 #include "telephony_log_wrapper.h"
30 #include "telephony_permission.h"
31 #include "want.h"
32
33 namespace OHOS {
34 namespace Telephony {
35 using namespace OHOS::EventFwk;
CdmaSmsReceiveHandler(const std::shared_ptr<AppExecFwk::EventRunner> & runner,int32_t slotId)36 CdmaSmsReceiveHandler::CdmaSmsReceiveHandler(const std::shared_ptr<AppExecFwk::EventRunner> &runner, int32_t slotId)
37 : SmsReceiveHandler(runner, slotId)
38 {
39 TELEPHONY_LOGI("%{public}d", slotId_);
40 }
41
HandleSmsByType(const std::shared_ptr<SmsBaseMessage> & smsBaseMessage)42 int32_t CdmaSmsReceiveHandler::HandleSmsByType(const std::shared_ptr<SmsBaseMessage> &smsBaseMessage)
43 {
44 if (smsBaseMessage == nullptr) {
45 TELEPHONY_LOGE("SmsBaseMessage is null!");
46 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
47 }
48 CdmaSmsMessage *message = static_cast<CdmaSmsMessage *>(smsBaseMessage.get());
49 if (message->IsBroadcastMsg()) {
50 SendCBBroadcast(smsBaseMessage);
51 return AckIncomeCause::SMS_ACK_RESULT_OK;
52 }
53 int service = message->GetTransTeleService();
54 if (SMS_TRANS_TELESVC_WEMT == service || SMS_TRANS_TELESVC_CMT_95 == service) {
55 if (message->IsStatusReport() && !cdmaSmsSender_.expired()) {
56 std::shared_ptr<SmsSender> smsSender = cdmaSmsSender_.lock();
57 CdmaSmsSender *cdmaSend = static_cast<CdmaSmsSender *>(smsSender.get());
58 std::shared_ptr<SmsReceiveIndexer> statusInfo = std::make_shared<SmsReceiveIndexer>();
59 if (statusInfo == nullptr) {
60 TELEPHONY_LOGE("statusInfo is null!");
61 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
62 }
63 statusInfo->SetMsgRefId(message->GetMsgRef());
64 statusInfo->SetPdu(message->GetRawPdu());
65 cdmaSend->ReceiveStatusReport(statusInfo);
66 return AckIncomeCause::SMS_ACK_RESULT_OK;
67 }
68 } else {
69 return AckIncomeCause::SMS_ACK_RESULT_OK;
70 }
71 // Encapsulate key information to Tracker
72 std::shared_ptr<SmsReceiveIndexer> indexer;
73 if (!message->IsConcatMsg()) {
74 indexer = std::make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
75 message->GetDestPort(), true, false, message->GetOriginatingAddress(),
76 message->GetVisibleOriginatingAddress(), message->GetVisibleMessageBody());
77 } else {
78 std::shared_ptr<SmsConcat> smsConcat = message->GetConcatMsg();
79 if (smsConcat == nullptr) {
80 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
81 }
82 indexer = std::make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
83 message->GetDestPort(), true, message->GetOriginatingAddress(), message->GetVisibleOriginatingAddress(),
84 smsConcat->msgRef, smsConcat->seqNum, smsConcat->totalSeg, false, message->GetVisibleMessageBody());
85 }
86 // add messages to the database
87 if (indexer == nullptr) {
88 TELEPHONY_LOGE("indexer is nullptr.");
89 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
90 }
91 if (indexer->GetIsText() && IsRepeatedMessagePart(indexer)) {
92 SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
93 SmsMmsErrorCode::SMS_ERROR_REPEATED_ERROR, "cdma message repeated error");
94 return AckIncomeCause::SMS_ACK_REPEATED_ERROR;
95 }
96 if (!AddMsgToDB(indexer)) {
97 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
98 }
99 CombineMessagePart(indexer);
100 return AckIncomeCause::SMS_ACK_RESULT_OK;
101 }
102
ReplySmsToSmsc(int result,const std::shared_ptr<SmsBaseMessage> & response)103 void CdmaSmsReceiveHandler::ReplySmsToSmsc(int result, const std::shared_ptr<SmsBaseMessage> &response)
104 {
105 TELEPHONY_LOGI("Reply To Smsc ackResult %{public}d", result);
106 CoreManagerInner::GetInstance().SendSmsAck(
107 slotId_, SMS_EVENT_NEW_SMS_REPLY, result == AckIncomeCause::SMS_ACK_RESULT_OK, result, shared_from_this());
108 }
109
SetCdmaSender(const std::weak_ptr<SmsSender> & smsSender)110 void CdmaSmsReceiveHandler::SetCdmaSender(const std::weak_ptr<SmsSender> &smsSender)
111 {
112 cdmaSmsSender_ = smsSender;
113 }
114
TransformMessageInfo(const std::shared_ptr<SmsMessageInfo> & info)115 std::shared_ptr<SmsBaseMessage> CdmaSmsReceiveHandler::TransformMessageInfo(
116 const std::shared_ptr<SmsMessageInfo> &info)
117 {
118 std::shared_ptr<SmsBaseMessage> baseMessage = nullptr;
119 if (info == nullptr) {
120 TELEPHONY_LOGE("SmsBaseMessage is null!");
121 return baseMessage;
122 }
123 std::string pdu = StringUtils::StringToHex(info->pdu);
124 baseMessage = CdmaSmsMessage::CreateMessage(pdu);
125 return baseMessage;
126 }
127
Init()128 void CdmaSmsReceiveHandler::Init()
129 {
130 if (!RegisterHandler()) {
131 TELEPHONY_LOGI("GsmSmsSender::Init Register RADIO_SMS_STATUS fail.");
132 }
133 }
134
RegisterHandler()135 bool CdmaSmsReceiveHandler::RegisterHandler()
136 {
137 TELEPHONY_LOGI("CdmaSmsReceiveHandler::RegisteHandler Register RADIO_CDMA_SMS ok.");
138 CoreManagerInner::GetInstance().RegisterCoreNotify(
139 slotId_, shared_from_this(), RadioEvent::RADIO_CDMA_SMS, nullptr);
140 return true;
141 }
142
UnRegisterHandler()143 void CdmaSmsReceiveHandler::UnRegisterHandler()
144 {
145 TELEPHONY_LOGI("CdmaSmsReceiveHandler::UnRegisterHandler::slotId= %{public}d", slotId_);
146 CoreManagerInner::GetInstance().UnRegisterCoreNotify(slotId_, shared_from_this(), RadioEvent::RADIO_CDMA_SMS);
147 }
148
SendCBBroadcast(const std::shared_ptr<SmsBaseMessage> & smsBaseMessage)149 bool CdmaSmsReceiveHandler::SendCBBroadcast(const std::shared_ptr<SmsBaseMessage> &smsBaseMessage)
150 {
151 if (smsBaseMessage == nullptr) {
152 TELEPHONY_LOGE("smsBaseMessage is nullptr.");
153 return false;
154 }
155
156 bool isMergency = false;
157 SmsCbData::CbData sendData;
158 GetCBData(smsBaseMessage, sendData, isMergency);
159 EventFwk::Want want;
160 EventFwk::CommonEventData data;
161 if (isMergency) {
162 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_EMERGENCY_CB_RECEIVE_COMPLETED);
163 } else {
164 want.SetAction(EventFwk::CommonEventSupport::COMMON_EVENT_SMS_CB_RECEIVE_COMPLETED);
165 }
166 SetCBBroadcastParam(want, sendData);
167 data.SetWant(want);
168 EventFwk::CommonEventPublishInfo publishInfo;
169 publishInfo.SetOrdered(true);
170 std::vector<std::string> cdmaCbPermissions;
171 cdmaCbPermissions.emplace_back(Permission::RECEIVE_MESSAGES);
172 publishInfo.SetSubscriberPermissions(cdmaCbPermissions);
173 bool publishResult = EventFwk::CommonEventManager::PublishCommonEvent(data, publishInfo, nullptr);
174 if (!publishResult) {
175 TELEPHONY_LOGE("SendBroadcast PublishBroadcastEvent result fail");
176 SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::CELL_BROAD_CAST,
177 SmsMmsErrorCode::SMS_ERROR_PUBLISH_COMMON_EVENT_FAIL, "publish cell broadcast event fail");
178 return false;
179 }
180 DelayedSingleton<SmsHiSysEvent>::GetInstance()->SetCbBroadcastStartTime();
181 return true;
182 }
183
SetCBBroadcastParam(AppExecFwk::Want & want,SmsCbData::CbData & sendData)184 bool CdmaSmsReceiveHandler::SetCBBroadcastParam(AppExecFwk::Want &want, SmsCbData::CbData &sendData)
185 {
186 const int lac = -1;
187 const int cid = -1;
188 want.SetParam(SmsCbData::GEO_SCOPE, static_cast<char>(sendData.geoScope));
189 want.SetParam(SmsCbData::CMAS_RESPONSE, static_cast<char>(sendData.cmasRes));
190 want.SetParam(SmsCbData::SLOT_ID, static_cast<int>(slotId_));
191 want.SetParam(SmsCbData::FORMAT, static_cast<char>(sendData.format));
192 want.SetParam(SmsCbData::CB_MSG_TYPE, static_cast<char>(sendData.msgType));
193 want.SetParam(SmsCbData::MSG_ID, static_cast<int>(sendData.msgId));
194 want.SetParam(SmsCbData::SERVICE_CATEGORY, static_cast<int>(sendData.category));
195 want.SetParam(SmsCbData::LANG_TYPE, static_cast<char>(sendData.langType));
196 want.SetParam(SmsCbData::PRIORITY, static_cast<char>(sendData.priority));
197 want.SetParam(SmsCbData::MSG_BODY, sendData.msgBody);
198 want.SetParam(SmsCbData::CMAS_CLASS, static_cast<char>(sendData.cmasClass));
199 want.SetParam(SmsCbData::CMAS_CATEGORY, static_cast<char>(sendData.cmasCate));
200 want.SetParam(SmsCbData::SEVERITY, static_cast<char>(sendData.severity));
201 want.SetParam(SmsCbData::URGENCY, static_cast<char>(sendData.urgency));
202 want.SetParam(SmsCbData::CERTAINTY, static_cast<char>(sendData.certainty));
203 want.SetParam(SmsCbData::IS_CMAS_MESSAGE, sendData.isCmas);
204 want.SetParam(SmsCbData::SERIAL_NUM, static_cast<int>(sendData.serial));
205 want.SetParam(SmsCbData::RECV_TIME, std::to_string(sendData.recvTime));
206 want.SetParam(SmsCbData::DCS, static_cast<char>(sendData.dcs));
207 want.SetParam(SmsCbData::IS_ETWS_PRIMARY, sendData.isPrimary);
208 want.SetParam(SmsCbData::IS_ETWS_MESSAGE, sendData.isEtws);
209 want.SetParam(SmsCbData::PLMN, StringUtils::ToUtf8(plmn_));
210 want.SetParam(SmsCbData::LAC, static_cast<int>(lac));
211 want.SetParam(SmsCbData::CID, static_cast<int>(cid));
212 want.SetParam(SmsCbData::WARNING_TYPE, static_cast<int>(sendData.warnType));
213 return true;
214 }
215
GetCBData(const std::shared_ptr<SmsBaseMessage> & smsBaseMessage,SmsCbData::CbData & sendData,bool & isEmergency)216 void CdmaSmsReceiveHandler::GetCBData(
217 const std::shared_ptr<SmsBaseMessage> &smsBaseMessage, SmsCbData::CbData &sendData, bool &isEmergency)
218 {
219 if (smsBaseMessage == nullptr) {
220 TELEPHONY_LOGE("smsBaseMessage is nullptr.");
221 return;
222 }
223 CdmaSmsMessage *message = static_cast<CdmaSmsMessage *>(smsBaseMessage.get());
224 if (message == nullptr) {
225 TELEPHONY_LOGE("message is nullptr.");
226 return;
227 }
228
229 sendData.format = message->GetFormat();
230 sendData.geoScope = message->GetGeoScope();
231 sendData.msgId = message->GetMessageId();
232 sendData.serial = message->GetMessageId();
233 sendData.category = message->GetServiceCategoty();
234 sendData.langType = static_cast<uint8_t>(message->GetLanguage());
235 sendData.msgBody = message->GetVisibleMessageBody();
236 sendData.priority = message->GetPriority();
237 sendData.isCmas = message->IsCMAS();
238 sendData.cmasClass = message->GetCMASMessageClass();
239 sendData.cmasCate = message->GetCMASCategory();
240 sendData.severity = message->GetCMASSeverity();
241 sendData.urgency = message->GetCMASUrgency();
242 sendData.certainty = message->GetCMASCertainty();
243 sendData.recvTime = message->GetReceTime();
244 sendData.langType = static_cast<uint8_t>(message->GetLanguage());
245 isEmergency = message->IsEmergencyMsg();
246 plmn_ = CoreManagerInner::GetInstance().GetOperatorNumeric(slotId_);
247 }
248 } // namespace Telephony
249 } // namespace OHOS