1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
|
/*
* 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.
*/
#ifndef android_hardware_automotive_vehicle_aidl_impl_vhal_include_ParcelableUtils_H_
#define android_hardware_automotive_vehicle_aidl_impl_vhal_include_ParcelableUtils_H_
#include <LargeParcelableBase.h>
#include <VehicleHalTypes.h>
#include <VehicleUtils.h>
#include <memory>
#include <vector>
namespace android {
namespace hardware {
namespace automotive {
namespace vehicle {
// Turns the values into a stable large parcelable that could be sent via binder.
// If values is small enough, it would be put into output.payloads, otherwise a shared memory file
// would be created and output.sharedMemoryFd would be filled in.
template <class T1, class T2>
ndk::ScopedAStatus vectorToStableLargeParcelable(std::vector<T1>&& values, T2* output) {
output->payloads = std::move(values);
auto result = android::automotive::car_binder_lib::LargeParcelableBase::
parcelableToStableLargeParcelable(*output);
if (!result.ok()) {
return toScopedAStatus(
result, aidl::android::hardware::automotive::vehicle::StatusCode::INTERNAL_ERROR);
}
auto& fd = result.value();
if (fd != nullptr) {
// Move the returned ScopedFileDescriptor pointer to ScopedFileDescriptor value in
// 'sharedMemoryFd' field.
output->payloads.clear();
output->sharedMemoryFd = std::move(*fd);
} else {
output->sharedMemoryFd = ndk::ScopedFileDescriptor();
// Do not modify payloads.
}
return ndk::ScopedAStatus::ok();
}
template <class T1, class T2>
ndk::ScopedAStatus vectorToStableLargeParcelable(const std::vector<T1>& values, T2* output) {
// Because 'values' is passed in as const reference, we have to do a copy here.
std::vector<T1> valuesCopy = values;
return vectorToStableLargeParcelable(std::move(valuesCopy), output);
}
template <class T>
android::base::expected<
android::automotive::car_binder_lib::LargeParcelableBase::BorrowedOwnedObject<T>,
ndk::ScopedAStatus>
fromStableLargeParcelable(const T& largeParcelable) {
auto result = android::automotive::car_binder_lib::LargeParcelableBase::
stableLargeParcelableToParcelable(largeParcelable);
if (!result.ok()) {
return android::base::unexpected(toScopedAStatus(
result, aidl::android::hardware::automotive::vehicle::StatusCode::INVALID_ARG,
"failed to parse large parcelable"));
}
return std::move(result.value());
}
} // namespace vehicle
} // namespace automotive
} // namespace hardware
} // namespace android
#endif // android_hardware_automotive_vehicle_aidl_impl_vhal_include_ParcelableUtils_H_
|
