1 /*
2 * Copyright (C) 2021-2023 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 "sms_send_manager.h"
17
18 #include <functional>
19 #include <memory.h>
20
21 #include "cdma_sms_message.h"
22 #include "gsm_sms_message.h"
23 #include "gsm_sms_tpdu_codec.h"
24 #include "i_sms_service_interface.h"
25 #include "sms_hisysevent.h"
26 #include "sms_receive_manager.h"
27 #include "telephony_errors.h"
28 #include "telephony_log_wrapper.h"
29
30 namespace OHOS {
31 namespace Telephony {
32 static constexpr const char *NET_TYPE_GSM_STRING = "3gpp";
33 static constexpr const char *NET_TYPE_CDMA_STRING = "3gpp2";
34 static constexpr const char *NET_TYPE_UNKNOWN_STRING = "unknown";
35
36 using namespace std;
SmsSendManager(int32_t slotId)37 SmsSendManager::SmsSendManager(int32_t slotId) : slotId_(slotId) {}
38
~SmsSendManager()39 SmsSendManager::~SmsSendManager()
40 {
41 if (gsmSmsSender_ != nullptr && networkManager_ != nullptr) {
42 if (auto id = gsmSmsSender_->GetNetworkId(); id.has_value()) {
43 networkManager_->NetworkUnregister(id.value());
44 }
45 }
46 if (cdmaSmsSender_ != nullptr && networkManager_ != nullptr) {
47 if (auto id = cdmaSmsSender_->GetNetworkId(); id.has_value()) {
48 networkManager_->NetworkUnregister(id.value());
49 }
50 }
51 if (networkManager_ != nullptr) {
52 networkManager_->UnRegisterHandler();
53 }
54 }
55
Init()56 void SmsSendManager::Init()
57 {
58 gsmSmsSender_ =
59 std::make_shared<GsmSmsSender>(slotId_, bind(&SmsSendManager::RetriedSmsDelivery, this, placeholders::_1));
60 if (gsmSmsSender_ == nullptr) {
61 TELEPHONY_LOGE("failed to create GsmSmsSender");
62 return;
63 }
64 gsmSmsSender_->Init();
65
66 cdmaSmsSender_ =
67 std::make_shared<CdmaSmsSender>(slotId_, bind(&SmsSendManager::RetriedSmsDelivery, this, placeholders::_1));
68 if (cdmaSmsSender_ == nullptr) {
69 TELEPHONY_LOGE("failed to create CdmaSmsSender");
70 return;
71 }
72 cdmaSmsSender_->Init();
73 InitNetworkHandle();
74 }
75
InitNetworkHandle()76 void SmsSendManager::InitNetworkHandle()
77 {
78 networkManager_ = std::make_shared<SmsNetworkPolicyManager>(slotId_);
79 if (networkManager_ == nullptr) {
80 TELEPHONY_LOGE("failed to create networkManager");
81 return;
82 }
83 networkManager_->Init();
84 TELEPHONY_LOGI("Init SmsSendManager successfully.");
85 if (auto ret = networkManager_->NetworkRegister(
86 std::bind(&SmsSender::SetNetworkState, gsmSmsSender_, std::placeholders::_1, std::placeholders::_2));
87 ret.has_value()) {
88 gsmSmsSender_->SetNetworkId(ret);
89 } else {
90 TELEPHONY_LOGE("gsm failed to register networkManager");
91 }
92 if (auto ret = networkManager_->NetworkRegister(
93 std::bind(&SmsSender::SetNetworkState, cdmaSmsSender_, std::placeholders::_1, std::placeholders::_2));
94 ret.has_value()) {
95 cdmaSmsSender_->SetNetworkId(ret);
96 } else {
97 TELEPHONY_LOGE("cdma failed to register networkManager");
98 }
99 }
100
TextBasedSmsDelivery(const string & desAddr,const string & scAddr,const string & text,const sptr<ISendShortMessageCallback> & sendCallback,const sptr<IDeliveryShortMessageCallback> & deliveryCallback)101 void SmsSendManager::TextBasedSmsDelivery(const string &desAddr, const string &scAddr, const string &text,
102 const sptr<ISendShortMessageCallback> &sendCallback,
103 const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
104 {
105 if (desAddr.empty() || text.empty()) {
106 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
107 TELEPHONY_LOGE("TextBasedSmsDelivery::param Set Error.");
108 return;
109 }
110 if (networkManager_ == nullptr) {
111 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
112 TELEPHONY_LOGE("TextBasedSmsDelivery::networkManager nullptr error.");
113 return;
114 }
115 if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr) {
116 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
117 TELEPHONY_LOGE("gsmSmsSender or cdmaSmsSender nullptr error.");
118 return;
119 }
120
121 NetWorkType netWorkType = networkManager_->GetNetWorkType();
122 TELEPHONY_LOGI("netWorkType = %{public}d.", netWorkType);
123 if (netWorkType == NetWorkType::NET_TYPE_GSM) {
124 gsmSmsSender_->RegisterImsHandler();
125 gsmSmsSender_->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
126 } else if (netWorkType == NetWorkType::NET_TYPE_CDMA) {
127 cdmaSmsSender_->RegisterImsHandler();
128 cdmaSmsSender_->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
129 } else {
130 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE);
131 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
132 SmsMmsErrorCode::SMS_ERROR_UNKNOWN_NETWORK_TYPE, "text sms network unknown send error");
133 TELEPHONY_LOGI("network unknown send error.");
134 }
135 }
136
DataBasedSmsDelivery(const string & desAddr,const string & scAddr,uint16_t port,const uint8_t * data,uint16_t dataLen,const sptr<ISendShortMessageCallback> & sendCallback,const sptr<IDeliveryShortMessageCallback> & deliveryCallback)137 void SmsSendManager::DataBasedSmsDelivery(const string &desAddr, const string &scAddr, uint16_t port,
138 const uint8_t *data, uint16_t dataLen, const sptr<ISendShortMessageCallback> &sendCallback,
139 const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
140 {
141 if (desAddr.empty() || data == nullptr) {
142 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
143 TELEPHONY_LOGE("DataBasedSmsDelivery::param Set Error.");
144 return;
145 }
146 if (networkManager_ == nullptr) {
147 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
148 TELEPHONY_LOGE("DataBasedSmsDelivery::networkManager nullptr error.");
149 return;
150 }
151 if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr) {
152 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
153 TELEPHONY_LOGE("gsmSmsSender or cdmaSmsSender nullptr error.");
154 return;
155 }
156
157 NetWorkType netWorkType = networkManager_->GetNetWorkType();
158 if (netWorkType == NetWorkType::NET_TYPE_GSM) {
159 gsmSmsSender_->RegisterImsHandler();
160 gsmSmsSender_->DataBasedSmsDelivery(desAddr, scAddr, port, data, dataLen, sendCallback, deliveryCallback);
161 } else if (netWorkType == NetWorkType::NET_TYPE_CDMA) {
162 cdmaSmsSender_->RegisterImsHandler();
163 cdmaSmsSender_->DataBasedSmsDelivery(desAddr, scAddr, port, data, dataLen, sendCallback, deliveryCallback);
164 } else {
165 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE);
166 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
167 SmsMmsErrorCode::SMS_ERROR_UNKNOWN_NETWORK_TYPE, "data sms network unknown send error");
168 TELEPHONY_LOGI("network unknown send error.");
169 }
170 }
171
RetriedSmsDelivery(const shared_ptr<SmsSendIndexer> smsIndexer)172 void SmsSendManager::RetriedSmsDelivery(const shared_ptr<SmsSendIndexer> smsIndexer)
173 {
174 if (smsIndexer == nullptr) {
175 TELEPHONY_LOGI("RetriedSmsDelivery::smsIndexer is nullptr error.");
176 return;
177 }
178 if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr || networkManager_ == nullptr) {
179 TELEPHONY_LOGE("Sender or network nullptr error.");
180 return;
181 }
182
183 NetWorkType oldNetWorkType = smsIndexer->GetNetWorkType();
184 NetWorkType newNetWorkType = networkManager_->GetNetWorkType();
185 if (oldNetWorkType != newNetWorkType) {
186 smsIndexer->SetNetWorkType(newNetWorkType);
187 shared_ptr<SmsSendIndexer> indexer = smsIndexer;
188 switch (newNetWorkType) {
189 case NetWorkType::NET_TYPE_CDMA:
190 if (smsIndexer->GetIsText()) {
191 cdmaSmsSender_->ResendTextDelivery(indexer);
192 } else {
193 cdmaSmsSender_->ResendDataDelivery(indexer);
194 }
195 break;
196 case NetWorkType::NET_TYPE_GSM:
197 if (smsIndexer->GetIsText()) {
198 gsmSmsSender_->ResendTextDelivery(indexer);
199 } else {
200 gsmSmsSender_->ResendDataDelivery(indexer);
201 }
202 break;
203 default:
204 SmsSender::SendResultCallBack(
205 smsIndexer, ISendShortMessageCallback::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE);
206 TELEPHONY_LOGI("network unknown send error.");
207 break;
208 }
209 return;
210 }
211
212 if (newNetWorkType == NetWorkType::NET_TYPE_GSM) {
213 gsmSmsSender_->SendSmsToRil(smsIndexer);
214 } else if (newNetWorkType == NetWorkType::NET_TYPE_CDMA) {
215 cdmaSmsSender_->SendSmsToRil(smsIndexer);
216 } else {
217 SmsSender::SendResultCallBack(smsIndexer, ISendShortMessageCallback::SEND_SMS_FAILURE_SERVICE_UNAVAILABLE);
218 TELEPHONY_LOGI("Network Unknown.");
219 }
220 }
221
SplitMessage(const std::string & message,std::vector<std::u16string> & splitMessage)222 int32_t SmsSendManager::SplitMessage(const std::string &message, std::vector<std::u16string> &splitMessage)
223 {
224 if (networkManager_ == nullptr) {
225 TELEPHONY_LOGE("SmsSendManager::SplitMessage networkManager nullptr Error.");
226 return TELEPHONY_ERR_LOCAL_PTR_NULL;
227 }
228
229 DataCodingScheme codingType;
230 std::vector<struct SplitInfo> cellsInfos;
231 NetWorkType netWorkType = networkManager_->GetNetWorkType();
232 std::string addr;
233 switch (netWorkType) {
234 case NetWorkType::NET_TYPE_CDMA: {
235 GsmSmsMessage gsmSmsMessage;
236 gsmSmsMessage.SetSmsCodingNationalType(SmsSender::GetSmsCodingNationalType(slotId_));
237 gsmSmsMessage.SplitMessage(cellsInfos, message, false, codingType, false, addr);
238 break;
239 }
240 case NetWorkType::NET_TYPE_GSM: {
241 CdmaSmsMessage cdmaSmsMessage;
242 cdmaSmsMessage.SplitMessage(cellsInfos, message, false, codingType, false, addr);
243 break;
244 }
245 default:
246 TELEPHONY_LOGE("netWorkType is NET_TYPE_UNKNOWN");
247 break;
248 }
249
250 for (auto &item : cellsInfos) {
251 splitMessage.emplace_back(StringUtils::ToUtf16(item.text));
252 }
253 return TELEPHONY_ERR_SUCCESS;
254 }
255
GetSmsSegmentsInfo(const std::string & message,bool force7BitCode,LengthInfo & lenInfo)256 int32_t SmsSendManager::GetSmsSegmentsInfo(const std::string &message, bool force7BitCode, LengthInfo &lenInfo)
257 {
258 if (networkManager_ == nullptr) {
259 TELEPHONY_LOGE("GetSmsSegmentsInfo networkManager_ Nullptr Error.");
260 return TELEPHONY_ERR_LOCAL_PTR_NULL;
261 }
262 NetWorkType netWorkType = networkManager_->GetNetWorkType();
263 switch (netWorkType) {
264 case NetWorkType::NET_TYPE_CDMA: {
265 CdmaSmsMessage cdmaSmsMessage;
266 return cdmaSmsMessage.GetSmsSegmentsInfo(message, force7BitCode, lenInfo);
267 }
268 case NetWorkType::NET_TYPE_GSM: {
269 GsmSmsMessage gsmSmsMessage;
270 return gsmSmsMessage.GetSmsSegmentsInfo(message, force7BitCode, lenInfo);
271 }
272 default:
273 TELEPHONY_LOGE("netWorkType is NET_TYPE_UNKNOWN");
274 break;
275 }
276 return TELEPHONY_ERR_UNKNOWN_NETWORK_TYPE;
277 }
278
GetCdmaSmsSender() const279 std::shared_ptr<SmsSender> SmsSendManager::GetCdmaSmsSender() const
280 {
281 return cdmaSmsSender_;
282 }
283
IsImsSmsSupported(int32_t slotId,bool & isSupported)284 int32_t SmsSendManager::IsImsSmsSupported(int32_t slotId, bool &isSupported)
285 {
286 if (networkManager_ == nullptr) {
287 TELEPHONY_LOGE("networkManager is nullptr error.");
288 return TELEPHONY_ERR_LOCAL_PTR_NULL;
289 }
290
291 if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr || networkManager_ == nullptr) {
292 TELEPHONY_LOGE("Sender or network nullptr error.");
293 return TELEPHONY_ERR_LOCAL_PTR_NULL;
294 }
295
296 NetWorkType newNetWorkType = networkManager_->GetNetWorkType();
297 switch (newNetWorkType) {
298 case NetWorkType::NET_TYPE_GSM:
299 return gsmSmsSender_->IsImsSmsSupported(slotId, isSupported);
300 case NetWorkType::NET_TYPE_CDMA:
301 return cdmaSmsSender_->IsImsSmsSupported(slotId, isSupported);
302 default:
303 TELEPHONY_LOGE("network unknown send error.");
304 return TELEPHONY_ERR_UNKNOWN_NETWORK_TYPE;
305 }
306 }
307
SetImsSmsConfig(int32_t slotId,int32_t enable)308 bool SmsSendManager::SetImsSmsConfig(int32_t slotId, int32_t enable)
309 {
310 bool result = false;
311 if (gsmSmsSender_ == nullptr || cdmaSmsSender_ == nullptr || networkManager_ == nullptr) {
312 TELEPHONY_LOGE("Sender or network nullptr error.");
313 return result;
314 }
315 NetWorkType newNetWorkType = networkManager_->GetNetWorkType();
316
317 switch (newNetWorkType) {
318 case NetWorkType::NET_TYPE_GSM:
319 result = gsmSmsSender_->SetImsSmsConfig(slotId, enable);
320 break;
321 case NetWorkType::NET_TYPE_CDMA:
322 result = cdmaSmsSender_->SetImsSmsConfig(slotId, enable);
323 break;
324 default:
325 TELEPHONY_LOGE("network unknown send error.");
326 break;
327 }
328 return result;
329 }
330
GetImsShortMessageFormat(std::u16string & format)331 int32_t SmsSendManager::GetImsShortMessageFormat(std::u16string &format)
332 {
333 format = StringUtils::ToUtf16(NET_TYPE_UNKNOWN_STRING);
334 if (networkManager_ == nullptr) {
335 TELEPHONY_LOGE("networkManager is nullptr error.");
336 return TELEPHONY_ERR_LOCAL_PTR_NULL;
337 }
338 switch (networkManager_->GetNetWorkType()) {
339 case NetWorkType::NET_TYPE_GSM:
340 format = StringUtils::ToUtf16(NET_TYPE_GSM_STRING);
341 break;
342 case NetWorkType::NET_TYPE_CDMA:
343 format = StringUtils::ToUtf16(NET_TYPE_CDMA_STRING);
344 break;
345 default:
346 break;
347 }
348 return TELEPHONY_ERR_SUCCESS;
349 }
350
OnRilAdapterHostDied()351 void SmsSendManager::OnRilAdapterHostDied()
352 {
353 if (gsmSmsSender_ != nullptr) {
354 gsmSmsSender_->OnRilAdapterHostDied();
355 }
356 if (cdmaSmsSender_ != nullptr) {
357 cdmaSmsSender_->OnRilAdapterHostDied();
358 }
359 }
360 } // namespace Telephony
361 } // namespace OHOS
362