Add vehicle hal.
- vehicle hal is used for supporting car specific features.
- Each property can be written (=set), read (=get), or subscribed.
- Each property has configuration informaiton to tell what that property
is and how it can be accessed.
- also adding dummy hal implementation.
bug: 25183740
Change-Id: Ib1cc1c11540f156db73552f2a18a8efb361002af
diff --git a/tests/vehicle/Android.mk b/tests/vehicle/Android.mk
new file mode 100644
index 0000000..eb41725
--- /dev/null
+++ b/tests/vehicle/Android.mk
@@ -0,0 +1,45 @@
+#
+# 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.
+
+LOCAL_PATH:= $(call my-dir)
+
+# Build native tests.
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+ vehicle_tests.cpp \
+
+LOCAL_SHARED_LIBRARIES := \
+ liblog \
+ libhardware \
+
+LOCAL_CFLAGS += -Wall -Wextra
+
+LOCAL_MODULE:= vehicle_tests
+LOCAL_MODULE_TAGS := tests
+
+include $(BUILD_NATIVE_TEST)
+
+# Build HAL command line utility.
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES := vehicle-hal-tool.c
+LOCAL_MODULE := vehicle-hal-tool
+LOCAL_CFLAGS := -Wall -Wno-unused-parameter -Werror
+LOCAL_MODULE_TAGS := tests
+
+LOCAL_SHARED_LIBRARIES := libcutils libhardware liblog
+
+include $(BUILD_EXECUTABLE)
diff --git a/tests/vehicle/README b/tests/vehicle/README
new file mode 100644
index 0000000..b8fc7d4
--- /dev/null
+++ b/tests/vehicle/README
@@ -0,0 +1,73 @@
+What does this document tell?
+
+This document details how to use the vehicle service if you are implementhing
+HAL. It lists the various places to look for code and how to build and test the
+code on your own dev device.
+
+This code also provides a simple command line utility for the target to test the
+vehicle HAL.
+
+What is the code?
+
+The code is split into folowing logical components:
+a) hardware/libhardware/include/hardware/vehicle.h - this is the main HAL
+interface that will be required to be implemented by the OEMs. It includes all
+documentation necessary to understand what vehicle subsystems are exposed,
+various units, capabilities and any other relevant details about the HAL design
+itself.
+
+b) hardware/libhardware/modules/vehicle/vehicle.c
+This is a reference implementation for the OEMs to have a peek into getting
+started with a barebones structure. There are implementation for each of the
+critical HAL functions such as, get(), set() and subscribe().
+
+c) hardware/libhardware/tests/vehicle/vehicle_test.cpp & vehicle_test_fixtures.h
+These are native tests that can be run on the target to validate basic
+features of HAL implementation. Things such as loading of HAL and
+basic functions are implemented (by check if the returned functions are not NULL
+pointers) can be asserted. It also checks if the subscribe function is doing its
+job by spitting out data at continuous intervals and printed on the stdout.
+
+d) hardware/libhardware/tests/vehicle/vehicle-hal-tool.c
+This tool will provide you with a simple utility which can set commands to the
+HAL such as:
+i) Getting a property (and printing its value).
+ii) Setting a property (and the HAL will take some setting action).
+iii) Subscribe to a property (and the HAL should send you values at some certain
+intevals).
+
+See the usage() function in vehicle-hal-tool.c for details on how to use the
+binary.
+
+How to build and run?
+
+You can build everything by issuing the following from the top of directory. It
+is assumed that you have done a first run of make from the top level so that
+intermediates are generated.
+
+$ croot
+$ mmm hardware/libhardware
+
+This will generate the following binaries that we care about:
+i) out/target/product/XXX/system/lib/hw/vehicle.default.so
+ii) out/target/product/XXX/data/nativetest/vehicle_tests
+iii) out/target/product/XXX/system/bin/vehicle-hal-tool
+
+The location for the first shared library would be:
+$ adb push out/target/product/XXX/system/lib/hw/vehicle.default.so
+/system/lib/hw
+You can also use 'adb sync' if you like, although this is the easiest least
+hassle way of putting it in place.
+
+The second binary is a native test - which is nothing but an executable for the
+target device. You can load it anywhere in your /data directory and run it as:
+$ adb push out/target/product/XXX/data/nativetest/vehicle_tests
+/data/tmp/vehicle_tests
+$ adb shell
+$ ./data/tmp/vehicle_tests
+<...output should be spitted with passing tests for atleast the reference
+implementation ...>
+
+The last binary is the command line tool, to push the binary on your target do:
+$ adb push out/target/product/XXX/system/bin/vehicle-hal-tool
+/data/tmp/vehicle-hal-tool
diff --git a/tests/vehicle/vehicle-hal-tool.c b/tests/vehicle/vehicle-hal-tool.c
new file mode 100755
index 0000000..78fd714
--- /dev/null
+++ b/tests/vehicle/vehicle-hal-tool.c
@@ -0,0 +1,428 @@
+/*
+ * 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.
+ */
+
+#define LOG_TAG "vehicle-hal-tool"
+
+#include <inttypes.h>
+#include <stdlib.h>
+#include <string.h>
+#include <hardware/hardware.h>
+#include <hardware/vehicle.h>
+
+#include <cutils/log.h>
+
+void usage() {
+ printf("Usage: "
+ "./vehicle-hal-tool [-l] [-m -p -t [-v]]\n"
+ "-l - List properties\n"
+ "-m - Mode (cannot be used with -l). Accepted strings: get, set or sub.\n"
+ "-p - Property (only used with -m)\n"
+ "-t - Type (only used with -m)\n"
+ "-w - Wait time in seconds (only used with -m set to sub)\n"
+ "-v - Value to which vehicle_prop_value is set\n"
+ "Depending on the type pass the value:\n"
+ "Int: pass a quoted integer\n"
+ "Float: pass a quoted float\n"
+ "Int array: pass a quoted space delimited int array, eg: \"1 2 3 4\" for\n:"
+ "setting int32_array's all 4 elements (see VEHICLE_VALUE_TYPE_INT32_VEC4\n"
+ "String: pass a normal string\n\n"
+ "The configurations to use the tool are as follows:\n"
+ "List Properties\n"
+ "---------------\n"
+ "./vehicle-hal-tool -l \n"
+ "Lists the various properties defined in HAL implementation. Use this to check if "
+ "the HAL implementation is correctly set up and exposing the capabilities correctly.\n"
+
+ "Get Properties\n"
+ "---------------\n"
+ "./vehicle-hal-tool -m get -p <prop> -t <type> [-v <vehicle_prop_value>]\n"
+ "Example: ./vehicle-hal-tool -m get -p 1028 -t 3 # VEHICLE_PROPERTY_DRIVING_STATUS\n"
+ "./vehicle-hal-tool -m get -p 257 -t 1 # VEHICLE_PROPERTY_INFO_MAKE\n"
+ "./vehicle-hal-tool -m get -p 2049 -t 19 -v \"3 0 0 0\"\n"
+ " # VEHICLE_PROPERTY_RADIO_PRESET\n"
+ "with preset value set to 3.\n\n"
+ "Set properties\n"
+ "--------------\n"
+ "./vehicle-hal-tool -m set -p 10 -t 1 -v random_property\n"
+ "Set properties may not be applicable to most properties\n\n"
+ "Subscribe properties\n"
+ "--------------------\n"
+ "Subscribes to be notified about a property change (depending on whether\n"
+ "it is a on change property or a continuous property) for seconds provided\n"
+ "as -w paramter.\n"
+ "./vehicle-hal-tool -m sub -p 1028 -w 10\n"
+ );
+}
+
+void list_all_properties(vehicle_hw_device_t *device) {
+ int num_configs = -1;
+ const vehicle_prop_config_t *configs = device->list_properties(device, &num_configs);
+ if (num_configs < 0) {
+ printf("List configs error. %d", num_configs);
+ exit(1);
+ }
+
+ printf("Listing configs\n--------------------\n");
+ int i = 0;
+ for (i = 0; i < num_configs; i++) {
+ const vehicle_prop_config_t *config_temp = configs + i;
+ printf("Property ID: %d\n"
+ "Property config_flags: %d\n"
+ "Property change mode: %d\n"
+ "Property min sample rate: %f\n"
+ "Property max sample rate: %f\n",
+ config_temp->prop, config_temp->config_flags, config_temp->change_mode,
+ config_temp->min_sample_rate, config_temp->max_sample_rate);
+ }
+}
+
+void get_property(
+ vehicle_hw_device_t *device, int32_t property, int32_t type, char *value_string) {
+ vehicle_prop_value_t *data = (vehicle_prop_value_t *) malloc (sizeof(vehicle_prop_value_t));
+
+ // Parse the string according to type.
+ if (value_string != NULL && strlen(value_string) > 0) {
+ switch (type) {
+ case VEHICLE_VALUE_TYPE_INT32:
+ sscanf(value_string, "%d", &(data->value.int32_value));
+ break;
+ case VEHICLE_VALUE_TYPE_INT32_VEC4:
+ {
+ int32_t vec[4];
+ sscanf(value_string, "%d %d %d %d", &vec[0], &vec[1], &vec[2], &vec[3]);
+ memcpy(data->value.int32_array, vec, sizeof(vec));
+ break;
+ }
+ default:
+ printf("%s Setting value type not supported: %d\n", __func__, type);
+ exit(1);
+ }
+ }
+
+ data->prop = property;
+ int ret_code = device->get(device, data);
+ if (ret_code != 0) {
+ printf("Cannot get property: %d\n", ret_code);
+ exit(1);
+ }
+
+ // We simply convert the data into the type mentioned by the result of the
+ // get call.
+ printf("Get output\n------------\n");
+ switch (data->value_type) {
+ case VEHICLE_VALUE_TYPE_FLOAT:
+ printf("Value type: FLOAT\nValue: %f\n", data->value.float_value);
+ break;
+ case VEHICLE_VALUE_TYPE_INT32:
+ printf("Value type: INT32\nValue: %d\n", data->value.int32_value);
+ break;
+ case VEHICLE_VALUE_TYPE_INT64:
+ printf("Value type: INT64\nValue: %" PRId64 "\n", data->value.int64_value);
+ break;
+ case VEHICLE_VALUE_TYPE_BOOLEAN:
+ printf("Value type: BOOLEAN\nValue: %d\n", data->value.boolean_value);
+ break;
+ case VEHICLE_VALUE_TYPE_STRING:
+ printf("Value type: STRING\n Size: %d\n", data->value.str_value.len);
+ // This implementation only supports ASCII.
+ char *ascii_out = (char *) malloc((data->value.str_value.len + 1) * sizeof(char));
+ memcpy(ascii_out, data->value.str_value.data, data->value.str_value.len);
+ ascii_out[data->value.str_value.len] = '\0';
+ printf("Value: %s\n", ascii_out);
+ break;
+ case VEHICLE_VALUE_TYPE_ZONED_FLOAT:
+ printf("Value type: ZONED_FLOAT\nZone: %d\n", data->value.zoned_float_value.zone);
+ printf("Value type: ZONED_FLOAT\nValue: %f\n", data->value.zoned_float_value.value);
+ break;
+ case VEHICLE_VALUE_TYPE_INT32_VEC3:
+ printf("Value type: INT32_VEC3\nValue[0]: %d\n", data->value.int32_array[0]);
+ printf("Value type: INT32_VEC3\nValue[1]: %d\n", data->value.int32_array[1]);
+ printf("Value type: INT32_VEC3\nValue[2]: %d\n", data->value.int32_array[2]);
+ break;
+ case VEHICLE_VALUE_TYPE_INT32_VEC4:
+ printf("Value type: INT32_VEC4\nValue[0]: %d\n", data->value.int32_array[0]);
+ printf("Value type: INT32_VEC4\nValue[1]: %d\n", data->value.int32_array[1]);
+ printf("Value type: INT32_VEC4\nValue[2]: %d\n", data->value.int32_array[2]);
+ printf("Value type: INT32_VEC4\nValue[3]: %d\n", data->value.int32_array[3]);
+ break;
+ default:
+ printf("Value type not yet handled: %d.\n", data->value_type);
+ }
+ free(data);
+}
+
+void set_property(vehicle_hw_device_t *device,
+ int32_t property,
+ int32_t type,
+ char *data) {
+ vehicle_prop_value_t vehicle_data;
+ vehicle_data.prop = property;
+ vehicle_data.value_type = type;
+ int32_t zone = 0;
+ float value = 0.0;
+ switch (type) {
+ case VEHICLE_VALUE_TYPE_FLOAT:
+ vehicle_data.value.float_value = atof(data);
+ break;
+ case VEHICLE_VALUE_TYPE_INT32:
+ vehicle_data.value.int32_value = atoi(data);
+ break;
+ case VEHICLE_VALUE_TYPE_INT64:
+ vehicle_data.value.int64_value = atoi(data);
+ break;
+ case VEHICLE_VALUE_TYPE_BOOLEAN:
+ vehicle_data.value.boolean_value = atoi(data);
+ break;
+ case VEHICLE_VALUE_TYPE_STRING:
+ // TODO: Make the code generic to UTF8 characters.
+ vehicle_data.value.str_value.len = strlen(data);
+ vehicle_data.value.str_value.data =
+ (uint8_t *) malloc (strlen(data) * sizeof(uint8_t));
+ memcpy(vehicle_data.value.str_value.data, data, strlen(data) + 1);
+ break;
+ case VEHICLE_VALUE_TYPE_ZONED_FLOAT:
+ sscanf(data, "%d %f", &zone, &value);
+ vehicle_data.value.zoned_float_value.zone = zone;
+ vehicle_data.value.zoned_float_value.value = value;
+ printf("Value type: ZONED_FLOAT\nZone: %d\n", vehicle_data.value.zoned_float_value.zone);
+ printf("Value type: ZONED_FLOAT\nValue: %f\n", vehicle_data.value.zoned_float_value.value);
+ break;
+ case VEHICLE_VALUE_TYPE_INT32_VEC2:
+ sscanf(data, "%d %d", &vehicle_data.value.int32_array[0],
+ &vehicle_data.value.int32_array[1]);
+ printf("Setting: Value type INT32_VEC2: %d %d\n",
+ vehicle_data.value.int32_array[0],
+ vehicle_data.value.int32_array[1]);
+ break;
+ case VEHICLE_VALUE_TYPE_INT32_VEC3:
+ sscanf(data, "%d %d %d", &vehicle_data.value.int32_array[0],
+ &vehicle_data.value.int32_array[1],
+ &vehicle_data.value.int32_array[2]);
+ printf("Setting: Value type INT32_VEC3: %d %d %d\n",
+ vehicle_data.value.int32_array[0],
+ vehicle_data.value.int32_array[1],
+ vehicle_data.value.int32_array[2]);
+ break;
+ case VEHICLE_VALUE_TYPE_INT32_VEC4:
+ sscanf(data, "%d %d %d %d", &vehicle_data.value.int32_array[0],
+ &vehicle_data.value.int32_array[1],
+ &vehicle_data.value.int32_array[2],
+ &vehicle_data.value.int32_array[3]);
+ printf("Setting: Value type INT32_VEC4: %d %d %d %d\n",
+ vehicle_data.value.int32_array[0],
+ vehicle_data.value.int32_array[1],
+ vehicle_data.value.int32_array[2],
+ vehicle_data.value.int32_array[3]);
+ break;
+ default:
+ printf("set_property: Value type not yet handled: %d\n", type);
+ exit(1);
+ }
+ printf("Property id: %d\n", vehicle_data.prop);
+ int ret_code = device->set(device, &vehicle_data);
+ if (ret_code != 0) {
+ printf("Cannot set property: %d\n", ret_code);
+ exit(1);
+ }
+}
+
+int vehicle_event_callback(const vehicle_prop_value_t *event_data) {
+ // Print what we got.
+ printf("Got some value from callback property: %d\n", event_data->prop);
+ printf("Timestamp: %" PRId64 "\n", event_data->timestamp);
+ char *ascii_out;
+ switch (event_data->value_type) {
+ case VEHICLE_VALUE_TYPE_FLOAT:
+ printf("Float value: %f\n", event_data->value.float_value);
+ break;
+ case VEHICLE_VALUE_TYPE_INT32:
+ printf("int32 value: %d\n", event_data->value.int32_value);
+ break;
+ case VEHICLE_VALUE_TYPE_INT64:
+ printf("int64 value: %" PRId64 "\n", event_data->value.int64_value);
+ break;
+ case VEHICLE_VALUE_TYPE_BOOLEAN:
+ printf("bool value: %d\n", event_data->value.boolean_value);
+ break;
+ case VEHICLE_VALUE_TYPE_STRING:
+ // TODO: Make the code generic to UTF8 characters.
+ ascii_out = (char *) malloc ((event_data->value.str_value.len + 1) * sizeof(char));
+ memcpy(ascii_out, event_data->value.str_value.data, event_data->value.str_value.len);
+ ascii_out[event_data->value.str_value.len] = '\0';
+ printf("Ascii value: %s\n", ascii_out);
+ break;
+ case VEHICLE_VALUE_TYPE_ZONED_FLOAT:
+ printf("Value type: ZONED_FLOAT\nZone: %d\n", event_data->value.zoned_float_value.zone);
+ printf("Value type: ZONED_FLOAT\nValue: %f\n", event_data->value.zoned_float_value.value);
+ break;
+ case VEHICLE_VALUE_TYPE_INT32_VEC4:
+ printf("Value type: INT32_VEC4\nValue[0]: %d Value[1] %d Value[2] %d Value[3] %d\n",
+ event_data->value.int32_array[0], event_data->value.int32_array[1],
+ event_data->value.int32_array[2], event_data->value.int32_array[3]);
+ break;
+ default:
+ printf("vehicle_event_callback: Value type not yet handled: %d\n",
+ event_data->value_type);
+ exit(1);
+ }
+ return 0;
+}
+int vehicle_error_callback(int32_t error_code, int32_t property, int32_t operation) {
+ // Print what we got.
+ printf("Error code obtained: %d\n", error_code);
+ return 0;
+}
+void subscribe_to_property(
+ vehicle_hw_device_t *device,
+ int32_t prop,
+ float sample_rate,
+ uint32_t wait_in_seconds) {
+ // Init the device with a callback.
+ device->init(device, vehicle_event_callback, vehicle_error_callback);
+ int ret_code = device->subscribe(device, prop, 0);
+ if (ret_code != 0) {
+ printf("Could not subscribe: %d\n", ret_code);
+ exit(1);
+ }
+
+ // Callbacks will happen on one of the threads created by the HAL hence we
+ // can simply sleep here and see the output.
+ sleep(wait_in_seconds);
+
+ // Unsubscribe and uninit.
+ ret_code = device->unsubscribe(device, prop);
+ if (ret_code != 0) {
+ printf("Error unsubscribing the HAL, still continuining to uninit HAL ...");
+ }
+
+ ret_code = device->release(device);
+ if (ret_code != 0) {
+ printf("Error uniniting HAL, exiting anyways.");
+ }
+}
+
+int main(int argc, char* argv[]) {
+ // Open the vehicle module and just ask for the list of properties.
+ const hw_module_t *hw_module = NULL;
+ int ret_code = hw_get_module(VEHICLE_HARDWARE_MODULE_ID, &hw_module);
+ if (ret_code != 0) {
+ printf("Cannot open the hw module. Does the HAL exist? %d\n", ret_code);
+ return -1;
+ }
+
+ vehicle_module_t *vehicle_module = (vehicle_module_t *)(hw_module);
+ hw_device_t *device = NULL;
+ ret_code = vehicle_module->common.methods->open(hw_module, NULL, &device);
+ if (!device) {
+ printf("Cannot open the hw device: %d\n", ret_code);
+ return -1;
+ }
+ vehicle_hw_device_t *vehicle_device = (vehicle_hw_device_t *) (device);
+ printf("HAL Loaded!\n");
+
+ // If this is a list properties command - we check for -l command.
+ int list_properties = 0;
+ // Type of the property (see #defines in vehicle.h).
+ int property = -1;
+ // Type of the value of the property (see enum vehicle_value_type).
+ int type = -1;
+ // Whether the mode is "get" or "set".
+ char mode[100] = "";
+ // Actual value as a string representation (supports only PODs for now).
+ // TODO: Support structures and complex types in the tool.
+ char value[100] = "";
+ // Wait time for the subscribe type of calls.
+ // We keep a default in case the user does not specify one.
+ int wait_time_in_sec = 10;
+ // Sample rate for subscribe type of calls.
+ // Default value is 0 for onchange type of properties.
+ int sample_rate = 0;
+ // Int array string which represents the vehicle_value_t in array of
+ // numbers. See vehicle_prop_value_t.value.int32_array.
+ char int_array_string[1000]; int_array_string[0] = '\0';
+
+ int opt;
+ while ((opt = getopt(argc, argv, "lm:p:t:v:w:s:")) != -1) {
+ switch (opt) {
+ case 'l':
+ list_properties = 1;
+ break;
+ case 'm':
+ strcpy(mode, optarg);
+ break;
+ case 'p':
+ property = atoi(optarg);
+ break;
+ case 't':
+ type = atoi(optarg);
+ break;
+ case 'v':
+ strcpy(value, optarg);
+ break;
+ case 'w':
+ wait_time_in_sec = atoi(optarg);
+ break;
+ case 's':
+ sample_rate = atoi(optarg);
+ break;
+ }
+ }
+
+ // We should have atleast one of list properties or mode (for get or set).
+ if (!list_properties &&
+ !(!strcmp(mode, "get") || !strcmp(mode, "set") || !strcmp(mode, "sub"))) {
+ usage();
+ exit(1);
+ }
+
+ if (list_properties) {
+ printf("Listing properties...\n");
+ list_all_properties(vehicle_device);
+ } else if (!strcmp(mode, "get")) {
+ printf("Getting property ...\n");
+ if (property == -1) {
+ printf("Use -p to pass a valid Property.\n");
+ usage();
+ exit(1);
+ }
+
+ int32_t int_array_list[4];
+ int count = -1;
+ if (strlen(int_array_string) > 0) {
+ count = sscanf(int_array_string, "%d%d%d%d",
+ &int_array_list[0], &int_array_list[1], &int_array_list[2], &int_array_list[3]);
+ }
+
+ get_property(vehicle_device, property, type, value);
+ } else if (!strcmp(mode, "set")) {
+ printf("Setting property ...\n");
+ if (property == -1 || type == -1) {
+ printf("Use -p to pass a valid Property and -t to pass a valid Type.\n");
+ usage();
+ exit(1);
+ }
+ set_property(vehicle_device, property, type, value);
+ } else if (!strcmp(mode, "sub")) {
+ printf("Subscribing property ...\n");
+ if (property == -1 || wait_time_in_sec <= 0) {
+ printf("Use -p to pass a valid property and -w to pass a valid wait time(s)\n");
+ usage();
+ exit(1);
+ }
+ subscribe_to_property(vehicle_device, property, sample_rate, wait_time_in_sec);
+ }
+ return 0;
+}
diff --git a/tests/vehicle/vehicle_test_fixtures.h b/tests/vehicle/vehicle_test_fixtures.h
new file mode 100644
index 0000000..15cafaa
--- /dev/null
+++ b/tests/vehicle/vehicle_test_fixtures.h
@@ -0,0 +1,97 @@
+/*
+ * 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.
+ */
+
+#ifndef __ANDROID_HAL_VEHICLE_TEST_
+#define __ANDROID_HAL_VEHICLE_TEST_
+
+#include <gtest/gtest.h>
+#include <hardware/hardware.h>
+#include <hardware/vehicle.h>
+
+namespace tests {
+
+static const uint64_t kVersion = HARDWARE_DEVICE_API_VERSION_2(1, 0, 1);
+
+class VehicleModule : public testing::Test {
+public:
+ VehicleModule() :
+ vehicle_module_(NULL) {}
+ ~VehicleModule() {}
+protected:
+ virtual void SetUp() {
+ const hw_module_t *hw_module = NULL;
+ ASSERT_EQ(0, hw_get_module(VEHICLE_HARDWARE_MODULE_ID, &hw_module))
+ << "Can't get vehicle module";
+ ASSERT_TRUE(NULL != hw_module)
+ << "hw_get_module didn't return a valid hardware module";
+
+ vehicle_module_ = reinterpret_cast<const vehicle_module_t*>(hw_module);
+ }
+ const vehicle_module_t* vehicle_module() { return vehicle_module_; }
+private:
+ const vehicle_module_t* vehicle_module_;
+};
+
+
+int VehicleEventCallback(const vehicle_prop_value_t* event_data) {
+ // Print what we got.
+ std::cout << "got some value from callback: "
+ << event_data->prop
+ << " uint32 value: "
+ << event_data->value.int32_value << "\n";
+ return 0;
+}
+
+int VehicleErrorCallback(int32_t error_code, int32_t property, int32_t operation) {
+ // Do nothing.
+ return 0;
+}
+
+class VehicleDevice : public VehicleModule {
+public:
+ VehicleDevice() :
+ vehicle_device_(NULL) {}
+ ~VehicleDevice() {}
+protected:
+ virtual void SetUp() {
+ VehicleModule::SetUp();
+ hw_device_t *device = NULL;
+ ASSERT_TRUE(NULL != vehicle_module()->common.methods->open)
+ << "Vehicle open() is unimplemented";
+ ASSERT_EQ(0, vehicle_module()->common.methods->open(
+ (const hw_module_t*)vehicle_module(), NULL, &device))
+ << "Can't open vehicle device";
+ ASSERT_TRUE(NULL != device)
+ << "Vehicle open() returned a NULL device";
+ ASSERT_EQ(kVersion, device->version)
+ << "Unsupported version";
+ vehicle_device_ = reinterpret_cast<vehicle_hw_device_t*>(device);
+ }
+ vehicle_hw_device_t* vehicle_device() { return vehicle_device_; }
+ vehicle_event_callback_fn callback_fn() {
+ return VehicleEventCallback;
+ }
+ vehicle_error_callback_fn error_fn() {
+ return VehicleErrorCallback;
+ }
+
+ private:
+ vehicle_hw_device_t* vehicle_device_;
+};
+
+} // namespace tests
+
+#endif // __ANDROID_HAL_VEHICLE_TEST_
diff --git a/tests/vehicle/vehicle_tests.cpp b/tests/vehicle/vehicle_tests.cpp
new file mode 100644
index 0000000..5862972
--- /dev/null
+++ b/tests/vehicle/vehicle_tests.cpp
@@ -0,0 +1,129 @@
+/*
+ * 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.
+ */
+
+#include <gtest/gtest.h>
+#include "vehicle_test_fixtures.h"
+#include "hardware/vehicle.h"
+
+namespace tests {
+
+// Check if list_properties command exists.
+TEST_F(VehicleDevice, isThereListProperties) {
+ ASSERT_TRUE(NULL != vehicle_device()->list_properties)
+ << "list_properties() function is not implemented";
+ std::cout << "Test succeeds.\n";
+}
+
+// HAL should provide atleast one property. The output of this command should be
+// used to verify the vailidity of the function.
+TEST_F(VehicleDevice, listPropertiesMoreThanOne) {
+ vehicle_prop_config_t const* config;
+ int num_configs = -1;
+ config = vehicle_device()->list_properties(vehicle_device(), &num_configs);
+ ASSERT_TRUE(num_configs > -1) << "list_properties() call failed.";
+ ASSERT_TRUE(num_configs > 0) << "list_properties() returned zero items.";
+ std::cout << "Number of properties reported: " << num_configs << "\n";
+ for (int i = 0; i < num_configs; i++) {
+ // Print each of the properties.
+ const vehicle_prop_config_t& config_temp = config[i];
+ std::cout << "Property ID: " << config_temp.prop << "\n";
+ std::cout << "Property flags: " << config_temp.config_flags << "\n";
+ std::cout << "Property change mode: " << config_temp.change_mode << "\n";
+ std::cout << "Property min sample rate: " << config_temp.min_sample_rate << "\n";
+ std::cout << "Property max sample rate: " << config_temp.max_sample_rate << "\n\n";
+ }
+}
+
+// Test get() command.
+// The fields are hardcoded in the dummy implementation and here.
+TEST_F(VehicleDevice, getDriveState) {
+ vehicle_prop_value_t data;
+ data.prop = VEHICLE_PROPERTY_DRIVING_STATUS;
+ // Set drive_state field to EINVAL so that we can check that its valid when
+ // it comes back.
+ data.value_type = -EINVAL;
+ data.value.driving_status = -EINVAL;
+ vehicle_device()->get(vehicle_device(), &data);
+
+ // Check that retured values are not invalid.
+ ASSERT_NE(data.value_type, -EINVAL) << "Drive state value type should be integer.";
+ ASSERT_NE(data.value.driving_status, -EINVAL) << "Driving status should be positive.";
+
+ std::cout << "Driving status value type: " << data.value_type << "\n"
+ << "Driving status: " << data.value.driving_status << "\n";
+}
+
+// Test the workflows for subscribe and init/release.
+// Subscribe will return error before init() is called or after release() is
+// called.
+TEST_F(VehicleDevice, initTest) {
+ // Test that init on a new device works. When getting an instance, we are
+ // already calling 'open' on the device.
+ int ret_code =
+ vehicle_device()->init(vehicle_device(), callback_fn(), error_fn());
+ ASSERT_EQ(ret_code, 0) << "ret code: " << ret_code;
+
+ // Trying to init again should return an error.
+ ret_code = vehicle_device()->init(vehicle_device(), callback_fn(), error_fn());
+ ASSERT_EQ(ret_code, -EEXIST) << "ret code: " << ret_code;
+
+ // Uninit should always return 0.
+ ret_code = vehicle_device()->release(vehicle_device());
+ ASSERT_EQ(ret_code, 0) << "ret code: " << ret_code;
+
+ // We should be able to init again.
+ ret_code = vehicle_device()->init(vehicle_device(), callback_fn(), error_fn());
+ ASSERT_EQ(ret_code, 0) << "ret code: " << ret_code;
+
+ // Finally release.
+ ret_code = vehicle_device()->release(vehicle_device());
+ ASSERT_EQ(ret_code, 0) << "ret_code: " << ret_code;
+}
+
+// Test that subscribe works.
+// We wait for 10 seconds while which the vehicle.c can post messages from
+// within it's own thread.
+TEST_F(VehicleDevice, subscribeTest) {
+ // If the device is not init subscribe should fail off the bat.
+ int ret_code = vehicle_device()->subscribe(vehicle_device(), VEHICLE_PROPERTY_DRIVING_STATUS,
+ 0);
+ ASSERT_EQ(ret_code, -EINVAL) << "Return code is: " << ret_code;
+
+ // Let's init the device.
+ ret_code = vehicle_device()->init(vehicle_device(), callback_fn(), error_fn());
+ ASSERT_EQ(ret_code, 0) << "Return code is: " << ret_code;
+
+ // Subscribe should now go through.
+ ret_code = vehicle_device()->subscribe(vehicle_device(), VEHICLE_PROPERTY_DRIVING_STATUS, 0);
+ ASSERT_EQ(ret_code, 0) << "Return code is: " << ret_code;
+
+ // We should start getting some messages thrown from the callback. Let's
+ // wait for 20 seconds before unsubscribing.
+ std::cout << "Sleeping for 20 seconds.";
+ sleep(20);
+ std::cout << "Waking from sleep.";
+
+ // This property does not exist, so we should get -EINVAL.
+ ret_code = vehicle_device()->unsubscribe(vehicle_device(), VEHICLE_PROPERTY_INFO_VIN);
+ ASSERT_EQ(ret_code, -EINVAL) << "Return code is: " << ret_code;
+
+ // This property exists, so we should get a success return code - also this
+ // will be a blocking call.
+ ret_code = vehicle_device()->unsubscribe(vehicle_device(), VEHICLE_PROPERTY_DRIVING_STATUS);
+ ASSERT_EQ(ret_code, 0) << "Return code is: " << ret_code;
+}
+
+} // namespace tests