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_interface_manager.h"
17
18 #include "sms_misc_manager.h"
19 #include "string_utils.h"
20 #include "telephony_log_wrapper.h"
21
22 namespace OHOS {
23 namespace Telephony {
24 using namespace std;
SmsInterfaceManager(int32_t slotId)25 SmsInterfaceManager::SmsInterfaceManager(int32_t slotId) : slotId_(slotId) {}
26
~SmsInterfaceManager()27 SmsInterfaceManager::~SmsInterfaceManager() {}
28
InitInterfaceManager()29 void SmsInterfaceManager::InitInterfaceManager()
30 {
31 smsSendManager_ = make_unique<SmsSendManager>(slotId_);
32 if (smsSendManager_ == nullptr) {
33 TELEPHONY_LOGE("failed to create SmsSendManager");
34 return;
35 }
36 smsSendManager_->Init();
37
38 smsReceiveManager_ = make_unique<SmsReceiveManager>(slotId_);
39 if (smsReceiveManager_ == nullptr) {
40 TELEPHONY_LOGE("failed to create SmsReceiveManager");
41 return;
42 }
43 smsReceiveManager_->Init();
44 auto smsMiscRunner = AppExecFwk::EventRunner::Create("SmsMiscRunner" + to_string(slotId_));
45 if (smsMiscRunner == nullptr) {
46 TELEPHONY_LOGE("failed to create SmsCbRunner");
47 return;
48 }
49 smsReceiveManager_->SetCdmaSender(smsSendManager_->GetCdmaSmsSender());
50 smsMiscManager_ = make_shared<SmsMiscManager>(smsMiscRunner, slotId_);
51 smsMiscRunner->Run();
52 TELEPHONY_LOGI("SmsInterfaceManager::InitInterfaceManager success, %{public}d", slotId_);
53 }
54
TextBasedSmsDelivery(const string & desAddr,const string & scAddr,const string & text,const sptr<ISendShortMessageCallback> & sendCallback,const sptr<IDeliveryShortMessageCallback> & deliveryCallback)55 void SmsInterfaceManager::TextBasedSmsDelivery(const string &desAddr, const string &scAddr, const string &text,
56 const sptr<ISendShortMessageCallback> &sendCallback,
57 const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
58 {
59 if (desAddr.empty() || text.empty() || (smsSendManager_ == nullptr)) {
60 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
61 TELEPHONY_LOGE("TextBasedSmsDelivery failed to send.");
62 return;
63 }
64 smsSendManager_->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
65 }
66
DataBasedSmsDelivery(const string & desAddr,const string & scAddr,const uint16_t port,const uint8_t * data,uint16_t dataLen,const sptr<ISendShortMessageCallback> & sendCallback,const sptr<IDeliveryShortMessageCallback> & deliveryCallback)67 void SmsInterfaceManager::DataBasedSmsDelivery(const string &desAddr, const string &scAddr, const uint16_t port,
68 const uint8_t *data, uint16_t dataLen, const sptr<ISendShortMessageCallback> &sendCallback,
69 const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
70 {
71 if (desAddr.empty() || (smsSendManager_ == nullptr) || (data == nullptr)) {
72 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
73 TELEPHONY_LOGE("DataBasedSmsDelivery failed to send.");
74 return;
75 }
76 smsSendManager_->DataBasedSmsDelivery(desAddr, scAddr, port, data, dataLen, sendCallback, deliveryCallback);
77 }
78
AddSimMessage(const std::string & smsc,const std::string & pdu,ISmsServiceInterface::SimMessageStatus status)79 bool SmsInterfaceManager::AddSimMessage(
80 const std::string &smsc, const std::string &pdu, ISmsServiceInterface::SimMessageStatus status)
81 {
82 if (smsMiscManager_ == nullptr) {
83 TELEPHONY_LOGE("smsMiscManager nullptr error.");
84 return false;
85 }
86 return smsMiscManager_->AddSimMessage(smsc, pdu, status);
87 }
88
DelSimMessage(uint32_t msgIndex)89 bool SmsInterfaceManager::DelSimMessage(uint32_t msgIndex)
90 {
91 if (smsMiscManager_ == nullptr) {
92 TELEPHONY_LOGE("smsMiscManager nullptr error.");
93 return false;
94 }
95 return smsMiscManager_->DelSimMessage(msgIndex);
96 }
97
UpdateSimMessage(uint32_t msgIndex,ISmsServiceInterface::SimMessageStatus newStatus,const std::string & pdu,const std::string & smsc)98 bool SmsInterfaceManager::UpdateSimMessage(uint32_t msgIndex, ISmsServiceInterface::SimMessageStatus newStatus,
99 const std::string &pdu, const std::string &smsc)
100 {
101 if (smsMiscManager_ == nullptr) {
102 TELEPHONY_LOGE("smsMiscManager nullptr error.");
103 return false;
104 }
105 return smsMiscManager_->UpdateSimMessage(msgIndex, newStatus, pdu, smsc);
106 }
107
GetAllSimMessages()108 vector<ShortMessage> SmsInterfaceManager::GetAllSimMessages()
109 {
110 std::vector<ShortMessage> ret;
111 if (smsMiscManager_ == nullptr) {
112 TELEPHONY_LOGE("smsMiscManager nullptr error.");
113 return ret;
114 }
115 return smsMiscManager_->GetAllSimMessages();
116 }
117
SetSmscAddr(const std::string & scAddr)118 bool SmsInterfaceManager::SetSmscAddr(const std::string &scAddr)
119 {
120 if (smsMiscManager_ == nullptr) {
121 TELEPHONY_LOGE("smsMiscManager nullptr error.");
122 return false;
123 }
124 return smsMiscManager_->SetSmscAddr(scAddr);
125 }
126
GetSmscAddr()127 std::string SmsInterfaceManager::GetSmscAddr()
128 {
129 if (smsMiscManager_ == nullptr) {
130 TELEPHONY_LOGE("smsMiscManager nullptr error.");
131 return "";
132 }
133 return smsMiscManager_->GetSmscAddr();
134 }
135
SetCBConfig(bool enable,uint32_t fromMsgId,uint32_t toMsgId,uint8_t netType)136 bool SmsInterfaceManager::SetCBConfig(bool enable, uint32_t fromMsgId, uint32_t toMsgId, uint8_t netType)
137 {
138 if (smsMiscManager_ == nullptr) {
139 TELEPHONY_LOGE("smsMiscManager nullptr error.");
140 return false;
141 }
142 return smsMiscManager_->SetCBConfig(enable, fromMsgId, toMsgId, netType);
143 }
144
SetDefaultSmsSlotId(int32_t slotId)145 bool SmsInterfaceManager::SetDefaultSmsSlotId(int32_t slotId)
146 {
147 if (smsMiscManager_ == nullptr) {
148 TELEPHONY_LOGE("smsMiscManager nullptr error.");
149 return false;
150 }
151 return smsMiscManager_->SetDefaultSmsSlotId(slotId);
152 }
153
GetDefaultSmsSlotId()154 int32_t SmsInterfaceManager::GetDefaultSmsSlotId()
155 {
156 int32_t result = -1;
157 if (smsMiscManager_ == nullptr) {
158 TELEPHONY_LOGE("smsMiscManager nullptr error.");
159 return result;
160 }
161 return smsMiscManager_->GetDefaultSmsSlotId();
162 }
163
SplitMessage(const std::string & message)164 std::vector<std::string> SmsInterfaceManager::SplitMessage(const std::string &message)
165 {
166 std::vector<std::string> result;
167 if (smsSendManager_ == nullptr) {
168 TELEPHONY_LOGE("smsSendManager nullptr error.");
169 return result;
170 }
171 return smsSendManager_->SplitMessage(message);
172 }
173
GetSmsSegmentsInfo(const std::string & message,bool force7BitCode,LengthInfo & outInfo)174 bool SmsInterfaceManager::GetSmsSegmentsInfo(const std::string &message, bool force7BitCode, LengthInfo &outInfo)
175 {
176 if (smsSendManager_ == nullptr) {
177 TELEPHONY_LOGE("smsSendManager nullptr error.");
178 return false;
179 }
180 return smsSendManager_->GetSmsSegmentsInfo(message, force7BitCode, outInfo);
181 }
182
IsImsSmsSupported()183 bool SmsInterfaceManager::IsImsSmsSupported()
184 {
185 bool result = false;
186 if (smsSendManager_ == nullptr) {
187 TELEPHONY_LOGE("smsSendManager is nullptr error.");
188 return result;
189 }
190 return smsSendManager_->IsImsSmsSupported();
191 }
192
GetImsShortMessageFormat()193 std::string SmsInterfaceManager::GetImsShortMessageFormat()
194 {
195 std::string result;
196 if (smsSendManager_ == nullptr) {
197 TELEPHONY_LOGE("smsSendManager is nullptr error.");
198 return result;
199 }
200 return smsSendManager_->GetImsShortMessageFormat();
201 }
202
HasSmsCapability()203 bool SmsInterfaceManager::HasSmsCapability()
204 {
205 auto helperPtr = DelayedSingleton<SmsPersistHelper>::GetInstance();
206 if (helperPtr == nullptr) {
207 TELEPHONY_LOGE("Get SmsPersistHelper Singleton nullptr error.");
208 return true;
209 }
210 return helperPtr->QueryParamBoolean(SmsPersistHelper::SMS_CAPABLE_PARAM_KEY, true);
211 }
212 } // namespace Telephony
213 } // namespace OHOS