blob: 887f8b8131c9c6a2e86584ce995da936fa1ed0b0 [file] [log] [blame]
Amy Zhang45cc57a2020-07-09 22:56:25 -07001/*
2 * Copyright 2020 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 "FrontendTests.h"
18
Amy Zhang68afca62020-07-20 18:28:58 -070019Return<void> FrontendCallback::onEvent(FrontendEventType frontendEventType) {
20 android::Mutex::Autolock autoLock(mMsgLock);
21 ALOGD("[vts] frontend event received. Type: %d", frontendEventType);
22 mEventReceived = true;
23 mMsgCondition.signal();
24 switch (frontendEventType) {
25 case FrontendEventType::LOCKED:
26 mLockMsgReceived = true;
27 mLockMsgCondition.signal();
28 return Void();
29 default:
30 // do nothing
31 return Void();
32 }
Amy Zhang45cc57a2020-07-09 22:56:25 -070033}
34
Amy Zhang3ea25a62020-08-04 10:23:52 -070035Return<void> FrontendCallback::onScanMessage(FrontendScanMessageType type,
36 const FrontendScanMessage& message) {
37 android::Mutex::Autolock autoLock(mMsgLock);
38 while (!mScanMsgProcessed) {
39 mMsgCondition.wait(mMsgLock);
40 }
41 ALOGD("[vts] frontend scan message. Type: %d", type);
42 mScanMessageReceived = true;
43 mScanMsgProcessed = false;
44 mScanMessageType = type;
45 mScanMessage = message;
46 mMsgCondition.signal();
Amy Zhang45cc57a2020-07-09 22:56:25 -070047 return Void();
48}
49
Amy Zhang19ed17b2020-08-04 10:23:52 -070050Return<void> FrontendCallback::onScanMessageExt1_1(FrontendScanMessageTypeExt1_1 type,
51 const FrontendScanMessageExt1_1& message) {
52 android::Mutex::Autolock autoLock(mMsgLock);
53 ALOGD("[vts] frontend ext1_1 scan message. Type: %d", type);
Amy Zhang7ec2b702020-10-05 18:07:20 -070054 switch (message.getDiscriminator()) {
55 case FrontendScanMessageExt1_1::hidl_discriminator::modulation:
56 readFrontendScanMessageExt1_1Modulation(message.modulation());
57 break;
58 case FrontendScanMessageExt1_1::hidl_discriminator::isHighPriority:
59 ALOGD("[vts] frontend ext1_1 scan message high priority: %d", message.isHighPriority());
Amy Zhang19ed17b2020-08-04 10:23:52 -070060 break;
Amy Zhang7e669ce2020-10-20 16:41:30 -070061 case FrontendScanMessageExt1_1::hidl_discriminator::annex:
62 ALOGD("[vts] frontend ext1_1 scan message dvbc annex: %hhu", message.annex());
63 break;
Amy Zhang19ed17b2020-08-04 10:23:52 -070064 default:
65 break;
66 }
67 return Void();
68}
69
70void FrontendCallback::readFrontendScanMessageExt1_1Modulation(FrontendModulation modulation) {
71 switch (modulation.getDiscriminator()) {
72 case FrontendModulation::hidl_discriminator::dvbc:
73 ALOGD("[vts] frontend ext1_1 scan message modulation dvbc: %d", modulation.dvbc());
74 break;
75 case FrontendModulation::hidl_discriminator::dvbs:
76 ALOGD("[vts] frontend ext1_1 scan message modulation dvbs: %d", modulation.dvbs());
77 break;
78 case FrontendModulation::hidl_discriminator::isdbs:
79 ALOGD("[vts] frontend ext1_1 scan message modulation isdbs: %d", modulation.isdbs());
80 break;
81 case FrontendModulation::hidl_discriminator::isdbs3:
82 ALOGD("[vts] frontend ext1_1 scan message modulation isdbs3: %d", modulation.isdbs3());
83 break;
84 case FrontendModulation::hidl_discriminator::isdbt:
85 ALOGD("[vts] frontend ext1_1 scan message modulation isdbt: %d", modulation.isdbt());
86 break;
87 case FrontendModulation::hidl_discriminator::atsc:
88 ALOGD("[vts] frontend ext1_1 scan message modulation atsc: %d", modulation.atsc());
89 break;
90 case FrontendModulation::hidl_discriminator::atsc3:
91 ALOGD("[vts] frontend ext1_1 scan message modulation atsc3: %d", modulation.atsc3());
92 break;
93 case FrontendModulation::hidl_discriminator::dvbt:
94 ALOGD("[vts] frontend ext1_1 scan message modulation dvbt: %d", modulation.dvbt());
95 break;
96 default:
97 break;
98 }
99}
100
Amy Zhang3ea25a62020-08-04 10:23:52 -0700101void FrontendCallback::tuneTestOnLock(sp<IFrontend>& frontend, FrontendSettings settings,
Amy Zhangbc15b592020-09-25 15:35:55 -0700102 FrontendSettingsExt1_1 settingsExt1_1) {
Amy Zhang3ea25a62020-08-04 10:23:52 -0700103 sp<android::hardware::tv::tuner::V1_1::IFrontend> frontend_1_1;
104 frontend_1_1 = android::hardware::tv::tuner::V1_1::IFrontend::castFrom(frontend);
105 if (frontend_1_1 == nullptr) {
106 EXPECT_TRUE(false) << "Couldn't get 1.1 IFrontend from the Hal implementation.";
107 return;
108 }
109
Amy Zhangbc15b592020-09-25 15:35:55 -0700110 Result result = frontend_1_1->tune_1_1(settings, settingsExt1_1);
Amy Zhang68afca62020-07-20 18:28:58 -0700111 EXPECT_TRUE(result == Result::SUCCESS);
112
113 android::Mutex::Autolock autoLock(mMsgLock);
114 while (!mLockMsgReceived) {
115 if (-ETIMEDOUT == mLockMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
116 EXPECT_TRUE(false) << "Event LOCKED not received within timeout";
117 mLockMsgReceived = false;
118 return;
119 }
120 }
121 mLockMsgReceived = false;
122}
123
Amy Zhang3ea25a62020-08-04 10:23:52 -0700124void FrontendCallback::scanTest(sp<IFrontend>& frontend, FrontendConfig config,
125 FrontendScanType type) {
126 sp<android::hardware::tv::tuner::V1_1::IFrontend> frontend_1_1;
127 frontend_1_1 = android::hardware::tv::tuner::V1_1::IFrontend::castFrom(frontend);
128 if (frontend_1_1 == nullptr) {
129 EXPECT_TRUE(false) << "Couldn't get 1.1 IFrontend from the Hal implementation.";
130 return;
131 }
132
133 uint32_t targetFrequency = getTargetFrequency(config.settings, config.type);
134 if (type == FrontendScanType::SCAN_BLIND) {
135 // reset the frequency in the scan configuration to test blind scan. The settings param of
136 // passed in means the real input config on the transponder connected to the DUT.
137 // We want the blind the test to start from lower frequency than this to check the blind
138 // scan implementation.
139 resetBlindScanStartingFrequency(config, targetFrequency - 100);
140 }
141
Amy Zhangbc15b592020-09-25 15:35:55 -0700142 Result result = frontend_1_1->scan_1_1(config.settings, type, config.settingsExt1_1);
Amy Zhang3ea25a62020-08-04 10:23:52 -0700143 EXPECT_TRUE(result == Result::SUCCESS);
144
145 bool scanMsgLockedReceived = false;
146 bool targetFrequencyReceived = false;
147
148 android::Mutex::Autolock autoLock(mMsgLock);
149wait:
150 while (!mScanMessageReceived) {
151 if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
152 EXPECT_TRUE(false) << "Scan message not received within timeout";
153 mScanMessageReceived = false;
154 mScanMsgProcessed = true;
155 return;
156 }
157 }
158
159 if (mScanMessageType != FrontendScanMessageType::END) {
160 if (mScanMessageType == FrontendScanMessageType::LOCKED) {
161 scanMsgLockedReceived = true;
Amy Zhangbc15b592020-09-25 15:35:55 -0700162 Result result = frontend_1_1->scan_1_1(config.settings, type, config.settingsExt1_1);
Amy Zhang3ea25a62020-08-04 10:23:52 -0700163 EXPECT_TRUE(result == Result::SUCCESS);
164 }
165
166 if (mScanMessageType == FrontendScanMessageType::FREQUENCY) {
167 targetFrequencyReceived = mScanMessage.frequencies().size() > 0 &&
168 mScanMessage.frequencies()[0] == targetFrequency;
169 }
170
171 if (mScanMessageType == FrontendScanMessageType::PROGRESS_PERCENT) {
172 ALOGD("[vts] Scan in progress...[%d%%]", mScanMessage.progressPercent());
173 }
174
175 mScanMessageReceived = false;
176 mScanMsgProcessed = true;
177 mMsgCondition.signal();
178 goto wait;
179 }
180
181 EXPECT_TRUE(scanMsgLockedReceived) << "Scan message LOCKED not received before END";
182 EXPECT_TRUE(targetFrequencyReceived) << "frequency not received before LOCKED on blindScan";
183 mScanMessageReceived = false;
184 mScanMsgProcessed = true;
185}
186
187uint32_t FrontendCallback::getTargetFrequency(FrontendSettings settings, FrontendType type) {
188 switch (type) {
189 case FrontendType::ANALOG:
190 return settings.analog().frequency;
191 case FrontendType::ATSC:
192 return settings.atsc().frequency;
193 case FrontendType::ATSC3:
194 return settings.atsc3().frequency;
195 case FrontendType::DVBC:
196 return settings.dvbc().frequency;
197 case FrontendType::DVBS:
198 return settings.dvbs().frequency;
199 case FrontendType::DVBT:
200 return settings.dvbt().frequency;
201 case FrontendType::ISDBS:
202 return settings.isdbs().frequency;
203 case FrontendType::ISDBS3:
204 return settings.isdbs3().frequency;
205 case FrontendType::ISDBT:
206 return settings.isdbt().frequency;
207 default:
208 return 0;
209 }
210}
211
212void FrontendCallback::resetBlindScanStartingFrequency(FrontendConfig& config,
213 uint32_t resetingFreq) {
214 switch (config.type) {
215 case FrontendType::ANALOG:
216 config.settings.analog().frequency = resetingFreq;
217 break;
218 case FrontendType::ATSC:
219 config.settings.atsc().frequency = resetingFreq;
220 break;
221 case FrontendType::ATSC3:
222 config.settings.atsc3().frequency = resetingFreq;
223 break;
224 case FrontendType::DVBC:
225 config.settings.dvbc().frequency = resetingFreq;
226 break;
227 case FrontendType::DVBS:
228 config.settings.dvbs().frequency = resetingFreq;
229 break;
230 case FrontendType::DVBT:
231 config.settings.dvbt().frequency = resetingFreq;
232 break;
233 case FrontendType::ISDBS:
234 config.settings.isdbs().frequency = resetingFreq;
235 break;
236 case FrontendType::ISDBS3:
237 config.settings.isdbs3().frequency = resetingFreq;
238 break;
239 case FrontendType::ISDBT:
240 config.settings.isdbt().frequency = resetingFreq;
241 break;
242 default:
243 // do nothing
244 return;
245 }
246}
247
Amy Zhang45cc57a2020-07-09 22:56:25 -0700248AssertionResult FrontendTests::getFrontendIds() {
249 Result status;
250 mService->getFrontendIds([&](Result result, const hidl_vec<FrontendId>& frontendIds) {
251 status = result;
252 mFeIds = frontendIds;
253 });
254 return AssertionResult(status == Result::SUCCESS);
255}
256
257AssertionResult FrontendTests::getFrontendInfo(uint32_t frontendId) {
258 Result status;
259 mService->getFrontendInfo(frontendId, [&](Result result, const FrontendInfo& frontendInfo) {
260 mFrontendInfo = frontendInfo;
261 status = result;
262 });
263 return AssertionResult(status == Result::SUCCESS);
264}
265
266AssertionResult FrontendTests::openFrontendById(uint32_t frontendId) {
267 Result status;
268 mService->openFrontendById(frontendId, [&](Result result, const sp<IFrontend>& frontend) {
269 mFrontend = frontend;
270 status = result;
271 });
272 return AssertionResult(status == Result::SUCCESS);
273}
274
275AssertionResult FrontendTests::setFrontendCallback() {
276 EXPECT_TRUE(mFrontend) << "Test with openFrontendById first.";
277 mFrontendCallback = new FrontendCallback();
278 auto callbackStatus = mFrontend->setCallback(mFrontendCallback);
279 return AssertionResult(callbackStatus.isOk());
280}
281
Amy Zhang3ea25a62020-08-04 10:23:52 -0700282AssertionResult FrontendTests::scanFrontend(FrontendConfig config, FrontendScanType type) {
283 EXPECT_TRUE(mFrontendCallback)
284 << "test with openFrontendById/setFrontendCallback/getFrontendInfo first.";
285
286 EXPECT_TRUE(mFrontendInfo.type == config.type)
287 << "FrontendConfig does not match the frontend info of the given id.";
288
289 mFrontendCallback->scanTest(mFrontend, config, type);
290 return AssertionResult(true);
291}
292
293AssertionResult FrontendTests::stopScanFrontend() {
294 EXPECT_TRUE(mFrontend) << "Test with openFrontendById first.";
295 Result status;
296 status = mFrontend->stopScan();
Amy Zhang4c49c152020-08-25 21:08:19 -0700297
298 return AssertionResult(status == Result::SUCCESS);
299}
300
301AssertionResult FrontendTests::getFrontendDtmbCaps(uint32_t id) {
302 Result status;
303 mService->getFrontendDtmbCapabilities(
304 id, [&](Result result, const FrontendDtmbCapabilities& /*caps*/) { status = result; });
Amy Zhang3ea25a62020-08-04 10:23:52 -0700305 return AssertionResult(status == Result::SUCCESS);
306}
307
Amy Zhangda3a54d2021-02-18 21:47:00 -0800308AssertionResult FrontendTests::linkCiCam(uint32_t ciCamId) {
309 sp<android::hardware::tv::tuner::V1_1::IFrontend> frontend_1_1;
310 frontend_1_1 = android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);
311 if (frontend_1_1 == nullptr) {
312 EXPECT_TRUE(false) << "Couldn't get 1.1 IFrontend from the Hal implementation.";
313 return failure();
314 }
315
316 Result status;
317 uint32_t ltsId;
318 frontend_1_1->linkCiCam(ciCamId, [&](Result r, uint32_t id) {
319 status = r;
320 ltsId = id;
321 });
322
323 return AssertionResult(status == Result::SUCCESS);
324}
325
326AssertionResult FrontendTests::unlinkCiCam(uint32_t ciCamId) {
327 sp<android::hardware::tv::tuner::V1_1::IFrontend> frontend_1_1;
328 frontend_1_1 = android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);
329 if (frontend_1_1 == nullptr) {
330 EXPECT_TRUE(false) << "Couldn't get 1.1 IFrontend from the Hal implementation.";
331 return failure();
332 }
333
334 Result status = frontend_1_1->unlinkCiCam(ciCamId);
335 return AssertionResult(status == Result::SUCCESS);
336}
337
Amy Zhang422bb112020-08-12 15:21:44 -0700338void FrontendTests::verifyFrontendStatusExt1_1(vector<FrontendStatusTypeExt1_1> statusTypes,
339 vector<FrontendStatusExt1_1> expectStatuses) {
Amy Zhang3ea25a62020-08-04 10:23:52 -0700340 ASSERT_TRUE(mFrontend) << "Frontend is not opened yet.";
341 Result status;
Amy Zhang422bb112020-08-12 15:21:44 -0700342 vector<FrontendStatusExt1_1> realStatuses;
Amy Zhang3ea25a62020-08-04 10:23:52 -0700343
Amy Zhang422bb112020-08-12 15:21:44 -0700344 sp<android::hardware::tv::tuner::V1_1::IFrontend> frontend_1_1;
345 frontend_1_1 = android::hardware::tv::tuner::V1_1::IFrontend::castFrom(mFrontend);
346 if (frontend_1_1 == nullptr) {
347 EXPECT_TRUE(false) << "Couldn't get 1.1 IFrontend from the Hal implementation.";
348 return;
349 }
350
351 frontend_1_1->getStatusExt1_1(
352 statusTypes, [&](Result result, const hidl_vec<FrontendStatusExt1_1>& statuses) {
353 status = result;
354 realStatuses = statuses;
355 });
Amy Zhang3ea25a62020-08-04 10:23:52 -0700356
357 ASSERT_TRUE(realStatuses.size() == statusTypes.size());
358 for (int i = 0; i < statusTypes.size(); i++) {
Amy Zhang422bb112020-08-12 15:21:44 -0700359 FrontendStatusTypeExt1_1 type = statusTypes[i];
Amy Zhang3ea25a62020-08-04 10:23:52 -0700360 switch (type) {
Amy Zhang422bb112020-08-12 15:21:44 -0700361 case FrontendStatusTypeExt1_1::MODULATIONS: {
362 // TODO: verify modulations
Amy Zhang3ea25a62020-08-04 10:23:52 -0700363 break;
364 }
Amy Zhang422bb112020-08-12 15:21:44 -0700365 case FrontendStatusTypeExt1_1::BERS: {
366 ASSERT_TRUE(std::equal(realStatuses[i].bers().begin(), realStatuses[i].bers().end(),
367 expectStatuses[i].bers().begin()));
Amy Zhang3ea25a62020-08-04 10:23:52 -0700368 break;
369 }
Amy Zhang422bb112020-08-12 15:21:44 -0700370 case FrontendStatusTypeExt1_1::CODERATES: {
371 ASSERT_TRUE(std::equal(realStatuses[i].codeRates().begin(),
372 realStatuses[i].codeRates().end(),
373 expectStatuses[i].codeRates().begin()));
Amy Zhang3ea25a62020-08-04 10:23:52 -0700374 break;
375 }
Amy Zhang422bb112020-08-12 15:21:44 -0700376 case FrontendStatusTypeExt1_1::GUARD_INTERVAL: {
377 // TODO: verify interval
Amy Zhang3ea25a62020-08-04 10:23:52 -0700378 break;
379 }
Amy Zhang422bb112020-08-12 15:21:44 -0700380 case FrontendStatusTypeExt1_1::TRANSMISSION_MODE: {
381 // TODO: verify tranmission mode
Amy Zhang3ea25a62020-08-04 10:23:52 -0700382 break;
383 }
Amy Zhang422bb112020-08-12 15:21:44 -0700384 case FrontendStatusTypeExt1_1::UEC: {
385 ASSERT_TRUE(realStatuses[i].uec() == expectStatuses[i].uec());
Amy Zhang3ea25a62020-08-04 10:23:52 -0700386 break;
387 }
Amy Zhang422bb112020-08-12 15:21:44 -0700388 case FrontendStatusTypeExt1_1::T2_SYSTEM_ID: {
389 ASSERT_TRUE(realStatuses[i].systemId() == expectStatuses[i].systemId());
Amy Zhang3ea25a62020-08-04 10:23:52 -0700390 break;
391 }
Amy Zhang422bb112020-08-12 15:21:44 -0700392 case FrontendStatusTypeExt1_1::INTERLEAVINGS: {
393 ASSERT_TRUE(std::equal(realStatuses[i].interleaving().begin(),
394 realStatuses[i].interleaving().end(),
395 expectStatuses[i].interleaving().begin()));
Amy Zhang3ea25a62020-08-04 10:23:52 -0700396 break;
397 }
Amy Zhang422bb112020-08-12 15:21:44 -0700398 case FrontendStatusTypeExt1_1::ISDBT_SEGMENTS: {
399 ASSERT_TRUE(std::equal(realStatuses[i].isdbtSegment().begin(),
400 realStatuses[i].isdbtSegment().end(),
401 expectStatuses[i].isdbtSegment().begin()));
Amy Zhang3ea25a62020-08-04 10:23:52 -0700402 break;
403 }
Amy Zhang422bb112020-08-12 15:21:44 -0700404 case FrontendStatusTypeExt1_1::TS_DATA_RATES: {
405 ASSERT_TRUE(std::equal(realStatuses[i].tsDataRate().begin(),
406 realStatuses[i].tsDataRate().end(),
407 expectStatuses[i].tsDataRate().begin()));
Amy Zhang3ea25a62020-08-04 10:23:52 -0700408 break;
409 }
Amy Zhang7e669ce2020-10-20 16:41:30 -0700410 case FrontendStatusTypeExt1_1::ROLL_OFF: {
411 // TODO: verify roll off
412 break;
413 }
414 case FrontendStatusTypeExt1_1::IS_MISO: {
415 ASSERT_TRUE(realStatuses[i].isMiso() == expectStatuses[i].isMiso());
416 break;
417 }
418 case FrontendStatusTypeExt1_1::IS_LINEAR: {
419 ASSERT_TRUE(realStatuses[i].isLinear() == expectStatuses[i].isLinear());
420 break;
421 }
422 case FrontendStatusTypeExt1_1::IS_SHORT_FRAMES: {
423 ASSERT_TRUE(realStatuses[i].isShortFrames() == expectStatuses[i].isShortFrames());
424 break;
425 }
Amy Zhang422bb112020-08-12 15:21:44 -0700426 default: {
Amy Zhang3ea25a62020-08-04 10:23:52 -0700427 continue;
Amy Zhang422bb112020-08-12 15:21:44 -0700428 }
Amy Zhang3ea25a62020-08-04 10:23:52 -0700429 }
430 }
431 ASSERT_TRUE(status == Result::SUCCESS);
432}
433
Amy Zhang68afca62020-07-20 18:28:58 -0700434AssertionResult FrontendTests::tuneFrontend(FrontendConfig config, bool testWithDemux) {
435 EXPECT_TRUE(mFrontendCallback)
436 << "test with openFrontendById/setFrontendCallback/getFrontendInfo first.";
437
438 EXPECT_TRUE(mFrontendInfo.type == config.type)
439 << "FrontendConfig does not match the frontend info of the given id.";
440
441 mIsSoftwareFe = config.isSoftwareFe;
442 bool result = true;
443 if (mIsSoftwareFe && testWithDemux) {
444 result &= mDvrTests.openDvrInDemux(mDvrConfig.type, mDvrConfig.bufferSize) == success();
445 result &= mDvrTests.configDvrPlayback(mDvrConfig.settings) == success();
446 result &= mDvrTests.getDvrPlaybackMQDescriptor() == success();
447 mDvrTests.startPlaybackInputThread(mDvrConfig.playbackInputFile,
448 mDvrConfig.settings.playback());
449 if (!result) {
450 ALOGW("[vts] Software frontend dvr configure failed.");
451 return failure();
452 }
453 }
Amy Zhangbc15b592020-09-25 15:35:55 -0700454 mFrontendCallback->tuneTestOnLock(mFrontend, config.settings, config.settingsExt1_1);
Amy Zhang68afca62020-07-20 18:28:58 -0700455 return AssertionResult(true);
456}
457
458AssertionResult FrontendTests::stopTuneFrontend(bool testWithDemux) {
459 EXPECT_TRUE(mFrontend) << "Test with openFrontendById first.";
460 Result status;
461 status = mFrontend->stopTune();
462 if (mIsSoftwareFe && testWithDemux) {
463 mDvrTests.stopPlaybackThread();
464 mDvrTests.closeDvrPlayback();
465 }
466 return AssertionResult(status == Result::SUCCESS);
467}
468
Amy Zhang45cc57a2020-07-09 22:56:25 -0700469AssertionResult FrontendTests::closeFrontend() {
470 EXPECT_TRUE(mFrontend) << "Test with openFrontendById first.";
471 Result status;
472 status = mFrontend->close();
473 mFrontend = nullptr;
474 mFrontendCallback = nullptr;
475 return AssertionResult(status == Result::SUCCESS);
476}
477
478void FrontendTests::getFrontendIdByType(FrontendType feType, uint32_t& feId) {
479 ASSERT_TRUE(getFrontendIds());
480 ASSERT_TRUE(mFeIds.size() > 0);
481 for (size_t i = 0; i < mFeIds.size(); i++) {
482 ASSERT_TRUE(getFrontendInfo(mFeIds[i]));
483 if (mFrontendInfo.type != feType) {
484 continue;
485 }
486 feId = mFeIds[i];
487 return;
488 }
489 feId = INVALID_ID;
Amy Zhang68afca62020-07-20 18:28:58 -0700490}
Amy Zhang3ea25a62020-08-04 10:23:52 -0700491
492void FrontendTests::tuneTest(FrontendConfig frontendConf) {
493 uint32_t feId;
494 getFrontendIdByType(frontendConf.type, feId);
495 ASSERT_TRUE(feId != INVALID_ID);
496 ASSERT_TRUE(openFrontendById(feId));
497 ASSERT_TRUE(setFrontendCallback());
Amy Zhangda3a54d2021-02-18 21:47:00 -0800498 if (frontendConf.canConnectToCiCam) {
499 ASSERT_TRUE(linkCiCam(frontendConf.ciCamId));
500 ASSERT_TRUE(unlinkCiCam(frontendConf.ciCamId));
501 }
Amy Zhang3ea25a62020-08-04 10:23:52 -0700502 ASSERT_TRUE(tuneFrontend(frontendConf, false /*testWithDemux*/));
Amy Zhang422bb112020-08-12 15:21:44 -0700503 verifyFrontendStatusExt1_1(frontendConf.tuneStatusTypes, frontendConf.expectTuneStatuses);
Amy Zhang3ea25a62020-08-04 10:23:52 -0700504 ASSERT_TRUE(stopTuneFrontend(false /*testWithDemux*/));
505 ASSERT_TRUE(closeFrontend());
506}
507
508void FrontendTests::scanTest(FrontendConfig frontendConf, FrontendScanType scanType) {
509 uint32_t feId;
510 getFrontendIdByType(frontendConf.type, feId);
511 ASSERT_TRUE(feId != INVALID_ID);
512 ASSERT_TRUE(openFrontendById(feId));
513 ASSERT_TRUE(setFrontendCallback());
514 ASSERT_TRUE(scanFrontend(frontendConf, scanType));
515 ASSERT_TRUE(stopScanFrontend());
516 ASSERT_TRUE(closeFrontend());
517}
Amy Zhang4c49c152020-08-25 21:08:19 -0700518
519void FrontendTests::getFrontendDtmbCapsTest() {
520 uint32_t feId;
521 getFrontendIdByType(
522 static_cast<FrontendType>(android::hardware::tv::tuner::V1_1::FrontendType::DTMB),
523 feId);
524 if (feId != INVALID_ID) {
525 ALOGD("[vts] Found DTMB Frontend");
526 ASSERT_TRUE(getFrontendDtmbCaps(feId));
527 }
528}