blob: 47ff581287f3b490c0fb7e3039e836f0def0f4a5 [file] [log] [blame]
/*
* Copyright (C) 2016 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_HIDL_BINDER_SUPPORT_H
#define ANDROID_HIDL_BINDER_SUPPORT_H
#include <sys/types.h>
#include <android/hidl/base/1.0/BnHwBase.h>
#include <android/hidl/base/1.0/IBase.h>
#include <hidl/HidlSupport.h>
#include <hidl/HidlTransportUtils.h>
#include <hidl/MQDescriptor.h>
#include <hidl/Static.h>
#include <hwbinder/IBinder.h>
#include <hwbinder/IPCThreadState.h>
#include <hwbinder/Parcel.h>
#include <hwbinder/ProcessState.h>
// Defines functions for hidl_string, hidl_version, Status, hidl_vec, MQDescriptor,
// etc. to interact with Parcel.
namespace android {
namespace hardware {
// hidl_binder_death_recipient wraps a transport-independent
// hidl_death_recipient, and implements the binder-specific
// DeathRecipient interface.
struct hidl_binder_death_recipient : IBinder::DeathRecipient {
hidl_binder_death_recipient(const sp<hidl_death_recipient> &recipient,
uint64_t cookie, const sp<::android::hidl::base::V1_0::IBase> &base);
virtual void binderDied(const wp<IBinder>& /*who*/);
wp<hidl_death_recipient> getRecipient();
private:
wp<hidl_death_recipient> mRecipient;
uint64_t mCookie;
wp<::android::hidl::base::V1_0::IBase> mBase;
};
// ---------------------- hidl_memory
status_t readEmbeddedFromParcel(const hidl_memory &memory,
const Parcel &parcel, size_t parentHandle, size_t parentOffset);
status_t writeEmbeddedToParcel(const hidl_memory &memory,
Parcel *parcel, size_t parentHandle, size_t parentOffset);
// ---------------------- hidl_string
status_t readEmbeddedFromParcel(const hidl_string &string,
const Parcel &parcel, size_t parentHandle, size_t parentOffset);
status_t writeEmbeddedToParcel(const hidl_string &string,
Parcel *parcel, size_t parentHandle, size_t parentOffset);
// ---------------------- hidl_version
status_t writeToParcel(const hidl_version &version, android::hardware::Parcel& parcel);
// Caller is responsible for freeing the returned object.
hidl_version* readFromParcel(const android::hardware::Parcel& parcel);
// ---------------------- Status
// Bear in mind that if the client or service is a Java endpoint, this
// is not the logic which will provide/interpret the data here.
status_t readFromParcel(Status *status, const Parcel& parcel);
status_t writeToParcel(const Status &status, Parcel* parcel);
// ---------------------- hidl_vec
template<typename T>
status_t readEmbeddedFromParcel(
const hidl_vec<T> &vec,
const Parcel &parcel,
size_t parentHandle,
size_t parentOffset,
size_t *handle) {
const void *out;
return parcel.readNullableEmbeddedBuffer(
vec.size() * sizeof(T),
handle,
parentHandle,
parentOffset + hidl_vec<T>::kOffsetOfBuffer,
&out);
}
template<typename T>
status_t writeEmbeddedToParcel(
const hidl_vec<T> &vec,
Parcel *parcel,
size_t parentHandle,
size_t parentOffset,
size_t *handle) {
return parcel->writeEmbeddedBuffer(
vec.data(),
sizeof(T) * vec.size(),
handle,
parentHandle,
parentOffset + hidl_vec<T>::kOffsetOfBuffer);
}
template<typename T>
status_t findInParcel(const hidl_vec<T> &vec, const Parcel &parcel, size_t *handle) {
return parcel.quickFindBuffer(vec.data(), handle);
}
// ---------------------- MQDescriptor
template<typename T, MQFlavor flavor>
::android::status_t readEmbeddedFromParcel(
MQDescriptor<T, flavor> &obj,
const ::android::hardware::Parcel &parcel,
size_t parentHandle,
size_t parentOffset) {
::android::status_t _hidl_err = ::android::OK;
size_t _hidl_grantors_child;
_hidl_err = ::android::hardware::readEmbeddedFromParcel(
obj.grantors(),
parcel,
parentHandle,
parentOffset + MQDescriptor<T, flavor>::kOffsetOfGrantors,
&_hidl_grantors_child);
if (_hidl_err != ::android::OK) { return _hidl_err; }
const native_handle_t *_hidl_mq_handle_ptr;
_hidl_err = parcel.readNullableEmbeddedNativeHandle(
parentHandle,
parentOffset + MQDescriptor<T, flavor>::kOffsetOfHandle,
&_hidl_mq_handle_ptr);
if (_hidl_err != ::android::OK) { return _hidl_err; }
return _hidl_err;
}
template<typename T, MQFlavor flavor>
::android::status_t writeEmbeddedToParcel(
const MQDescriptor<T, flavor> &obj,
::android::hardware::Parcel *parcel,
size_t parentHandle,
size_t parentOffset) {
::android::status_t _hidl_err = ::android::OK;
size_t _hidl_grantors_child;
_hidl_err = ::android::hardware::writeEmbeddedToParcel(
obj.grantors(),
parcel,
parentHandle,
parentOffset + MQDescriptor<T, flavor>::kOffsetOfGrantors,
&_hidl_grantors_child);
if (_hidl_err != ::android::OK) { return _hidl_err; }
_hidl_err = parcel->writeEmbeddedNativeHandle(
obj.handle(),
parentHandle,
parentOffset + MQDescriptor<T, flavor>::kOffsetOfHandle);
if (_hidl_err != ::android::OK) { return _hidl_err; }
return _hidl_err;
}
// ---------------------- pointers for HIDL
template <typename T>
static status_t readEmbeddedReferenceFromParcel(
T const* * /* bufptr */,
const Parcel & parcel,
size_t parentHandle,
size_t parentOffset,
size_t *handle,
bool *shouldResolveRefInBuffer
) {
// *bufptr is ignored because, if I am embedded in some
// other buffer, the kernel should have fixed me up already.
bool isPreviouslyWritten;
status_t result = parcel.readEmbeddedReference(
nullptr, // ignored, not written to bufptr.
handle,
parentHandle,
parentOffset,
&isPreviouslyWritten);
// tell caller to run T::readEmbeddedToParcel and
// T::readEmbeddedReferenceToParcel if necessary.
// It is not called here because we don't know if these two are valid methods.
*shouldResolveRefInBuffer = !isPreviouslyWritten;
return result;
}
template <typename T>
static status_t writeEmbeddedReferenceToParcel(
T const* buf,
Parcel *parcel, size_t parentHandle, size_t parentOffset,
size_t *handle,
bool *shouldResolveRefInBuffer
) {
if(buf == nullptr) {
*shouldResolveRefInBuffer = false;
return parcel->writeEmbeddedNullReference(handle, parentHandle, parentOffset);
}
// find whether the buffer exists
size_t childHandle, childOffset;
status_t result;
bool found;
result = parcel->findBuffer(buf, sizeof(T), &found, &childHandle, &childOffset);
// tell caller to run T::writeEmbeddedToParcel and
// T::writeEmbeddedReferenceToParcel if necessary.
// It is not called here because we don't know if these two are valid methods.
*shouldResolveRefInBuffer = !found;
if(result != OK) {
return result; // bad pointers and length given
}
if(!found) { // did not find it.
return parcel->writeEmbeddedBuffer(buf, sizeof(T), handle,
parentHandle, parentOffset);
}
// found the buffer. easy case.
return parcel->writeEmbeddedReference(
handle,
childHandle,
childOffset,
parentHandle,
parentOffset);
}
template <typename T>
static status_t readReferenceFromParcel(
T const* *bufptr,
const Parcel & parcel,
size_t *handle,
bool *shouldResolveRefInBuffer
) {
bool isPreviouslyWritten;
status_t result = parcel.readReference(reinterpret_cast<void const* *>(bufptr),
handle, &isPreviouslyWritten);
// tell caller to run T::readEmbeddedToParcel and
// T::readEmbeddedReferenceToParcel if necessary.
// It is not called here because we don't know if these two are valid methods.
*shouldResolveRefInBuffer = !isPreviouslyWritten;
return result;
}
template <typename T>
static status_t writeReferenceToParcel(
T const *buf,
Parcel * parcel,
size_t *handle,
bool *shouldResolveRefInBuffer
) {
if(buf == nullptr) {
*shouldResolveRefInBuffer = false;
return parcel->writeNullReference(handle);
}
// find whether the buffer exists
size_t childHandle, childOffset;
status_t result;
bool found;
result = parcel->findBuffer(buf, sizeof(T), &found, &childHandle, &childOffset);
// tell caller to run T::writeEmbeddedToParcel and
// T::writeEmbeddedReferenceToParcel if necessary.
// It is not called here because we don't know if these two are valid methods.
*shouldResolveRefInBuffer = !found;
if(result != OK) {
return result; // bad pointers and length given
}
if(!found) { // did not find it.
return parcel->writeBuffer(buf, sizeof(T), handle);
}
// found the buffer. easy case.
return parcel->writeReference(handle,
childHandle, childOffset);
}
// ---------------------- support for casting interfaces
// Construct a smallest possible binder from the given interface.
// If it is remote, then its remote() will be retrieved.
// Otherwise, the smallest possible BnChild is found where IChild is a subclass of IType
// and iface is of class IChild. BnChild will be used to wrapped the given iface.
// Return nullptr if iface is null or any failure.
template <typename IType>
sp<IBinder> toBinder(sp<IType> iface) {
IType *ifacePtr = iface.get();
if (ifacePtr == nullptr) {
return nullptr;
}
if (ifacePtr->isRemote()) {
return ::android::hardware::IInterface::asBinder(
static_cast<BpInterface<IType>*>(ifacePtr));
} else {
std::string myDescriptor = details::getDescriptor(ifacePtr);
if (myDescriptor.empty()) {
// interfaceDescriptor fails
return nullptr;
}
// for get + set
std::unique_lock<std::mutex> _lock = details::gBnMap.lock();
wp<BHwBinder> wBnObj = details::gBnMap.getLocked(ifacePtr, nullptr);
sp<IBinder> sBnObj = wBnObj.promote();
if (sBnObj == nullptr) {
auto func = details::gBnConstructorMap.get(myDescriptor, nullptr);
if (!func) {
return nullptr;
}
sBnObj = sp<IBinder>(func(static_cast<void*>(ifacePtr)));
if (sBnObj != nullptr) {
details::gBnMap.setLocked(ifacePtr, static_cast<BHwBinder*>(sBnObj.get()));
}
}
return sBnObj;
}
}
template <typename IType, typename ProxyType, typename StubType>
sp<IType> fromBinder(const sp<IBinder>& binderIface) {
using ::android::hidl::base::V1_0::IBase;
using ::android::hidl::base::V1_0::BnHwBase;
if (binderIface.get() == nullptr) {
return nullptr;
}
if (binderIface->localBinder() == nullptr) {
return new ProxyType(binderIface);
}
sp<IBase> base = static_cast<BnHwBase*>(binderIface.get())->getImpl();
if (details::canCastInterface(base.get(), IType::descriptor)) {
StubType* stub = static_cast<StubType*>(binderIface.get());
return stub->getImpl();
} else {
return nullptr;
}
}
void configureBinderRpcThreadpool(size_t maxThreads, bool callerWillJoin);
void joinBinderRpcThreadpool();
} // namespace hardware
} // namespace android
#endif // ANDROID_HIDL_BINDER_SUPPORT_H