1 /*
2  * Copyright (C) 2021-2023 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_stub.h"
17 
18 #include "sms_interface_manager.h"
19 #include "sms_receive_reliability_handler.h"
20 #include "sms_service.h"
21 #include "string_utils.h"
22 #include "telephony_errors.h"
23 #include "telephony_log_wrapper.h"
24 #include "telephony_types.h"
25 
26 namespace OHOS {
27 namespace Telephony {
28 using namespace std;
29 
IsValidSlotId(int32_t slotId)30 static inline bool IsValidSlotId(int32_t slotId)
31 {
32     return ((slotId >= DEFAULT_SIM_SLOT_ID) && (slotId < SIM_SLOT_COUNT));
33 }
34 
SmsInterfaceStub()35 SmsInterfaceStub::SmsInterfaceStub()
36 {
37     memberFuncMap_[SmsServiceInterfaceCode::TEXT_BASED_SMS_DELIVERY] = [this](MessageParcel &data,
38         MessageParcel &reply, MessageOption &option) { OnSendSmsTextRequest(data, reply, option); };
39     memberFuncMap_[SmsServiceInterfaceCode::DATA_BASED_SMS_DELIVERY] = [this](MessageParcel &data,
40         MessageParcel &reply, MessageOption &option) { OnSendSmsDataRequest(data, reply, option); };
41     memberFuncMap_[SmsServiceInterfaceCode::SET_SMSC_ADDRESS] = [this](MessageParcel &data,
42         MessageParcel &reply, MessageOption &option) { OnSetSmscAddr(data, reply, option); };
43     memberFuncMap_[SmsServiceInterfaceCode::GET_SMSC_ADDRESS] = [this](MessageParcel &data,
44         MessageParcel &reply, MessageOption &option) { OnGetSmscAddr(data, reply, option); };
45     memberFuncMap_[SmsServiceInterfaceCode::ADD_SIM_MESSAGE] = [this](MessageParcel &data,
46         MessageParcel &reply, MessageOption &option) { OnAddSimMessage(data, reply, option); };
47     memberFuncMap_[SmsServiceInterfaceCode::DEL_SIM_MESSAGE] = [this](MessageParcel &data,
48         MessageParcel &reply, MessageOption &option) { OnDelSimMessage(data, reply, option); };
49     memberFuncMap_[SmsServiceInterfaceCode::UPDATE_SIM_MESSAGE] = [this](MessageParcel &data,
50         MessageParcel &reply, MessageOption &option) { OnUpdateSimMessage(data, reply, option); };
51     memberFuncMap_[SmsServiceInterfaceCode::GET_ALL_SIM_MESSAGE] = [this](MessageParcel &data,
52         MessageParcel &reply, MessageOption &option) { OnGetAllSimMessages(data, reply, option); };
53     memberFuncMap_[SmsServiceInterfaceCode::SET_CB_CONFIG] = [this](MessageParcel &data,
54         MessageParcel &reply, MessageOption &option) { OnSetCBConfig(data, reply, option); };
55     memberFuncMap_[SmsServiceInterfaceCode::SET_IMS_SMS_CONFIG] = [this](MessageParcel &data,
56         MessageParcel &reply, MessageOption &option) { OnSetImsSmsConfig(data, reply, option); };
57     memberFuncMap_[SmsServiceInterfaceCode::SET_DEFAULT_SMS_SLOT_ID] = [this](MessageParcel &data,
58         MessageParcel &reply, MessageOption &option) { OnSetDefaultSmsSlotId(data, reply, option); };
59     memberFuncMap_[SmsServiceInterfaceCode::GET_DEFAULT_SMS_SLOT_ID] = [this](MessageParcel &data,
60         MessageParcel &reply, MessageOption &option) { OnGetDefaultSmsSlotId(data, reply, option); };
61     memberFuncMap_[SmsServiceInterfaceCode::GET_DEFAULT_SMS_SIM_ID] = [this](MessageParcel &data,
62         MessageParcel &reply, MessageOption &option) { OnGetDefaultSmsSimId(data, reply, option); };
63     memberFuncMap_[SmsServiceInterfaceCode::SPLIT_MESSAGE] = [this](MessageParcel &data,
64         MessageParcel &reply, MessageOption &option) { OnSplitMessage(data, reply, option); };
65     memberFuncMap_[SmsServiceInterfaceCode::GET_SMS_SEGMENTS_INFO] = [this](MessageParcel &data,
66         MessageParcel &reply, MessageOption &option) { OnGetSmsSegmentsInfo(data, reply, option); };
67     memberFuncMap_[SmsServiceInterfaceCode::GET_IMS_SHORT_MESSAGE_FORMAT] = [this](MessageParcel &data,
68         MessageParcel &reply, MessageOption &option) { OnGetImsShortMessageFormat(data, reply, option); };
69     memberFuncMap_[SmsServiceInterfaceCode::IS_IMS_SMS_SUPPORTED] = [this](MessageParcel &data,
70         MessageParcel &reply, MessageOption &option) { OnIsImsSmsSupported(data, reply, option); };
71     memberFuncMap_[SmsServiceInterfaceCode::HAS_SMS_CAPABILITY] = [this](MessageParcel &data,
72         MessageParcel &reply, MessageOption &option) { OnHasSmsCapability(data, reply, option); };
73     memberFuncMap_[SmsServiceInterfaceCode::CREATE_MESSAGE] = [this](MessageParcel &data,
74         MessageParcel &reply, MessageOption &option) { OnCreateMessage(data, reply, option); };
75     memberFuncMap_[SmsServiceInterfaceCode::MMS_BASE64_ENCODE] = [this](MessageParcel &data,
76         MessageParcel &reply, MessageOption &option) { OnGetBase64Encode(data, reply, option); };
77     memberFuncMap_[SmsServiceInterfaceCode::MMS_BASE64_DECODE] = [this](MessageParcel &data,
78         MessageParcel &reply, MessageOption &option) { OnGetBase64Decode(data, reply, option); };
79     memberFuncMap_[SmsServiceInterfaceCode::GET_ENCODE_STRING] = [this](MessageParcel &data,
80         MessageParcel &reply, MessageOption &option) { OnGetEncodeStringFunc(data, reply, option); };
81     memberFuncMap_[SmsServiceInterfaceCode::SEND_MMS] = [this](MessageParcel &data,
82         MessageParcel &reply, MessageOption &option) { OnSendMms(data, reply, option); };
83     memberFuncMap_[SmsServiceInterfaceCode::DOWNLOAD_MMS] = [this](MessageParcel &data,
84         MessageParcel &reply, MessageOption &option) { OnDownloadMms(data, reply, option); };
85 }
86 
~SmsInterfaceStub()87 SmsInterfaceStub::~SmsInterfaceStub()
88 {
89     slotSmsInterfaceManagerMap_.clear();
90     memberFuncMap_.clear();
91 }
92 
InitModule()93 void SmsInterfaceStub::InitModule()
94 {
95     static bool bInitModule = false;
96     if (bInitModule) {
97         return;
98     }
99     bInitModule = true;
100     std::lock_guard<std::mutex> lock(mutex_);
101     for (int32_t slotId = 0; slotId < SIM_SLOT_COUNT; ++slotId) {
102         slotSmsInterfaceManagerMap_[slotId] = std::make_shared<SmsInterfaceManager>(slotId);
103         if (slotSmsInterfaceManagerMap_[slotId] == nullptr) {
104             TELEPHONY_LOGE("SmsInterfaceStub InitModule slotSmsInterfaceManagerMap_[%{public}d] is nullptr", slotId);
105             return;
106         }
107         slotSmsInterfaceManagerMap_[slotId]->InitInterfaceManager();
108 
109         TelFFRTUtils::Submit([slotId]() {
110             auto reliabilityHandler = std::make_shared<SmsReceiveReliabilityHandler>(slotId);
111             if (reliabilityHandler == nullptr) {
112                 TELEPHONY_LOGE("reliabilityHandler nullptr");
113                 return;
114             }
115             if (!reliabilityHandler->DeleteExpireSmsFromDB()) {
116                 return;
117             }
118             if (!reliabilityHandler->CheckSmsCapable()) {
119                 TELEPHONY_LOGE("sms receive capable unSupport");
120                 return;
121             }
122             reliabilityHandler->SmsReceiveReliabilityProcessing();
123         });
124     }
125 }
126 
GetSmsInterfaceManager(int32_t slotId)127 std::shared_ptr<SmsInterfaceManager> SmsInterfaceStub::GetSmsInterfaceManager(int32_t slotId)
128 {
129     std::lock_guard<std::mutex> lock(mutex_);
130     std::map<uint32_t, std::shared_ptr<SmsInterfaceManager>>::iterator iter =
131         slotSmsInterfaceManagerMap_.find(slotId);
132     if (iter != slotSmsInterfaceManagerMap_.end()) {
133         return iter->second;
134     }
135     return nullptr;
136 }
137 
GetSmsInterfaceManager()138 std::shared_ptr<SmsInterfaceManager> SmsInterfaceStub::GetSmsInterfaceManager()
139 {
140     std::lock_guard<std::mutex> lock(mutex_);
141     for (const auto &iter : slotSmsInterfaceManagerMap_) {
142         if (iter.second != nullptr) {
143             return iter.second;
144         }
145     }
146     return nullptr;
147 }
148 
OnSendSmsTextRequest(MessageParcel & data,MessageParcel & reply,MessageOption & option)149 void SmsInterfaceStub::OnSendSmsTextRequest(MessageParcel &data, MessageParcel &reply, MessageOption &option)
150 {
151     sptr<ISendShortMessageCallback> sendCallback = nullptr;
152     sptr<IDeliveryShortMessageCallback> deliveryCallback = nullptr;
153     int32_t slotId = data.ReadInt32();
154     u16string desAddr = data.ReadString16();
155     u16string scAddr = data.ReadString16();
156     u16string text = data.ReadString16();
157     if (!IsValidSlotId(slotId)) {
158         TELEPHONY_LOGE("invalid slotId：%{public}d", slotId);
159         return;
160     }
161 
162     sptr<IRemoteObject> remoteSendCallback = data.ReadRemoteObject();
163     sptr<IRemoteObject> remoteDeliveryCallback = data.ReadRemoteObject();
164     if (remoteSendCallback != nullptr) {
165         sendCallback = iface_cast<ISendShortMessageCallback>(remoteSendCallback);
166     }
167     if (remoteDeliveryCallback != nullptr) {
168         deliveryCallback = iface_cast<IDeliveryShortMessageCallback>(remoteDeliveryCallback);
169     }
170     TELEPHONY_LOGI("MessageID::TEXT_BASED_SMS_DELIVERY %{public}d", slotId);
171     RemoveSpacesInDesAddr(desAddr);
172     std::string bundleName = data.ReadString();
173     TELEPHONY_LOGI("bundleName = %{public}s", bundleName.c_str());
174     int32_t result = SendMessage(slotId, desAddr, scAddr, text, sendCallback, deliveryCallback);
175     if (bundleName != MMS_APP && result == TELEPHONY_ERR_SUCCESS) {
176         DelayedSingleton<SmsService>::GetInstance()->InsertSessionAndDetail(slotId, StringUtils::ToUtf8(desAddr),
177             StringUtils::ToUtf8(text));
178     }
179     reply.WriteInt32(result);
180 }
181 
OnSendSmsDataRequest(MessageParcel & data,MessageParcel & reply,MessageOption & option)182 void SmsInterfaceStub::OnSendSmsDataRequest(MessageParcel &data, MessageParcel &reply, MessageOption &option)
183 {
184     sptr<ISendShortMessageCallback> sendCallback = nullptr;
185     sptr<IDeliveryShortMessageCallback> deliveryCallback = nullptr;
186     int32_t slotId = data.ReadInt32();
187     u16string desAddr = data.ReadString16();
188     u16string scAddr = data.ReadString16();
189     int16_t port = data.ReadInt16();
190     if (!IsValidSlotId(slotId)) {
191         TELEPHONY_LOGE("invalid slotId：%{public}d", slotId);
192         return;
193     }
194 
195     sptr<IRemoteObject> remoteSendCallback = data.ReadRemoteObject();
196     sptr<IRemoteObject> remoteDeliveryCallback = data.ReadRemoteObject();
197     if (remoteSendCallback != nullptr) {
198         sendCallback = iface_cast<ISendShortMessageCallback>(remoteSendCallback);
199     }
200     if (remoteDeliveryCallback != nullptr) {
201         deliveryCallback = iface_cast<IDeliveryShortMessageCallback>(remoteDeliveryCallback);
202     }
203     int16_t dataLen = data.ReadInt16();
204     const uint8_t *buffer = reinterpret_cast<const uint8_t *>(data.ReadRawData(dataLen));
205     if (buffer == nullptr) {
206         return;
207     }
208     RemoveSpacesInDesAddr(desAddr);
209     int32_t result = SendMessage(slotId, desAddr, scAddr, port, buffer, dataLen, sendCallback, deliveryCallback);
210     reply.WriteInt32(result);
211 }
212 
RemoveSpacesInDesAddr(std::u16string & desAddr)213 void SmsInterfaceStub::RemoveSpacesInDesAddr(std::u16string &desAddr)
214 {
215     // Remove spaces in desAddr
216     if (desAddr.empty() || desAddr.size() >= MAX_ADDRESS_LEN) {
217         TELEPHONY_LOGE("RemoveSpacesInDesAddr desAddr is invalid");
218         return;
219     }
220 
221     std::u16string storeAddr = desAddr;
222     int32_t count = static_cast<int32_t>(desAddr.size());
223     int32_t indexDes = 0;
224     int32_t indexResult = 0;
225     while (indexDes < count) {
226         if (desAddr[indexDes] != ' ') {
227             storeAddr[indexResult] = desAddr[indexDes];
228             indexResult++;
229         }
230         indexDes++;
231     }
232     desAddr = storeAddr.substr(0, indexResult);
233 }
234 
OnSetSmscAddr(MessageParcel & data,MessageParcel & reply,MessageOption & option)235 void SmsInterfaceStub::OnSetSmscAddr(MessageParcel &data, MessageParcel &reply, MessageOption &option)
236 {
237     int32_t slotId = data.ReadInt32();
238     std::u16string scAddr = data.ReadString16();
239     int32_t result = SetSmscAddr(slotId, scAddr);
240     TELEPHONY_LOGI("set smsc result:%{public}d", result == TELEPHONY_ERR_SUCCESS);
241     reply.WriteInt32(result);
242 }
243 
OnGetSmscAddr(MessageParcel & data,MessageParcel & reply,MessageOption & option)244 void SmsInterfaceStub::OnGetSmscAddr(MessageParcel &data, MessageParcel &reply, MessageOption &option)
245 {
246     std::u16string smscAddress;
247     int32_t slotId = data.ReadInt32();
248     int32_t result = GetSmscAddr(slotId, smscAddress);
249     if (!reply.WriteInt32(result)) {
250         TELEPHONY_LOGE("SmsInterfaceStub::OnGetSmscAddr write reply failed.");
251         return;
252     }
253     if (result != TELEPHONY_ERR_SUCCESS) {
254         TELEPHONY_LOGE("SmsInterfaceStub::OnGetSmscAddr result is not TELEPHONY_ERR_SUCCESS.");
255         return;
256     }
257 
258     if (!reply.WriteString16(smscAddress)) {
259         TELEPHONY_LOGE("SmsInterfaceStub::OnGetSmscAddr write reply failed.");
260         return;
261     }
262 }
263 
OnAddSimMessage(MessageParcel & data,MessageParcel & reply,MessageOption & option)264 void SmsInterfaceStub::OnAddSimMessage(MessageParcel &data, MessageParcel &reply, MessageOption &option)
265 {
266     int32_t slotId = data.ReadInt32();
267     std::u16string smsc = data.ReadString16();
268     std::u16string pdu = data.ReadString16();
269     uint32_t status = data.ReadUint32();
270     if (status > SIM_MESSAGE_STATUS_SENT || status < SIM_MESSAGE_STATUS_UNREAD) {
271         return;
272     }
273     int32_t result = AddSimMessage(slotId, smsc, pdu, static_cast<SimMessageStatus>(status));
274     TELEPHONY_LOGI("AddSimMessage result %{public}d", result);
275     reply.WriteInt32(result);
276 }
277 
OnDelSimMessage(MessageParcel & data,MessageParcel & reply,MessageOption & option)278 void SmsInterfaceStub::OnDelSimMessage(MessageParcel &data, MessageParcel &reply, MessageOption &option)
279 {
280     int32_t slotId = data.ReadInt32();
281     uint32_t msgIndex = data.ReadUint32();
282     int32_t result = DelSimMessage(slotId, msgIndex);
283     TELEPHONY_LOGI("DelSimMessage result %{public}d", result);
284     reply.WriteInt32(result);
285 }
286 
OnUpdateSimMessage(MessageParcel & data,MessageParcel & reply,MessageOption & option)287 void SmsInterfaceStub::OnUpdateSimMessage(MessageParcel &data, MessageParcel &reply, MessageOption &option)
288 {
289     int32_t slotId = data.ReadInt32();
290     uint32_t msgIndex = data.ReadUint32();
291     uint32_t newStatus = data.ReadUint32();
292     std::u16string pdu = data.ReadString16();
293     std::u16string smsc = data.ReadString16();
294     if (newStatus > SIM_MESSAGE_STATUS_SENT || newStatus < SIM_MESSAGE_STATUS_UNREAD) {
295         return;
296     }
297     int32_t result = UpdateSimMessage(slotId, msgIndex, static_cast<SimMessageStatus>(newStatus), pdu, smsc);
298     TELEPHONY_LOGI("UpdateSimMessage result %{public}d", result);
299     reply.WriteInt32(result);
300 }
301 
OnGetAllSimMessages(MessageParcel & data,MessageParcel & reply,MessageOption & option)302 void SmsInterfaceStub::OnGetAllSimMessages(MessageParcel &data, MessageParcel &reply, MessageOption &option)
303 {
304     std::vector<ShortMessage> message;
305     int32_t slotId = data.ReadInt32();
306     int32_t result = GetAllSimMessages(slotId, message);
307     TELEPHONY_LOGI("GetAllSimMessages result %{public}d size %{public}zu", result, message.size());
308     reply.WriteInt32(result);
309     if (result != TELEPHONY_ERR_SUCCESS) {
310         TELEPHONY_LOGE("SmsInterfaceStub::OnGetSmscAddr result is not TELEPHONY_ERR_SUCCESS.");
311         return;
312     }
313     int32_t resultLen = static_cast<int32_t>(message.size());
314     reply.WriteInt32(resultLen);
315     for (const auto &v : message) {
316         v.Marshalling(reply);
317     }
318 }
319 
OnSetCBConfig(MessageParcel & data,MessageParcel & reply,MessageOption & option)320 void SmsInterfaceStub::OnSetCBConfig(MessageParcel &data, MessageParcel &reply, MessageOption &option)
321 {
322     int32_t slotId = data.ReadInt32();
323     TELEPHONY_LOGD("set cb config slotId:%{public}d", slotId);
324     bool enable = data.ReadBool();
325     uint32_t fromMsgId = data.ReadUint32();
326     uint32_t toMsgId = data.ReadUint32();
327     uint8_t ranType = data.ReadUint8();
328     int32_t result = SetCBConfig(slotId, enable, fromMsgId, toMsgId, ranType);
329     if (result != TELEPHONY_ERR_SUCCESS) {
330         TELEPHONY_LOGE("OnSetCBConfig fail, result:%{public}d, slotId:%{public}d", result, slotId);
331     }
332     reply.WriteInt32(result);
333 }
334 
OnSetImsSmsConfig(MessageParcel & data,MessageParcel & reply,MessageOption & option)335 void SmsInterfaceStub::OnSetImsSmsConfig(MessageParcel &data, MessageParcel &reply, MessageOption &option)
336 {
337     bool result = false;
338     int32_t slotId = data.ReadInt32();
339     int32_t enable = data.ReadInt32();
340     result = SetImsSmsConfig(slotId, enable);
341     TELEPHONY_LOGI("SetImsSmsConfig result %{public}d", result);
342     reply.WriteBool(result);
343 }
344 
OnSetDefaultSmsSlotId(MessageParcel & data,MessageParcel & reply,MessageOption & option)345 void SmsInterfaceStub::OnSetDefaultSmsSlotId(MessageParcel &data, MessageParcel &reply, MessageOption &option)
346 {
347     int32_t slotId = data.ReadInt32();
348     int32_t result = SetDefaultSmsSlotId(slotId);
349     TELEPHONY_LOGI("SetDefaultSmsSlotId result %{public}d", result);
350     reply.WriteInt32(result);
351 }
352 
OnGetDefaultSmsSlotId(MessageParcel & data,MessageParcel & reply,MessageOption & option)353 void SmsInterfaceStub::OnGetDefaultSmsSlotId(MessageParcel &data, MessageParcel &reply, MessageOption &option)
354 {
355     int32_t result = 0;
356     result = GetDefaultSmsSlotId();
357     TELEPHONY_LOGI("SetDefaultSmsSlotId result %{public}d", result);
358     reply.WriteInt32(result);
359 }
360 
OnGetDefaultSmsSimId(MessageParcel & data,MessageParcel & reply,MessageOption & option)361 void SmsInterfaceStub::OnGetDefaultSmsSimId(MessageParcel &data, MessageParcel &reply, MessageOption &option)
362 {
363     int32_t result = 0;
364     int32_t simId = 0;
365     result = GetDefaultSmsSimId(simId);
366     if (!reply.WriteInt32(result)) {
367         TELEPHONY_LOGE("write int32 reply failed.");
368         return;
369     }
370     if (result != TELEPHONY_ERR_SUCCESS) {
371         TELEPHONY_LOGE("result %{public}d", result);
372         return;
373     }
374     if (!reply.WriteInt32(simId)) {
375         TELEPHONY_LOGE("write int32 reply failed.");
376         return;
377     }
378 }
379 
OnSplitMessage(MessageParcel & data,MessageParcel & reply,MessageOption & option)380 void SmsInterfaceStub::OnSplitMessage(MessageParcel &data, MessageParcel &reply, MessageOption &option)
381 {
382     std::vector<std::u16string> splitMessage;
383     std::u16string message = data.ReadString16();
384     int32_t result = SplitMessage(message, splitMessage);
385     reply.WriteInt32(result);
386     if (result != TELEPHONY_ERR_SUCCESS) {
387         TELEPHONY_LOGE("SmsInterfaceStub::OnSplitMessage result is not TELEPHONY_ERR_SUCCESS.");
388         return;
389     }
390     int32_t resultLen = static_cast<int32_t>(splitMessage.size());
391     TELEPHONY_LOGI("SplitMessage size %{public}d", resultLen);
392     reply.WriteInt32(resultLen);
393     for (const auto &item : splitMessage) {
394         reply.WriteString16(item);
395     }
396 }
397 
OnGetSmsSegmentsInfo(MessageParcel & data,MessageParcel & reply,MessageOption & option)398 void SmsInterfaceStub::OnGetSmsSegmentsInfo(MessageParcel &data, MessageParcel &reply, MessageOption &option)
399 {
400     int32_t slotId = data.ReadInt32();
401     std::u16string message = data.ReadString16();
402     bool force7BitCode = data.ReadBool();
403 
404     SmsSegmentsInfo segInfo;
405     int32_t result = GetSmsSegmentsInfo(slotId, message, force7BitCode, segInfo);
406     reply.WriteInt32(result);
407 
408     if (result == TELEPHONY_ERR_SUCCESS) {
409         reply.WriteInt32(segInfo.msgSegCount);
410         reply.WriteInt32(segInfo.msgEncodingCount);
411         reply.WriteInt32(segInfo.msgRemainCount);
412         reply.WriteInt32(static_cast<int32_t>(segInfo.msgCodeScheme));
413     }
414 }
415 
OnIsImsSmsSupported(MessageParcel & data,MessageParcel & reply,MessageOption & option)416 void SmsInterfaceStub::OnIsImsSmsSupported(MessageParcel &data, MessageParcel &reply, MessageOption &option)
417 {
418     int32_t slotId = data.ReadInt32();
419     bool isSupported = false;
420     int32_t result = IsImsSmsSupported(slotId, isSupported);
421     if (!reply.WriteInt32(result)) {
422         TELEPHONY_LOGE("SmsInterfaceStub::OnIsImsSmsSupported write reply failed.");
423         return;
424     }
425     if (result != TELEPHONY_ERR_SUCCESS) {
426         TELEPHONY_LOGE("SmsInterfaceStub::OnIsImsSmsSupported result is not TELEPHONY_ERR_SUCCESS.");
427         return;
428     }
429     if (!reply.WriteBool(isSupported)) {
430         TELEPHONY_LOGE("SmsInterfaceStub::OnIsImsSmsSupported write reply failed.");
431         return;
432     }
433 }
434 
OnGetImsShortMessageFormat(MessageParcel & data,MessageParcel & reply,MessageOption & option)435 void SmsInterfaceStub::OnGetImsShortMessageFormat(MessageParcel &data, MessageParcel &reply, MessageOption &option)
436 {
437     std::u16string format;
438     int32_t result = GetImsShortMessageFormat(format);
439     reply.WriteInt32(result);
440     if (result != TELEPHONY_ERR_SUCCESS) {
441         TELEPHONY_LOGE("SmsInterfaceStub::OnGetImsShortMessageFormat result is not TELEPHONY_ERR_SUCCESS.");
442         return;
443     }
444     reply.WriteString16(format);
445 }
446 
OnHasSmsCapability(MessageParcel & data,MessageParcel & reply,MessageOption & option)447 void SmsInterfaceStub::OnHasSmsCapability(MessageParcel &data, MessageParcel &reply, MessageOption &option)
448 {
449     reply.WriteBool(HasSmsCapability());
450 }
451 
OnCreateMessage(MessageParcel & data,MessageParcel & reply,MessageOption & option)452 void SmsInterfaceStub::OnCreateMessage(MessageParcel &data, MessageParcel &reply, MessageOption &option)
453 {
454     std::string pdu = data.ReadString();
455     std::string specification = data.ReadString();
456     ShortMessage message;
457     int32_t result = CreateMessage(pdu, specification, message);
458 
459     reply.WriteInt32(result);
460     if (result != TELEPHONY_ERR_SUCCESS) {
461         return;
462     }
463     if (!message.Marshalling(reply)) {
464         TELEPHONY_LOGE("SmsInterfaceStub::OnCreateMessage fail");
465     }
466 }
467 
OnGetBase64Encode(MessageParcel & data,MessageParcel & reply,MessageOption & option)468 void SmsInterfaceStub::OnGetBase64Encode(MessageParcel &data, MessageParcel &reply, MessageOption &option)
469 {
470     bool result = false;
471 
472     u16string src = data.ReadString16();
473     std::string dest;
474     result = GetBase64Encode(StringUtils::ToUtf8(src), dest);
475     reply.WriteBool(result);
476     if (!result) {
477         return;
478     }
479     reply.WriteString16(StringUtils::ToUtf16(dest));
480 }
481 
OnGetBase64Decode(MessageParcel & data,MessageParcel & reply,MessageOption & option)482 void SmsInterfaceStub::OnGetBase64Decode(MessageParcel &data, MessageParcel &reply, MessageOption &option)
483 {
484     bool result = false;
485     u16string src = data.ReadString16();
486     std::string dest;
487     result = GetBase64Decode(StringUtils::ToUtf8(src), dest);
488     reply.WriteBool(result);
489     if (!result) {
490         return;
491     }
492     reply.WriteString16(StringUtils::ToUtf16(dest));
493 }
494 
OnGetEncodeStringFunc(MessageParcel & data,MessageParcel & reply,MessageOption & option)495 void SmsInterfaceStub::OnGetEncodeStringFunc(MessageParcel &data, MessageParcel &reply, MessageOption &option)
496 {
497     bool result = false;
498     uint32_t charset = data.ReadUint32();
499     uint32_t valLength = data.ReadUint32();
500     u16string strEncodeString = data.ReadString16();
501     std::string str = StringUtils::ToUtf8(strEncodeString);
502     std::string encodeString;
503 
504     if (valLength != str.length()) {
505         TELEPHONY_LOGE("invalid valLength!");
506         return;
507     }
508     result = GetEncodeStringFunc(encodeString, charset, valLength, str);
509     reply.WriteBool(result);
510     if (!result) {
511         return;
512     }
513     reply.WriteString16(StringUtils::ToUtf16(encodeString));
514 }
515 
OnSendMms(MessageParcel & data,MessageParcel & reply,MessageOption & option)516 void SmsInterfaceStub::OnSendMms(MessageParcel &data, MessageParcel &reply, MessageOption &option)
517 {
518     int32_t slotId = data.ReadInt32();
519     TELEPHONY_LOGI("send mms slotId:%{public}d", slotId);
520     u16string mmsc = data.ReadString16();
521     u16string mmsData = data.ReadString16();
522     u16string ua = data.ReadString16();
523     u16string uaprof = data.ReadString16();
524     int32_t result = SendMms(slotId, mmsc, mmsData, ua, uaprof);
525     if (!reply.WriteInt32(result)) {
526         TELEPHONY_LOGE("SmsInterfaceStub::OnSendMms write reply failed");
527         return;
528     }
529 }
530 
OnDownloadMms(MessageParcel & data,MessageParcel & reply,MessageOption & option)531 void SmsInterfaceStub::OnDownloadMms(MessageParcel &data, MessageParcel &reply, MessageOption &option)
532 {
533     int32_t slotId = data.ReadInt32();
534     TELEPHONY_LOGI("download mms slotId:%{public}d", slotId);
535     u16string mmsc = data.ReadString16();
536     u16string mmsData = data.ReadString16();
537     u16string ua = data.ReadString16();
538     u16string uaprof = data.ReadString16();
539     int32_t result = DownloadMms(slotId, mmsc, mmsData, ua, uaprof);
540     if (!reply.WriteInt32(result)) {
541         TELEPHONY_LOGE("SmsInterfaceStub::OnDownloadMms write reply failed");
542         return;
543     }
544     reply.WriteString16(mmsData);
545     TELEPHONY_LOGI("SmsInterfaceStub::OnDownloadMms dbUrls:%{public}s", StringUtils::ToUtf8(mmsData).c_str());
546 }
547 
OnRemoteRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)548 int SmsInterfaceStub::OnRemoteRequest(
549     uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option)
550 {
551     TELEPHONY_LOGD("SmsInterfaceStub::OnRemoteRequest code:%{public}d", code);
552     std::u16string myDescripter = SmsInterfaceStub::GetDescriptor();
553     std::u16string remoteDescripter = data.ReadInterfaceToken();
554     if (myDescripter != remoteDescripter) {
555         TELEPHONY_LOGE("descriptor checked fail");
556         return TELEPHONY_ERR_DESCRIPTOR_MISMATCH;
557     }
558 
559     auto itFunc = memberFuncMap_.find(static_cast<SmsServiceInterfaceCode>(code));
560     if (itFunc != memberFuncMap_.end()) {
561         auto memberFunc = itFunc->second;
562         if (memberFunc != nullptr) {
563             memberFunc(data, reply, option);
564             return TELEPHONY_ERR_SUCCESS;
565         }
566     }
567     return IPCObjectStub::OnRemoteRequest(code, data, reply, option);
568 }
569 } // namespace Telephony
570 } // namespace OHOS
571