blob: a596917945ff3acee2c9848c1f7fffffa2e4031c [file] [log] [blame]
Yifan Hong7f97f442016-11-14 18:31:05 -08001/*
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_HIDL_BINDER_SUPPORT_H
18#define ANDROID_HIDL_BINDER_SUPPORT_H
19
20#include <hidl/HidlSupport.h>
21#include <hidl/MQDescriptor.h>
Yifan Hongb2c9c752016-12-07 15:15:41 -080022#include <hidl/Static.h>
Yifan Hong7f97f442016-11-14 18:31:05 -080023#include <hwbinder/IBinder.h>
24#include <hwbinder/Parcel.h>
25
26// Defines functions for hidl_string, hidl_version, Status, hidl_vec, MQDescriptor,
27// etc. to interact with Parcel.
28
29namespace android {
30namespace hardware {
31
Martijn Coenen30791002016-12-01 15:40:46 +010032// ---------------------- hidl_memory
33
34status_t readEmbeddedFromParcel(hidl_memory *memory,
35 const Parcel &parcel, size_t parentHandle, size_t parentOffset);
36
37status_t writeEmbeddedToParcel(const hidl_memory &memory,
38 Parcel *parcel, size_t parentHandle, size_t parentOffset);
39
Yifan Hong7f97f442016-11-14 18:31:05 -080040// ---------------------- hidl_string
41
42status_t readEmbeddedFromParcel(hidl_string *string,
43 const Parcel &parcel, size_t parentHandle, size_t parentOffset);
44
45status_t writeEmbeddedToParcel(const hidl_string &string,
46 Parcel *parcel, size_t parentHandle, size_t parentOffset);
47
48// ---------------------- hidl_version
49
50status_t writeToParcel(const hidl_version &version, android::hardware::Parcel& parcel);
51
52// Caller is responsible for freeing the returned object.
53hidl_version* readFromParcel(const android::hardware::Parcel& parcel);
54
55// ---------------------- Status
56
57// Bear in mind that if the client or service is a Java endpoint, this
58// is not the logic which will provide/interpret the data here.
59status_t readFromParcel(Status *status, const Parcel& parcel);
60status_t writeToParcel(const Status &status, Parcel* parcel);
61
62// ---------------------- hidl_vec
63
64template<typename T>
65status_t readEmbeddedFromParcel(
66 hidl_vec<T> * /*vec*/,
67 const Parcel &parcel,
68 size_t parentHandle,
69 size_t parentOffset,
70 size_t *handle) {
71 const void *ptr = parcel.readEmbeddedBuffer(
72 handle,
73 parentHandle,
74 parentOffset + hidl_vec<T>::kOffsetOfBuffer);
75
76 return ptr != NULL ? OK : UNKNOWN_ERROR;
77}
78
79template<typename T>
80status_t writeEmbeddedToParcel(
81 const hidl_vec<T> &vec,
82 Parcel *parcel,
83 size_t parentHandle,
84 size_t parentOffset,
85 size_t *handle) {
86 return parcel->writeEmbeddedBuffer(
87 vec.data(),
88 sizeof(T) * vec.size(),
89 handle,
90 parentHandle,
91 parentOffset + hidl_vec<T>::kOffsetOfBuffer);
92}
93
94template<typename T>
95status_t findInParcel(const hidl_vec<T> &vec, const Parcel &parcel, size_t *handle) {
96 return parcel.quickFindBuffer(vec.data(), handle);
97}
98
99// ---------------------- MQDescriptor
100
101template<MQFlavor flavor>
102::android::status_t readEmbeddedFromParcel(
103 MQDescriptor<flavor> *obj,
104 const ::android::hardware::Parcel &parcel,
105 size_t parentHandle,
106 size_t parentOffset) {
107 ::android::status_t _hidl_err = ::android::OK;
108
109 size_t _hidl_grantors_child;
110
111 _hidl_err = ::android::hardware::readEmbeddedFromParcel(
112 &obj->grantors(),
113 parcel,
114 parentHandle,
115 parentOffset + MQDescriptor<flavor>::kOffsetOfGrantors,
116 &_hidl_grantors_child);
117
118 if (_hidl_err != ::android::OK) { return _hidl_err; }
119
120 const native_handle_t *_hidl_mq_handle_ptr = parcel.readEmbeddedNativeHandle(
121 parentHandle,
122 parentOffset + MQDescriptor<flavor>::kOffsetOfHandle);
123
124 if (_hidl_mq_handle_ptr == nullptr) {
125 _hidl_err = ::android::UNKNOWN_ERROR;
126 return _hidl_err;
127 }
128
129 return _hidl_err;
130}
131
132template<MQFlavor flavor>
133::android::status_t writeEmbeddedToParcel(
134 const MQDescriptor<flavor> &obj,
135 ::android::hardware::Parcel *parcel,
136 size_t parentHandle,
137 size_t parentOffset) {
138 ::android::status_t _hidl_err = ::android::OK;
139
140 size_t _hidl_grantors_child;
141
142 _hidl_err = ::android::hardware::writeEmbeddedToParcel(
143 obj.grantors(),
144 parcel,
145 parentHandle,
146 parentOffset + MQDescriptor<flavor>::kOffsetOfGrantors,
147 &_hidl_grantors_child);
148
149 if (_hidl_err != ::android::OK) { return _hidl_err; }
150
151 _hidl_err = parcel->writeEmbeddedNativeHandle(
152 obj.handle(),
153 parentHandle,
154 parentOffset + MQDescriptor<flavor>::kOffsetOfHandle);
155
156 if (_hidl_err != ::android::OK) { return _hidl_err; }
157
158 return _hidl_err;
159}
160
161// ---------------------- pointers for HIDL
162
163template <typename T>
164static status_t readEmbeddedReferenceFromParcel(
165 T const* * /* bufptr */,
166 const Parcel & parcel,
167 size_t parentHandle,
168 size_t parentOffset,
169 size_t *handle,
170 bool *shouldResolveRefInBuffer
171 ) {
172 // *bufptr is ignored because, if I am embedded in some
173 // other buffer, the kernel should have fixed me up already.
174 bool isPreviouslyWritten;
175 status_t result = parcel.readEmbeddedReference(
176 nullptr, // ignored, not written to bufptr.
177 handle,
178 parentHandle,
179 parentOffset,
180 &isPreviouslyWritten);
181 // tell caller to run T::readEmbeddedToParcel and
182 // T::readEmbeddedReferenceToParcel if necessary.
183 // It is not called here because we don't know if these two are valid methods.
184 *shouldResolveRefInBuffer = !isPreviouslyWritten;
185 return result;
186}
187
188template <typename T>
189static status_t writeEmbeddedReferenceToParcel(
190 T const* buf,
191 Parcel *parcel, size_t parentHandle, size_t parentOffset,
192 size_t *handle,
193 bool *shouldResolveRefInBuffer
194 ) {
195
196 if(buf == nullptr) {
197 *shouldResolveRefInBuffer = false;
198 return parcel->writeEmbeddedNullReference(handle, parentHandle, parentOffset);
199 }
200
201 // find whether the buffer exists
202 size_t childHandle, childOffset;
203 status_t result;
204 bool found;
205
206 result = parcel->findBuffer(buf, sizeof(T), &found, &childHandle, &childOffset);
207
208 // tell caller to run T::writeEmbeddedToParcel and
209 // T::writeEmbeddedReferenceToParcel if necessary.
210 // It is not called here because we don't know if these two are valid methods.
211 *shouldResolveRefInBuffer = !found;
212
213 if(result != OK) {
214 return result; // bad pointers and length given
215 }
216 if(!found) { // did not find it.
217 return parcel->writeEmbeddedBuffer(buf, sizeof(T), handle,
218 parentHandle, parentOffset);
219 }
220 // found the buffer. easy case.
221 return parcel->writeEmbeddedReference(
222 handle,
223 childHandle,
224 childOffset,
225 parentHandle,
226 parentOffset);
227}
228
229template <typename T>
230static status_t readReferenceFromParcel(
231 T const* *bufptr,
232 const Parcel & parcel,
233 size_t *handle,
234 bool *shouldResolveRefInBuffer
235 ) {
236 bool isPreviouslyWritten;
237 status_t result = parcel.readReference(reinterpret_cast<void const* *>(bufptr),
238 handle, &isPreviouslyWritten);
239 // tell caller to run T::readEmbeddedToParcel and
240 // T::readEmbeddedReferenceToParcel if necessary.
241 // It is not called here because we don't know if these two are valid methods.
242 *shouldResolveRefInBuffer = !isPreviouslyWritten;
243 return result;
244}
245
246template <typename T>
247static status_t writeReferenceToParcel(
248 T const *buf,
249 Parcel * parcel,
250 size_t *handle,
251 bool *shouldResolveRefInBuffer
252 ) {
253
254 if(buf == nullptr) {
255 *shouldResolveRefInBuffer = false;
256 return parcel->writeNullReference(handle);
257 }
258
259 // find whether the buffer exists
260 size_t childHandle, childOffset;
261 status_t result;
262 bool found;
263
264 result = parcel->findBuffer(buf, sizeof(T), &found, &childHandle, &childOffset);
265
266 // tell caller to run T::writeEmbeddedToParcel and
267 // T::writeEmbeddedReferenceToParcel if necessary.
268 // It is not called here because we don't know if these two are valid methods.
269 *shouldResolveRefInBuffer = !found;
270
271 if(result != OK) {
272 return result; // bad pointers and length given
273 }
274 if(!found) { // did not find it.
275 return parcel->writeBuffer(buf, sizeof(T), handle);
276 }
277 // found the buffer. easy case.
278 return parcel->writeReference(handle,
279 childHandle, childOffset);
280}
281
282// ---------------------- support for casting interfaces
283
Yifan Hong7f97f442016-11-14 18:31:05 -0800284// Construct a smallest possible binder from the given interface.
285// If it is remote, then its remote() will be retrieved.
286// Otherwise, the smallest possible BnChild is found where IChild is a subclass of IType
287// and iface is of class IChild. BnChild will be used to wrapped the given iface.
288// Return nullptr if iface is null or any failure.
289template <typename IType, typename IHwType>
290sp<IBinder> toBinder(sp<IType> iface) {
291 IType *ifacePtr = iface.get();
292 if (ifacePtr == nullptr) {
293 return nullptr;
294 }
295 if (ifacePtr->isRemote()) {
296 return ::android::hardware::IInterface::asBinder(static_cast<IHwType *>(ifacePtr));
297 } else {
298 std::string myDescriptor{};
299 ifacePtr->interfaceChain([&](const hidl_vec<hidl_string> &types) {
300 if (types.size() > 0) {
301 myDescriptor = types[0].c_str();
302 }
303 });
304 if (myDescriptor.empty()) {
Yifan Hongb2c9c752016-12-07 15:15:41 -0800305 // interfaceChain fails
Yifan Hong7f97f442016-11-14 18:31:05 -0800306 return nullptr;
307 }
308 auto iter = gBnConstructorMap.find(myDescriptor);
309 if (iter == gBnConstructorMap.end()) {
310 return nullptr;
311 }
312 return sp<IBinder>((iter->second)(reinterpret_cast<void *>(ifacePtr)));
313 }
314}
315
316#define IMPLEMENT_SERVICE_MANAGER_INTERACTIONS(INTERFACE, PACKAGE) \
317 ::android::sp<I##INTERFACE> I##INTERFACE::getService( \
318 const std::string &serviceName, bool getStub) \
319 { \
320 using ::android::sp; \
321 using ::android::hardware::defaultServiceManager; \
Yifan Hong7f97f442016-11-14 18:31:05 -0800322 using ::android::hidl::manager::V1_0::IServiceManager; \
323 sp<I##INTERFACE> iface; \
324 const sp<IServiceManager> sm = defaultServiceManager(); \
325 if (sm != nullptr && !getStub) { \
Yifan Hong2cd440c2016-11-23 11:30:36 -0800326 sp<::android::hidl::base::V1_0::IBase> base; \
Yifan Hong7f97f442016-11-14 18:31:05 -0800327 ::android::hardware::Return<void> ret = \
328 sm->get(PACKAGE "::I" #INTERFACE, serviceName.c_str(), \
Yifan Hong2cd440c2016-11-23 11:30:36 -0800329 [&base](sp<::android::hidl::base::V1_0::IBase> found) { \
330 base = found; \
Yifan Hong7f97f442016-11-14 18:31:05 -0800331 }); \
332 if (ret.getStatus().isOk()) { \
Yifan Hong2cd440c2016-11-23 11:30:36 -0800333 iface = I##INTERFACE::castFrom(base); \
Yifan Hong7f97f442016-11-14 18:31:05 -0800334 if (iface != nullptr) { \
335 return iface; \
336 } \
337 } \
338 } \
339 int dlMode = RTLD_LAZY; \
340 void *handle = dlopen(HAL_LIBRARY_PATH_ODM PACKAGE "-impl.so", dlMode); \
341 if (handle == nullptr) { \
342 handle = dlopen(HAL_LIBRARY_PATH_VENDOR PACKAGE "-impl.so", dlMode); \
343 } \
344 if (handle == nullptr) { \
345 handle = dlopen(HAL_LIBRARY_PATH_SYSTEM PACKAGE "-impl.so", dlMode); \
346 } \
347 if (handle == nullptr) { \
348 return iface; \
349 } \
350 I##INTERFACE* (*generator)(const char* name); \
351 *(void **)(&generator) = dlsym(handle, "HIDL_FETCH_I"#INTERFACE); \
352 if (generator) { \
353 iface = (*generator)(serviceName.c_str()); \
354 if (iface != nullptr) { \
355 iface = new Bs##INTERFACE(iface); \
356 } \
357 } \
358 return iface; \
359 } \
360 ::android::status_t I##INTERFACE::registerAsService( \
361 const std::string &serviceName) \
362 { \
363 using ::android::sp; \
364 using ::android::hardware::defaultServiceManager; \
365 using ::android::hidl::manager::V1_0::IServiceManager; \
366 sp<Bn##INTERFACE> binderIface = new Bn##INTERFACE(this); \
367 const sp<IServiceManager> sm = defaultServiceManager(); \
368 bool success = false; \
369 ::android::hardware::Return<void> ret = \
370 this->interfaceChain( \
371 [&success, &sm, &serviceName, &binderIface](const auto &chain) { \
Steven Moreland337c3ae2016-11-22 13:37:32 -0800372 ::android::hardware::Return<bool> addRet = \
373 sm->add(chain, serviceName.c_str(), binderIface); \
Steven Moreland1cfaee72016-12-01 08:34:19 -0800374 success = addRet.isOk() && addRet; \
Yifan Hong7f97f442016-11-14 18:31:05 -0800375 }); \
376 success = success && ret.getStatus().isOk(); \
377 return success ? ::android::OK : ::android::UNKNOWN_ERROR; \
378 } \
379 bool I##INTERFACE::registerForNotifications( \
380 const std::string &serviceName, \
381 const ::android::sp<::android::hidl::manager::V1_0::IServiceNotification> \
382 &notification) \
383 { \
384 using ::android::sp; \
385 using ::android::hardware::defaultServiceManager; \
386 using ::android::hidl::manager::V1_0::IServiceManager; \
387 const sp<IServiceManager> sm = defaultServiceManager(); \
388 if (sm == nullptr) { \
389 return false; \
390 } \
Steven Moreland337c3ae2016-11-22 13:37:32 -0800391 ::android::hardware::Return<bool> success = \
392 sm->registerForNotifications(PACKAGE "::I" #INTERFACE, \
393 serviceName, \
394 notification); \
Steven Moreland1cfaee72016-12-01 08:34:19 -0800395 return success.isOk() && success; \
Yifan Hong7f97f442016-11-14 18:31:05 -0800396 }
397
398
399} // namespace hardware
400} // namespace android
401
402
403#endif // ANDROID_HIDL_BINDER_SUPPORT_H