Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 293d67a4 authored by Michal Olech's avatar Michal Olech Committed by Gerrit Code Review
Browse files

Merge changes from topic "vts_cec_10" 

* changes:
  CEC: Add VTS test to get physical address
  CEC: Add methods to get device types
  CEC: Add VTS test to check is connected
  CEC: Add README for VTS tests
  CEC: Add VTS test to enable audio return channel
  CEC: Add VTS test to get port info
  CEC: Add VTS test to set language
  CEC: Add VTS test to set option
  CEC: Add VTS test to send CEC messages
  CEC: Add VTS test to clear and add logical address
  CEC: Add VTS test to get Vendor Id
  CEC: Add VTS test to get CEC version
parents 2175ee28 697a002e

tv/cec/1.0/vts/functional/Android.bp

0 → 100644
+29 −0
Original line number Diff line number Diff line 
//

// Copyright (C) 2021 The Android Open Source Project

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

//      http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

//



cc_test {

    name: "VtsHalTvCecV1_0TargetTest",

    defaults: ["VtsHalTargetTestDefaults"],

    srcs: ["VtsHalTvCecV1_0TargetTest.cpp"],

    static_libs: [

        "android.hardware.tv.cec@1.0",

    ],

    test_suites: [

        "general-tests",

        "vts",

    ],

    disable_framework: true,

}

tv/cec/1.0/vts/functional/README.md

0 → 100644
+30 −0
Original line number Diff line number Diff line 
# CEC VTS testing for Android TV devices



Validate HDMI CEC VTS (android.hardware.tv.cec@1.0) functionality.



### Setup:



Running these CEC VTS tests requires an Android playback, TV or audio device connected to the host machine.



![drawing](setup.png)



### Building



From the Android root folder, after choosing the lunch combo, use `make vts` to build VTS.



### Automation



On the host machine, ensure that the [software requirements](https://codelabs.developers.google.com/codelabs/android-lab/#2) for python SDK are met.



Given the setup described above you can run tests with any of the following commands:



1. Using vts-tradefed :

```

cd $ANDROID_BUILD_TOP/out/host/linux-x86/vts/android-vts/tools

./vts-tradefed run commandAndExit vts -m VtsHalTvCecV1_0TargetTest

```

2. Using atest

```

atest VtsHalTvCecV1_0TargetTest

```

Note : atest internally handles building as well. To update the test use '-c' (clear cache) option

tv/cec/1.0/vts/functional/VtsHalTvCecV1_0TargetTest.cpp

0 → 100644
+209 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2021 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#define LOG_TAG "HdmiCec_hal_test"

#include <android-base/logging.h>



#include <android/hardware/tv/cec/1.0/IHdmiCec.h>

#include <android/hardware/tv/cec/1.0/types.h>

#include <utils/Log.h>

#include <sstream>

#include <vector>



#include <gtest/gtest.h>

#include <hidl/GtestPrinter.h>

#include <hidl/ServiceManagement.h>



using ::android::sp;

using ::android::hardware::hidl_death_recipient;

using ::android::hardware::hidl_vec;

using ::android::hardware::Return;

using ::android::hardware::tv::cec::V1_0::CecDeviceType;

using ::android::hardware::tv::cec::V1_0::CecLogicalAddress;

using ::android::hardware::tv::cec::V1_0::CecMessage;

using ::android::hardware::tv::cec::V1_0::HdmiPortInfo;

using ::android::hardware::tv::cec::V1_0::HdmiPortType;

using ::android::hardware::tv::cec::V1_0::IHdmiCec;

using ::android::hardware::tv::cec::V1_0::OptionKey;

using ::android::hardware::tv::cec::V1_0::Result;

using ::android::hardware::tv::cec::V1_0::SendMessageResult;



#define CEC_VERSION 0x05

#define INCORRECT_VENDOR_ID 0x00

#define TV_PHYSICAL_ADDRESS 0x0000



// The main test class for TV CEC HAL.

class HdmiCecTest : public ::testing::TestWithParam<std::string> {

  public:

    void SetUp() override {

        hdmiCec = IHdmiCec::getService(GetParam());

        ASSERT_NE(hdmiCec, nullptr);

        ALOGI("%s: getService() for hdmiCec is %s", __func__,

              hdmiCec->isRemote() ? "remote" : "local");



        hdmiCec_death_recipient = new HdmiCecDeathRecipient();

        ASSERT_NE(hdmiCec_death_recipient, nullptr);

        ASSERT_TRUE(hdmiCec->linkToDeath(hdmiCec_death_recipient, 0).isOk());

    }



    std::vector<int> getDeviceTypes() {

        std::vector<int> deviceTypes;

        FILE* p = popen("getprop ro.hdmi.device_type", "re");

        if (p) {

            char* line = NULL;

            size_t len = 0;

            if (getline(&line, &len, p) > 0) {

                std::istringstream stream(line);

                std::string number{};

                while (std::getline(stream, number, ',')) {

                    deviceTypes.push_back(stoi(number));

                }

            }

            pclose(p);

        }

        return deviceTypes;

    }



    bool hasDeviceType(CecDeviceType type) {

        std::vector<int> deviceTypes = getDeviceTypes();

        for (auto deviceType = deviceTypes.begin(); deviceType != deviceTypes.end(); ++deviceType) {

            if (*deviceType == (int)type) {

                return true;

            }

        }

        return false;

    }



    class HdmiCecDeathRecipient : public hidl_death_recipient {

      public:

        void serviceDied(uint64_t /*cookie*/,

                         const android::wp<::android::hidl::base::V1_0::IBase>& /*who*/) override {

            FAIL();

        }

    };



    sp<IHdmiCec> hdmiCec;

    sp<HdmiCecDeathRecipient> hdmiCec_death_recipient;

};



GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(HdmiCecTest);

INSTANTIATE_TEST_SUITE_P(

        PerInstance, HdmiCecTest,

        testing::ValuesIn(android::hardware::getAllHalInstanceNames(IHdmiCec::descriptor)),

        android::hardware::PrintInstanceNameToString);



TEST_P(HdmiCecTest, ClearAddLogicalAddress) {

    hdmiCec->clearLogicalAddress();

    Return<Result> ret = hdmiCec->addLogicalAddress(CecLogicalAddress::PLAYBACK_3);

    EXPECT_EQ(ret, Result::SUCCESS);

}



TEST_P(HdmiCecTest, PhysicalAddress) {

    Result result;

    uint16_t addr;

    Return<void> ret = hdmiCec->getPhysicalAddress([&result, &addr](Result res, uint16_t paddr) {

        result = res;

        addr = paddr;

    });

    EXPECT_TRUE(ret.isOk());

    EXPECT_EQ(result, Result::SUCCESS);

    if (!hasDeviceType(CecDeviceType::TV)) {

        EXPECT_NE(addr, TV_PHYSICAL_ADDRESS);

    }

}



TEST_P(HdmiCecTest, SendMessage) {

    CecMessage message;

    message.initiator = CecLogicalAddress::PLAYBACK_1;

    message.destination = CecLogicalAddress::BROADCAST;

    message.body.resize(1);

    message.body[0] = 131;

    SendMessageResult ret = hdmiCec->sendMessage(message);

    EXPECT_EQ(ret, SendMessageResult::SUCCESS);

}



TEST_P(HdmiCecTest, CecVersion) {

    Return<int32_t> ret = hdmiCec->getCecVersion();

    EXPECT_GE(ret, CEC_VERSION);

}



TEST_P(HdmiCecTest, VendorId) {

    Return<uint32_t> ret = hdmiCec->getVendorId();

    EXPECT_NE(ret, INCORRECT_VENDOR_ID);

}



TEST_P(HdmiCecTest, GetPortInfo) {

    hidl_vec<HdmiPortInfo> ports;

    Return<void> ret =

            hdmiCec->getPortInfo([&ports](hidl_vec<HdmiPortInfo> list) { ports = list; });

    EXPECT_TRUE(ret.isOk());

    bool cecSupportedOnDevice = false;

    for (size_t i = 0; i < ports.size(); ++i) {

        EXPECT_TRUE((ports[i].type == HdmiPortType::OUTPUT) ||

                    (ports[i].type == HdmiPortType::INPUT));

        if (ports[i].portId == 0) {

            ALOGW("%s: Port id should start from 1", __func__);

        }

        cecSupportedOnDevice = cecSupportedOnDevice | ports[i].cecSupported;

    }

    EXPECT_NE(cecSupportedOnDevice, false) << "At least one port should support CEC";

}



TEST_P(HdmiCecTest, SetOption) {

    Return<void> ret;

    ret = hdmiCec->setOption(OptionKey::WAKEUP, false);

    EXPECT_TRUE(ret.isOk());

    ret = hdmiCec->setOption(OptionKey::ENABLE_CEC, false);

    EXPECT_TRUE(ret.isOk());

    ret = hdmiCec->setOption(OptionKey::SYSTEM_CEC_CONTROL, true);

    EXPECT_TRUE(ret.isOk());

    // Restore option keys to their default values

    ret = hdmiCec->setOption(OptionKey::WAKEUP, true);

    EXPECT_TRUE(ret.isOk());

    ret = hdmiCec->setOption(OptionKey::ENABLE_CEC, true);

    EXPECT_TRUE(ret.isOk());

    ret = hdmiCec->setOption(OptionKey::SYSTEM_CEC_CONTROL, false);

    EXPECT_TRUE(ret.isOk());

}



TEST_P(HdmiCecTest, SetLanguage) {

    Return<void> ret = hdmiCec->setLanguage("eng");

    EXPECT_TRUE(ret.isOk());

}



TEST_P(HdmiCecTest, EnableAudioReturnChannel) {

    hidl_vec<HdmiPortInfo> ports;

    Return<void> ret =

            hdmiCec->getPortInfo([&ports](hidl_vec<HdmiPortInfo> list) { ports = list; });

    EXPECT_TRUE(ret.isOk());

    for (size_t i = 0; i < ports.size(); ++i) {

        if (ports[i].arcSupported) {

            ret = hdmiCec->enableAudioReturnChannel(ports[i].portId, true);

            EXPECT_TRUE(ret.isOk());

        }

    }

}



TEST_P(HdmiCecTest, IsConnected) {

    hidl_vec<HdmiPortInfo> ports;

    Return<void> ret =

            hdmiCec->getPortInfo([&ports](hidl_vec<HdmiPortInfo> list) { ports = list; });

    EXPECT_TRUE(ret.isOk());

    for (size_t i = 0; i < ports.size(); ++i) {

        Return<bool> ret = hdmiCec->isConnected(ports[i].portId);

        EXPECT_TRUE(ret.isOk());

    }

}

tv/cec/1.0/vts/functional/setup.png

0 → 100644
+12.2 KiB
Loading image diff...