automotive/vehicle/aidl/impl/fake_impl/userhal/src/UserHalHelper.cpp - platform/hardware/interfaces - Git at Google

 /*
  * Copyright (C) 2021 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 "UserHalHelper"

 #include "UserHalHelper.h"

 #include <VehicleUtils.h>
 #include <log/log.h>
 #include <utils/SystemClock.h>

 #include <vector>

 namespace android {
 namespace hardware {
 namespace automotive {
 namespace vehicle {
 namespace fake {
 namespace user_hal_helper {

 namespace {

 using ::aidl::android::hardware::automotive::vehicle::CreateUserRequest;
 using ::aidl::android::hardware::automotive::vehicle::CreateUserResponse;
 using ::aidl::android::hardware::automotive::vehicle::CreateUserStatus;
 using ::aidl::android::hardware::automotive::vehicle::InitialUserInfoRequest;
 using ::aidl::android::hardware::automotive::vehicle::InitialUserInfoRequestType;
 using ::aidl::android::hardware::automotive::vehicle::InitialUserInfoResponse;
 using ::aidl::android::hardware::automotive::vehicle::RemoveUserRequest;
 using ::aidl::android::hardware::automotive::vehicle::SwitchUserMessageType;
 using ::aidl::android::hardware::automotive::vehicle::SwitchUserRequest;
 using ::aidl::android::hardware::automotive::vehicle::SwitchUserResponse;
 using ::aidl::android::hardware::automotive::vehicle::SwitchUserStatus;
 using ::aidl::android::hardware::automotive::vehicle::UserIdentificationAssociationSetValue;
 using ::aidl::android::hardware::automotive::vehicle::UserIdentificationAssociationType;
 using ::aidl::android::hardware::automotive::vehicle::UserIdentificationGetRequest;
 using ::aidl::android::hardware::automotive::vehicle::UserIdentificationResponse;
 using ::aidl::android::hardware::automotive::vehicle::UserIdentificationSetAssociation;
 using ::aidl::android::hardware::automotive::vehicle::UserIdentificationSetRequest;
 using ::aidl::android::hardware::automotive::vehicle::UserInfo;
 using ::aidl::android::hardware::automotive::vehicle::UsersInfo;
 using ::aidl::android::hardware::automotive::vehicle::VehicleProperty;
 using ::aidl::android::hardware::automotive::vehicle::VehiclePropValue;
 using ::android::base::Error;
 using ::android::base::Result;

 constexpr const char kSeparator[] = "||";
 constexpr size_t kNumFieldsPerUserInfo = 2;
 constexpr size_t kNumFieldsPerSetAssociation = 2;

 Result<void> verifyPropValue(const VehiclePropValue& propValue, VehicleProperty vehicleProperty,
                              size_t minInt32Values) {
     auto prop = verifyAndCast<VehicleProperty>(propValue.prop);
     if (!prop.ok()) {
         return Error() << "Invalid vehicle property: " << prop.error();
     }
     if (*prop != vehicleProperty) {
         return Error() << "Mismatching " << toString(vehicleProperty) << " request, received "
                        << toString(*prop) << " property";
     }
     if (propValue.value.int32Values.size() < minInt32Values) {
         return Error() << "Int32Values must have at least " << minInt32Values
                        << " values, received " << propValue.value.int32Values.size();
     }
     return {};
 }

 Result<void> parseUserInfo(const std::vector<int32_t>& int32Values, size_t startPos,
                            UserInfo* userInfo) {
     if (int32Values.size() < startPos + kNumFieldsPerUserInfo) {
         return Error() << "Int32Values must have at least " << startPos + 2 << " values, received "
                        << int32Values.size();
     }
     userInfo->userId = int32Values[startPos];
     int32_t intUserFlags = int32Values[startPos + 1];
     const int32_t combinedFlags = UserInfo::USER_FLAG_SYSTEM | UserInfo::USER_FLAG_GUEST |
                                   UserInfo::USER_FLAG_EPHEMERAL | UserInfo::USER_FLAG_ADMIN |
                                   UserInfo::USER_FLAG_DISABLED | UserInfo::USER_FLAG_PROFILE;

     if ((intUserFlags & ~combinedFlags) != 0) {
         return Error() << "Invalid user flags: " << intUserFlags << ", must be '|' of UserFlags";
     }
     userInfo->flags = intUserFlags;
     return {};
 }

 Result<void> parseUsersInfo(const std::vector<int32_t>& int32Values, size_t startPos,
                             UsersInfo* usersInfo) {
     if (int32Values.size() < startPos + 3) {
         return Error() << "Int32Values must have at least " << startPos + 3 << " values, received "
                        << int32Values.size();
     }
     auto ret = parseUserInfo(int32Values, startPos, &usersInfo->currentUser);
     if (!ret.ok()) {
         return ret;
     }
     usersInfo->numberUsers = int32Values[startPos + 2];
     usersInfo->existingUsers.resize(usersInfo->numberUsers);
     for (size_t i = 0; i < static_cast<size_t>(usersInfo->numberUsers); ++i) {
         ret = parseUserInfo(int32Values, startPos + 3 + (kNumFieldsPerUserInfo * i),
                             &usersInfo->existingUsers[i]);
         if (!ret.ok()) {
             return Error() << "Failed to parse existing user '" << i << "' info: " << ret.error();
         }
     }
     return {};
 }

 Result<void> parseUserAssociationTypes(
         const std::vector<int32_t>& int32Values, size_t startPos, size_t numberAssociationTypes,
         std::vector<UserIdentificationAssociationType>* associationTypes) {
     size_t minInt32Values = startPos + numberAssociationTypes;
     if (int32Values.size() < minInt32Values) {
         return Error() << "Int32Values must have at least " << minInt32Values
                        << " values, received " << int32Values.size();
     }
     associationTypes->resize(numberAssociationTypes);
     for (size_t i = 0; i < static_cast<size_t>(numberAssociationTypes); ++i) {
         size_t pos = startPos + i;
         auto type = verifyAndCast<UserIdentificationAssociationType>(int32Values[pos]);
         if (!type.ok()) {
             return Error() << "Invalid association type in query '" << i << "': " << type.error();
         }
         (*associationTypes)[i] = *type;
     }
     return {};
 }

 Result<void> parseUserAssociations(const std::vector<int32_t>& int32Values, size_t startPos,
                                    size_t numberAssociations,
                                    std::vector<UserIdentificationSetAssociation>* associations) {
     size_t minInt32Values = startPos + (numberAssociations * kNumFieldsPerSetAssociation);
     if (int32Values.size() < minInt32Values) {
         return Error() << "Int32Values must have at least " << minInt32Values
                        << " values, received " << int32Values.size();
     }
     associations->resize(numberAssociations);
     for (size_t i = 0; i < static_cast<size_t>(numberAssociations); ++i) {
         size_t pos = startPos + (kNumFieldsPerSetAssociation * i);
         auto type = verifyAndCast<UserIdentificationAssociationType>(int32Values[pos]);
         if (!type.ok()) {
             return Error() << "Invalid association type in request '" << i << "': " << type.error();
         }
         (*associations)[i].type = *type;
         auto value = verifyAndCast<UserIdentificationAssociationSetValue>(int32Values[pos + 1]);
         if (!value.ok()) {
             return Error() << "Invalid association set value in request '" << i
                            << "': " << value.error();
         }
         (*associations)[i].value = *value;
     }
     return {};
 }

 }  // namespace

 template <typename T>
 Result<T> verifyAndCast(int32_t value) {
     T castValue = static_cast<T>(value);
     for (const auto& v : ::ndk::enum_range<T>()) {
         if (castValue == v) {
             return castValue;
         }
     }

     return Error() << "Value " << value << " not in enum values";
 }

 Result<InitialUserInfoRequest> toInitialUserInfoRequest(const VehiclePropValue& propValue) {
     auto ret = verifyPropValue(propValue, VehicleProperty::INITIAL_USER_INFO, /*minInt32Values=*/2);
     if (!ret.ok()) {
         return ret.error();
     }
     InitialUserInfoRequest request;
     request.requestId = propValue.value.int32Values[0];
     auto requestType = verifyAndCast<InitialUserInfoRequestType>(propValue.value.int32Values[1]);
     if (!requestType.ok()) {
         return Error() << "Invalid InitialUserInfoRequestType: " << requestType.error();
     }
     request.requestType = *requestType;
     ret = parseUsersInfo(propValue.value.int32Values, 2, &request.usersInfo);
     if (!ret.ok()) {
         return Error() << "Failed to parse users info: " << ret.error();
     }
     return request;
 }

 Result<SwitchUserRequest> toSwitchUserRequest(const VehiclePropValue& propValue) {
     auto ret = verifyPropValue(propValue, VehicleProperty::SWITCH_USER, /*minInt32Values=*/2);
     if (!ret.ok()) {
         return ret.error();
     }
     SwitchUserRequest request;
     auto messageType = verifyAndCast<SwitchUserMessageType>(propValue.value.int32Values[1]);
     if (!messageType.ok()) {
         return Error() << "Invalid SwitchUserMessageType: " << messageType.error();
     }
     if (*messageType != SwitchUserMessageType::LEGACY_ANDROID_SWITCH &&
         *messageType != SwitchUserMessageType::ANDROID_SWITCH &&
         *messageType != SwitchUserMessageType::ANDROID_POST_SWITCH) {
         return Error() << "Invalid " << toString(*messageType)
                        << " message type from Android System";
     }
     request.requestId = propValue.value.int32Values[0];
     request.messageType = *messageType;
     ret = parseUserInfo(propValue.value.int32Values, /*startPos=*/2, &request.targetUser);
     if (!ret.ok()) {
         return Error() << "Failed to parse target user info: " << ret.error();
     }
     ret = parseUsersInfo(propValue.value.int32Values, /*startPos=*/4, &request.usersInfo);
     if (!ret.ok()) {
         return Error() << "Failed to parse users info: " << ret.error();
     }
     return request;
 }

 Result<CreateUserRequest> toCreateUserRequest(const VehiclePropValue& propValue) {
     auto ret = verifyPropValue(propValue, VehicleProperty::CREATE_USER, /*minInt32Values=*/1);
     if (!ret.ok()) {
         return ret.error();
     }
     CreateUserRequest request;
     request.requestId = propValue.value.int32Values[0];
     ret = parseUserInfo(propValue.value.int32Values, /*startPos=*/1, &request.newUserInfo);
     if (!ret.ok()) {
         return Error() << "Failed to parse new user info: " << ret.error();
     }
     request.newUserName = propValue.value.stringValue;
     ret = parseUsersInfo(propValue.value.int32Values, /*startPos=*/3, &request.usersInfo);
     if (!ret.ok()) {
         return Error() << "Failed to parse users info: " << ret.error();
     }
     return request;
 }

 Result<RemoveUserRequest> toRemoveUserRequest(const VehiclePropValue& propValue) {
     auto ret = verifyPropValue(propValue, VehicleProperty::REMOVE_USER, /*minInt32Values=*/1);
     if (!ret.ok()) {
         return ret.error();
     }
     RemoveUserRequest request;
     request.requestId = propValue.value.int32Values[0];
     ret = parseUserInfo(propValue.value.int32Values, /*startPos=*/1, &request.removedUserInfo);
     if (!ret.ok()) {
         return Error() << "Failed to parse removed user info: " << ret.error();
     }
     ret = parseUsersInfo(propValue.value.int32Values, /*startPos=*/3, &request.usersInfo);
     if (!ret.ok()) {
         return Error() << "Failed to parse users info: " << ret.error();
     }
     return request;
 }

 Result<UserIdentificationGetRequest> toUserIdentificationGetRequest(
         const VehiclePropValue& propValue) {
     auto ret = verifyPropValue(propValue, VehicleProperty::USER_IDENTIFICATION_ASSOCIATION,
                                /*minInt32Values=*/4);
     if (!ret.ok()) {
         return ret.error();
     }
     UserIdentificationGetRequest request;
     request.requestId = propValue.value.int32Values[0];
     ret = parseUserInfo(propValue.value.int32Values, /*startPos=*/1, &request.userInfo);
     if (!ret.ok()) {
         return Error() << "Failed to parse user info: " << ret.error();
     }
     request.numberAssociationTypes = propValue.value.int32Values[3];
     ret = parseUserAssociationTypes(propValue.value.int32Values, 4, request.numberAssociationTypes,
                                     &request.associationTypes);
     if (!ret.ok()) {
         return Error() << "Failed to parse UserIdentificationAssociationType: " << ret.error();
     }
     return request;
 }

 Result<UserIdentificationSetRequest> toUserIdentificationSetRequest(
         const VehiclePropValue& propValue) {
     auto ret = verifyPropValue(propValue, VehicleProperty::USER_IDENTIFICATION_ASSOCIATION,
                                /*minInt32Values=*/4);
     if (!ret.ok()) {
         return ret.error();
     }
     UserIdentificationSetRequest request;
     request.requestId = propValue.value.int32Values[0];
     ret = parseUserInfo(propValue.value.int32Values, /*startPos=*/1, &request.userInfo);
     if (!ret.ok()) {
         return Error() << "Failed to parse user info: " << ret.error();
     }
     request.numberAssociations = propValue.value.int32Values[3];
     ret = parseUserAssociations(propValue.value.int32Values, 4, request.numberAssociations,
                                 &request.associations);
     if (!ret.ok()) {
         return Error() << "Failed to parse UserIdentificationSetAssociation: " << ret.error();
     }
     return request;
 }

 Result<VehiclePropValuePool::RecyclableType> toVehiclePropValue(VehiclePropValuePool& pool,
                                                                 const SwitchUserRequest& request) {
     if (request.messageType != SwitchUserMessageType::VEHICLE_REQUEST) {
         return Errorf("Invalid %s message type %s from HAL",
                       toString(VehicleProperty::SWITCH_USER).c_str(),
                       toString(request.messageType).c_str());
     }
     int32_t switchUserProp = toInt(VehicleProperty::SWITCH_USER);
     auto propValue = pool.obtain(getPropType(switchUserProp));
     propValue->prop = switchUserProp;
     propValue->timestamp = elapsedRealtimeNano();
     propValue->value.int32Values.resize(3);
     propValue->value.int32Values[0] = static_cast<int32_t>(request.requestId);
     propValue->value.int32Values[1] = static_cast<int32_t>(request.messageType);
     propValue->value.int32Values[2] = static_cast<int32_t>(request.targetUser.userId);
     return propValue;
 }

 VehiclePropValuePool::RecyclableType toVehiclePropValue(VehiclePropValuePool& pool,
                                                         const InitialUserInfoResponse& response) {
     int32_t initialUserInfoProp = toInt(VehicleProperty::INITIAL_USER_INFO);
     auto propValue = pool.obtain(getPropType(initialUserInfoProp));
     propValue->prop = initialUserInfoProp;
     propValue->timestamp = elapsedRealtimeNano();
     propValue->value.int32Values.resize(4);
     propValue->value.int32Values[0] = static_cast<int32_t>(response.requestId);
     propValue->value.int32Values[1] = static_cast<int32_t>(response.action);
     propValue->value.int32Values[2] = static_cast<int32_t>(response.userToSwitchOrCreate.userId);
     propValue->value.int32Values[3] = response.userToSwitchOrCreate.flags;
     propValue->value.stringValue = std::string(response.userLocales) + std::string(kSeparator) +
                                    std::string(response.userNameToCreate);
     return propValue;
 }

 VehiclePropValuePool::RecyclableType toVehiclePropValue(VehiclePropValuePool& pool,
                                                         const SwitchUserResponse& response) {
     int32_t switchUserProp = toInt(VehicleProperty::SWITCH_USER);
     auto propValue = pool.obtain(getPropType(switchUserProp));
     propValue->prop = switchUserProp;
     propValue->timestamp = elapsedRealtimeNano();
     propValue->value.int32Values.resize(3);
     propValue->value.int32Values[0] = static_cast<int32_t>(response.requestId);
     propValue->value.int32Values[1] = static_cast<int32_t>(response.messageType);
     propValue->value.int32Values[2] = static_cast<int32_t>(response.status);
     if (response.status == SwitchUserStatus::FAILURE) {
         propValue->value.stringValue = response.errorMessage;
     }
     return propValue;
 }

 VehiclePropValuePool::RecyclableType toVehiclePropValue(VehiclePropValuePool& pool,
                                                         const CreateUserResponse& response) {
     int32_t createUserProp = toInt(VehicleProperty::CREATE_USER);
     auto propValue = pool.obtain(getPropType(createUserProp));
     propValue->prop = createUserProp;
     propValue->timestamp = elapsedRealtimeNano();
     propValue->value.int32Values.resize(2);
     propValue->value.int32Values[0] = static_cast<int32_t>(response.requestId);
     propValue->value.int32Values[1] = static_cast<int32_t>(response.status);
     if (response.status == CreateUserStatus::FAILURE) {
         propValue->value.stringValue = response.errorMessage;
     }
     return propValue;
 }

 VehiclePropValuePool::RecyclableType toVehiclePropValue(
         VehiclePropValuePool& pool, const UserIdentificationResponse& response) {
     int32_t userIdAssocProp = toInt(VehicleProperty::USER_IDENTIFICATION_ASSOCIATION);
     auto propValue = pool.obtain(getPropType(userIdAssocProp));
     propValue->prop = userIdAssocProp;
     propValue->timestamp = elapsedRealtimeNano();
     propValue->value.int32Values.resize(2 + (response.numberAssociation * 2));
     propValue->value.int32Values[0] = static_cast<int32_t>(response.requestId);
     propValue->value.int32Values[1] = static_cast<int32_t>(response.numberAssociation);
     for (size_t i = 0; i < static_cast<size_t>(response.numberAssociation); ++i) {
         size_t int32ValuesPos = 2 + (2 * i);
         propValue->value.int32Values[int32ValuesPos] =
                 static_cast<int32_t>(response.associations[i].type);
         propValue->value.int32Values[int32ValuesPos + 1] =
                 static_cast<int32_t>(response.associations[i].value);
     }
     if (!response.errorMessage.empty()) {
         propValue->value.stringValue = response.errorMessage;
     }
     return propValue;
 }

 }  // namespace user_hal_helper
 }  // namespace fake
 }  // namespace vehicle
 }  // namespace automotive
 }  // namespace hardware
 }  // namespace android
	/*
	* Copyright (C) 2021 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 "UserHalHelper"

	#include "UserHalHelper.h"

	#include <VehicleUtils.h>
	#include <log/log.h>
	#include <utils/SystemClock.h>

	#include <vector>

	namespace android {
	namespace hardware {
	namespace automotive {
	namespace vehicle {
	namespace fake {
	namespace user_hal_helper {

	namespace {

	using ::aidl::android::hardware::automotive::vehicle::CreateUserRequest;
	using ::aidl::android::hardware::automotive::vehicle::CreateUserResponse;
	using ::aidl::android::hardware::automotive::vehicle::CreateUserStatus;
	using ::aidl::android::hardware::automotive::vehicle::InitialUserInfoRequest;
	using ::aidl::android::hardware::automotive::vehicle::InitialUserInfoRequestType;
	using ::aidl::android::hardware::automotive::vehicle::InitialUserInfoResponse;
	using ::aidl::android::hardware::automotive::vehicle::RemoveUserRequest;
	using ::aidl::android::hardware::automotive::vehicle::SwitchUserMessageType;
	using ::aidl::android::hardware::automotive::vehicle::SwitchUserRequest;
	using ::aidl::android::hardware::automotive::vehicle::SwitchUserResponse;
	using ::aidl::android::hardware::automotive::vehicle::SwitchUserStatus;
	using ::aidl::android::hardware::automotive::vehicle::UserIdentificationAssociationSetValue;
	using ::aidl::android::hardware::automotive::vehicle::UserIdentificationAssociationType;
	using ::aidl::android::hardware::automotive::vehicle::UserIdentificationGetRequest;
	using ::aidl::android::hardware::automotive::vehicle::UserIdentificationResponse;
	using ::aidl::android::hardware::automotive::vehicle::UserIdentificationSetAssociation;
	using ::aidl::android::hardware::automotive::vehicle::UserIdentificationSetRequest;
	using ::aidl::android::hardware::automotive::vehicle::UserInfo;
	using ::aidl::android::hardware::automotive::vehicle::UsersInfo;
	using ::aidl::android::hardware::automotive::vehicle::VehicleProperty;
	using ::aidl::android::hardware::automotive::vehicle::VehiclePropValue;
	using ::android::base::Error;
	using ::android::base::Result;

	constexpr const char kSeparator[] = "\|\|";
	constexpr size_t kNumFieldsPerUserInfo = 2;
	constexpr size_t kNumFieldsPerSetAssociation = 2;

	Result<void> verifyPropValue(const VehiclePropValue& propValue, VehicleProperty vehicleProperty,
	size_t minInt32Values) {
	auto prop = verifyAndCast<VehicleProperty>(propValue.prop);
	if (!prop.ok()) {
	return Error() << "Invalid vehicle property: " << prop.error();
	}
	if (*prop != vehicleProperty) {
	return Error() << "Mismatching " << toString(vehicleProperty) << " request, received "
	<< toString(*prop) << " property";
	}
	if (propValue.value.int32Values.size() < minInt32Values) {
	return Error() << "Int32Values must have at least " << minInt32Values
	<< " values, received " << propValue.value.int32Values.size();
	}
	return {};
	}

	Result<void> parseUserInfo(const std::vector<int32_t>& int32Values, size_t startPos,
	UserInfo* userInfo) {
	if (int32Values.size() < startPos + kNumFieldsPerUserInfo) {
	return Error() << "Int32Values must have at least " << startPos + 2 << " values, received "
	<< int32Values.size();
	}
	userInfo->userId = int32Values[startPos];
	int32_t intUserFlags = int32Values[startPos + 1];
	const int32_t combinedFlags = UserInfo::USER_FLAG_SYSTEM \| UserInfo::USER_FLAG_GUEST \|
	UserInfo::USER_FLAG_EPHEMERAL \| UserInfo::USER_FLAG_ADMIN \|
	UserInfo::USER_FLAG_DISABLED \| UserInfo::USER_FLAG_PROFILE;

	if ((intUserFlags & ~combinedFlags) != 0) {
	return Error() << "Invalid user flags: " << intUserFlags << ", must be '\|' of UserFlags";
	}
	userInfo->flags = intUserFlags;
	return {};
	}

	Result<void> parseUsersInfo(const std::vector<int32_t>& int32Values, size_t startPos,
	UsersInfo* usersInfo) {
	if (int32Values.size() < startPos + 3) {
	return Error() << "Int32Values must have at least " << startPos + 3 << " values, received "
	<< int32Values.size();
	}
	auto ret = parseUserInfo(int32Values, startPos, &usersInfo->currentUser);
	if (!ret.ok()) {
	return ret;
	}
	usersInfo->numberUsers = int32Values[startPos + 2];
	usersInfo->existingUsers.resize(usersInfo->numberUsers);
	for (size_t i = 0; i < static_cast<size_t>(usersInfo->numberUsers); ++i) {
	ret = parseUserInfo(int32Values, startPos + 3 + (kNumFieldsPerUserInfo * i),
	&usersInfo->existingUsers[i]);
	if (!ret.ok()) {
	return Error() << "Failed to parse existing user '" << i << "' info: " << ret.error();
	}
	}
	return {};
	}

	Result<void> parseUserAssociationTypes(
	const std::vector<int32_t>& int32Values, size_t startPos, size_t numberAssociationTypes,
	std::vector<UserIdentificationAssociationType>* associationTypes) {
	size_t minInt32Values = startPos + numberAssociationTypes;
	if (int32Values.size() < minInt32Values) {
	return Error() << "Int32Values must have at least " << minInt32Values
	<< " values, received " << int32Values.size();
	}
	associationTypes->resize(numberAssociationTypes);
	for (size_t i = 0; i < static_cast<size_t>(numberAssociationTypes); ++i) {
	size_t pos = startPos + i;
	auto type = verifyAndCast<UserIdentificationAssociationType>(int32Values[pos]);
	if (!type.ok()) {
	return Error() << "Invalid association type in query '" << i << "': " << type.error();
	}
	(associationTypes)[i] = type;
	}
	return {};
	}

	Result<void> parseUserAssociations(const std::vector<int32_t>& int32Values, size_t startPos,
	size_t numberAssociations,
	std::vector<UserIdentificationSetAssociation>* associations) {
	size_t minInt32Values = startPos + (numberAssociations * kNumFieldsPerSetAssociation);
	if (int32Values.size() < minInt32Values) {
	return Error() << "Int32Values must have at least " << minInt32Values
	<< " values, received " << int32Values.size();
	}
	associations->resize(numberAssociations);
	for (size_t i = 0; i < static_cast<size_t>(numberAssociations); ++i) {
	size_t pos = startPos + (kNumFieldsPerSetAssociation * i);
	auto type = verifyAndCast<UserIdentificationAssociationType>(int32Values[pos]);
	if (!type.ok()) {
	return Error() << "Invalid association type in request '" << i << "': " << type.error();
	}
	(associations)[i].type = type;
	auto value = verifyAndCast<UserIdentificationAssociationSetValue>(int32Values[pos + 1]);
	if (!value.ok()) {
	return Error() << "Invalid association set value in request '" << i
	<< "': " << value.error();
	}
	(associations)[i].value = value;
	}
	return {};
	}

	} // namespace

	template <typename T>
	Result<T> verifyAndCast(int32_t value) {
	T castValue = static_cast<T>(value);
	for (const auto& v : ::ndk::enum_range<T>()) {
	if (castValue == v) {
	return castValue;
	}
	}

	return Error() << "Value " << value << " not in enum values";
	}

	Result<InitialUserInfoRequest> toInitialUserInfoRequest(const VehiclePropValue& propValue) {
	auto ret = verifyPropValue(propValue, VehicleProperty::INITIAL_USER_INFO, /minInt32Values=/2);
	if (!ret.ok()) {
	return ret.error();
	}
	InitialUserInfoRequest request;
	request.requestId = propValue.value.int32Values[0];
	auto requestType = verifyAndCast<InitialUserInfoRequestType>(propValue.value.int32Values[1]);
	if (!requestType.ok()) {
	return Error() << "Invalid InitialUserInfoRequestType: " << requestType.error();
	}
	request.requestType = *requestType;
	ret = parseUsersInfo(propValue.value.int32Values, 2, &request.usersInfo);
	if (!ret.ok()) {
	return Error() << "Failed to parse users info: " << ret.error();
	}
	return request;
	}

	Result<SwitchUserRequest> toSwitchUserRequest(const VehiclePropValue& propValue) {
	auto ret = verifyPropValue(propValue, VehicleProperty::SWITCH_USER, /minInt32Values=/2);
	if (!ret.ok()) {
	return ret.error();
	}
	SwitchUserRequest request;
	auto messageType = verifyAndCast<SwitchUserMessageType>(propValue.value.int32Values[1]);
	if (!messageType.ok()) {
	return Error() << "Invalid SwitchUserMessageType: " << messageType.error();
	}
	if (*messageType != SwitchUserMessageType::LEGACY_ANDROID_SWITCH &&
	*messageType != SwitchUserMessageType::ANDROID_SWITCH &&
	*messageType != SwitchUserMessageType::ANDROID_POST_SWITCH) {
	return Error() << "Invalid " << toString(*messageType)
	<< " message type from Android System";
	}
	request.requestId = propValue.value.int32Values[0];
	request.messageType = *messageType;
	ret = parseUserInfo(propValue.value.int32Values, /startPos=/2, &request.targetUser);
	if (!ret.ok()) {
	return Error() << "Failed to parse target user info: " << ret.error();
	}
	ret = parseUsersInfo(propValue.value.int32Values, /startPos=/4, &request.usersInfo);
	if (!ret.ok()) {
	return Error() << "Failed to parse users info: " << ret.error();
	}
	return request;
	}

	Result<CreateUserRequest> toCreateUserRequest(const VehiclePropValue& propValue) {
	auto ret = verifyPropValue(propValue, VehicleProperty::CREATE_USER, /minInt32Values=/1);
	if (!ret.ok()) {
	return ret.error();
	}
	CreateUserRequest request;
	request.requestId = propValue.value.int32Values[0];
	ret = parseUserInfo(propValue.value.int32Values, /startPos=/1, &request.newUserInfo);
	if (!ret.ok()) {
	return Error() << "Failed to parse new user info: " << ret.error();
	}
	request.newUserName = propValue.value.stringValue;
	ret = parseUsersInfo(propValue.value.int32Values, /startPos=/3, &request.usersInfo);
	if (!ret.ok()) {
	return Error() << "Failed to parse users info: " << ret.error();
	}
	return request;
	}

	Result<RemoveUserRequest> toRemoveUserRequest(const VehiclePropValue& propValue) {
	auto ret = verifyPropValue(propValue, VehicleProperty::REMOVE_USER, /minInt32Values=/1);
	if (!ret.ok()) {
	return ret.error();
	}
	RemoveUserRequest request;
	request.requestId = propValue.value.int32Values[0];
	ret = parseUserInfo(propValue.value.int32Values, /startPos=/1, &request.removedUserInfo);
	if (!ret.ok()) {
	return Error() << "Failed to parse removed user info: " << ret.error();
	}
	ret = parseUsersInfo(propValue.value.int32Values, /startPos=/3, &request.usersInfo);
	if (!ret.ok()) {
	return Error() << "Failed to parse users info: " << ret.error();
	}
	return request;
	}

	Result<UserIdentificationGetRequest> toUserIdentificationGetRequest(
	const VehiclePropValue& propValue) {
	auto ret = verifyPropValue(propValue, VehicleProperty::USER_IDENTIFICATION_ASSOCIATION,
	/minInt32Values=/4);
	if (!ret.ok()) {
	return ret.error();
	}
	UserIdentificationGetRequest request;
	request.requestId = propValue.value.int32Values[0];
	ret = parseUserInfo(propValue.value.int32Values, /startPos=/1, &request.userInfo);
	if (!ret.ok()) {
	return Error() << "Failed to parse user info: " << ret.error();
	}
	request.numberAssociationTypes = propValue.value.int32Values[3];
	ret = parseUserAssociationTypes(propValue.value.int32Values, 4, request.numberAssociationTypes,
	&request.associationTypes);
	if (!ret.ok()) {
	return Error() << "Failed to parse UserIdentificationAssociationType: " << ret.error();
	}
	return request;
	}

	Result<UserIdentificationSetRequest> toUserIdentificationSetRequest(
	const VehiclePropValue& propValue) {
	auto ret = verifyPropValue(propValue, VehicleProperty::USER_IDENTIFICATION_ASSOCIATION,
	/minInt32Values=/4);
	if (!ret.ok()) {
	return ret.error();
	}
	UserIdentificationSetRequest request;
	request.requestId = propValue.value.int32Values[0];
	ret = parseUserInfo(propValue.value.int32Values, /startPos=/1, &request.userInfo);
	if (!ret.ok()) {
	return Error() << "Failed to parse user info: " << ret.error();
	}
	request.numberAssociations = propValue.value.int32Values[3];
	ret = parseUserAssociations(propValue.value.int32Values, 4, request.numberAssociations,
	&request.associations);
	if (!ret.ok()) {
	return Error() << "Failed to parse UserIdentificationSetAssociation: " << ret.error();
	}
	return request;
	}

	Result<VehiclePropValuePool::RecyclableType> toVehiclePropValue(VehiclePropValuePool& pool,
	const SwitchUserRequest& request) {
	if (request.messageType != SwitchUserMessageType::VEHICLE_REQUEST) {
	return Errorf("Invalid %s message type %s from HAL",
	toString(VehicleProperty::SWITCH_USER).c_str(),
	toString(request.messageType).c_str());
	}
	int32_t switchUserProp = toInt(VehicleProperty::SWITCH_USER);
	auto propValue = pool.obtain(getPropType(switchUserProp));
	propValue->prop = switchUserProp;
	propValue->timestamp = elapsedRealtimeNano();
	propValue->value.int32Values.resize(3);
	propValue->value.int32Values[0] = static_cast<int32_t>(request.requestId);
	propValue->value.int32Values[1] = static_cast<int32_t>(request.messageType);
	propValue->value.int32Values[2] = static_cast<int32_t>(request.targetUser.userId);
	return propValue;
	}

	VehiclePropValuePool::RecyclableType toVehiclePropValue(VehiclePropValuePool& pool,
	const InitialUserInfoResponse& response) {
	int32_t initialUserInfoProp = toInt(VehicleProperty::INITIAL_USER_INFO);
	auto propValue = pool.obtain(getPropType(initialUserInfoProp));
	propValue->prop = initialUserInfoProp;
	propValue->timestamp = elapsedRealtimeNano();
	propValue->value.int32Values.resize(4);
	propValue->value.int32Values[0] = static_cast<int32_t>(response.requestId);
	propValue->value.int32Values[1] = static_cast<int32_t>(response.action);
	propValue->value.int32Values[2] = static_cast<int32_t>(response.userToSwitchOrCreate.userId);
	propValue->value.int32Values[3] = response.userToSwitchOrCreate.flags;
	propValue->value.stringValue = std::string(response.userLocales) + std::string(kSeparator) +
	std::string(response.userNameToCreate);
	return propValue;
	}

	VehiclePropValuePool::RecyclableType toVehiclePropValue(VehiclePropValuePool& pool,
	const SwitchUserResponse& response) {
	int32_t switchUserProp = toInt(VehicleProperty::SWITCH_USER);
	auto propValue = pool.obtain(getPropType(switchUserProp));
	propValue->prop = switchUserProp;
	propValue->timestamp = elapsedRealtimeNano();
	propValue->value.int32Values.resize(3);
	propValue->value.int32Values[0] = static_cast<int32_t>(response.requestId);
	propValue->value.int32Values[1] = static_cast<int32_t>(response.messageType);
	propValue->value.int32Values[2] = static_cast<int32_t>(response.status);
	if (response.status == SwitchUserStatus::FAILURE) {
	propValue->value.stringValue = response.errorMessage;
	}
	return propValue;
	}

	VehiclePropValuePool::RecyclableType toVehiclePropValue(VehiclePropValuePool& pool,
	const CreateUserResponse& response) {
	int32_t createUserProp = toInt(VehicleProperty::CREATE_USER);
	auto propValue = pool.obtain(getPropType(createUserProp));
	propValue->prop = createUserProp;
	propValue->timestamp = elapsedRealtimeNano();
	propValue->value.int32Values.resize(2);
	propValue->value.int32Values[0] = static_cast<int32_t>(response.requestId);
	propValue->value.int32Values[1] = static_cast<int32_t>(response.status);
	if (response.status == CreateUserStatus::FAILURE) {
	propValue->value.stringValue = response.errorMessage;
	}
	return propValue;
	}

	VehiclePropValuePool::RecyclableType toVehiclePropValue(
	VehiclePropValuePool& pool, const UserIdentificationResponse& response) {
	int32_t userIdAssocProp = toInt(VehicleProperty::USER_IDENTIFICATION_ASSOCIATION);
	auto propValue = pool.obtain(getPropType(userIdAssocProp));
	propValue->prop = userIdAssocProp;
	propValue->timestamp = elapsedRealtimeNano();
	propValue->value.int32Values.resize(2 + (response.numberAssociation * 2));
	propValue->value.int32Values[0] = static_cast<int32_t>(response.requestId);
	propValue->value.int32Values[1] = static_cast<int32_t>(response.numberAssociation);
	for (size_t i = 0; i < static_cast<size_t>(response.numberAssociation); ++i) {
	size_t int32ValuesPos = 2 + (2 * i);
	propValue->value.int32Values[int32ValuesPos] =
	static_cast<int32_t>(response.associations[i].type);
	propValue->value.int32Values[int32ValuesPos + 1] =
	static_cast<int32_t>(response.associations[i].value);
	}
	if (!response.errorMessage.empty()) {
	propValue->value.stringValue = response.errorMessage;
	}
	return propValue;
	}

	} // namespace user_hal_helper
	} // namespace fake
	} // namespace vehicle
	} // namespace automotive
	} // namespace hardware
	} // namespace android