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_hisysevent.h"
19 #include "sms_misc_manager.h"
20 #include "string_utils.h"
21 #include "telephony_errors.h"
22 #include "telephony_log_wrapper.h"
23
24 namespace OHOS {
25 namespace Telephony {
26 using namespace std;
SmsInterfaceManager(int32_t slotId)27 SmsInterfaceManager::SmsInterfaceManager(int32_t slotId) : slotId_(slotId) {}
28
~SmsInterfaceManager()29 SmsInterfaceManager::~SmsInterfaceManager() {}
30
InitInterfaceManager()31 void SmsInterfaceManager::InitInterfaceManager()
32 {
33 smsSendManager_ = make_unique<SmsSendManager>(slotId_);
34 if (smsSendManager_ == nullptr) {
35 TELEPHONY_LOGE("failed to create SmsSendManager");
36 return;
37 }
38 smsSendManager_->Init();
39
40 smsReceiveManager_ = make_unique<SmsReceiveManager>(slotId_);
41 if (smsReceiveManager_ == nullptr) {
42 TELEPHONY_LOGE("failed to create SmsReceiveManager");
43 return;
44 }
45 smsReceiveManager_->Init();
46 smsReceiveManager_->SetCdmaSender(smsSendManager_->GetCdmaSmsSender());
47 smsMiscManager_ = make_shared<SmsMiscManager>(slotId_);
48
49 mmsSendManager_ = make_unique<MmsSendManager>(slotId_);
50 if (mmsSendManager_ == nullptr) {
51 TELEPHONY_LOGE("failed to create MmsSendManager");
52 return;
53 }
54 mmsSendManager_->Init();
55
56 mmsReceiverManager_ = make_unique<MmsReceiveManager>(slotId_);
57 if (mmsReceiverManager_ == nullptr) {
58 TELEPHONY_LOGE("failed to create MmsReceiveManager");
59 return;
60 }
61 mmsReceiverManager_->Init();
62
63 TELEPHONY_LOGI("SmsInterfaceManager::InitInterfaceManager success, %{public}d", slotId_);
64 }
65
TextBasedSmsDelivery(const string & desAddr,const string & scAddr,const string & text,const sptr<ISendShortMessageCallback> & sendCallback,const sptr<IDeliveryShortMessageCallback> & deliveryCallback,uint16_t dataBaseId,bool isMmsApp)66 int32_t SmsInterfaceManager::TextBasedSmsDelivery(const string &desAddr, const string &scAddr, const string &text,
67 const sptr<ISendShortMessageCallback> &sendCallback, const sptr<IDeliveryShortMessageCallback> &deliveryCallback,
68 uint16_t dataBaseId, bool isMmsApp)
69 {
70 if (desAddr.empty() || text.empty()) {
71 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
72 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
73 SmsMmsErrorCode::SMS_ERROR_EMPTY_INPUT_PARAMETER, "text sms arges is empty");
74 TELEPHONY_LOGE("TextBasedSmsDelivery failed to send.");
75 return TELEPHONY_ERR_ARGUMENT_INVALID;
76 }
77 if (smsSendManager_ == nullptr) {
78 TELEPHONY_LOGE("TextBasedSmsDelivery failed to send.");
79 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
80 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
81 SmsMmsErrorCode::SMS_ERROR_NULL_POINTER, "text sms smsSendManager_ is nullptr");
82 return TELEPHONY_ERR_LOCAL_PTR_NULL;
83 }
84 smsSendManager_->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback, dataBaseId, isMmsApp);
85 return TELEPHONY_ERR_SUCCESS;
86 }
87
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)88 int32_t SmsInterfaceManager::DataBasedSmsDelivery(const string &desAddr, const string &scAddr, const uint16_t port,
89 const uint8_t *data, uint16_t dataLen, const sptr<ISendShortMessageCallback> &sendCallback,
90 const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
91 {
92 if (desAddr.empty() || (data == nullptr)) {
93 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
94 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
95 SmsMmsErrorCode::SMS_ERROR_EMPTY_INPUT_PARAMETER, "data sms arges is empty");
96 TELEPHONY_LOGE("DataBasedSmsDelivery failed to send.");
97 return TELEPHONY_ERR_ARGUMENT_INVALID;
98 }
99 if (smsSendManager_ == nullptr) {
100 TELEPHONY_LOGE("TextBasedSmsDelivery failed to send.");
101 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
102 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
103 SmsMmsErrorCode::SMS_ERROR_NULL_POINTER, "text sms smsSendManager_ is nullptr");
104 return TELEPHONY_ERR_LOCAL_PTR_NULL;
105 }
106 smsSendManager_->DataBasedSmsDelivery(desAddr, scAddr, port, data, dataLen, sendCallback, deliveryCallback);
107 return TELEPHONY_ERR_SUCCESS;
108 }
109
AddSimMessage(const std::string & smsc,const std::string & pdu,ISmsServiceInterface::SimMessageStatus status)110 int32_t SmsInterfaceManager::AddSimMessage(
111 const std::string &smsc, const std::string &pdu, ISmsServiceInterface::SimMessageStatus status)
112 {
113 if (smsMiscManager_ == nullptr) {
114 TELEPHONY_LOGE("smsMiscManager nullptr error.");
115 return TELEPHONY_ERR_LOCAL_PTR_NULL;
116 }
117 return smsMiscManager_->AddSimMessage(smsc, pdu, status);
118 }
119
DelSimMessage(uint32_t msgIndex)120 int32_t SmsInterfaceManager::DelSimMessage(uint32_t msgIndex)
121 {
122 if (smsMiscManager_ == nullptr) {
123 TELEPHONY_LOGE("smsMiscManager nullptr error.");
124 return TELEPHONY_ERR_LOCAL_PTR_NULL;
125 }
126 return smsMiscManager_->DelSimMessage(msgIndex);
127 }
128
UpdateSimMessage(uint32_t msgIndex,ISmsServiceInterface::SimMessageStatus newStatus,const std::string & pdu,const std::string & smsc)129 int32_t SmsInterfaceManager::UpdateSimMessage(uint32_t msgIndex, ISmsServiceInterface::SimMessageStatus newStatus,
130 const std::string &pdu, const std::string &smsc)
131 {
132 if (smsMiscManager_ == nullptr) {
133 TELEPHONY_LOGE("smsMiscManager nullptr error.");
134 return TELEPHONY_ERR_LOCAL_PTR_NULL;
135 }
136 return smsMiscManager_->UpdateSimMessage(msgIndex, newStatus, pdu, smsc);
137 }
138
GetAllSimMessages(std::vector<ShortMessage> & message)139 int32_t SmsInterfaceManager::GetAllSimMessages(std::vector<ShortMessage> &message)
140 {
141 if (smsMiscManager_ == nullptr) {
142 TELEPHONY_LOGE("smsMiscManager nullptr error.");
143 return TELEPHONY_ERR_LOCAL_PTR_NULL;
144 }
145 return smsMiscManager_->GetAllSimMessages(message);
146 }
147
SetSmscAddr(const std::string & scAddr)148 int32_t SmsInterfaceManager::SetSmscAddr(const std::string &scAddr)
149 {
150 if (smsMiscManager_ == nullptr) {
151 TELEPHONY_LOGE("smsMiscManager nullptr error.");
152 return TELEPHONY_ERR_LOCAL_PTR_NULL;
153 }
154 return smsMiscManager_->SetSmscAddr(scAddr);
155 }
156
GetSmscAddr(std::u16string & smscAddress)157 int32_t SmsInterfaceManager::GetSmscAddr(std::u16string &smscAddress)
158 {
159 if (smsMiscManager_ == nullptr) {
160 TELEPHONY_LOGE("smsMiscManager nullptr error.");
161 return TELEPHONY_ERR_LOCAL_PTR_NULL;
162 }
163 return smsMiscManager_->GetSmscAddr(smscAddress);
164 }
165
SetCBConfig(bool enable,uint32_t fromMsgId,uint32_t toMsgId,uint8_t netType)166 int32_t SmsInterfaceManager::SetCBConfig(bool enable, uint32_t fromMsgId, uint32_t toMsgId, uint8_t netType)
167 {
168 if (smsMiscManager_ == nullptr) {
169 TELEPHONY_LOGE("smsMiscManager nullptr error.");
170 return TELEPHONY_ERR_LOCAL_PTR_NULL;
171 }
172 return smsMiscManager_->SetCBConfig(enable, fromMsgId, toMsgId, netType);
173 }
174
SetCBConfigList(const std::vector<int32_t> & messageIds,int32_t ranType)175 int32_t SmsInterfaceManager::SetCBConfigList(const std::vector<int32_t>& messageIds, int32_t ranType)
176 {
177 if (smsMiscManager_ == nullptr) {
178 TELEPHONY_LOGE("smsMiscManager nullptr error.");
179 return TELEPHONY_ERR_LOCAL_PTR_NULL;
180 }
181 return smsMiscManager_->SetCBConfigList(messageIds, ranType);
182 }
183
SetImsSmsConfig(int32_t slotId,int32_t enable)184 bool SmsInterfaceManager::SetImsSmsConfig(int32_t slotId, int32_t enable)
185 {
186 if (smsMiscManager_ == nullptr) {
187 TELEPHONY_LOGE("smsMiscManager nullptr error.");
188 return false;
189 }
190 return smsSendManager_->SetImsSmsConfig(slotId, enable);
191 }
192
SetDefaultSmsSlotId(int32_t slotId)193 int32_t SmsInterfaceManager::SetDefaultSmsSlotId(int32_t slotId)
194 {
195 if (smsMiscManager_ == nullptr) {
196 TELEPHONY_LOGE("smsMiscManager nullptr error.");
197 return TELEPHONY_ERR_LOCAL_PTR_NULL;
198 }
199 return smsMiscManager_->SetDefaultSmsSlotId(slotId);
200 }
201
GetDefaultSmsSlotId()202 int32_t SmsInterfaceManager::GetDefaultSmsSlotId()
203 {
204 if (smsMiscManager_ == nullptr) {
205 TELEPHONY_LOGE("smsMiscManager nullptr error.");
206 return TELEPHONY_ERROR;
207 }
208 return smsMiscManager_->GetDefaultSmsSlotId();
209 }
210
GetDefaultSmsSimId(int32_t & simId)211 int32_t SmsInterfaceManager::GetDefaultSmsSimId(int32_t &simId)
212 {
213 if (smsMiscManager_ == nullptr) {
214 TELEPHONY_LOGE("smsMiscManager nullptr error.");
215 return TELEPHONY_ERR_LOCAL_PTR_NULL;
216 }
217 return smsMiscManager_->GetDefaultSmsSimId(simId);
218 }
219
SplitMessage(const std::string & message,std::vector<std::u16string> & splitMessage)220 int32_t SmsInterfaceManager::SplitMessage(const std::string &message, std::vector<std::u16string> &splitMessage)
221 {
222 if (smsSendManager_ == nullptr) {
223 TELEPHONY_LOGE("smsSendManager nullptr error.");
224 return TELEPHONY_ERR_LOCAL_PTR_NULL;
225 }
226 return smsSendManager_->SplitMessage(message, splitMessage);
227 }
228
GetSmsSegmentsInfo(const std::string & message,bool force7BitCode,LengthInfo & outInfo)229 int32_t SmsInterfaceManager::GetSmsSegmentsInfo(const std::string &message, bool force7BitCode, LengthInfo &outInfo)
230 {
231 if (smsSendManager_ == nullptr) {
232 TELEPHONY_LOGE("smsSendManager nullptr error.");
233 return TELEPHONY_ERR_LOCAL_PTR_NULL;
234 }
235 return smsSendManager_->GetSmsSegmentsInfo(message, force7BitCode, outInfo);
236 }
237
IsImsSmsSupported(int32_t slotId,bool & isSupported)238 int32_t SmsInterfaceManager::IsImsSmsSupported(int32_t slotId, bool &isSupported)
239 {
240 if (smsSendManager_ == nullptr) {
241 TELEPHONY_LOGE("smsSendManager is nullptr error.");
242 return TELEPHONY_ERR_LOCAL_PTR_NULL;
243 }
244 return smsSendManager_->IsImsSmsSupported(slotId, isSupported);
245 }
246
GetImsShortMessageFormat(std::u16string & format)247 int32_t SmsInterfaceManager::GetImsShortMessageFormat(std::u16string &format)
248 {
249 if (smsSendManager_ == nullptr) {
250 TELEPHONY_LOGE("smsSendManager is nullptr error.");
251 return TELEPHONY_ERR_LOCAL_PTR_NULL;
252 }
253 return smsSendManager_->GetImsShortMessageFormat(format);
254 }
255
HasSmsCapability()256 bool SmsInterfaceManager::HasSmsCapability()
257 {
258 auto helperPtr = DelayedSingleton<SmsPersistHelper>::GetInstance();
259 if (helperPtr == nullptr) {
260 TELEPHONY_LOGE("Get SmsPersistHelper Singleton nullptr error.");
261 return true;
262 }
263 return helperPtr->QueryParamBoolean(SmsPersistHelper::SMS_CAPABLE_PARAM_KEY, true);
264 }
265
SendMms(const std::u16string & mmsc,const std::u16string & data,const std::u16string & ua,const std::u16string & uaprof)266 int32_t SmsInterfaceManager::SendMms(
267 const std::u16string &mmsc, const std::u16string &data, const std::u16string &ua, const std::u16string &uaprof)
268 {
269 if (mmsSendManager_ == nullptr) {
270 TELEPHONY_LOGE("mmsSendManager_ nullptr error");
271 return TELEPHONY_ERR_LOCAL_PTR_NULL;
272 }
273 return mmsSendManager_->SendMms(mmsc, data, ua, uaprof);
274 }
275
DownloadMms(const std::u16string & mmsc,std::u16string & data,const std::u16string & ua,const std::u16string & uaprof)276 int32_t SmsInterfaceManager::DownloadMms(
277 const std::u16string &mmsc, std::u16string &data, const std::u16string &ua, const std::u16string &uaprof)
278 {
279 if (mmsReceiverManager_ == nullptr) {
280 TELEPHONY_LOGE("mmsReceiverManager_ nullptr error");
281 return TELEPHONY_ERR_LOCAL_PTR_NULL;
282 }
283 return mmsReceiverManager_->DownloadMms(mmsc, data, ua, uaprof);
284 }
285
OnRilAdapterHostDied()286 int32_t SmsInterfaceManager::OnRilAdapterHostDied()
287 {
288 if (smsSendManager_ == nullptr) {
289 TELEPHONY_LOGE("smsSendManager is nullptr error.");
290 return TELEPHONY_ERR_LOCAL_PTR_NULL;
291 }
292 smsSendManager_->OnRilAdapterHostDied();
293 return TELEPHONY_ERR_SUCCESS;
294 }
295 } // namespace Telephony
296 } // namespace OHOS
297