keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2015 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 | |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 17 | #define LOG_TAG "VehicleNetwork" |
| 18 | |
| 19 | #include <utils/Log.h> |
| 20 | |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 21 | #include <IVehicleNetwork.h> |
| 22 | #include "VehicleNetworkProtoUtil.h" |
| 23 | |
| 24 | namespace android { |
| 25 | |
| 26 | static status_t copyString(const std::string& in, uint8_t** out, int32_t* len) { |
| 27 | *len = in.length(); |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 28 | if (*len == 0) { |
| 29 | *out = NULL; |
| 30 | return NO_ERROR; |
| 31 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 32 | *out = new uint8_t[*len]; |
| 33 | ASSERT_OR_HANDLE_NO_MEMORY(*out, return NO_MEMORY); |
| 34 | memcpy(*out, in.data(), *len); |
| 35 | return NO_ERROR; |
| 36 | } |
| 37 | |
| 38 | status_t VehicleNetworkProtoUtil::toVehiclePropValue(const vehicle_prop_value_t& in, |
| 39 | VehiclePropValue& out, bool /*inPlace*/) { |
| 40 | out.set_prop(in.prop); |
| 41 | out.set_value_type(in.value_type); |
| 42 | out.set_timestamp(in.timestamp); |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 43 | out.set_zone(in.zone); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 44 | switch (in.value_type) { |
| 45 | case VEHICLE_VALUE_TYPE_STRING: { |
| 46 | //TODO fix ugly copy here for inplace mode |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 47 | if (in.value.str_value.len > 0) { |
| 48 | out.set_string_value((char*)in.value.str_value.data, in.value.str_value.len); |
| 49 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 50 | } break; |
| 51 | case VEHICLE_VALUE_TYPE_BYTES: { |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 52 | if (in.value.bytes_value.len > 0) { |
| 53 | out.set_bytes_value(in.value.bytes_value.data, in.value.bytes_value.len); |
| 54 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 55 | } break; |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 56 | case VEHICLE_VALUE_TYPE_FLOAT: |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 57 | case VEHICLE_VALUE_TYPE_FLOAT_VEC2: |
| 58 | case VEHICLE_VALUE_TYPE_FLOAT_VEC3: |
| 59 | case VEHICLE_VALUE_TYPE_FLOAT_VEC4: { |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 60 | int expectedSize = in.value_type - VEHICLE_VALUE_TYPE_FLOAT + 1; |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 61 | for (int i = 0; i < expectedSize; i++) { |
| 62 | out.add_float_values(in.value.float_array[i]); |
| 63 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 64 | } break; |
| 65 | case VEHICLE_VALUE_TYPE_INT64: { |
| 66 | out.set_int64_value(in.value.int64_value); |
| 67 | } break; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 68 | case VEHICLE_VALUE_TYPE_BOOLEAN: |
| 69 | case VEHICLE_VALUE_TYPE_ZONED_BOOLEAN: { |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 70 | out.add_int32_values(in.value.int32_value); |
| 71 | } break; |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 72 | case VEHICLE_VALUE_TYPE_INT32: |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 73 | case VEHICLE_VALUE_TYPE_INT32_VEC2: |
| 74 | case VEHICLE_VALUE_TYPE_INT32_VEC3: |
| 75 | case VEHICLE_VALUE_TYPE_INT32_VEC4: { |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 76 | int expectedSize = in.value_type - VEHICLE_VALUE_TYPE_INT32 + 1; |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 77 | for (int i = 0; i < expectedSize; i++) { |
| 78 | out.add_int32_values(in.value.int32_array[i]); |
| 79 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 80 | } break; |
| 81 | case VEHICLE_VALUE_TYPE_ZONED_INT32: |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 82 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC2: |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 83 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC3: |
| 84 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC4: { |
| 85 | int expectedSize = in.value_type - VEHICLE_VALUE_TYPE_ZONED_INT32 + 1; |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 86 | for (int i = 0; i < expectedSize; i++) { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 87 | out.add_int32_values(in.value.int32_array[i]); |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 88 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 89 | } break; |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 90 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT: |
| 91 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC2: |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 92 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC3: |
| 93 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC4: { |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 94 | int expectedSize = in.value_type - VEHICLE_VALUE_TYPE_ZONED_FLOAT + 1; |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 95 | for (int i = 0; i < expectedSize; i++) { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 96 | out.add_float_values(in.value.float_array[i]); |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 97 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 98 | } break; |
| 99 | } |
| 100 | return NO_ERROR; |
| 101 | } |
| 102 | |
| 103 | status_t VehicleNetworkProtoUtil::fromVehiclePropValue(const VehiclePropValue& in, |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 104 | vehicle_prop_value_t& out, bool /*inPlace*/, bool canIgnoreNoData) { |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 105 | out.prop = in.prop(); |
| 106 | out.value_type = in.value_type(); |
| 107 | out.timestamp = in.timestamp(); |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 108 | out.zone = in.zone(); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 109 | switch (out.value_type) { |
| 110 | case VEHICLE_VALUE_TYPE_STRING: { |
| 111 | if (!in.has_string_value()) { |
| 112 | // set to NULL so that client can just delete this safely. |
| 113 | out.value.str_value.data = NULL; |
| 114 | out.value.str_value.len = 0; |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 115 | if (canIgnoreNoData) { |
| 116 | return NO_ERROR; |
| 117 | } else { |
| 118 | ALOGE("fromVehiclePropValue, no string data"); |
| 119 | return BAD_VALUE; |
| 120 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 121 | } |
| 122 | //TODO fix copy... |
| 123 | status_t r = copyString(in.string_value(), &(out.value.str_value.data), |
| 124 | &(out.value.str_value.len)); |
| 125 | if (r != NO_ERROR) { |
| 126 | out.value.str_value.data = NULL; |
| 127 | out.value.str_value.len = 0; |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 128 | ALOGE("copyString for string failed %d", r); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 129 | return r; |
| 130 | } |
| 131 | } break; |
| 132 | case VEHICLE_VALUE_TYPE_BYTES: { |
| 133 | if (!in.has_bytes_value()) { |
| 134 | out.value.bytes_value.data = NULL; |
| 135 | out.value.bytes_value.len = 0; |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 136 | if (canIgnoreNoData) { |
| 137 | return NO_ERROR; |
| 138 | } else { |
| 139 | ALOGE("fromVehiclePropValue, no byte data"); |
| 140 | return BAD_VALUE; |
| 141 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 142 | } |
| 143 | status_t r = copyString(in.bytes_value(), &(out.value.bytes_value.data), |
| 144 | &(out.value.bytes_value.len)); |
| 145 | if (r != NO_ERROR) { |
| 146 | out.value.bytes_value.data = NULL; |
| 147 | out.value.bytes_value.len = 0; |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 148 | ALOGE("copyString for bytes failed %d", r); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 149 | return r; |
| 150 | } |
| 151 | } break; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 152 | case VEHICLE_VALUE_TYPE_FLOAT: |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 153 | case VEHICLE_VALUE_TYPE_FLOAT_VEC2: |
| 154 | case VEHICLE_VALUE_TYPE_FLOAT_VEC3: |
| 155 | case VEHICLE_VALUE_TYPE_FLOAT_VEC4: { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 156 | int expectedSize = out.value_type - VEHICLE_VALUE_TYPE_FLOAT + 1; |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 157 | if (in.float_values_size() != expectedSize) { |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 158 | if (canIgnoreNoData) { |
| 159 | return NO_ERROR; |
| 160 | } |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 161 | ALOGE("float value, wrong size %d, expecting %d", in.float_values_size(), |
| 162 | expectedSize); |
| 163 | return BAD_VALUE; |
| 164 | } |
| 165 | for (int i = 0; i < expectedSize; i++) { |
| 166 | out.value.float_array[i] = in.float_values(i); |
| 167 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 168 | } break; |
| 169 | case VEHICLE_VALUE_TYPE_INT64: { |
| 170 | if (!in.has_int64_value()) { |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 171 | if (canIgnoreNoData) { |
| 172 | return NO_ERROR; |
| 173 | } |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 174 | ALOGE("no int64 value"); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 175 | return BAD_VALUE; |
| 176 | } |
| 177 | out.value.int64_value = in.int64_value(); |
| 178 | } break; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 179 | case VEHICLE_VALUE_TYPE_BOOLEAN: |
| 180 | case VEHICLE_VALUE_TYPE_ZONED_BOOLEAN: { |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 181 | if (in.int32_values_size() != 1) { |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 182 | if (canIgnoreNoData) { |
| 183 | return NO_ERROR; |
| 184 | } |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 185 | ALOGE("no int32 value"); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 186 | return BAD_VALUE; |
| 187 | } |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 188 | out.value.int32_value = in.int32_values(0); |
| 189 | } break; |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 190 | case VEHICLE_VALUE_TYPE_INT32: |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 191 | case VEHICLE_VALUE_TYPE_INT32_VEC2: |
| 192 | case VEHICLE_VALUE_TYPE_INT32_VEC3: |
| 193 | case VEHICLE_VALUE_TYPE_INT32_VEC4: { |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 194 | int expectedSize = out.value_type - VEHICLE_VALUE_TYPE_INT32 + 1; |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 195 | if (in.int32_values_size() != expectedSize) { |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 196 | if (canIgnoreNoData) { |
| 197 | return NO_ERROR; |
| 198 | } |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 199 | ALOGE("int32 value, wrong size %d, expecting %d", in.int32_values_size(), |
| 200 | expectedSize); |
| 201 | return BAD_VALUE; |
| 202 | } |
| 203 | for (int i = 0; i < expectedSize; i++) { |
| 204 | out.value.int32_array[i] = in.int32_values(i); |
| 205 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 206 | } break; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 207 | |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 208 | case VEHICLE_VALUE_TYPE_ZONED_INT32: |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 209 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC2: |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 210 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC3: |
| 211 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC4: { |
| 212 | int expectedSize = out.value_type - VEHICLE_VALUE_TYPE_ZONED_INT32 + 1; |
| 213 | if (in.int32_values_size() != expectedSize) { |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 214 | if (canIgnoreNoData) { |
| 215 | return NO_ERROR; |
| 216 | } |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 217 | ALOGE("int32 value, wrong size %d, expecting %d", in.int32_values_size(), |
| 218 | expectedSize); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 219 | return BAD_VALUE; |
| 220 | } |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 221 | for (int i = 0; i < expectedSize; i++) { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 222 | out.value.int32_array[i] = in.int32_values(i); |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 223 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 224 | } break; |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 225 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT: |
| 226 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC2: |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 227 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC3: |
| 228 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC4:{ |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 229 | int expectedSize = out.value_type - VEHICLE_VALUE_TYPE_ZONED_FLOAT + 1; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 230 | if (in.float_values_size() != expectedSize) { |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 231 | if (canIgnoreNoData) { |
| 232 | return NO_ERROR; |
| 233 | } |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 234 | ALOGE("float value, wrong size %d, expecting %d", in.float_values_size(), |
| 235 | expectedSize); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 236 | return BAD_VALUE; |
| 237 | } |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 238 | for (int i = 0; i < expectedSize; i++) { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 239 | out.value.float_array[i] = in.float_values(i); |
Keun-young Park | e4b186e | 2016-01-14 11:05:21 -0800 | [diff] [blame] | 240 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 241 | } break; |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 242 | default: { |
| 243 | if (canIgnoreNoData) { |
| 244 | return NO_ERROR; |
| 245 | } |
| 246 | ALOGE("fromVehiclePropValue unknown type 0x%x", out.value_type); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 247 | return BAD_VALUE; |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 248 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 249 | } |
| 250 | return NO_ERROR; |
| 251 | } |
| 252 | |
| 253 | status_t VehicleNetworkProtoUtil::toVehiclePropValues(const List<vehicle_prop_value_t*>& in, |
| 254 | VehiclePropValues& out) { |
| 255 | status_t r; |
| 256 | for (auto& v : in) { |
| 257 | VehiclePropValue* value = out.add_values(); |
| 258 | r = toVehiclePropValue(*v, *value); |
| 259 | if (r != NO_ERROR) { |
| 260 | out.clear_values(); |
| 261 | return r; |
| 262 | } |
| 263 | } |
| 264 | return NO_ERROR; |
| 265 | } |
| 266 | |
| 267 | status_t VehicleNetworkProtoUtil::fromVehiclePropValues(const VehiclePropValues& in, |
| 268 | List<vehicle_prop_value_t*>& out) { |
| 269 | status_t r; |
| 270 | for (int i = 0; i < in.values_size(); i++) { |
| 271 | vehicle_prop_value_t* v = new vehicle_prop_value_t(); |
| 272 | memset(v, 0, sizeof(vehicle_prop_value_t)); |
| 273 | ASSERT_OR_HANDLE_NO_MEMORY(v, r = NO_MEMORY;goto error); |
Keun-young Park | 5af1fda | 2015-12-08 18:15:27 -0800 | [diff] [blame] | 274 | r = fromVehiclePropValue(in.values(i), *v); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 275 | if (r != NO_ERROR) { |
| 276 | delete v; |
| 277 | goto error; |
| 278 | } |
| 279 | out.push_back(v); |
| 280 | } |
| 281 | return NO_ERROR; |
| 282 | error: |
| 283 | // clean up everything in List |
| 284 | for (auto pv : out) { |
| 285 | VehiclePropValueUtil::deleteMembers(pv); |
| 286 | } |
| 287 | return r; |
| 288 | } |
| 289 | |
| 290 | status_t VehicleNetworkProtoUtil::toVehiclePropConfig(const vehicle_prop_config_t& in, |
| 291 | VehiclePropConfig& out) { |
| 292 | out.set_prop(in.prop); |
| 293 | out.set_access(in.access); |
| 294 | out.set_change_mode(in.change_mode); |
| 295 | out.set_value_type(in.value_type); |
| 296 | out.set_permission_model(in.permission_model); |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 297 | out.set_zones(in.vehicle_zone_flags); |
Keun-young Park | 0727f95 | 2015-12-21 14:30:07 -0800 | [diff] [blame] | 298 | for (unsigned int i = 0; i < sizeof(in.config_array) / sizeof(int32_t); i++) { |
| 299 | out.add_config_array(in.config_array[i]); |
| 300 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 301 | if (in.config_string.data != NULL && in.config_string.len != 0) { |
| 302 | out.set_config_string((char*)in.config_string.data, in.config_string.len); |
| 303 | } else { |
| 304 | out.clear_config_string(); |
| 305 | } |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 306 | int numZones = VehicleNetworkUtil::countNumberOfZones(in.vehicle_zone_flags); |
| 307 | if (numZones == 0) { |
| 308 | numZones = 1; |
| 309 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 310 | switch (in.value_type) { |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 311 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT: |
| 312 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC2: |
| 313 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC3: |
| 314 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC4: |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 315 | case VEHICLE_VALUE_TYPE_FLOAT: |
Keun-young Park | 450faba | 2016-02-10 18:15:12 -0800 | [diff] [blame] | 316 | case VEHICLE_VALUE_TYPE_FLOAT_VEC2: |
| 317 | case VEHICLE_VALUE_TYPE_FLOAT_VEC3: |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 318 | case VEHICLE_VALUE_TYPE_FLOAT_VEC4: { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 319 | if (in.float_min_values == NULL) { |
| 320 | if (in.float_max_values == NULL) { |
| 321 | // all the same min/max |
| 322 | for (int i = 0; i < numZones; i++) { |
| 323 | out.add_float_maxs(in.float_max_value); |
| 324 | out.add_float_mins(in.float_min_value); |
| 325 | } |
| 326 | } else { // invalid combination |
| 327 | ALOGW("Zoned property 0x%x, min_values NULL while max_values not NULL", |
| 328 | in.prop); |
| 329 | return BAD_VALUE; |
| 330 | } |
| 331 | } else { |
| 332 | if (in.float_max_values != NULL) { |
| 333 | for (int i = 0; i < numZones; i++) { |
| 334 | out.add_float_maxs(in.float_max_values[i]); |
| 335 | out.add_float_mins(in.float_min_values[i]); |
| 336 | } |
| 337 | } else { // invalid combination |
| 338 | ALOGW("Zoned property 0x%x, max_values NULL while min_values not NULL", |
| 339 | in.prop); |
| 340 | return BAD_VALUE; |
| 341 | } |
| 342 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 343 | } break; |
| 344 | case VEHICLE_VALUE_TYPE_INT64: { |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 345 | if (in.int64_min_values == NULL) { |
| 346 | if (in.int64_max_values == NULL) { |
| 347 | // all the same min/max |
| 348 | for (int i = 0; i < numZones; i++) { |
| 349 | out.add_int64_maxs(in.int64_max_value); |
| 350 | out.add_int64_mins(in.int64_min_value); |
| 351 | } |
| 352 | } else { // invalid combination |
| 353 | ALOGW("Zoned property 0x%x, min_values NULL while max_values not NULL", |
| 354 | in.prop); |
| 355 | return BAD_VALUE; |
| 356 | } |
| 357 | } else { |
| 358 | if (in.int64_max_values != NULL) { |
| 359 | for (int i = 0; i < numZones; i++) { |
| 360 | out.add_int64_maxs(in.int64_max_values[i]); |
| 361 | out.add_int64_mins(in.int64_min_values[i]); |
| 362 | } |
| 363 | } else { // invalid combination |
| 364 | ALOGW("Zoned property 0x%x, max_values NULL while min_values not NULL", |
| 365 | in.prop); |
| 366 | return BAD_VALUE; |
| 367 | } |
| 368 | } |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 369 | } break; |
Keun-young Park | 450faba | 2016-02-10 18:15:12 -0800 | [diff] [blame] | 370 | case VEHICLE_VALUE_TYPE_ZONED_INT32: |
| 371 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC2: |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 372 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC3: |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 373 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC4: |
| 374 | case VEHICLE_VALUE_TYPE_INT32: |
| 375 | case VEHICLE_VALUE_TYPE_INT32_VEC2: |
| 376 | case VEHICLE_VALUE_TYPE_INT32_VEC3: |
| 377 | case VEHICLE_VALUE_TYPE_INT32_VEC4: { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 378 | if (in.int32_min_values == NULL) { |
| 379 | if (in.int32_max_values == NULL) { |
| 380 | // all the same min/max |
| 381 | for (int i = 0; i < numZones; i++) { |
| 382 | out.add_int32_maxs(in.int32_max_value); |
| 383 | out.add_int32_mins(in.int32_min_value); |
| 384 | } |
| 385 | } else { // invalid combination |
| 386 | ALOGW("Zoned property 0x%x, min_values NULL while max_values not NULL", |
| 387 | in.prop); |
| 388 | return BAD_VALUE; |
| 389 | } |
| 390 | } else { |
| 391 | if (in.int32_max_values != NULL) { |
| 392 | for (int i = 0; i < numZones; i++) { |
| 393 | out.add_int32_maxs(in.int32_max_values[i]); |
| 394 | out.add_int32_mins(in.int32_min_values[i]); |
| 395 | } |
| 396 | } else { // invalid combination |
| 397 | ALOGW("Zoned property 0x%x, max_values NULL while min_values not NULL", |
| 398 | in.prop); |
| 399 | return BAD_VALUE; |
| 400 | } |
| 401 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 402 | } break; |
| 403 | } |
| 404 | out.set_sample_rate_max(in.max_sample_rate); |
| 405 | out.set_sample_rate_min(in.min_sample_rate); |
| 406 | return NO_ERROR; |
| 407 | } |
| 408 | |
| 409 | status_t VehicleNetworkProtoUtil::fromVehiclePropConfig(const VehiclePropConfig& in, |
| 410 | vehicle_prop_config_t& out) { |
| 411 | out.prop = in.prop(); |
| 412 | out.access = in.access(); |
| 413 | out.change_mode = in.change_mode(); |
| 414 | out.value_type = in.value_type(); |
| 415 | out.permission_model = in.permission_model(); |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 416 | out.vehicle_zone_flags = in.zones(); |
Keun-young Park | 0727f95 | 2015-12-21 14:30:07 -0800 | [diff] [blame] | 417 | int maxConfigSize = sizeof(out.config_array) / sizeof(int32_t); |
| 418 | int configSize = in.config_array_size(); |
| 419 | if (configSize > maxConfigSize) { |
| 420 | return BAD_VALUE; |
| 421 | } |
| 422 | int i = 0; |
| 423 | for (; i < configSize; i++) { |
| 424 | out.config_array[i] = in.config_array(i); |
| 425 | } |
| 426 | for (; i < maxConfigSize; i++) { |
| 427 | out.config_array[i] = 0; |
| 428 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 429 | if (in.has_config_string()) { |
| 430 | status_t r = copyString(in.config_string(), &(out.config_string.data), |
| 431 | &(out.config_string.len)); |
| 432 | if (r != NO_ERROR) { |
| 433 | return r; |
| 434 | } |
| 435 | } else { |
| 436 | out.config_string.data = NULL; |
| 437 | out.config_string.len = 0; |
| 438 | } |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 439 | int numZones = VehicleNetworkUtil::countNumberOfZones(out.vehicle_zone_flags); |
| 440 | if (numZones == 0) { |
| 441 | numZones = 1; |
| 442 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 443 | switch (out.value_type) { |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 444 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT: |
| 445 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC2: |
| 446 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC3: |
| 447 | case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC4: |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 448 | case VEHICLE_VALUE_TYPE_FLOAT: |
Keun-young Park | 450faba | 2016-02-10 18:15:12 -0800 | [diff] [blame] | 449 | case VEHICLE_VALUE_TYPE_FLOAT_VEC2: |
| 450 | case VEHICLE_VALUE_TYPE_FLOAT_VEC3: |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 451 | case VEHICLE_VALUE_TYPE_FLOAT_VEC4: { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 452 | int maxSize = in.float_maxs_size(); |
| 453 | int minSize = in.float_mins_size(); |
| 454 | if (maxSize != minSize) { |
| 455 | ALOGW("Zoned property 0x%x, config maxSize %d minSize %d", out.prop, maxSize, |
| 456 | minSize); |
| 457 | return BAD_VALUE; |
| 458 | } |
| 459 | if (maxSize == 0) { |
| 460 | out.float_max_value = 0; |
| 461 | out.float_min_value = 0; |
| 462 | out.float_max_values = NULL; |
| 463 | out.float_min_values = NULL; |
| 464 | } else if (maxSize == 1) { // one for all |
| 465 | out.float_max_value = in.float_maxs(0); |
| 466 | out.float_min_value = in.float_mins(0); |
| 467 | out.float_max_values = NULL; |
| 468 | out.float_min_values = NULL; |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 469 | } else { |
| 470 | if ((numZones > 1) && (numZones != maxSize)) { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 471 | ALOGW("Zoned property 0x%x, config maxSize %d num Zones %d", out.prop, maxSize, |
| 472 | numZones); |
| 473 | return BAD_VALUE; |
| 474 | } |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 475 | out.float_max_values = new float[maxSize]; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 476 | ASSERT_OR_HANDLE_NO_MEMORY(out.float_max_values, return NO_MEMORY); |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 477 | out.float_min_values = new float[maxSize]; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 478 | ASSERT_OR_HANDLE_NO_MEMORY(out.float_min_values, return NO_MEMORY); |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 479 | for (int i = 0; i < maxSize; i++) { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 480 | out.float_max_values[i] = in.float_maxs(i); |
| 481 | out.float_min_values[i] = in.float_mins(i); |
| 482 | } |
| 483 | } |
| 484 | } break; |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 485 | case VEHICLE_VALUE_TYPE_INT64: { |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 486 | int maxSize = in.int64_maxs_size(); |
| 487 | int minSize = in.int64_mins_size(); |
| 488 | if (maxSize != minSize) { |
| 489 | ALOGW("Zoned property 0x%x, config maxSize %d minSize %d", out.prop, maxSize, |
| 490 | minSize); |
| 491 | return BAD_VALUE; |
| 492 | } |
| 493 | if (maxSize == 0) { |
keunyoung | 1ab8e18 | 2015-09-24 09:25:22 -0700 | [diff] [blame] | 494 | out.int64_max_value = 0; |
| 495 | out.int64_min_value = 0; |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 496 | out.int64_max_values = NULL; |
| 497 | out.int64_min_values = NULL; |
| 498 | } else if (maxSize == 1) { // one for all |
| 499 | out.int64_max_value = in.int64_maxs(0); |
| 500 | out.int64_min_value = in.int64_mins(0); |
| 501 | out.int64_max_values = NULL; |
| 502 | out.int64_min_values = NULL; |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 503 | } else { |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 504 | if ((numZones > 1) && (numZones != maxSize)) { |
| 505 | ALOGW("Zoned property 0x%x, config maxSize %d num Zones %d", out.prop, maxSize, |
| 506 | numZones); |
| 507 | return BAD_VALUE; |
| 508 | } |
| 509 | out.int64_max_values = new int64_t[maxSize]; |
| 510 | ASSERT_OR_HANDLE_NO_MEMORY(out.int64_max_values, return NO_MEMORY); |
| 511 | out.int64_min_values = new int64_t[maxSize]; |
| 512 | ASSERT_OR_HANDLE_NO_MEMORY(out.int64_min_values, return NO_MEMORY); |
| 513 | for (int i = 0; i < maxSize; i++) { |
| 514 | out.int64_max_values[i] = in.int64_maxs(i); |
| 515 | out.int64_min_values[i] = in.int64_mins(i); |
| 516 | } |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 517 | } |
| 518 | } break; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 519 | case VEHICLE_VALUE_TYPE_ZONED_INT32: |
| 520 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC2: |
| 521 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC3: |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 522 | case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC4: |
| 523 | case VEHICLE_VALUE_TYPE_INT32: |
| 524 | case VEHICLE_VALUE_TYPE_INT32_VEC2: |
| 525 | case VEHICLE_VALUE_TYPE_INT32_VEC3: |
| 526 | case VEHICLE_VALUE_TYPE_INT32_VEC4: { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 527 | int maxSize = in.int32_maxs_size(); |
| 528 | int minSize = in.int32_mins_size(); |
| 529 | if (maxSize != minSize) { |
| 530 | ALOGW("Zoned property 0x%x, config maxSize %d minSize %d", out.prop, maxSize, |
| 531 | minSize); |
| 532 | return BAD_VALUE; |
| 533 | } |
| 534 | if (maxSize == 0) { |
| 535 | out.int32_max_value = 0; |
| 536 | out.int32_min_value = 0; |
| 537 | out.int32_max_values = NULL; |
| 538 | out.int32_min_values = NULL; |
| 539 | } else if (maxSize == 1) { // one for all |
| 540 | out.int32_max_value = in.int32_maxs(0); |
| 541 | out.int32_min_value = in.int32_mins(0); |
| 542 | out.int32_max_values = NULL; |
| 543 | out.int32_min_values = NULL; |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 544 | } else { |
| 545 | if ((numZones > 1) && (numZones != maxSize)) { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 546 | ALOGW("Zoned property 0x%x, config maxSize %d num Zones %d", out.prop, maxSize, |
| 547 | numZones); |
| 548 | return BAD_VALUE; |
| 549 | } |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 550 | out.int32_max_values = new int32_t[maxSize]; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 551 | ASSERT_OR_HANDLE_NO_MEMORY(out.int32_max_values, return NO_MEMORY); |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 552 | out.int32_min_values = new int32_t[maxSize]; |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 553 | ASSERT_OR_HANDLE_NO_MEMORY(out.int32_min_values, return NO_MEMORY); |
Keun-young Park | 7d3fd01 | 2016-05-11 14:54:50 -0700 | [diff] [blame] | 554 | for (int i = 0; i < maxSize; i++) { |
Keun-young Park | 71b2f5c | 2016-03-10 18:44:40 -0800 | [diff] [blame] | 555 | out.int32_max_values[i] = in.int32_maxs(i); |
| 556 | out.int32_min_values[i] = in.int32_mins(i); |
| 557 | } |
| 558 | } |
| 559 | } break; |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 560 | } |
| 561 | out.max_sample_rate = in.sample_rate_max(); |
| 562 | out.min_sample_rate = in.sample_rate_min(); |
| 563 | return NO_ERROR; |
| 564 | } |
| 565 | |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 566 | status_t VehicleNetworkProtoUtil::toVehiclePropConfigs(List<vehicle_prop_config_t const*> &in, |
| 567 | VehiclePropConfigs& out) { |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 568 | status_t r; |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 569 | for (auto& inEntry : in) { |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 570 | VehiclePropConfig* config = out.add_configs(); |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 571 | r = toVehiclePropConfig(*inEntry, *config); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 572 | if (r != NO_ERROR) { |
| 573 | out.clear_configs(); |
| 574 | return r; |
| 575 | } |
| 576 | } |
| 577 | return NO_ERROR; |
| 578 | } |
| 579 | |
| 580 | status_t VehicleNetworkProtoUtil::fromVehiclePropConfigs(const VehiclePropConfigs& in, |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 581 | List<vehicle_prop_config_t const*>& out) { |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 582 | int32_t n = in.configs_size(); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 583 | status_t r; |
| 584 | for (int32_t i = 0; i < n; i++) { |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 585 | vehicle_prop_config_t* entry = new vehicle_prop_config_t(); |
| 586 | ASSERT_OR_HANDLE_NO_MEMORY(entry, r = NO_MEMORY; goto error); |
| 587 | memset(entry, 0, sizeof(vehicle_prop_config_t)); |
| 588 | r = fromVehiclePropConfig(in.configs(i), *entry); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 589 | if (r != NO_ERROR) { |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 590 | goto error; |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 591 | } |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 592 | out.push_back(entry); |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 593 | } |
| 594 | return NO_ERROR; |
keunyoung | d32f4e6 | 2015-09-21 11:33:06 -0700 | [diff] [blame] | 595 | error: |
| 596 | for (auto& e : out) { |
| 597 | vehicle_prop_config_t* eDelete = const_cast<vehicle_prop_config_t*>(e); |
| 598 | VehiclePropertiesUtil::deleteMembers(eDelete); |
| 599 | delete eDelete; |
| 600 | } |
| 601 | out.clear(); |
| 602 | return r; |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 603 | } |
| 604 | |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 605 | status_t VehiclePropValueBinderUtil::writeToParcel(Parcel& parcel, |
| 606 | const vehicle_prop_value_t& value) { |
| 607 | parcel.writeInt32(1); // 0 means no value. For compatibility with aidl based code. |
| 608 | std::unique_ptr<VehiclePropValue> v(new VehiclePropValue()); |
| 609 | ASSERT_OR_HANDLE_NO_MEMORY(v.get(), return NO_MEMORY); |
| 610 | VehicleNetworkProtoUtil::toVehiclePropValue(value, *v.get()); |
| 611 | int size = v->ByteSize(); |
| 612 | WritableBlobHolder blob(new Parcel::WritableBlob()); |
| 613 | ASSERT_OR_HANDLE_NO_MEMORY(blob.blob, return NO_MEMORY); |
| 614 | parcel.writeInt32(size); |
| 615 | parcel.writeBlob(size, false, blob.blob); |
| 616 | v->SerializeToArray(blob.blob->data(), size); |
| 617 | return NO_ERROR; |
| 618 | } |
| 619 | |
| 620 | status_t VehiclePropValueBinderUtil::readFromParcel(const Parcel& parcel, |
| 621 | vehicle_prop_value_t* value, bool deleteMembers, bool canIgnoreNoData) { |
| 622 | if (parcel.readInt32() == 0) { // no result |
| 623 | ALOGE("readFromParcel, null data"); |
| 624 | return BAD_VALUE; |
| 625 | } |
| 626 | ReadableBlobHolder blob(new Parcel::ReadableBlob()); |
| 627 | ASSERT_OR_HANDLE_NO_MEMORY(blob.blob, return NO_MEMORY); |
| 628 | int32_t size = parcel.readInt32(); |
Keun-young Park | 20539ba | 2016-10-10 17:57:34 -0700 | [diff] [blame] | 629 | if (size < 0) { |
| 630 | ALOGE("readFromParcel, bad blob size %d", size); |
| 631 | return BAD_VALUE; |
| 632 | } |
keunyoung | 7d74e6d | 2015-10-14 15:43:10 -0700 | [diff] [blame] | 633 | status_t status = parcel.readBlob(size, blob.blob); |
| 634 | if (status != NO_ERROR) { |
| 635 | ALOGE("readFromParcel, cannot read blob"); |
| 636 | return status; |
| 637 | } |
| 638 | std::unique_ptr<VehiclePropValue> v(new VehiclePropValue()); |
| 639 | ASSERT_OR_HANDLE_NO_MEMORY(v.get(), return NO_MEMORY); |
| 640 | if (!v->ParseFromArray(blob.blob->data(), size)) { |
| 641 | ALOGE("readFromParcel, cannot parse"); |
| 642 | return BAD_VALUE; |
| 643 | } |
| 644 | if (deleteMembers) { |
| 645 | VehiclePropValueUtil::deleteMembers(value); |
| 646 | } |
| 647 | return VehicleNetworkProtoUtil::fromVehiclePropValue(*v.get(), *value, false /*inPlace*/, |
| 648 | canIgnoreNoData); |
| 649 | } |
| 650 | |
keunyoung | e18e25d | 2015-08-28 15:57:19 -0700 | [diff] [blame] | 651 | }; //namespace android |
| 652 | |