1/* 2 * Copyright (C) 2015 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 18 19#define LOG_TAG "VehicleNetworkListener" 20 21#include <memory> 22 23#include <utils/Errors.h> 24#include <utils/Log.h> 25 26#include <VehicleNetworkProto.pb.h> 27 28#include <IVehicleNetworkListener.h> 29 30#include "VehicleNetworkProtoUtil.h" 31 32namespace android { 33 34enum { 35 ON_EVENTS = IBinder::FIRST_CALL_TRANSACTION, 36 ON_HAL_ERROR, 37 ON_HAL_RESTART, 38}; 39 40class BpVehicleNetworkListener : public BpInterface<IVehicleNetworkListener> 41{ 42public: 43 BpVehicleNetworkListener(const sp<IBinder> & impl) 44 : BpInterface<IVehicleNetworkListener>(impl) { 45 } 46 47 virtual void onEvents(sp<VehiclePropValueListHolder>& events) { 48 Parcel data, reply; 49 data.writeInterfaceToken(IVehicleNetworkListener::getInterfaceDescriptor()); 50 std::unique_ptr<VehiclePropValues> values(new VehiclePropValues()); 51 ASSERT_OR_HANDLE_NO_MEMORY(values.get(), return NO_MEMORY); 52 status_t r = VehicleNetworkProtoUtil::toVehiclePropValues(events->getList(), *values.get()); 53 if (r != NO_ERROR) { 54 ALOGE("onEvents: toVehiclePropValues failed %d", r); 55 return; 56 } 57 data.writeInt32(1); // for java compatibility 58 WritableBlobHolder blob(new Parcel::WritableBlob()); 59 int size = values->ByteSize(); 60 data.writeInt32(size); 61 data.writeBlob(size, false, blob.blob); 62 values->SerializeToArray(blob.blob->data(), size); 63 remote()->transact(ON_EVENTS, data, &reply); 64 } 65 66 virtual void onHalError(int32_t errorCode, int32_t property, int32_t operation) { 67 Parcel data, reply; 68 data.writeInterfaceToken(IVehicleNetworkListener::getInterfaceDescriptor()); 69 data.writeInt32(errorCode); 70 data.writeInt32(property); 71 data.writeInt32(operation); 72 remote()->transact(ON_HAL_ERROR, data, &reply); 73 } 74 75 virtual void onHalRestart(bool inMocking) { 76 Parcel data, reply; 77 data.writeInterfaceToken(IVehicleNetworkListener::getInterfaceDescriptor()); 78 data.writeInt32(inMocking ? 1 : 0); 79 remote()->transact(ON_HAL_RESTART, data, &reply); 80 } 81}; 82 83IMPLEMENT_META_INTERFACE(VehicleNetworkListener, "com.android.car.vehiclenetwork.IVehicleNetworkListener"); 84 85// ---------------------------------------------------------------------- 86 87status_t BnVehicleNetworkListener::onTransact(uint32_t code, const Parcel& data, Parcel* reply, 88 uint32_t flags) { 89 status_t r; 90 switch (code) { 91 case ON_EVENTS: { 92 CHECK_INTERFACE(IVehicleNetworkListener, data, reply); 93 if (data.readInt32() == 0) { // java side allows passing null with this. 94 return BAD_VALUE; 95 } 96 List<vehicle_prop_value_t*>* list = new List<vehicle_prop_value_t*>(); 97 ASSERT_OR_HANDLE_NO_MEMORY(list, return NO_MEMORY); 98 sp<VehiclePropValueListHolder> holder(new VehiclePropValueListHolder(list)); 99 ASSERT_OR_HANDLE_NO_MEMORY(holder.get(), return NO_MEMORY); 100 ReadableBlobHolder blob(new Parcel::ReadableBlob()); 101 ASSERT_OR_HANDLE_NO_MEMORY(blob.blob, return NO_MEMORY); 102 int32_t size = data.readInt32(); 103 r = data.readBlob(size, blob.blob); 104 if (r != NO_ERROR) { 105 ALOGE("onEvents: cannot read blob"); 106 return r; 107 } 108 std::unique_ptr<VehiclePropValues> v(new VehiclePropValues()); 109 ASSERT_OR_HANDLE_NO_MEMORY(v.get(), return NO_MEMORY); 110 if (!v->ParseFromArray(blob.blob->data(), size)) { 111 ALOGE("onEvents: cannot parse data"); 112 return BAD_VALUE; 113 } 114 r = VehicleNetworkProtoUtil::fromVehiclePropValues(*v.get(), *list); 115 if (r != NO_ERROR) { 116 ALOGE("onEvents: cannot convert data"); 117 return BAD_VALUE; 118 } 119 onEvents(holder); 120 return NO_ERROR; 121 } break; 122 case ON_HAL_ERROR: { 123 CHECK_INTERFACE(IVehicleNetworkListener, data, reply); 124 int32_t errorCode = data.readInt32(); 125 int32_t property = data.readInt32(); 126 int32_t operation = data.readInt32(); 127 onHalError(errorCode, property, operation); 128 return NO_ERROR; 129 } break; 130 case ON_HAL_RESTART: { 131 CHECK_INTERFACE(IVehicleNetworkListener, data, reply); 132 bool inMocking = (data.readInt32() == 1); 133 onHalRestart(inMocking); 134 return NO_ERROR; 135 } break; 136 default: 137 return BBinder::onTransact(code, data, reply, flags); 138 } 139} 140 141}; // namespace android 142