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