1 /*
2 * Copyright (C) 2021 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include <aidl/android/hardware/radio/config/IRadioConfig.h>
18 #include <android/binder_manager.h>
19
20 #include "radio_messaging_utils.h"
21
22 #define ASSERT_OK(ret) ASSERT_TRUE(ret.isOk())
23
SetUp()24 void RadioMessagingTest::SetUp() {
25 RadioServiceTest::SetUp();
26 std::string serviceName = GetParam();
27
28 if (!isServiceValidForDeviceConfiguration(serviceName)) {
29 ALOGI("Skipped the test due to device configuration.");
30 GTEST_SKIP();
31 }
32
33 radio_messaging = IRadioMessaging::fromBinder(
34 ndk::SpAIBinder(AServiceManager_waitForService(GetParam().c_str())));
35 ASSERT_NE(nullptr, radio_messaging.get());
36
37 radioRsp_messaging = ndk::SharedRefBase::make<RadioMessagingResponse>(*this);
38 ASSERT_NE(nullptr, radioRsp_messaging.get());
39
40 radioInd_messaging = ndk::SharedRefBase::make<RadioMessagingIndication>(*this);
41 ASSERT_NE(nullptr, radioInd_messaging.get());
42
43 radio_messaging->setResponseFunctions(radioRsp_messaging, radioInd_messaging);
44
45 // Assert IRadioSim exists and SIM is present before testing
46 radio_sim = sim::IRadioSim::fromBinder(ndk::SpAIBinder(
47 AServiceManager_waitForService("android.hardware.radio.sim.IRadioSim/slot1")));
48 ASSERT_NE(nullptr, radio_sim.get());
49 updateSimCardStatus();
50 EXPECT_EQ(CardStatus::STATE_PRESENT, cardStatus.cardState);
51
52 // Assert IRadioConfig exists before testing
53 radio_config = config::IRadioConfig::fromBinder(ndk::SpAIBinder(
54 AServiceManager_waitForService("android.hardware.radio.config.IRadioConfig/default")));
55 ASSERT_NE(nullptr, radio_config.get());
56 }
57
58 /*
59 * Test IRadioMessaging.sendSms() for the response returned.
60 */
TEST_P(RadioMessagingTest,sendSms)61 TEST_P(RadioMessagingTest, sendSms) {
62 if (telephony_flags::enforce_telephony_feature_mapping()) {
63 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
64 GTEST_SKIP() << "Skipping sendSms "
65 "due to undefined FEATURE_TELEPHONY_MESSAGING";
66 }
67 }
68
69 serial = GetRandomSerialNumber();
70 GsmSmsMessage msg;
71 msg.smscPdu = "";
72 msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
73
74 radio_messaging->sendSms(serial, msg);
75
76 EXPECT_EQ(std::cv_status::no_timeout, wait());
77 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
78 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
79
80 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
81 ASSERT_TRUE(CheckAnyOfErrors(
82 radioRsp_messaging->rspInfo.error,
83 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
84 CHECK_GENERAL_ERROR));
85 EXPECT_EQ(0, radioRsp_messaging->sendSmsResult.errorCode);
86 }
87 }
88
89 /*
90 * Test IRadioMessaging.sendSmsExpectMore() for the response returned.
91 */
TEST_P(RadioMessagingTest,sendSmsExpectMore)92 TEST_P(RadioMessagingTest, sendSmsExpectMore) {
93 if (telephony_flags::enforce_telephony_feature_mapping()) {
94 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
95 GTEST_SKIP() << "Skipping sendSmsExpectMore "
96 "due to undefined FEATURE_TELEPHONY_MESSAGING";
97 }
98 }
99
100 serial = GetRandomSerialNumber();
101 GsmSmsMessage msg;
102 msg.smscPdu = "";
103 msg.pdu = "01000b916105770203f3000006d4f29c3e9b01";
104
105 radio_messaging->sendSmsExpectMore(serial, msg);
106
107 EXPECT_EQ(std::cv_status::no_timeout, wait());
108 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
109 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
110
111 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
112 ASSERT_TRUE(CheckAnyOfErrors(
113 radioRsp_messaging->rspInfo.error,
114 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
115 CHECK_GENERAL_ERROR));
116 }
117 }
118
119 /*
120 * Test IRadioMessaging.sendCdmaSms() for the response returned.
121 */
TEST_P(RadioMessagingTest,sendCdmaSms)122 TEST_P(RadioMessagingTest, sendCdmaSms) {
123 if (telephony_flags::enforce_telephony_feature_mapping()) {
124 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
125 GTEST_SKIP() << "Skipping sendCdmaSms "
126 "due to undefined FEATURE_TELEPHONY_CDMA";
127 }
128 }
129
130 serial = GetRandomSerialNumber();
131
132 // Create a CdmaSmsAddress
133 CdmaSmsAddress cdmaSmsAddress;
134 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
135 cdmaSmsAddress.isNumberModeDataNetwork = false;
136 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
137 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
138 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
139
140 // Create a CdmaSmsSubAddress
141 CdmaSmsSubaddress cdmaSmsSubaddress;
142 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
143 cdmaSmsSubaddress.odd = false;
144 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
145
146 // Create a CdmaSmsMessage
147 CdmaSmsMessage cdmaSmsMessage;
148 cdmaSmsMessage.teleserviceId = 4098;
149 cdmaSmsMessage.isServicePresent = false;
150 cdmaSmsMessage.serviceCategory = 0;
151 cdmaSmsMessage.address = cdmaSmsAddress;
152 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
153 cdmaSmsMessage.bearerData =
154 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
155
156 radio_messaging->sendCdmaSms(serial, cdmaSmsMessage);
157
158 EXPECT_EQ(std::cv_status::no_timeout, wait());
159 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
160 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
161
162 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
163 ASSERT_TRUE(CheckAnyOfErrors(
164 radioRsp_messaging->rspInfo.error,
165 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
166 CHECK_GENERAL_ERROR));
167 }
168 }
169
170 /*
171 * Test IRadioMessaging.sendCdmaSmsExpectMore() for the response returned.
172 */
TEST_P(RadioMessagingTest,sendCdmaSmsExpectMore)173 TEST_P(RadioMessagingTest, sendCdmaSmsExpectMore) {
174 if (telephony_flags::enforce_telephony_feature_mapping()) {
175 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
176 GTEST_SKIP() << "Skipping sendCdmaSmsExpectMore "
177 "due to undefined FEATURE_TELEPHONY_CDMA";
178 }
179 }
180
181 serial = GetRandomSerialNumber();
182
183 // Create a CdmaSmsAddress
184 CdmaSmsAddress cdmaSmsAddress;
185 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
186 cdmaSmsAddress.isNumberModeDataNetwork = false;
187 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
188 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
189 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
190
191 // Create a CdmaSmsSubAddress
192 CdmaSmsSubaddress cdmaSmsSubaddress;
193 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
194 cdmaSmsSubaddress.odd = false;
195 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
196
197 // Create a CdmaSmsMessage
198 CdmaSmsMessage cdmaSmsMessage;
199 cdmaSmsMessage.teleserviceId = 4098;
200 cdmaSmsMessage.isServicePresent = false;
201 cdmaSmsMessage.serviceCategory = 0;
202 cdmaSmsMessage.address = cdmaSmsAddress;
203 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
204 cdmaSmsMessage.bearerData =
205 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
206
207 radio_messaging->sendCdmaSmsExpectMore(serial, cdmaSmsMessage);
208
209 EXPECT_EQ(std::cv_status::no_timeout, wait());
210 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
211 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
212
213 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
214 ASSERT_TRUE(CheckAnyOfErrors(
215 radioRsp_messaging->rspInfo.error,
216 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE, RadioError::SIM_ABSENT},
217 CHECK_GENERAL_ERROR));
218 }
219 }
220
221 /*
222 * Test IRadioMessaging.setGsmBroadcastConfig() for the response returned.
223 */
TEST_P(RadioMessagingTest,setGsmBroadcastConfig)224 TEST_P(RadioMessagingTest, setGsmBroadcastConfig) {
225 if (telephony_flags::enforce_telephony_feature_mapping()) {
226 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
227 GTEST_SKIP() << "Skipping setGsmBroadcastConfig "
228 "due to undefined FEATURE_TELEPHONY_MESSAGING";
229 }
230 }
231
232 serial = GetRandomSerialNumber();
233
234 // Create GsmBroadcastSmsConfigInfo #1
235 GsmBroadcastSmsConfigInfo gbSmsConfig1;
236 gbSmsConfig1.fromServiceId = 4352;
237 gbSmsConfig1.toServiceId = 4354;
238 gbSmsConfig1.fromCodeScheme = 0;
239 gbSmsConfig1.toCodeScheme = 255;
240 gbSmsConfig1.selected = true;
241
242 // Create GsmBroadcastSmsConfigInfo #2
243 GsmBroadcastSmsConfigInfo gbSmsConfig2;
244 gbSmsConfig2.fromServiceId = 4356;
245 gbSmsConfig2.toServiceId = 4356;
246 gbSmsConfig2.fromCodeScheme = 0;
247 gbSmsConfig2.toCodeScheme = 255;
248 gbSmsConfig2.selected = true;
249
250 // Create GsmBroadcastSmsConfigInfo #3
251 GsmBroadcastSmsConfigInfo gbSmsConfig3;
252 gbSmsConfig3.fromServiceId = 4370;
253 gbSmsConfig3.toServiceId = 4379;
254 gbSmsConfig3.fromCodeScheme = 0;
255 gbSmsConfig3.toCodeScheme = 255;
256 gbSmsConfig3.selected = true;
257
258 // Create GsmBroadcastSmsConfigInfo #4
259 GsmBroadcastSmsConfigInfo gbSmsConfig4;
260 gbSmsConfig4.fromServiceId = 4383;
261 gbSmsConfig4.toServiceId = 4391;
262 gbSmsConfig4.fromCodeScheme = 0;
263 gbSmsConfig4.toCodeScheme = 255;
264 gbSmsConfig4.selected = true;
265
266 // Create GsmBroadcastSmsConfigInfo #5
267 GsmBroadcastSmsConfigInfo gbSmsConfig5;
268 gbSmsConfig5.fromServiceId = 4392;
269 gbSmsConfig5.toServiceId = 4392;
270 gbSmsConfig5.fromCodeScheme = 0;
271 gbSmsConfig5.toCodeScheme = 255;
272 gbSmsConfig5.selected = true;
273
274 std::vector<GsmBroadcastSmsConfigInfo> gsmBroadcastSmsConfigsInfoList = {
275 gbSmsConfig1, gbSmsConfig2, gbSmsConfig3, gbSmsConfig4, gbSmsConfig5};
276
277 radio_messaging->setGsmBroadcastConfig(serial, gsmBroadcastSmsConfigsInfoList);
278
279 EXPECT_EQ(std::cv_status::no_timeout, wait());
280 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
281 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
282
283 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
284 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
285 {RadioError::NONE, RadioError::INVALID_ARGUMENTS,
286 RadioError::INVALID_MODEM_STATE, RadioError::INVALID_STATE},
287 CHECK_GENERAL_ERROR));
288 }
289 }
290
291 /*
292 * Test IRadioMessaging.getGsmBroadcastConfig() for the response returned.
293 */
TEST_P(RadioMessagingTest,getGsmBroadcastConfig)294 TEST_P(RadioMessagingTest, getGsmBroadcastConfig) {
295 if (telephony_flags::enforce_telephony_feature_mapping()) {
296 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
297 GTEST_SKIP() << "Skipping getGsmBroadcastConfig "
298 "due to undefined FEATURE_TELEPHONY_MESSAGING";
299 }
300 }
301
302 serial = GetRandomSerialNumber();
303
304 radio_messaging->getGsmBroadcastConfig(serial);
305
306 EXPECT_EQ(std::cv_status::no_timeout, wait());
307 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
308 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
309
310 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
311 ASSERT_TRUE(CheckAnyOfErrors(
312 radioRsp_messaging->rspInfo.error,
313 {RadioError::NONE, RadioError::INVALID_MODEM_STATE, RadioError::INVALID_STATE},
314 CHECK_GENERAL_ERROR));
315 }
316 }
317
318 /*
319 * Test IRadioMessaging.setCdmaBroadcastConfig() for the response returned.
320 */
TEST_P(RadioMessagingTest,setCdmaBroadcastConfig)321 TEST_P(RadioMessagingTest, setCdmaBroadcastConfig) {
322 if (telephony_flags::enforce_telephony_feature_mapping()) {
323 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
324 GTEST_SKIP() << "Skipping setCdmaBroadcastConfig "
325 "due to undefined FEATURE_TELEPHONY_CDMA";
326 }
327 }
328
329 serial = GetRandomSerialNumber();
330
331 CdmaBroadcastSmsConfigInfo cbSmsConfig;
332 cbSmsConfig.serviceCategory = 4096;
333 cbSmsConfig.language = 1;
334 cbSmsConfig.selected = true;
335
336 std::vector<CdmaBroadcastSmsConfigInfo> cdmaBroadcastSmsConfigInfoList = {cbSmsConfig};
337
338 radio_messaging->setCdmaBroadcastConfig(serial, cdmaBroadcastSmsConfigInfoList);
339
340 EXPECT_EQ(std::cv_status::no_timeout, wait());
341 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
342 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
343
344 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
345 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
346 {RadioError::NONE, RadioError::INVALID_MODEM_STATE},
347 CHECK_GENERAL_ERROR));
348 }
349 }
350
351 /*
352 * Test IRadioMessaging.getCdmaBroadcastConfig() for the response returned.
353 */
TEST_P(RadioMessagingTest,getCdmaBroadcastConfig)354 TEST_P(RadioMessagingTest, getCdmaBroadcastConfig) {
355 if (telephony_flags::enforce_telephony_feature_mapping()) {
356 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
357 GTEST_SKIP() << "Skipping getCdmaBroadcastConfig "
358 "due to undefined FEATURE_TELEPHONY_CDMA";
359 }
360 }
361
362 serial = GetRandomSerialNumber();
363
364 radio_messaging->getCdmaBroadcastConfig(serial);
365
366 EXPECT_EQ(std::cv_status::no_timeout, wait());
367 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
368 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
369
370 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
371 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error, {RadioError::NONE},
372 CHECK_GENERAL_ERROR));
373 }
374 }
375
376 /*
377 * Test IRadioMessaging.setCdmaBroadcastActivation() for the response returned.
378 */
TEST_P(RadioMessagingTest,setCdmaBroadcastActivation)379 TEST_P(RadioMessagingTest, setCdmaBroadcastActivation) {
380 if (telephony_flags::enforce_telephony_feature_mapping()) {
381 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
382 GTEST_SKIP() << "Skipping setCdmaBroadcastActivation "
383 "due to undefined FEATURE_TELEPHONY_CDMA";
384 }
385 }
386
387 serial = GetRandomSerialNumber();
388 bool activate = false;
389
390 radio_messaging->setCdmaBroadcastActivation(serial, activate);
391
392 EXPECT_EQ(std::cv_status::no_timeout, wait());
393 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
394 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
395
396 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
397 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
398 {RadioError::NONE, RadioError::INVALID_ARGUMENTS},
399 CHECK_GENERAL_ERROR));
400 }
401 }
402
403 /*
404 * Test IRadioMessaging.setGsmBroadcastActivation() for the response returned.
405 */
TEST_P(RadioMessagingTest,setGsmBroadcastActivation)406 TEST_P(RadioMessagingTest, setGsmBroadcastActivation) {
407 if (telephony_flags::enforce_telephony_feature_mapping()) {
408 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
409 GTEST_SKIP() << "Skipping setGsmBroadcastActivation "
410 "due to undefined FEATURE_TELEPHONY_MESSAGING";
411 }
412 }
413
414 serial = GetRandomSerialNumber();
415 bool activate = false;
416
417 radio_messaging->setGsmBroadcastActivation(serial, activate);
418
419 EXPECT_EQ(std::cv_status::no_timeout, wait());
420 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
421 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
422
423 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
424 ASSERT_TRUE(CheckAnyOfErrors(
425 radioRsp_messaging->rspInfo.error,
426 {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_MODEM_STATE,
427 RadioError::INVALID_STATE, RadioError::OPERATION_NOT_ALLOWED},
428 CHECK_GENERAL_ERROR));
429 }
430 }
431
432 /*
433 * Test IRadioMessaging.acknowledgeLastIncomingGsmSms() for the response returned.
434 */
TEST_P(RadioMessagingTest,acknowledgeLastIncomingGsmSms)435 TEST_P(RadioMessagingTest, acknowledgeLastIncomingGsmSms) {
436 if (telephony_flags::enforce_telephony_feature_mapping()) {
437 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
438 GTEST_SKIP() << "Skipping acknowledgeLastIncomingGsmSms "
439 "due to undefined FEATURE_TELEPHONY_MESSAGING";
440 }
441 }
442
443 serial = GetRandomSerialNumber();
444 bool success = true;
445
446 radio_messaging->acknowledgeLastIncomingGsmSms(
447 serial, success, SmsAcknowledgeFailCause::MEMORY_CAPACITY_EXCEEDED);
448
449 EXPECT_EQ(std::cv_status::no_timeout, wait());
450 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
451 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
452
453 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
454 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
455 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE},
456 CHECK_GENERAL_ERROR));
457 }
458 }
459
460 /*
461 * Test IRadioMessaging.acknowledgeIncomingGsmSmsWithPdu() for the response returned.
462 */
TEST_P(RadioMessagingTest,acknowledgeIncomingGsmSmsWithPdu)463 TEST_P(RadioMessagingTest, acknowledgeIncomingGsmSmsWithPdu) {
464 if (telephony_flags::enforce_telephony_feature_mapping()) {
465 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
466 GTEST_SKIP() << "Skipping acknowledgeIncomingGsmSmsWithPdu "
467 "due to undefined FEATURE_TELEPHONY_MESSAGING";
468 }
469 }
470
471 serial = GetRandomSerialNumber();
472 bool success = true;
473 std::string ackPdu = "";
474
475 radio_messaging->acknowledgeIncomingGsmSmsWithPdu(serial, success, ackPdu);
476
477 EXPECT_EQ(std::cv_status::no_timeout, wait());
478 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
479 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
480
481 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
482 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
483 {RadioError::INVALID_ARGUMENTS, RadioError::NO_SMS_TO_ACK},
484 CHECK_GENERAL_ERROR));
485 }
486 }
487
488 /*
489 * Test IRadioMessaging.acknowledgeLastIncomingCdmaSms() for the response returned.
490 */
TEST_P(RadioMessagingTest,acknowledgeLastIncomingCdmaSms)491 TEST_P(RadioMessagingTest, acknowledgeLastIncomingCdmaSms) {
492 if (telephony_flags::enforce_telephony_feature_mapping()) {
493 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
494 GTEST_SKIP() << "Skipping acknowledgeIncomingGsmSmsWithPdu "
495 "due to undefined FEATURE_TELEPHONY_CDMA";
496 }
497 }
498
499 serial = GetRandomSerialNumber();
500
501 // Create a CdmaSmsAck
502 CdmaSmsAck cdmaSmsAck;
503 cdmaSmsAck.errorClass = false;
504 cdmaSmsAck.smsCauseCode = 1;
505
506 radio_messaging->acknowledgeLastIncomingCdmaSms(serial, cdmaSmsAck);
507
508 EXPECT_EQ(std::cv_status::no_timeout, wait());
509 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
510 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
511
512 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
513 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
514 {RadioError::INVALID_ARGUMENTS, RadioError::NO_SMS_TO_ACK},
515 CHECK_GENERAL_ERROR));
516 }
517 }
518
519 /*
520 * Test IRadioMessaging.sendImsSms() for the response returned.
521 */
TEST_P(RadioMessagingTest,sendImsSms)522 TEST_P(RadioMessagingTest, sendImsSms) {
523 if (telephony_flags::enforce_telephony_feature_mapping()) {
524 if (!deviceSupportsFeature(FEATURE_TELEPHONY_IMS)) {
525 GTEST_SKIP() << "Skipping acknowledgeIncomingGsmSmsWithPdu "
526 "due to undefined FEATURE_TELEPHONY_IMS";
527 }
528 }
529
530 serial = GetRandomSerialNumber();
531
532 // Create a CdmaSmsAddress
533 CdmaSmsAddress cdmaSmsAddress;
534 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
535 cdmaSmsAddress.isNumberModeDataNetwork = false;
536 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
537 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
538 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
539
540 // Create a CdmaSmsSubAddress
541 CdmaSmsSubaddress cdmaSmsSubaddress;
542 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
543 cdmaSmsSubaddress.odd = false;
544 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
545
546 // Create a CdmaSmsMessage
547 CdmaSmsMessage cdmaSmsMessage;
548 cdmaSmsMessage.teleserviceId = 4098;
549 cdmaSmsMessage.isServicePresent = false;
550 cdmaSmsMessage.serviceCategory = 0;
551 cdmaSmsMessage.address = cdmaSmsAddress;
552 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
553 cdmaSmsMessage.bearerData =
554 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
555
556 // Create an ImsSmsMessage
557 ImsSmsMessage msg;
558 msg.tech = RadioTechnologyFamily::THREE_GPP2;
559 msg.retry = false;
560 msg.messageRef = 0;
561 msg.cdmaMessage = (std::vector<CdmaSmsMessage>){cdmaSmsMessage};
562 msg.gsmMessage = (std::vector<GsmSmsMessage>){};
563
564 radio_messaging->sendImsSms(serial, msg);
565
566 EXPECT_EQ(std::cv_status::no_timeout, wait());
567 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
568 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
569
570 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
571 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
572 {RadioError::INVALID_ARGUMENTS}, CHECK_GENERAL_ERROR));
573 }
574 }
575
576 /*
577 * Test IRadioMessaging.getSmscAddress() for the response returned.
578 */
TEST_P(RadioMessagingTest,getSmscAddress)579 TEST_P(RadioMessagingTest, getSmscAddress) {
580 if (telephony_flags::enforce_telephony_feature_mapping()) {
581 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
582 GTEST_SKIP() << "Skipping getSmscAddress "
583 "due to undefined FEATURE_TELEPHONY_MESSAGING";
584 }
585 }
586
587 serial = GetRandomSerialNumber();
588
589 radio_messaging->getSmscAddress(serial);
590
591 EXPECT_EQ(std::cv_status::no_timeout, wait());
592 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
593 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
594
595 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
596 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
597 {RadioError::INVALID_MODEM_STATE, RadioError::INVALID_STATE,
598 RadioError::SIM_ABSENT},
599 CHECK_GENERAL_ERROR));
600 }
601 }
602
603 /*
604 * Test IRadioMessaging.setSmscAddress() for the response returned.
605 */
TEST_P(RadioMessagingTest,setSmscAddress)606 TEST_P(RadioMessagingTest, setSmscAddress) {
607 if (telephony_flags::enforce_telephony_feature_mapping()) {
608 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
609 GTEST_SKIP() << "Skipping setSmscAddress "
610 "due to undefined FEATURE_TELEPHONY_MESSAGING";
611 }
612 }
613
614 serial = GetRandomSerialNumber();
615 std::string address = std::string("smscAddress");
616
617 radio_messaging->setSmscAddress(serial, address);
618
619 EXPECT_EQ(std::cv_status::no_timeout, wait());
620 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
621 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
622
623 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
624 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
625 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_SMS_FORMAT,
626 RadioError::SIM_ABSENT},
627 CHECK_GENERAL_ERROR));
628 }
629 }
630
631 /*
632 * Test IRadioMessaging.writeSmsToSim() for the response returned.
633 */
TEST_P(RadioMessagingTest,writeSmsToSim)634 TEST_P(RadioMessagingTest, writeSmsToSim) {
635 if (telephony_flags::enforce_telephony_feature_mapping()) {
636 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
637 GTEST_SKIP() << "Skipping writeSmsToSim "
638 "due to undefined FEATURE_TELEPHONY_MESSAGING";
639 }
640 }
641
642 serial = GetRandomSerialNumber();
643 SmsWriteArgs smsWriteArgs;
644 smsWriteArgs.status = SmsWriteArgs::STATUS_REC_UNREAD;
645 smsWriteArgs.smsc = "";
646 smsWriteArgs.pdu = "01000b916105770203f3000006d4f29c3e9b01";
647
648 radio_messaging->writeSmsToSim(serial, smsWriteArgs);
649
650 EXPECT_EQ(std::cv_status::no_timeout, wait());
651 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
652 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
653
654 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
655 ASSERT_TRUE(CheckAnyOfErrors(
656 radioRsp_messaging->rspInfo.error,
657 {RadioError::NONE, RadioError::ENCODING_ERR, RadioError::INVALID_ARGUMENTS,
658 RadioError::INVALID_SMSC_ADDRESS, RadioError::MODEM_ERR,
659 RadioError::NETWORK_NOT_READY, RadioError::NO_RESOURCES, RadioError::SIM_ABSENT},
660 CHECK_GENERAL_ERROR));
661 }
662 }
663
664 /*
665 * Test IRadioMessaging.deleteSmsOnSim() for the response returned.
666 */
TEST_P(RadioMessagingTest,deleteSmsOnSim)667 TEST_P(RadioMessagingTest, deleteSmsOnSim) {
668 if (telephony_flags::enforce_telephony_feature_mapping()) {
669 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
670 GTEST_SKIP() << "Skipping deleteSmsOnSim "
671 "due to undefined FEATURE_TELEPHONY_MESSAGING";
672 }
673 }
674
675 serial = GetRandomSerialNumber();
676 int index = 1;
677
678 radio_messaging->deleteSmsOnSim(serial, index);
679
680 EXPECT_EQ(std::cv_status::no_timeout, wait());
681 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
682 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
683
684 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
685 ASSERT_TRUE(CheckAnyOfErrors(
686 radioRsp_messaging->rspInfo.error,
687 {RadioError::NONE, RadioError::ENCODING_ERR, RadioError::INVALID_ARGUMENTS,
688 RadioError::INVALID_MODEM_STATE, RadioError::NO_SUCH_ENTRY, RadioError::MODEM_ERR,
689 RadioError::SIM_ABSENT},
690 CHECK_GENERAL_ERROR));
691 }
692 }
693
694 /*
695 * Test IRadioMessaging.writeSmsToRuim() for the response returned.
696 */
TEST_P(RadioMessagingTest,writeSmsToRuim)697 TEST_P(RadioMessagingTest, writeSmsToRuim) {
698 if (telephony_flags::enforce_telephony_feature_mapping()) {
699 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
700 GTEST_SKIP() << "Skipping writeSmsToRuim "
701 "due to undefined FEATURE_TELEPHONY_CDMA";
702 }
703 }
704
705 serial = GetRandomSerialNumber();
706
707 // Create a CdmaSmsAddress
708 CdmaSmsAddress cdmaSmsAddress;
709 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
710 cdmaSmsAddress.isNumberModeDataNetwork = false;
711 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
712 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
713 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
714
715 // Create a CdmaSmsSubAddress
716 CdmaSmsSubaddress cdmaSmsSubaddress;
717 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
718 cdmaSmsSubaddress.odd = false;
719 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
720
721 // Create a CdmaSmsMessage
722 CdmaSmsMessage cdmaSmsMessage;
723 cdmaSmsMessage.teleserviceId = 4098;
724 cdmaSmsMessage.isServicePresent = false;
725 cdmaSmsMessage.serviceCategory = 0;
726 cdmaSmsMessage.address = cdmaSmsAddress;
727 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
728 cdmaSmsMessage.bearerData =
729 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
730
731 // Create a CdmaSmsWriteArgs
732 CdmaSmsWriteArgs cdmaSmsWriteArgs;
733 cdmaSmsWriteArgs.status = CdmaSmsWriteArgs::STATUS_REC_UNREAD;
734 cdmaSmsWriteArgs.message = cdmaSmsMessage;
735
736 radio_messaging->writeSmsToRuim(serial, cdmaSmsWriteArgs);
737
738 EXPECT_EQ(std::cv_status::no_timeout, wait());
739 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
740 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
741
742 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
743 ASSERT_TRUE(CheckAnyOfErrors(
744 radioRsp_messaging->rspInfo.error,
745 {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_SMS_FORMAT,
746 RadioError::INVALID_SMSC_ADDRESS, RadioError::INVALID_STATE, RadioError::MODEM_ERR,
747 RadioError::NO_SUCH_ENTRY, RadioError::SIM_ABSENT},
748 CHECK_GENERAL_ERROR));
749 }
750 }
751
752 /*
753 * Test IRadioMessaging.deleteSmsOnRuim() for the response returned.
754 */
TEST_P(RadioMessagingTest,deleteSmsOnRuim)755 TEST_P(RadioMessagingTest, deleteSmsOnRuim) {
756 if (telephony_flags::enforce_telephony_feature_mapping()) {
757 if (!deviceSupportsFeature(FEATURE_TELEPHONY_CDMA)) {
758 GTEST_SKIP() << "Skipping deleteSmsOnRuim "
759 "due to undefined FEATURE_TELEPHONY_CDMA";
760 }
761 }
762
763 serial = GetRandomSerialNumber();
764 int index = 1;
765
766 // Create a CdmaSmsAddress
767 CdmaSmsAddress cdmaSmsAddress;
768 cdmaSmsAddress.digitMode = CdmaSmsAddress::DIGIT_MODE_FOUR_BIT;
769 cdmaSmsAddress.isNumberModeDataNetwork = false;
770 cdmaSmsAddress.numberType = CdmaSmsAddress::NUMBER_TYPE_UNKNOWN;
771 cdmaSmsAddress.numberPlan = CdmaSmsAddress::NUMBER_PLAN_UNKNOWN;
772 cdmaSmsAddress.digits = (std::vector<uint8_t>){11, 1, 6, 5, 10, 7, 7, 2, 10, 3, 10, 3};
773
774 // Create a CdmaSmsSubAddress
775 CdmaSmsSubaddress cdmaSmsSubaddress;
776 cdmaSmsSubaddress.subaddressType = CdmaSmsSubaddress::SUBADDRESS_TYPE_NSAP;
777 cdmaSmsSubaddress.odd = false;
778 cdmaSmsSubaddress.digits = (std::vector<uint8_t>){};
779
780 // Create a CdmaSmsMessage
781 CdmaSmsMessage cdmaSmsMessage;
782 cdmaSmsMessage.teleserviceId = 4098;
783 cdmaSmsMessage.isServicePresent = false;
784 cdmaSmsMessage.serviceCategory = 0;
785 cdmaSmsMessage.address = cdmaSmsAddress;
786 cdmaSmsMessage.subAddress = cdmaSmsSubaddress;
787 cdmaSmsMessage.bearerData =
788 (std::vector<uint8_t>){15, 0, 3, 32, 3, 16, 1, 8, 16, 53, 76, 68, 6, 51, 106, 0};
789
790 // Create a CdmaSmsWriteArgs
791 CdmaSmsWriteArgs cdmaSmsWriteArgs;
792 cdmaSmsWriteArgs.status = CdmaSmsWriteArgs::STATUS_REC_UNREAD;
793 cdmaSmsWriteArgs.message = cdmaSmsMessage;
794
795 radio_messaging->deleteSmsOnRuim(serial, index);
796
797 EXPECT_EQ(std::cv_status::no_timeout, wait());
798 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
799 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
800
801 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
802 ASSERT_TRUE(CheckAnyOfErrors(
803 radioRsp_messaging->rspInfo.error,
804 {RadioError::NONE, RadioError::INVALID_ARGUMENTS, RadioError::INVALID_MODEM_STATE,
805 RadioError::MODEM_ERR, RadioError::NO_SUCH_ENTRY, RadioError::SIM_ABSENT},
806 CHECK_GENERAL_ERROR));
807 }
808 }
809
810 /*
811 * Test IRadioMessaging.reportSmsMemoryStatus() for the response returned.
812 */
TEST_P(RadioMessagingTest,reportSmsMemoryStatus)813 TEST_P(RadioMessagingTest, reportSmsMemoryStatus) {
814 if (telephony_flags::enforce_telephony_feature_mapping()) {
815 if (!deviceSupportsFeature(FEATURE_TELEPHONY_MESSAGING)) {
816 GTEST_SKIP() << "Skipping reportSmsMemoryStatus "
817 "due to undefined FEATURE_TELEPHONY_MESSAGING";
818 }
819 }
820
821 serial = GetRandomSerialNumber();
822 bool available = true;
823
824 radio_messaging->reportSmsMemoryStatus(serial, available);
825
826 EXPECT_EQ(std::cv_status::no_timeout, wait());
827 EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_messaging->rspInfo.type);
828 EXPECT_EQ(serial, radioRsp_messaging->rspInfo.serial);
829
830 if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
831 ASSERT_TRUE(CheckAnyOfErrors(radioRsp_messaging->rspInfo.error,
832 {RadioError::INVALID_ARGUMENTS, RadioError::INVALID_STATE,
833 RadioError::MODEM_ERR, RadioError::SIM_ABSENT},
834 CHECK_GENERAL_ERROR));
835 }
836 }
837