Merge changes from topics "ch_hal_1.1_coral", "contexthub_hal_update" (b9852ce2) · Commits · e / os / android_hardware_interfaces

compatibility_matrices/compatibility_matrix.current.xml

+1 −1

Original line number	Diff line number	Diff line
		@@ -153,7 +153,7 @@
		</hal>
		<hal format="hidl" optional="true">
		<name>android.hardware.contexthub</name>
		<version>1.0</version>
		<version>1.0-1</version>
		<interface>
		<name>IContexthub</name>
		<instance>default</instance>

contexthub/1.0/vts/functional/Android.bp

+4 −1

Original line number	Diff line number	Diff line
		@@ -18,7 +18,10 @@ cc_test {
		name: "VtsHalContexthubV1_0TargetTest",
		defaults: ["VtsHalTargetTestDefaults"],
		srcs: ["VtsHalContexthubV1_0TargetTest.cpp"],
		static_libs: ["android.hardware.contexthub@1.0"],
		static_libs: [
		"android.hardware.contexthub@1.0",
		"VtsHalContexthubUtils",
		],
		test_suites: [
		"general-tests",
		"vts-core",

contexthub/1.0/vts/functional/VtsHalContexthubV1_0TargetTest.cpp

+132 −253

Original line number	Diff line number	Diff line
		@@ -16,6 +16,10 @@

		#define LOG_TAG "contexthub_hidl_hal_test"

		#include "ContexthubCallbackBase.h"
		#include "ContexthubHidlTestBase.h"
		#include "VtsHalContexthubUtils.h"

		#include <android-base/logging.h>
		#include <android/hardware/contexthub/1.0/IContexthub.h>
		#include <android/hardware/contexthub/1.0/IContexthubCallback.h>
		@@ -23,17 +27,17 @@
		#include <android/log.h>
		#include <gtest/gtest.h>
		#include <hidl/GtestPrinter.h>
		#include <hidl/ServiceManagement.h>
		#include <log/log.h>

		#include <cinttypes>
		#include <future>
		#include <utility>

		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::sp;
		using ::android::hardware::hidl_string;
		using ::android::hardware::hidl_vec;
		using ::android::hardware::Return;
		using ::android::hardware::Void;
		using ::android::hardware::contexthub::V1_0::AsyncEventType;
		using ::android::hardware::contexthub::V1_0::ContextHub;
		using ::android::hardware::contexthub::V1_0::ContextHubMsg;
		@@ -43,10 +47,11 @@ using ::android::hardware::contexthub::V1_0::IContexthubCallback;
		using ::android::hardware::contexthub::V1_0::NanoAppBinary;
		using ::android::hardware::contexthub::V1_0::Result;
		using ::android::hardware::contexthub::V1_0::TransactionResult;
		using ::android::sp;

		#define ASSERT_OK(result) ASSERT_EQ(result, Result::OK)
		#define EXPECT_OK(result) EXPECT_EQ(result, Result::OK)
		using ::android::hardware::contexthub::vts_utils::asBaseType;
		using ::android::hardware::contexthub::vts_utils::ContexthubCallbackBase;
		using ::android::hardware::contexthub::vts_utils::ContexthubHidlTestBase;
		using ::android::hardware::contexthub::vts_utils::getHalAndHubIdList;
		using ::android::hardware::contexthub::vts_utils::getHubsSync;

		namespace {

		@@ -54,110 +59,16 @@ namespace {
		// app ID is reserved and must never appear in the list of loaded apps.
		constexpr uint64_t kNonExistentAppId = 0x476f6f6754555555;

		// Helper that does explicit conversion of an enum class to its underlying/base
		// type. Useful for stream output of enum values.
		template<typename EnumType>
		constexpr typename std::underlying_type<EnumType>::type asBaseType(
		EnumType value) {
		return static_cast<typename std::underlying_type<EnumType>::type>(value);
		}

		// Synchronously queries IContexthub::getHubs() and returns the result
		hidl_vec<ContextHub> getHubsSync(sp<IContexthub> hubApi) {
		hidl_vec<ContextHub> hubList;
		std::promise<void> barrier;

		hubApi->getHubs([&hubList, &barrier](const hidl_vec<ContextHub>& hubs) {
		hubList = hubs;
		barrier.set_value();
		});
		barrier.get_future().wait_for(std::chrono::seconds(1));

		return hubList;
		}

		// Gets a list of valid hub IDs in the system
		std::vector<std::string> getHubIds(const std::string& service_name) {
		std::vector<std::string> hubIds;
		const std::vector<std::tuple<std::string, std::string>> kTestParameters =
		getHalAndHubIdList<IContexthub>();

		sp<IContexthub> hubApi = IContexthub::getService(service_name);

		if (hubApi != nullptr) {
		for (const ContextHub& hub : getHubsSync(hubApi)) {
		hubIds.push_back(std::to_string(hub.hubId));
		}
		}

		ALOGD("Running tests against all %zu reported hubs for service %s", hubIds.size(),
		service_name.c_str());
		return hubIds;
		}

		// Test fixture parameterized by hub ID, initializes the HAL and makes the context hub API handle
		// available.
		class ContexthubHidlTest : public ::testing::TestWithParam<std::tuple<std::string, std::string>> {
		public:
		virtual void SetUp() override {
		hubApi = IContexthub::getService(std::get<0>(GetParam()));
		ASSERT_NE(hubApi, nullptr);

		// getHubs() must be called at least once for proper initialization of the
		// HAL implementation
		getHubsSync(hubApi);
		}

		uint32_t getHubId() { return std::stoi(std::get<1>(GetParam())); }

		Result registerCallback(sp<IContexthubCallback> cb) {
		Result result = hubApi->registerCallback(getHubId(), cb);
		ALOGD("Registered callback, result %" PRIu32, result);
		return result;
		}

		sp<IContexthub> hubApi;
		};

		// Base callback implementation that just logs all callbacks by default
		class ContexthubCallbackBase : public IContexthubCallback {
		public:
		virtual Return<void> handleClientMsg(const ContextHubMsg& /msg/) override {
		ALOGD("Got client message callback");
		return Void();
		}

		virtual Return<void> handleTxnResult(
		uint32_t txnId, TransactionResult result) override {
		ALOGD("Got transaction result callback for txnId %" PRIu32 " with result %"
		PRId32, txnId, result);
		return Void();
		}

		virtual Return<void> handleHubEvent(AsyncEventType evt) override {
		ALOGD("Got hub event callback for event type %" PRIu32, evt);
		return Void();
		}

		virtual Return<void> handleAppAbort(uint64_t appId, uint32_t abortCode)
		override {
		ALOGD("Got app abort notification for appId 0x%" PRIx64 " with abort code "
		"0x%" PRIx32, appId, abortCode);
		return Void();
		}

		virtual Return<void> handleAppsInfo(const hidl_vec<HubAppInfo>& /appInfo/)
		override {
		ALOGD("Got app info callback");
		return Void();
		}
		};
		class ContexthubHidlTest : public ContexthubHidlTestBase<IContexthub> {};

		// Wait for a callback to occur (signaled by the given future) up to the
		// provided timeout. If the future is invalid or the callback does not come
		// within the given time, returns false.
		template <class ReturnType>
		bool waitForCallback(
		std::future<ReturnType> future,
		ReturnType *result,
		bool waitForCallback(std::future<ReturnType> future, ReturnType* result,
		std::chrono::milliseconds timeout = std::chrono::seconds(5)) {
		auto expiration = std::chrono::system_clock::now() + timeout;

		@@ -165,8 +76,7 @@ bool waitForCallback(
		EXPECT_TRUE(future.valid());
		if (result != nullptr && future.valid()) {
		std::future_status status = future.wait_until(expiration);
		EXPECT_NE(status, std::future_status::timeout)
		<< "Timed out waiting for callback";
		EXPECT_NE(status, std::future_status::timeout) << "Timed out waiting for callback";

		if (status == std::future_status::ready) {
		*result = future.get();
		@@ -179,7 +89,7 @@ bool waitForCallback(

		// Ensures that the metadata reported in getHubs() is sane
		TEST_P(ContexthubHidlTest, TestGetHubs) {
		hidl_vec<ContextHub> hubs = getHubsSync(hubApi);
		hidl_vec<ContextHub> hubs = getHubsSync(hubApi.get());
		ALOGD("System reports %zu hubs", hubs.size());

		for (const ContextHub& hub : hubs) {
		@@ -211,8 +121,7 @@ TEST_P(ContexthubHidlTest, TestRegisterNullCallback) {
		// Helper callback that puts the async appInfo callback data into a promise
		class QueryAppsCallback : public ContexthubCallbackBase {
		public:
		virtual Return<void> handleAppsInfo(const hidl_vec<HubAppInfo>& appInfo)
		override {
		virtual Return<void> handleAppsInfo(const hidl_vec<HubAppInfo>& appInfo) override {
		ALOGD("Got app info callback with %zu apps", appInfo.size());
		promise.set_value(appInfo);
		return Void();
		@@ -243,10 +152,10 @@ TEST_P(ContexthubHidlTest, TestQueryApps) {
		// promise
		class TxnResultCallback : public ContexthubCallbackBase {
		public:
		virtual Return<void> handleTxnResult(
		uint32_t txnId, TransactionResult result) override {
		ALOGD("Got transaction result callback for txnId %" PRIu32 " (expecting %"
		PRIu32 ") with result %" PRId32, txnId, expectedTxnId, result);
		virtual Return<void> handleTxnResult(uint32_t txnId, TransactionResult result) override {
		ALOGD("Got transaction result callback for txnId %" PRIu32 " (expecting %" PRIu32
		") with result %" PRId32,
		txnId, expectedTxnId, result);
		if (txnId == expectedTxnId) {
		promise.set_value(result);
		}
		@@ -268,22 +177,19 @@ class ContexthubTxnTest : public ContexthubHidlTest {
		sp<TxnResultCallback> cb = new TxnResultCallback();
		};


		// Checks cases where the hub implementation is expected to return an error, but
		// that error can be returned either synchronously or in the asynchronous
		// transaction callback. Returns an AssertionResult that can be used in
		// ASSERT/EXPECT_TRUE. Allows checking the sync result against 1 additional
		// allowed error code apart from OK and TRANSACTION_FAILED, which are always
		// allowed.
		::testing::AssertionResult checkFailureSyncOrAsync(
		Result result, Result allowedSyncResult,
		::testing::AssertionResult checkFailureSyncOrAsync(Result result, Result allowedSyncResult,
		std::future<TransactionResult>&& future) {
		if (result == Result::OK) {
		// No error reported synchronously - this is OK, but then we should get an
		// async callback with a failure status
		TransactionResult asyncResult;
		if (!waitForCallback(std::forward<std::future<TransactionResult>>(future),
		&asyncResult)) {
		if (!waitForCallback(std::forward<std::future<TransactionResult>>(future), &asyncResult)) {
		return ::testing::AssertionFailure()
		<< "Got successful sync result, then failed to receive async cb";
		} else if (asyncResult == TransactionResult::SUCCESS) {
		@@ -291,10 +197,9 @@ class ContexthubTxnTest : public ContexthubHidlTest {
		<< "Got successful sync result, then unexpected successful async "
		"result";
		}
		} else if (result != allowedSyncResult &&
		result != Result::TRANSACTION_FAILED) {
		return ::testing::AssertionFailure() << "Got sync result "
		<< asBaseType(result) << ", expected TRANSACTION_FAILED or "
		} else if (result != allowedSyncResult && result != Result::TRANSACTION_FAILED) {
		return ::testing::AssertionFailure()
		<< "Got sync result " << asBaseType(result) << ", expected TRANSACTION_FAILED or "
		<< asBaseType(allowedSyncResult);
		}

		@@ -310,8 +215,7 @@ TEST_P(ContexthubTxnTest, TestSendMessageToNonExistentNanoApp) {

		ALOGD("Sending message to non-existent nanoapp");
		Result result = hubApi->sendMessageToHub(getHubId(), msg);
		if (result != Result::OK &&
		result != Result::BAD_PARAMS &&
		if (result != Result::OK && result != Result::BAD_PARAMS &&
		result != Result::TRANSACTION_FAILED) {
		FAIL() << "Got result " << asBaseType(result) << ", expected OK, BAD_PARAMS"
		<< ", or TRANSACTION_FAILED";
		@@ -330,58 +234,33 @@ TEST_P(ContexthubTxnTest, TestLoadEmptyNanoApp) {

		ALOGD("Loading empty nanoapp");
		Result result = hubApi->loadNanoApp(getHubId(), emptyApp, cb->expectedTxnId);
		EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS,
		cb->promise.get_future()));
		EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future()));
		}

		TEST_P(ContexthubTxnTest, TestUnloadNonexistentNanoApp) {
		cb->expectedTxnId = 1234;

		ALOGD("Unloading nonexistent nanoapp");
		Result result = hubApi->unloadNanoApp(getHubId(), kNonExistentAppId,
		cb->expectedTxnId);
		EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS,
		cb->promise.get_future()));
		Result result = hubApi->unloadNanoApp(getHubId(), kNonExistentAppId, cb->expectedTxnId);
		EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future()));
		}

		TEST_P(ContexthubTxnTest, TestEnableNonexistentNanoApp) {
		cb->expectedTxnId = 2345;

		ALOGD("Enabling nonexistent nanoapp");
		Result result = hubApi->enableNanoApp(getHubId(), kNonExistentAppId,
		cb->expectedTxnId);
		EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS,
		cb->promise.get_future()));
		Result result = hubApi->enableNanoApp(getHubId(), kNonExistentAppId, cb->expectedTxnId);
		EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future()));
		}

		TEST_P(ContexthubTxnTest, TestDisableNonexistentNanoApp) {
		cb->expectedTxnId = 3456;

		ALOGD("Disabling nonexistent nanoapp");
		Result result = hubApi->disableNanoApp(getHubId(), kNonExistentAppId,
		cb->expectedTxnId);
		EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS,
		cb->promise.get_future()));
		Result result = hubApi->disableNanoApp(getHubId(), kNonExistentAppId, cb->expectedTxnId);
		EXPECT_TRUE(checkFailureSyncOrAsync(result, Result::BAD_PARAMS, cb->promise.get_future()));
		}

		// Return the test parameters of a vecter of tuples for all IContexthub services and each of its hub
		// id: <service name of IContexthub, hub id of the IContexthub service>
		static std::vector<std::tuple<std::string, std::string>> get_parameters() {
		std::vector<std::tuple<std::string, std::string>> parameters;
		std::vector<std::string> service_names =
		android::hardware::getAllHalInstanceNames(IContexthub::descriptor);
		for (const std::string& service_name : service_names) {
		std::vector<std::string> ids = getHubIds(service_name);
		for (const std::string& id : ids) {
		parameters.push_back(std::make_tuple(service_name, id));
		}
		}

		return parameters;
		}

		static std::vector<std::tuple<std::string, std::string>> kTestParameters = get_parameters();

		INSTANTIATE_TEST_SUITE_P(HubIdSpecificTests, ContexthubHidlTest, testing::ValuesIn(kTestParameters),
		android::hardware::PrintInstanceTupleNameToString<>);

contexthub/1.1/vts/functional/Android.bp

0 → 100644

+30 −0

Original line number	Diff line number	Diff line
		//
		// Copyright (C) 2020 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: "VtsHalContexthubV1_1TargetTest",
		defaults: ["VtsHalTargetTestDefaults"],
		srcs: ["VtsHalContexthubV1_1TargetTest.cpp"],
		static_libs: [
		"android.hardware.contexthub@1.0",
		"android.hardware.contexthub@1.1",
		"VtsHalContexthubUtils",
		],
		test_suites: [
		"general-tests",
		"vts-core",
		],
		}

contexthub/1.1/vts/functional/OWNERS

0 → 100644

+8 −0

Original line number	Diff line number	Diff line
		#Context Hub team
		arthuri@google.com
		bduddie@google.com
		stange@google.com

		#VTS team
		dshi@google.com
		trong@google.com