1 /*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #ifndef android_hardware_automotive_vehicle_V2_0_VehicleDebugUtils_H_
18 #define android_hardware_automotive_vehicle_V2_0_VehicleDebugUtils_H_
19
20 #include <android/hardware/automotive/vehicle/2.0/types.h>
21 #include <ios>
22 #include <sstream>
23
24 #include "vhal_v2_0/VehicleUtils.h"
25
26 namespace android {
27 namespace hardware {
28 namespace automotive {
29 namespace vehicle {
30 namespace V2_0 {
31
32 constexpr int32_t kCustomComplexProperty =
33 0xbeef | VehiclePropertyGroup::VENDOR | VehiclePropertyType::MIXED | VehicleArea::GLOBAL;
34
35 const VehiclePropConfig kVehicleProperties[] = {
36 {
37 .prop = toInt(VehicleProperty::INFO_MAKE),
38 .access = VehiclePropertyAccess::READ,
39 .changeMode = VehiclePropertyChangeMode::STATIC,
40 .configString = "Some=config,options=if,you=have_any",
41 },
42
43 {.prop = toInt(VehicleProperty::HVAC_FAN_SPEED),
44 .access = VehiclePropertyAccess::READ_WRITE,
45 .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
46 .areaConfigs =
47 {VehicleAreaConfig{
48 .areaId = toInt(VehicleAreaSeat::ROW_1_LEFT), .minInt32Value = 1, .maxInt32Value = 7},
49 VehicleAreaConfig{
50 .areaId = toInt(VehicleAreaSeat::ROW_1_RIGHT), .minInt32Value = 1, .maxInt32Value = 5,
51 }}},
52
53 // Write-only property
54 {.prop = toInt(VehicleProperty::HVAC_SEAT_TEMPERATURE),
55 .access = VehiclePropertyAccess::WRITE,
56 .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
57 .areaConfigs = {VehicleAreaConfig{.areaId = toInt(VehicleAreaSeat::ROW_1_LEFT),
58 .minInt32Value = 64,
59 .maxInt32Value = 80},
60 VehicleAreaConfig{
61 .areaId = toInt(VehicleAreaSeat::ROW_1_RIGHT),
62 .minInt32Value = 64,
63 .maxInt32Value = 80,
64 }}},
65
66 {.prop = toInt(VehicleProperty::INFO_FUEL_CAPACITY),
67 .access = VehiclePropertyAccess::READ,
68 .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
69 .areaConfigs = {VehicleAreaConfig{.minFloatValue = 0, .maxFloatValue = 1.0}}},
70
71 {.prop = toInt(VehicleProperty::DISPLAY_BRIGHTNESS),
72 .access = VehiclePropertyAccess::READ_WRITE,
73 .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
74 .areaConfigs = {VehicleAreaConfig{.minInt32Value = 0, .maxInt32Value = 10}}},
75
76 {
77 .prop = toInt(VehicleProperty::MIRROR_FOLD),
78 .access = VehiclePropertyAccess::READ_WRITE,
79 .changeMode = VehiclePropertyChangeMode::ON_CHANGE,
80
81 },
82
83 // Complex data type.
84 {.prop = kCustomComplexProperty,
85 .access = VehiclePropertyAccess::READ_WRITE,
86 .changeMode = VehiclePropertyChangeMode::ON_CHANGE}};
87
88 constexpr auto kTimeout = std::chrono::milliseconds(500);
89
90 class MockedVehicleCallback : public IVehicleCallback {
91 private:
92 using MuxGuard = std::lock_guard<std::mutex>;
93 using HidlVecOfValues = hidl_vec<VehiclePropValue>;
94 public:
95 // Methods from ::android::hardware::automotive::vehicle::V2_0::IVehicleCallback follow.
onPropertyEvent(const hidl_vec<VehiclePropValue> & values)96 Return<void> onPropertyEvent(
97 const hidl_vec<VehiclePropValue>& values) override {
98 {
99 MuxGuard g(mLock);
100 mReceivedEvents.push_back(values);
101 }
102 mEventCond.notify_one();
103 return Return<void>();
104 }
onPropertySet(const VehiclePropValue &)105 Return<void> onPropertySet(const VehiclePropValue& /* value */) override {
106 return Return<void>();
107 }
onPropertySetError(StatusCode,int32_t,int32_t)108 Return<void> onPropertySetError(StatusCode /* errorCode */,
109 int32_t /* propId */,
110 int32_t /* areaId */) override {
111 return Return<void>();
112 }
113
waitForExpectedEvents(size_t expectedEvents)114 bool waitForExpectedEvents(size_t expectedEvents) {
115 std::unique_lock<std::mutex> g(mLock);
116
117 if (expectedEvents == 0 && mReceivedEvents.size() == 0) {
118 // No events expected, let's sleep a little bit to make sure
119 // nothing will show up.
120 return mEventCond.wait_for(g, kTimeout) == std::cv_status::timeout;
121 }
122
123 while (expectedEvents != mReceivedEvents.size()) {
124 if (mEventCond.wait_for(g, kTimeout) == std::cv_status::timeout) {
125 return false;
126 }
127 }
128 return true;
129 }
130
reset()131 void reset() {
132 mReceivedEvents.clear();
133 }
134
getReceivedEvents()135 const std::vector<HidlVecOfValues>& getReceivedEvents() {
136 return mReceivedEvents;
137 }
138
139 private:
140 std::mutex mLock;
141 std::condition_variable mEventCond;
142 std::vector<HidlVecOfValues> mReceivedEvents;
143 };
144
145 template<typename T>
hexString(T value)146 inline std::string hexString(T value) {
147 std::stringstream ss;
148 ss << std::showbase << std::hex << value;
149 return ss.str();
150 }
151
152 template <typename T, typename Collection>
assertAllExistsAnyOrder(std::initializer_list<T> expected,const Collection & actual,const char * msg)153 inline void assertAllExistsAnyOrder(
154 std::initializer_list<T> expected,
155 const Collection& actual,
156 const char* msg) {
157 std::set<T> expectedSet = expected;
158
159 for (auto a: actual) {
160 ASSERT_EQ(1u, expectedSet.erase(a))
161 << msg << "\nContains not unexpected value.\n";
162 }
163
164 ASSERT_EQ(0u, expectedSet.size())
165 << msg
166 << "\nDoesn't contain expected value.";
167 }
168
169 #define ASSERT_ALL_EXISTS(...) \
170 assertAllExistsAnyOrder(__VA_ARGS__, (std::string("Called from: ") + \
171 std::string(__FILE__) + std::string(":") + \
172 std::to_string(__LINE__)).c_str()); \
173
174 template<typename T>
enumToHexString(T value)175 inline std::string enumToHexString(T value) {
176 return hexString(toInt(value));
177 }
178
179 template <typename T>
vecToString(const hidl_vec<T> & vec)180 inline std::string vecToString(const hidl_vec<T>& vec) {
181 std::stringstream ss("[");
182 for (size_t i = 0; i < vec.size(); i++) {
183 if (i != 0) ss << ",";
184 ss << vec[i];
185 }
186 ss << "]";
187 return ss.str();
188 }
189
190 } // namespace V2_0
191 } // namespace vehicle
192 } // namespace automotive
193 } // namespace hardware
194 } // namespace android
195
196
197 #endif //android_hardware_automotive_vehicle_V2_0_VehicleDebugUtils_H_
198