2 * Copyright (C) 2016 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 #define LOG_TAG "BroadcastRadioHidlHalTest"
18 #include <VtsHalHidlTargetTestBase.h>
19 #include <android-base/logging.h>
20 #include <cutils/native_handle.h>
21 #include <cutils/properties.h>
22 #include <hidl/HidlTransportSupport.h>
23 #include <utils/threads.h>
25 #include <android/hardware/broadcastradio/1.0/IBroadcastRadioFactory.h>
26 #include <android/hardware/broadcastradio/1.0/IBroadcastRadio.h>
27 #include <android/hardware/broadcastradio/1.0/ITuner.h>
28 #include <android/hardware/broadcastradio/1.0/ITunerCallback.h>
29 #include <android/hardware/broadcastradio/1.0/types.h>
33 using ::android::Mutex;
34 using ::android::Condition;
35 using ::android::hardware::Return;
36 using ::android::hardware::Void;
37 using ::android::hardware::broadcastradio::V1_0::IBroadcastRadioFactory;
38 using ::android::hardware::broadcastradio::V1_0::IBroadcastRadio;
39 using ::android::hardware::broadcastradio::V1_0::ITuner;
40 using ::android::hardware::broadcastradio::V1_0::ITunerCallback;
41 using ::android::hardware::broadcastradio::V1_0::Result;
42 using ::android::hardware::broadcastradio::V1_0::Class;
43 using ::android::hardware::broadcastradio::V1_0::Properties;
44 using ::android::hardware::broadcastradio::V1_0::Band;
45 using ::android::hardware::broadcastradio::V1_0::BandConfig;
46 using ::android::hardware::broadcastradio::V1_0::Direction;
47 using ::android::hardware::broadcastradio::V1_0::ProgramInfo;
48 using ::android::hardware::broadcastradio::V1_0::MetaData;
51 #define RETURN_IF_SKIPPED \
53 std::cout << "[ SKIPPED ] This device class is not supported. " << std::endl; \
57 // The main test class for Broadcast Radio HIDL HAL.
59 class BroadcastRadioHidlTest : public ::testing::VtsHalHidlTargetTestBase,
60 public ::testing::WithParamInterface<Class> {
62 virtual void SetUp() override {
63 ASSERT_EQ(nullptr, mRadio.get());
65 radioClass = GetParam();
68 sp<IBroadcastRadioFactory> factory =
69 ::testing::VtsHalHidlTargetTestBase::getService<IBroadcastRadioFactory>();
70 ASSERT_NE(nullptr, factory.get());
73 factory->connectModule(radioClass, [&](Result ret, const sp<IBroadcastRadio>& radio) {
78 EXPECT_EQ(true, waitForCallback(kConnectCallbacktimeoutNs));
79 mCallbackCalled = false;
81 if (connectResult == Result::INVALID_ARGUMENTS) {
85 ASSERT_EQ(connectResult, Result::OK);
87 mTunerCallback = new MyCallback(this);
88 ASSERT_NE(nullptr, mRadio.get());
89 ASSERT_NE(nullptr, mTunerCallback.get());
92 virtual void TearDown() override {
97 class MyCallback : public ITunerCallback {
100 // ITunerCallback methods (see doc in ITunerCallback.hal)
101 virtual Return<void> hardwareFailure() {
102 ALOGI("%s", __FUNCTION__);
103 mParentTest->onHwFailureCallback();
107 virtual Return<void> configChange(Result result, const BandConfig& config) {
108 ALOGI("%s result %d", __FUNCTION__, result);
109 mParentTest->onConfigChangeCallback(result, config);
113 virtual Return<void> tuneComplete(Result result, const ProgramInfo& info) {
114 ALOGI("%s result %d", __FUNCTION__, result);
115 mParentTest->onTuneCompleteCallback(result, info);
119 virtual Return<void> afSwitch(const ProgramInfo& info __unused) {
123 virtual Return<void> antennaStateChange(bool connected) {
124 ALOGI("%s connected %d", __FUNCTION__, connected);
128 virtual Return<void> trafficAnnouncement(bool active) {
129 ALOGI("%s active %d", __FUNCTION__, active);
133 virtual Return<void> emergencyAnnouncement(bool active) {
134 ALOGI("%s active %d", __FUNCTION__, active);
138 virtual Return<void> newMetadata(uint32_t channel __unused, uint32_t subChannel __unused,
139 const ::android::hardware::hidl_vec<MetaData>& metadata __unused) {
140 ALOGI("%s", __FUNCTION__);
144 MyCallback(BroadcastRadioHidlTest *parentTest) : mParentTest(parentTest) {}
147 // BroadcastRadioHidlTest instance to which callbacks will be notified.
148 BroadcastRadioHidlTest *mParentTest;
153 * Method called by MyCallback when a callback with no status or boolean value is received
156 Mutex::Autolock _l(mLock);
161 * Method called by MyCallback when hardwareFailure() callback is received
163 void onHwFailureCallback() {
164 Mutex::Autolock _l(mLock);
170 * Method called by MyCallback when configChange() callback is received.
172 void onConfigChangeCallback(Result result, const BandConfig& config) {
173 Mutex::Autolock _l(mLock);
174 mResultCallbackData = result;
175 mBandConfigCallbackData = config;
180 * Method called by MyCallback when tuneComplete() callback is received.
182 void onTuneCompleteCallback(Result result, const ProgramInfo& info) {
183 Mutex::Autolock _l(mLock);
184 mResultCallbackData = result;
185 mProgramInfoCallbackData = info;
190 * Method called by MyCallback when a boolean indication is received
192 void onBoolCallback(bool result) {
193 Mutex::Autolock _l(mLock);
194 mBoolCallbackData = result;
199 BroadcastRadioHidlTest()
200 : mCallbackCalled(false), mBoolCallbackData(false), mResultCallbackData(Result::OK),
203 void onCallback_l() {
204 if (!mCallbackCalled) {
205 mCallbackCalled = true;
206 mCallbackCond.broadcast();
211 bool waitForCallback(nsecs_t reltime = 0) {
212 Mutex::Autolock _l(mLock);
213 nsecs_t endTime = systemTime() + reltime;
214 while (!mCallbackCalled) {
216 mCallbackCond.wait(mLock);
218 nsecs_t now = systemTime();
222 mCallbackCond.waitRelative(mLock, endTime - now);
228 bool getProperties();
231 BandConfig& getBand(unsigned idx);
233 static const nsecs_t kConnectCallbacktimeoutNs = seconds_to_nanoseconds(1);
234 static const nsecs_t kConfigCallbacktimeoutNs = seconds_to_nanoseconds(10);
235 static const nsecs_t kTuneCallbacktimeoutNs = seconds_to_nanoseconds(30);
239 sp<IBroadcastRadio> mRadio;
240 Properties mHalProperties;
241 bool mHalPropertiesInitialized = false;
243 sp<MyCallback> mTunerCallback;
245 Condition mCallbackCond;
246 bool mCallbackCalled;
247 bool mBoolCallbackData;
248 Result mResultCallbackData;
249 ProgramInfo mProgramInfoCallbackData;
250 BandConfig mBandConfigCallbackData;
256 namespace broadcastradio {
260 * Compares two BandConfig objects for testing purposes.
262 static bool operator==(const BandConfig& l, const BandConfig& r) {
263 if (l.type != r.type) return false;
264 if (l.antennaConnected != r.antennaConnected) return false;
265 if (l.lowerLimit != r.lowerLimit) return false;
266 if (l.upperLimit != r.upperLimit) return false;
267 if (l.spacings != r.spacings) return false;
268 if (l.type == Band::AM || l.type == Band::AM_HD) {
269 return l.ext.am == r.ext.am;
270 } else if (l.type == Band::FM || l.type == Band::FM_HD) {
271 return l.ext.fm == r.ext.fm;
283 bool BroadcastRadioHidlTest::getProperties()
285 if (mHalPropertiesInitialized) return true;
287 Result halResult = Result::NOT_INITIALIZED;
288 auto hidlReturn = mRadio->getProperties([&](Result result, const Properties& properties) {
290 if (result == Result::OK) {
291 mHalProperties = properties;
295 EXPECT_TRUE(hidlReturn.isOk());
296 EXPECT_EQ(Result::OK, halResult);
297 EXPECT_EQ(radioClass, mHalProperties.classId);
298 EXPECT_GT(mHalProperties.numTuners, 0u);
299 if (radioClass == Class::AM_FM) {
300 EXPECT_GT(mHalProperties.bands.size(), 0u);
303 if (hidlReturn.isOk() && halResult == Result::OK) {
304 mHalPropertiesInitialized = true;
310 bool BroadcastRadioHidlTest::openTuner()
312 if (!getProperties()) {
315 if (mTuner.get() == nullptr) {
316 Result halResult = Result::NOT_INITIALIZED;
317 auto openCb = [&](Result result, const sp<ITuner>& tuner) {
319 if (result == Result::OK) {
323 auto hidlReturn = mRadio->openTuner(getBand(0), true, mTunerCallback, openCb);
324 EXPECT_TRUE(hidlReturn.isOk());
325 EXPECT_EQ(Result::OK, halResult);
326 if (radioClass == Class::AM_FM) {
327 EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs));
330 EXPECT_NE(nullptr, mTuner.get());
331 return nullptr != mTuner.get();
334 bool BroadcastRadioHidlTest::checkAntenna()
336 if (radioClass != Class::AM_FM) return true;
338 BandConfig halConfig;
339 Result halResult = Result::NOT_INITIALIZED;
340 Return<void> hidlReturn =
341 mTuner->getConfiguration([&](Result result, const BandConfig& config) {
343 if (result == Result::OK) {
348 return ((halResult == Result::OK) && (halConfig.antennaConnected == true));
351 BandConfig& BroadcastRadioHidlTest::getBand(unsigned idx) {
352 static BandConfig dummyBandConfig = {};
353 if (radioClass == Class::AM_FM) {
354 EXPECT_GT(mHalProperties.bands.size(), idx);
355 if (mHalProperties.bands.size() > idx) {
356 return mHalProperties.bands[idx];
358 return dummyBandConfig;
361 return dummyBandConfig;
366 * Test IBroadcastRadio::getProperties() method
369 * - the HAL implements the method
370 * - the method returns 0 (no error)
371 * - the implementation class is radioClass
372 * - the implementation supports at least one tuner
373 * - the implementation supports at one band
375 TEST_P(BroadcastRadioHidlTest, GetProperties) {
377 EXPECT_EQ(true, getProperties());
381 * Test IBroadcastRadio::openTuner() method
384 * - the HAL implements the method
385 * - the method returns 0 (no error) and a valid ITuner interface
387 TEST_P(BroadcastRadioHidlTest, OpenTuner) {
389 EXPECT_EQ(true, openTuner());
393 * Test IBroadcastRadio::openTuner() after ITuner disposal.
396 * - ITuner destruction gets propagated through HAL
397 * - the openTuner method works well when called for the second time
399 TEST_P(BroadcastRadioHidlTest, ReopenTuner) {
401 EXPECT_TRUE(openTuner());
403 EXPECT_TRUE(openTuner());
407 * Test IBroadcastRadio::openTuner() method called twice.
410 * - the openTuner method fails with INVALID_STATE or succeeds when called for the second time
411 * without deleting previous ITuner instance
413 TEST_P(BroadcastRadioHidlTest, OpenTunerTwice) {
415 EXPECT_TRUE(openTuner());
417 Result halResult = Result::NOT_INITIALIZED;
418 auto openCb = [&](Result result, const sp<ITuner>&) { halResult = result; };
419 auto hidlReturn = mRadio->openTuner(getBand(0), true, mTunerCallback, openCb);
420 EXPECT_TRUE(hidlReturn.isOk());
421 if (halResult == Result::INVALID_STATE) {
422 EXPECT_TRUE(waitForCallback(kConfigCallbacktimeoutNs));
427 * Test ITuner::setConfiguration() and getConfiguration methods
430 * - the HAL implements both methods
431 * - the methods return 0 (no error)
432 * - the configuration callback is received within kConfigCallbacktimeoutNs ns
433 * - the configuration read back from HAl has the same class Id
435 TEST_P(BroadcastRadioHidlTest, SetAndGetConfiguration) {
436 if (radioClass != Class::AM_FM) skipped = true;
438 ASSERT_EQ(true, openTuner());
439 // test setConfiguration
440 mCallbackCalled = false;
441 Return<Result> hidlResult = mTuner->setConfiguration(getBand(1));
442 EXPECT_TRUE(hidlResult.isOk());
443 EXPECT_EQ(Result::OK, hidlResult);
444 EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs));
445 EXPECT_EQ(Result::OK, mResultCallbackData);
446 EXPECT_EQ(getBand(1), mBandConfigCallbackData);
448 // test getConfiguration
449 BandConfig halConfig;
451 Return<void> hidlReturn =
452 mTuner->getConfiguration([&](Result result, const BandConfig& config) {
454 if (result == Result::OK) {
458 EXPECT_TRUE(hidlReturn.isOk());
459 EXPECT_EQ(Result::OK, halResult);
460 EXPECT_EQ(getBand(1), halConfig);
464 * Test ITuner::setConfiguration() with invalid arguments.
467 * - the methods returns INVALID_ARGUMENTS on invalid arguments
468 * - the method recovers and succeeds after passing correct arguments
470 TEST_P(BroadcastRadioHidlTest, SetConfigurationFails) {
471 if (radioClass != Class::AM_FM) skipped = true;
473 ASSERT_EQ(true, openTuner());
475 // Let's define a config that's bad for sure.
476 BandConfig badConfig = {};
477 badConfig.type = Band::FM;
478 badConfig.lowerLimit = 0xFFFFFFFF;
479 badConfig.upperLimit = 0;
480 badConfig.spacings = (std::vector<uint32_t>){ 0 };
482 // Test setConfiguration failing on bad data.
483 mCallbackCalled = false;
484 auto setResult = mTuner->setConfiguration(badConfig);
485 EXPECT_TRUE(setResult.isOk());
486 EXPECT_EQ(Result::INVALID_ARGUMENTS, setResult);
488 // Test setConfiguration recovering after passing good data.
489 mCallbackCalled = false;
490 setResult = mTuner->setConfiguration(getBand(0));
491 EXPECT_TRUE(setResult.isOk());
492 EXPECT_EQ(Result::OK, setResult);
493 EXPECT_EQ(true, waitForCallback(kConfigCallbacktimeoutNs));
494 EXPECT_EQ(Result::OK, mResultCallbackData);
501 * - the HAL implements the method
502 * - the method returns 0 (no error)
503 * - the tuned callback is received within kTuneCallbacktimeoutNs ns
504 * - skipping sub-channel or not does not fail the call
506 TEST_P(BroadcastRadioHidlTest, Scan) {
508 ASSERT_EQ(true, openTuner());
509 ASSERT_TRUE(checkAntenna());
511 mCallbackCalled = false;
512 Return<Result> hidlResult = mTuner->scan(Direction::UP, true);
513 EXPECT_TRUE(hidlResult.isOk());
514 EXPECT_EQ(Result::OK, hidlResult);
515 EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
518 mCallbackCalled = false;
519 hidlResult = mTuner->scan(Direction::DOWN, false);
520 EXPECT_TRUE(hidlResult.isOk());
521 EXPECT_EQ(Result::OK, hidlResult);
522 EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
529 * - the HAL implements the method
530 * - the method returns 0 (no error)
531 * - the tuned callback is received within kTuneCallbacktimeoutNs ns
532 * - skipping sub-channel or not does not fail the call
534 TEST_P(BroadcastRadioHidlTest, Step) {
535 if (radioClass != Class::AM_FM) skipped = true;
537 ASSERT_EQ(true, openTuner());
538 ASSERT_TRUE(checkAntenna());
540 mCallbackCalled = false;
541 Return<Result> hidlResult = mTuner->step(Direction::UP, false);
542 EXPECT_TRUE(hidlResult.isOk());
543 EXPECT_EQ(Result::OK, hidlResult);
544 EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
547 mCallbackCalled = false;
548 hidlResult = mTuner->step(Direction::DOWN, true);
549 EXPECT_TRUE(hidlResult.isOk());
550 EXPECT_EQ(Result::OK, hidlResult);
551 EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
555 * Test ITuner::tune, getProgramInformation and cancel methods
558 * - the HAL implements the methods
559 * - the methods return 0 (no error)
560 * - the tuned callback is received within kTuneCallbacktimeoutNs ns after tune()
562 TEST_P(BroadcastRadioHidlTest, TuneAndGetProgramInformationAndCancel) {
563 if (radioClass != Class::AM_FM) skipped = true;
565 ASSERT_EQ(true, openTuner());
566 ASSERT_TRUE(checkAntenna());
568 auto& band = getBand(0);
571 ASSERT_GT(band.spacings.size(), 0u);
572 ASSERT_GT(band.upperLimit, band.lowerLimit);
575 uint32_t lowerLimit = band.lowerLimit;
576 uint32_t upperLimit = band.upperLimit;
577 uint32_t spacing = band.spacings[0];
580 lowerLimit + (((upperLimit - lowerLimit) / 2 + spacing - 1) / spacing) * spacing;
581 mCallbackCalled = false;
582 mResultCallbackData = Result::NOT_INITIALIZED;
583 Return<Result> hidlResult = mTuner->tune(channel, 0);
584 EXPECT_TRUE(hidlResult.isOk());
585 EXPECT_EQ(Result::OK, hidlResult);
586 EXPECT_EQ(true, waitForCallback(kTuneCallbacktimeoutNs));
587 EXPECT_EQ(channel, mProgramInfoCallbackData.channel);
589 // test getProgramInformation
591 Result halResult = Result::NOT_INITIALIZED;
592 Return<void> hidlReturn = mTuner->getProgramInformation(
593 [&](Result result, const ProgramInfo& info) {
595 if (result == Result::OK) {
599 EXPECT_TRUE(hidlReturn.isOk());
600 EXPECT_EQ(Result::OK, halResult);
601 if (mResultCallbackData == Result::OK) {
602 EXPECT_EQ(true, halInfo.tuned);
603 EXPECT_LE(halInfo.channel, upperLimit);
604 EXPECT_GE(halInfo.channel, lowerLimit);
606 EXPECT_EQ(false, halInfo.tuned);
610 mTuner->tune(lowerLimit, 0);
611 hidlResult = mTuner->cancel();
612 EXPECT_TRUE(hidlResult.isOk());
613 EXPECT_EQ(Result::OK, hidlResult);
617 * Test ITuner::tune failing when channel out of the range is provided.
620 * - the method returns INVALID_ARGUMENTS when applicable
621 * - the method recovers and succeeds after passing correct arguments
623 TEST_P(BroadcastRadioHidlTest, TuneFailsOutOfBounds) {
624 if (radioClass != Class::AM_FM) skipped = true;
626 ASSERT_TRUE(openTuner());
627 ASSERT_TRUE(checkAntenna());
629 // get current channel bounds
630 BandConfig halConfig;
632 auto configResult = mTuner->getConfiguration([&](Result result, const BandConfig& config) {
636 ASSERT_TRUE(configResult.isOk());
637 ASSERT_EQ(Result::OK, halResult);
639 // try to tune slightly above the limit and expect to fail
640 auto badChannel = halConfig.upperLimit + halConfig.spacings[0];
641 auto tuneResult = mTuner->tune(badChannel, 0);
642 EXPECT_TRUE(tuneResult.isOk());
643 EXPECT_EQ(Result::INVALID_ARGUMENTS, tuneResult);
644 EXPECT_TRUE(waitForCallback(kTuneCallbacktimeoutNs));
646 // tuning exactly at the limit should succeed
647 auto goodChannel = halConfig.upperLimit;
648 tuneResult = mTuner->tune(goodChannel, 0);
649 EXPECT_TRUE(tuneResult.isOk());
650 EXPECT_EQ(Result::OK, tuneResult);
651 EXPECT_TRUE(waitForCallback(kTuneCallbacktimeoutNs));
654 INSTANTIATE_TEST_CASE_P(
655 BroadcastRadioHidlTestCases,
656 BroadcastRadioHidlTest,
657 ::testing::Values(Class::AM_FM, Class::SAT, Class::DT));
659 int main(int argc, char** argv) {
660 ::testing::InitGoogleTest(&argc, argv);
661 int status = RUN_ALL_TESTS();
662 ALOGI("Test result = %d", status);