bluetooth: android: Confirm the notify session after the descriptor has been written.

device/bluetooth/test/android/java/src/org/chromium/device/bluetooth/Fakes.java

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // 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.annotation.TargetApi;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.le.ScanFilter;
@@ skipping 336 matching lines @@
 
     /**
      * Fakes android.bluetooth.BluetoothGatt.
      */
     static class FakeBluetoothGatt extends Wrappers.BluetoothGattWrapper {
         final FakeBluetoothDevice mDevice;
         final ArrayList<Wrappers.BluetoothGattServiceWrapper> mServices;
         boolean mReadCharacteristicWillFailSynchronouslyOnce = false;
         boolean mSetCharacteristicNotificationWillFailSynchronouslyOnce = false;
         boolean mWriteCharacteristicWillFailSynchronouslyOnce = false;
+        boolean mReadDescriptorWillFailSynchronouslyOnce = false;
         boolean mWriteDescriptorWillFailSynchronouslyOnce = false;
 
         public FakeBluetoothGatt(FakeBluetoothDevice device) {
             super(null, null);
             mDevice = device;
             mServices = new ArrayList<Wrappers.BluetoothGattServiceWrapper>();
         }
 
         @Override
         public void disconnect() {
@@ skipping 43 matching lines @@
             if (mWriteCharacteristicWillFailSynchronouslyOnce) {
                 mWriteCharacteristicWillFailSynchronouslyOnce = false;
                 return false;
             }
             nativeOnFakeBluetoothGattWriteCharacteristic(
                     mDevice.mAdapter.mNativeBluetoothTestAndroid, characteristic.getValue());
             return true;
         }
 
         @Override
+        boolean readDescriptor(Wrappers.BluetoothGattDescriptorWrapper descriptor) {
+            if (mReadDescriptorWillFailSynchronouslyOnce) {
+                mReadDescriptorWillFailSynchronouslyOnce = false;
+                return false;
+            }
+            nativeOnFakeBluetoothGattReadDescriptor(mDevice.mAdapter.mNativeBluetoothTestAndroid);
+            return true;
+        }
+
+        @Override
         boolean writeDescriptor(Wrappers.BluetoothGattDescriptorWrapper descriptor) {
             if (mWriteDescriptorWillFailSynchronouslyOnce) {
                 mWriteDescriptorWillFailSynchronouslyOnce = false;
                 return false;
             }
             nativeOnFakeBluetoothGattWriteDescriptor(
                     mDevice.mAdapter.mNativeBluetoothTestAndroid, descriptor.getValue());
             return true;
         }
     }
@@ skipping 235 matching lines @@
         }
     }
 
     /**
      * 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);
+            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
@@ skipping 25 matching lines @@
             long nativeBluetoothTestAndroid);
 
     // Binds to BluetoothTestAndroid::OnFakeBluetoothGattReadCharacteristic.
     private static native void nativeOnFakeBluetoothGattReadCharacteristic(
             long nativeBluetoothTestAndroid);
 
     // Binds to BluetoothTestAndroid::OnFakeBluetoothGattWriteCharacteristic.
     private static native void nativeOnFakeBluetoothGattWriteCharacteristic(
             long nativeBluetoothTestAndroid, byte[] value);
 
+    // Binds to BluetoothTestAndroid::OnFakeBluetoothGattReadDescriptor.
+    private static native void nativeOnFakeBluetoothGattReadDescriptor(
+            long nativeBluetoothTestAndroid);
+
     // Binds to BluetoothTestAndroid::OnFakeBluetoothGattWriteDescriptor.
     private static native void nativeOnFakeBluetoothGattWriteDescriptor(
             long nativeBluetoothTestAndroid, byte[] value);
 }