libvehiclenetwork/native/IVehicleNetwork.cpp

/*
 * 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