1 /*
2 * Copyright (C) 2018 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 #include "VmsUtils.h"
18
19 #include <common/include/vhal_v2_0/VehicleUtils.h>
20
21 namespace android {
22 namespace hardware {
23 namespace automotive {
24 namespace vehicle {
25 namespace V2_0 {
26 namespace vms {
27
28 static constexpr int kMessageIndex = toInt(VmsBaseMessageIntegerValuesIndex::MESSAGE_TYPE);
29 static constexpr int kMessageTypeSize = 1;
30 static constexpr int kLayerNumberSize = 1;
31 static constexpr int kLayerSize = 3;
32 static constexpr int kLayerAndPublisherSize = 4;
33
34 // TODO(aditin): We should extend the VmsMessageType enum to include a first and
35 // last, which would prevent breakages in this API. However, for all of the
36 // functions in this module, we only need to guarantee that the message type is
37 // between SUBSCRIBE and DATA.
38 static constexpr int kFirstMessageType = toInt(VmsMessageType::SUBSCRIBE);
39 static constexpr int kLastMessageType = toInt(VmsMessageType::DATA);
40
createBaseVmsMessage(size_t message_size)41 std::unique_ptr<VehiclePropValue> createBaseVmsMessage(size_t message_size) {
42 auto result = createVehiclePropValue(VehiclePropertyType::INT32, message_size);
43 result->prop = toInt(VehicleProperty::VEHICLE_MAP_SERVICE);
44 result->areaId = toInt(VehicleArea::GLOBAL);
45 return result;
46 }
47
createSubscribeMessage(const VmsLayer & layer)48 std::unique_ptr<VehiclePropValue> createSubscribeMessage(const VmsLayer& layer) {
49 auto result = createBaseVmsMessage(kMessageTypeSize + kLayerSize);
50 result->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::SUBSCRIBE), layer.type,
51 layer.subtype, layer.version};
52 return result;
53 }
54
createSubscribeToPublisherMessage(const VmsLayerAndPublisher & layer_publisher)55 std::unique_ptr<VehiclePropValue> createSubscribeToPublisherMessage(
56 const VmsLayerAndPublisher& layer_publisher) {
57 auto result = createBaseVmsMessage(kMessageTypeSize + kLayerAndPublisherSize);
58 result->value.int32Values = hidl_vec<int32_t>{
59 toInt(VmsMessageType::SUBSCRIBE_TO_PUBLISHER), layer_publisher.layer.type,
60 layer_publisher.layer.subtype, layer_publisher.layer.version, layer_publisher.publisher_id};
61 return result;
62 }
63
createUnsubscribeMessage(const VmsLayer & layer)64 std::unique_ptr<VehiclePropValue> createUnsubscribeMessage(const VmsLayer& layer) {
65 auto result = createBaseVmsMessage(kMessageTypeSize + kLayerSize);
66 result->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::UNSUBSCRIBE), layer.type,
67 layer.subtype, layer.version};
68 return result;
69 }
70
createUnsubscribeToPublisherMessage(const VmsLayerAndPublisher & layer_publisher)71 std::unique_ptr<VehiclePropValue> createUnsubscribeToPublisherMessage(
72 const VmsLayerAndPublisher& layer_publisher) {
73 auto result = createBaseVmsMessage(kMessageTypeSize + kLayerAndPublisherSize);
74 result->value.int32Values = hidl_vec<int32_t>{
75 toInt(VmsMessageType::UNSUBSCRIBE_TO_PUBLISHER), layer_publisher.layer.type,
76 layer_publisher.layer.subtype, layer_publisher.layer.version, layer_publisher.publisher_id};
77 return result;
78 }
79
createOfferingMessage(const std::vector<VmsLayerOffering> & offering)80 std::unique_ptr<VehiclePropValue> createOfferingMessage(
81 const std::vector<VmsLayerOffering>& offering) {
82 int message_size = kMessageTypeSize + kLayerNumberSize;
83 for (const auto& offer : offering) {
84 message_size += kLayerNumberSize + (1 + offer.dependencies.size()) * kLayerSize;
85 }
86 auto result = createBaseVmsMessage(message_size);
87
88 std::vector<int32_t> offers = {toInt(VmsMessageType::OFFERING),
89 static_cast<int>(offering.size())};
90 for (const auto& offer : offering) {
91 std::vector<int32_t> layer_vector = {offer.layer.type, offer.layer.subtype,
92 offer.layer.version,
93 static_cast<int32_t>(offer.dependencies.size())};
94 for (const auto& dependency : offer.dependencies) {
95 std::vector<int32_t> dependency_layer = {dependency.type, dependency.subtype,
96 dependency.version};
97 layer_vector.insert(layer_vector.end(), dependency_layer.begin(),
98 dependency_layer.end());
99 }
100 offers.insert(offers.end(), layer_vector.begin(), layer_vector.end());
101 }
102 result->value.int32Values = offers;
103 return result;
104 }
105
createAvailabilityRequest()106 std::unique_ptr<VehiclePropValue> createAvailabilityRequest() {
107 auto result = createBaseVmsMessage(kMessageTypeSize);
108 result->value.int32Values = hidl_vec<int32_t>{
109 toInt(VmsMessageType::AVAILABILITY_REQUEST),
110 };
111 return result;
112 }
113
createSubscriptionsRequest()114 std::unique_ptr<VehiclePropValue> createSubscriptionsRequest() {
115 auto result = createBaseVmsMessage(kMessageTypeSize);
116 result->value.int32Values = hidl_vec<int32_t>{
117 toInt(VmsMessageType::SUBSCRIPTIONS_REQUEST),
118 };
119 return result;
120 }
121
createDataMessage(const std::string & bytes)122 std::unique_ptr<VehiclePropValue> createDataMessage(const std::string& bytes) {
123 auto result = createBaseVmsMessage(kMessageTypeSize);
124 result->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::DATA)};
125 result->value.bytes = std::vector<uint8_t>(bytes.begin(), bytes.end());
126 return result;
127 }
128
isValidVmsProperty(const VehiclePropValue & value)129 bool isValidVmsProperty(const VehiclePropValue& value) {
130 return (value.prop == toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
131 }
132
isValidVmsMessageType(const VehiclePropValue & value)133 bool isValidVmsMessageType(const VehiclePropValue& value) {
134 return (value.value.int32Values.size() > 0 &&
135 value.value.int32Values[kMessageIndex] >= kFirstMessageType &&
136 value.value.int32Values[kMessageIndex] <= kLastMessageType);
137 }
138
isValidVmsMessage(const VehiclePropValue & value)139 bool isValidVmsMessage(const VehiclePropValue& value) {
140 return (isValidVmsProperty(value) && isValidVmsMessageType(value));
141 }
142
parseMessageType(const VehiclePropValue & value)143 VmsMessageType parseMessageType(const VehiclePropValue& value) {
144 return static_cast<VmsMessageType>(value.value.int32Values[kMessageIndex]);
145 }
146
parseData(const VehiclePropValue & value)147 std::string parseData(const VehiclePropValue& value) {
148 if (isValidVmsMessage(value) && parseMessageType(value) == VmsMessageType::DATA &&
149 value.value.bytes.size() > 0) {
150 return std::string(value.value.bytes.begin(), value.value.bytes.end());
151 } else {
152 return std::string();
153 }
154 }
155
156 } // namespace vms
157 } // namespace V2_0
158 } // namespace vehicle
159 } // namespace automotive
160 } // namespace hardware
161 } // namespace android
162