/*
 * 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.
 */
#define LOG_TAG "VehicleNetwork"

#include <binder/PermissionCache.h>
#include <utils/Errors.h>
#include <utils/SystemClock.h>

#include <private/android_filesystem_config.h>

#include <vehicle-internal.h>

#include "VehicleHalPropertyUtil.h"
#include "VehicleNetworkService.h"

//#define DBG_EVENT
//#define DBG_VERBOSE
#ifdef DBG_EVENT
#define EVENT_LOG(x...) ALOGD(x)
#else
#define EVENT_LOG(x...)
#endif
#ifdef DBG_VERBOSE
#define LOG_VERBOSE(x...) ALOGD(x)
#else
#define LOG_VERBOSE(x...)
#endif

namespace android {

VehicleHalMessageHandler::VehicleHalMessageHandler(const sp<Looper>& looper,
        VehicleNetworkService& service)
    : mLooper(looper),
      mService(service),
      mFreeListIndex(0),
      mLastDispatchTime(0) {
}

VehicleHalMessageHandler::~VehicleHalMessageHandler() {
    Mutex::Autolock autoLock(mLock);
    for (int i = 0; i < NUM_PROPERTY_EVENT_LISTS; i++) {
        for (auto& e : mHalPropertyList[i]) {
            VehiclePropValueUtil::deleteMembers(e);
            delete e;
        }
    }
    for (VehicleHalError* e : mHalErrors) {
        delete e;
    }
}

static const int MS_TO_NS = 1000000;

void VehicleHalMessageHandler::handleHalEvent(vehicle_prop_value_t *eventData) {
    EVENT_LOG("handleHalEvent 0x%x", eventData->prop);
    Mutex::Autolock autoLock(mLock);
    List<vehicle_prop_value_t*>& propList = mHalPropertyList[mFreeListIndex];
    propList.push_back(eventData);
    int64_t deltaFromLast = elapsedRealtime() - mLastDispatchTime;
    if (deltaFromLast > DISPATCH_INTERVAL_MS) {
        mLooper->sendMessage(this, Message(HAL_EVENT));
    } else {
        mLooper->sendMessageDelayed((DISPATCH_INTERVAL_MS - deltaFromLast) * MS_TO_NS,
                this, Message(HAL_EVENT));
    }
}

void VehicleHalMessageHandler::handleHalError(VehicleHalError* error) {
    Mutex::Autolock autoLock(mLock);
    mHalErrors.push_back(error);
    mLooper->sendMessage(this, Message(HAL_ERROR));
}

void VehicleHalMessageHandler::handleMockStart() {
    Mutex::Autolock autoLock(mLock);
    mHalPropertyList[0].clear();
    mHalPropertyList[1].clear();
    sp<MessageHandler> self(this);
    mLooper->removeMessages(self);
}

void VehicleHalMessageHandler::doHandleHalEvent() {
    // event dispatching can take time, so do it outside lock and that requires double buffering.
    // inside lock, free buffer is swapped with non-free buffer.
    List<vehicle_prop_value_t*>* events = NULL;
    do {
        Mutex::Autolock autoLock(mLock);
        mLastDispatchTime = elapsedRealtime();
        int nonFreeListIndex = mFreeListIndex ^ 0x1;
        List<vehicle_prop_value_t*>* nonFreeList = &(mHalPropertyList[nonFreeListIndex]);
        List<vehicle_prop_value_t*>* freeList = &(mHalPropertyList[mFreeListIndex]);
        if (nonFreeList->size() > 0) {
            for (auto& e : *freeList) {
                nonFreeList->push_back(e);
            }
            freeList->clear();
            events = nonFreeList;
        } else if (freeList->size() > 0) {
            events = freeList;
            mFreeListIndex = nonFreeListIndex;
        }
    } while (false);
    if (events != NULL) {
        EVENT_LOG("doHandleHalEvent, num events:%d", events->size());
        mService.dispatchHalEvents(*events);
        //TODO implement return to memory pool
        for (auto& e : *events) {
            VehiclePropValueUtil::deleteMembers(e);
            delete e;
        }
        events->clear();
    }
}

void VehicleHalMessageHandler::doHandleHalError() {
    VehicleHalError* error = NULL;
    do {
        Mutex::Autolock autoLock(mLock);
        if (mHalErrors.size() > 0) {
            auto itr = mHalErrors.begin();
            error = *itr;
            mHalErrors.erase(itr);
        }
    } while (false);
    if (error != NULL) {
        mService.dispatchHalError(error);
    }
}

void VehicleHalMessageHandler::handleMessage(const Message& message) {
    switch (message.what) {
    case HAL_EVENT:
        doHandleHalEvent();
        break;
    case HAL_ERROR:
        doHandleHalError();
        break;
    }
}

// ----------------------------------------------------------------------------

void MockDeathHandler::binderDied(const wp<IBinder>& who) {
    mService.handleHalMockDeath(who);
}

// ----------------------------------------------------------------------------

PropertyValueCache::PropertyValueCache() {

}

PropertyValueCache::~PropertyValueCache() {
    for (size_t i = 0; i < mCache.size(); i++) {
        vehicle_prop_value_t* v = mCache.editValueAt(i);
        VehiclePropValueUtil::deleteMembers(v);
        delete v;
    }
    mCache.clear();
}

void PropertyValueCache::writeToCache(const vehicle_prop_value_t& value) {
    vehicle_prop_value_t* v;
    ssize_t index = mCache.indexOfKey(value.prop);
    if (index < 0) {
        v = VehiclePropValueUtil::allocVehicleProp(value);
        ASSERT_OR_HANDLE_NO_MEMORY(v, return);
        mCache.add(value.prop, v);
    } else {
        v = mCache.editValueAt(index);
        VehiclePropValueUtil::copyVehicleProp(v, value, true /* deleteOldData */);
    }
}

bool PropertyValueCache::readFromCache(vehicle_prop_value_t* value) {
    ssize_t index = mCache.indexOfKey(value->prop);
    if (index < 0) {
        ALOGE("readFromCache 0x%x, not found", value->prop);
        return false;
    }
    const vehicle_prop_value_t* cached = mCache.valueAt(index);
    //TODO this can be improved by just passing pointer and not deleting members.
    status_t r = VehiclePropValueUtil::copyVehicleProp(value, *cached);
    if (r != NO_ERROR) {
        ALOGD("readFromCache 0x%x, copy failed %d", value->prop, r);
        return false;
    }
    return true;
}

// ----------------------------------------------------------------------------


VehicleNetworkService* VehicleNetworkService::sInstance = NULL;

status_t VehicleNetworkService::dump(int fd, const Vector<String16>& /*args*/) {
    static const String16 sDump("android.permission.DUMP");
    String8 msg;
    if (!PermissionCache::checkCallingPermission(sDump)) {
        msg.appendFormat("Permission Denial: "
                    "can't dump VNS from pid=%d, uid=%d\n",
                    IPCThreadState::self()->getCallingPid(),
                    IPCThreadState::self()->getCallingUid());
        write(fd, msg.string(), msg.size());
        return NO_ERROR;
    }
    msg.append("MockingEnabled=%d\n", mMockingEnabled ? 1 : 0);
    msg.append("*Properties\n");
    for (auto& prop : mProperties->getList()) {
        VechilePropertyUtil::dumpProperty(msg, *prop);
    }
    if (mMockingEnabled) {
        msg.append("*Mocked Properties\n");
        for (auto& prop : mPropertiesForMocking->getList()) {
            //TODO dump more info
            msg.appendFormat("property 0x%x\n", prop->prop);
        }
    }
    msg.append("*Active clients*\n");
    for (size_t i = 0; i < mBinderToClientMap.size(); i++) {
        msg.appendFormat("pid %d uid %d\n", mBinderToClientMap.valueAt(i)->getPid(),
                mBinderToClientMap.valueAt(i)->getUid());
    }
    msg.append("*Active clients per property*\n");
    for (size_t i = 0; i < mPropertyToClientsMap.size(); i++) {
        msg.appendFormat("prop 0x%x, pids:", mPropertyToClientsMap.keyAt(i));
        sp<HalClientSpVector> clients = mPropertyToClientsMap.valueAt(i);
        for (size_t j = 0; j < clients->size(); j++) {
            msg.appendFormat("%d,", clients->itemAt(j)->getPid());
        }
        msg.append("\n");
    }
    msg.append("*Subscription info per property*\n");
    for (size_t i = 0; i < mSubscriptionInfos.size(); i++) {
        const SubscriptionInfo& info = mSubscriptionInfos.valueAt(i);
        msg.appendFormat("prop 0x%x, sample rate %f Hz, zones 0x%x\n", mSubscriptionInfos.keyAt(i),
                info.sampleRate, info.zones);
    }
    msg.append("*Event counts per property*\n");
    for (size_t i = 0; i < mEventsCount.size(); i++) {
        msg.appendFormat("prop 0x%x: %d\n", mEventsCount.keyAt(i),
                mEventsCount.valueAt(i));
    }
    msg.append("*Vehicle Network Service Permissions*\n");
    mVehiclePropertyAccessControl.dump(msg);

    write(fd, msg.string(), msg.size());
    return NO_ERROR;
}

bool VehicleNetworkService::isOperationAllowed(int32_t property, bool isWrite) {
    const uid_t uid = IPCThreadState::self()->getCallingUid();

    bool allowed = mVehiclePropertyAccessControl.testAccess(property, uid, isWrite);
    if (!allowed) {
        ALOGW("Property 0x%x: access not allowed for uid %d, isWrite %d", property, uid, isWrite);
    }
    return allowed;
}

VehicleNetworkService::VehicleNetworkService()
    : mModule(NULL),
      mMockingEnabled(false) {
    sInstance = this;

   // Load vehicle network services policy file
   if(!mVehiclePropertyAccessControl.init()) {
     LOG_ALWAYS_FATAL("Vehicle property access policy could not be initialized.");
   }
}

VehicleNetworkService::~VehicleNetworkService() {
    sInstance = NULL;
    for (size_t i = 0; i < mPropertyToClientsMap.size(); i++) {
        sp<HalClientSpVector> clients = mPropertyToClientsMap.editValueAt(i);
        clients->clear();
    }
    mBinderToClientMap.clear();
    mPropertyToClientsMap.clear();
    mSubscriptionInfos.clear();
}

void VehicleNetworkService::binderDied(const wp<IBinder>& who) {
    List<int32_t> propertiesToUnsubscribe;
    do {
        Mutex::Autolock autoLock(mLock);
        sp<IBinder> ibinder = who.promote();
        ibinder->unlinkToDeath(this);
        ssize_t index = mBinderToClientMap.indexOfKey(ibinder);
        if (index < 0) {
            // already removed. ignore
            return;
        }
        sp<HalClient> currentClient = mBinderToClientMap.editValueAt(index);
        ALOGW("client binder death, pid: %d, uid:%d", currentClient->getPid(),
                currentClient->getUid());
        mBinderToClientMap.removeItemsAt(index);

        for (size_t i = 0; i < mPropertyToClientsMap.size(); i++) {
            sp<HalClientSpVector>& clients = mPropertyToClientsMap.editValueAt(i);
            clients->remove(currentClient);
            // TODO update frame rate
            if (clients->size() == 0) {
                int32_t property = mPropertyToClientsMap.keyAt(i);
                propertiesToUnsubscribe.push_back(property);
                mSubscriptionInfos.removeItem(property);
            }
        }
        for (int32_t property : propertiesToUnsubscribe) {
            mPropertyToClientsMap.removeItem(property);
        }
    } while (false);
    for (int32_t property : propertiesToUnsubscribe) {
        mDevice->unsubscribe(mDevice, property);
    }
}

void VehicleNetworkService::handleHalMockDeath(const wp<IBinder>& who) {
    ALOGE("Hal mock binder died");
    sp<IBinder> ibinder = who.promote();
    stopMocking(IVehicleNetworkHalMock::asInterface(ibinder));
}

int VehicleNetworkService::eventCallback(const vehicle_prop_value_t *eventData) {
    EVENT_LOG("eventCallback 0x%x");
    sInstance->onHalEvent(eventData);
    return NO_ERROR;
}

int VehicleNetworkService::errorCallback(int32_t errorCode, int32_t property, int32_t operation) {
    status_t r = sInstance->onHalError(errorCode, property, operation);
    if (r != NO_ERROR) {
        ALOGE("VehicleNetworkService::errorCallback onHalError failed with %d", r);
    }
    return NO_ERROR;
}

extern "C" {
vehicle_prop_config_t const * getInternalProperties();
int getNumInternalProperties();
};

void VehicleNetworkService::onFirstRef() {
    Mutex::Autolock autoLock(mLock);
    status_t r = loadHal();
    if (r!= NO_ERROR) {
        ALOGE("cannot load HAL, error:%d", r);
        return;
    }
    mHandlerThread = new HandlerThread();
    r = mHandlerThread->start("HAL.NATIVE_LOOP");
    if (r != NO_ERROR) {
        ALOGE("cannot start handler thread, error:%d", r);
        return;
    }
    sp<VehicleHalMessageHandler> handler(new VehicleHalMessageHandler(mHandlerThread->getLooper(),
            *this));
    ASSERT_ALWAYS_ON_NO_MEMORY(handler.get());
    mHandler = handler;
    r = mDevice->init(mDevice, eventCallback, errorCallback);
    if (r != NO_ERROR) {
        ALOGE("HAL init failed:%d", r);
        return;
    }
    int numConfigs = 0;
    vehicle_prop_config_t const* configs = mDevice->list_properties(mDevice, &numConfigs);
    mProperties = new VehiclePropertiesHolder(false /* deleteConfigsInDestructor */);
    ASSERT_ALWAYS_ON_NO_MEMORY(mProperties);
    for (int i = 0; i < numConfigs; i++) {
        mProperties->getList().push_back(&configs[i]);
    }
    configs = getInternalProperties();
    for (int i = 0; i < getNumInternalProperties(); i++) {
        mProperties->getList().push_back(&configs[i]);
    }
}

void VehicleNetworkService::release() {
    do {
        Mutex::Autolock autoLock(mLock);
        mHandlerThread->quit();
    } while (false);
    mDevice->release(mDevice);
}

vehicle_prop_config_t const * VehicleNetworkService::findConfigLocked(int32_t property) {
    for (auto& config : (mMockingEnabled ?
            mPropertiesForMocking->getList() : mProperties->getList())) {
        if (config->prop == property) {
            return config;
        }
    }
    ALOGW("property not found 0x%x", property);
    return NULL;
}

bool VehicleNetworkService::isGettableLocked(int32_t property) {
    vehicle_prop_config_t const * config = findConfigLocked(property);
    if (config == NULL) {
        return false;
    }
    if ((config->access & VEHICLE_PROP_ACCESS_READ) == 0) {
        ALOGI("cannot get, property 0x%x is write only", property);
        return false;
    }
    return true;
}

bool VehicleNetworkService::isSettableLocked(int32_t property, int32_t valueType) {
    vehicle_prop_config_t const * config = findConfigLocked(property);
    if (config == NULL) {
        return false;
    }
    if ((config->access & VEHICLE_PROP_ACCESS_WRITE) == 0) {
        ALOGI("cannot set, property 0x%x is read only", property);
        return false;
    }
    if (config->value_type != valueType) {
        ALOGW("cannot set, property 0x%x expects type 0x%x while got 0x%x", property,
                config->value_type, valueType);
        return false;
    }
    return true;
}

bool VehicleNetworkService::isSubscribableLocked(int32_t property) {
    vehicle_prop_config_t const * config = findConfigLocked(property);
    if (config == NULL) {
        return false;
    }
    if ((config->access & VEHICLE_PROP_ACCESS_READ) == 0) {
        ALOGI("cannot subscribe, property 0x%x is write only", property);
        return false;
    }
    if (config->change_mode == VEHICLE_PROP_CHANGE_MODE_STATIC) {
        ALOGI("cannot subscribe, property 0x%x is static", property);
        return false;
    }
    return true;
}

bool VehicleNetworkService::isZonedProperty(vehicle_prop_config_t const * config) {
    if (config == NULL) {
        return false;
    }
    switch (config->value_type) {
    case VEHICLE_VALUE_TYPE_ZONED_INT32:
    case VEHICLE_VALUE_TYPE_ZONED_FLOAT:
    case VEHICLE_VALUE_TYPE_ZONED_BOOLEAN:
    case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC2:
    case VEHICLE_VALUE_TYPE_ZONED_INT32_VEC3:
    case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC2:
    case VEHICLE_VALUE_TYPE_ZONED_FLOAT_VEC3:
        return true;
    }
    return false;
}

sp<VehiclePropertiesHolder> VehicleNetworkService::listProperties(int32_t property) {
    Mutex::Autolock autoLock(mLock);
    if (property == 0) {
        if (!mMockingEnabled) {
            return mProperties;
        } else {
            return mPropertiesForMocking;
        }
    } else {
        sp<VehiclePropertiesHolder> p;
        const vehicle_prop_config_t* config = findConfigLocked(property);
        if (config != NULL) {
            p = new VehiclePropertiesHolder(false /* deleteConfigsInDestructor */);
            p->getList().push_back(config);
            ASSERT_OR_HANDLE_NO_MEMORY(p.get(), return p);
        }
        return p;
    }
}

status_t VehicleNetworkService::getProperty(vehicle_prop_value_t *data) {
    bool inMocking = false;
    do { // for lock scoping
        Mutex::Autolock autoLock(mLock);
        if (!isGettableLocked(data->prop)) {
            ALOGW("getProperty, cannot get 0x%x", data->prop);
            return BAD_VALUE;
        }
        if ((data->prop >= (int32_t)VEHICLE_PROPERTY_INTERNAL_START) &&
                (data->prop <= (int32_t)VEHICLE_PROPERTY_INTERNAL_END)) {
            if (!mCache.readFromCache(data)) {
                return BAD_VALUE;
            }
            return NO_ERROR;
        }
        //TODO caching for static, on-change type?
        if (mMockingEnabled) {
            inMocking = true;
        }
    } while (false);
    // set done outside lock to allow concurrent access
    if (inMocking) {
        status_t r = mHalMock->onPropertyGet(data);
        if (r != NO_ERROR) {
            ALOGW("getProperty 0x%x failed, mock returned %d", data->prop, r);
        }
        return r;
    }
    /*
     * get call can return -EAGAIN error when hal has not fetched all data. In that case,
     * keep retrying for certain time with some sleep. This will happen only at initial stage.
     */
    status_t r = -EAGAIN;
    int retryCount = 0;
    while (true) {
        r = mDevice->get(mDevice, data);
        if (r == NO_ERROR) {
            break;
        }
        if (r != -EAGAIN) {
            break;
        }
        retryCount++;
        if (retryCount > MAX_GET_RETRY_FOR_NOT_READY) {
            ALOGE("Vehicle hal keep retrying not ready after multiple retries");
            break;
        }
        usleep(GET_WAIT_US);
    }
    if (r != NO_ERROR) {
        ALOGW("getProperty 0x%x failed, HAL returned %d", data->prop, r);
    }
    return r;
}

void VehicleNetworkService::releaseMemoryFromGet(vehicle_prop_value_t* value) {
    switch (value->prop) {
    case VEHICLE_VALUE_TYPE_STRING:
    case VEHICLE_VALUE_TYPE_BYTES: {
        Mutex::Autolock autoLock(mLock);
        mDevice->release_memory_from_get(mDevice, value);
    } break;
    }
}

status_t VehicleNetworkService::setProperty(const vehicle_prop_value_t& data) {
    bool isInternalProperty = false;
    bool inMocking = false;
    do { // for lock scoping
        Mutex::Autolock autoLock(mLock);
        if (!isSettableLocked(data.prop, data.value_type)) {
            ALOGW("setProperty, cannot set 0x%x", data.prop);
            return BAD_VALUE;
        }
        if ((data.prop >= (int32_t)VEHICLE_PROPERTY_INTERNAL_START) &&
                            (data.prop <= (int32_t)VEHICLE_PROPERTY_INTERNAL_END)) {
            isInternalProperty = true;
            mCache.writeToCache(data);
        }
        if (mMockingEnabled) {
            inMocking = true;
        }
    } while (false);
    if (inMocking) {
        status_t r = mHalMock->onPropertySet(data);
        if (r != NO_ERROR) {
            ALOGW("setProperty 0x%x failed, mock returned %d", data.prop, r);
            return r;
        }
    }
    if (isInternalProperty) {
        // for internal property, just publish it.
        onHalEvent(&data, inMocking);
        return NO_ERROR;
    }
    if (inMocking) {
        return NO_ERROR;
    }
    //TODO add value check requires auto generated code to return value range for enum types
    // set done outside lock to allow concurrent access
    status_t r = mDevice->set(mDevice, &data);
    if (r != NO_ERROR) {
        ALOGW("setProperty 0x%x failed, HAL returned %d", data.prop, r);
    }
    return r;
}

status_t VehicleNetworkService::subscribe(const sp<IVehicleNetworkListener> &listener, int32_t prop,
        float sampleRate, int32_t zones) {
    bool shouldSubscribe = false;
    bool inMock = false;
    int32_t newZones = zones;
    do {
        Mutex::Autolock autoLock(mLock);
        if (!isSubscribableLocked(prop)) {
            return BAD_VALUE;
        }
        vehicle_prop_config_t const * config = findConfigLocked(prop);
        if (config->change_mode == VEHICLE_PROP_CHANGE_MODE_ON_CHANGE) {
            if (sampleRate != 0) {
                ALOGW("Sample rate set to non-zeo for on change type. Ignore it");
                sampleRate = 0;
            }
        } else {
            if (sampleRate > config->max_sample_rate) {
                ALOGW("sample rate %f higher than max %f. limit to max", sampleRate,
                        config->max_sample_rate);
                sampleRate = config->max_sample_rate;
            }
            if (sampleRate < config->min_sample_rate) {
                ALOGW("sample rate %f lower than min %f. limit to min", sampleRate,
                                    config->min_sample_rate);
                sampleRate = config->min_sample_rate;
            }
        }
        if (isZonedProperty(config)) {
            if ((zones != 0) && ((zones & config->vehicle_zone_flags) != zones)) {
                ALOGE("subscribe requested zones 0x%x out of range, supported:0x%x", zones,
                        config->vehicle_zone_flags);
                return BAD_VALUE;
            }
        } else { // ignore zone
            zones = 0;
        }
        sp<IBinder> ibinder = IInterface::asBinder(listener);
        LOG_VERBOSE("subscribe, binder 0x%x prop 0x%x", ibinder.get(), prop);
        sp<HalClient> client = findOrCreateClientLocked(ibinder, listener);
        if (client.get() == NULL) {
            ALOGE("subscribe, no memory, cannot create HalClient");
            return NO_MEMORY;
        }
        sp<HalClientSpVector> clientsForProperty = findOrCreateClientsVectorForPropertyLocked(prop);
        if (clientsForProperty.get() == NULL) {
            ALOGE("subscribe, no memory, cannot create HalClientSpVector");
            return NO_MEMORY;
        }
        clientsForProperty->add(client);
        ssize_t index = mSubscriptionInfos.indexOfKey(prop);
        if (index < 0) {
            // first time subscription for this property
            shouldSubscribe = true;
        } else {
            const SubscriptionInfo& info = mSubscriptionInfos.valueAt(index);
            if (info.sampleRate < sampleRate) {
                shouldSubscribe = true;
            }
            newZones = (info.zones == 0) ? 0 : ((zones == 0) ? 0 : (info.zones | zones));
            if (info.zones != newZones) {
                shouldSubscribe = true;
            }
        }
        client->setSubscriptionInfo(prop, sampleRate, zones);
        if (shouldSubscribe) {
            inMock = mMockingEnabled;
            SubscriptionInfo info(sampleRate, newZones);
            mSubscriptionInfos.add(prop, info);
            if ((prop >= (int32_t)VEHICLE_PROPERTY_INTERNAL_START) &&
                                (prop <= (int32_t)VEHICLE_PROPERTY_INTERNAL_END)) {
                LOG_VERBOSE("subscribe to internal property, prop 0x%x", prop);
                return NO_ERROR;
            }
        }
    } while (false);
    if (shouldSubscribe) {
        status_t r;
        if (inMock) {
            r = mHalMock->onPropertySubscribe(prop, sampleRate, newZones);
            if (r != NO_ERROR) {
                ALOGW("subscribe 0x%x failed, mock returned %d", prop, r);
            }
        } else {
            LOG_VERBOSE("subscribe to HAL, prop 0x%x sample rate:%f zones:0x%x", prop, sampleRate,
                    newZones);
            r = mDevice->subscribe(mDevice, prop, sampleRate, newZones);
            if (r != NO_ERROR) {
                ALOGW("subscribe 0x%x failed, HAL returned %d", prop, r);
            }
        }
        return r;
    }
    return NO_ERROR;
}

void VehicleNetworkService::unsubscribe(const sp<IVehicleNetworkListener> &listener, int32_t prop) {
    bool shouldUnsubscribe = false;
    bool inMocking = false;
    do {
        Mutex::Autolock autoLock(mLock);
        if (!isSubscribableLocked(prop)) {
            return;
        }
        sp<IBinder> ibinder = IInterface::asBinder(listener);
        LOG_VERBOSE("unsubscribe, binder 0x%x, prop 0x%x", ibinder.get(), prop);
        sp<HalClient> client = findClientLocked(ibinder);
        if (client.get() == NULL) {
            ALOGD("unsubscribe client not found in binder map");
            return;
        }
        shouldUnsubscribe = removePropertyFromClientLocked(ibinder, client, prop);
        if ((prop >= (int32_t)VEHICLE_PROPERTY_INTERNAL_START) &&
                (prop <= (int32_t)VEHICLE_PROPERTY_INTERNAL_END)) {
            LOG_VERBOSE("unsubscribe to internal property, prop 0x%x", prop);
            return;
        }
        if (mMockingEnabled) {
            inMocking = true;
        }
    } while (false);
    if (shouldUnsubscribe) {
        if (inMocking) {
            mHalMock->onPropertyUnsubscribe(prop);
        } else {
            mDevice->unsubscribe(mDevice, prop);
        }
    }
}

sp<HalClient> VehicleNetworkService::findClientLocked(sp<IBinder>& ibinder) {
    sp<HalClient> client;
    ssize_t index = mBinderToClientMap.indexOfKey(ibinder);
    if (index < 0) {
        return client;
    }
    return mBinderToClientMap.editValueAt(index);
}

sp<HalClient> VehicleNetworkService::findOrCreateClientLocked(sp<IBinder>& ibinder,
        const sp<IVehicleNetworkListener> &listener) {
    sp<HalClient> client;
    ssize_t index = mBinderToClientMap.indexOfKey(ibinder);
    if (index < 0) {
        IPCThreadState* self = IPCThreadState::self();
        pid_t pid = self->getCallingPid();
        uid_t uid = self->getCallingUid();
        client = new HalClient(listener, pid, uid);
        ASSERT_OR_HANDLE_NO_MEMORY(client.get(), return client);
        ibinder->linkToDeath(this);
        LOG_VERBOSE("add binder 0x%x to map", ibinder.get());
        mBinderToClientMap.add(ibinder, client);
    } else {
        client = mBinderToClientMap.editValueAt(index);
    }
    return client;
}

sp<HalClientSpVector> VehicleNetworkService::findClientsVectorForPropertyLocked(int32_t property) {
    sp<HalClientSpVector> clientsForProperty;
    ssize_t index = mPropertyToClientsMap.indexOfKey(property);
    if (index >= 0) {
        clientsForProperty = mPropertyToClientsMap.editValueAt(index);
    }
    return clientsForProperty;
}

sp<HalClientSpVector> VehicleNetworkService::findOrCreateClientsVectorForPropertyLocked(
        int32_t property) {
    sp<HalClientSpVector> clientsForProperty;
    ssize_t index = mPropertyToClientsMap.indexOfKey(property);
    if (index >= 0) {
        clientsForProperty = mPropertyToClientsMap.editValueAt(index);
    } else {
        clientsForProperty = new HalClientSpVector();
        ASSERT_OR_HANDLE_NO_MEMORY(clientsForProperty.get(), return clientsForProperty);
        mPropertyToClientsMap.add(property, clientsForProperty);
    }
    return clientsForProperty;
}

/**
 * remove given property from client and remove HalCLient if necessary.
 * @return true if the property should be unsubscribed from HAL (=no more clients).
 */
bool VehicleNetworkService::removePropertyFromClientLocked(sp<IBinder>& ibinder,
        sp<HalClient>& client, int32_t property) {
    if(!client->removePropertyAndCheckIfActive(property)) {
        // client is no longer necessary
        mBinderToClientMap.removeItem(ibinder);
        ibinder->unlinkToDeath(this);
    }
    sp<HalClientSpVector> clientsForProperty = findClientsVectorForPropertyLocked(property);
    if (clientsForProperty.get() == NULL) {
        // no subscription
        return false;
    }
    clientsForProperty->remove(client);
    //TODO reset sample rate. do not care for now.
    if (clientsForProperty->size() == 0) {
        mPropertyToClientsMap.removeItem(property);
        mSubscriptionInfos.removeItem(property);
        return true;
    }
    return false;
}

status_t VehicleNetworkService::injectEvent(const vehicle_prop_value_t& value) {
    ALOGI("injectEvent property:0x%x", value.prop);
    return onHalEvent(&value, true);
}

status_t VehicleNetworkService::startMocking(const sp<IVehicleNetworkHalMock>& mock) {
    sp<VehicleHalMessageHandler> handler;
    List<sp<HalClient> > clientsToDispatch;
    do {
        Mutex::Autolock autoLock(mLock);
        if (mMockingEnabled) {
            ALOGW("startMocking while already enabled");
            // allow it as test can fail without clearing
            if (mHalMock != NULL) {
                IInterface::asBinder(mHalMock)->unlinkToDeath(mHalMockDeathHandler.get());
            }
        }
        ALOGW("starting vehicle HAL mocking");
        sp<IBinder> ibinder = IInterface::asBinder(mock);
        if (mHalMockDeathHandler.get() == NULL) {
            mHalMockDeathHandler = new MockDeathHandler(*this);
        }
        ibinder->linkToDeath(mHalMockDeathHandler);
        mHalMock = mock;
        mMockingEnabled = true;
        // Mock implementation should make sure that its startMocking call is not blocking its
        // onlistProperties call. Otherwise, this will lead into dead-lock.
        mPropertiesForMocking = mock->onListProperties();
        handleHalRestartAndGetClientsToDispatchLocked(clientsToDispatch);
        //TODO handle binder death
        handler = mHandler;
    } while (false);
    handler->handleMockStart();
    for (auto& client : clientsToDispatch) {
        client->dispatchHalRestart(true);
    }
    clientsToDispatch.clear();
    return NO_ERROR;
}

void VehicleNetworkService::stopMocking(const sp<IVehicleNetworkHalMock>& mock) {
    List<sp<HalClient> > clientsToDispatch;
    do {
        Mutex::Autolock autoLock(mLock);
        if (mHalMock.get() == NULL) {
            return;
        }
        sp<IBinder> ibinder = IInterface::asBinder(mock);
        if (ibinder != IInterface::asBinder(mHalMock)) {
            ALOGE("stopMocking, not the one started");
            return;
        }
        ALOGW("stopping vehicle HAL mocking");
        ibinder->unlinkToDeath(mHalMockDeathHandler.get());
        mHalMock = NULL;
        mMockingEnabled = false;
        handleHalRestartAndGetClientsToDispatchLocked(clientsToDispatch);
    } while (false);
    for (auto& client : clientsToDispatch) {
        client->dispatchHalRestart(false);
    }
    clientsToDispatch.clear();
}

void VehicleNetworkService::handleHalRestartAndGetClientsToDispatchLocked(
        List<sp<HalClient> >& clientsToDispatch) {
    // all subscriptions are invalid
    mPropertyToClientsMap.clear();
    mSubscriptionInfos.clear();
    mEventsCount.clear();
    List<sp<HalClient> > clientsToRemove;
    for (size_t i = 0; i < mBinderToClientMap.size(); i++) {
        sp<HalClient> client = mBinderToClientMap.valueAt(i);
        client->removeAllProperties();
        if (client->isMonitoringHalRestart()) {
            clientsToDispatch.push_back(client);
        }
        if (!client->isActive()) {
            clientsToRemove.push_back(client);
        }
    }
    for (auto& client : clientsToRemove) {
        // client is no longer necessary
        sp<IBinder> ibinder = IInterface::asBinder(client->getListener());
        mBinderToClientMap.removeItem(ibinder);
        ibinder->unlinkToDeath(this);
    }
    clientsToRemove.clear();
}

status_t VehicleNetworkService::injectHalError(int32_t errorCode, int32_t property,
        int32_t operation) {
    return onHalError(errorCode, property, operation, true /*isInjection*/);
}

status_t VehicleNetworkService::startErrorListening(const sp<IVehicleNetworkListener> &listener) {
    sp<IBinder> ibinder = IInterface::asBinder(listener);
    sp<HalClient> client;
    do {
        Mutex::Autolock autoLock(mLock);
        client = findOrCreateClientLocked(ibinder, listener);
    } while (false);
    if (client.get() == NULL) {
        ALOGW("startErrorListening failed, no memory");
        return NO_MEMORY;
    }
    client->setHalErrorMonitoringState(true);
    return NO_ERROR;
}

void VehicleNetworkService::stopErrorListening(const sp<IVehicleNetworkListener> &listener) {
    sp<IBinder> ibinder = IInterface::asBinder(listener);
    sp<HalClient> client;
    do {
        Mutex::Autolock autoLock(mLock);
        client = findClientLocked(ibinder);
    } while (false);
    if (client.get() != NULL) {
        client->setHalErrorMonitoringState(false);
    }
}

status_t VehicleNetworkService::startHalRestartMonitoring(
        const sp<IVehicleNetworkListener> &listener) {
    sp<IBinder> ibinder = IInterface::asBinder(listener);
    sp<HalClient> client;
    do {
        Mutex::Autolock autoLock(mLock);
        client = findOrCreateClientLocked(ibinder, listener);
    } while (false);
    if (client.get() == NULL) {
        ALOGW("startHalRestartMonitoring failed, no memory");
        return NO_MEMORY;
    }
    client->setHalRestartMonitoringState(true);
    return NO_ERROR;
}

void VehicleNetworkService::stopHalRestartMonitoring(const sp<IVehicleNetworkListener> &listener) {
    sp<IBinder> ibinder = IInterface::asBinder(listener);
    sp<HalClient> client;
    do {
        Mutex::Autolock autoLock(mLock);
        client = findClientLocked(ibinder);
    } while (false);
    if (client.get() != NULL) {
        client->setHalRestartMonitoringState(false);
    }
}

status_t VehicleNetworkService::onHalEvent(const vehicle_prop_value_t* eventData, bool isInjection)
{
    sp<VehicleHalMessageHandler> handler;
    do {
        Mutex::Autolock autoLock(mLock);
        if (!isInjection) {
            if (mMockingEnabled) {
                // drop real HAL event if mocking is enabled
                return NO_ERROR;
            }
        }
        ssize_t index = mEventsCount.indexOfKey(eventData->prop);
        if (index < 0) {
            mEventsCount.add(eventData->prop, 1);
        } else {
            int count = mEventsCount.valueAt(index);
            count++;
            mEventsCount.add(eventData->prop, count);
        }
        handler = mHandler;
    } while (false);
    //TODO add memory pool
    vehicle_prop_value_t* copy = VehiclePropValueUtil::allocVehicleProp(*eventData);
    ASSERT_OR_HANDLE_NO_MEMORY(copy, return NO_MEMORY);
    handler->handleHalEvent(copy);
    return NO_ERROR;
}

status_t VehicleNetworkService::onHalError(int32_t errorCode, int32_t property, int32_t operation,
        bool isInjection) {
    sp<VehicleHalMessageHandler> handler;
    VehicleHalError* error = NULL;
    do {
        Mutex::Autolock autoLock(mLock);
        if (!isInjection) {
            if (mMockingEnabled) {
                // drop real HAL error if mocking is enabled
                return NO_ERROR;
            }
        }

        error = new VehicleHalError(errorCode, property, operation);
        if (error == NULL) {
            return NO_MEMORY;
        }
        handler = mHandler;
    } while (false);
    ALOGI("HAL error, error code:%d, property:0x%x, operation:%d, isInjection:%d",
            errorCode, property, operation, isInjection? 1 : 0);
    handler->handleHalError(error);
    return NO_ERROR;
}

void VehicleNetworkService::dispatchHalEvents(List<vehicle_prop_value_t*>& events) {
    HalClientSpVector activeClients;
    do { // for lock scoping
        Mutex::Autolock autoLock(mLock);
        for (vehicle_prop_value_t* e : events) {
            ssize_t index = mPropertyToClientsMap.indexOfKey(e->prop);
            if (index < 0) {
                EVENT_LOG("HAL event for not subscribed property 0x%x", e->prop);
                continue;
            }
            sp<HalClientSpVector>& clients = mPropertyToClientsMap.editValueAt(index);
            EVENT_LOG("dispatchHalEvents, prop 0x%x, active clients %d", e->prop, clients->size());
            for (size_t i = 0; i < clients->size(); i++) {
                sp<HalClient>& client = clients->editItemAt(i);
                activeClients.add(client);
                client->addEvent(e);
            }
        }
    } while (false);
    EVENT_LOG("dispatchHalEvents num events %d, active clients:%d", events.size(),
            activeClients.size());
    for (size_t i = 0; i < activeClients.size(); i++) {
        sp<HalClient> client = activeClients.editItemAt(i);
        client->dispatchEvents();
    }
    activeClients.clear();
}

void VehicleNetworkService::dispatchHalError(VehicleHalError* error) {
    List<sp<HalClient> > clientsToDispatch;
    do {
        Mutex::Autolock autoLock(mLock);
        if (error->property != 0) {
            sp<HalClientSpVector> clientsForProperty = findClientsVectorForPropertyLocked(
                    error->property);
            if (clientsForProperty.get() != NULL) {
                for (size_t i = 0; i < clientsForProperty->size(); i++) {
                    sp<HalClient> client = clientsForProperty->itemAt(i);
                    clientsToDispatch.push_back(client);
                }
            }
        }
        // Send to global error handler if property is 0 or if no client subscribing.
        if (error->property == 0 || clientsToDispatch.size() == 0) {
            for (size_t i = 0; i < mBinderToClientMap.size(); i++) {
                sp<HalClient> client = mBinderToClientMap.valueAt(i);
                if (client->isMonitoringHalError()) {
                    clientsToDispatch.push_back(client);
                }
            }
        }
    } while (false);
    ALOGI("dispatchHalError error:%d, property:0x%x, operation:%d, num clients to dispatch:%d",
            error->errorCode, error->property, error->operation, clientsToDispatch.size());
    for (auto& client : clientsToDispatch) {
        client->dispatchHalError(error->errorCode, error->property, error->operation);
    }
    clientsToDispatch.clear();
}

status_t VehicleNetworkService::loadHal() {
    int r = hw_get_module(VEHICLE_HARDWARE_MODULE_ID, (hw_module_t const**)&mModule);
    if (r != NO_ERROR) {
        ALOGE("cannot load HAL module, error:%d", r);
        return r;
    }
    r = mModule->common.methods->open(&mModule->common, VEHICLE_HARDWARE_DEVICE,
            (hw_device_t**)&mDevice);
    return r;
}

void VehicleNetworkService::closeHal() {
    mDevice->common.close(&mDevice->common);
}
};