| /* |
| * Copyright (C) 2015 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 "VehicleNetwork" |
| |
| #include <memory> |
| #include <string.h> |
| |
| #include <binder/IPCThreadState.h> |
| #include <binder/Status.h> |
| |
| #include <utils/Log.h> |
| |
| #include <IVehicleNetwork.h> |
| #include <VehicleNetworkProto.pb.h> |
| |
| #include "BinderUtil.h" |
| #include "VehicleNetworkProtoUtil.h" |
| |
| namespace android { |
| |
| enum { |
| LIST_PROPERTIES = IBinder::FIRST_CALL_TRANSACTION, |
| SET_PROPERTY, |
| GET_PROPERTY, |
| SUBSCRIBE, |
| UNSUBSCRIBE, |
| INJECT_EVENT, |
| START_MOCKING, |
| STOP_MOCKING, |
| INJECT_HAL_ERROR, |
| START_ERROR_LISTENING, |
| STOP_ERROR_LISTENING, |
| START_HAL_RESTART_MONITORING, |
| STOP_HAL_RESTART_MONITORING |
| }; |
| |
| // ---------------------------------------------------------------------------- |
| |
| const char IVehicleNetwork::SERVICE_NAME[] = "com.android.car.vehiclenetwork.IVehicleNetwork"; |
| |
| // ---------------------------------------------------------------------------- |
| |
| class BpVehicleNetwork : public BpInterface<IVehicleNetwork> { |
| public: |
| BpVehicleNetwork(const sp<IBinder> & impl) |
| : BpInterface<IVehicleNetwork>(impl) { |
| } |
| |
| virtual sp<VehiclePropertiesHolder> listProperties(int32_t property) { |
| sp<VehiclePropertiesHolder> holder; |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeInt32(property); |
| status_t status = remote()->transact(LIST_PROPERTIES, data, &reply); |
| if (status == NO_ERROR) { |
| reply.readExceptionCode(); // for compatibility with java |
| if (reply.readInt32() == 0) { // no result |
| return holder; |
| } |
| ReadableBlobHolder blob(new Parcel::ReadableBlob()); |
| if (blob.blob == NULL) { |
| ALOGE("listProperties, no memory"); |
| return holder; |
| } |
| int32_t size = reply.readInt32(); |
| status = reply.readBlob(size, blob.blob); |
| if (status != NO_ERROR) { |
| ALOGE("listProperties, cannot read blob %d", status); |
| return holder; |
| } |
| //TODO make this more memory efficient |
| std::unique_ptr<VehiclePropConfigs> configs(new VehiclePropConfigs()); |
| if (configs.get() == NULL) { |
| return holder; |
| } |
| if(!configs->ParseFromArray(blob.blob->data(), size)) { |
| ALOGE("listProperties, cannot parse reply"); |
| return holder; |
| } |
| holder = new VehiclePropertiesHolder(); |
| ASSERT_OR_HANDLE_NO_MEMORY(holder.get(), return); |
| status = VehicleNetworkProtoUtil::fromVehiclePropConfigs(*configs.get(), |
| holder->getList()); |
| if (status != NO_ERROR) { |
| ALOGE("listProperties, cannot convert VehiclePropConfigs %d", status); |
| return holder; |
| } |
| |
| } |
| return holder; |
| } |
| |
| virtual status_t setProperty(const vehicle_prop_value_t& value) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| status_t status = VehiclePropValueBinderUtil::writeToParcel(data, value); |
| if (status != NO_ERROR) { |
| return status; |
| } |
| status = remote()->transact(SET_PROPERTY, data, &reply); |
| return status; |
| } |
| |
| virtual status_t getProperty(vehicle_prop_value_t* value) { |
| Parcel data, reply; |
| if (value == NULL) { |
| return BAD_VALUE; |
| } |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| status_t status = VehiclePropValueBinderUtil::writeToParcel(data, *value); |
| if (status != NO_ERROR) { |
| ALOGE("getProperty, cannot write"); |
| return status; |
| } |
| status = remote()->transact(GET_PROPERTY, data, &reply); |
| if (status == NO_ERROR) { |
| int32_t exceptionCode = reply.readExceptionCode(); |
| if (exceptionCode != NO_ERROR) { |
| if (exceptionCode == binder::Status::EX_SERVICE_SPECIFIC) { |
| return -EAGAIN; |
| } |
| return exceptionCode; |
| } |
| status = VehiclePropValueBinderUtil::readFromParcel(reply, value); |
| } |
| return status; |
| } |
| |
| virtual status_t subscribe(const sp<IVehicleNetworkListener> &listener, int32_t property, |
| float sampleRate, int32_t zones) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeStrongBinder(IInterface::asBinder(listener)); |
| data.writeInt32(property); |
| data.writeFloat(sampleRate); |
| data.writeInt32(zones); |
| status_t status = remote()->transact(SUBSCRIBE, data, &reply); |
| return status; |
| } |
| |
| virtual void unsubscribe(const sp<IVehicleNetworkListener> &listener, int32_t property) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeStrongBinder(IInterface::asBinder(listener)); |
| data.writeInt32(property); |
| status_t status = remote()->transact(UNSUBSCRIBE, data, &reply); |
| if (status != NO_ERROR) { |
| ALOGI("unsubscribing property %d failed %d", property, status); |
| } |
| } |
| |
| virtual status_t injectEvent(const vehicle_prop_value_t& value) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeInt32(1); // 0 means no value. For compatibility with aidl based code. |
| std::unique_ptr<VehiclePropValue> v(new VehiclePropValue()); |
| ASSERT_OR_HANDLE_NO_MEMORY(v.get(), return NO_MEMORY); |
| VehicleNetworkProtoUtil::toVehiclePropValue(value, *v.get()); |
| int size = v->ByteSize(); |
| WritableBlobHolder blob(new Parcel::WritableBlob()); |
| ASSERT_OR_HANDLE_NO_MEMORY(blob.blob, return NO_MEMORY); |
| data.writeInt32(size); |
| data.writeBlob(size, false, blob.blob); |
| v->SerializeToArray(blob.blob->data(), size); |
| status_t status = remote()->transact(INJECT_EVENT, data, &reply); |
| return status; |
| } |
| |
| virtual status_t startMocking(const sp<IVehicleNetworkHalMock>& mock) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeStrongBinder(IInterface::asBinder(mock)); |
| status_t status = remote()->transact(START_MOCKING, data, &reply); |
| return status; |
| } |
| |
| virtual void stopMocking(const sp<IVehicleNetworkHalMock>& mock) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeStrongBinder(IInterface::asBinder(mock)); |
| status_t status = remote()->transact(STOP_MOCKING, data, &reply); |
| if (status != NO_ERROR) { |
| ALOGI("stop mocking failed %d", status); |
| } |
| } |
| |
| status_t injectHalError(int32_t errorCode, int32_t property, int32_t operation) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeInt32(errorCode); |
| data.writeInt32(property); |
| data.writeInt32(operation); |
| status_t status = remote()->transact(INJECT_HAL_ERROR, data, &reply); |
| return status; |
| } |
| |
| virtual status_t startErrorListening(const sp<IVehicleNetworkListener> &listener) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeStrongBinder(IInterface::asBinder(listener)); |
| status_t status = remote()->transact(START_ERROR_LISTENING, data, &reply); |
| return status; |
| } |
| |
| virtual void stopErrorListening(const sp<IVehicleNetworkListener> &listener) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeStrongBinder(IInterface::asBinder(listener)); |
| status_t status = remote()->transact(STOP_ERROR_LISTENING, data, &reply); |
| if (status != NO_ERROR) { |
| ALOGI("stopErrorListening %d", status); |
| } |
| } |
| |
| virtual status_t startHalRestartMonitoring(const sp<IVehicleNetworkListener> &listener) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeStrongBinder(IInterface::asBinder(listener)); |
| status_t status = remote()->transact(START_HAL_RESTART_MONITORING, data, &reply); |
| return status; |
| } |
| |
| virtual void stopHalRestartMonitoring(const sp<IVehicleNetworkListener> &listener) { |
| Parcel data, reply; |
| data.writeInterfaceToken(IVehicleNetwork::getInterfaceDescriptor()); |
| data.writeStrongBinder(IInterface::asBinder(listener)); |
| status_t status = remote()->transact(STOP_HAL_RESTART_MONITORING, data, &reply); |
| if (status != NO_ERROR) { |
| ALOGI("stopHalRestartMonitoring %d", status); |
| } |
| } |
| }; |
| |
| IMPLEMENT_META_INTERFACE(VehicleNetwork, IVehicleNetwork::SERVICE_NAME); |
| |
| // ---------------------------------------------------------------------- |
| |
| status_t BnVehicleNetwork::onTransact(uint32_t code, const Parcel& data, Parcel* reply, |
| uint32_t flags) { |
| status_t r; |
| switch (code) { |
| case LIST_PROPERTIES: { |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| if (!isOperationAllowed(0, false)) { |
| return PERMISSION_DENIED; |
| } |
| int32_t property = data.readInt32(); |
| sp<VehiclePropertiesHolder> holder = listProperties(property); |
| if (holder.get() == NULL) { // given property not found |
| BinderUtil::fillObjectResultReply(reply, false /* isValid */); |
| return NO_ERROR; |
| } |
| std::unique_ptr<VehiclePropConfigs> configs(new VehiclePropConfigs()); |
| ASSERT_OR_HANDLE_NO_MEMORY(configs.get(), return NO_MEMORY); |
| VehicleNetworkProtoUtil::toVehiclePropConfigs(holder->getList(), *configs.get()); |
| int size = configs->ByteSize(); |
| WritableBlobHolder blob(new Parcel::WritableBlob()); |
| ASSERT_OR_HANDLE_NO_MEMORY(blob.blob, return NO_MEMORY); |
| BinderUtil::fillObjectResultReply(reply, true); |
| reply->writeInt32(size); |
| reply->writeBlob(size, false, blob.blob); |
| configs->SerializeToArray(blob.blob->data(), size); |
| return NO_ERROR; |
| } break; |
| case SET_PROPERTY: { |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| ScopedVehiclePropValue value; |
| r = VehiclePropValueBinderUtil::readFromParcel(data, &value.value, |
| false /* deleteMembers */); |
| if (r != NO_ERROR) { |
| return r; |
| } |
| if (!isOperationAllowed(value.value.prop, true)) { |
| return PERMISSION_DENIED; |
| } |
| r = setProperty(value.value); |
| BinderUtil::fillNoResultReply(reply); |
| return r; |
| } break; |
| case GET_PROPERTY: { |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| vehicle_prop_value_t value; |
| memset(&value, 0, sizeof(value)); |
| r = VehiclePropValueBinderUtil::readFromParcel(data, &value, |
| false /* deleteMembers */, true /*canIgnoreNoData*/); |
| if (r != NO_ERROR) { |
| ALOGE("getProperty cannot read %d", r); |
| return r; |
| } |
| if (!isOperationAllowed(value.prop, false)) { |
| return PERMISSION_DENIED; |
| } |
| r = getProperty(&value); |
| if (r == NO_ERROR) { |
| reply->writeNoException(); |
| r = VehiclePropValueBinderUtil::writeToParcel(*reply, value); |
| releaseMemoryFromGet(&value); |
| } else if (r == -EAGAIN) { |
| // this should be handled specially to throw ServiceSpecificException in java. |
| reply->writeInt32(binder::Status::EX_SERVICE_SPECIFIC); |
| return NO_ERROR; |
| } |
| return r; |
| } break; |
| case SUBSCRIBE: { |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| sp<IVehicleNetworkListener> listener = |
| interface_cast<IVehicleNetworkListener>(data.readStrongBinder()); |
| int32_t property = data.readInt32(); |
| if (!isOperationAllowed(property, false)) { |
| return PERMISSION_DENIED; |
| } |
| float sampleRate = data.readFloat(); |
| int32_t zones = data.readInt32(); |
| r = subscribe(listener, property, sampleRate, zones); |
| BinderUtil::fillNoResultReply(reply); |
| return r; |
| } break; |
| case UNSUBSCRIBE: { |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| sp<IVehicleNetworkListener> listener = |
| interface_cast<IVehicleNetworkListener>(data.readStrongBinder()); |
| int32_t property = data.readInt32(); |
| if (!isOperationAllowed(property, false)) { |
| return PERMISSION_DENIED; |
| } |
| unsubscribe(listener, property); |
| BinderUtil::fillNoResultReply(reply); |
| return NO_ERROR; |
| } break; |
| case INJECT_EVENT: { |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| if (data.readInt32() == 0) { // java side allows passing null with this. |
| return BAD_VALUE; |
| } |
| if (!isOperationAllowed(0, true)) { |
| return PERMISSION_DENIED; |
| } |
| ScopedVehiclePropValue value; |
| ReadableBlobHolder blob(new Parcel::ReadableBlob()); |
| ASSERT_OR_HANDLE_NO_MEMORY(blob.blob, return NO_MEMORY); |
| int32_t size = data.readInt32(); |
| r = data.readBlob(size, blob.blob); |
| if (r != NO_ERROR) { |
| ALOGE("injectEvent:service, cannot read blob"); |
| return r; |
| } |
| std::unique_ptr<VehiclePropValue> v(new VehiclePropValue()); |
| ASSERT_OR_HANDLE_NO_MEMORY(v.get(), return NO_MEMORY); |
| if (!v->ParseFromArray(blob.blob->data(), size)) { |
| ALOGE("injectEvent:service, cannot parse data"); |
| return BAD_VALUE; |
| } |
| r = VehicleNetworkProtoUtil::fromVehiclePropValue(*v.get(), value.value); |
| if (r != NO_ERROR) { |
| ALOGE("injectEvent:service, cannot convert data"); |
| return BAD_VALUE; |
| } |
| r = injectEvent(value.value); |
| BinderUtil::fillNoResultReply(reply); |
| return r; |
| } break; |
| case START_MOCKING: { |
| if (!isOperationAllowed(0, true)) { |
| return PERMISSION_DENIED; |
| } |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| sp<IVehicleNetworkHalMock> mock = |
| interface_cast<IVehicleNetworkHalMock>(data.readStrongBinder()); |
| r = startMocking(mock); |
| BinderUtil::fillNoResultReply(reply); |
| return r; |
| } break; |
| case STOP_MOCKING: { |
| if (!isOperationAllowed(0, true)) { |
| return PERMISSION_DENIED; |
| } |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| sp<IVehicleNetworkHalMock> mock = |
| interface_cast<IVehicleNetworkHalMock>(data.readStrongBinder()); |
| stopMocking(mock); |
| BinderUtil::fillNoResultReply(reply); |
| return NO_ERROR; |
| } break; |
| case INJECT_HAL_ERROR: { |
| if (!isOperationAllowed(0, true)) { |
| return PERMISSION_DENIED; |
| } |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| int32_t errorCode = data.readInt32(); |
| int32_t property = data.readInt32(); |
| int32_t operation = data.readInt32(); |
| r = injectHalError(errorCode, property, operation); |
| BinderUtil::fillNoResultReply(reply); |
| return r; |
| } break; |
| case START_ERROR_LISTENING: { |
| if (!isOperationAllowed(0, false)) { |
| return PERMISSION_DENIED; |
| } |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| sp<IVehicleNetworkListener> listener = |
| interface_cast<IVehicleNetworkListener>(data.readStrongBinder()); |
| r = startErrorListening(listener); |
| BinderUtil::fillNoResultReply(reply); |
| return r; |
| } break; |
| case STOP_ERROR_LISTENING: { |
| if (!isOperationAllowed(0, false)) { |
| return PERMISSION_DENIED; |
| } |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| sp<IVehicleNetworkListener> listener = |
| interface_cast<IVehicleNetworkListener>(data.readStrongBinder()); |
| stopErrorListening(listener); |
| BinderUtil::fillNoResultReply(reply); |
| return NO_ERROR; |
| } break; |
| case START_HAL_RESTART_MONITORING: { |
| if (!isOperationAllowed(0, false)) { |
| return PERMISSION_DENIED; |
| } |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| sp<IVehicleNetworkListener> listener = |
| interface_cast<IVehicleNetworkListener>(data.readStrongBinder()); |
| r = startHalRestartMonitoring(listener); |
| BinderUtil::fillNoResultReply(reply); |
| return r; |
| } break; |
| case STOP_HAL_RESTART_MONITORING: { |
| if (!isOperationAllowed(0, false)) { |
| return PERMISSION_DENIED; |
| } |
| CHECK_INTERFACE(IVehicleNetwork, data, reply); |
| sp<IVehicleNetworkListener> listener = |
| interface_cast<IVehicleNetworkListener>(data.readStrongBinder()); |
| stopHalRestartMonitoring(listener); |
| BinderUtil::fillNoResultReply(reply); |
| return NO_ERROR; |
| } break; |
| default: |
| return BBinder::onTransact(code, data, reply, flags); |
| } |
| } |
| |
| }; // namespace android |
