| /* |
| * Copyright (C) 2017 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. |
| */ |
| |
| package com.googlecode.android_scripting.facade.bluetooth; |
| |
| import android.app.Service; |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.BluetoothGatt; |
| import android.bluetooth.IBluetoothGatt; |
| import android.bluetooth.BluetoothGattCallback; |
| import android.bluetooth.BluetoothGattCharacteristic; |
| import android.bluetooth.BluetoothGattDescriptor; |
| import android.bluetooth.BluetoothGattService; |
| import android.bluetooth.BluetoothManager; |
| import android.bluetooth.BluetoothProfile; |
| import android.content.Context; |
| import android.os.Bundle; |
| |
| import com.googlecode.android_scripting.Log; |
| import com.googlecode.android_scripting.MainThread; |
| import com.googlecode.android_scripting.facade.EventFacade; |
| import com.googlecode.android_scripting.facade.FacadeManager; |
| import com.googlecode.android_scripting.jsonrpc.RpcReceiver; |
| import com.googlecode.android_scripting.rpc.Rpc; |
| import com.googlecode.android_scripting.rpc.RpcParameter; |
| import com.googlecode.android_scripting.rpc.RpcStopEvent; |
| |
| import java.lang.reflect.*; |
| import java.util.ArrayList; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.concurrent.Callable; |
| import java.util.UUID; |
| |
| public class GattClientFacade extends RpcReceiver { |
| private final EventFacade mEventFacade; |
| private BluetoothAdapter mBluetoothAdapter; |
| private BluetoothManager mBluetoothManager; |
| private final Service mService; |
| private final Context mContext; |
| private final HashMap<Integer, myBluetoothGattCallback> mGattCallbackList; |
| private final HashMap<Integer, BluetoothGatt> mBluetoothGattList; |
| private final HashMap<Integer, BluetoothGattCharacteristic> mCharacteristicList; |
| private final HashMap<Integer, BluetoothGattDescriptor> mDescriptorList; |
| private final HashMap<Integer, BluetoothGattService> mGattServiceList; |
| private final HashMap<Integer, List<BluetoothGattService>> mBluetoothGattDiscoveredServicesList; |
| private final HashMap<Integer, List<BluetoothDevice>> mGattServerDiscoveredDevicesList; |
| private static int GattCallbackCount; |
| private static int BluetoothGattDiscoveredServicesCount; |
| private static int BluetoothGattCount; |
| private static int CharacteristicCount; |
| private static int DescriptorCount; |
| private static int GattServerCallbackCount; |
| private static int GattServerCount; |
| private static int GattServiceCount; |
| |
| public GattClientFacade(FacadeManager manager) { |
| super(manager); |
| mService = manager.getService(); |
| mContext = mService.getApplicationContext(); |
| mBluetoothAdapter = |
| MainThread.run( |
| mService, |
| new Callable<BluetoothAdapter>() { |
| @Override |
| public BluetoothAdapter call() throws Exception { |
| return BluetoothAdapter.getDefaultAdapter(); |
| } |
| }); |
| mBluetoothManager = (BluetoothManager) mContext.getSystemService(Service.BLUETOOTH_SERVICE); |
| mEventFacade = manager.getReceiver(EventFacade.class); |
| mGattCallbackList = new HashMap<Integer, myBluetoothGattCallback>(); |
| mCharacteristicList = new HashMap<Integer, BluetoothGattCharacteristic>(); |
| mBluetoothGattList = new HashMap<Integer, BluetoothGatt>(); |
| mDescriptorList = new HashMap<Integer, BluetoothGattDescriptor>(); |
| mGattServiceList = new HashMap<Integer, BluetoothGattService>(); |
| mBluetoothGattDiscoveredServicesList = new HashMap<Integer, List<BluetoothGattService>>(); |
| mGattServerDiscoveredDevicesList = new HashMap<Integer, List<BluetoothDevice>>(); |
| } |
| |
| /** |
| * Create a BluetoothGatt connection |
| * |
| * @param index of the callback to start a connection on |
| * @param macAddress the mac address of the ble device |
| * @param autoConnect Whether to directly connect to the remote device (false) or to |
| * automatically connect as soon as the remote device becomes available (true) |
| * @param transport preferred transport for GATT connections to remote dual-mode devices |
| * TRANSPORT_AUTO or TRANSPORT_BREDR or TRANSPORT_LE |
| * @return the index of the BluetoothGatt object |
| * @throws Exception |
| */ |
| @Rpc(description = "Create a gatt connection") |
| public int gattClientConnectGatt( |
| @RpcParameter(name = "index") Integer index, |
| @RpcParameter(name = "macAddress") String macAddress, |
| @RpcParameter(name = "autoConnect") Boolean autoConnect, |
| @RpcParameter(name = "transport") Integer transport, |
| @RpcParameter(name = "phy") Integer phy) |
| throws Exception { |
| if (mGattCallbackList.get(index) != null) { |
| BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(macAddress); |
| if (phy == null) phy = BluetoothDevice.PHY_LE_1M; |
| |
| BluetoothGatt mBluetoothGatt = |
| device.connectGatt( |
| mService.getApplicationContext(), |
| autoConnect, |
| mGattCallbackList.get(index), |
| transport, |
| phy); |
| BluetoothGattCount += 1; |
| mBluetoothGattList.put(BluetoothGattCount, mBluetoothGatt); |
| return BluetoothGattCount; |
| } else { |
| throw new Exception("Invalid index input:" + Integer.toString(index)); |
| } |
| } |
| |
| /** |
| * Trigger discovering of services on the BluetoothGatt object |
| * |
| * @param index The BluetoothGatt object index |
| * @return true, if the remote service discovery has been started |
| * @throws Exception |
| */ |
| @Rpc(description = "Trigger discovering of services on the BluetoothGatt object") |
| public boolean gattClientDiscoverServices(@RpcParameter(name = "index") Integer index) |
| throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).discoverServices(); |
| } else { |
| throw new Exception("Invalid index input:" + Integer.toString(index)); |
| } |
| } |
| |
| /** |
| * Trigger discovering of services by UUID on the BluetoothGatt object |
| * |
| * @param index The BluetoothGatt object index |
| * @param uuid service UUID |
| * @return true, if the remote service discovery has been started |
| * @throws Exception |
| */ |
| @Rpc(description = "Trigger discovering of services on the BluetoothGatt object") |
| public boolean gattClientDiscoverServiceByUuid(@RpcParameter(name = "index") Integer index, |
| @RpcParameter(name = "uuid") String uuid) throws Exception { |
| BluetoothGatt gatt = mBluetoothGattList.get(index); |
| if (gatt != null) { |
| Object ret = gatt.getClass().getMethod("discoverServiceByUuid", UUID.class) |
| .invoke(gatt, UUID.fromString(uuid)); |
| return (Boolean) ret; |
| } else { |
| throw new Exception("Invalid index input:" + Integer.toString(index)); |
| } |
| } |
| |
| |
| /** |
| * Get the services from the BluetoothGatt object |
| * |
| * @param index The BluetoothGatt object index |
| * @return a list of BluetoothGattServices |
| * @throws Exception |
| */ |
| @Rpc(description = "Get the services from the BluetoothGatt object") |
| public List<BluetoothGattService> gattClientGetServices( |
| @RpcParameter(name = "index") Integer index) throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).getServices(); |
| } else { |
| throw new Exception("Invalid index input:" + Integer.toString(index)); |
| } |
| } |
| |
| /** |
| * Abort reliable write of a bluetooth gatt |
| * |
| * @param index the bluetooth gatt index |
| * @throws Exception |
| */ |
| @Rpc(description = "Abort reliable write of a bluetooth gatt") |
| public void gattClientAbortReliableWrite(@RpcParameter(name = "index") Integer index) |
| throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| mBluetoothGattList.get(index).abortReliableWrite(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Begin reliable write of a bluetooth gatt |
| * |
| * @param index the bluetooth gatt index |
| * @return |
| * @throws Exception |
| */ |
| @Rpc(description = "Begin reliable write of a bluetooth gatt") |
| public boolean gattClientBeginReliableWrite(@RpcParameter(name = "index") Integer index) |
| throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).beginReliableWrite(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Configure a bluetooth gatt's MTU |
| * |
| * @param index the bluetooth gatt index |
| * @param mtu the MTU to set |
| * @return |
| * @throws Exception |
| */ |
| @Rpc(description = "true, if the new MTU value has been requested successfully") |
| public boolean gattClientRequestMtu( |
| @RpcParameter(name = "index") Integer index, @RpcParameter(name = "mtu") Integer mtu) |
| throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).requestMtu(mtu); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Read the current transmitter PHY and receiver PHY of the connection. |
| * |
| * @param index the bluetooth gatt index |
| * @throws Exception |
| */ |
| @Rpc(description = "Read PHY") |
| public void gattClientReadPhy(@RpcParameter(name = "index") Integer index) throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| mBluetoothGattList.get(index).readPhy(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Set the preferred connection PHY. |
| * |
| * @param index the bluetooth gatt index |
| * @throws Exception |
| */ |
| @Rpc(description = "Set the preferred connection PHY") |
| public void gattClientSetPreferredPhy(@RpcParameter(name = "index") Integer index, |
| @RpcParameter(name = "txPhy") Integer txPhy, |
| @RpcParameter(name = "rxPhy") Integer rxPhy, |
| @RpcParameter(name = "txPhy") Integer phyOptions) throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| mBluetoothGattList.get(index).setPreferredPhy(txPhy, rxPhy, phyOptions); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Disconnect a bluetooth gatt |
| * |
| * @param index the bluetooth gatt index |
| * @throws Exception |
| */ |
| @Rpc(description = "Disconnect a bluetooth gatt") |
| @RpcStopEvent("GattConnect") |
| public void gattClientDisconnect(@RpcParameter(name = "index") Integer index) throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| mBluetoothGattList.get(index).disconnect(); |
| } else { |
| throw new Exception("Invalid index input: " + index); |
| } |
| } |
| |
| /** |
| * Close a bluetooth gatt object |
| * |
| * @param index the bluetooth gatt index |
| * @throws Exception |
| */ |
| @Rpc(description = "Close a Bluetooth GATT object") |
| public void gattClientClose(@RpcParameter(name = "index") Integer index) throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| mBluetoothGattList.get(index).close(); |
| } else { |
| throw new Exception("Invalid index input: " + index); |
| } |
| } |
| |
| /** |
| * Execute reliable write on a bluetooth gatt |
| * |
| * @param index the bluetooth gatt index |
| * @return true, if the request to execute the transaction has been sent |
| * @throws Exception |
| */ |
| @Rpc(description = "Execute reliable write on a bluetooth gatt") |
| public boolean gattExecuteReliableWrite(@RpcParameter(name = "index") Integer index) |
| throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).executeReliableWrite(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Get a list of Bluetooth Devices connnected to the bluetooth gatt |
| * |
| * @param index the bluetooth gatt index |
| * @return List of BluetoothDevice Objects |
| * @throws Exception |
| */ |
| @Rpc(description = "Get a list of Bluetooth Devices connnected to the bluetooth gatt") |
| public List<BluetoothDevice> gattClientGetConnectedDevices( |
| @RpcParameter(name = "index") Integer index) throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).getConnectedDevices(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Get the remote bluetooth device this GATT client targets to |
| * |
| * @param index the bluetooth gatt index |
| * @return the remote bluetooth device this gatt client targets to |
| * @throws Exception |
| */ |
| @Rpc(description = "Get the remote bluetooth device this GATT client targets to") |
| public BluetoothDevice gattGetDevice(@RpcParameter(name = "index") Integer index) |
| throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).getDevice(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Get the bluetooth devices matching input connection states |
| * |
| * @param index the bluetooth gatt index |
| * @param states the list of states to match |
| * @return The list of BluetoothDevice objects that match the states |
| * @throws Exception |
| */ |
| @Rpc(description = "Get the bluetooth devices matching input connection states") |
| public List<BluetoothDevice> gattClientGetDevicesMatchingConnectionStates( |
| @RpcParameter(name = "index") Integer index, @RpcParameter( |
| name = "states") int[] states) |
| throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).getDevicesMatchingConnectionStates(states); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Get the service from an input UUID |
| * |
| * @param index the bluetooth gatt index |
| * @return BluetoothGattService related to the bluetooth gatt |
| * @throws Exception |
| */ |
| @Rpc(description = "Get the service from an input UUID") |
| public ArrayList<String> gattClientGetServiceUuidList( |
| @RpcParameter(name = "index") Integer index) |
| throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| ArrayList<String> serviceUuidList = new ArrayList<String>(); |
| for (BluetoothGattService service : mBluetoothGattList.get(index).getServices()) { |
| serviceUuidList.add(service.getUuid().toString()); |
| } |
| return serviceUuidList; |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Reads the requested characteristic from the associated remote device. |
| * |
| * @deprecated Use {@link #gattClientReadCharacteristicByIndex(gattIndex, |
| * discoveredServiceListIndex, serviceIndex, characteristicIndex)} instead. |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param serviceIndex the service index of the discovered services |
| * @param characteristicUuid the characteristic uuid to read |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Reads the requested characteristic from the associated remote device.") |
| @Deprecated |
| public boolean gattClientReadCharacteristic( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicUuid") String characteristicUuid) throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| UUID cUuid = UUID.fromString(characteristicUuid); |
| BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid); |
| if (gattCharacteristic == null) { |
| throw new Exception("Invalid characteristic uuid: " + characteristicUuid); |
| } |
| return bluetoothGatt.readCharacteristic(gattCharacteristic); |
| } |
| |
| /** |
| * Reads the characteristic from the associated remote device. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param uuid the characteristic uuid to read |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Reads the characteristic from the associated remote device.") |
| public boolean gattClientReadUsingCharacteristicUuid( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "uuid") String uuid, |
| @RpcParameter(name = "startHandle") Integer startHandle, |
| @RpcParameter(name = "endHandle") Integer endHandle) throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| UUID cUuid = UUID.fromString(uuid); |
| return bluetoothGatt.readUsingCharacteristicUuid(cUuid, startHandle, endHandle); |
| } |
| |
| /** |
| * Reads the requested characteristic from the associated remote device. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param serviceIndex the service index of the discovered services |
| * @param characteristicIndex the characteristic index |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Reads the requested characteristic from the associated remote device.") |
| public boolean gattClientReadCharacteristicByIndex( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex " + characteristicIndex); |
| } |
| return bluetoothGatt.readCharacteristic(charList.get(characteristicIndex)); |
| } |
| |
| /** |
| * Reads the requested characteristic from the associated remote device by instance id. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Reads the requested characteristic from the associated remote " |
| + "device by instance id.") |
| public boolean gattClientReadCharacteristicByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "characteristicInstanceId") Integer characteristicInstanceId) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| List<BluetoothGattCharacteristic> charList = mGattService.getCharacteristics(); |
| for (BluetoothGattCharacteristic mGattChar : charList) { |
| if (mGattChar.getInstanceId() == characteristicInstanceId) { |
| Log.i("Found Characteristic to read. instanceId: " |
| + Integer.toString(characteristicInstanceId) |
| + " UUID: " + mGattChar.getUuid().toString()); |
| return bluetoothGatt.readCharacteristic(mGattChar); |
| } |
| } |
| } |
| Log.e("Failed to find Characteristic with instanceId: " + Integer.toString( |
| characteristicInstanceId)); |
| return false; |
| } |
| |
| /** |
| * Writes the requested characteristic from the associated remote device by instance id. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param characteristicInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Writes the requested characteristic from the associated remote " |
| + "device by instance id.") |
| public boolean gattClientWriteDescriptorByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "descriptorInstanceId") Integer descriptorInstanceId, |
| @RpcParameter(name = "value") byte[] value) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| List<BluetoothGattCharacteristic> charList = mGattService.getCharacteristics(); |
| for (BluetoothGattCharacteristic mGattChar : charList) { |
| List<BluetoothGattDescriptor> descList = mGattChar.getDescriptors(); |
| for (BluetoothGattDescriptor mGattDesc : descList) { |
| if (mGattDesc.getInstanceId() == descriptorInstanceId) { |
| mGattDesc.setValue(value); |
| Log.i("Found Descriptor to write. instanceId: " |
| + Integer.toString(descriptorInstanceId) |
| + " UUID: " + mGattDesc.getUuid().toString()); |
| return bluetoothGatt.writeDescriptor(mGattDesc); |
| } |
| } |
| } |
| } |
| Log.e("Failed to find Descriptor with instanceId: " + Integer.toString( |
| descriptorInstanceId)); |
| return false; |
| } |
| |
| /** |
| * Writes the requested characteristic from the associated remote device by instance id. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Writes the requested characteristic from the associated remote " |
| + "device by instance id.") |
| public boolean gattClientWriteCharacteristicByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "characteristicInstanceId") Integer characteristicInstanceId, |
| @RpcParameter(name = "value") byte[] value) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| List<BluetoothGattCharacteristic> charList = mGattService.getCharacteristics(); |
| for (BluetoothGattCharacteristic mGattChar : charList) { |
| if (mGattChar.getInstanceId() == characteristicInstanceId) { |
| mGattChar.setValue(value); |
| Log.i("Found Characteristic to write. instanceId: " |
| + Integer.toString(characteristicInstanceId) |
| + " UUID: " + mGattChar.getUuid().toString()); |
| return bluetoothGatt.writeCharacteristic(mGattChar); |
| } |
| } |
| } |
| Log.e("Failed to find Characteristic with instanceId: " + Integer.toString( |
| characteristicInstanceId)); |
| return false; |
| } |
| |
| /** |
| * Writes the requested characteristic in which write is not permitted. For conformance tests |
| * only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Writes the requested characteristic from the associated remote " |
| + "device by instance id.") |
| public boolean gattClientModifyAccessAndWriteCharacteristicByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "characteristicInstanceId") Integer characteristicInstanceId, |
| @RpcParameter(name = "value") byte[] value) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| List<BluetoothGattCharacteristic> charList = mGattService.getCharacteristics(); |
| for (BluetoothGattCharacteristic mGattChar : charList) { |
| if (mGattChar.getInstanceId() == characteristicInstanceId) { |
| Log.i("Found Characteristic to write. instanceId: " |
| + Integer.toString(characteristicInstanceId) |
| + " UUID: " + mGattChar.getUuid().toString()); |
| BluetoothGattCharacteristic modChar = new BluetoothGattCharacteristic( |
| mGattChar.getUuid(), 0x08, 0x10); |
| modChar.setInstanceId(mGattChar.getInstanceId()); |
| mGattService.addCharacteristic(modChar); |
| modChar.setValue(value); |
| return bluetoothGatt.writeCharacteristic(modChar); |
| } |
| } |
| } |
| Log.e("Failed to find Characteristic with instanceId: " + Integer.toString( |
| characteristicInstanceId)); |
| return false; |
| } |
| |
| /** |
| * Writes the requested descriptor in which write is not permitted. For conformance tests only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Writes a Characteristic with an invalid instanceId to each service.") |
| public boolean gattClientWriteInvalidCharacteristicByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "instanceId") Integer instanceId, |
| @RpcParameter(name = "value") byte[] value) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| BluetoothGattCharacteristic invalidHandleChar = new BluetoothGattCharacteristic( |
| UUID.fromString("aa7edd5a-4d1d-4f0e-883a-d145616a1630"), 0x08, 0x10); |
| invalidHandleChar.setInstanceId(instanceId); |
| mGattService.addCharacteristic(invalidHandleChar); |
| invalidHandleChar.setValue(value); |
| //todo: this used to be return bluetoothGatt. Retest with and without return |
| bluetoothGatt.writeCharacteristic(invalidHandleChar); |
| } |
| return true; |
| } |
| |
| /** |
| * Writes the requested characteristic in which write is not permitted. For conformance tests |
| * only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Read the requested characteristic from the associated remote " |
| + "device by instance id.") |
| public boolean gattClientModifyAccessAndReadCharacteristicByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "characteristicInstanceId") Integer characteristicInstanceId) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| List<BluetoothGattCharacteristic> charList = mGattService.getCharacteristics(); |
| for (BluetoothGattCharacteristic mGattChar : charList) { |
| if (mGattChar.getInstanceId() == characteristicInstanceId) { |
| Log.i("Found Characteristic to read. instanceId: " |
| + Integer.toString(characteristicInstanceId) |
| + " UUID: " + mGattChar.getUuid().toString()); |
| BluetoothGattCharacteristic modChar = new BluetoothGattCharacteristic( |
| mGattChar.getUuid(), 0x02, 0x01); |
| modChar.setInstanceId(mGattChar.getInstanceId()); |
| mGattService.addCharacteristic(modChar); |
| return bluetoothGatt.readCharacteristic(modChar); |
| } |
| } |
| } |
| Log.e("Failed to find Characteristic with instanceId: " + Integer.toString( |
| characteristicInstanceId)); |
| return false; |
| } |
| |
| /** |
| * Writes the requested descriptor in which write is not permitted. For conformance tests only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Read a Characteristic with an invalid instanceId to each service.") |
| public boolean gattClientReadInvalidCharacteristicByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "characteristicInstanceId") Integer characteristicInstanceId) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| BluetoothGattCharacteristic invalidHandleChar = new BluetoothGattCharacteristic( |
| UUID.fromString("aa7edd5a-4d1d-4f0e-883a-d145616a1630"), 0x02, 0x01); |
| invalidHandleChar.setInstanceId(characteristicInstanceId); |
| mGattService.addCharacteristic(invalidHandleChar); |
| bluetoothGatt.readCharacteristic(invalidHandleChar); |
| } |
| return true; |
| } |
| |
| /** |
| * Writes the requested descriptor in which write is not permitted. For conformance tests |
| * only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Writes the requested descriptor from the associated remote " |
| + "device by instance id.") |
| public boolean gattClientModifyAccessAndWriteDescriptorByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "descriptorInstanceId") Integer descriptorInstanceId, |
| @RpcParameter(name = "value") byte[] value) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| List<BluetoothGattCharacteristic> charList = mGattService.getCharacteristics(); |
| for (BluetoothGattCharacteristic mGattChar : charList) { |
| for (BluetoothGattDescriptor mGattDesc : mGattChar.getDescriptors()) { |
| if (mGattDesc.getInstanceId() == descriptorInstanceId) { |
| Log.i("Found Descriptor to write. instanceId: " |
| + Integer.toString(descriptorInstanceId) |
| + " UUID: " + mGattChar.getUuid().toString()); |
| BluetoothGattDescriptor modDesc = new BluetoothGattDescriptor( |
| mGattDesc.getUuid(), 0x10); |
| modDesc.setInstanceId(descriptorInstanceId); |
| mGattChar.addDescriptor(modDesc); |
| modDesc.setValue(value); |
| return bluetoothGatt.writeDescriptor(modDesc); |
| } |
| } |
| } |
| } |
| Log.e("Failed to find Descriptor with instanceId: " + Integer.toString( |
| descriptorInstanceId)); |
| return false; |
| } |
| |
| /** |
| * Writes the requested descriptor in which write is not permitted. For conformance tests only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Writes a Characteristic with an invalid instanceId to each service.") |
| public boolean gattClientWriteInvalidDescriptorByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "instanceId") Integer instanceId, |
| @RpcParameter(name = "value") byte[] value) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| for (BluetoothGattCharacteristic mGattChar : mGattService.getCharacteristics()) { |
| BluetoothGattDescriptor invalidHandleDesc = new BluetoothGattDescriptor( |
| UUID.fromString("aa7edd5a-4d1d-4f0e-883a-d145616a1630"), 0x10); |
| invalidHandleDesc.setInstanceId(instanceId); |
| mGattChar.addDescriptor(invalidHandleDesc); |
| invalidHandleDesc.setValue(value); |
| bluetoothGatt.writeDescriptor(invalidHandleDesc); |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Writes the requested descriptor in which write is not permitted. For conformance tests |
| * only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Read the requested descriptor from the associated remote " |
| + "device by instance id.") |
| public boolean gattClientModifyAccessAndReadDescriptorByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "descriptorInstanceId") Integer descriptorInstanceId) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| List<BluetoothGattCharacteristic> charList = mGattService.getCharacteristics(); |
| for (BluetoothGattCharacteristic mGattChar : charList) { |
| for (BluetoothGattDescriptor mGattDesc : mGattChar.getDescriptors()) { |
| if (mGattDesc.getInstanceId() == descriptorInstanceId) { |
| Log.i("Found Descriptor to read. instanceId: " |
| + Integer.toString(descriptorInstanceId) |
| + " UUID: " + mGattDesc.getUuid().toString()); |
| BluetoothGattDescriptor modDesc = new BluetoothGattDescriptor( |
| mGattDesc.getUuid(), 0x01); |
| modDesc.setInstanceId(descriptorInstanceId); |
| mGattChar.addDescriptor(modDesc); |
| return bluetoothGatt.readDescriptor(modDesc); |
| } |
| } |
| } |
| } |
| Log.e("Failed to find Descriptor with instanceId: " + Integer.toString( |
| descriptorInstanceId)); |
| return false; |
| } |
| |
| /** |
| * Writes the requested descriptor in which write is not permitted. For conformance tests only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Read a Characteristic with an invalid instanceId to each service.") |
| public boolean gattClientReadInvalidDescriptorByInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "descriptorInstanceId") Integer descriptorInstanceId) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| for (BluetoothGattCharacteristic mGattChar : mGattService.getCharacteristics()) { |
| BluetoothGattDescriptor invalidHandleDesc = new BluetoothGattDescriptor( |
| UUID.fromString("aa7edd5a-4d1d-4f0e-883a-d145616a1630"), 0x01); |
| invalidHandleDesc.setInstanceId(descriptorInstanceId); |
| mGattChar.addDescriptor(invalidHandleDesc); |
| bluetoothGatt.readDescriptor(invalidHandleDesc); |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Writes the requested characteristic in which write is not permitted. For conformance tests |
| * only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Read the requested characteristic from the associated remote " |
| + "device by uuid.") |
| public boolean gattClientModifyAccessAndReadCharacteristicByUuidAndInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "characteristicInstanceId") Integer characteristicInstanceId, |
| @RpcParameter(name = "characteristicUuid") String characteristicUuid) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| List<BluetoothGattCharacteristic> charList = mGattService.getCharacteristics(); |
| for (BluetoothGattCharacteristic mGattChar : charList) { |
| if (mGattChar.getUuid().toString().equalsIgnoreCase(characteristicUuid) && |
| mGattChar.getInstanceId() == characteristicInstanceId) { |
| Log.i("Found Characteristic to read. UUID: " + mGattChar.getUuid().toString()); |
| BluetoothGattCharacteristic modChar = new BluetoothGattCharacteristic( |
| mGattChar.getUuid(), 0x02, 0x01); |
| modChar.setInstanceId(characteristicInstanceId); |
| mGattService.addCharacteristic(modChar); |
| bluetoothGatt.readCharacteristic(modChar); |
| } |
| } |
| } |
| return true; |
| } |
| |
| /** |
| * Writes the requested descriptor in which write is not permitted. For conformance tests only. |
| * |
| * @param gattIndex the BluetoothGatt server accociated with the device |
| * @param discoveredServiceListIndex the index returned from the discovered services callback |
| * @param descriptorInstanceId the integer instance id of the Characteristic to write to |
| * @param value the value to write to the characteristic |
| * @return true, if the read operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Read a Characteristic with an invalid Uuid to each service.") |
| public boolean gattClientReadInvalidCharacteristicByUuidAndInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "characteristicUuid") String characteristicUuid) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| for (BluetoothGattService mGattService : gattServiceList) { |
| BluetoothGattCharacteristic invalidHandleChar = new BluetoothGattCharacteristic( |
| UUID.fromString(characteristicUuid), 0x02, 0x01); |
| mGattService.addCharacteristic(invalidHandleChar); |
| bluetoothGatt.readCharacteristic(invalidHandleChar); |
| } |
| return true; |
| } |
| |
| /** |
| * /** Reads the value for a given descriptor from the associated remote device |
| * |
| * @deprecated Use {@link #gattClientReadDescriptorByIndex( |
| * gattIndex, discoveredServiceListIndex, serviceIndex, characteristicIndex, descriptorIndex)} |
| * instead. |
| * @param gattIndex - the gatt index to use |
| * @param discoveredServiceListIndex - the discvered serivice list index |
| * @param serviceIndex - the servce index of the discoveredServiceListIndex |
| * @param characteristicUuid - the characteristic uuid in which the descriptor is |
| * @param descriptorUuid - the descriptor uuid to read |
| * @return |
| * @throws Exception |
| */ |
| @Deprecated |
| @Rpc(description = "Reads the value for a given descriptor from the associated remote device") |
| public boolean gattClientReadDescriptor( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicUuid") String characteristicUuid, |
| @RpcParameter(name = "descriptorUuid") String descriptorUuid) throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = mBluetoothGattDiscoveredServicesList.get( |
| discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| UUID cUuid = UUID.fromString(characteristicUuid); |
| BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid); |
| if (gattCharacteristic == null) { |
| throw new Exception("Invalid characteristic uuid: " + characteristicUuid); |
| } |
| UUID dUuid = UUID.fromString(descriptorUuid); |
| BluetoothGattDescriptor gattDescriptor = gattCharacteristic.getDescriptor(dUuid); |
| if (gattDescriptor == null) { |
| throw new Exception("Invalid descriptor uuid: " + descriptorUuid); |
| } |
| return bluetoothGatt.readDescriptor(gattDescriptor); |
| } |
| |
| |
| /** |
| * /** Reads the value for a given descriptor from the associated remote device |
| * |
| * @param gattIndex - the gatt index to use |
| * @param discoveredServiceListIndex - the discvered serivice list index |
| * @param serviceIndex - the servce index of the discoveredServiceListIndex |
| * @param characteristicIndex - the characteristic index |
| * @param descriptorIndex - the descriptor index to read |
| * @return |
| * @throws Exception |
| */ |
| @Rpc(description = "Reads the value for a given descriptor from the associated remote device") |
| public boolean gattClientReadDescriptorByIndex( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex, |
| @RpcParameter(name = "descriptorIndex") Integer descriptorIndex) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex " + characteristicIndex); |
| } |
| BluetoothGattCharacteristic gattCharacteristic = charList.get(characteristicIndex); |
| List<BluetoothGattDescriptor> descList = gattCharacteristic.getDescriptors(); |
| if (descList.get(descriptorIndex) == null) { |
| throw new Exception("Invalid descriptorIndex " + descriptorIndex); |
| } |
| return bluetoothGatt.readDescriptor(descList.get(descriptorIndex)); |
| } |
| |
| /** |
| * Write the value of a given descriptor to the associated remote device |
| * |
| * @deprecated Use {@link #gattClientWriteDescriptorByIndex( |
| * gattIndex, discoveredServiceListIndex, serviceIndex, characteristicIndex, descriptorIndex)} |
| * instead. |
| * @param index the bluetooth gatt index |
| * @param serviceIndex the service index to write to |
| * @param characteristicUuid the uuid where the descriptor lives |
| * @param descriptorIndex the descriptor index |
| * @return true, if the write operation was initiated successfully |
| * @throws Exception |
| */ |
| @Deprecated |
| @Rpc(description = "Write the value of a given descriptor to the associated remote device") |
| public boolean gattClientWriteDescriptor( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicUuid") String characteristicUuid, |
| @RpcParameter(name = "descriptorUuid") String descriptorUuid) throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> discoveredServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (discoveredServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = discoveredServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| UUID cUuid = UUID.fromString(characteristicUuid); |
| BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid); |
| if (gattCharacteristic == null) { |
| throw new Exception("Invalid characteristic uuid: " + characteristicUuid); |
| } |
| UUID dUuid = UUID.fromString(descriptorUuid); |
| BluetoothGattDescriptor gattDescriptor = gattCharacteristic.getDescriptor(dUuid); |
| if (gattDescriptor == null) { |
| throw new Exception("Invalid descriptor uuid: " + descriptorUuid); |
| } |
| return bluetoothGatt.writeDescriptor(gattDescriptor); |
| } |
| |
| /** |
| * Write the value of a given descriptor to the associated remote device |
| * |
| * @param index the bluetooth gatt index |
| * @param serviceIndex the service index to write to |
| * @param characteristicIndex the characteristic index to write to |
| * @param descriptorIndex the descriptor index to write to |
| * @return true, if the write operation was initiated successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Write the value of a given descriptor to the associated remote device") |
| public boolean gattClientWriteDescriptorByIndex( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex, |
| @RpcParameter(name = "descriptorIndex") Integer descriptorIndex) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex " + characteristicIndex); |
| } |
| BluetoothGattCharacteristic gattCharacteristic = charList.get(characteristicIndex); |
| List<BluetoothGattDescriptor> descList = gattCharacteristic.getDescriptors(); |
| if (descList.get(descriptorIndex) == null) { |
| throw new Exception("Invalid descriptorIndex " + descriptorIndex); |
| } |
| return bluetoothGatt.writeDescriptor(descList.get(descriptorIndex)); |
| } |
| |
| /** |
| * Write the value to a discovered descriptor. |
| * |
| * @deprecated Use {@link #gattClientDescriptorSetValueByIndex( |
| * gattIndex, discoveredServiceListIndex, serviceIndex, characteristicIndex, descriptorIndex, |
| * value)} instead. |
| * @param gattIndex - the gatt index to use |
| * @param discoveredServiceListIndex - the discovered service list index |
| * @param serviceIndex - the service index of the discoveredServiceListIndex |
| * @param characteristicUuid - the characteristic uuid in which the descriptor is |
| * @param descriptorUuid - the descriptor uuid to read |
| * @param value - the value to set the descriptor to |
| * @return true is the value was set to the descriptor |
| * @throws Exception |
| */ |
| @Deprecated |
| @Rpc(description = "Write the value of a given descriptor to the associated remote device") |
| public boolean gattClientDescriptorSetValue( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicUuid") String characteristicUuid, |
| @RpcParameter(name = "descriptorUuid") String descriptorUuid, |
| @RpcParameter(name = "value") byte[] value) throws Exception { |
| if (mBluetoothGattList.get(gattIndex) == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> discoveredServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (discoveredServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = discoveredServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| UUID cUuid = UUID.fromString(characteristicUuid); |
| BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid); |
| if (gattCharacteristic == null) { |
| throw new Exception("Invalid characteristic uuid: " + characteristicUuid); |
| } |
| UUID dUuid = UUID.fromString(descriptorUuid); |
| BluetoothGattDescriptor gattDescriptor = gattCharacteristic.getDescriptor(dUuid); |
| if (gattDescriptor == null) { |
| throw new Exception("Invalid descriptor uuid: " + descriptorUuid); |
| } |
| return gattDescriptor.setValue(value); |
| } |
| |
| /** |
| * Write the value to a discovered descriptor. |
| * |
| * @param gattIndex - the gatt index to use |
| * @param discoveredServiceListIndex - the discovered service list index |
| * @param serviceIndex - the service index of the discoveredServiceListIndex |
| * @param characteristicIndex - the characteristic index |
| * @param descriptorIndex - the descriptor index to set |
| * @param value - the value to set the descriptor to |
| * @return true is the value was set to the descriptor |
| * @throws Exception |
| */ |
| @Rpc(description = "Write the value of a given descriptor to the associated remote device") |
| public boolean gattClientDescriptorSetValueByIndex( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex, |
| @RpcParameter(name = "descriptorIndex") Integer descriptorIndex, |
| @RpcParameter(name = "value") byte[] value) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex " + characteristicIndex); |
| } |
| BluetoothGattCharacteristic gattCharacteristic = charList.get(characteristicIndex); |
| List<BluetoothGattDescriptor> descList = gattCharacteristic.getDescriptors(); |
| if (descList.get(descriptorIndex) == null) { |
| throw new Exception("Invalid descriptorIndex " + descriptorIndex); |
| } |
| return descList.get(descriptorIndex).setValue(value); |
| } |
| |
| |
| /** |
| * Write the value of a given characteristic to the associated remote device |
| * |
| * @deprecated Use {@link #gattClientWriteCharacteristicByIndex( |
| * gattIndex, discoveredServiceListIndex, serviceIndex, characteristicIndex)} instead. |
| * @param index the bluetooth gatt index |
| * @param serviceIndex the service where the characteristic lives |
| * @param characteristicUuid the characteristic uuid to write to |
| * @return true, if the write operation was successful |
| * @throws Exception |
| */ |
| @Deprecated |
| @Rpc(description = "Write the value of a given characteristic to the associated remote device") |
| public boolean gattClientWriteCharacteristic( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicUuid") String characteristicUuid) throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> discoveredServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (discoveredServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = discoveredServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| UUID cUuid = UUID.fromString(characteristicUuid); |
| BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid); |
| if (gattCharacteristic == null) { |
| throw new Exception("Invalid characteristic uuid: " + characteristicUuid); |
| } |
| return bluetoothGatt.writeCharacteristic(gattCharacteristic); |
| } |
| |
| /** |
| * Write the value of a given characteristic to the associated remote device |
| * |
| * @param index the bluetooth gatt index |
| * @param serviceIndex the service where the characteristic lives |
| * @param characteristicIndex the characteristic index |
| * @return true, if the write operation was successful |
| * @throws Exception |
| */ |
| @Rpc(description = "Write the value of a given characteristic to the associated remote device") |
| public boolean gattClientWriteCharacteristicByIndex( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex " + characteristicIndex); |
| } |
| return bluetoothGatt.writeCharacteristic(charList.get(characteristicIndex)); |
| } |
| |
| /** |
| * PTS HELPER... Write the value of a given characteristic to the associated remote device |
| * |
| * @param index the bluetooth gatt index |
| * @param serviceIndex the service where the characteristic lives |
| * @param characteristicIndex the characteristic index |
| * @return true, if the write operation was successful |
| * @throws Exception |
| */ |
| @Rpc(description = "Write the value of a given characteristic to the associated remote device") |
| public boolean gattClientReadInvalidCharacteristicInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "instanceId") Integer instanceId) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| charList.get(0).setInstanceId(instanceId); |
| return bluetoothGatt.readCharacteristic(charList.get(0)); |
| } |
| |
| /** |
| * Get the input Characteristic's instance ID. |
| * |
| * @param index the bluetooth gatt index |
| * @param serviceIndex the service where the characteristic lives |
| * @param characteristicIndex the characteristic index |
| * @return true, if the write operation was successful |
| * @throws Exception |
| */ |
| @Rpc(description = "Write the value of a given characteristic to the associated remote device") |
| public Integer gattClientGetCharacteristicInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex " + characteristicIndex); |
| } |
| return charList.get(characteristicIndex).getInstanceId(); |
| } |
| |
| /** |
| * Get the input Descriptor's instance ID. |
| * |
| * @param index the bluetooth gatt index |
| * @param serviceIndex the service where the characteristic lives |
| * @param characteristicIndex the characteristic index |
| * @param descriptorIndex the descriptor index |
| * @return true, if the write operation was successful |
| * @throws Exception |
| */ |
| @Rpc(description = "Write the value of a given characteristic to the associated remote device") |
| public Integer gattClientGetDescriptorInstanceId( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex, |
| @RpcParameter(name = "descriptorIndex") Integer descriptorIndex) |
| throws Exception { |
| BluetoothGatt bluetoothGatt = mBluetoothGattList.get(gattIndex); |
| if (bluetoothGatt == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> gattServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (gattServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = gattServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex " + characteristicIndex); |
| } |
| BluetoothGattCharacteristic gattCharacteristic = charList.get(characteristicIndex); |
| if (gattCharacteristic == null) { |
| throw new Exception("Invalid characteristicIndex " + serviceIndex); |
| } |
| List<BluetoothGattDescriptor> descList = gattCharacteristic.getDescriptors(); |
| if (descList.get(descriptorIndex) == null) { |
| throw new Exception("Invalid descriptorIndex " + descriptorIndex); |
| } |
| return descList.get(descriptorIndex).getInstanceId(); |
| } |
| |
| /** |
| * Write the value to a discovered characteristic. |
| * |
| * @deprecated Use {@link #gattClientCharacteristicSetValueByIndex( |
| * gattIndex, discoveredServiceListIndex, serviceIndex, characteristicIndex, value)} instead. |
| * @param gattIndex - the gatt index to use |
| * @param discoveredServiceListIndex - the discovered service list index |
| * @param serviceIndex - the service index of the discoveredServiceListIndex |
| * @param characteristicUuid - the characteristic uuid in which the descriptor is |
| * @param value - the value to set the characteristic to |
| * @return true, if the value was set to the characteristic |
| * @throws Exception |
| */ |
| @Deprecated |
| @Rpc(description = "Write the value of a given characteristic to the associated remote device") |
| public boolean gattClientCharacteristicSetValue( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicUuid") String characteristicUuid, |
| @RpcParameter(name = "value") byte[] value) throws Exception { |
| if (mBluetoothGattList.get(gattIndex) == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> discoveredServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (discoveredServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = discoveredServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| UUID cUuid = UUID.fromString(characteristicUuid); |
| BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid); |
| if (gattCharacteristic == null) { |
| throw new Exception("Invalid characteristic uuid: " + characteristicUuid); |
| } |
| return gattCharacteristic.setValue(value); |
| } |
| |
| /** |
| * Write the value to a discovered characteristic. |
| * |
| * @param gattIndex - the gatt index to use |
| * @param discoveredServiceListIndex - the discovered service list index |
| * @param serviceIndex - the service index of the discoveredServiceListIndex |
| * @param characteristicIndex - the characteristic index |
| * @param value - the value to set the characteristic to |
| * @return true, if the value was set to the characteristic |
| * @throws Exception |
| */ |
| @Rpc(description = "Write the value of a given characteristic to the associated remote device") |
| public boolean gattClientCharacteristicSetValueByIndex( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex, |
| @RpcParameter(name = "value") byte[] value) |
| throws Exception { |
| if (mBluetoothGattList.get(gattIndex) == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> discoveredServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (discoveredServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = discoveredServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex: " + characteristicIndex); |
| } |
| return charList.get(characteristicIndex).setValue(value); |
| } |
| |
| /** |
| * Set write type to a discovered characteristic. |
| * |
| * @deprecated Use {@link #gattClientCharacteristicSetWriteTypeByIndex( |
| * gattIndex, discoveredServiceListIndex, serviceIndex, ccharacteristicUuid, writeType)} |
| * instead. |
| * @param gattIndex - the gatt index to use |
| * @param discoveredServiceListIndex - the discovered service list index |
| * @param serviceIndex - the service index of the discoveredServiceListIndex |
| * @param characteristicUuid - the characteristic uuid in which the descriptor is |
| * @param writeType - the write type for characteristic |
| * @return true, if the value was set to the characteristic |
| * @throws Exception |
| */ |
| @Deprecated |
| @Rpc(description = "Set write type of a given characteristic to the associated remote device") |
| public boolean gattClientCharacteristicSetWriteType( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicUuid") String characteristicUuid, |
| @RpcParameter(name = "writeType") Integer writeType) throws Exception { |
| if (mBluetoothGattList.get(gattIndex) == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> discoveredServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (discoveredServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = discoveredServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| UUID cUuid = UUID.fromString(characteristicUuid); |
| BluetoothGattCharacteristic gattCharacteristic = gattService.getCharacteristic(cUuid); |
| if (gattCharacteristic == null) { |
| throw new Exception("Invalid characteristic uuid: " + characteristicUuid); |
| } |
| gattCharacteristic.setWriteType(writeType); |
| return true; |
| } |
| |
| /** |
| * Set write type to a discovered characteristic. |
| * |
| * @param gattIndex - the gatt index to use |
| * @param discoveredServiceListIndex - the discovered service list index |
| * @param serviceIndex - the service index of the discoveredServiceListIndex |
| * @param characteristicIndex - the characteristic index |
| * @param writeType - the write type for characteristic |
| * @return true, if the value was set to the characteristic |
| * @throws Exception |
| */ |
| @Rpc(description = "Set write type of a given characteristic to the associated remote device") |
| public void gattClientCharacteristicSetWriteTypeByIndex( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex, |
| @RpcParameter(name = "writeType") Integer writeType) |
| throws Exception { |
| if (mBluetoothGattList.get(gattIndex) == null) { |
| throw new Exception("Invalid gattIndex " + gattIndex); |
| } |
| List<BluetoothGattService> discoveredServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (discoveredServiceList == null) { |
| throw new Exception("Invalid discoveredServiceListIndex " + discoveredServiceListIndex); |
| } |
| BluetoothGattService gattService = discoveredServiceList.get(serviceIndex); |
| if (gattService == null) { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = gattService.getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex: " + characteristicIndex); |
| } |
| charList.get(characteristicIndex).setWriteType(writeType); |
| } |
| |
| /** |
| * Read the RSSI for a connected remote device |
| * |
| * @param index the bluetooth gatt index |
| * @return true, if the RSSI value has been requested successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Read the RSSI for a connected remote device") |
| public boolean gattClientReadRSSI( |
| @RpcParameter(name = "index") Integer index) throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).readRemoteRssi(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Clears the internal cache and forces a refresh of the services from the remote device |
| * |
| * @param index the bluetooth gatt index |
| * @return Clears the internal cache and forces a refresh of the services from the remote |
| * device. |
| * @throws Exception |
| */ |
| @Rpc(description = "Clears the internal cache and forces a refresh of the services from the " |
| + "remote device") |
| public boolean gattClientRefresh(@RpcParameter(name = "index") Integer index) throws Exception { |
| if (mBluetoothGattList.get(index) != null) { |
| return mBluetoothGattList.get(index).refresh(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Request a connection parameter update. |
| * |
| * @param index the bluetooth gatt index |
| * @param connectionPriority connection priority |
| * @return boolean True if successful False otherwise. |
| * @throws Exception |
| */ |
| @Rpc(description = "Request a connection parameter update. from the Bluetooth Gatt") |
| public boolean gattClientRequestConnectionPriority( |
| @RpcParameter(name = "index") Integer index, |
| @RpcParameter(name = "connectionPriority") Integer connectionPriority) |
| throws Exception { |
| boolean result = false; |
| if (mBluetoothGattList.get(index) != null) { |
| result = mBluetoothGattList.get(index).requestConnectionPriority(connectionPriority); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| return result; |
| } |
| |
| /** |
| * Sets the characteristic notification of a bluetooth gatt |
| * |
| * @deprecated Use {@link #gattClientSetCharacteristicNotificationByIndex( |
| * gattIndex, discoveredServiceListIndex, serviceIndex, characteristicIndex, enable)} instead. |
| * @param index the bluetooth gatt index |
| * @param characteristicIndex the characteristic index |
| * @param enable Enable or disable notifications/indications for a given characteristic |
| * @return true, if the requested notification status was set successfully |
| * @throws Exception |
| */ |
| @Deprecated |
| @Rpc(description = "Sets the characteristic notification of a bluetooth gatt") |
| public boolean gattClientSetCharacteristicNotification( |
| @RpcParameter(name = "gattIndex") |
| Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") |
| Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") |
| Integer serviceIndex, |
| @RpcParameter(name = "characteristicUuid") |
| String characteristicUuid, |
| @RpcParameter(name = "enable") |
| Boolean enable |
| ) throws Exception { |
| if (mBluetoothGattList.get(gattIndex) != null) { |
| if(mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex) != null) { |
| List<BluetoothGattService> discoveredServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (discoveredServiceList.get(serviceIndex) != null) { |
| UUID cUuid = UUID.fromString(characteristicUuid); |
| if (discoveredServiceList.get(serviceIndex).getCharacteristic(cUuid) != null) { |
| return mBluetoothGattList.get(gattIndex).setCharacteristicNotification( |
| discoveredServiceList.get(serviceIndex).getCharacteristic(cUuid), enable); |
| } else { |
| throw new Exception ("Invalid characteristic uuid: " + characteristicUuid); |
| } |
| } else { |
| throw new Exception ("Invalid serviceIndex " + serviceIndex); |
| } |
| } else { |
| throw new Exception("Invalid discoveredServiceListIndex: " + discoveredServiceListIndex); |
| } |
| } else { |
| throw new Exception("Invalid gattIndex input: " + gattIndex); |
| } |
| } |
| |
| /** |
| * Sets the characteristic notification of a bluetooth gatt |
| * |
| * @param index the bluetooth gatt index |
| * @param characteristicIndex the characteristic index |
| * @param enable Enable or disable notifications/indications for a given characteristic |
| * @return true, if the requested notification status was set successfully |
| * @throws Exception |
| */ |
| @Rpc(description = "Sets the characteristic notification of a bluetooth gatt") |
| public boolean gattClientSetCharacteristicNotificationByIndex( |
| @RpcParameter(name = "gattIndex") Integer gattIndex, |
| @RpcParameter(name = "discoveredServiceListIndex") Integer discoveredServiceListIndex, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex, |
| @RpcParameter(name = "enable") Boolean enable) |
| throws Exception { |
| if (mBluetoothGattList.get(gattIndex) != null) { |
| if (mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex) != null) { |
| List<BluetoothGattService> discoveredServiceList = |
| mBluetoothGattDiscoveredServicesList.get(discoveredServiceListIndex); |
| if (discoveredServiceList.get(serviceIndex) != null) { |
| List<BluetoothGattCharacteristic> charList = |
| discoveredServiceList.get(serviceIndex).getCharacteristics(); |
| if (charList.get(characteristicIndex) != null) { |
| return mBluetoothGattList |
| .get(gattIndex) |
| .setCharacteristicNotification(charList.get(characteristicIndex), |
| enable); |
| } else { |
| throw new Exception("Invalid characteristicIndex: " + characteristicIndex); |
| } |
| } else { |
| throw new Exception("Invalid serviceIndex " + serviceIndex); |
| } |
| } else { |
| throw new Exception( |
| "Invalid discoveredServiceListIndex: " + discoveredServiceListIndex); |
| } |
| } else { |
| throw new Exception("Invalid gattIndex input: " + gattIndex); |
| } |
| } |
| |
| /** |
| * Create a new GattCallback object |
| * |
| * @return the index of the callback object |
| */ |
| @Rpc(description = "Create a new GattCallback object") |
| public Integer gattCreateGattCallback() { |
| GattCallbackCount += 1; |
| int index = GattCallbackCount; |
| mGattCallbackList.put(index, new myBluetoothGattCallback(index)); |
| return index; |
| } |
| |
| /** |
| * Returns the list of discovered Bluetooth Gatt Services. |
| * |
| * @throws Exception |
| */ |
| @Rpc(description = "Get Bluetooth Gatt Services") |
| public int gattClientGetDiscoveredServicesCount(@RpcParameter(name = "index") Integer index) |
| throws Exception { |
| if (mBluetoothGattDiscoveredServicesList.get(index) != null) { |
| return mBluetoothGattDiscoveredServicesList.get(index).size(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Returns the discovered Bluetooth Gatt Service Uuid. |
| * |
| * @throws Exception |
| */ |
| @Rpc(description = "Get Bluetooth Gatt Service Uuid") |
| public String gattClientGetDiscoveredServiceUuid( |
| @RpcParameter(name = "index") Integer index, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex) |
| throws Exception { |
| List<BluetoothGattService> mBluetoothServiceList = |
| mBluetoothGattDiscoveredServicesList.get(index); |
| if (mBluetoothServiceList != null) { |
| return mBluetoothServiceList.get(serviceIndex).getUuid().toString(); |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Get discovered characteristic uuids from the pheripheral device. |
| * |
| * @param index the index of the bluetooth gatt discovered services list |
| * @param serviceIndex the service to get |
| * @return the list of characteristic uuids |
| * @throws Exception |
| */ |
| @Rpc(description = "Get Bluetooth Gatt Services") |
| public ArrayList<String> gattClientGetDiscoveredCharacteristicUuids( |
| @RpcParameter(name = "index") Integer index, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex) |
| throws Exception { |
| if (mBluetoothGattDiscoveredServicesList.get(index) != null) { |
| if (mBluetoothGattDiscoveredServicesList.get(index).get(serviceIndex) != null) { |
| ArrayList<String> uuidList = new ArrayList<String>(); |
| List<BluetoothGattCharacteristic> charList = |
| mBluetoothGattDiscoveredServicesList.get(index).get( |
| serviceIndex).getCharacteristics(); |
| for (BluetoothGattCharacteristic mChar : charList) { |
| uuidList.add(mChar.getUuid().toString()); |
| } |
| return uuidList; |
| } else { |
| throw new Exception("Invalid serviceIndex input:" + index); |
| } |
| } else { |
| throw new Exception("Invalid index input:" + index); |
| } |
| } |
| |
| /** |
| * Get discovered descriptor uuids from the pheripheral device. |
| * |
| * @deprecated Use {@link #gattClientGetDiscoveredDescriptorUuidsByIndex( |
| * index, serviceIndex, characteristicIndex)} instead. |
| * @param index the discovered services list index |
| * @param serviceIndex the service index of the discovered services list |
| * @param characteristicUuid the characteristicUuid to select from the |
| * discovered service which contains the list of descriptors. |
| * @return the list of descriptor uuids |
| * @throws Exception |
| */ |
| @Deprecated |
| @Rpc(description = "Get Bluetooth Gatt Services") |
| public ArrayList<String> gattClientGetDiscoveredDescriptorUuids ( |
| @RpcParameter(name = "index") |
| Integer index, |
| @RpcParameter(name = "serviceIndex") |
| Integer serviceIndex, |
| @RpcParameter(name = "characteristicUuid") |
| String characteristicUuid |
| ) throws Exception { |
| if (mBluetoothGattDiscoveredServicesList.get(index) != null) { |
| if (mBluetoothGattDiscoveredServicesList.get(index).get(serviceIndex) != null) { |
| BluetoothGattService service = mBluetoothGattDiscoveredServicesList.get( |
| index).get(serviceIndex); |
| UUID cUuid = UUID.fromString(characteristicUuid); |
| if (service.getCharacteristic(cUuid) != null) { |
| ArrayList<String> uuidList = new ArrayList<String>(); |
| for (BluetoothGattDescriptor mDesc : service.getCharacteristic( |
| cUuid).getDescriptors()) { |
| uuidList.add(mDesc.getUuid().toString()); |
| } |
| return uuidList; |
| } else { |
| throw new Exception("Invalid characeristicUuid : " |
| + characteristicUuid); |
| } |
| } else { |
| throw new Exception("Invalid serviceIndex input:" |
| + index); |
| } |
| } else { |
| throw new Exception("Invalid index input:" |
| + index); |
| } |
| } |
| |
| /** |
| * Get discovered descriptor uuids from the pheripheral device. |
| * |
| * @param index the discovered services list index |
| * @param serviceIndex the service index of the discovered services list |
| * @param characteristicIndex the characteristicIndex to select from the discovered service |
| * which contains the list of descriptors. |
| * @return the list of descriptor uuids |
| * @throws Exception |
| */ |
| @Rpc(description = "Get Bluetooth Gatt Services") |
| public ArrayList<String> gattClientGetDiscoveredDescriptorUuidsByIndex( |
| @RpcParameter(name = "index") Integer index, |
| @RpcParameter(name = "serviceIndex") Integer serviceIndex, |
| @RpcParameter(name = "characteristicIndex") Integer characteristicIndex) |
| throws Exception { |
| if (mBluetoothGattDiscoveredServicesList.get(index) == null) { |
| throw new Exception("Invalid index: " + index); |
| } |
| if (mBluetoothGattDiscoveredServicesList.get(index).get(serviceIndex) == null) { |
| throw new Exception("Invalid serviceIndex: " + serviceIndex); |
| } |
| List<BluetoothGattCharacteristic> charList = |
| mBluetoothGattDiscoveredServicesList.get(index).get( |
| serviceIndex).getCharacteristics(); |
| if (charList.get(characteristicIndex) == null) { |
| throw new Exception("Invalid characteristicIndex: " + characteristicIndex); |
| } |
| List<BluetoothGattDescriptor> descList = charList.get(characteristicIndex).getDescriptors(); |
| ArrayList<String> uuidList = new ArrayList<String>(); |
| for (BluetoothGattDescriptor mDesc : descList) { |
| uuidList.add(mDesc.getUuid().toString()); |
| } |
| return uuidList; |
| } |
| |
| private class myBluetoothGattCallback extends BluetoothGattCallback { |
| private final Bundle mResults; |
| private final int index; |
| private final String mEventType; |
| |
| public myBluetoothGattCallback(int idx) { |
| mResults = new Bundle(); |
| mEventType = "GattConnect"; |
| index = idx; |
| } |
| |
| @Override |
| public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) { |
| Log.d("gatt_connect change onConnectionStateChange " + mEventType + " " + index); |
| if (newState == BluetoothProfile.STATE_CONNECTED) { |
| Log.d( |
| "State Connected to mac address " |
| + gatt.getDevice().getAddress() |
| + " status " |
| + status); |
| } else if (newState == BluetoothProfile.STATE_DISCONNECTED) { |
| Log.d( |
| "State Disconnected from mac address " |
| + gatt.getDevice().getAddress() |
| + " status " |
| + status); |
| } else if (newState == BluetoothProfile.STATE_CONNECTING) { |
| Log.d( |
| "State Connecting to mac address " |
| + gatt.getDevice().getAddress() |
| + " status " |
| + status); |
| } else if (newState == BluetoothProfile.STATE_DISCONNECTING) { |
| Log.d( |
| "State Disconnecting from mac address " |
| + gatt.getDevice().getAddress() |
| + " status " |
| + status); |
| } |
| mResults.putInt("Status", status); |
| mResults.putInt("State", newState); |
| mEventFacade.postEvent( |
| mEventType + index + "onConnectionStateChange", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onPhyRead(BluetoothGatt gatt, int txPhy, int rxPhy, int status) { |
| Log.d("gatt_connect change onPhyRead " + mEventType + " " + index); |
| mResults.putInt("TxPhy", txPhy); |
| mResults.putInt("RxPhy", rxPhy); |
| mResults.putInt("Status", status); |
| mEventFacade.postEvent(mEventType + index + "onPhyRead", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onPhyUpdate(BluetoothGatt gatt, int txPhy, int rxPhy, int status) { |
| Log.d("gatt_connect change onPhyUpdate " + mEventType + " " + index); |
| mResults.putInt("TxPhy", txPhy); |
| mResults.putInt("RxPhy", rxPhy); |
| mResults.putInt("Status", status); |
| mEventFacade.postEvent(mEventType + index + "onPhyUpdate", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onServicesDiscovered(BluetoothGatt gatt, int status) { |
| Log.d("gatt_connect change onServicesDiscovered " + mEventType + " " + index); |
| int idx = BluetoothGattDiscoveredServicesCount++; |
| mBluetoothGattDiscoveredServicesList.put(idx, gatt.getServices()); |
| mResults.putInt("ServicesIndex", idx); |
| mResults.putInt("Status", status); |
| mEventFacade.postEvent(mEventType + index + "onServicesDiscovered", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onCharacteristicRead( |
| BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) { |
| Log.d("gatt_connect change onCharacteristicRead " + mEventType + " " + index); |
| mResults.putInt("Status", status); |
| mResults.putString("CharacteristicUuid", characteristic.getUuid().toString()); |
| mResults.putByteArray("CharacteristicValue", characteristic.getValue()); |
| mEventFacade.postEvent(mEventType + index + "onCharacteristicRead", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onCharacteristicWrite( |
| BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) { |
| Log.d("gatt_connect change onCharacteristicWrite " + mEventType + " " + index); |
| mResults.putInt("Status", status); |
| mResults.putString("CharacteristicUuid", characteristic.getUuid().toString()); |
| mResults.putByteArray("CharacteristicValue", characteristic.getValue()); |
| mEventFacade.postEvent(mEventType + index + "onCharacteristicWrite", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onCharacteristicChanged( |
| BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) { |
| Log.d("gatt_connect change onCharacteristicChanged " + mEventType + " " + index); |
| mResults.putInt("ID", index); |
| mResults.putString("CharacteristicUuid", characteristic.getUuid().toString()); |
| mResults.putByteArray("CharacteristicValue", characteristic.getValue()); |
| mEventFacade.postEvent( |
| mEventType + index + "onCharacteristicChanged", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onDescriptorRead( |
| BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) { |
| Log.d("gatt_connect change onServicesDiscovered " + mEventType + " " + index); |
| mResults.putInt("Status", status); |
| mResults.putString("DescriptorUuid", descriptor.getUuid().toString()); |
| mEventFacade.postEvent(mEventType + index + "onDescriptorRead", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onDescriptorWrite( |
| BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) { |
| Log.d("gatt_connect change onDescriptorWrite " + mEventType + " " + index); |
| mResults.putInt("ID", index); |
| mResults.putInt("Status", status); |
| mResults.putString("DescriptorUuid", descriptor.getUuid().toString()); |
| mEventFacade.postEvent(mEventType + index + "onDescriptorWrite", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onReliableWriteCompleted(BluetoothGatt gatt, int status) { |
| Log.d("gatt_connect change onReliableWriteCompleted " + mEventType + " " + index); |
| mResults.putInt("Status", status); |
| mEventFacade.postEvent( |
| mEventType + index + "onReliableWriteCompleted", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) { |
| Log.d("gatt_connect change onReadRemoteRssi " + mEventType + " " + index); |
| mResults.putInt("Status", status); |
| mResults.putInt("Rssi", rssi); |
| mEventFacade.postEvent(mEventType + index + "onReadRemoteRssi", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| @Override |
| public void onMtuChanged(BluetoothGatt gatt, int mtu, int status) { |
| Log.d("gatt_connect change onMtuChanged " + mEventType + " " + index); |
| mResults.putInt("Status", status); |
| mResults.putInt("MTU", mtu); |
| mEventFacade.postEvent(mEventType + index + "onMtuChanged", mResults.clone()); |
| mResults.clear(); |
| } |
| |
| public void onConnectionUpdated(BluetoothGatt gatt, int interval, int latency, |
| int timeout, int status) { |
| Log.d("gatt_connect change onConnecitonUpdated " + mEventType + " " + index |
| + ", interval: " + interval + ", latency: " + latency |
| + ", timeout: " + timeout + ", status: " + status); |
| |
| mResults.putInt("Status", status); |
| mResults.putInt("Interval", interval); |
| mResults.putInt("Latency", latency); |
| mResults.putInt("Timeout", timeout); |
| mEventFacade.postEvent(mEventType + index + "onConnectionUpdated", mResults.clone()); |
| mResults.clear(); |
| } |
| } |
| |
| @Override |
| public void shutdown() { |
| if (!mBluetoothGattList.isEmpty()) { |
| if (mBluetoothGattList.values() != null) { |
| for (BluetoothGatt mBluetoothGatt : mBluetoothGattList.values()) { |
| mBluetoothGatt.close(); |
| } |
| } |
| } |
| mGattCallbackList.clear(); |
| } |
| } |