Snap for 8107456 from 66a8c97891c7dc3c48593a2792bb32bd5b6d23e9 to tm-d1-release (0dbabe27) · Commits · e / os / android_hardware_interfaces

automotive/vehicle/2.0/default/impl/vhal_v2_0/proto/VehicleHalProto.proto

deleted100644 → 0

+0 −110

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 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.
		*/

		syntax = "proto2";

		package vhal_proto;

		// CMD messages are from workstation --> VHAL
		// RESP messages are from VHAL --> workstation
		enum MsgType {
		GET_CONFIG_CMD = 0;
		GET_CONFIG_RESP = 1;
		GET_CONFIG_ALL_CMD = 2;
		GET_CONFIG_ALL_RESP = 3;
		GET_PROPERTY_CMD = 4;
		GET_PROPERTY_RESP = 5;
		GET_PROPERTY_ALL_CMD = 6;
		GET_PROPERTY_ALL_RESP = 7;
		SET_PROPERTY_CMD = 8;
		SET_PROPERTY_RESP = 9;
		SET_PROPERTY_ASYNC = 10;
		DEBUG_CMD = 11;
		DEBUG_RESP = 12;
		}
		enum Status {
		RESULT_OK = 0;
		ERROR_UNKNOWN = 1;
		ERROR_UNIMPLEMENTED_CMD = 2;
		ERROR_INVALID_PROPERTY = 3;
		ERROR_INVALID_AREA_ID = 4;
		ERROR_PROPERTY_UNINITIALIZED = 5;
		ERROR_WRITE_ONLY_PROPERTY = 6;
		ERROR_MEMORY_ALLOC_FAILED = 7;
		ERROR_INVALID_OPERATION = 8;
		}

		enum VehiclePropStatus {
		AVAILABLE = 0;
		UNAVAILABLE = 1;
		ERROR = 2;
		}

		message VehicleAreaConfig {
		required int32 area_id = 1;
		optional sint32 min_int32_value = 2;
		optional sint32 max_int32_value = 3;
		optional sint64 min_int64_value = 4;
		optional sint64 max_int64_value = 5;
		optional float min_float_value = 6;
		optional float max_float_value = 7;
		}

		message VehiclePropConfig {
		required int32 prop = 1;
		optional int32 access = 2;
		optional int32 change_mode = 3;
		optional int32 value_type = 4;
		optional int32 supported_areas = 5; // Deprecated - DO NOT USE
		repeated VehicleAreaConfig area_configs = 6;
		optional int32 config_flags = 7;
		repeated int32 config_array = 8;
		optional string config_string = 9;
		optional float min_sample_rate = 10;
		optional float max_sample_rate = 11;
		};

		message VehiclePropValue {
		// common data
		required int32 prop = 1;
		optional int32 value_type = 2;
		optional int64 timestamp = 3; // required for valid data from HAL, skipped for set
		optional VehiclePropStatus status = 10; // required for valid data from HAL, skipped for set

		// values
		optional int32 area_id = 4;
		repeated sint32 int32_values = 5; // this also covers boolean value.
		repeated sint64 int64_values = 6;
		repeated float float_values = 7;
		optional string string_value = 8;
		optional bytes bytes_value = 9;
		};

		// This structure is used to notify what values to get from the Vehicle HAL
		message VehiclePropGet {
		required int32 prop = 1;
		optional int32 area_id = 2;
		};

		message EmulatorMessage {
		required MsgType msg_type = 1;
		optional Status status = 2; // Only for RESP messages
		repeated VehiclePropGet prop = 3; // Provided for getConfig, getProperty commands
		repeated VehiclePropConfig config = 4;
		repeated VehiclePropValue value = 5;
		repeated string debug_commands = 6; // Required for debug command
		optional string debug_result = 7; // Required for debug RESP messages
		};

automotive/vehicle/aidl/impl/fake_impl/hardware/include/FakeVehicleHardware.h

+43 −4

Original line number	Diff line number	Diff line
		@@ -23,7 +23,9 @@
		#include <IVehicleHardware.h>
		#include <VehicleHalTypes.h>
		#include <VehiclePropertyStore.h>
		#include <android-base/parseint.h>
		#include <android-base/result.h>
		#include <android-base/stringprintf.h>
		#include <android-base/thread_annotations.h>

		#include <map>
		@@ -37,7 +39,7 @@ namespace automotive {
		namespace vehicle {
		namespace fake {

		class FakeVehicleHardware final : public IVehicleHardware {
		class FakeVehicleHardware : public IVehicleHardware {
		public:
		FakeVehicleHardware();

		@@ -78,13 +80,21 @@ class FakeVehicleHardware final : public IVehicleHardware {
		void registerOnPropertySetErrorEvent(
		std::unique_ptr<const PropertySetErrorCallback> callback) override;

		protected:
		// mValuePool is also used in mServerSidePropStore.
		const std::shared_ptr<VehiclePropValuePool> mValuePool;
		const std::shared_ptr<VehiclePropertyStore> mServerSidePropStore;

		::android::base::Result<VehiclePropValuePool::RecyclableType> getValue(
		const ::aidl::android::hardware::automotive::vehicle::VehiclePropValue& value) const;

		::android::base::Result<void> setValue(
		const ::aidl::android::hardware::automotive::vehicle::VehiclePropValue& value);

		private:
		// Expose private methods to unit test.
		friend class FakeVehicleHardwareTestHelper;

		// mValuePool is also used in mServerSidePropStore.
		const std::shared_ptr<VehiclePropValuePool> mValuePool;
		const std::shared_ptr<VehiclePropertyStore> mServerSidePropStore;
		const std::unique_ptr<obd2frame::FakeObd2Frame> mFakeObd2Frame;
		const std::unique_ptr<FakeUserHal> mFakeUserHal;
		std::mutex mCallbackLock;
		@@ -120,6 +130,35 @@ class FakeVehicleHardware final : public IVehicleHardware {
		::android::base::Result<VehiclePropValuePool::RecyclableType> getUserHalProp(
		const ::aidl::android::hardware::automotive::vehicle::VehiclePropValue& value) const;
		bool isHvacPropAndHvacNotAvailable(int32_t propId);

		std::string dumpAllProperties();
		std::string dumpOnePropertyByConfig(
		int rowNumber,
		const ::aidl::android::hardware::automotive::vehicle::VehiclePropConfig& config);
		std::string dumpOnePropertyById(int32_t propId, int32_t areaId);
		std::string dumpHelp();
		std::string dumpListProperties();
		std::string dumpSpecificProperty(const std::vector<std::string>& options);
		std::string dumpSetProperties(const std::vector<std::string>& options);

		template <typename T>
		::android::base::Result<T> safelyParseInt(int index, const std::string& s) {
		T out;
		if (!::android::base::ParseInt(s, &out)) {
		return ::android::base::Error() << ::android::base::StringPrintf(
		"non-integer argument at index %d: %s\n", index, s.c_str());
		}
		return out;
		}
		::android::base::Result<float> safelyParseFloat(int index, const std::string& s);
		std::vector<std::string> getOptionValues(const std::vector<std::string>& options,
		size_t* index);
		::android::base::Result<::aidl::android::hardware::automotive::vehicle::VehiclePropValue>
		parseSetPropOptions(const std::vector<std::string>& options);
		::android::base::Result<std::vector<uint8_t>> parseHexString(const std::string& s);

		::android::base::Result<void> checkArgumentsSize(const std::vector<std::string>& options,
		size_t minSize);
		};

		} // namespace fake

automotive/vehicle/aidl/impl/fake_impl/hardware/src/FakeVehicleHardware.cpp

+423 −57

File changed.

Preview size limit exceeded, changes collapsed.

automotive/vehicle/aidl/impl/fake_impl/hardware/test/FakeVehicleHardwareTest.cpp

+259 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@

		#include <android-base/expected.h>
		#include <android-base/file.h>
		#include <android-base/stringprintf.h>
		#include <gmock/gmock.h>
		#include <gtest/gtest.h>
		#include <utils/Log.h>
		@@ -52,13 +53,16 @@ using ::aidl::android::hardware::automotive::vehicle::VehicleProperty;
		using ::aidl::android::hardware::automotive::vehicle::VehiclePropertyStatus;
		using ::aidl::android::hardware::automotive::vehicle::VehiclePropValue;
		using ::android::base::expected;
		using ::android::base::StringPrintf;
		using ::android::base::unexpected;
		using ::testing::ContainerEq;
		using ::testing::ContainsRegex;
		using ::testing::Eq;
		using ::testing::IsSubsetOf;
		using ::testing::WhenSortedBy;

		constexpr int INVALID_PROP_ID = 0;
		constexpr char CAR_MAKE[] = "Default Car";

		} // namespace

		@@ -1203,6 +1207,261 @@ TEST_F(FakeVehicleHardwareTest, testInitialUserInfo) {
		}));
		}

		TEST_F(FakeVehicleHardwareTest, testDumpAllProperties) {
		std::vector<std::string> options;
		DumpResult result = getHardware()->dump(options);
		ASSERT_TRUE(result.callerShouldDumpState);
		ASSERT_NE(result.buffer, "");
		ASSERT_THAT(result.buffer, ContainsRegex("dumping .+ properties"));
		}

		TEST_F(FakeVehicleHardwareTest, testDumpHelp) {
		std::vector<std::string> options;
		options.push_back("--help");
		DumpResult result = getHardware()->dump(options);
		ASSERT_FALSE(result.callerShouldDumpState);
		ASSERT_NE(result.buffer, "");
		ASSERT_THAT(result.buffer, ContainsRegex("Usage: "));
		}

		TEST_F(FakeVehicleHardwareTest, testDumpListProperties) {
		std::vector<std::string> options;
		options.push_back("--list");
		DumpResult result = getHardware()->dump(options);
		ASSERT_FALSE(result.callerShouldDumpState);
		ASSERT_NE(result.buffer, "");
		ASSERT_THAT(result.buffer, ContainsRegex("listing .+ properties"));
		}

		TEST_F(FakeVehicleHardwareTest, testDumpSpecificProperties) {
		std::vector<std::string> options;
		options.push_back("--get");
		std::string prop1 = std::to_string(toInt(VehicleProperty::INFO_FUEL_CAPACITY));
		std::string prop2 = std::to_string(toInt(VehicleProperty::TIRE_PRESSURE));
		options.push_back(prop1);
		options.push_back(prop2);
		DumpResult result = getHardware()->dump(options);
		ASSERT_FALSE(result.callerShouldDumpState);
		ASSERT_NE(result.buffer, "");
		ASSERT_THAT(result.buffer,
		ContainsRegex(StringPrintf("1:.prop: %s.\n2-0:.prop: %s.\n2-1:.prop: %s.\n",
		prop1.c_str(), prop2.c_str(), prop2.c_str())));
		}

		TEST_F(FakeVehicleHardwareTest, testDumpSpecificPropertiesInvalidProp) {
		std::vector<std::string> options;
		options.push_back("--get");
		std::string prop1 = std::to_string(toInt(VehicleProperty::INFO_FUEL_CAPACITY));
		std::string prop2 = std::to_string(INVALID_PROP_ID);
		options.push_back(prop1);
		options.push_back(prop2);
		DumpResult result = getHardware()->dump(options);
		ASSERT_FALSE(result.callerShouldDumpState);
		ASSERT_NE(result.buffer, "");
		ASSERT_THAT(result.buffer, ContainsRegex(StringPrintf("1:.prop: %s.\nNo property %d\n",
		prop1.c_str(), INVALID_PROP_ID)));
		}

		TEST_F(FakeVehicleHardwareTest, testDumpSpecificPropertiesNoArg) {
		std::vector<std::string> options;
		options.push_back("--get");

		// No arguments.
		DumpResult result = getHardware()->dump(options);
		ASSERT_FALSE(result.callerShouldDumpState);
		ASSERT_NE(result.buffer, "");
		ASSERT_THAT(result.buffer, ContainsRegex("Invalid number of arguments"));
		}

		TEST_F(FakeVehicleHardwareTest, testDumpInvalidOptions) {
		std::vector<std::string> options;
		options.push_back("--invalid");

		DumpResult result = getHardware()->dump(options);
		ASSERT_FALSE(result.callerShouldDumpState);
		ASSERT_NE(result.buffer, "");
		ASSERT_THAT(result.buffer, ContainsRegex("Invalid option: --invalid"));
		}

		struct SetPropTestCase {
		std::string test_name;
		std::vector<std::string> options;
		bool success;
		std::string errorMsg = "";
		};

		class FakeVehicleHardwareSetPropTest : public FakeVehicleHardwareTest,
		public testing::WithParamInterface<SetPropTestCase> {};

		TEST_P(FakeVehicleHardwareSetPropTest, cmdSetOneProperty) {
		const SetPropTestCase& tc = GetParam();

		DumpResult result = getHardware()->dump(tc.options);
		ASSERT_FALSE(result.callerShouldDumpState);
		ASSERT_NE(result.buffer, "");
		if (tc.success) {
		ASSERT_THAT(result.buffer, ContainsRegex("Set property:"));
		} else {
		ASSERT_THAT(result.buffer, ContainsRegex(tc.errorMsg));
		}
		}

		std::vector<SetPropTestCase> GenSetPropParams() {
		std::string infoMakeProperty = std::to_string(toInt(VehicleProperty::INFO_MAKE));
		return {
		{"success_set_string", {"--set", infoMakeProperty, "-s", CAR_MAKE}, true},
		{"success_set_bytes", {"--set", infoMakeProperty, "-b", "0xdeadbeef"}, true},
		{"success_set_bytes_caps", {"--set", infoMakeProperty, "-b", "0xDEADBEEF"}, true},
		{"success_set_int", {"--set", infoMakeProperty, "-i", "2147483647"}, true},
		{"success_set_ints",
		{"--set", infoMakeProperty, "-i", "2147483647", "0", "-2147483648"},
		true},
		{"success_set_int64",
		{"--set", infoMakeProperty, "-i64", "-9223372036854775808"},
		true},
		{"success_set_int64s",
		{"--set", infoMakeProperty, "-i64", "-9223372036854775808", "0",
		"9223372036854775807"},
		true},
		{"success_set_float", {"--set", infoMakeProperty, "-f", "1.175494351E-38"}, true},
		{"success_set_floats",
		{"--set", infoMakeProperty, "-f", "-3.402823466E+38", "0", "3.402823466E+38"},
		true},
		{"success_set_area", {"--set", infoMakeProperty, "-a", "2147483647"}, true},
		{"fail_no_options", {"--set", infoMakeProperty}, false, "Invalid number of arguments"},
		{"fail_less_than_4_options",
		{"--set", infoMakeProperty, "-i"},
		false,
		"No values specified"},
		{"fail_unknown_options", {"--set", infoMakeProperty, "-abcd"}, false, "Unknown option"},
		{"fail_invalid_property",
		{"--set", "not valid", "-s", CAR_MAKE},
		false,
		"not a valid int"},
		{"fail_duplicate_string",
		{"--set", infoMakeProperty, "-s", CAR_MAKE, "-s", CAR_MAKE},
		false,
		"Duplicate \"-s\" options"},
		{"fail_multiple_strings",
		{"--set", infoMakeProperty, "-s", CAR_MAKE, CAR_MAKE},
		false,
		"Expect exact one value"},
		{"fail_no_string_value",
		{"--set", infoMakeProperty, "-s", "-a", "1234"},
		false,
		"Expect exact one value"},
		{"fail_duplicate_bytes",
		{"--set", infoMakeProperty, "-b", "0xdeadbeef", "-b", "0xdeadbeef"},
		false,
		"Duplicate \"-b\" options"},
		{"fail_multiple_bytes",
		{"--set", infoMakeProperty, "-b", "0xdeadbeef", "0xdeadbeef"},
		false,
		"Expect exact one value"},
		{"fail_invalid_bytes",
		{"--set", infoMakeProperty, "-b", "0xgood"},
		false,
		"not a valid hex string"},
		{"fail_invalid_bytes_no_prefix",
		{"--set", infoMakeProperty, "-b", "deadbeef"},
		false,
		"not a valid hex string"},
		{"fail_invalid_int",
		{"--set", infoMakeProperty, "-i", "abc"},
		false,
		"not a valid int"},
		{"fail_int_out_of_range",
		{"--set", infoMakeProperty, "-i", "2147483648"},
		false,
		"not a valid int"},
		{"fail_no_int_value",
		{"--set", infoMakeProperty, "-i", "-s", CAR_MAKE},
		false,
		"No values specified"},
		{"fail_invalid_int64",
		{"--set", infoMakeProperty, "-i64", "abc"},
		false,
		"not a valid int64"},
		{"fail_int64_out_of_range",
		{"--set", infoMakeProperty, "-i64", "-9223372036854775809"},
		false,
		"not a valid int64"},
		{"fail_no_int64_value",
		{"--set", infoMakeProperty, "-i64", "-s", CAR_MAKE},
		false,
		"No values specified"},
		{"fail_invalid_float",
		{"--set", infoMakeProperty, "-f", "abc"},
		false,
		"not a valid float"},
		{"fail_float_out_of_range",
		{"--set", infoMakeProperty, "-f", "-3.402823466E+39"},
		false,
		"not a valid float"},
		{"fail_no_float_value",
		{"--set", infoMakeProperty, "-f", "-s", CAR_MAKE},
		false,
		"No values specified"},
		{"fail_multiple_areas",
		{"--set", infoMakeProperty, "-a", "2147483648", "0"},
		false,
		"Expect exact one value"},
		{"fail_invalid_area",
		{"--set", infoMakeProperty, "-a", "abc"},
		false,
		"not a valid int"},
		{"fail_area_out_of_range",
		{"--set", infoMakeProperty, "-a", "2147483648"},
		false,
		"not a valid int"},
		{"fail_no_area_value",
		{"--set", infoMakeProperty, "-a", "-s", CAR_MAKE},
		false,
		"Expect exact one value"},
		};
		}

		INSTANTIATE_TEST_SUITE_P(
		FakeVehicleHardwareSetPropTests, FakeVehicleHardwareSetPropTest,
		testing::ValuesIn(GenSetPropParams()),
		[](const testing::TestParamInfo<FakeVehicleHardwareSetPropTest::ParamType>& info) {
		return info.param.test_name;
		});

		TEST_F(FakeVehicleHardwareTest, SetComplexPropTest) {
		std::string infoMakeProperty = std::to_string(toInt(VehicleProperty::INFO_MAKE));
		getHardware()->dump({"--set", infoMakeProperty, "-s", CAR_MAKE,
		"-b", "0xdeadbeef", "-i", "2147483647",
		"0", "-2147483648", "-i64", "-9223372036854775808",
		"0", "9223372036854775807", "-f", "-3.402823466E+38",
		"0", "3.402823466E+38", "-a", "123"});
		VehiclePropValue requestProp;
		requestProp.prop = toInt(VehicleProperty::INFO_MAKE);
		requestProp.areaId = 123;
		auto result = getValue(requestProp);
		ASSERT_TRUE(result.ok());
		VehiclePropValue value = result.value();
		ASSERT_EQ(value.prop, toInt(VehicleProperty::INFO_MAKE));
		ASSERT_EQ(value.areaId, 123);
		ASSERT_STREQ(CAR_MAKE, value.value.stringValue.c_str());
		uint8_t bytes[] = {0xde, 0xad, 0xbe, 0xef};
		ASSERT_FALSE(memcmp(bytes, value.value.byteValues.data(), sizeof(bytes)));
		ASSERT_EQ(3u, value.value.int32Values.size());
		ASSERT_EQ(2147483647, value.value.int32Values[0]);
		ASSERT_EQ(0, value.value.int32Values[1]);
		ASSERT_EQ(-2147483648, value.value.int32Values[2]);
		ASSERT_EQ(3u, value.value.int64Values.size());
		// -9223372036854775808 is not a valid literal since '-' and '9223372036854775808' would be two
		// tokens and the later does not fit in unsigned long long.
		ASSERT_EQ(-9223372036854775807 - 1, value.value.int64Values[0]);
		ASSERT_EQ(0, value.value.int64Values[1]);
		ASSERT_EQ(9223372036854775807, value.value.int64Values[2]);
		ASSERT_EQ(3u, value.value.floatValues.size());
		ASSERT_EQ(-3.402823466E+38f, value.value.floatValues[0]);
		ASSERT_EQ(0.0f, value.value.floatValues[1]);
		ASSERT_EQ(3.402823466E+38f, value.value.floatValues[2]);
		}

		} // namespace fake
		} // namespace vehicle
		} // namespace automotive

automotive/vehicle/aidl/impl/vhal/include/ConnectedClient.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -79,7 +79,7 @@ class GetSetValuesClient final : public ConnectedClient {
		GetSetValuesClient(std::shared_ptr<PendingRequestPool> requestPool, CallbackType callback);

		// Sends the results to this client.
		void sendResults(const std::vector<ResultType>& results);
		void sendResults(std::vector<ResultType>&& results);

		// Sends each result separately to this client. Each result would be sent through one callback
		// invocation.