1 // 2 // Copyright (C) 2015 Google, Inc. 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 #include "service/common/bluetooth/binder/IBluetoothGattServerCallback.h" 18 19 #include <base/logging.h> 20 #include <binder/Parcel.h> 21 22 #include "service/common/bluetooth/binder/parcel_helpers.h" 23 24 using android::IBinder; 25 using android::Parcel; 26 using android::sp; 27 using android::status_t; 28 29 namespace ipc { 30 namespace binder { 31 32 // static 33 const char IBluetoothGattServerCallback::kServiceName[] = 34 "bluetooth-gatt-server-callback-service"; 35 36 // BnBluetoothGattServerCallback (server) implementation 37 // ======================================================== 38 39 status_t BnBluetoothGattServerCallback::onTransact( 40 uint32_t code, 41 const Parcel& data, 42 Parcel* reply, 43 uint32_t flags) { 44 VLOG(2) << "IBluetoothGattServerCallback: " << code; 45 if (!data.checkInterface(this)) 46 return android::PERMISSION_DENIED; 47 48 switch (code) { 49 case ON_SERVER_REGISTERED_TRANSACTION: { 50 int status = data.readInt32(); 51 int server_if = data.readInt32(); 52 OnServerRegistered(status, server_if); 53 return android::NO_ERROR; 54 } 55 case ON_SERVICE_ADDED_TRANSACTION: { 56 int status = data.readInt32(); 57 auto gatt_id = CreateGattIdentifierFromParcel(data); 58 CHECK(gatt_id); 59 OnServiceAdded(status, *gatt_id); 60 return android::NO_ERROR; 61 } 62 case ON_CHARACTERISTIC_READ_REQUEST_TRANSACTION: { 63 std::string device_address = data.readCString(); 64 int request_id = data.readInt32(); 65 int offset = data.readInt32(); 66 bool is_long = data.readInt32(); 67 auto char_id = CreateGattIdentifierFromParcel(data); 68 CHECK(char_id); 69 OnCharacteristicReadRequest(device_address, request_id, offset, is_long, 70 *char_id); 71 return android::NO_ERROR; 72 } 73 case ON_DESCRIPTOR_READ_REQUEST_TRANSACTION: { 74 std::string device_address = data.readCString(); 75 int request_id = data.readInt32(); 76 int offset = data.readInt32(); 77 bool is_long = data.readInt32(); 78 auto desc_id = CreateGattIdentifierFromParcel(data); 79 CHECK(desc_id); 80 OnDescriptorReadRequest(device_address, request_id, offset, is_long, 81 *desc_id); 82 return android::NO_ERROR; 83 } 84 case ON_CHARACTERISTIC_WRITE_REQUEST_TRANSACTION: { 85 std::string device_address = data.readCString(); 86 int request_id = data.readInt32(); 87 int offset = data.readInt32(); 88 bool is_prep = data.readInt32(); 89 bool need_rsp = data.readInt32(); 90 91 std::unique_ptr<std::vector<uint8_t>> value; 92 data.readByteVector(&value); 93 CHECK(value.get()); 94 95 auto char_id = CreateGattIdentifierFromParcel(data); 96 CHECK(char_id); 97 98 OnCharacteristicWriteRequest(device_address, request_id, offset, is_prep, 99 need_rsp, *value, *char_id); 100 return android::NO_ERROR; 101 } 102 case ON_DESCRIPTOR_WRITE_REQUEST_TRANSACTION: { 103 std::string device_address = data.readCString(); 104 int request_id = data.readInt32(); 105 int offset = data.readInt32(); 106 bool is_prep = data.readInt32(); 107 bool need_rsp = data.readInt32(); 108 109 std::unique_ptr<std::vector<uint8_t>> value; 110 data.readByteVector(&value); 111 CHECK(value.get()); 112 113 auto desc_id = CreateGattIdentifierFromParcel(data); 114 CHECK(desc_id); 115 116 OnDescriptorWriteRequest(device_address, request_id, offset, is_prep, 117 need_rsp, *value, *desc_id); 118 return android::NO_ERROR; 119 } 120 case ON_EXECUTE_WRITE_REQUEST_TRANSACTION: { 121 std::string device_address = data.readCString(); 122 int request_id = data.readInt32(); 123 bool is_exec = data.readInt32(); 124 125 OnExecuteWriteRequest(device_address, request_id, is_exec); 126 return android::NO_ERROR; 127 } 128 case ON_NOTIFICATION_SENT_TRANSACTION: { 129 std::string device_address = data.readCString(); 130 int status = data.readInt32(); 131 132 OnNotificationSent(device_address, status); 133 return android::NO_ERROR; 134 } 135 default: 136 return BBinder::onTransact(code, data, reply, flags); 137 } 138 } 139 140 // BpBluetoothGattServerCallback (client) implementation 141 // ======================================================== 142 143 BpBluetoothGattServerCallback::BpBluetoothGattServerCallback( 144 const sp<IBinder>& impl) 145 : BpInterface<IBluetoothGattServerCallback>(impl) { 146 } 147 148 void BpBluetoothGattServerCallback::OnServerRegistered( 149 int status, int server_if) { 150 Parcel data, reply; 151 152 data.writeInterfaceToken( 153 IBluetoothGattServerCallback::getInterfaceDescriptor()); 154 data.writeInt32(status); 155 data.writeInt32(server_if); 156 157 remote()->transact( 158 IBluetoothGattServerCallback::ON_SERVER_REGISTERED_TRANSACTION, 159 data, &reply, 160 IBinder::FLAG_ONEWAY); 161 } 162 163 void BpBluetoothGattServerCallback::OnServiceAdded( 164 int status, 165 const bluetooth::GattIdentifier& service_id) { 166 Parcel data, reply; 167 168 data.writeInterfaceToken( 169 IBluetoothGattServerCallback::getInterfaceDescriptor()); 170 data.writeInt32(status); 171 WriteGattIdentifierToParcel(service_id, &data); 172 173 remote()->transact(IBluetoothGattServerCallback::ON_SERVICE_ADDED_TRANSACTION, 174 data, &reply, 175 IBinder::FLAG_ONEWAY); 176 } 177 178 void BpBluetoothGattServerCallback::OnCharacteristicReadRequest( 179 const std::string& device_address, 180 int request_id, int offset, bool is_long, 181 const bluetooth::GattIdentifier& characteristic_id) { 182 Parcel data, reply; 183 184 data.writeInterfaceToken( 185 IBluetoothGattServerCallback::getInterfaceDescriptor()); 186 data.writeCString(device_address.c_str()); 187 data.writeInt32(request_id); 188 data.writeInt32(offset); 189 data.writeInt32(is_long); 190 WriteGattIdentifierToParcel(characteristic_id, &data); 191 192 remote()->transact( 193 IBluetoothGattServerCallback::ON_CHARACTERISTIC_READ_REQUEST_TRANSACTION, 194 data, &reply, 195 IBinder::FLAG_ONEWAY); 196 } 197 198 void BpBluetoothGattServerCallback::OnDescriptorReadRequest( 199 const std::string& device_address, 200 int request_id, int offset, bool is_long, 201 const bluetooth::GattIdentifier& descriptor_id) { 202 Parcel data, reply; 203 204 data.writeInterfaceToken( 205 IBluetoothGattServerCallback::getInterfaceDescriptor()); 206 data.writeCString(device_address.c_str()); 207 data.writeInt32(request_id); 208 data.writeInt32(offset); 209 data.writeInt32(is_long); 210 WriteGattIdentifierToParcel(descriptor_id, &data); 211 212 remote()->transact( 213 IBluetoothGattServerCallback::ON_DESCRIPTOR_READ_REQUEST_TRANSACTION, 214 data, &reply, 215 IBinder::FLAG_ONEWAY); 216 } 217 218 void BpBluetoothGattServerCallback::OnCharacteristicWriteRequest( 219 const std::string& device_address, 220 int request_id, int offset, bool is_prepare_write, bool need_response, 221 const std::vector<uint8_t>& value, 222 const bluetooth::GattIdentifier& characteristic_id) { 223 Parcel data, reply; 224 225 data.writeInterfaceToken( 226 IBluetoothGattServerCallback::getInterfaceDescriptor()); 227 data.writeCString(device_address.c_str()); 228 data.writeInt32(request_id); 229 data.writeInt32(offset); 230 data.writeInt32(is_prepare_write); 231 data.writeInt32(need_response); 232 data.writeByteVector(value); 233 WriteGattIdentifierToParcel(characteristic_id, &data); 234 235 remote()->transact( 236 IBluetoothGattServerCallback::ON_CHARACTERISTIC_WRITE_REQUEST_TRANSACTION, 237 data, &reply, 238 IBinder::FLAG_ONEWAY); 239 } 240 241 void BpBluetoothGattServerCallback::OnDescriptorWriteRequest( 242 const std::string& device_address, 243 int request_id, int offset, bool is_prepare_write, bool need_response, 244 const std::vector<uint8_t>& value, 245 const bluetooth::GattIdentifier& descriptor_id) { 246 Parcel data, reply; 247 248 data.writeInterfaceToken( 249 IBluetoothGattServerCallback::getInterfaceDescriptor()); 250 data.writeCString(device_address.c_str()); 251 data.writeInt32(request_id); 252 data.writeInt32(offset); 253 data.writeInt32(is_prepare_write); 254 data.writeInt32(need_response); 255 data.writeByteVector(value); 256 WriteGattIdentifierToParcel(descriptor_id, &data); 257 258 remote()->transact( 259 IBluetoothGattServerCallback::ON_DESCRIPTOR_WRITE_REQUEST_TRANSACTION, 260 data, &reply, 261 IBinder::FLAG_ONEWAY); 262 } 263 264 void BpBluetoothGattServerCallback::OnExecuteWriteRequest( 265 const std::string& device_address, 266 int request_id, bool is_execute) { 267 Parcel data, reply; 268 269 data.writeInterfaceToken( 270 IBluetoothGattServerCallback::getInterfaceDescriptor()); 271 data.writeCString(device_address.c_str()); 272 data.writeInt32(request_id); 273 data.writeInt32(is_execute); 274 275 remote()->transact( 276 IBluetoothGattServerCallback::ON_EXECUTE_WRITE_REQUEST_TRANSACTION, 277 data, &reply, 278 IBinder::FLAG_ONEWAY); 279 } 280 281 void BpBluetoothGattServerCallback::OnNotificationSent( 282 const std::string& device_address, 283 int status) { 284 Parcel data, reply; 285 286 data.writeInterfaceToken( 287 IBluetoothGattServerCallback::getInterfaceDescriptor()); 288 data.writeCString(device_address.c_str()); 289 data.writeInt32(status); 290 291 remote()->transact( 292 IBluetoothGattServerCallback::ON_NOTIFICATION_SENT_TRANSACTION, 293 data, &reply, 294 IBinder::FLAG_ONEWAY); 295 } 296 297 IMPLEMENT_META_INTERFACE(BluetoothGattServerCallback, 298 IBluetoothGattServerCallback::kServiceName); 299 300 } // namespace binder 301 } // namespace ipc 302
