• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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