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
24namespace OHOS {
25namespace Telephony {
26using namespace std;
27SmsInterfaceManager::SmsInterfaceManager(int32_t slotId) : slotId_(slotId) {}
28
29SmsInterfaceManager::~SmsInterfaceManager() {}
30
31void 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
66int32_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
88int32_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
110int32_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
120int32_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
129int32_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
139int32_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
148int32_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
157int32_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
166int32_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
175bool SmsInterfaceManager::SetImsSmsConfig(int32_t slotId, int32_t enable)
176{
177    if (smsMiscManager_ == nullptr) {
178        TELEPHONY_LOGE("smsMiscManager nullptr error.");
179        return false;
180    }
181    return smsSendManager_->SetImsSmsConfig(slotId, enable);
182}
183
184int32_t SmsInterfaceManager::SetDefaultSmsSlotId(int32_t slotId)
185{
186    if (smsMiscManager_ == nullptr) {
187        TELEPHONY_LOGE("smsMiscManager nullptr error.");
188        return TELEPHONY_ERR_LOCAL_PTR_NULL;
189    }
190    return smsMiscManager_->SetDefaultSmsSlotId(slotId);
191}
192
193int32_t SmsInterfaceManager::GetDefaultSmsSlotId()
194{
195    if (smsMiscManager_ == nullptr) {
196        TELEPHONY_LOGE("smsMiscManager nullptr error.");
197        return TELEPHONY_ERROR;
198    }
199    return smsMiscManager_->GetDefaultSmsSlotId();
200}
201
202int32_t SmsInterfaceManager::GetDefaultSmsSimId(int32_t &simId)
203{
204    if (smsMiscManager_ == nullptr) {
205        TELEPHONY_LOGE("smsMiscManager nullptr error.");
206        return TELEPHONY_ERR_LOCAL_PTR_NULL;
207    }
208    return smsMiscManager_->GetDefaultSmsSimId(simId);
209}
210
211int32_t SmsInterfaceManager::SplitMessage(const std::string &message, std::vector<std::u16string> &splitMessage)
212{
213    if (smsSendManager_ == nullptr) {
214        TELEPHONY_LOGE("smsSendManager nullptr error.");
215        return TELEPHONY_ERR_LOCAL_PTR_NULL;
216    }
217    return smsSendManager_->SplitMessage(message, splitMessage);
218}
219
220int32_t SmsInterfaceManager::GetSmsSegmentsInfo(const std::string &message, bool force7BitCode, LengthInfo &outInfo)
221{
222    if (smsSendManager_ == nullptr) {
223        TELEPHONY_LOGE("smsSendManager nullptr error.");
224        return TELEPHONY_ERR_LOCAL_PTR_NULL;
225    }
226    return smsSendManager_->GetSmsSegmentsInfo(message, force7BitCode, outInfo);
227}
228
229int32_t SmsInterfaceManager::IsImsSmsSupported(int32_t slotId, bool &isSupported)
230{
231    if (smsSendManager_ == nullptr) {
232        TELEPHONY_LOGE("smsSendManager is nullptr error.");
233        return TELEPHONY_ERR_LOCAL_PTR_NULL;
234    }
235    return smsSendManager_->IsImsSmsSupported(slotId, isSupported);
236}
237
238int32_t SmsInterfaceManager::GetImsShortMessageFormat(std::u16string &format)
239{
240    if (smsSendManager_ == nullptr) {
241        TELEPHONY_LOGE("smsSendManager is nullptr error.");
242        return TELEPHONY_ERR_LOCAL_PTR_NULL;
243    }
244    return smsSendManager_->GetImsShortMessageFormat(format);
245}
246
247bool SmsInterfaceManager::HasSmsCapability()
248{
249    auto helperPtr = DelayedSingleton<SmsPersistHelper>::GetInstance();
250    if (helperPtr == nullptr) {
251        TELEPHONY_LOGE("Get SmsPersistHelper Singleton nullptr error.");
252        return true;
253    }
254    return helperPtr->QueryParamBoolean(SmsPersistHelper::SMS_CAPABLE_PARAM_KEY, true);
255}
256
257int32_t SmsInterfaceManager::SendMms(
258    const std::u16string &mmsc, const std::u16string &data, const std::u16string &ua, const std::u16string &uaprof)
259{
260    if (mmsSendManager_ == nullptr) {
261        TELEPHONY_LOGE("mmsSendManager_ nullptr error");
262        return TELEPHONY_ERR_LOCAL_PTR_NULL;
263    }
264    return mmsSendManager_->SendMms(mmsc, data, ua, uaprof);
265}
266
267int32_t SmsInterfaceManager::DownloadMms(
268    const std::u16string &mmsc, std::u16string &data, const std::u16string &ua, const std::u16string &uaprof)
269{
270    if (mmsReceiverManager_ == nullptr) {
271        TELEPHONY_LOGE("mmsReceiverManager_ nullptr error");
272        return TELEPHONY_ERR_LOCAL_PTR_NULL;
273    }
274    return mmsReceiverManager_->DownloadMms(mmsc, data, ua, uaprof);
275}
276
277int32_t SmsInterfaceManager::OnRilAdapterHostDied()
278{
279    if (smsSendManager_ == nullptr) {
280        TELEPHONY_LOGE("smsSendManager is nullptr error.");
281        return TELEPHONY_ERR_LOCAL_PTR_NULL;
282    }
283    smsSendManager_->OnRilAdapterHostDied();
284    return TELEPHONY_ERR_SUCCESS;
285}
286} // namespace Telephony
287} // namespace OHOS
288