device/bluetooth/test/android/java/src/org/chromium/device/bluetooth/Fakes.java - chromium/src - Git at Google

 // Copyright 2015 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 package org.chromium.device.bluetooth;

 import android.Manifest;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.le.ScanFilter;
 import android.bluetooth.le.ScanSettings;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.PackageManager;
 import android.os.Handler;
 import android.os.ParcelUuid;
 import android.test.mock.MockContext;
 import android.util.SparseArray;

 import org.jni_zero.CalledByNative;
 import org.jni_zero.JNINamespace;
 import org.jni_zero.NativeMethods;

 import org.chromium.base.Log;
 import org.chromium.components.location.LocationUtils;
 import org.chromium.device.bluetooth.test.TestRSSI;
 import org.chromium.device.bluetooth.test.TestTxPower;

 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;

 /**
  * Fake implementations of android.bluetooth.* classes for testing.
  *
  * Fakes are contained in a single file to simplify code. Only one C++ file may
  * access a Java file via JNI, and all of these classes are accessed by
  * bluetooth_test_android.cc. The alternative would be a C++ .h, .cc file for
  * each of these classes.
  */
 @JNINamespace("device")
 class Fakes {
     private static final String TAG = "Bluetooth";

     // Android uses Integer.MIN_VALUE to signal no Tx Power in advertisement
     // packet.
     // https://developer.android.com/reference/android/bluetooth/le/ScanRecord.html#getTxPowerLevel()
     private static final int NO_TX_POWER = Integer.MIN_VALUE;

     /**
      * Sets the factory for LocationUtils to return an instance whose
      * isSystemLocationSettingEnabled method returns |isEnabled|.
      */
     @CalledByNative
     public static void setLocationServicesState(final boolean isEnabled) {
         LocationUtils.setFactory(new LocationUtils.Factory() {
             @Override
             public LocationUtils create() {
                 return new LocationUtils() {
                     @Override
                     public boolean isSystemLocationSettingEnabled() {
                         return isEnabled;
                     }
                 };
             }
         });
     }

     /**
      * Sets the factory for ThreadUtilsWrapper to always post a task to the UI thread
      * rather than running the task immediately. This simulates events arriving on a separate
      * thread on Android.
      * runOnUiThread uses FakesJni.get().postTaskFromJava. This allows java to post tasks to the
      * message loop that the test is using rather than to the Java message loop which
      * is not running during tests.
      */
     @CalledByNative
     public static void initFakeThreadUtilsWrapper(final long nativeBluetoothTestAndroid) {
         Wrappers.ThreadUtilsWrapper.setFactory(new Wrappers.ThreadUtilsWrapper.Factory() {
             @Override
             public Wrappers.ThreadUtilsWrapper create() {
                 return new Wrappers.ThreadUtilsWrapper() {
                     @Override
                     public void runOnUiThread(Runnable r) {
                         FakesJni.get().postTaskFromJava(nativeBluetoothTestAndroid, r);
                     }
                 };
             }
         });
     }

     @CalledByNative
     public static void runRunnable(Runnable r) {
         r.run();
     }

     /**
      * Fakes android.bluetooth.BluetoothAdapter.
      */
     static class FakeBluetoothAdapter extends Wrappers.BluetoothAdapterWrapper {
         private final FakeContext mFakeContext;
         private final FakeBluetoothLeScanner mFakeScanner;
         private boolean mPowered = true;
         final long mNativeBluetoothTestAndroid;

         /**
          * Creates a FakeBluetoothAdapter.
          */
         @CalledByNative("FakeBluetoothAdapter")
         public static FakeBluetoothAdapter create(long nativeBluetoothTestAndroid) {
             Log.v(TAG, "FakeBluetoothAdapter created.");
             return new FakeBluetoothAdapter(nativeBluetoothTestAndroid);
         }

         private FakeBluetoothAdapter(long nativeBluetoothTestAndroid) {
             super(null, new FakeContext());
             mNativeBluetoothTestAndroid = nativeBluetoothTestAndroid;
             mFakeContext = (FakeContext) mContext;
             mFakeScanner = new FakeBluetoothLeScanner();
         }

         @CalledByNative("FakeBluetoothAdapter")
         public void setFakeContextLocationPermission(boolean enabled) {
             mFakeContext.setLocationPermission(enabled);
         }

         /**
          * Creates and discovers a new device.
          */
         @CalledByNative("FakeBluetoothAdapter")
         public void simulateLowEnergyDevice(int deviceOrdinal) {
             if (mFakeScanner == null) {
                 return;
             }

             switch (deviceOrdinal) {
                 case 1: {
                     ArrayList<ParcelUuid> uuids = new ArrayList<ParcelUuid>(2);
                     uuids.add(ParcelUuid.fromString("00001800-0000-1000-8000-00805f9b34fb"));
                     uuids.add(ParcelUuid.fromString("00001801-0000-1000-8000-00805f9b34fb"));

                     HashMap<ParcelUuid, byte[]> serviceData = new HashMap<>();
                     serviceData.put(ParcelUuid.fromString("0000180d-0000-1000-8000-00805f9b34fb"),
                             new byte[] {1});

                     SparseArray<byte[]> manufacturerData = new SparseArray<>();
                     manufacturerData.put(0x00E0, new byte[] {0x01, 0x02, 0x03, 0x04});

                     mFakeScanner.mScanCallback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
                             new FakeScanResult(new FakeBluetoothDevice(this, "01:00:00:90:1E:BE",
                                                        "FakeBluetoothDevice"),
                                     "FakeBluetoothDevice", TestRSSI.LOWEST, 4, uuids,
                                     TestTxPower.LOWEST, serviceData, manufacturerData));
                     break;
                 }
                 case 2: {
                     ArrayList<ParcelUuid> uuids = new ArrayList<ParcelUuid>(2);
                     uuids.add(ParcelUuid.fromString("00001802-0000-1000-8000-00805f9b34fb"));
                     uuids.add(ParcelUuid.fromString("00001803-0000-1000-8000-00805f9b34fb"));

                     HashMap<ParcelUuid, byte[]> serviceData = new HashMap<>();
                     serviceData.put(ParcelUuid.fromString("0000180d-0000-1000-8000-00805f9b34fb"),
                             new byte[] {});
                     serviceData.put(ParcelUuid.fromString("00001802-0000-1000-8000-00805f9b34fb"),
                             new byte[] {0, 2});

                     SparseArray<byte[]> manufacturerData = new SparseArray<>();
                     manufacturerData.put(0x00E0, new byte[] {});

                     mFakeScanner.mScanCallback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
                             new FakeScanResult(new FakeBluetoothDevice(this, "01:00:00:90:1E:BE",
                                                        "FakeBluetoothDevice"),
                                     "Local Device Name", TestRSSI.LOWER, 5, uuids,
                                     TestTxPower.LOWER, serviceData, manufacturerData));
                     break;
                 }
                 case 3: {
                     ArrayList<ParcelUuid> uuids = null;
                     mFakeScanner.mScanCallback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
                             new FakeScanResult(
                                     new FakeBluetoothDevice(this, "01:00:00:90:1E:BE", ""),
                                     "Local Device Name", TestRSSI.LOW, -1, uuids, NO_TX_POWER, null,
                                     null));

                     break;
                 }
                 case 4: {
                     ArrayList<ParcelUuid> uuids = null;
                     mFakeScanner.mScanCallback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
                             new FakeScanResult(
                                     new FakeBluetoothDevice(this, "02:00:00:8B:74:63", ""),
                                     "Local Device Name", TestRSSI.MEDIUM, -1, uuids, NO_TX_POWER,
                                     null, null));

                     break;
                 }
                 case 5: {
                     ArrayList<ParcelUuid> uuids = null;
                     mFakeScanner.mScanCallback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
                             new FakeScanResult(
                                     new FakeBluetoothDevice(this, "01:00:00:90:1E:BE", null),
                                     "Local Device Name", TestRSSI.HIGH, -1, uuids, NO_TX_POWER,
                                     null, null));
                     break;
                 }
                 case 6: {
                     ArrayList<ParcelUuid> uuids = null;
                     mFakeScanner.mScanCallback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
                             new FakeScanResult(
                                     new FakeBluetoothDevice(this, "02:00:00:8B:74:63", null),
                                     "Local Device Name", TestRSSI.LOWEST, -1, uuids, NO_TX_POWER,
                                     null, null));
                     break;
                 }
                 case 7: {
                     ArrayList<ParcelUuid> uuids = new ArrayList<ParcelUuid>(2);
                     uuids.add(ParcelUuid.fromString("f1d0fff3-deaa-ecee-b42f-c9ba7ed623bb"));

                     HashMap<ParcelUuid, byte[]> serviceData = new HashMap<>();
                     serviceData.put(ParcelUuid.fromString("f1d0fff3-deaa-ecee-b42f-c9ba7ed623bb"),
                             new byte[] {0, 20});

                     mFakeScanner.mScanCallback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
                             new FakeScanResult(new FakeBluetoothDevice(
                                                        this, "01:00:00:90:1E:BE", "U2F FakeDevice"),
                                     "Local Device Name", TestRSSI.LOWEST, -1, uuids, NO_TX_POWER,
                                     serviceData, null));
                     break;
                 }
             }
         }

         @CalledByNative("FakeBluetoothAdapter")
         public void forceIllegalStateException() {
             if (mFakeScanner != null) {
                 mFakeScanner.forceIllegalStateException();
             }
         }

         // -----------------------------------------------------------------------------------------
         // BluetoothAdapterWrapper overrides:

         @Override
         public boolean disable() {
             // android.bluetooth.BluetoothAdapter::disable() is an async call, so we simulate this
             // by posting a task to the UI thread.
             FakesJni.get().postTaskFromJava(mNativeBluetoothTestAndroid, new Runnable() {
                 @Override
                 public void run() {
                     mPowered = false;
                     FakesJni.get().onFakeAdapterStateChanged(mNativeBluetoothTestAndroid, false);
                 }
             });
             return true;
         }

         @Override
         public boolean enable() {
             // android.bluetooth.BluetoothAdapter::enable() is an async call, so we simulate this by
             // posting a task to the UI thread.
             FakesJni.get().postTaskFromJava(mNativeBluetoothTestAndroid, new Runnable() {
                 @Override
                 public void run() {
                     mPowered = true;
                     FakesJni.get().onFakeAdapterStateChanged(mNativeBluetoothTestAndroid, true);
                 }
             });
             return true;
         }

         @Override
         public String getAddress() {
             return "A1:B2:C3:D4:E5:F6";
         }

         @Override
         public Wrappers.BluetoothLeScannerWrapper getBluetoothLeScanner() {
             if (isEnabled()) {
                 return mFakeScanner;
             }
             return null;
         }

         @Override
         public String getName() {
             return "FakeBluetoothAdapter";
         }

         @Override
         public int getScanMode() {
             return android.bluetooth.BluetoothAdapter.SCAN_MODE_NONE;
         }

         @Override
         public boolean isEnabled() {
             return mPowered;
         }

         @Override
         public boolean isDiscovering() {
             return false;
         }
     }

     /**
      * Fakes android.content.Context by extending MockContext.
      */
     static class FakeContext extends MockContext {
         private boolean mLocationPermission;

         public FakeContext() {
             super();
             mLocationPermission = true;
         }

         public void setLocationPermission(boolean enabled) {
             mLocationPermission = enabled;
         }

         @Override
         public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter,
                 String permission, Handler scheduler) {
             return null;
         }

         @Override
         public Intent registerReceiver(BroadcastReceiver receiver, IntentFilter filter,
                 String permission, Handler scheduler, int flags) {
             return null;
         }

         @Override
         public void unregisterReceiver(BroadcastReceiver receiver) {}

         @Override
         public int checkCallingOrSelfPermission(String permission) {
             if (permission.equals(Manifest.permission.ACCESS_FINE_LOCATION)
                     || permission.equals(Manifest.permission.ACCESS_COARSE_LOCATION)) {
                 return mLocationPermission ? PackageManager.PERMISSION_GRANTED
                                            : PackageManager.PERMISSION_DENIED;
             }
             return PackageManager.PERMISSION_DENIED;
         }
     }

     /**
      * Fakes android.bluetooth.le.BluetoothLeScanner.
      */
     static class FakeBluetoothLeScanner extends Wrappers.BluetoothLeScannerWrapper {
         public Wrappers.ScanCallbackWrapper mScanCallback;
         private boolean mThrowException;

         private FakeBluetoothLeScanner() {
             super(null);
         }

         @Override
         public void startScan(List<ScanFilter> filters, int scanSettingsScanMode,
                 Wrappers.ScanCallbackWrapper callback) {
             if (mScanCallback != null) {
                 throw new IllegalArgumentException(
                         "FakeBluetoothLeScanner does not support multiple scans.");
             }
             if (mThrowException) {
                 throw new IllegalStateException("Adapter is off.");
             }
             mScanCallback = callback;
         }

         @Override
         public void stopScan(Wrappers.ScanCallbackWrapper callback) {
             if (mScanCallback != callback) {
                 throw new IllegalArgumentException("No scan in progress.");
             }
             if (mThrowException) {
                 throw new IllegalStateException("Adapter is off.");
             }
             mScanCallback = null;
         }

         void forceIllegalStateException() {
             mThrowException = true;
         }
     }

     /**
      * Fakes android.bluetooth.le.ScanResult
      */
     static class FakeScanResult extends Wrappers.ScanResultWrapper {
         private final FakeBluetoothDevice mDevice;
         private final String mLocalName;
         private final int mRssi;
         private final int mTxPower;
         private final int mAdvertisementFlags;
         private final ArrayList<ParcelUuid> mUuids;
         private final Map<ParcelUuid, byte[]> mServiceData;
         private final SparseArray<byte[]> mManufacturerData;

         FakeScanResult(FakeBluetoothDevice device, String localName, int rssi,
                 int advertisementFlags, ArrayList<ParcelUuid> uuids, int txPower,
                 Map<ParcelUuid, byte[]> serviceData, SparseArray<byte[]> manufacturerData) {
             super(null);
             mDevice = device;
             mLocalName = localName;
             mRssi = rssi;
             mAdvertisementFlags = advertisementFlags;
             mUuids = uuids;
             mTxPower = txPower;
             mServiceData = serviceData;
             mManufacturerData = manufacturerData;
         }

         @Override
         public Wrappers.BluetoothDeviceWrapper getDevice() {
             return mDevice;
         }

         @Override
         public int getRssi() {
             return mRssi;
         }

         @Override
         public List<ParcelUuid> getScanRecord_getServiceUuids() {
             return mUuids;
         }

         @Override
         public int getScanRecord_getTxPowerLevel() {
             return mTxPower;
         }

         @Override
         public Map<ParcelUuid, byte[]> getScanRecord_getServiceData() {
             return mServiceData;
         }

         @Override
         public SparseArray<byte[]> getScanRecord_getManufacturerSpecificData() {
             return mManufacturerData;
         }

         @Override
         public String getScanRecord_getDeviceName() {
             return mLocalName;
         }

         @Override
         public int getScanRecord_getAdvertiseFlags() {
             return mAdvertisementFlags;
         }
     }

     /**
      * Fakes android.bluetooth.BluetoothDevice.
      */
     static class FakeBluetoothDevice extends Wrappers.BluetoothDeviceWrapper {
         final FakeBluetoothAdapter mAdapter;
         private String mAddress;
         private String mName;
         final FakeBluetoothGatt mGatt;
         private Wrappers.BluetoothGattCallbackWrapper mGattCallback;

         static FakeBluetoothDevice sRememberedDevice;

         public FakeBluetoothDevice(FakeBluetoothAdapter adapter, String address, String name) {
             super(null);
             mAdapter = adapter;
             mAddress = address;
             mName = name;
             mGatt = new FakeBluetoothGatt(this);
         }

         // Implements BluetoothTestAndroid::RememberDeviceForSubsequentAction.
         @CalledByNative("FakeBluetoothDevice")
         private static void rememberDeviceForSubsequentAction(ChromeBluetoothDevice chromeDevice) {
             sRememberedDevice = (FakeBluetoothDevice) chromeDevice.mDevice;
         }

         // Create a call to onConnectionStateChange on the |chrome_device| using parameters
         // |status| & |connected|.
         @CalledByNative("FakeBluetoothDevice")
         private static void connectionStateChange(
                 ChromeBluetoothDevice chromeDevice, int status, boolean connected) {
             FakeBluetoothDevice fakeDevice = (FakeBluetoothDevice) chromeDevice.mDevice;
             fakeDevice.mGattCallback.onConnectionStateChange(status, connected
                             ? android.bluetooth.BluetoothProfile.STATE_CONNECTED
                             : android.bluetooth.BluetoothProfile.STATE_DISCONNECTED);
         }

         // Create a call to onServicesDiscovered on the |chrome_device| using parameter
         // |status|.
         @CalledByNative("FakeBluetoothDevice")
         private static void servicesDiscovered(
                 ChromeBluetoothDevice chromeDevice, int status, String uuidsSpaceDelimited) {
             if (chromeDevice == null && sRememberedDevice == null) {
                 throw new IllegalArgumentException("rememberDevice wasn't called previously.");
             }

             FakeBluetoothDevice fakeDevice = (chromeDevice == null)
                     ? sRememberedDevice
                     : (FakeBluetoothDevice) chromeDevice.mDevice;

             if (status == android.bluetooth.BluetoothGatt.GATT_SUCCESS) {
                 fakeDevice.mGatt.mServices.clear();
                 HashMap<String, Integer> uuidsToInstanceIdMap = new HashMap<String, Integer>();
                 for (String uuid : uuidsSpaceDelimited.split(" ")) {
                     // String.split() can return empty strings. Ignore them.
                     if (uuid.isEmpty()) continue;
                     Integer previousId = uuidsToInstanceIdMap.get(uuid);
                     int instanceId = (previousId == null) ? 0 : previousId + 1;
                     uuidsToInstanceIdMap.put(uuid, instanceId);
                     fakeDevice.mGatt.mServices.add(new FakeBluetoothGattService(
                             fakeDevice, UUID.fromString(uuid), instanceId));
                 }
             }

             fakeDevice.mGattCallback.onServicesDiscovered(status);
         }

         // -----------------------------------------------------------------------------------------
         // Wrappers.BluetoothDeviceWrapper overrides:

         @Override
         public Wrappers.BluetoothGattWrapper connectGatt(Context context, boolean autoConnect,
                 Wrappers.BluetoothGattCallbackWrapper callback, int transport) {
             if (mGattCallback != null && mGattCallback != callback) {
                 throw new IllegalArgumentException(
                         "BluetoothGattWrapper doesn't support calls to connectGatt() with "
                         + "multiple distinct callbacks.");
             }
             FakesJni.get().onFakeBluetoothDeviceConnectGattCalled(
                     mAdapter.mNativeBluetoothTestAndroid);
             mGattCallback = callback;
             return mGatt;
         }

         @Override
         public String getAddress() {
             return mAddress;
         }

         @Override
         public int getBluetoothClass_getDeviceClass() {
             return Wrappers.DEVICE_CLASS_UNSPECIFIED;
         }

         @Override
         public int getBondState() {
             return BluetoothDevice.BOND_NONE;
         }

         @Override
         public String getName() {
             return mName;
         }
     }

     /**
      * Fakes android.bluetooth.BluetoothGatt.
      */
     static class FakeBluetoothGatt extends Wrappers.BluetoothGattWrapper {
         final FakeBluetoothDevice mDevice;
         final ArrayList<Wrappers.BluetoothGattServiceWrapper> mServices;
         boolean mReadCharacteristicWillFailSynchronouslyOnce;
         boolean mSetCharacteristicNotificationWillFailSynchronouslyOnce;
         boolean mWriteCharacteristicWillFailSynchronouslyOnce;
         boolean mReadDescriptorWillFailSynchronouslyOnce;
         boolean mWriteDescriptorWillFailSynchronouslyOnce;

         public FakeBluetoothGatt(FakeBluetoothDevice device) {
             super(null, null);
             mDevice = device;
             mServices = new ArrayList<Wrappers.BluetoothGattServiceWrapper>();
         }

         @Override
         public void disconnect() {
             FakesJni.get().onFakeBluetoothGattDisconnect(
                     mDevice.mAdapter.mNativeBluetoothTestAndroid);
         }

         @Override
         public void close() {
             FakesJni.get().onFakeBluetoothGattClose(mDevice.mAdapter.mNativeBluetoothTestAndroid);
         }

         @Override
         public boolean requestMtu(int mtu) {
             return false;
         }

         @Override
         public void discoverServices() {
             FakesJni.get().onFakeBluetoothGattDiscoverServices(
                     mDevice.mAdapter.mNativeBluetoothTestAndroid);
         }

         @Override
         public List<Wrappers.BluetoothGattServiceWrapper> getServices() {
             return mServices;
         }

         @Override
         boolean readCharacteristic(Wrappers.BluetoothGattCharacteristicWrapper characteristic) {
             if (mReadCharacteristicWillFailSynchronouslyOnce) {
                 mReadCharacteristicWillFailSynchronouslyOnce = false;
                 return false;
             }
             FakesJni.get().onFakeBluetoothGattReadCharacteristic(
                     mDevice.mAdapter.mNativeBluetoothTestAndroid);
             return true;
         }

         @Override
         boolean setCharacteristicNotification(
                 Wrappers.BluetoothGattCharacteristicWrapper characteristic, boolean enable) {
             if (mSetCharacteristicNotificationWillFailSynchronouslyOnce) {
                 mSetCharacteristicNotificationWillFailSynchronouslyOnce = false;
                 return false;
             }
             FakesJni.get().onFakeBluetoothGattSetCharacteristicNotification(
                     mDevice.mAdapter.mNativeBluetoothTestAndroid);
             return true;
         }

         @Override
         boolean writeCharacteristic(Wrappers.BluetoothGattCharacteristicWrapper characteristic) {
             if (mWriteCharacteristicWillFailSynchronouslyOnce) {
                 mWriteCharacteristicWillFailSynchronouslyOnce = false;
                 return false;
             }
             FakesJni.get().onFakeBluetoothGattWriteCharacteristic(
                     mDevice.mAdapter.mNativeBluetoothTestAndroid, characteristic.getValue());
             return true;
         }

         @Override
         boolean readDescriptor(Wrappers.BluetoothGattDescriptorWrapper descriptor) {
             if (mReadDescriptorWillFailSynchronouslyOnce) {
                 mReadDescriptorWillFailSynchronouslyOnce = false;
                 return false;
             }
             FakesJni.get().onFakeBluetoothGattReadDescriptor(
                     mDevice.mAdapter.mNativeBluetoothTestAndroid);
             return true;
         }

         @Override
         boolean writeDescriptor(Wrappers.BluetoothGattDescriptorWrapper descriptor) {
             if (mWriteDescriptorWillFailSynchronouslyOnce) {
                 mWriteDescriptorWillFailSynchronouslyOnce = false;
                 return false;
             }
             FakesJni.get().onFakeBluetoothGattWriteDescriptor(
                     mDevice.mAdapter.mNativeBluetoothTestAndroid, descriptor.getValue());
             return true;
         }
     }

     /**
      * Fakes android.bluetooth.BluetoothGattService.
      */
     static class FakeBluetoothGattService extends Wrappers.BluetoothGattServiceWrapper {
         final FakeBluetoothDevice mDevice;
         final int mInstanceId;
         final UUID mUuid;
         final ArrayList<Wrappers.BluetoothGattCharacteristicWrapper> mCharacteristics;

         public FakeBluetoothGattService(FakeBluetoothDevice device, UUID uuid, int instanceId) {
             super(null, null);
             mDevice = device;
             mUuid = uuid;
             mInstanceId = instanceId;
             mCharacteristics = new ArrayList<Wrappers.BluetoothGattCharacteristicWrapper>();
         }

         // Create a characteristic and add it to this service.
         @CalledByNative("FakeBluetoothGattService")
         private static void addCharacteristic(
                 ChromeBluetoothRemoteGattService chromeService, String uuidString, int properties) {
             FakeBluetoothGattService fakeService =
                     (FakeBluetoothGattService) chromeService.mService;
             UUID uuid = UUID.fromString(uuidString);

             int countOfDuplicateUUID = 0;
             for (Wrappers.BluetoothGattCharacteristicWrapper characteristic :
                     fakeService.mCharacteristics) {
                 if (characteristic.getUuid().equals(uuid)) {
                     countOfDuplicateUUID++;
                 }
             }
             fakeService.mCharacteristics.add(new FakeBluetoothGattCharacteristic(fakeService,
                     /* instanceId */ countOfDuplicateUUID, properties, uuid));
         }

         // -----------------------------------------------------------------------------------------
         // Wrappers.BluetoothGattServiceWrapper overrides:

         @Override
         public List<Wrappers.BluetoothGattCharacteristicWrapper> getCharacteristics() {
             return mCharacteristics;
         }

         @Override
         public int getInstanceId() {
             return mInstanceId;
         }

         @Override
         public UUID getUuid() {
             return mUuid;
         }
     }

     /**
      * Fakes android.bluetooth.BluetoothGattCharacteristic.
      */
     static class FakeBluetoothGattCharacteristic
             extends Wrappers.BluetoothGattCharacteristicWrapper {
         final FakeBluetoothGattService mService;
         final int mInstanceId;
         final int mProperties;
         final UUID mUuid;
         byte[] mValue;
         int mWriteType;
         static FakeBluetoothGattCharacteristic sRememberedCharacteristic;
         final ArrayList<Wrappers.BluetoothGattDescriptorWrapper> mDescriptors;

         public FakeBluetoothGattCharacteristic(
                 FakeBluetoothGattService service, int instanceId, int properties, UUID uuid) {
             super(null, null);
             mService = service;
             mInstanceId = instanceId;
             mProperties = properties;
             mUuid = uuid;
             mValue = new byte[0];
             mDescriptors = new ArrayList<Wrappers.BluetoothGattDescriptorWrapper>();
         }

         // Simulate a characteristic value notified as changed.
         @CalledByNative("FakeBluetoothGattCharacteristic")
         private static void valueChanged(
                 ChromeBluetoothRemoteGattCharacteristic chromeCharacteristic, byte[] value) {
             if (chromeCharacteristic == null && sRememberedCharacteristic == null) {
                 throw new IllegalArgumentException(
                         "rememberCharacteristic wasn't called previously.");
             }

             FakeBluetoothGattCharacteristic fakeCharacteristic = (chromeCharacteristic == null)
                     ? sRememberedCharacteristic
                     : (FakeBluetoothGattCharacteristic) chromeCharacteristic.mCharacteristic;

             fakeCharacteristic.mValue = value;
             fakeCharacteristic.mService.mDevice.mGattCallback.onCharacteristicChanged(
                     fakeCharacteristic);
         }

         // Implements BluetoothTestAndroid::RememberCharacteristicForSubsequentAction.
         @CalledByNative("FakeBluetoothGattCharacteristic")
         private static void rememberCharacteristicForSubsequentAction(
                 ChromeBluetoothRemoteGattCharacteristic chromeCharacteristic) {
             sRememberedCharacteristic =
                     (FakeBluetoothGattCharacteristic) chromeCharacteristic.mCharacteristic;
         }

         // Simulate a value being read from a characteristic.
         @CalledByNative("FakeBluetoothGattCharacteristic")
         private static void valueRead(ChromeBluetoothRemoteGattCharacteristic chromeCharacteristic,
                 int status, byte[] value) {
             if (chromeCharacteristic == null && sRememberedCharacteristic == null) {
                 throw new IllegalArgumentException(
                         "rememberCharacteristic wasn't called previously.");
             }

             FakeBluetoothGattCharacteristic fakeCharacteristic = (chromeCharacteristic == null)
                     ? sRememberedCharacteristic
                     : (FakeBluetoothGattCharacteristic) chromeCharacteristic.mCharacteristic;

             fakeCharacteristic.mValue = value;
             fakeCharacteristic.mService.mDevice.mGattCallback.onCharacteristicRead(
                     fakeCharacteristic, status);
         }

         // Simulate a value being written to a characteristic.
         @CalledByNative("FakeBluetoothGattCharacteristic")
         private static void valueWrite(
                 ChromeBluetoothRemoteGattCharacteristic chromeCharacteristic, int status) {
             if (chromeCharacteristic == null && sRememberedCharacteristic == null) {
                 throw new IllegalArgumentException(
                         "rememberCharacteristic wasn't called previously.");
             }

             FakeBluetoothGattCharacteristic fakeCharacteristic = (chromeCharacteristic == null)
                     ? sRememberedCharacteristic
                     : (FakeBluetoothGattCharacteristic) chromeCharacteristic.mCharacteristic;

             fakeCharacteristic.mService.mDevice.mGattCallback.onCharacteristicWrite(
                     fakeCharacteristic, status);
         }

         // Cause subsequent notification of a characteristic to fail synchronously.
         @CalledByNative("FakeBluetoothGattCharacteristic")
         private static void setCharacteristicNotificationWillFailSynchronouslyOnce(
                 ChromeBluetoothRemoteGattCharacteristic chromeCharacteristic) {
             FakeBluetoothGattCharacteristic fakeCharacteristic =
                     (FakeBluetoothGattCharacteristic) chromeCharacteristic.mCharacteristic;

             fakeCharacteristic.mService.mDevice.mGatt
                     .mSetCharacteristicNotificationWillFailSynchronouslyOnce = true;
         }

         // Cause subsequent value read of a characteristic to fail synchronously.
         @CalledByNative("FakeBluetoothGattCharacteristic")
         private static void setReadCharacteristicWillFailSynchronouslyOnce(
                 ChromeBluetoothRemoteGattCharacteristic chromeCharacteristic) {
             FakeBluetoothGattCharacteristic fakeCharacteristic =
                     (FakeBluetoothGattCharacteristic) chromeCharacteristic.mCharacteristic;

             fakeCharacteristic.mService.mDevice.mGatt.mReadCharacteristicWillFailSynchronouslyOnce =
                     true;
         }

         // Cause subsequent value write of a characteristic to fail synchronously.
         @CalledByNative("FakeBluetoothGattCharacteristic")
         private static void setWriteCharacteristicWillFailSynchronouslyOnce(
                 ChromeBluetoothRemoteGattCharacteristic chromeCharacteristic) {
             FakeBluetoothGattCharacteristic fakeCharacteristic =
                     (FakeBluetoothGattCharacteristic) chromeCharacteristic.mCharacteristic;

             fakeCharacteristic.mService.mDevice.mGatt
                     .mWriteCharacteristicWillFailSynchronouslyOnce = true;
         }

         // Create a descriptor and add it to this characteristic.
         @CalledByNative("FakeBluetoothGattCharacteristic")
         private static void addDescriptor(
                 ChromeBluetoothRemoteGattCharacteristic chromeCharacteristic, String uuidString) {
             FakeBluetoothGattCharacteristic fakeCharacteristic =
                     (FakeBluetoothGattCharacteristic) chromeCharacteristic.mCharacteristic;
             UUID uuid = UUID.fromString(uuidString);

             fakeCharacteristic.mDescriptors.add(
                     new FakeBluetoothGattDescriptor(fakeCharacteristic, uuid));
         }

         // -----------------------------------------------------------------------------------------
         // Wrappers.BluetoothGattCharacteristicWrapper overrides:

         @Override
         public List<Wrappers.BluetoothGattDescriptorWrapper> getDescriptors() {
             return mDescriptors;
         }

         @Override
         public int getInstanceId() {
             return mInstanceId;
         }

         @Override
         public int getProperties() {
             return mProperties;
         }

         @Override
         public UUID getUuid() {
             return mUuid;
         }

         @Override
         public byte[] getValue() {
             return mValue;
         }

         @Override
         public boolean setValue(byte[] value) {
             mValue = value;
             return true;
         }

         @Override
         public void setWriteType(int writeType) {
             mWriteType = writeType;
         }
     }

     /**
      * Fakes android.bluetooth.BluetoothGattDescriptor.
      */
     static class FakeBluetoothGattDescriptor extends Wrappers.BluetoothGattDescriptorWrapper {
         final FakeBluetoothGattCharacteristic mCharacteristic;
         final UUID mUuid;
         byte[] mValue;
         static FakeBluetoothGattDescriptor sRememberedDescriptor;

         public FakeBluetoothGattDescriptor(
                 FakeBluetoothGattCharacteristic characteristic, UUID uuid) {
             super(null, null);
             mCharacteristic = characteristic;
             mUuid = uuid;
             mValue = new byte[0];
         }

         // Implements BluetoothTestAndroid::RememberDescriptorForSubsequentAction.
         @CalledByNative("FakeBluetoothGattDescriptor")
         private static void rememberDescriptorForSubsequentAction(
                 ChromeBluetoothRemoteGattDescriptor chromeDescriptor) {
             sRememberedDescriptor = (FakeBluetoothGattDescriptor) chromeDescriptor.mDescriptor;
         }

         // Simulate a value being read from a descriptor.
         @CalledByNative("FakeBluetoothGattDescriptor")
         private static void valueRead(
                 ChromeBluetoothRemoteGattDescriptor chromeDescriptor, int status, byte[] value) {
             if (chromeDescriptor == null && sRememberedDescriptor == null) {
                 throw new IllegalArgumentException("rememberDescriptor wasn't called previously.");
             }

             FakeBluetoothGattDescriptor fakeDescriptor = (chromeDescriptor == null)
                     ? sRememberedDescriptor
                     : (FakeBluetoothGattDescriptor) chromeDescriptor.mDescriptor;

             fakeDescriptor.mValue = value;
             fakeDescriptor.mCharacteristic.mService.mDevice.mGattCallback.onDescriptorRead(
                     fakeDescriptor, status);
         }

         // Simulate a value being written to a descriptor.
         @CalledByNative("FakeBluetoothGattDescriptor")
         private static void valueWrite(
                 ChromeBluetoothRemoteGattDescriptor chromeDescriptor, int status) {
             if (chromeDescriptor == null && sRememberedDescriptor == null) {
                 throw new IllegalArgumentException("rememberDescriptor wasn't called previously.");
             }

             FakeBluetoothGattDescriptor fakeDescriptor = (chromeDescriptor == null)
                     ? sRememberedDescriptor
                     : (FakeBluetoothGattDescriptor) chromeDescriptor.mDescriptor;

             fakeDescriptor.mCharacteristic.mService.mDevice.mGattCallback.onDescriptorWrite(
                     fakeDescriptor, status);
         }

         // Cause subsequent value read of a descriptor to fail synchronously.
         @CalledByNative("FakeBluetoothGattDescriptor")
         private static void setReadDescriptorWillFailSynchronouslyOnce(
                 ChromeBluetoothRemoteGattDescriptor chromeDescriptor) {
             FakeBluetoothGattDescriptor fakeDescriptor =
                     (FakeBluetoothGattDescriptor) chromeDescriptor.mDescriptor;

             fakeDescriptor.mCharacteristic.mService.mDevice.mGatt
                     .mReadDescriptorWillFailSynchronouslyOnce = true;
         }

         // Cause subsequent value write of a descriptor to fail synchronously.
         @CalledByNative("FakeBluetoothGattDescriptor")
         private static void setWriteDescriptorWillFailSynchronouslyOnce(
                 ChromeBluetoothRemoteGattDescriptor chromeDescriptor) {
             FakeBluetoothGattDescriptor fakeDescriptor =
                     (FakeBluetoothGattDescriptor) chromeDescriptor.mDescriptor;

             fakeDescriptor.mCharacteristic.mService.mDevice.mGatt
                     .mWriteDescriptorWillFailSynchronouslyOnce = true;
         }

         // -----------------------------------------------------------------------------------------
         // Wrappers.BluetoothGattDescriptorWrapper overrides:

         @Override
         public Wrappers.BluetoothGattCharacteristicWrapper getCharacteristic() {
             return mCharacteristic;
         }

         @Override
         public UUID getUuid() {
             return mUuid;
         }

         @Override
         public byte[] getValue() {
             return mValue;
         }

         @Override
         public boolean setValue(byte[] value) {
             mValue = value;
             return true;
         }
     }

     // ---------------------------------------------------------------------------------------------
     // BluetoothTestAndroid C++ methods declared for access from java:
     @NativeMethods
     interface Natives {

         // Bind to BluetoothTestAndroid::PostTaskFromJava.
         void postTaskFromJava(long nativeBluetoothTestAndroid, Runnable r);

         // Binds to BluetoothTestAndroid::OnFakeAdapterStateChanged.
         void onFakeAdapterStateChanged(long nativeBluetoothTestAndroid, boolean powered);

         // Binds to BluetoothTestAndroid::OnFakeBluetoothDeviceConnectGattCalled.
         void onFakeBluetoothDeviceConnectGattCalled(long nativeBluetoothTestAndroid);

         // Binds to BluetoothTestAndroid::OnFakeBluetoothGattDisconnect.
         void onFakeBluetoothGattDisconnect(long nativeBluetoothTestAndroid);

         // Binds to BluetoothTestAndroid::OnFakeBluetoothGattClose.
         void onFakeBluetoothGattClose(long nativeBluetoothTestAndroid);

         // Binds to BluetoothTestAndroid::OnFakeBluetoothGattDiscoverServices.
         void onFakeBluetoothGattDiscoverServices(long nativeBluetoothTestAndroid);

         // Binds to BluetoothTestAndroid::OnFakeBluetoothGattSetCharacteristicNotification.
         void onFakeBluetoothGattSetCharacteristicNotification(long nativeBluetoothTestAndroid);

         // Binds to BluetoothTestAndroid::OnFakeBluetoothGattReadCharacteristic.
         void onFakeBluetoothGattReadCharacteristic(long nativeBluetoothTestAndroid);

         // Binds to BluetoothTestAndroid::OnFakeBluetoothGattWriteCharacteristic.
         void onFakeBluetoothGattWriteCharacteristic(long nativeBluetoothTestAndroid, byte[] value);

         // Binds to BluetoothTestAndroid::OnFakeBluetoothGattReadDescriptor.
         void onFakeBluetoothGattReadDescriptor(long nativeBluetoothTestAndroid);

         // Binds to BluetoothTestAndroid::OnFakeBluetoothGattWriteDescriptor.
         void onFakeBluetoothGattWriteDescriptor(long nativeBluetoothTestAndroid, byte[] value);
     }
 }