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 "sms_service.h"
17
18 #include <regex>
19
20 #include "cdma_sms_message.h"
21 #include "core_manager_inner.h"
22 #include "ims_sms_client.h"
23 #include "sms_dump_helper.h"
24 #include "sms_hisysevent.h"
25 #include "string_utils.h"
26 #include "telephony_common_utils.h"
27 #include "telephony_log_wrapper.h"
28 #include "telephony_permission.h"
29 #include "text_coder.h"
30
31 namespace OHOS {
32 namespace Telephony {
33 using namespace std;
34 using namespace AppExecFwk;
35 using namespace HiviewDFX;
36 constexpr static uint32_t CONNECT_SERVICE_WAIT_TIME = 2000;
37 constexpr static size_t MIN_LEN = 1;
38 bool g_registerResult = SystemAbility::MakeAndRegisterAbility(DelayedSingleton<SmsService>::GetInstance().get());
39
SmsService()40 SmsService::SmsService() : SystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID, true) {}
41
~SmsService()42 SmsService::~SmsService() {}
43
OnStart()44 void SmsService::OnStart()
45 {
46 TELEPHONY_LOGI("SmsService::OnStart start service Enter.");
47 bindTime_ =
48 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
49 .count();
50 if (state_ == ServiceRunningState::STATE_RUNNING) {
51 TELEPHONY_LOGE("msService has already started.");
52 return;
53 }
54 if (!Init()) {
55 TELEPHONY_LOGE("failed to init SmsService");
56 return;
57 }
58 state_ = ServiceRunningState::STATE_RUNNING;
59 endTime_ =
60 std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::system_clock::now().time_since_epoch())
61 .count();
62 TELEPHONY_LOGI("SmsService::OnStart start service Exit.");
63 }
64
Init()65 bool SmsService::Init()
66 {
67 DelayedSingleton<ImsSmsClient>::GetInstance()->Init();
68 if (!registerToService_) {
69 bool ret = Publish(DelayedSingleton<SmsService>::GetInstance().get());
70 if (!ret) {
71 TELEPHONY_LOGE("SmsService::Init Publish failed!");
72 return false;
73 }
74 registerToService_ = true;
75 WaitCoreServiceToInit();
76 }
77 DelayedSingleton<SmsStateHandler>::GetInstance()->Init();
78 return true;
79 }
80
OnStop()81 void SmsService::OnStop()
82 {
83 state_ = ServiceRunningState::STATE_NOT_START;
84 registerToService_ = false;
85 DelayedSingleton<ImsSmsClient>::GetInstance()->UnInit();
86 DelayedSingleton<SmsStateHandler>::GetInstance()->UnInit();
87 TELEPHONY_LOGI("SmsService::OnStop stop service.");
88 }
89
Dump(std::int32_t fd,const std::vector<std::u16string> & args)90 int32_t SmsService::Dump(std::int32_t fd, const std::vector<std::u16string> &args)
91 {
92 if (fd < 0) {
93 TELEPHONY_LOGE("dump fd invalid");
94 return TELEPHONY_ERR_FAIL;
95 }
96 std::vector<std::string> argsInStr;
97 for (const auto &arg : args) {
98 TELEPHONY_LOGI("Dump args: %{public}s", Str16ToStr8(arg).c_str());
99 argsInStr.emplace_back(Str16ToStr8(arg));
100 }
101 std::string result;
102 SmsDumpHelper dumpHelper;
103 if (dumpHelper.Dump(argsInStr, result)) {
104 TELEPHONY_LOGI("%{public}s", result.c_str());
105 std::int32_t ret = dprintf(fd, "%s", result.c_str());
106 if (ret < 0) {
107 TELEPHONY_LOGE("dprintf to dump fd failed");
108 return TELEPHONY_ERR_FAIL;
109 }
110 return TELEPHONY_SUCCESS;
111 }
112 TELEPHONY_LOGW("dumpHelper failed");
113 return TELEPHONY_ERR_FAIL;
114 }
115
WaitCoreServiceToInit()116 void SmsService::WaitCoreServiceToInit()
117 {
118 TelFFRTUtils::Submit([&]() {
119 while (true) {
120 if (CoreManagerInner::GetInstance().IsInitFinished()) {
121 InitModule();
122 TELEPHONY_LOGI("SmsService Connection successful");
123 break;
124 }
125 TelFFRTUtils::SleepFor(CONNECT_SERVICE_WAIT_TIME);
126 }
127 });
128 }
129
GetBindTime()130 std::string SmsService::GetBindTime()
131 {
132 return std::to_string(bindTime_);
133 }
134
SendMessage(int32_t slotId,const u16string desAddr,const u16string scAddr,const u16string text,const sptr<ISendShortMessageCallback> & sendCallback,const sptr<IDeliveryShortMessageCallback> & deliveryCallback)135 int32_t SmsService::SendMessage(int32_t slotId, const u16string desAddr, const u16string scAddr, const u16string text,
136 const sptr<ISendShortMessageCallback> &sendCallback, const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
137 {
138 if (!CheckSmsPermission(sendCallback)) {
139 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId, SmsMmsMessageType::SMS_SHORT_MESSAGE,
140 SmsMmsErrorCode::SMS_ERROR_PERMISSION_ERROR, Permission::SEND_MESSAGES);
141 return TELEPHONY_ERR_PERMISSION_ERR;
142 }
143 if (desAddr.empty()) {
144 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
145 TELEPHONY_LOGE("SmsService::SendMessage desAddr empty");
146 return TELEPHONY_ERR_ARGUMENT_INVALID;
147 }
148 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
149 if (interfaceManager == nullptr) {
150 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
151 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId, SmsMmsMessageType::SMS_SHORT_MESSAGE,
152 SmsMmsErrorCode::SMS_ERROR_NULL_POINTER, "text sms interfaceManager is nullptr");
153 TELEPHONY_LOGE("SmsService::SendMessage interfaceManager nullptr error.");
154 return TELEPHONY_ERR_LOCAL_PTR_NULL;
155 }
156 if (!ValidDestinationAddress(StringUtils::ToUtf8(desAddr))) {
157 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
158 TELEPHONY_LOGE("SmsService::SendMessage desAddr not conform to the regular specification");
159 return TELEPHONY_ERR_ARGUMENT_INVALID;
160 }
161 bool ret = interfaceManager->TextBasedSmsDelivery(StringUtils::ToUtf8(desAddr), StringUtils::ToUtf8(scAddr),
162 StringUtils::ToUtf8(text), sendCallback, deliveryCallback);
163 DelayedSingleton<SmsPersistHelper>::GetInstance()->UpdateContact(StringUtils::ToUtf8(desAddr));
164 return ret;
165 }
166
InsertSessionAndDetail(int32_t slotId,const std::string & telephone,const std::string & text)167 void SmsService::InsertSessionAndDetail(int32_t slotId, const std::string &telephone, const std::string &text)
168 {
169 uint16_t sessionId = 0;
170 uint16_t messageCount = 0;
171 bool ret = QuerySessionByTelephone(telephone, sessionId, messageCount);
172 if (ret) {
173 InsertSmsMmsInfo(slotId, sessionId, telephone, text);
174 messageCount++;
175 InsertSession(false, messageCount, telephone, text);
176 } else {
177 ret = InsertSession(true, 0, telephone, text);
178 if (ret) {
179 QuerySessionByTelephone(telephone, sessionId, messageCount);
180 InsertSmsMmsInfo(slotId, sessionId, telephone, text);
181 }
182 }
183 }
184
QuerySessionByTelephone(const std::string & telephone,uint16_t & sessionId,uint16_t & messageCount)185 bool SmsService::QuerySessionByTelephone(const std::string &telephone, uint16_t &sessionId, uint16_t &messageCount)
186 {
187 DataShare::DataSharePredicates predicates;
188 predicates.EqualTo(Session::TELEPHONE, telephone);
189 return DelayedSingleton<SmsPersistHelper>::GetInstance()->QuerySession(predicates, sessionId, messageCount);
190 }
191
InsertSmsMmsInfo(int32_t slotId,uint16_t sessionId,const std::string & number,const std::string & text)192 void SmsService::InsertSmsMmsInfo(
193 int32_t slotId, uint16_t sessionId, const std::string &number, const std::string &text)
194 {
195 DataShare::DataSharePredicates predicates;
196 uint16_t maxGroupId = 0;
197 DelayedSingleton<SmsPersistHelper>::GetInstance()->QueryMaxGroupId(predicates, maxGroupId);
198 auto now = std::chrono::system_clock::now();
199 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
200 DataShare::DataShareValuesBucket smsMmsInfoBucket;
201 smsMmsInfoBucket.Put(SmsMmsInfo::SLOT_ID, std::to_string(slotId));
202 smsMmsInfoBucket.Put(SmsMmsInfo::RECEIVER_NUMBER, number);
203 smsMmsInfoBucket.Put(SmsMmsInfo::SENDER_NUMBER, "");
204 smsMmsInfoBucket.Put(SmsMmsInfo::IS_SENDER, "0");
205 smsMmsInfoBucket.Put(SmsMmsInfo::START_TIME, std::to_string(duration.count()));
206 smsMmsInfoBucket.Put(SmsMmsInfo::END_TIME, std::to_string(duration.count()));
207 smsMmsInfoBucket.Put(SmsMmsInfo::MSG_TYPE, "0");
208 smsMmsInfoBucket.Put(SmsMmsInfo::SMS_TYPE, "0");
209 smsMmsInfoBucket.Put(SmsMmsInfo::MSG_TITLE, text);
210 smsMmsInfoBucket.Put(SmsMmsInfo::MSG_CONTENT, text);
211 smsMmsInfoBucket.Put(SmsMmsInfo::MSG_STATE, "0");
212 smsMmsInfoBucket.Put(SmsMmsInfo::MSG_CODE, "");
213 smsMmsInfoBucket.Put(SmsMmsInfo::IS_LOCK, "0");
214 smsMmsInfoBucket.Put(SmsMmsInfo::IS_READ, "1");
215 smsMmsInfoBucket.Put(SmsMmsInfo::IS_COLLECT, "0");
216 smsMmsInfoBucket.Put(SmsMmsInfo::SESSION_TYPE, "0");
217 smsMmsInfoBucket.Put(SmsMmsInfo::SESSION_ID, std::to_string(sessionId));
218 smsMmsInfoBucket.Put(SmsMmsInfo::GROUP_ID, std::to_string(maxGroupId + 1));
219 smsMmsInfoBucket.Put(SmsMmsInfo::IS_SUBSECTION, "0");
220 smsMmsInfoBucket.Put(SmsMmsInfo::IS_SEND_REPORT, "0");
221 DelayedSingleton<SmsPersistHelper>::GetInstance()->Insert(SMS_MMS_INFO, smsMmsInfoBucket);
222 }
223
InsertSession(bool isNewSession,uint16_t messageCount,const std::string & number,const std::string & text)224 bool SmsService::InsertSession(
225 bool isNewSession, uint16_t messageCount, const std::string &number, const std::string &text)
226 {
227 auto now = std::chrono::system_clock::now();
228 auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch());
229 DataShare::DataShareValuesBucket sessionBucket;
230 sessionBucket.Put(Session::TIME, std::to_string(duration.count()));
231 sessionBucket.Put(Session::TELEPHONE, number);
232 sessionBucket.Put(Session::CONTENT, text);
233 sessionBucket.Put(Session::CONTACTS_NUM, "1");
234 sessionBucket.Put(Session::SMS_TYPE, "0");
235 sessionBucket.Put(Session::UNREAD_COUNT, "0");
236 sessionBucket.Put(Session::SENDING_STATUS, "0");
237 sessionBucket.Put(Session::HAS_DRAFT, "0");
238 sessionBucket.Put(Session::HAS_LOCK, "0");
239 sessionBucket.Put(Session::HAS_MMS, "0");
240 sessionBucket.Put(Session::HAS_ATTACHMENT, "0");
241 if (!isNewSession) {
242 sessionBucket.Put(Session::MESSAGE_COUNT, std::to_string(messageCount));
243 DataShare::DataSharePredicates predicates;
244 predicates.EqualTo(Session::TELEPHONE, number);
245 return DelayedSingleton<SmsPersistHelper>::GetInstance()->Update(predicates, sessionBucket);
246 }
247 sessionBucket.Put(Session::MESSAGE_COUNT, "1");
248 return DelayedSingleton<SmsPersistHelper>::GetInstance()->Insert(SMS_SESSION, sessionBucket);
249 }
250
SendMessage(int32_t slotId,const u16string desAddr,const u16string scAddr,uint16_t port,const uint8_t * data,uint16_t dataLen,const sptr<ISendShortMessageCallback> & sendCallback,const sptr<IDeliveryShortMessageCallback> & deliveryCallback)251 int32_t SmsService::SendMessage(int32_t slotId, const u16string desAddr, const u16string scAddr, uint16_t port,
252 const uint8_t *data, uint16_t dataLen, const sptr<ISendShortMessageCallback> &sendCallback,
253 const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
254 {
255 if (!CheckSmsPermission(sendCallback)) {
256 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId, SmsMmsMessageType::SMS_SHORT_MESSAGE,
257 SmsMmsErrorCode::SMS_ERROR_PERMISSION_ERROR, Permission::SEND_MESSAGES);
258 return TELEPHONY_ERR_PERMISSION_ERR;
259 }
260 if (desAddr.empty()) {
261 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
262 TELEPHONY_LOGE("SmsService::SendMessage desAddr empty");
263 return TELEPHONY_ERR_ARGUMENT_INVALID;
264 }
265 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
266 if (interfaceManager == nullptr) {
267 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
268 TELEPHONY_LOGE("SmsService::SendMessage interfaceManager nullptr error.");
269 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId, SmsMmsMessageType::SMS_SHORT_MESSAGE,
270 SmsMmsErrorCode::SMS_ERROR_NULL_POINTER, "data sms interfaceManager is nullptr");
271 return TELEPHONY_ERR_LOCAL_PTR_NULL;
272 }
273 if (!ValidDestinationAddress(StringUtils::ToUtf8(desAddr))) {
274 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
275 TELEPHONY_LOGE("SmsService::SendMessage desAddr not conform to the regular specification");
276 return TELEPHONY_ERR_ARGUMENT_INVALID;
277 }
278 bool ret = interfaceManager->DataBasedSmsDelivery(
279 StringUtils::ToUtf8(desAddr), StringUtils::ToUtf8(scAddr), port, data, dataLen, sendCallback, deliveryCallback);
280 DelayedSingleton<SmsPersistHelper>::GetInstance()->UpdateContact(StringUtils::ToUtf8(desAddr));
281 return ret;
282 }
283
CheckSmsPermission(const sptr<ISendShortMessageCallback> & sendCallback)284 bool SmsService::CheckSmsPermission(const sptr<ISendShortMessageCallback> &sendCallback)
285 {
286 if (!TelephonyPermission::CheckPermission(Permission::SEND_MESSAGES)) {
287 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
288 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Send Messages Permisson.");
289 return false;
290 }
291 return true;
292 }
293
IsImsSmsSupported(int32_t slotId,bool & isSupported)294 int32_t SmsService::IsImsSmsSupported(int32_t slotId, bool &isSupported)
295 {
296 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
297 TELEPHONY_LOGE("Non-system applications use system APIs!");
298 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
299 }
300 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
301 if (interfaceManager == nullptr) {
302 TELEPHONY_LOGE("interfaceManager is nullptr.");
303 return TELEPHONY_ERR_SLOTID_INVALID;
304 }
305 return interfaceManager->IsImsSmsSupported(slotId, isSupported);
306 }
307
GetImsShortMessageFormat(std::u16string & format)308 int32_t SmsService::GetImsShortMessageFormat(std::u16string &format)
309 {
310 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
311 TELEPHONY_LOGE("Non-system applications use system APIs!");
312 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
313 }
314 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
315 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Get State Permisson.");
316 return TELEPHONY_ERR_PERMISSION_ERR;
317 }
318 int32_t slotId = GetDefaultSmsSlotId();
319 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
320 if (interfaceManager == nullptr) {
321 TELEPHONY_LOGE("interfaceManager is nullptr error.");
322 return TELEPHONY_ERR_SLOTID_INVALID;
323 }
324 return interfaceManager->GetImsShortMessageFormat(format);
325 }
326
HasSmsCapability()327 bool SmsService::HasSmsCapability()
328 {
329 int32_t slotId = GetDefaultSmsSlotId();
330 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
331 if (interfaceManager == nullptr) {
332 TELEPHONY_LOGE("Get SmsInterfaceManager is nullptr error.");
333 return true;
334 }
335 return interfaceManager->HasSmsCapability();
336 }
337
SetSmscAddr(int32_t slotId,const std::u16string & scAddr)338 int32_t SmsService::SetSmscAddr(int32_t slotId, const std::u16string &scAddr)
339 {
340 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
341 TELEPHONY_LOGE("Non-system applications use system APIs!");
342 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
343 }
344 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
345 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Set State Permisson.");
346 return TELEPHONY_ERR_PERMISSION_ERR;
347 }
348
349 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
350 if (interfaceManager == nullptr) {
351 TELEPHONY_LOGE("interfaceManager is nullptr error.");
352 return TELEPHONY_ERR_SLOTID_INVALID;
353 }
354 string sca = StringUtils::ToUtf8(scAddr);
355 TrimSmscAddr(sca);
356 if (sca.empty() || sca.length() == 0) {
357 TELEPHONY_LOGE("sca is empty");
358 return TELEPHONY_ERR_ARGUMENT_NULL;
359 }
360 return interfaceManager->SetSmscAddr(sca);
361 }
362
TrimSmscAddr(std::string & sca)363 void SmsService::TrimSmscAddr(std::string &sca)
364 {
365 if (sca.length() < MIN_LEN) {
366 return;
367 }
368 while (sca.length() >= MIN_LEN && sca[0] == ' ') {
369 sca.erase(0, 1);
370 }
371 while (sca.length() > MIN_LEN && sca[sca.length() - 1] == ' ') {
372 sca.erase(sca.length() - 1, 1);
373 }
374 }
375
GetSmscAddr(int32_t slotId,std::u16string & smscAddress)376 int32_t SmsService::GetSmscAddr(int32_t slotId, std::u16string &smscAddress)
377 {
378 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
379 TELEPHONY_LOGE("Non-system applications use system APIs!");
380 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
381 }
382 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
383 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Get State Permisson.");
384 return TELEPHONY_ERR_PERMISSION_ERR;
385 }
386
387 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
388 if (interfaceManager == nullptr) {
389 TELEPHONY_LOGE("SmsService::GetSmscAddr interfaceManager nullptr error");
390 return TELEPHONY_ERR_SLOTID_INVALID;
391 }
392 return interfaceManager->GetSmscAddr(smscAddress);
393 }
394
AddSimMessage(int32_t slotId,const std::u16string & smsc,const std::u16string & pdu,SimMessageStatus status)395 int32_t SmsService::AddSimMessage(
396 int32_t slotId, const std::u16string &smsc, const std::u16string &pdu, SimMessageStatus status)
397 {
398 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
399 TELEPHONY_LOGE("Non-system applications use system APIs!");
400 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
401 }
402 if (!TelephonyPermission::CheckPermission(Permission::RECEIVE_MESSAGES)) {
403 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Receive Messages Permisson.");
404 return TELEPHONY_ERR_PERMISSION_ERR;
405 }
406 if (!TelephonyPermission::CheckPermission(Permission::SEND_MESSAGES)) {
407 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Send Messages Permisson.");
408 return TELEPHONY_ERR_PERMISSION_ERR;
409 }
410
411 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
412 if (interfaceManager == nullptr) {
413 TELEPHONY_LOGE("SmsService::AddSimMessage interfaceManager nullptr error");
414 return TELEPHONY_ERR_SLOTID_INVALID;
415 }
416 std::string smscData = StringUtils::ToUtf8(smsc);
417 std::string pduData = StringUtils::ToUtf8(pdu);
418 if (pdu.empty() || pduData.empty()) {
419 TELEPHONY_LOGE("SmsService::AddSimMessage pdu empty error");
420 return TELEPHONY_ERR_ARGUMENT_INVALID;
421 }
422 return interfaceManager->AddSimMessage(smscData, pduData, status);
423 }
424
DelSimMessage(int32_t slotId,uint32_t msgIndex)425 int32_t SmsService::DelSimMessage(int32_t slotId, uint32_t msgIndex)
426 {
427 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
428 TELEPHONY_LOGE("Non-system applications use system APIs!");
429 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
430 }
431 if (!TelephonyPermission::CheckPermission(Permission::RECEIVE_MESSAGES)) {
432 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Receive Messages Permisson.");
433 return TELEPHONY_ERR_PERMISSION_ERR;
434 }
435 if (!TelephonyPermission::CheckPermission(Permission::SEND_MESSAGES)) {
436 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Send Messages Permisson.");
437 return TELEPHONY_ERR_PERMISSION_ERR;
438 }
439
440 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
441 if (interfaceManager == nullptr) {
442 TELEPHONY_LOGE("SmsService::DelSimMessage interfaceManager nullptr error.");
443 return TELEPHONY_ERR_SLOTID_INVALID;
444 }
445 if (!CheckSimMessageIndexValid(slotId, msgIndex)) {
446 TELEPHONY_LOGE("SmsService::DelSimMessage msgIndex inValid");
447 return TELEPHONY_ERR_ARGUMENT_INVALID;
448 }
449
450 return interfaceManager->DelSimMessage(msgIndex);
451 }
452
UpdateSimMessage(int32_t slotId,uint32_t msgIndex,SimMessageStatus newStatus,const std::u16string & pdu,const std::u16string & smsc)453 int32_t SmsService::UpdateSimMessage(int32_t slotId, uint32_t msgIndex, SimMessageStatus newStatus,
454 const std::u16string &pdu, const std::u16string &smsc)
455 {
456 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
457 TELEPHONY_LOGE("Non-system applications use system APIs!");
458 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
459 }
460 if (!TelephonyPermission::CheckPermission(Permission::RECEIVE_MESSAGES)) {
461 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Receive Messages Permisson.");
462 return TELEPHONY_ERR_PERMISSION_ERR;
463 }
464 if (!TelephonyPermission::CheckPermission(Permission::SEND_MESSAGES)) {
465 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Send Messages Permisson.");
466 return TELEPHONY_ERR_PERMISSION_ERR;
467 }
468
469 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
470 if (interfaceManager == nullptr) {
471 TELEPHONY_LOGE("SmsService::UpdateSimMessage interfaceManager nullptr error.");
472 return TELEPHONY_ERR_SLOTID_INVALID;
473 }
474 std::string pduData = StringUtils::ToUtf8(pdu);
475 std::string smscData = StringUtils::ToUtf8(smsc);
476 if (!CheckSimMessageIndexValid(slotId, msgIndex)) {
477 TELEPHONY_LOGE("SmsService::UpdateSimMessage msgIndex inValid");
478 return TELEPHONY_ERR_ARGUMENT_INVALID;
479 }
480 if (pdu.empty() || pduData.empty()) {
481 TELEPHONY_LOGE("SmsService::UpdateSimMessage pdu empty error");
482 return TELEPHONY_ERR_ARGUMENT_INVALID;
483 }
484 return interfaceManager->UpdateSimMessage(msgIndex, newStatus, pduData, smscData);
485 }
486
GetAllSimMessages(int32_t slotId,std::vector<ShortMessage> & message)487 int32_t SmsService::GetAllSimMessages(int32_t slotId, std::vector<ShortMessage> &message)
488 {
489 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
490 TELEPHONY_LOGE("Non-system applications use system APIs!");
491 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
492 }
493 if (!TelephonyPermission::CheckPermission(Permission::RECEIVE_MESSAGES)) {
494 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Receive Messages Permisson.");
495 return TELEPHONY_ERR_PERMISSION_ERR;
496 }
497
498 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
499 if (interfaceManager == nullptr) {
500 TELEPHONY_LOGE("SmsService::GetAllSimMessages interfaceManager nullptr error.");
501 return TELEPHONY_ERR_SLOTID_INVALID;
502 }
503 return interfaceManager->GetAllSimMessages(message);
504 }
505
CheckSimMessageIndexValid(int32_t slotId,uint32_t msgIndex)506 bool SmsService::CheckSimMessageIndexValid(int32_t slotId, uint32_t msgIndex)
507 {
508 std::vector<ShortMessage> totalMessages;
509 int32_t result = GetAllSimMessages(slotId, totalMessages);
510 if (result != TELEPHONY_ERR_SUCCESS) {
511 TELEPHONY_LOGE("SmsService::CheckSimMessageIndexValid get result fail");
512 return false;
513 }
514
515 if (msgIndex < 0 || totalMessages.size() == 0) {
516 TELEPHONY_LOGE("SmsService::CheckSimMessageIndexValid msgIndex error");
517 return false;
518 }
519 for (auto message : totalMessages) {
520 if (message.GetIndexOnSim() == static_cast<int32_t>(msgIndex)) {
521 return true;
522 }
523 }
524 TELEPHONY_LOGI("SmsService::CheckSimMessageIndexValid msgIndex not founded");
525 return false;
526 }
527
SetCBConfig(int32_t slotId,bool enable,uint32_t fromMsgId,uint32_t toMsgId,uint8_t netType)528 int32_t SmsService::SetCBConfig(int32_t slotId, bool enable, uint32_t fromMsgId, uint32_t toMsgId, uint8_t netType)
529 {
530 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
531 TELEPHONY_LOGE("Non-system applications use system APIs!");
532 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
533 }
534 if (!TelephonyPermission::CheckPermission(Permission::RECEIVE_MESSAGES)) {
535 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Receive Messages Permisson.");
536 return TELEPHONY_ERR_PERMISSION_ERR;
537 }
538
539 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
540 if (interfaceManager == nullptr) {
541 TELEPHONY_LOGE("SmsService::SetCBConfig interfaceManager nullptr error.");
542 return TELEPHONY_ERR_SLOTID_INVALID;
543 }
544 return interfaceManager->SetCBConfig(enable, fromMsgId, toMsgId, netType);
545 }
546
SetImsSmsConfig(int32_t slotId,int32_t enable)547 bool SmsService::SetImsSmsConfig(int32_t slotId, int32_t enable)
548 {
549 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
550 TELEPHONY_LOGE("Check permission failed.");
551 return false;
552 }
553 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
554 if (interfaceManager == nullptr) {
555 TELEPHONY_LOGE("SmsService::SetImsSmsConfig interfaceManager nullptr error.");
556 return false;
557 }
558 return interfaceManager->SetImsSmsConfig(slotId, enable);
559 }
560
SetDefaultSmsSlotId(int32_t slotId)561 int32_t SmsService::SetDefaultSmsSlotId(int32_t slotId)
562 {
563 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
564 TELEPHONY_LOGE("Non-system applications use system APIs!");
565 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
566 }
567 if (!TelephonyPermission::CheckPermission(Permission::SET_TELEPHONY_STATE)) {
568 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Set State Permisson.");
569 return TELEPHONY_ERR_PERMISSION_ERR;
570 }
571
572 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager();
573 if (interfaceManager == nullptr) {
574 TELEPHONY_LOGE("SmsService::SetDefaultSmsSlotId interfaceManager nullptr error.");
575 return TELEPHONY_ERR_LOCAL_PTR_NULL;
576 }
577 return interfaceManager->SetDefaultSmsSlotId(slotId);
578 }
579
GetDefaultSmsSlotId()580 int32_t SmsService::GetDefaultSmsSlotId()
581 {
582 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager();
583 if (interfaceManager == nullptr) {
584 TELEPHONY_LOGE("SmsService::GetDefaultSmsSlotId interfaceManager nullptr error.");
585 return TELEPHONY_ERROR;
586 }
587 return interfaceManager->GetDefaultSmsSlotId();
588 }
589
GetDefaultSmsSimId(int32_t & simId)590 int32_t SmsService::GetDefaultSmsSimId(int32_t &simId)
591 {
592 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager();
593 if (interfaceManager == nullptr) {
594 TELEPHONY_LOGE("interfaceManager nullptr error.");
595 return TELEPHONY_ERROR;
596 }
597 return interfaceManager->GetDefaultSmsSimId(simId);
598 }
599
SplitMessage(const std::u16string & message,std::vector<std::u16string> & splitMessage)600 int32_t SmsService::SplitMessage(const std::u16string &message, std::vector<std::u16string> &splitMessage)
601 {
602 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
603 TELEPHONY_LOGE("Non-system applications use system APIs!");
604 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
605 }
606 if (!TelephonyPermission::CheckPermission(Permission::SEND_MESSAGES)) {
607 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Get State Permisson.");
608 return TELEPHONY_ERR_PERMISSION_ERR;
609 }
610
611 if (message.empty()) {
612 return TELEPHONY_ERR_ARGUMENT_INVALID;
613 }
614 int32_t slotId = GetDefaultSmsSlotId();
615 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
616 if (interfaceManager == nullptr) {
617 TELEPHONY_LOGE("SmsService::SplitMessage interfaceManager nullptr error.");
618 return TELEPHONY_ERR_SLOTID_INVALID;
619 }
620 std::string messageData = StringUtils::ToUtf8(message);
621 return interfaceManager->SplitMessage(messageData, splitMessage);
622 }
623
GetSmsSegmentsInfo(int32_t slotId,const std::u16string & message,bool force7BitCode,ISmsServiceInterface::SmsSegmentsInfo & info)624 int32_t SmsService::GetSmsSegmentsInfo(
625 int32_t slotId, const std::u16string &message, bool force7BitCode, ISmsServiceInterface::SmsSegmentsInfo &info)
626 {
627 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
628 TELEPHONY_LOGE("Non-system applications use system APIs!");
629 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
630 }
631 if (!TelephonyPermission::CheckPermission(Permission::GET_TELEPHONY_STATE)) {
632 TELEPHONY_LOGE("Check Permission Failed, No Has Telephony Get State Permisson.");
633 return TELEPHONY_ERR_PERMISSION_ERR;
634 }
635 if (message.empty()) {
636 return TELEPHONY_ERR_ARGUMENT_NULL;
637 }
638 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
639 if (interfaceManager == nullptr) {
640 TELEPHONY_LOGE("GetSmsSegmentsInfo interfaceManager is nullptr error.");
641 return TELEPHONY_ERR_SLOTID_INVALID;
642 }
643 std::string messageData = StringUtils::ToUtf8(message);
644 LengthInfo result;
645 int32_t ret = interfaceManager->GetSmsSegmentsInfo(messageData, force7BitCode, result);
646 if (ret != TELEPHONY_ERR_SUCCESS) {
647 return ret;
648 }
649 info.msgSegCount = static_cast<int32_t>(result.msgSegCount);
650 info.msgEncodingCount = static_cast<int32_t>(result.msgEncodeCount);
651 info.msgRemainCount = static_cast<int32_t>(result.msgRemainCount);
652 SmsSegmentsInfo::SmsSegmentCodeScheme dcs = static_cast<SmsSegmentsInfo::SmsSegmentCodeScheme>(result.dcs);
653 switch (dcs) {
654 case SmsSegmentsInfo::SmsSegmentCodeScheme::SMS_ENCODING_7BIT:
655 case SmsSegmentsInfo::SmsSegmentCodeScheme::SMS_ENCODING_8BIT:
656 case SmsSegmentsInfo::SmsSegmentCodeScheme::SMS_ENCODING_16BIT:
657 info.msgCodeScheme = dcs;
658 break;
659 default:
660 info.msgCodeScheme = SmsSegmentsInfo::SmsSegmentCodeScheme::SMS_ENCODING_UNKNOWN;
661 break;
662 }
663 return TELEPHONY_ERR_SUCCESS;
664 }
665
GetServiceRunningState()666 int32_t SmsService::GetServiceRunningState()
667 {
668 return static_cast<int32_t>(state_);
669 }
670
GetEndTime()671 int64_t SmsService::GetEndTime()
672 {
673 return endTime_;
674 }
675
ValidDestinationAddress(std::string desAddr)676 bool SmsService::ValidDestinationAddress(std::string desAddr)
677 {
678 // Allow address start with '+' and number, Address length range 3 to 20
679 std::regex regexMode("^([0-9_+]{1})([0-9]{2,19})$");
680 return std::regex_match(desAddr, regexMode);
681 }
682
GetSpendTime()683 int64_t SmsService::GetSpendTime()
684 {
685 spendTime_ = endTime_ - bindTime_;
686 return spendTime_;
687 }
688
CreateMessage(std::string pdu,std::string specification,ShortMessage & message)689 int32_t SmsService::CreateMessage(std::string pdu, std::string specification, ShortMessage &message)
690 {
691 std::shared_ptr<SmsBaseMessage> baseMessage;
692 if (specification == "3gpp") {
693 baseMessage = GsmSmsMessage::CreateMessage(pdu);
694 } else if (specification == "3gpp2") {
695 baseMessage = CdmaSmsMessage::CreateMessage(pdu);
696 }
697
698 if (baseMessage == nullptr) {
699 return TELEPHONY_ERR_LOCAL_PTR_NULL;
700 }
701 message.visibleMessageBody_ = StringUtils::ToUtf16(baseMessage->GetVisibleMessageBody());
702 message.visibleRawAddress_ = StringUtils::ToUtf16(baseMessage->GetVisibleOriginatingAddress());
703 message.messageClass_ = static_cast<ShortMessage::SmsMessageClass>(baseMessage->GetMessageClass());
704 message.scAddress_ = StringUtils::ToUtf16(baseMessage->GetSmscAddr());
705 message.scTimestamp_ = baseMessage->GetScTimestamp();
706 message.isReplaceMessage_ = baseMessage->IsReplaceMessage();
707 message.status_ = baseMessage->GetStatus();
708 message.isSmsStatusReportMessage_ = baseMessage->IsSmsStatusReportMessage();
709 message.hasReplyPath_ = baseMessage->HasReplyPath();
710 message.protocolId_ = baseMessage->GetProtocolId();
711 message.pdu_ = baseMessage->GetRawPdu();
712 message.rawUserData_ = baseMessage->GetRawUserData();
713 return TELEPHONY_ERR_SUCCESS;
714 }
715
GetBase64Encode(std::string src,std::string & dest)716 bool SmsService::GetBase64Encode(std::string src, std::string &dest)
717 {
718 TextCoder::Instance().Base64Encode(src, dest);
719 return true;
720 }
721
GetBase64Decode(std::string src,std::string & dest)722 bool SmsService::GetBase64Decode(std::string src, std::string &dest)
723 {
724 TextCoder::Instance().Base64Decode(src, dest);
725 return true;
726 }
727
GetEncodeStringFunc(std::string & encodeString,uint32_t charset,uint32_t valLength,std::string strEncodeString)728 bool SmsService::GetEncodeStringFunc(
729 std::string &encodeString, uint32_t charset, uint32_t valLength, std::string strEncodeString)
730 {
731 TextCoder::Instance().GetEncodeString(encodeString, charset, valLength, strEncodeString);
732 return true;
733 }
734
SendMms(int32_t slotId,const std::u16string & mmsc,const std::u16string & data,const std::u16string & ua,const std::u16string & uaprof)735 int32_t SmsService::SendMms(int32_t slotId, const std::u16string &mmsc, const std::u16string &data,
736 const std::u16string &ua, const std::u16string &uaprof)
737 {
738 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
739 TELEPHONY_LOGE("Non-system applications use system APIs!");
740 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
741 }
742 if (!TelephonyPermission::CheckPermission(Permission::SEND_MESSAGES)) {
743 TELEPHONY_LOGE("check permission failed");
744 return TELEPHONY_ERR_PERMISSION_ERR;
745 }
746 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
747 if (interfaceManager == nullptr) {
748 TELEPHONY_LOGE("interfaceManager nullptr");
749 return TELEPHONY_ERR_SLOTID_INVALID;
750 }
751 if (mmsc.empty()) {
752 TELEPHONY_LOGE("mmsc URL is empty");
753 return TELEPHONY_ERR_ARGUMENT_INVALID;
754 }
755 if (data.empty()) {
756 TELEPHONY_LOGE("mms pdu file is empty");
757 return TELEPHONY_ERR_ARGUMENT_INVALID;
758 }
759 TELEPHONY_LOGI("send mms slotId:%{public}d", slotId);
760 int32_t ret = interfaceManager->SendMms(mmsc, data, ua, uaprof);
761 if (ret == TELEPHONY_ERR_SUCCESS) {
762 TELEPHONY_LOGI("send mms successed");
763 return TELEPHONY_ERR_SUCCESS;
764 } else {
765 TELEPHONY_LOGI("send mms failed");
766 return ret;
767 }
768 }
769
DownloadMms(int32_t slotId,const std::u16string & mmsc,std::u16string & data,const std::u16string & ua,const std::u16string & uaprof)770 int32_t SmsService::DownloadMms(int32_t slotId, const std::u16string &mmsc, std::u16string &data,
771 const std::u16string &ua, const std::u16string &uaprof)
772 {
773 if (!TelephonyPermission::CheckCallerIsSystemApp()) {
774 TELEPHONY_LOGE("Non-system applications use system APIs!");
775 return TELEPHONY_ERR_ILLEGAL_USE_OF_SYSTEM_API;
776 }
777 if (!TelephonyPermission::CheckPermission(Permission::RECEIVE_MMS)) {
778 TELEPHONY_LOGE("check permission failed");
779 return TELEPHONY_ERR_PERMISSION_ERR;
780 }
781 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
782 if (interfaceManager == nullptr) {
783 TELEPHONY_LOGE("interfaceManager nullptr error");
784 return TELEPHONY_ERR_SLOTID_INVALID;
785 }
786 if (mmsc.empty()) {
787 TELEPHONY_LOGE("mmsc URL is empty");
788 return TELEPHONY_ERR_ARGUMENT_INVALID;
789 }
790 TELEPHONY_LOGI("download mms slotId:%{public}d", slotId);
791 int32_t ret = interfaceManager->DownloadMms(mmsc, data, ua, uaprof);
792 if (ret == TELEPHONY_ERR_SUCCESS) {
793 TELEPHONY_LOGI("down mms successed");
794 return TELEPHONY_ERR_SUCCESS;
795 } else {
796 TELEPHONY_LOGI("down mms failed");
797 return ret;
798 }
799 }
800
OnRilAdapterHostDied(int32_t slotId)801 int32_t SmsService::OnRilAdapterHostDied(int32_t slotId)
802 {
803 std::shared_ptr<SmsInterfaceManager> interfaceManager = GetSmsInterfaceManager(slotId);
804 if (interfaceManager == nullptr) {
805 TELEPHONY_LOGE("interfaceManager is nullptr error.");
806 return TELEPHONY_ERR_LOCAL_PTR_NULL;
807 }
808 interfaceManager->OnRilAdapterHostDied();
809 return TELEPHONY_ERR_SUCCESS;
810 }
811 } // namespace Telephony
812 } // namespace OHOS
813