bluetooth: android: Fix a couple of crashes when adapter is turned on/off.

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 25 matching lines @@
 @TargetApi(Build.VERSION_CODES.LOLLIPOP)
 class Fakes {
     private static final String TAG = "cr.Bluetooth";
 
     /**
      * 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(), new FakeBluetoothLeScanner());
+            super(null, new FakeContext());
             mNativeBluetoothTestAndroid = nativeBluetoothTestAndroid;
             mFakeContext = (FakeContext) mContext;
-            mFakeScanner = (FakeBluetoothLeScanner) mScanner;
+            mFakeScanner = new FakeBluetoothLeScanner();
         }
 
         @CalledByNative("FakeBluetoothAdapter")
         public void denyPermission() {
             mFakeContext.mPermissions.clear();
         }
 
         /**
          * Creates and discovers a new device.
          */
         @CalledByNative("FakeBluetoothAdapter")
         public void discoverLowEnergyDevice(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"));
 
                     mFakeScanner.mScanCallback.onScanResult(ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
                             new FakeScanResult(new FakeBluetoothDevice(this, "01:00:00:90:1E:BE",
                                                        "FakeBluetoothDevice"),
                                                                     uuids));
@@ skipping 24 matching lines @@
                     mFakeScanner.mScanCallback.onScanResult(
                             ScanSettings.CALLBACK_TYPE_ALL_MATCHES,
                             new FakeScanResult(
                                     new FakeBluetoothDevice(this, "02:00:00:8B:74:63", ""), uuids));
 
                     break;
                 }
             }
         }
 
+        @CalledByNative("FakeBluetoothAdapter")
+        public void forceIllegalStateException() {
+            if (mFakeScanner != null) {
+                mFakeScanner.forceIllegalStateException();
+            }
+        }
+
         // -----------------------------------------------------------------------------------------
         // BluetoothAdapterWrapper overrides:
 
         @Override
-        public boolean isEnabled() {
+        public boolean disable() {
+            mPowered = false;
             return true;
         }
 
+        @Override
+        public boolean enable() {
+            mPowered = 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.
      */
     static class FakeContext extends Wrappers.ContextWrapper {
         public final Set<String> mPermissions = new HashSet<String>();
 
         public FakeContext() {
             super(null);
             mPermissions.add(Manifest.permission.ACCESS_COARSE_LOCATION);
         }
 
         @Override
         public boolean checkPermission(String permission) {
             return mPermissions.contains(permission);
         }
     }
 
     /**
      * 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 ArrayList<ParcelUuid> mUuids;
 
         FakeScanResult(FakeBluetoothDevice device, ArrayList<ParcelUuid> uuids) {
@@ skipping 80 matching lines @@
             return mGatt;
         }
 
         @Override
         public String getAddress() {
             return mAddress;
         }
 
         @Override
         public int getBluetoothClass_getDeviceClass() {
-            return 0x1F00; // Unspecified Device Class
+            return Wrappers.DEVICE_CLASS_UNSPECIFIED;
         }
 
         @Override
         public int getBondState() {
             return BluetoothDevice.BOND_NONE;
         }
 
         @Override
         public String getName() {
             return mName;
@@ skipping 393 matching lines @@
             long nativeBluetoothTestAndroid);
 
     // Binds to BluetoothTestAndroid::OnFakeBluetoothGattWriteCharacteristic.
     private static native void nativeOnFakeBluetoothGattWriteCharacteristic(
             long nativeBluetoothTestAndroid, byte[] value);
 
     // Binds to BluetoothTestAndroid::OnFakeBluetoothGattWriteDescriptor.
     private static native void nativeOnFakeBluetoothGattWriteDescriptor(
             long nativeBluetoothTestAndroid, byte[] value);
 }