|
|
/*
|
|
|
* Copyright (C) 2017 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 "tv_input_hidl_hal_test"
|
|
|
#include <android-base/logging.h>
|
|
|
|
|
|
#include <android/hardware/tv/input/1.0/ITvInput.h>
|
|
|
#include <android/hardware/tv/input/1.0/ITvInputCallback.h>
|
|
|
#include <android/hardware/tv/input/1.0/types.h>
|
|
|
#include <gtest/gtest.h>
|
|
|
#include <hidl/GtestPrinter.h>
|
|
|
#include <hidl/ServiceManagement.h>
|
|
|
#include <utils/KeyedVector.h>
|
|
|
#include <mutex>
|
|
|
#include <vector>
|
|
|
|
|
|
using ::android::hardware::tv::input::V1_0::ITvInput;
|
|
|
using ::android::hardware::tv::input::V1_0::ITvInputCallback;
|
|
|
using ::android::hardware::tv::input::V1_0::Result;
|
|
|
using ::android::hardware::tv::input::V1_0::TvInputType;
|
|
|
using ::android::hardware::tv::input::V1_0::TvInputDeviceInfo;
|
|
|
using ::android::hardware::tv::input::V1_0::TvInputEventType;
|
|
|
using ::android::hardware::tv::input::V1_0::TvInputEvent;
|
|
|
using ::android::hardware::tv::input::V1_0::TvStreamConfig;
|
|
|
using ::android::hardware::Return;
|
|
|
using ::android::hardware::Void;
|
|
|
using ::android::hardware::hidl_vec;
|
|
|
using ::android::sp;
|
|
|
|
|
|
#define WAIT_FOR_EVENT_TIMEOUT 5
|
|
|
#define DEFAULT_ID INT32_MIN
|
|
|
|
|
|
/* The main test class for TV Input HIDL HAL. */
|
|
|
class TvInputHidlTest : public testing::TestWithParam<std::string> {
|
|
|
public:
|
|
|
virtual void SetUp() override {
|
|
|
tv_input_ = ITvInput::getService(GetParam());
|
|
|
tv_input_callback_ = new TvInputCallback(*this);
|
|
|
ASSERT_NE(tv_input_callback_, nullptr);
|
|
|
tv_input_->setCallback(tv_input_callback_);
|
|
|
// All events received within the timeout should be handled.
|
|
|
sleep(WAIT_FOR_EVENT_TIMEOUT);
|
|
|
}
|
|
|
|
|
|
virtual void TearDown() override {}
|
|
|
|
|
|
/* Called when a DEVICE_AVAILABLE event is received. */
|
|
|
void onDeviceAvailable(const TvInputDeviceInfo& deviceInfo) {
|
|
|
device_info_.add(deviceInfo.deviceId, deviceInfo);
|
|
|
}
|
|
|
|
|
|
/* Called when a DEVICE_UNAVAILABLE event is received. */
|
|
|
void onDeviceUnavailable(int32_t deviceId) { device_info_.removeItem(deviceId); }
|
|
|
|
|
|
/* Called when a DEVICE_CONFIGURATIONS_CHANGED event is received. */
|
|
|
Result onStreamConfigurationsChanged(int32_t deviceId) {
|
|
|
return updateStreamConfigurations(deviceId);
|
|
|
}
|
|
|
|
|
|
/* Gets and updates the stream configurations for a device. */
|
|
|
Result updateStreamConfigurations(int32_t deviceId) {
|
|
|
stream_config_.removeItem(deviceId);
|
|
|
Result result = Result::UNKNOWN;
|
|
|
hidl_vec<TvStreamConfig> list;
|
|
|
tv_input_->getStreamConfigurations(
|
|
|
deviceId, [&result, &list](Result res, hidl_vec<TvStreamConfig> configs) {
|
|
|
result = res;
|
|
|
if (res == Result::OK) {
|
|
|
list = configs;
|
|
|
}
|
|
|
});
|
|
|
if (result == Result::OK) {
|
|
|
stream_config_.add(deviceId, list);
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/* Gets and updates the stream configurations for all existing devices. */
|
|
|
void updateAllStreamConfigurations() {
|
|
|
for (size_t i = 0; i < device_info_.size(); i++) {
|
|
|
int32_t device_id = device_info_.keyAt(i);
|
|
|
updateStreamConfigurations(device_id);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/* Returns a list of indices of stream_config_ whose corresponding values are not empty. */
|
|
|
std::vector<size_t> getConfigIndices() {
|
|
|
std::vector<size_t> indices;
|
|
|
for (size_t i = 0; i < stream_config_.size(); i++) {
|
|
|
if (stream_config_.valueAt(i).size() != 0) {
|
|
|
indices.push_back(i);
|
|
|
}
|
|
|
}
|
|
|
return indices;
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* Returns DEFAULT_ID if there is no missing integer in the range [0, the size of nums).
|
|
|
* Otherwise, returns the smallest missing non-negative integer.
|
|
|
*/
|
|
|
int32_t getNumNotIn(std::vector<int32_t>& nums) {
|
|
|
int32_t result = DEFAULT_ID;
|
|
|
int32_t size = static_cast<int32_t>(nums.size());
|
|
|
for (int32_t i = 0; i < size; i++) {
|
|
|
// Put every element to its target position, if possible.
|
|
|
int32_t target_pos = nums[i];
|
|
|
while (target_pos >= 0 && target_pos < size && i != target_pos &&
|
|
|
nums[i] != nums[target_pos]) {
|
|
|
std::swap(nums[i], nums[target_pos]);
|
|
|
target_pos = nums[i];
|
|
|
}
|
|
|
}
|
|
|
|
|
|
for (int32_t i = 0; i < size; i++) {
|
|
|
if (nums[i] != i) {
|
|
|
return i;
|
|
|
}
|
|
|
}
|
|
|
return result;
|
|
|
}
|
|
|
|
|
|
/* A simple test implementation of TvInputCallback for TV Input Events. */
|
|
|
class TvInputCallback : public ITvInputCallback {
|
|
|
public:
|
|
|
TvInputCallback(TvInputHidlTest& parent) : parent_(parent){};
|
|
|
|
|
|
virtual ~TvInputCallback() = default;
|
|
|
|
|
|
/*
|
|
|
* Notifies the client that an event has occurred. For possible event types,
|
|
|
* check TvInputEventType.
|
|
|
*/
|
|
|
Return<void> notify(const TvInputEvent& event) override {
|
|
|
std::unique_lock<std::mutex> lock(parent_.mutex_);
|
|
|
switch (event.type) {
|
|
|
case TvInputEventType::DEVICE_AVAILABLE:
|
|
|
parent_.onDeviceAvailable(event.deviceInfo);
|
|
|
break;
|
|
|
case TvInputEventType::DEVICE_UNAVAILABLE:
|
|
|
parent_.onDeviceUnavailable(event.deviceInfo.deviceId);
|
|
|
break;
|
|
|
case TvInputEventType::STREAM_CONFIGURATIONS_CHANGED:
|
|
|
parent_.onStreamConfigurationsChanged(event.deviceInfo.deviceId);
|
|
|
break;
|
|
|
}
|
|
|
return Void();
|
|
|
};
|
|
|
|
|
|
private:
|
|
|
/* The test contains this callback instance. */
|
|
|
TvInputHidlTest& parent_;
|
|
|
};
|
|
|
|
|
|
/* The TvInput used for the test. */
|
|
|
sp<ITvInput> tv_input_;
|
|
|
|
|
|
/* The TvInputCallback used for the test. */
|
|
|
sp<ITvInputCallback> tv_input_callback_;
|
|
|
|
|
|
/*
|
|
|
* A KeyedVector stores device information of every available device.
|
|
|
* A key is a device ID and the corresponding value is the TvInputDeviceInfo.
|
|
|
*/
|
|
|
android::KeyedVector<int32_t, TvInputDeviceInfo> device_info_;
|
|
|
|
|
|
/*
|
|
|
* A KeyedVector stores a list of stream configurations of every available device.
|
|
|
* A key is a device ID and the corresponding value is the stream configuration list.
|
|
|
*/
|
|
|
android::KeyedVector<int32_t, hidl_vec<TvStreamConfig>> stream_config_;
|
|
|
|
|
|
/* The mutex controls the access of shared data. */
|
|
|
std::mutex mutex_;
|
|
|
};
|
|
|
|
|
|
/*
|
|
|
* GetStreamConfigTest:
|
|
|
* Calls updateStreamConfigurations() for each existing device
|
|
|
* Checks returned results
|
|
|
*/
|
|
|
TEST_P(TvInputHidlTest, GetStreamConfigTest) {
|
|
|
std::unique_lock<std::mutex> lock(mutex_);
|
|
|
for (size_t i = 0; i < device_info_.size(); i++) {
|
|
|
int32_t device_id = device_info_.keyAt(i);
|
|
|
Result result = updateStreamConfigurations(device_id);
|
|
|
EXPECT_EQ(Result::OK, result);
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* OpenAndCloseStreamTest:
|
|
|
* Calls openStream() and then closeStream() for each existing stream
|
|
|
* Checks returned results
|
|
|
*/
|
|
|
TEST_P(TvInputHidlTest, OpenAndCloseStreamTest) {
|
|
|
std::unique_lock<std::mutex> lock(mutex_);
|
|
|
updateAllStreamConfigurations();
|
|
|
for (size_t j = 0; j < stream_config_.size(); j++) {
|
|
|
int32_t device_id = stream_config_.keyAt(j);
|
|
|
hidl_vec<TvStreamConfig> config = stream_config_.valueAt(j);
|
|
|
for (size_t i = 0; i < config.size(); i++) {
|
|
|
Result result = Result::UNKNOWN;
|
|
|
int32_t stream_id = config[i].streamId;
|
|
|
tv_input_->openStream(device_id, stream_id,
|
|
|
[&result](Result res, const native_handle_t*) { result = res; });
|
|
|
EXPECT_EQ(Result::OK, result);
|
|
|
|
|
|
result = Result::UNKNOWN;
|
|
|
result = tv_input_->closeStream(device_id, stream_id);
|
|
|
EXPECT_EQ(Result::OK, result);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* InvalidDeviceIdTest:
|
|
|
* Calls updateStreamConfigurations(), openStream(), and closeStream()
|
|
|
* for a non-existing device
|
|
|
* Checks returned results
|
|
|
* The results should be Result::INVALID_ARGUMENTS
|
|
|
*/
|
|
|
TEST_P(TvInputHidlTest, InvalidDeviceIdTest) {
|
|
|
std::unique_lock<std::mutex> lock(mutex_);
|
|
|
|
|
|
std::vector<int32_t> device_ids;
|
|
|
for (size_t i = 0; i < device_info_.size(); i++) {
|
|
|
device_ids.push_back(device_info_.keyAt(i));
|
|
|
}
|
|
|
// Get a non-existing device ID.
|
|
|
int32_t id = getNumNotIn(device_ids);
|
|
|
EXPECT_EQ(Result::INVALID_ARGUMENTS, updateStreamConfigurations(id));
|
|
|
|
|
|
Result result = Result::UNKNOWN;
|
|
|
int32_t stream_id = 0;
|
|
|
tv_input_->openStream(id, stream_id,
|
|
|
[&result](Result res, const native_handle_t*) { result = res; });
|
|
|
EXPECT_EQ(Result::INVALID_ARGUMENTS, result);
|
|
|
|
|
|
result = Result::UNKNOWN;
|
|
|
result = tv_input_->closeStream(id, stream_id);
|
|
|
EXPECT_EQ(Result::INVALID_ARGUMENTS, result);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* InvalidStreamIdTest:
|
|
|
* Calls openStream(), and closeStream() for a non-existing stream
|
|
|
* Checks returned results
|
|
|
* The results should be Result::INVALID_ARGUMENTS
|
|
|
*/
|
|
|
TEST_P(TvInputHidlTest, InvalidStreamIdTest) {
|
|
|
std::unique_lock<std::mutex> lock(mutex_);
|
|
|
if (device_info_.isEmpty()) {
|
|
|
return;
|
|
|
}
|
|
|
updateAllStreamConfigurations();
|
|
|
|
|
|
int32_t device_id = device_info_.keyAt(0);
|
|
|
// Get a non-existing stream ID.
|
|
|
int32_t id = DEFAULT_ID;
|
|
|
if (stream_config_.indexOfKey(device_id) >= 0) {
|
|
|
std::vector<int32_t> stream_ids;
|
|
|
hidl_vec<TvStreamConfig> config = stream_config_.valueFor(device_id);
|
|
|
for (size_t i = 0; i < config.size(); i++) {
|
|
|
stream_ids.push_back(config[i].streamId);
|
|
|
}
|
|
|
id = getNumNotIn(stream_ids);
|
|
|
}
|
|
|
|
|
|
Result result = Result::UNKNOWN;
|
|
|
tv_input_->openStream(device_id, id,
|
|
|
[&result](Result res, const native_handle_t*) { result = res; });
|
|
|
EXPECT_EQ(Result::INVALID_ARGUMENTS, result);
|
|
|
|
|
|
result = Result::UNKNOWN;
|
|
|
result = tv_input_->closeStream(device_id, id);
|
|
|
EXPECT_EQ(Result::INVALID_ARGUMENTS, result);
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* OpenAnOpenedStreamsTest:
|
|
|
* Calls openStream() twice for a stream (if any)
|
|
|
* Checks returned results
|
|
|
* The result of the second call should be Result::INVALID_STATE
|
|
|
*/
|
|
|
TEST_P(TvInputHidlTest, OpenAnOpenedStreamsTest) {
|
|
|
std::unique_lock<std::mutex> lock(mutex_);
|
|
|
updateAllStreamConfigurations();
|
|
|
std::vector<size_t> indices = getConfigIndices();
|
|
|
if (indices.empty()) {
|
|
|
return;
|
|
|
}
|
|
|
int32_t device_id = stream_config_.keyAt(indices[0]);
|
|
|
int32_t stream_id = stream_config_.valueAt(indices[0])[0].streamId;
|
|
|
|
|
|
Result result = Result::UNKNOWN;
|
|
|
tv_input_->openStream(device_id, stream_id,
|
|
|
[&result](Result res, const native_handle_t*) { result = res; });
|
|
|
EXPECT_EQ(Result::OK, result);
|
|
|
|
|
|
tv_input_->openStream(device_id, stream_id,
|
|
|
[&result](Result res, const native_handle_t*) { result = res; });
|
|
|
EXPECT_EQ(Result::INVALID_STATE, result);
|
|
|
|
|
|
// close stream as subsequent tests assume no open streams
|
|
|
EXPECT_EQ(Result::OK, tv_input_->closeStream(device_id, stream_id));
|
|
|
}
|
|
|
|
|
|
/*
|
|
|
* CloseStreamBeforeOpenTest:
|
|
|
* Calls closeStream() without calling openStream() for a stream (if any)
|
|
|
* Checks the returned result
|
|
|
* The result should be Result::INVALID_STATE
|
|
|
*/
|
|
|
TEST_P(TvInputHidlTest, CloseStreamBeforeOpenTest) {
|
|
|
std::unique_lock<std::mutex> lock(mutex_);
|
|
|
updateAllStreamConfigurations();
|
|
|
std::vector<size_t> indices = getConfigIndices();
|
|
|
if (indices.empty()) {
|
|
|
return;
|
|
|
}
|
|
|
int32_t device_id = stream_config_.keyAt(indices[0]);
|
|
|
int32_t stream_id = stream_config_.valueAt(indices[0])[0].streamId;
|
|
|
EXPECT_EQ(Result::INVALID_STATE, tv_input_->closeStream(device_id, stream_id));
|
|
|
}
|
|
|
|
|
|
INSTANTIATE_TEST_SUITE_P(
|
|
|
PerInstance, TvInputHidlTest,
|
|
|
testing::ValuesIn(android::hardware::getAllHalInstanceNames(ITvInput::descriptor)),
|
|
|
android::hardware::PrintInstanceNameToString);
|
|
|
|
|
|
// TODO remove from the allow list once the cf tv target is enabled for testing
|
|
|
GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(TvInputHidlTest);
|
