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 "gsm_sms_receive_handler.h"
17
18 #include "core_manager_inner.h"
19 #include "gsm_sms_message.h"
20 #include "radio_event.h"
21 #include "sms_base_message.h"
22 #include "sms_hisysevent.h"
23 #include "sms_receive_indexer.h"
24 #include "string_utils.h"
25 #include "telephony_log_wrapper.h"
26
27 namespace OHOS {
28 namespace Telephony {
29 using namespace std;
GsmSmsReceiveHandler(const shared_ptr<AppExecFwk::EventRunner> & runner,int32_t slotId)30 GsmSmsReceiveHandler::GsmSmsReceiveHandler(const shared_ptr<AppExecFwk::EventRunner> &runner, int32_t slotId)
31 : SmsReceiveHandler(runner, slotId)
32 {}
33
~GsmSmsReceiveHandler()34 GsmSmsReceiveHandler::~GsmSmsReceiveHandler()
35 {
36 if (smsCbHandler_ != nullptr) {
37 smsCbHandler_->UnRegisterHandler();
38 }
39 }
40
Init()41 void GsmSmsReceiveHandler::Init()
42 {
43 if (!RegisterHandler()) {
44 TELEPHONY_LOGI("GsmSmsSender::Init Register RADIO_SMS_STATUS fail.");
45 }
46 smsCbRunner_ = AppExecFwk::EventRunner::Create("GsmSmsCbHandler" + to_string(slotId_));
47 if (smsCbRunner_ == nullptr) {
48 TELEPHONY_LOGE("failed to create GsmSmsCbHandler");
49 return;
50 }
51 smsCbHandler_ = std::make_shared<GsmSmsCbHandler>(smsCbRunner_, slotId_);
52 if (smsCbHandler_ == nullptr) {
53 TELEPHONY_LOGE("failed to create GsmSmsCbHandler");
54 return;
55 }
56 smsCbHandler_->Init();
57 smsCbRunner_->Run();
58 TELEPHONY_LOGI("smsCbHandler_->Run().");
59 }
60
RegisterHandler()61 bool GsmSmsReceiveHandler::RegisterHandler()
62 {
63 TELEPHONY_LOGI("GsmSmsReceiveHandler::RegisteHandler Register RADIO_GSM_SMS ok.");
64 CoreManagerInner::GetInstance().RegisterCoreNotify(
65 slotId_, shared_from_this(), RadioEvent::RADIO_GSM_SMS, nullptr);
66 return true;
67 }
68
UnRegisterHandler()69 void GsmSmsReceiveHandler::UnRegisterHandler()
70 {
71 TELEPHONY_LOGI("SmsReceiveHandler::UnRegisterHandler::slotId= %{public}d", slotId_);
72 CoreManagerInner::GetInstance().UnRegisterCoreNotify(
73 slotId_, shared_from_this(), RadioEvent::RADIO_GSM_SMS);
74 if (smsCbHandler_ != nullptr) {
75 smsCbRunner_->Stop();
76 }
77 }
78
HandleSmsByType(const shared_ptr<SmsBaseMessage> & smsBaseMessage)79 int32_t GsmSmsReceiveHandler::HandleSmsByType(const shared_ptr<SmsBaseMessage> &smsBaseMessage)
80 {
81 TELEPHONY_LOGI("GsmSmsReceiveHandler:: HandleSmsByType");
82 if (smsBaseMessage == nullptr) {
83 TELEPHONY_LOGE("BaseMessage is null.");
84 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
85 }
86 GsmSmsMessage *message = (GsmSmsMessage *)smsBaseMessage.get();
87 if (message->IsSpecialMessage()) {
88 TELEPHONY_LOGI("GsmSmsReceiveHandler:: IsSpecialMessage");
89 return AckIncomeCause::SMS_ACK_RESULT_OK;
90 }
91 if (!CheckSmsCapable()) {
92 TELEPHONY_LOGI("sms receive capable unSupport");
93 SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
94 SmsMmsErrorCode::SMS_ERROR_EMPTY_INPUT_PARAMETER, "sms receive capable unsupported");
95 return AckIncomeCause::SMS_ACK_PROCESSED;
96 }
97
98 shared_ptr<SmsReceiveIndexer> indexer;
99 if (!message->IsConcatMsg()) {
100 indexer = make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
101 message->GetDestPort(), !message->GetGsm(), false, message->GetOriginatingAddress(),
102 message->GetVisibleOriginatingAddress(), message->GetVisibleMessageBody());
103 } else {
104 std::shared_ptr<SmsConcat> smsConcat = message->GetConcatMsg();
105 if (smsConcat == nullptr) {
106 TELEPHONY_LOGE("Concat is null.");
107 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
108 }
109 indexer = make_shared<SmsReceiveIndexer>(message->GetRawPdu(), message->GetScTimestamp(),
110 message->GetDestPort(), !message->GetGsm(), message->GetOriginatingAddress(),
111 message->GetVisibleOriginatingAddress(), smsConcat->msgRef, smsConcat->seqNum, smsConcat->totalSeg,
112 false, message->GetVisibleMessageBody());
113 }
114 if (indexer == nullptr) {
115 TELEPHONY_LOGE("indexer is null.");
116 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
117 }
118 indexer->SetRawUserData(message->GetRawUserData());
119 if (indexer->GetIsText() && IsRepeatedMessagePart(indexer)) {
120 TELEPHONY_LOGE("Ack repeated error.");
121 SmsHiSysEvent::WriteSmsReceiveFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
122 SmsMmsErrorCode::SMS_ERROR_REPEATED_ERROR, "gsm message repeated error");
123 return AckIncomeCause::SMS_ACK_REPEATED_ERROR;
124 }
125 if (!AddMsgToDB(indexer)) {
126 return AckIncomeCause::SMS_ACK_UNKNOWN_ERROR;
127 }
128 CombineMessagePart(indexer);
129 return AckIncomeCause::SMS_ACK_RESULT_OK;
130 }
131
ReplySmsToSmsc(int result,const shared_ptr<SmsBaseMessage> & response)132 void GsmSmsReceiveHandler::ReplySmsToSmsc(int result, const shared_ptr<SmsBaseMessage> &response)
133 {
134 TELEPHONY_LOGI("GsmSmsReceiveHandler::ReplySmsToSmsc ackResult %{public}d", result);
135 CoreManagerInner::GetInstance().SendSmsAck(
136 slotId_, SMS_EVENT_NEW_SMS_REPLY, result == AckIncomeCause::SMS_ACK_RESULT_OK, result, shared_from_this());
137 }
138
TransformMessageInfo(const shared_ptr<SmsMessageInfo> & info)139 shared_ptr<SmsBaseMessage> GsmSmsReceiveHandler::TransformMessageInfo(const shared_ptr<SmsMessageInfo> &info)
140 {
141 std::shared_ptr<SmsBaseMessage> baseMessage = nullptr;
142 if (info == nullptr) {
143 TELEPHONY_LOGE("MessageInfo is null.");
144 return baseMessage;
145 }
146 std::string pdu = StringUtils::StringToHex(info->pdu);
147 baseMessage = GsmSmsMessage::CreateMessage(pdu);
148 return baseMessage;
149 }
150 } // namespace Telephony
151 } // namespace OHOS