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 "gsm_sms_sender_test.h"
17
18#include <iostream>
19
20#include "ability_context.h"
21#include "ability_info.h"
22#include "access_mms_token.h"
23#include "context_deal.h"
24#include "iservice_registry.h"
25#include "sms_delivery_callback_test.h"
26#include "sms_send_callback_test.h"
27#include "string_utils.h"
28#include "telephony_errors.h"
29
30namespace OHOS {
31namespace Telephony {
32namespace {
33const std::string CU_MMSC = "http://mmsc.myuni.com.cn";
34const std::string SEND_MMS_FILE_URL = "/data/app/deSrc/SendReq.mms";
35} // namespace
36
37void GsmSmsSenderTest::TestGsmSendShortData(const sptr<ISmsServiceInterface> &smsService) const
38{
39    AccessMmsToken token;
40    if (smsService == nullptr) {
41        std::cout << "smsService is nullptr." << std::endl;
42        return;
43    }
44    std::string dest;
45    std::cout << "Please enter the card id" << std::endl;
46    int32_t slotIdTesta;
47    std::cin >> dest;
48    slotIdTesta = atoi(dest.c_str());
49    std::cout << "Please enter the receiver's telephone number" << std::endl;
50    dest.clear();
51    std::cin >> dest;
52    std::string sca("");
53    OHOS::sptr<SmsSendCallbackTest> sendCallBackPtr(new SmsSendCallbackTest());
54    OHOS::sptr<SmsDeliveryCallbackTest> deliveryCallBackPtr(new SmsDeliveryCallbackTest());
55    uint16_t port = 100;
56    uint8_t data[] = "hello world";
57    bool isMmsApp = false;
58    smsService->SendMessage(slotIdTesta, StringUtils::ToUtf16(dest), StringUtils::ToUtf16(sca), port, data,
59        (sizeof(data) / sizeof(data[0]) - 1), sendCallBackPtr, deliveryCallBackPtr, false);
60    smsService->SendMessage(slotIdTesta, StringUtils::ToUtf16(dest), StringUtils::ToUtf16(sca), port, data,
61        (sizeof(data) / sizeof(data[0]) - 1), sendCallBackPtr, deliveryCallBackPtr, true);
62    std::cout << "TestGsmSendShortData" << std::endl;
63}
64
65void GsmSmsSenderTest::TestGsmSendLongData(const sptr<ISmsServiceInterface> &smsService) const
66{
67    AccessMmsToken token;
68    if (smsService == nullptr) {
69        std::cout << "smsService is nullptr." << std::endl;
70        return;
71    }
72    int32_t slotIdTestb;
73    std::string dest;
74    std::cout << "Please enter the card id" << std::endl;
75    std::cin >> dest;
76    slotIdTestb = atoi(dest.c_str());
77    dest.clear();
78    std::cout << "Please enter the receiver's telephone number" << std::endl;
79    std::cin >> dest;
80    std::string sca("");
81    OHOS::sptr<SmsSendCallbackTest> sendCallBackPtr(new SmsSendCallbackTest());
82    OHOS::sptr<SmsDeliveryCallbackTest> deliveryCallBackPtr(new SmsDeliveryCallbackTest());
83    uint8_t data[] =
84        R"(This is the test data!This is the test data!This is the test data!
85        This is the test data!This is the test data!This is the test data!
86        This is the test data!This is the test data!This is the test data!
87        This is the test data!This is the test data!This is the test data!
88        This is the test data!This is the test data!This is the test data!
89        This is the test data!This is the test data!This is the test data!)";
90    uint16_t port = 100;
91
92    smsService->SendMessage(slotIdTestb, StringUtils::ToUtf16(dest), StringUtils::ToUtf16(sca), port, data,
93        sizeof(data) / sizeof(data[0]), sendCallBackPtr, deliveryCallBackPtr, true);
94    smsService->SendMessage(slotIdTestb, StringUtils::ToUtf16(dest), StringUtils::ToUtf16(sca), port, data,
95        sizeof(data) / sizeof(data[0]), sendCallBackPtr, deliveryCallBackPtr, false);
96    std::cout << "TestGsmSendLongData" << std::endl;
97}
98
99void GsmSmsSenderTest::TestSendShortText(const sptr<ISmsServiceInterface> &smsService) const
100{
101    AccessMmsToken token;
102    if (smsService == nullptr) {
103        std::cout << "smsService is nullptr." << std::endl;
104        return;
105    }
106    std::string dest;
107    std::cout << "Please enter the card id" << std::endl;
108    int32_t slotIdTestc;
109    std::cin >> dest;
110    slotIdTestc = atoi(dest.c_str());
111    dest.clear();
112    std::string text;
113    std::cin.ignore();
114    std::cout << "Please enter the receiver's telephone number" << std::endl;
115    getline(std::cin, dest);
116    std::cout << "Please enter text" << std::endl;
117    getline(std::cin, text);
118    std::string sca("");
119    OHOS::sptr<SmsSendCallbackTest> sendCallBackPtr(new SmsSendCallbackTest());
120    OHOS::sptr<SmsDeliveryCallbackTest> deliveryCallBackPtr(new SmsDeliveryCallbackTest());
121    smsService->SendMessage(slotIdTestc, StringUtils::ToUtf16(dest), StringUtils::ToUtf16(sca),
122        StringUtils::ToUtf16(text), sendCallBackPtr, deliveryCallBackPtr, true);
123    smsService->SendMessage(slotIdTestc, StringUtils::ToUtf16(dest), StringUtils::ToUtf16(sca),
124        StringUtils::ToUtf16(text), sendCallBackPtr, deliveryCallBackPtr, false);
125    std::cout << "TestGsmSendShortText" << std::endl;
126}
127
128void GsmSmsSenderTest::TestSendMms(const sptr<ISmsServiceInterface> &smsService) const
129{
130    AccessMmsToken token;
131    if (smsService == nullptr) {
132        std::cout << "smsService is nullptr." << std::endl;
133        return;
134    }
135    std::string dest;
136    std::cout << "Please enter the card id" << std::endl;
137    int32_t slotId;
138    std::cin >> dest;
139    slotId = atoi(dest.c_str());
140    dest.clear();
141    std::u16string mmsc(StringUtils::ToUtf16(CU_MMSC));
142    std::u16string data(StringUtils::ToUtf16(SEND_MMS_FILE_URL));
143    std::u16string ua(u"");
144    std::u16string uaprof(u"");
145    int64_t time = 0;
146    int32_t result = smsService->SendMms(slotId, mmsc, data, ua, uaprof, time);
147    if (result == 0) {
148        std::cout << "send mms success" << std::endl;
149    } else {
150        std::cout << "send mms fail" << std::endl;
151    }
152    result = smsService->SendMms(slotId, mmsc, data, ua, uaprof, time, true);
153    if (result == 0) {
154        std::cout << "send mms success" << std::endl;
155    } else {
156        std::cout << "send mms fail" << std::endl;
157    }
158}
159
160void GsmSmsSenderTest::TestSendLongText(const sptr<ISmsServiceInterface> &smsService) const
161{
162    AccessMmsToken token;
163    if (smsService == nullptr) {
164        std::cout << "smsService is nullptr." << std::endl;
165        return;
166    }
167    int32_t slotIdTestd;
168    std::string dest;
169    std::cout << "Please enter the card id" << std::endl;
170    std::cin >> dest;
171    slotIdTestd = atoi(dest.c_str());
172    dest.clear();
173    std::cout << "Please enter the receiver's telephone number" << std::endl;
174    std::cin >> dest;
175    std::string sca("");
176    std::string text(
177        R"(This is the test data!This is the test data!This is the test data!
178        This is the test data!This is the test data!This is the test data!
179        This is the test data!This is the test data!This is the test data!
180        This is the test data!This is the test data!This is the test data!
181        This is the test data!This is the test data!This is the test data!
182        This is the test data!This is the test data!This is the test data!)");
183    OHOS::sptr<SmsSendCallbackTest> sendCallBackPtr(new SmsSendCallbackTest());
184    OHOS::sptr<SmsDeliveryCallbackTest> deliveryCallBackPtr(new SmsDeliveryCallbackTest());
185    smsService->SendMessage(slotIdTestd, StringUtils::ToUtf16(dest), StringUtils::ToUtf16(sca),
186        StringUtils::ToUtf16(text), sendCallBackPtr, deliveryCallBackPtr, true);
187    smsService->SendMessage(slotIdTestd, StringUtils::ToUtf16(dest), StringUtils::ToUtf16(sca),
188        StringUtils::ToUtf16(text), sendCallBackPtr, deliveryCallBackPtr, false);
189    std::cout << "TestGsmSendLongText" << std::endl;
190}
191
192void GsmSmsSenderTest::TestSetSmscAddr(const sptr<ISmsServiceInterface> &smsService) const
193{
194    AccessMmsToken token;
195    bool result = false;
196    if (smsService == nullptr) {
197        std::cout << "smsService is nullptr." << std::endl;
198        return;
199    }
200    std::string dest;
201    std::cout << "Please enter the card id" << std::endl;
202    int32_t slotIdTeste;
203    std::cin >> dest;
204    slotIdTeste = atoi(dest.c_str());
205    dest.clear();
206    std::string sca;
207    std::cout << "Please enter smsc" << std::endl;
208    std::cin >> sca;
209    result = smsService->SetSmscAddr(slotIdTeste, StringUtils::ToUtf16(sca));
210    if (result) {
211        std::cout << "TestSetSmscAddr OK!" << std::endl;
212    } else {
213        std::cout << "TestSetSmscAddr failed!" << std::endl;
214    }
215}
216
217void GsmSmsSenderTest::TestGetSmscAddr(const sptr<ISmsServiceInterface> &smsService) const
218{
219    AccessMmsToken token;
220    std::u16string result;
221    if (smsService == nullptr) {
222        std::cout << "smsService is nullptr." << std::endl;
223        return;
224    }
225    std::string dest;
226    std::cout << "Please enter the card id" << std::endl;
227    int32_t slotIdTestf;
228    std::cin >> dest;
229    slotIdTestf = atoi(dest.c_str());
230    dest.clear();
231    smsService->GetSmscAddr(slotIdTestf, result);
232    std::cout << "TestGetSmscAddr:" << StringUtils::ToUtf8(result) << std::endl;
233}
234
235void GsmSmsSenderTest::TestAddSimMessage(const sptr<ISmsServiceInterface> &smsService) const
236{
237    AccessMmsToken token;
238    bool result = false;
239    if (smsService == nullptr) {
240        std::cout << "smsService is nullptr." << std::endl;
241        return;
242    }
243    std::string dest;
244    std::cout << "Please enter the card id" << std::endl;
245    int32_t slotIdTestg;
246    std::cin >> dest;
247    slotIdTestg = atoi(dest.c_str());
248    std::string smsc;
249    std::cout << "Please enter smsc" << std::endl;
250    std::cin >> smsc;
251    std::string pdu;
252    std::cout << "Please enter pdu" << std::endl;
253    std::cin >> pdu;
254    std::string input;
255    std::cout << "Please enter status" << std::endl;
256    std::cin >> input;
257    uint32_t status = std::atoi(input.c_str());
258    result = smsService->AddSimMessage(slotIdTestg, StringUtils::ToUtf16(smsc), StringUtils::ToUtf16(pdu),
259        static_cast<ISmsServiceInterface::SimMessageStatus>(status));
260    if (result == 0) {
261        std::cout << "TestAddSimMessage OK!" << std::endl;
262    } else {
263        std::cout << "TestAddSimMessage failed!" << std::endl;
264    }
265}
266
267void GsmSmsSenderTest::TestDelSimMessage(const sptr<ISmsServiceInterface> &smsService) const
268{
269    AccessMmsToken token;
270    if (smsService == nullptr) {
271        std::cout << "smsService is nullptr." << std::endl;
272        return;
273    }
274    bool result = false;
275    int32_t slotIdTesth;
276    std::string dest;
277    std::cout << "Please enter the card id" << std::endl;
278    std::cin >> dest;
279    slotIdTesth = atoi(dest.c_str());
280    dest.clear();
281    std::string input;
282    std::cout << "Please enter msgIndex" << std::endl;
283    std::cin >> input;
284    uint32_t msgIndex = std::atoi(input.c_str());
285    result = smsService->DelSimMessage(slotIdTesth, msgIndex);
286    if (result == 0) {
287        std::cout << "TestDelSimMessage OK!" << std::endl;
288    } else {
289        std::cout << "TestDelSimMessage failed!" << std::endl;
290    }
291}
292
293void GsmSmsSenderTest::TestUpdateSimMessage(const sptr<ISmsServiceInterface> &smsService) const
294{
295    AccessMmsToken token;
296    if (smsService == nullptr) {
297        std::cout << "smsService is nullptr." << std::endl;
298        return;
299    }
300    bool result = false;
301    std::string dest;
302    std::cout << "Please enter the card id" << std::endl;
303    int32_t slotIdTesti;
304    std::cin >> dest;
305    slotIdTesti = atoi(dest.c_str());
306    dest.clear();
307    std::string input;
308    std::cout << "Please enter msgIndex" << std::endl;
309    std::cin >> input;
310    uint32_t msgIndex = std::atoi(input.c_str());
311    std::string pdu;
312    std::cout << "Please enter pdu" << std::endl;
313    std::cin >> pdu;
314    std::string smsc;
315    std::cout << "Please enter smsc" << std::endl;
316    std::cin >> smsc;
317    int32_t status;
318    std::cout << "Please enter status" << std::endl;
319    std::cin >> status;
320    std::u16string pduData = StringUtils::ToUtf16(pdu);
321    std::u16string smscData = StringUtils::ToUtf16(smsc);
322    result = smsService->UpdateSimMessage(
323        slotIdTesti, msgIndex, static_cast<ISmsServiceInterface::SimMessageStatus>(status), pduData, smscData);
324    if (result) {
325        std::cout << "TestUpdateSimMessage OK!" << std::endl;
326    } else {
327        std::cout << "TestUpdateSimMessage failed!" << std::endl;
328    }
329}
330
331void GsmSmsSenderTest::TestGetAllSimMessages(const sptr<ISmsServiceInterface> &smsService) const
332{
333    AccessMmsToken token;
334    std::vector<ShortMessage> result;
335    if (smsService == nullptr) {
336        std::cout << "smsService is nullptr." << std::endl;
337        return;
338    }
339    std::string dest;
340    std::cout << "Please enter the card id" << std::endl;
341    int32_t slotIdTestj;
342    std::cin >> dest;
343    slotIdTestj = atoi(dest.c_str());
344    dest.clear();
345    smsService->GetAllSimMessages(slotIdTestj, result);
346    std::cout << "TestGetAllSimMessages Begin:" << std::endl;
347    for (auto &item : result) {
348        std::cout << "[" << item.GetIndexOnSim() << "] " << StringUtils::StringToHex(item.GetPdu()) << std::endl;
349        std::cout << "status:" << item.GetIccMessageStatus()
350                  << " message:" << StringUtils::ToUtf8(item.GetVisibleMessageBody()) << std::endl;
351    }
352    std::cout << "TestGetAllSimMessages End!" << std::endl;
353}
354
355void GsmSmsSenderTest::TestEnableCBRangeConfig(const sptr<ISmsServiceInterface> &smsService) const
356{
357    AccessMmsToken token;
358    if (smsService == nullptr) {
359        std::cout << "smsService is nullptr." << std::endl;
360        return;
361    }
362    std::string dest;
363    std::cout << "Please enter the card id" << std::endl;
364    int32_t slotIdTestk;
365    std::cin >> dest;
366    bool enable = true;
367    slotIdTestk = atoi(dest.c_str());
368    dest.clear();
369    uint8_t ranType = 1;
370    uint32_t startMessageId = 0;
371    uint32_t endMessageId = 0;
372    std::cout << "Please enter startMessageId" << std::endl;
373    std::string input;
374    std::cin >> input;
375    startMessageId = std::atoi(input.c_str());
376    std::cout << "Please enter endMessageId" << std::endl;
377    std::cin >> input;
378    endMessageId = std::atoi(input.c_str());
379    int32_t result = smsService->SetCBConfig(slotIdTestk, enable, startMessageId, endMessageId, ranType);
380    std::cout << "TestEnableCBRangeConfig:" << result << std::endl;
381}
382
383void GsmSmsSenderTest::TestDisableCBRangeConfig(const sptr<ISmsServiceInterface> &smsService) const
384{
385    AccessMmsToken token;
386    if (smsService == nullptr) {
387        std::cout << "smsService is nullptr." << std::endl;
388        return;
389    }
390    std::string dest;
391    std::cout << "Please enter the card id" << std::endl;
392    std::cin >> dest;
393    int32_t slotIdTestl = atoi(dest.c_str());
394    bool enable = false;
395    uint32_t startMessageId = 0;
396    uint32_t endMessageId = 0;
397    uint8_t ranType = 1;
398    std::string input;
399    std::cout << "Please enter startMessageId" << std::endl;
400    std::cin >> input;
401    startMessageId = std::atoi(input.c_str());
402    std::cout << "Please enter endMessageId" << std::endl;
403    std::cin >> input;
404    endMessageId = std::atoi(input.c_str());
405    int32_t result = smsService->SetCBConfig(slotIdTestl, enable, startMessageId, endMessageId, ranType);
406    std::cout << "TestDisableCBRangeConfig:" << result << std::endl;
407}
408
409void GsmSmsSenderTest::TestEnableCBConfig(const sptr<ISmsServiceInterface> &smsService) const
410{
411    AccessMmsToken token;
412    if (smsService == nullptr) {
413        std::cout << "smsService is nullptr." << std::endl;
414        return;
415    }
416    std::string dest;
417    std::cout << "Please enter the card id" << std::endl;
418    int32_t slotIdTestm;
419    std::cin >> dest;
420    slotIdTestm = atoi(dest.c_str());
421    dest.clear();
422    bool enable = true;
423    uint32_t identifier = 0;
424    uint8_t ranType = 1;
425    std::string input;
426    std::cout << "Please enter identifier" << std::endl;
427    std::cin >> input;
428    identifier = std::atoi(input.c_str());
429    int32_t result = smsService->SetCBConfig(slotIdTestm, enable, identifier, identifier, ranType);
430    std::cout << "TestEnableCBConfig:" << result << std::endl;
431}
432
433void GsmSmsSenderTest::TestDisableCBConfig(const sptr<ISmsServiceInterface> &smsService) const
434{
435    AccessMmsToken token;
436    if (smsService == nullptr) {
437        std::cout << "smsService is nullptr." << std::endl;
438        return;
439    }
440    std::string dest;
441    std::cout << "Please enter the card id" << std::endl;
442    int32_t slotIdTestn;
443    std::cin >> dest;
444    slotIdTestn = atoi(dest.c_str());
445    dest.clear();
446    bool enable = false;
447    uint32_t identifier = 0;
448    uint8_t ranType = 1;
449    std::string input;
450    std::cout << "Please enter identifier" << std::endl;
451    std::cin >> input;
452    identifier = std::atoi(input.c_str());
453    int32_t result = smsService->SetCBConfig(slotIdTestn, enable, identifier, identifier, ranType);
454    std::cout << "TestDisableCBConfig:" << result << std::endl;
455}
456
457void GsmSmsSenderTest::TestSetDefaultSmsSlotId(const sptr<ISmsServiceInterface> &smsService) const
458{
459    AccessMmsToken token;
460    if (smsService == nullptr) {
461        std::cout << "smsService is nullptr." << std::endl;
462        return;
463    }
464    int32_t slotId;
465    std::string input;
466    std::cout << "Please enter Slot Id" << std::endl;
467    std::cin >> input;
468    slotId = std::atoi(input.c_str());
469    int32_t result = smsService->SetDefaultSmsSlotId(slotId);
470    std::cout << "TestSetDefaultSmsSlotId:" << result << std::endl;
471}
472
473void GsmSmsSenderTest::TestGetDefaultSmsSlotId(const sptr<ISmsServiceInterface> &smsService) const
474{
475    int32_t result;
476    if (smsService == nullptr) {
477        std::cout << "smsService is nullptr." << std::endl;
478        return;
479    }
480    result = smsService->GetDefaultSmsSlotId();
481    std::cout << "TestGetDefaultSmsSlotId:" << result << std::endl;
482}
483
484void GsmSmsSenderTest::TestSplitMessage(const sptr<ISmsServiceInterface> &smsService) const
485{
486    AccessMmsToken token;
487    std::vector<std::u16string> result;
488    if (smsService == nullptr) {
489        std::cout << "smsService is nullptr." << std::endl;
490        return;
491    }
492    std::string input;
493    std::cout << "Please enter message" << std::endl;
494    std::getline(std::cin, input);
495    smsService->SplitMessage(StringUtils::ToUtf16(input), result);
496    std::cout << "TestSplitMessage size:" << result.size() << std::endl;
497    for (auto &item : result) {
498        std::cout << StringUtils::ToUtf8(item) << std::endl;
499    }
500}
501
502void GsmSmsSenderTest::TestGetSmsSegmentsInfo(const sptr<ISmsServiceInterface> &smsService) const
503{
504    if (smsService == nullptr) {
505        std::cout << "TestGetSmsSegmentsInfo smsService is nullptr." << std::endl;
506        return;
507    }
508    int32_t slotId;
509    std::string input;
510    std::cout << "TestGetSmsSegmentsInfo Please enter Slot Id" << std::endl;
511    std::getline(std::cin, input);
512    slotId = std::atoi(input.c_str());
513    input.clear();
514    std::cout << "Please enter message" << std::endl;
515    std::getline(std::cin, input);
516    ISmsServiceInterface::SmsSegmentsInfo result;
517    if (smsService->GetSmsSegmentsInfo(slotId, StringUtils::ToUtf16(input), false, result) != TELEPHONY_ERR_SUCCESS) {
518        std::cout << "Get Sms SegmentsInfo Fail." << std::endl;
519        return;
520    }
521
522    int32_t codeScheme = static_cast<int32_t>(result.msgCodeScheme);
523    std::cout << "msgSegCount:" << result.msgSegCount << " msgEncodingCount:" << result.msgEncodingCount << std::endl;
524    std::cout << "msgRemainCount:" << result.msgRemainCount << " msgCodeScheme:" << codeScheme << std::endl;
525}
526
527void GsmSmsSenderTest::TestIsImsSmsSupported(const sptr<ISmsServiceInterface> &smsService) const
528{
529    if (smsService == nullptr) {
530        std::cout << "TestIsImsSmsSupported smsService is nullptr." << std::endl;
531        return;
532    }
533    int32_t slotId;
534    std::string input;
535    std::cout << "TestIsImsSmsSupported Please enter Slot Id" << std::endl;
536    std::getline(std::cin, input);
537    slotId = std::atoi(input.c_str());
538    bool result = false;
539    smsService->IsImsSmsSupported(slotId, result);
540    std::string res = result ? "true" : "false";
541    std::cout << "IsImsSmsSupported:" << res << std::endl;
542}
543
544void GsmSmsSenderTest::TestSetImsSmsConfig(const sptr<ISmsServiceInterface> &smsService) const
545{
546    AccessMmsToken token;
547    if (smsService == nullptr) {
548        std::cout << "TestSetImsSmsConfig smsService is nullptr." << std::endl;
549        return;
550    }
551    int32_t slotId;
552    std::string input;
553    std::cout << "TestSetImsSmsConfig Please enter Slot Id" << std::endl;
554    std::getline(std::cin, input);
555    slotId = std::atoi(input.c_str());
556    int32_t enable;
557    std::cout << "Please enter enable" << std::endl;
558    std::getline(std::cin, input);
559    enable = std::atoi(input.c_str());
560    std::string res = smsService->SetImsSmsConfig(slotId, enable) ? "true" : "false";
561    std::cout << "SetImsSmsConfig:" << res << std::endl;
562}
563
564void GsmSmsSenderTest::TestGetImsShortMessageFormat(const sptr<ISmsServiceInterface> &smsService) const
565{
566    if (smsService == nullptr) {
567        std::cout << "smsService is nullptr." << std::endl;
568        return;
569    }
570    std::u16string format;
571    smsService->GetImsShortMessageFormat(format);
572    std::cout << "GetImsShortMessageFormat:" << StringUtils::ToUtf8(format) << std::endl;
573}
574
575void GsmSmsSenderTest::TestAddBlockPhone() const
576{
577    std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataAHelper();
578    if (helper == nullptr) {
579        std::cout << "Creator helper nullptr error." << std::endl;
580        return;
581    }
582    std::string input;
583    std::cout << "Please enter block phone number" << std::endl;
584    std::getline(std::cin, input);
585
586    Uri uri("datashare:///com.ohos.contactsdataability/contacts/contact_blocklist");
587    DataShare::DataShareValuesBucket value;
588    value.Put("phone_number", input);
589    int ret = helper->Insert(uri, value);
590    helper->Release();
591    std::cout << "add block:" << input << ((ret >= 0) ? " success" : " error") << std::endl;
592}
593
594void GsmSmsSenderTest::TestRemoveBlockPhone() const
595{
596    std::shared_ptr<DataShare::DataShareHelper> helper = CreateDataAHelper();
597    if (helper == nullptr) {
598        std::cout << "Creator helper nullptr error." << std::endl;
599        return;
600    }
601    std::string input;
602    std::cout << "Please enter Remove phone number" << std::endl;
603    std::getline(std::cin, input);
604    Uri uri("datashare:///com.ohos.contactsdataability/contacts/contact_blocklist");
605    DataShare::DataSharePredicates predicates;
606    predicates.EqualTo("phone_number", input);
607    int ret = helper->Delete(uri, predicates);
608    helper->Release();
609    std::cout << "remove block:" << input << ((ret >= 0) ? " success" : " error") << std::endl;
610}
611
612void GsmSmsSenderTest::TestHasSmsCapability(const sptr<ISmsServiceInterface> &smsService) const
613{
614    if (smsService == nullptr) {
615        std::cout << "GsmSmsSenderTest smsService is nullptr error." << std::endl;
616        return;
617    }
618    std::string res = smsService->HasSmsCapability() ? "true" : "false";
619    std::cout << "HasSmsCapability:" << res << std::endl;
620}
621
622std::shared_ptr<DataShare::DataShareHelper> GsmSmsSenderTest::CreateDataAHelper() const
623{
624    auto saManager = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
625    if (saManager == nullptr) {
626        std::cout << "Get system ability mgr failed." << std::endl;
627        return nullptr;
628    }
629    auto remoteObj = saManager->GetSystemAbility(TELEPHONY_SMS_MMS_SYS_ABILITY_ID);
630    if (remoteObj == nullptr) {
631        std::cout << "GetSystemAbility Service Failed." << std::endl;
632        return nullptr;
633    }
634    const std::string uriContact("datashare:///com.ohos.contactsdataability");
635    return DataShare::DataShareHelper::Creator(remoteObj, uriContact);
636}
637} // namespace Telephony
638} // namespace OHOS
639