weave/src/device-manager/java/src/nl/Weave/DeviceManager/WeaveStack.java - nest-cam/4320010/weave - Git at Google

 /*
  *
  *    Copyright (c) 013-2017 Nest Labs, Inc.
  *    All rights reserved.
  *
  *    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 nl.Weave.DeviceManager;

 import android.bluetooth.BluetoothGatt;
 import android.bluetooth.BluetoothGattCallback;
 import android.bluetooth.BluetoothGattCharacteristic;
 import android.bluetooth.BluetoothGattDescriptor;
 import android.bluetooth.BluetoothGattService;
 import android.bluetooth.BluetoothProfile;
 import android.os.Build;
 import android.util.Log;

 import java.util.ArrayList;
 import java.util.UUID;

 /*
  * WeaveStack - a singleton object shared between all instances of
  * WeaveDeviceManager.
  *
  * Holds list of active connections with mapping to the associated
  * connection object.
  */
 public final class WeaveStack
 {
     private static final String TAG = WeaveStack.class.getSimpleName();
     public static final int INITIAL_CONNECTIONS = 4;

     private static class BleMtuBlacklist
     {
 	/**
 	 * Will be set at initialization to indicate whether the device on which this code is being run
 	 * is known to indicate unreliable MTU values for Bluetooth LE connections.
 	 */
 	static final boolean BLE_MTU_BLACKLISTED;

 	/**
 	 * If {@link #BLE_MTU_BLACKLISTED} is true, then this is the fallback MTU to use for this device
 	 */
 	static final int BLE_MTU_FALLBACK = 23;

 	static
 	{
 	    if ("OnePlus".equals(android.os.Build.MANUFACTURER))
 	    {
 		if ("ONE A2005".equals(android.os.Build.MODEL))
 		{
 		    BLE_MTU_BLACKLISTED = true;
 		}
 		else
 		{
 		    BLE_MTU_BLACKLISTED = false;
 		}
 	    }
 	    else if ("motorola".equals(android.os.Build.MANUFACTURER))
 	    {
 		if ("XT1575".equals(android.os.Build.MODEL) ||
 		    "XT1585".equals(android.os.Build.MODEL))
 		{
 		    BLE_MTU_BLACKLISTED = true;
                 }
 		else
 		{
 		    BLE_MTU_BLACKLISTED = false;
 		}
 	    }
 	    else
 	    {
 		BLE_MTU_BLACKLISTED = false;
 	    }
 	}
     }

     /*
      * Singleton instance of this class
      */
     private static final WeaveStack sInstance = new WeaveStack();

     /*
      * Mapping of connections to connection objects
      */
     private final ArrayList<WeaveDeviceManager> mConnections;

     private BluetoothGattCallback mGattCallback;

     private WeaveStack()
     {
 	mConnections = new ArrayList<WeaveDeviceManager>(INITIAL_CONNECTIONS);

         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2)
         {
             mGattCallback = new BluetoothGattCallback()
             {
 		@Override
 		public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState)
 		{
 		    int connId = 0;

 		    if (newState == BluetoothProfile.STATE_DISCONNECTED)
 		    {
 			connId = getConnId(gatt);
 			if (connId > 0)
 			{
 			    Log.d(TAG, "onConnectionStateChange Disconnected");
 			    handleConnectionError(connId);
 			}
 			else
 			{
 			    Log.e(TAG, "onConnectionStateChange disconnected: no active connection");
 			}
 		    }
 		}

 		@Override
 		public void onServicesDiscovered(BluetoothGatt gatt, int status)
 		{
 		}

 		@Override
 		public void onCharacteristicRead(BluetoothGatt gatt,
 						 BluetoothGattCharacteristic characteristic,
 						 int status)
 		{
 		}

 		@Override
 		public void onCharacteristicWrite(BluetoothGatt gatt,
 						  BluetoothGattCharacteristic characteristic,
 						  int status)
 		{
 		    byte[] svcIdBytes = convertUUIDToBytes(characteristic.getService().getUuid());
 		    byte[] charIdBytes = convertUUIDToBytes(characteristic.getUuid());

 		    if (status != BluetoothGatt.GATT_SUCCESS)
 		    {
 			Log.e(TAG, "onCharacteristicWrite for " + characteristic.getUuid().toString() + " failed with status: " + status);
 			return;
 		    }
 		    int connId = getConnId(gatt);
 		    if (connId > 0)
 		    {
 			handleWriteConfirmation(connId, svcIdBytes, charIdBytes, status == BluetoothGatt.GATT_SUCCESS);
 		    }
 		    else
 		    {
 			Log.e(TAG, "onCharacteristicWrite no active connection");
 			return;
 		    }
 		}

 		@Override
 		public void onCharacteristicChanged(BluetoothGatt gatt,
 						    BluetoothGattCharacteristic characteristic)
 		{
 		    byte[] svcIdBytes = convertUUIDToBytes(characteristic.getService().getUuid());
 		    byte[] charIdBytes = convertUUIDToBytes(characteristic.getUuid());
 		    int connId = getConnId(gatt);
 		    if (connId > 0)
 		    {
                         handleIndicationReceived(connId, svcIdBytes, charIdBytes, characteristic.getValue());
 		    }
 		    else
 		    {
 			Log.e(TAG, "onCharacteristicChanged no active connection");
 			return;
 		    }
 		}

 		@Override
 		public void onDescriptorWrite(BluetoothGatt gatt,
 					      BluetoothGattDescriptor descriptor,
 					      int status)
 		{
 		    BluetoothGattCharacteristic characteristic = descriptor.getCharacteristic();

 		    byte[] svcIdBytes = convertUUIDToBytes(characteristic.getService().getUuid());
 		    byte[] charIdBytes = convertUUIDToBytes(characteristic.getUuid());

 		    if (status != BluetoothGatt.GATT_SUCCESS)
 		    {
 			Log.e(TAG, "onDescriptorWrite for " + descriptor.getUuid().toString() + " failed with status: " + status);
 		    }
 		    int connId = getConnId(gatt);
 		    if (connId == 0)
 		    {
 			Log.e(TAG, "onDescriptorWrite no active connection");
 			return;
 		    }
 		    if (descriptor.getValue() == BluetoothGattDescriptor.ENABLE_INDICATION_VALUE)
 		    {
 			handleSubscribeComplete(connId, svcIdBytes, charIdBytes, status == BluetoothGatt.GATT_SUCCESS);
 		    }
 		    else if (descriptor.getValue() == BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE)
 		    {
 			handleUnsubscribeComplete(connId, svcIdBytes, charIdBytes, status == BluetoothGatt.GATT_SUCCESS);
 		    }
 		    else
 		    {
 			Log.d(TAG, "Unexpected onDescriptorWrite().");
 		    }
 		}

 		@Override
 		public void onDescriptorRead(BluetoothGatt gatt,
 					     BluetoothGattDescriptor descriptor,
 					     int status)
 		{
 		}
 	    };
         }

     }

     public static WeaveStack getInstance()
     {
 	return sInstance;
     }

     public BluetoothGattCallback getCallback()
     {
         return mGattCallback;
     }

     public synchronized WeaveDeviceManager getConnection(int connId)
     {
         int connIndex = connId - 1;
         if (connIndex >= 0 && connIndex < mConnections.size())
         {
             return mConnections.get(connIndex);
         }
         else
         {
             Log.e(TAG, "Unknown connId " + connId);
             return null;
         }
     }

     public synchronized int getConnId(BluetoothGatt gatt)
     {
        // Find callback given gatt
        int connIndex = 0;
        while  (connIndex < mConnections.size())
        {
            WeaveDeviceManager devMgr = mConnections.get(connIndex);
            if (devMgr != null)
            {
                if (gatt == devMgr.getBluetoothGatt())
                {
                    return connIndex + 1;
                }
            }
 	   connIndex++;
        }
        return 0;
     }

     // Returns connId, a 1's based version of the index.
     public synchronized int addConnection(WeaveDeviceManager connObj)
     {
 	int connIndex = 0;
 	while (connIndex < mConnections.size())
 	{
 	    if (mConnections.get(connIndex) == null)
 	    {
 	        mConnections.set(connIndex, connObj);
 	        return connIndex + 1;
 	    }
 	    connIndex++;
 	}
 	mConnections.add(connIndex, connObj);
 	return connIndex + 1;
     }

     public synchronized WeaveDeviceManager removeConnection(int connId)
     {
         int connIndex = connId - 1;
         if (connIndex >= 0 && connIndex < mConnections.size())
         {
             // Set to null, rather than remove, so that other indexes are unchanged.
             return mConnections.set(connIndex, null);
         }
         else
         {
             Log.e(TAG, "Trying to remove unknown connId " + connId);
             return null;
         }
     }

     public static void onNotifyWeaveConnectionClosed(int connId)
     {
 	WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
 	deviceManager.onNotifyWeaveConnectionClosed(connId);
     }

     public static boolean onSendCharacteristic(int connId, byte[] svcId, byte[] charId, byte[] characteristicData)
     {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2)
 	{
 	    WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
 	    BluetoothGatt bluetoothGatt = deviceManager.getBluetoothGatt();
 	    if (bluetoothGatt == null)
 		return false;

 	    UUID svcUUID = convertBytesToUUID(svcId);
 	    BluetoothGattService sendSvc = bluetoothGatt.getService(svcUUID);
 	    if (sendSvc == null)
 	    {
 		Log.e(TAG, "Bad service");
 		return false;
 	    }

 	    UUID charUUID = convertBytesToUUID(charId);
 	    BluetoothGattCharacteristic sendChar = sendSvc.getCharacteristic(charUUID);
 	    if (!sendChar.setValue(characteristicData))
 	    {
 		Log.e(TAG, "Failed to set characteristic");
 		return false;
 	    }

 	    if (!bluetoothGatt.writeCharacteristic(sendChar))
 	    {
 		Log.e(TAG, "Failed writing char");
 		return false;
 	    }
 	    return true;
 	}
 	else
 	{
 	    Log.e(TAG, "BLE not supported on device.");
 	}
 	return false;
     }

     public static boolean onSubscribeCharacteristic(int connId, byte[] svcId, byte[] charId)
     {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2)
         {
 	    WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
 	    BluetoothGatt bluetoothGatt = deviceManager.getBluetoothGatt();
 	    if (bluetoothGatt == null)
 		return false;

 	    UUID svcUUID = convertBytesToUUID(svcId);
 	    BluetoothGattService subscribeSvc = bluetoothGatt.getService(svcUUID);
 	    if (subscribeSvc == null)
 	    {
 		Log.e(TAG, "Bad service");
 		return false;
 	    }

 	    UUID charUUID = convertBytesToUUID(charId);
 	    BluetoothGattCharacteristic subscribeChar = subscribeSvc.getCharacteristic(charUUID);
 	    if (subscribeChar == null)
 	    {
 		Log.e(TAG, "Bad characteristic");
 		return false;
 	    }

 	    if (!bluetoothGatt.setCharacteristicNotification(subscribeChar, true))
 	    {
 		Log.e(TAG, "Failed to subscribe to characteristic.");
 		return false;
 	    }

 	    BluetoothGattDescriptor descriptor =
 		subscribeChar.getDescriptor(UUID.fromString(CLIENT_CHARACTERISTIC_CONFIG));
 	    descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
 	    if (!bluetoothGatt.writeDescriptor(descriptor))
 	    {
 		Log.e(TAG, "writeDescriptor failed");
 		return false;
 	    }
 	    return true;
 	}
 	else
 	{
 	    Log.e(TAG, "BLE not supported on device.");
 	}
 	return false;
     }

     public static boolean onUnsubscribeCharacteristic(int connId, byte[] svcId, byte[] charId)
     {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2)
         {
 	    WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
 	    BluetoothGatt bluetoothGatt = deviceManager.getBluetoothGatt();
 	    if (bluetoothGatt == null)
 		return false;

 	    UUID svcUUID = convertBytesToUUID(svcId);
 	    BluetoothGattService subscribeSvc = bluetoothGatt.getService(svcUUID);
 	    if (subscribeSvc == null)
 	    {
 		Log.e(TAG, "Bad service");
 		return false;
 	    }

 	    UUID charUUID = convertBytesToUUID(charId);
 	    BluetoothGattCharacteristic subscribeChar = subscribeSvc.getCharacteristic(charUUID);
 	    if (subscribeChar == null)
 	    {
 		Log.e(TAG, "Bad characteristic");
 		return false;
 	    }

 	    if (!bluetoothGatt.setCharacteristicNotification(subscribeChar, false))
 	    {
 		Log.e(TAG, "Failed to unsubscribe to characteristic.");
 		return false;
 	    }

 	    BluetoothGattDescriptor descriptor =
 		subscribeChar.getDescriptor(UUID.fromString(CLIENT_CHARACTERISTIC_CONFIG));
 	    descriptor.setValue(BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
 	    if (!bluetoothGatt.writeDescriptor(descriptor))
 	    {
 		Log.e(TAG, "writeDescriptor failed");
 		return false;
 	    }
 	    return true;
 	}
 	else
 	{
 	    Log.e(TAG, "BLE not supported on device.");
 	}
 	return false;
     }

     public static boolean onCloseConnection(int connId)
     {
 	WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
 	deviceManager.onCloseBleComplete(connId);
 	return true;
     }

     // onGetMTU returns the desired MTU for the BLE connection.
     // In most cases, a value of 0 is used to indicate no preference.
     // On some devices, we override to use the minimum MTU to work around device bugs.
     public static int onGetMTU(int connId)
     {
 	int mtu = 0;

 	Log.d(TAG, "Android Manufacturer: (" + android.os.Build.MANUFACTURER + ")");
 	Log.d(TAG, "Android Model: (" + android.os.Build.MODEL + ")");

 	if (BleMtuBlacklist.BLE_MTU_BLACKLISTED)
 	{
 	    mtu = BleMtuBlacklist.BLE_MTU_FALLBACK;
 	    Log.e(TAG, "Detected Android Manufacturer/Model with MTU compatibiility issues. Reporting mtu of " + mtu);
 	}
 	return mtu;
     }

     // ----- Private Members -----

     static {
         System.loadLibrary("WeaveDeviceManager");
     }

     private native void handleWriteConfirmation(int connId, byte[] svcId, byte[] charId, boolean success);
     private native void handleIndicationReceived(int connId, byte[] svcId, byte[] charId, byte[] data);
     private native void handleSubscribeComplete(int connId, byte[] svcId, byte[] charId, boolean success);
     private native void handleUnsubscribeComplete(int connId, byte[] svcId, byte[] charId, boolean success);
     private native void handleConnectionError(int connId);

     // CLIENT_CHARACTERISTIC_CONFIG is the well-known UUID of the client characteristic descriptor that has the
     // flags for enabling and disabling notifications and indications.
     // c.f. https://www.bluetooth.org/en-us/specification/assigned-numbers/generic-attribute-profile
     private static String CLIENT_CHARACTERISTIC_CONFIG = "00002902-0000-1000-8000-00805f9b34fb";

     private static byte[] convertUUIDToBytes(UUID uuid)
     {
 	byte[] idBytes = new byte[16];
 	long idBits;
 	idBits = uuid.getLeastSignificantBits();
 	for (int i = 0; i < 8; i++)
         {
 	    idBytes[15 - i] = (byte) (idBits & 0xff);
 	    idBits = idBits >> 8;
 	}
 	idBits = uuid.getMostSignificantBits();
 	for (int i = 0; i < 8; i++)
         {
 	    idBytes[7 - i] = (byte) (idBits & 0xff);
 	    idBits = idBits >> 8;
         }
 	return idBytes;
     }

     private static UUID convertBytesToUUID(byte[] id)
     {
         long mostSigBits = 0;
         long leastSigBits = 0;

 	if (id.length == 16)
         {
 	    for (int i = 0; i < 8; i++)
 	    {
 		mostSigBits = (mostSigBits << 8) | (0xff & id[i]);
 	    }
 	    for (int i = 0; i < 8; i++)
 	    {
 		leastSigBits = (leastSigBits << 8) | (0xff & id[i + 8]);
 	    }
 	}
         return new UUID(mostSigBits, leastSigBits);
     }
 }
	/*
	*
	* Copyright (c) 013-2017 Nest Labs, Inc.
	* All rights reserved.
	*
	* 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 nl.Weave.DeviceManager;

	import android.bluetooth.BluetoothGatt;
	import android.bluetooth.BluetoothGattCallback;
	import android.bluetooth.BluetoothGattCharacteristic;
	import android.bluetooth.BluetoothGattDescriptor;
	import android.bluetooth.BluetoothGattService;
	import android.bluetooth.BluetoothProfile;
	import android.os.Build;
	import android.util.Log;

	import java.util.ArrayList;
	import java.util.UUID;

	/*
	* WeaveStack - a singleton object shared between all instances of
	* WeaveDeviceManager.
	*
	* Holds list of active connections with mapping to the associated
	* connection object.
	*/
	public final class WeaveStack
	{
	private static final String TAG = WeaveStack.class.getSimpleName();
	public static final int INITIAL_CONNECTIONS = 4;

	private static class BleMtuBlacklist
	{
	/**
	* Will be set at initialization to indicate whether the device on which this code is being run
	* is known to indicate unreliable MTU values for Bluetooth LE connections.
	*/
	static final boolean BLE_MTU_BLACKLISTED;

	/**
	* If {@link #BLE_MTU_BLACKLISTED} is true, then this is the fallback MTU to use for this device
	*/
	static final int BLE_MTU_FALLBACK = 23;

	static
	{
	if ("OnePlus".equals(android.os.Build.MANUFACTURER))
	{
	if ("ONE A2005".equals(android.os.Build.MODEL))
	{
	BLE_MTU_BLACKLISTED = true;
	}
	else
	{
	BLE_MTU_BLACKLISTED = false;
	}
	}
	else if ("motorola".equals(android.os.Build.MANUFACTURER))
	{
	if ("XT1575".equals(android.os.Build.MODEL) \|\|
	"XT1585".equals(android.os.Build.MODEL))
	{
	BLE_MTU_BLACKLISTED = true;
	}
	else
	{
	BLE_MTU_BLACKLISTED = false;
	}
	}
	else
	{
	BLE_MTU_BLACKLISTED = false;
	}
	}
	}

	/*
	* Singleton instance of this class
	*/
	private static final WeaveStack sInstance = new WeaveStack();

	/*
	* Mapping of connections to connection objects
	*/
	private final ArrayList<WeaveDeviceManager> mConnections;

	private BluetoothGattCallback mGattCallback;

	private WeaveStack()
	{
	mConnections = new ArrayList<WeaveDeviceManager>(INITIAL_CONNECTIONS);

	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2)
	{
	mGattCallback = new BluetoothGattCallback()
	{
	@Override
	public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState)
	{
	int connId = 0;

	if (newState == BluetoothProfile.STATE_DISCONNECTED)
	{
	connId = getConnId(gatt);
	if (connId > 0)
	{
	Log.d(TAG, "onConnectionStateChange Disconnected");
	handleConnectionError(connId);
	}
	else
	{
	Log.e(TAG, "onConnectionStateChange disconnected: no active connection");
	}
	}
	}

	@Override
	public void onServicesDiscovered(BluetoothGatt gatt, int status)
	{
	}

	@Override
	public void onCharacteristicRead(BluetoothGatt gatt,
	BluetoothGattCharacteristic characteristic,
	int status)
	{
	}

	@Override
	public void onCharacteristicWrite(BluetoothGatt gatt,
	BluetoothGattCharacteristic characteristic,
	int status)
	{
	byte[] svcIdBytes = convertUUIDToBytes(characteristic.getService().getUuid());
	byte[] charIdBytes = convertUUIDToBytes(characteristic.getUuid());

	if (status != BluetoothGatt.GATT_SUCCESS)
	{
	Log.e(TAG, "onCharacteristicWrite for " + characteristic.getUuid().toString() + " failed with status: " + status);
	return;
	}
	int connId = getConnId(gatt);
	if (connId > 0)
	{
	handleWriteConfirmation(connId, svcIdBytes, charIdBytes, status == BluetoothGatt.GATT_SUCCESS);
	}
	else
	{
	Log.e(TAG, "onCharacteristicWrite no active connection");
	return;
	}
	}

	@Override
	public void onCharacteristicChanged(BluetoothGatt gatt,
	BluetoothGattCharacteristic characteristic)
	{
	byte[] svcIdBytes = convertUUIDToBytes(characteristic.getService().getUuid());
	byte[] charIdBytes = convertUUIDToBytes(characteristic.getUuid());
	int connId = getConnId(gatt);
	if (connId > 0)
	{
	handleIndicationReceived(connId, svcIdBytes, charIdBytes, characteristic.getValue());
	}
	else
	{
	Log.e(TAG, "onCharacteristicChanged no active connection");
	return;
	}
	}

	@Override
	public void onDescriptorWrite(BluetoothGatt gatt,
	BluetoothGattDescriptor descriptor,
	int status)
	{
	BluetoothGattCharacteristic characteristic = descriptor.getCharacteristic();

	byte[] svcIdBytes = convertUUIDToBytes(characteristic.getService().getUuid());
	byte[] charIdBytes = convertUUIDToBytes(characteristic.getUuid());

	if (status != BluetoothGatt.GATT_SUCCESS)
	{
	Log.e(TAG, "onDescriptorWrite for " + descriptor.getUuid().toString() + " failed with status: " + status);
	}
	int connId = getConnId(gatt);
	if (connId == 0)
	{
	Log.e(TAG, "onDescriptorWrite no active connection");
	return;
	}
	if (descriptor.getValue() == BluetoothGattDescriptor.ENABLE_INDICATION_VALUE)
	{
	handleSubscribeComplete(connId, svcIdBytes, charIdBytes, status == BluetoothGatt.GATT_SUCCESS);
	}
	else if (descriptor.getValue() == BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE)
	{
	handleUnsubscribeComplete(connId, svcIdBytes, charIdBytes, status == BluetoothGatt.GATT_SUCCESS);
	}
	else
	{
	Log.d(TAG, "Unexpected onDescriptorWrite().");
	}
	}

	@Override
	public void onDescriptorRead(BluetoothGatt gatt,
	BluetoothGattDescriptor descriptor,
	int status)
	{
	}
	};
	}

	}

	public static WeaveStack getInstance()
	{
	return sInstance;
	}

	public BluetoothGattCallback getCallback()
	{
	return mGattCallback;
	}

	public synchronized WeaveDeviceManager getConnection(int connId)
	{
	int connIndex = connId - 1;
	if (connIndex >= 0 && connIndex < mConnections.size())
	{
	return mConnections.get(connIndex);
	}
	else
	{
	Log.e(TAG, "Unknown connId " + connId);
	return null;
	}
	}

	public synchronized int getConnId(BluetoothGatt gatt)
	{
	// Find callback given gatt
	int connIndex = 0;
	while (connIndex < mConnections.size())
	{
	WeaveDeviceManager devMgr = mConnections.get(connIndex);
	if (devMgr != null)
	{
	if (gatt == devMgr.getBluetoothGatt())
	{
	return connIndex + 1;
	}
	}
	connIndex++;
	}
	return 0;
	}

	// Returns connId, a 1's based version of the index.
	public synchronized int addConnection(WeaveDeviceManager connObj)
	{
	int connIndex = 0;
	while (connIndex < mConnections.size())
	{
	if (mConnections.get(connIndex) == null)
	{
	mConnections.set(connIndex, connObj);
	return connIndex + 1;
	}
	connIndex++;
	}
	mConnections.add(connIndex, connObj);
	return connIndex + 1;
	}

	public synchronized WeaveDeviceManager removeConnection(int connId)
	{
	int connIndex = connId - 1;
	if (connIndex >= 0 && connIndex < mConnections.size())
	{
	// Set to null, rather than remove, so that other indexes are unchanged.
	return mConnections.set(connIndex, null);
	}
	else
	{
	Log.e(TAG, "Trying to remove unknown connId " + connId);
	return null;
	}
	}

	public static void onNotifyWeaveConnectionClosed(int connId)
	{
	WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
	deviceManager.onNotifyWeaveConnectionClosed(connId);
	}

	public static boolean onSendCharacteristic(int connId, byte[] svcId, byte[] charId, byte[] characteristicData)
	{
	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2)
	{
	WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
	BluetoothGatt bluetoothGatt = deviceManager.getBluetoothGatt();
	if (bluetoothGatt == null)
	return false;

	UUID svcUUID = convertBytesToUUID(svcId);
	BluetoothGattService sendSvc = bluetoothGatt.getService(svcUUID);
	if (sendSvc == null)
	{
	Log.e(TAG, "Bad service");
	return false;
	}

	UUID charUUID = convertBytesToUUID(charId);
	BluetoothGattCharacteristic sendChar = sendSvc.getCharacteristic(charUUID);
	if (!sendChar.setValue(characteristicData))
	{
	Log.e(TAG, "Failed to set characteristic");
	return false;
	}

	if (!bluetoothGatt.writeCharacteristic(sendChar))
	{
	Log.e(TAG, "Failed writing char");
	return false;
	}
	return true;
	}
	else
	{
	Log.e(TAG, "BLE not supported on device.");
	}
	return false;
	}

	public static boolean onSubscribeCharacteristic(int connId, byte[] svcId, byte[] charId)
	{
	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2)
	{
	WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
	BluetoothGatt bluetoothGatt = deviceManager.getBluetoothGatt();
	if (bluetoothGatt == null)
	return false;

	UUID svcUUID = convertBytesToUUID(svcId);
	BluetoothGattService subscribeSvc = bluetoothGatt.getService(svcUUID);
	if (subscribeSvc == null)
	{
	Log.e(TAG, "Bad service");
	return false;
	}

	UUID charUUID = convertBytesToUUID(charId);
	BluetoothGattCharacteristic subscribeChar = subscribeSvc.getCharacteristic(charUUID);
	if (subscribeChar == null)
	{
	Log.e(TAG, "Bad characteristic");
	return false;
	}

	if (!bluetoothGatt.setCharacteristicNotification(subscribeChar, true))
	{
	Log.e(TAG, "Failed to subscribe to characteristic.");
	return false;
	}

	BluetoothGattDescriptor descriptor =
	subscribeChar.getDescriptor(UUID.fromString(CLIENT_CHARACTERISTIC_CONFIG));
	descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
	if (!bluetoothGatt.writeDescriptor(descriptor))
	{
	Log.e(TAG, "writeDescriptor failed");
	return false;
	}
	return true;
	}
	else
	{
	Log.e(TAG, "BLE not supported on device.");
	}
	return false;
	}

	public static boolean onUnsubscribeCharacteristic(int connId, byte[] svcId, byte[] charId)
	{
	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR2)
	{
	WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
	BluetoothGatt bluetoothGatt = deviceManager.getBluetoothGatt();
	if (bluetoothGatt == null)
	return false;

	UUID svcUUID = convertBytesToUUID(svcId);
	BluetoothGattService subscribeSvc = bluetoothGatt.getService(svcUUID);
	if (subscribeSvc == null)
	{
	Log.e(TAG, "Bad service");
	return false;
	}

	UUID charUUID = convertBytesToUUID(charId);
	BluetoothGattCharacteristic subscribeChar = subscribeSvc.getCharacteristic(charUUID);
	if (subscribeChar == null)
	{
	Log.e(TAG, "Bad characteristic");
	return false;
	}

	if (!bluetoothGatt.setCharacteristicNotification(subscribeChar, false))
	{
	Log.e(TAG, "Failed to unsubscribe to characteristic.");
	return false;
	}

	BluetoothGattDescriptor descriptor =
	subscribeChar.getDescriptor(UUID.fromString(CLIENT_CHARACTERISTIC_CONFIG));
	descriptor.setValue(BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
	if (!bluetoothGatt.writeDescriptor(descriptor))
	{
	Log.e(TAG, "writeDescriptor failed");
	return false;
	}
	return true;
	}
	else
	{
	Log.e(TAG, "BLE not supported on device.");
	}
	return false;
	}

	public static boolean onCloseConnection(int connId)
	{
	WeaveDeviceManager deviceManager = WeaveStack.getInstance().getConnection(connId);
	deviceManager.onCloseBleComplete(connId);
	return true;
	}

	// onGetMTU returns the desired MTU for the BLE connection.
	// In most cases, a value of 0 is used to indicate no preference.
	// On some devices, we override to use the minimum MTU to work around device bugs.
	public static int onGetMTU(int connId)
	{
	int mtu = 0;

	Log.d(TAG, "Android Manufacturer: (" + android.os.Build.MANUFACTURER + ")");
	Log.d(TAG, "Android Model: (" + android.os.Build.MODEL + ")");

	if (BleMtuBlacklist.BLE_MTU_BLACKLISTED)
	{
	mtu = BleMtuBlacklist.BLE_MTU_FALLBACK;
	Log.e(TAG, "Detected Android Manufacturer/Model with MTU compatibiility issues. Reporting mtu of " + mtu);
	}
	return mtu;
	}

	// ----- Private Members -----

	static {
	System.loadLibrary("WeaveDeviceManager");
	}

	private native void handleWriteConfirmation(int connId, byte[] svcId, byte[] charId, boolean success);
	private native void handleIndicationReceived(int connId, byte[] svcId, byte[] charId, byte[] data);
	private native void handleSubscribeComplete(int connId, byte[] svcId, byte[] charId, boolean success);
	private native void handleUnsubscribeComplete(int connId, byte[] svcId, byte[] charId, boolean success);
	private native void handleConnectionError(int connId);

	// CLIENT_CHARACTERISTIC_CONFIG is the well-known UUID of the client characteristic descriptor that has the
	// flags for enabling and disabling notifications and indications.
	// c.f. https://www.bluetooth.org/en-us/specification/assigned-numbers/generic-attribute-profile
	private static String CLIENT_CHARACTERISTIC_CONFIG = "00002902-0000-1000-8000-00805f9b34fb";

	private static byte[] convertUUIDToBytes(UUID uuid)
	{
	byte[] idBytes = new byte[16];
	long idBits;
	idBits = uuid.getLeastSignificantBits();
	for (int i = 0; i < 8; i++)
	{
	idBytes[15 - i] = (byte) (idBits & 0xff);
	idBits = idBits >> 8;
	}
	idBits = uuid.getMostSignificantBits();
	for (int i = 0; i < 8; i++)
	{
	idBytes[7 - i] = (byte) (idBits & 0xff);
	idBits = idBits >> 8;
	}
	return idBytes;
	}

	private static UUID convertBytesToUUID(byte[] id)
	{
	long mostSigBits = 0;
	long leastSigBits = 0;

	if (id.length == 16)
	{
	for (int i = 0; i < 8; i++)
	{
	mostSigBits = (mostSigBits << 8) \| (0xff & id[i]);
	}
	for (int i = 0; i < 8; i++)
	{
	leastSigBits = (leastSigBits << 8) \| (0xff & id[i + 8]);
	}
	}
	return new UUID(mostSigBits, leastSigBits);
	}
	}