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)66 int32_t SmsInterfaceManager::TextBasedSmsDelivery(const string &desAddr, const string &scAddr, const string &text,
67 const sptr<ISendShortMessageCallback> &sendCallback, const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
68 {
69 if (desAddr.empty() || text.empty()) {
70 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
71 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
72 SmsMmsErrorCode::SMS_ERROR_EMPTY_INPUT_PARAMETER, "text sms arges is empty");
73 TELEPHONY_LOGE("TextBasedSmsDelivery failed to send.");
74 return TELEPHONY_ERR_ARGUMENT_INVALID;
75 }
76 if (smsSendManager_ == nullptr) {
77 TELEPHONY_LOGE("TextBasedSmsDelivery failed to send.");
78 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
79 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
80 SmsMmsErrorCode::SMS_ERROR_NULL_POINTER, "text sms smsSendManager_ is nullptr");
81 return TELEPHONY_ERR_LOCAL_PTR_NULL;
82 }
83 smsSendManager_->TextBasedSmsDelivery(desAddr, scAddr, text, sendCallback, deliveryCallback);
84 return TELEPHONY_ERR_SUCCESS;
85 }
86
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)87 int32_t SmsInterfaceManager::DataBasedSmsDelivery(const string &desAddr, const string &scAddr, const uint16_t port,
88 const uint8_t *data, uint16_t dataLen, const sptr<ISendShortMessageCallback> &sendCallback,
89 const sptr<IDeliveryShortMessageCallback> &deliveryCallback)
90 {
91 if (desAddr.empty() || (data == nullptr)) {
92 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
93 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
94 SmsMmsErrorCode::SMS_ERROR_EMPTY_INPUT_PARAMETER, "data sms arges is empty");
95 TELEPHONY_LOGE("DataBasedSmsDelivery failed to send.");
96 return TELEPHONY_ERR_ARGUMENT_INVALID;
97 }
98 if (smsSendManager_ == nullptr) {
99 TELEPHONY_LOGE("TextBasedSmsDelivery failed to send.");
100 SmsSender::SendResultCallBack(sendCallback, ISendShortMessageCallback::SEND_SMS_FAILURE_UNKNOWN);
101 SmsHiSysEvent::WriteSmsSendFaultEvent(slotId_, SmsMmsMessageType::SMS_SHORT_MESSAGE,
102 SmsMmsErrorCode::SMS_ERROR_NULL_POINTER, "text sms smsSendManager_ is nullptr");
103 return TELEPHONY_ERR_LOCAL_PTR_NULL;
104 }
105 smsSendManager_->DataBasedSmsDelivery(desAddr, scAddr, port, data, dataLen, sendCallback, deliveryCallback);
106 return TELEPHONY_ERR_SUCCESS;
107 }
108
AddSimMessage(const std::string & smsc,const std::string & pdu,ISmsServiceInterface::SimMessageStatus status)109 int32_t SmsInterfaceManager::AddSimMessage(
110 const std::string &smsc, const std::string &pdu, ISmsServiceInterface::SimMessageStatus status)
111 {
112 if (smsMiscManager_ == nullptr) {
113 TELEPHONY_LOGE("smsMiscManager nullptr error.");
114 return TELEPHONY_ERR_LOCAL_PTR_NULL;
115 }
116 return smsMiscManager_->AddSimMessage(smsc, pdu, status);
117 }
118
DelSimMessage(uint32_t msgIndex)119 int32_t SmsInterfaceManager::DelSimMessage(uint32_t msgIndex)
120 {
121 if (smsMiscManager_ == nullptr) {
122 TELEPHONY_LOGE("smsMiscManager nullptr error.");
123 return TELEPHONY_ERR_LOCAL_PTR_NULL;
124 }
125 return smsMiscManager_->DelSimMessage(msgIndex);
126 }
127
UpdateSimMessage(uint32_t msgIndex,ISmsServiceInterface::SimMessageStatus newStatus,const std::string & pdu,const std::string & smsc)128 int32_t SmsInterfaceManager::UpdateSimMessage(uint32_t msgIndex, ISmsServiceInterface::SimMessageStatus newStatus,
129 const std::string &pdu, const std::string &smsc)
130 {
131 if (smsMiscManager_ == nullptr) {
132 TELEPHONY_LOGE("smsMiscManager nullptr error.");
133 return TELEPHONY_ERR_LOCAL_PTR_NULL;
134 }
135 return smsMiscManager_->UpdateSimMessage(msgIndex, newStatus, pdu, smsc);
136 }
137
GetAllSimMessages(std::vector<ShortMessage> & message)138 int32_t SmsInterfaceManager::GetAllSimMessages(std::vector<ShortMessage> &message)
139 {
140 if (smsMiscManager_ == nullptr) {
141 TELEPHONY_LOGE("smsMiscManager nullptr error.");
142 return TELEPHONY_ERR_LOCAL_PTR_NULL;
143 }
144 return smsMiscManager_->GetAllSimMessages(message);
145 }
146
SetSmscAddr(const std::string & scAddr)147 int32_t SmsInterfaceManager::SetSmscAddr(const std::string &scAddr)
148 {
149 if (smsMiscManager_ == nullptr) {
150 TELEPHONY_LOGE("smsMiscManager nullptr error.");
151 return TELEPHONY_ERR_LOCAL_PTR_NULL;
152 }
153 return smsMiscManager_->SetSmscAddr(scAddr);
154 }
155
GetSmscAddr(std::u16string & smscAddress)156 int32_t SmsInterfaceManager::GetSmscAddr(std::u16string &smscAddress)
157 {
158 if (smsMiscManager_ == nullptr) {
159 TELEPHONY_LOGE("smsMiscManager nullptr error.");
160 return TELEPHONY_ERR_LOCAL_PTR_NULL;
161 }
162 return smsMiscManager_->GetSmscAddr(smscAddress);
163 }
164
SetCBConfig(bool enable,uint32_t fromMsgId,uint32_t toMsgId,uint8_t netType)165 int32_t SmsInterfaceManager::SetCBConfig(bool enable, uint32_t fromMsgId, uint32_t toMsgId, uint8_t netType)
166 {
167 if (smsMiscManager_ == nullptr) {
168 TELEPHONY_LOGE("smsMiscManager nullptr error.");
169 return TELEPHONY_ERR_LOCAL_PTR_NULL;
170 }
171 return smsMiscManager_->SetCBConfig(enable, fromMsgId, toMsgId, netType);
172 }
173
SetImsSmsConfig(int32_t slotId,int32_t enable)174 bool SmsInterfaceManager::SetImsSmsConfig(int32_t slotId, int32_t enable)
175 {
176 if (smsMiscManager_ == nullptr) {
177 TELEPHONY_LOGE("smsMiscManager nullptr error.");
178 return false;
179 }
180 return smsSendManager_->SetImsSmsConfig(slotId, enable);
181 }
182
SetDefaultSmsSlotId(int32_t slotId)183 int32_t SmsInterfaceManager::SetDefaultSmsSlotId(int32_t slotId)
184 {
185 if (smsMiscManager_ == nullptr) {
186 TELEPHONY_LOGE("smsMiscManager nullptr error.");
187 return TELEPHONY_ERR_LOCAL_PTR_NULL;
188 }
189 return smsMiscManager_->SetDefaultSmsSlotId(slotId);
190 }
191
GetDefaultSmsSlotId()192 int32_t SmsInterfaceManager::GetDefaultSmsSlotId()
193 {
194 if (smsMiscManager_ == nullptr) {
195 TELEPHONY_LOGE("smsMiscManager nullptr error.");
196 return TELEPHONY_ERROR;
197 }
198 return smsMiscManager_->GetDefaultSmsSlotId();
199 }
200
GetDefaultSmsSimId(int32_t & simId)201 int32_t SmsInterfaceManager::GetDefaultSmsSimId(int32_t &simId)
202 {
203 if (smsMiscManager_ == nullptr) {
204 TELEPHONY_LOGE("smsMiscManager nullptr error.");
205 return TELEPHONY_ERR_LOCAL_PTR_NULL;
206 }
207 return smsMiscManager_->GetDefaultSmsSimId(simId);
208 }
209
SplitMessage(const std::string & message,std::vector<std::u16string> & splitMessage)210 int32_t SmsInterfaceManager::SplitMessage(const std::string &message, std::vector<std::u16string> &splitMessage)
211 {
212 if (smsSendManager_ == nullptr) {
213 TELEPHONY_LOGE("smsSendManager nullptr error.");
214 return TELEPHONY_ERR_LOCAL_PTR_NULL;
215 }
216 return smsSendManager_->SplitMessage(message, splitMessage);
217 }
218
GetSmsSegmentsInfo(const std::string & message,bool force7BitCode,LengthInfo & outInfo)219 int32_t SmsInterfaceManager::GetSmsSegmentsInfo(const std::string &message, bool force7BitCode, LengthInfo &outInfo)
220 {
221 if (smsSendManager_ == nullptr) {
222 TELEPHONY_LOGE("smsSendManager nullptr error.");
223 return TELEPHONY_ERR_LOCAL_PTR_NULL;
224 }
225 return smsSendManager_->GetSmsSegmentsInfo(message, force7BitCode, outInfo);
226 }
227
IsImsSmsSupported(int32_t slotId,bool & isSupported)228 int32_t SmsInterfaceManager::IsImsSmsSupported(int32_t slotId, bool &isSupported)
229 {
230 if (smsSendManager_ == nullptr) {
231 TELEPHONY_LOGE("smsSendManager is nullptr error.");
232 return TELEPHONY_ERR_LOCAL_PTR_NULL;
233 }
234 return smsSendManager_->IsImsSmsSupported(slotId, isSupported);
235 }
236
GetImsShortMessageFormat(std::u16string & format)237 int32_t SmsInterfaceManager::GetImsShortMessageFormat(std::u16string &format)
238 {
239 if (smsSendManager_ == nullptr) {
240 TELEPHONY_LOGE("smsSendManager is nullptr error.");
241 return TELEPHONY_ERR_LOCAL_PTR_NULL;
242 }
243 return smsSendManager_->GetImsShortMessageFormat(format);
244 }
245
HasSmsCapability()246 bool SmsInterfaceManager::HasSmsCapability()
247 {
248 auto helperPtr = DelayedSingleton<SmsPersistHelper>::GetInstance();
249 if (helperPtr == nullptr) {
250 TELEPHONY_LOGE("Get SmsPersistHelper Singleton nullptr error.");
251 return true;
252 }
253 return helperPtr->QueryParamBoolean(SmsPersistHelper::SMS_CAPABLE_PARAM_KEY, true);
254 }
255
SendMms(const std::u16string & mmsc,const std::u16string & data,const std::u16string & ua,const std::u16string & uaprof)256 int32_t SmsInterfaceManager::SendMms(
257 const std::u16string &mmsc, const std::u16string &data, const std::u16string &ua, const std::u16string &uaprof)
258 {
259 if (mmsSendManager_ == nullptr) {
260 TELEPHONY_LOGE("mmsSendManager_ nullptr error");
261 return TELEPHONY_ERR_LOCAL_PTR_NULL;
262 }
263 return mmsSendManager_->SendMms(mmsc, data, ua, uaprof);
264 }
265
DownloadMms(const std::u16string & mmsc,std::u16string & data,const std::u16string & ua,const std::u16string & uaprof)266 int32_t SmsInterfaceManager::DownloadMms(
267 const std::u16string &mmsc, std::u16string &data, const std::u16string &ua, const std::u16string &uaprof)
268 {
269 if (mmsReceiverManager_ == nullptr) {
270 TELEPHONY_LOGE("mmsReceiverManager_ nullptr error");
271 return TELEPHONY_ERR_LOCAL_PTR_NULL;
272 }
273 return mmsReceiverManager_->DownloadMms(mmsc, data, ua, uaprof);
274 }
275
OnRilAdapterHostDied()276 int32_t SmsInterfaceManager::OnRilAdapterHostDied()
277 {
278 if (smsSendManager_ == nullptr) {
279 TELEPHONY_LOGE("smsSendManager is nullptr error.");
280 return TELEPHONY_ERR_LOCAL_PTR_NULL;
281 }
282 smsSendManager_->OnRilAdapterHostDied();
283 return TELEPHONY_ERR_SUCCESS;
284 }
285 } // namespace Telephony
286 } // namespace OHOS
287