| /* | |
| * Copyright (C) 2016 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.android.cts.verifier.bluetooth; | |
| import android.app.Service; | |
| import android.bluetooth.BluetoothAdapter; | |
| import android.bluetooth.BluetoothDevice; | |
| import android.bluetooth.BluetoothGatt; | |
| 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.bluetooth.le.BluetoothLeScanner; | |
| import android.bluetooth.le.ScanCallback; | |
| import android.bluetooth.le.ScanFilter; | |
| import android.bluetooth.le.ScanResult; | |
| import android.bluetooth.le.ScanSettings; | |
| import android.content.Context; | |
| import android.content.Intent; | |
| import android.os.Handler; | |
| import android.os.IBinder; | |
| import android.os.ParcelUuid; | |
| import android.util.Log; | |
| import android.widget.Toast; | |
| import java.util.Arrays; | |
| import java.util.List; | |
| import java.util.UUID; | |
| public class BleEncryptedClientService extends Service { | |
| public static final boolean DEBUG = true; | |
| public static final String TAG = "BleEncryptedClient"; | |
| public static final String ACTION_CONNECT_WITH_SECURE = | |
| "com.android.cts.verifier.bluetooth.encripted.action.ACTION_CONNECT_WITH_SECURE"; | |
| public static final String ACTION_CONNECT_WITHOUT_SECURE = | |
| "com.android.cts.verifier.bluetooth.encripted.action.ACTION_CONNECT_WITHOUT_SECURE"; | |
| public static final String INTENT_BLE_BLUETOOTH_DISABLED = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.BLE_BLUETOOTH_DISABLED"; | |
| public static final String INTENT_BLE_WRITE_ENCRYPTED_CHARACTERISTIC = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.BLE_WRITE_ENCRYPTED_CHARACTERISTIC"; | |
| public static final String INTENT_BLE_WRITE_NOT_ENCRYPTED_CHARACTERISTIC = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.BLE_WRITE_NOT_ENCRYPTED_CHARACTERISTIC"; | |
| public static final String INTENT_BLE_READ_ENCRYPTED_CHARACTERISTIC = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.BLE_READ_ENCRYPTED_CHARACTERISTIC"; | |
| public static final String INTENT_BLE_READ_NOT_ENCRYPTED_CHARACTERISTIC = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.BLE_READ_NOT_ENCRYPTED_CHARACTERISTIC"; | |
| public static final String INTENT_BLE_WRITE_ENCRYPTED_DESCRIPTOR = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.BLE_WRITE_ENCRYPTED_DESCRIPTOR"; | |
| public static final String INTENT_BLE_WRITE_NOT_ENCRYPTED_DESCRIPTOR = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.BLE_WRITE_NOT_ENCRYPTED_DESCRIPTOR"; | |
| public static final String INTENT_BLE_READ_ENCRYPTED_DESCRIPTOR = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.BLE_READ_ENCRYPTED_DESCRIPTOR"; | |
| public static final String INTENT_BLE_READ_NOT_ENCRYPTED_DESCRIPTOR = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.BLE_READ_NOT_ENCRYPTED_DESCRIPTOR"; | |
| public static final String INTENT_BLE_WRITE_FAIL_ENCRYPTED_CHARACTERISTIC = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.INTENT_BLE_WRITE_FAIL_ENCRYPTED_CHARACTERISTIC"; | |
| public static final String INTENT_BLE_READ_FAIL_ENCRYPTED_CHARACTERISTIC = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.INTENT_BLE_READ_FAIL_ENCRYPTED_CHARACTERISTIC"; | |
| public static final String INTENT_BLE_WRITE_FAIL_ENCRYPTED_DESCRIPTOR = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.INTENT_BLE_WRITE_FAIL_ENCRYPTED_DESCRIPTOR"; | |
| public static final String INTENT_BLE_READ_FAIL_ENCRYPTED_DESCRIPTOR = | |
| "com.android.cts.verifier.bluetooth.encripted.intent.INTENT_BLE_READ_FAIL_ENCRYPTED_DESCRIPTOR"; | |
| public static final String ACTION_WRITE_ENCRYPTED_CHARACTERISTIC = | |
| "com.android.cts.verifier.bluetooth.encripted.action.WRITE_ENCRYPTED_CHARACTERISTIC"; | |
| public static final String ACTION_READ_ENCRYPTED_CHARACTERISTIC = | |
| "com.android.cts.verifier.bluetooth.encripted.action.READ_ENCRYPTED_CHARACTERISTIC"; | |
| public static final String ACTION_WRITE_ENCRYPTED_DESCRIPTOR = | |
| "com.android.cts.verifier.bluetooth.encripted.action.WRITE_ENCRYPTED_DESCRIPTOR"; | |
| public static final String ACTION_READ_ENCRYPTED_DESCRIPTOR = | |
| "com.android.cts.verifier.bluetooth.encripted.action.READ_ENCRYPTED_DESCRIPTOR"; | |
| public static final String ACTION_DISCONNECTED = | |
| "com.android.cts.verifier.bluetooth.encripted.action.DISCONNECTED"; | |
| public static final String WRITE_VALUE = "ENC_CLIENT_TEST"; | |
| private static final UUID SERVICE_UUID = | |
| UUID.fromString("00009999-0000-1000-8000-00805f9b34fb"); | |
| private static final UUID CHARACTERISTIC_UUID = | |
| UUID.fromString("00009998-0000-1000-8000-00805f9b34fb"); | |
| private static final UUID DESCRIPTOR_UUID = | |
| UUID.fromString("00009997-0000-1000-8000-00805f9b34fb"); | |
| private static final UUID CHARACTERISTIC_ENCRYPTED_WRITE_UUID = | |
| UUID.fromString("00009996-0000-1000-8000-00805f9b34fb"); | |
| private static final UUID CHARACTERISTIC_ENCRYPTED_READ_UUID = | |
| UUID.fromString("00009995-0000-1000-8000-00805f9b34fb"); | |
| private static final UUID DESCRIPTOR_ENCRYPTED_WRITE_UUID = | |
| UUID.fromString("00009994-0000-1000-8000-00805f9b34fb"); | |
| private static final UUID DESCRIPTOR_ENCRYPTED_READ_UUID = | |
| UUID.fromString("00009993-0000-1000-8000-00805f9b34fb"); | |
| private BluetoothManager mBluetoothManager; | |
| private BluetoothAdapter mBluetoothAdapter; | |
| private BluetoothGatt mBluetoothGatt; | |
| private BluetoothLeScanner mScanner; | |
| private BluetoothDevice mDevice; | |
| private Handler mHandler; | |
| private Context mContext; | |
| private String mAction; | |
| private boolean mSecure; | |
| private String mTarget; | |
| private String mLastScanError; | |
| private TestTaskQueue mTaskQueue; | |
| public BleEncryptedClientService() { | |
| } | |
| @Override | |
| public IBinder onBind(Intent intent) { | |
| return null; | |
| } | |
| @Override | |
| public void onCreate() { | |
| super.onCreate(); | |
| mTaskQueue = new TestTaskQueue(getClass().getName() + "_enc_cli_taskHandlerThread"); | |
| mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE); | |
| mBluetoothAdapter = mBluetoothManager.getAdapter(); | |
| mScanner = mBluetoothAdapter.getBluetoothLeScanner(); | |
| mHandler = new Handler(); | |
| mContext = this; | |
| mSecure = false; | |
| } | |
| @Override | |
| public void onDestroy() { | |
| super.onDestroy(); | |
| mTaskQueue.quit(); | |
| if (mBluetoothGatt != null) { | |
| mBluetoothGatt.disconnect(); | |
| mBluetoothGatt.close(); | |
| mBluetoothGatt = null; | |
| mDevice = null; | |
| } | |
| stopScan(); | |
| } | |
| private void notifyBluetoothDisabled() { | |
| Intent intent = new Intent(INTENT_BLE_BLUETOOTH_DISABLED); | |
| sendBroadcast(intent); | |
| } | |
| private void notifyDisconnected() { | |
| Intent intent = new Intent(ACTION_DISCONNECTED); | |
| sendBroadcast(intent); | |
| } | |
| @Override | |
| public int onStartCommand(Intent intent, int flags, int startId) { | |
| if (!mBluetoothAdapter.isEnabled()) { | |
| notifyBluetoothDisabled(); | |
| } else { | |
| if (intent != null) { | |
| mAction = intent.getAction(); | |
| if (mAction == null) { | |
| mSecure = intent.getBooleanExtra(BleEncryptedServerService.EXTRA_SECURE, false); | |
| } else { | |
| switch (mAction) { | |
| case ACTION_CONNECT_WITH_SECURE: | |
| mSecure = true; | |
| break; | |
| case ACTION_CONNECT_WITHOUT_SECURE: | |
| mSecure = false; | |
| break; | |
| case ACTION_WRITE_ENCRYPTED_CHARACTERISTIC: | |
| mTarget = BleEncryptedServerService.WRITE_CHARACTERISTIC; | |
| startScan(); | |
| break; | |
| case ACTION_READ_ENCRYPTED_CHARACTERISTIC: | |
| mTarget = BleEncryptedServerService.READ_CHARACTERISTIC; | |
| startScan(); | |
| break; | |
| case ACTION_WRITE_ENCRYPTED_DESCRIPTOR: | |
| mTarget = BleEncryptedServerService.WRITE_DESCRIPTOR; | |
| startScan(); | |
| break; | |
| case ACTION_READ_ENCRYPTED_DESCRIPTOR: | |
| mTarget = BleEncryptedServerService.READ_DESCRIPTOR; | |
| startScan(); | |
| break; | |
| default: | |
| return START_NOT_STICKY; | |
| } | |
| } | |
| } | |
| } | |
| return START_NOT_STICKY; | |
| } | |
| private BluetoothGattService getService() { | |
| BluetoothGattService service = null; | |
| if (mBluetoothGatt != null) { | |
| service = mBluetoothGatt.getService(SERVICE_UUID); | |
| if (service == null) { | |
| showMessage("Service not found"); | |
| } | |
| } | |
| return service; | |
| } | |
| private BluetoothGattCharacteristic getCharacteristic(UUID uuid) { | |
| BluetoothGattCharacteristic characteristic = null; | |
| BluetoothGattService service = getService(); | |
| if (service != null) { | |
| characteristic = service.getCharacteristic(uuid); | |
| if (characteristic == null) { | |
| showMessage("Characteristic not found"); | |
| } | |
| } | |
| return characteristic; | |
| } | |
| private BluetoothGattDescriptor getDescriptor(UUID uid) { | |
| BluetoothGattDescriptor descriptor = null; | |
| BluetoothGattCharacteristic characteristic = getCharacteristic(CHARACTERISTIC_UUID); | |
| if (characteristic != null) { | |
| descriptor = characteristic.getDescriptor(uid); | |
| if (descriptor == null) { | |
| showMessage("Descriptor not found"); | |
| } | |
| } | |
| return descriptor; | |
| } | |
| private void sleep(int millis) { | |
| try { | |
| Thread.sleep(millis); | |
| } catch (InterruptedException e) { | |
| Log.e(TAG, "Error in thread sleep", e); | |
| } | |
| } | |
| private void startEncryptedAction() { | |
| BluetoothGattCharacteristic characteristic; | |
| BluetoothGattCharacteristic caseCharacteristic; | |
| BluetoothGattDescriptor descriptor; | |
| switch (mTarget) { | |
| case BleEncryptedServerService.WRITE_CHARACTERISTIC: | |
| Log.v(TAG, "WRITE_CHARACTERISTIC"); | |
| characteristic = getCharacteristic(CHARACTERISTIC_ENCRYPTED_WRITE_UUID); | |
| characteristic.setValue(WRITE_VALUE); | |
| mBluetoothGatt.writeCharacteristic(characteristic); | |
| break; | |
| case BleEncryptedServerService.READ_CHARACTERISTIC: | |
| Log.v(TAG, "READ_CHARACTERISTIC"); | |
| characteristic = getCharacteristic(CHARACTERISTIC_ENCRYPTED_READ_UUID); | |
| mBluetoothGatt.readCharacteristic(characteristic); | |
| break; | |
| case BleEncryptedServerService.WRITE_DESCRIPTOR: | |
| Log.v(TAG, "WRITE_DESCRIPTOR"); | |
| descriptor = getDescriptor(DESCRIPTOR_ENCRYPTED_WRITE_UUID); | |
| descriptor.setValue(WRITE_VALUE.getBytes()); | |
| mBluetoothGatt.writeDescriptor(descriptor); | |
| break; | |
| case BleEncryptedServerService.READ_DESCRIPTOR: | |
| Log.v(TAG, "READ_DESCRIPTOR"); | |
| descriptor = getDescriptor(DESCRIPTOR_ENCRYPTED_READ_UUID); | |
| mBluetoothGatt.readDescriptor(descriptor); | |
| break; | |
| } | |
| } | |
| private void showMessage(final String msg) { | |
| mHandler.post(new Runnable() { | |
| public void run() { | |
| Toast.makeText(BleEncryptedClientService.this, msg, Toast.LENGTH_SHORT).show(); | |
| } | |
| }); | |
| } | |
| private final BluetoothGattCallback mGattCallbacks = new BluetoothGattCallback() { | |
| @Override | |
| public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) { | |
| if (DEBUG) Log.d(TAG, "onConnectionStateChange: status = " + status + ", newState = " + newState); | |
| if (status == BluetoothGatt.GATT_SUCCESS) { | |
| if (newState == BluetoothProfile.STATE_CONNECTED) { | |
| showMessage("Bluetooth LE connected"); | |
| mTaskQueue.addTask(new Runnable() { | |
| @Override | |
| public void run() { | |
| mBluetoothGatt.discoverServices(); | |
| } | |
| }, 1000); | |
| } else if (newState == BluetoothProfile.STATE_DISCONNECTED) { | |
| showMessage("Bluetooth LE disconnected"); | |
| mTaskQueue.addTask(new Runnable() { | |
| @Override | |
| public void run() { | |
| if (mBluetoothGatt != null) { | |
| mBluetoothGatt.close(); | |
| mBluetoothGatt = null; | |
| mTarget = null; | |
| mDevice = null; | |
| notifyDisconnected(); | |
| } | |
| } | |
| }, 1000); | |
| } | |
| } else { | |
| showMessage("Connection Not Success."); | |
| if (mTarget != null) { | |
| Intent intent; | |
| switch (mTarget) { | |
| case BleEncryptedServerService.READ_CHARACTERISTIC: | |
| intent = new Intent(INTENT_BLE_READ_FAIL_ENCRYPTED_CHARACTERISTIC); | |
| break; | |
| case BleEncryptedServerService.WRITE_CHARACTERISTIC: | |
| if (mSecure) { | |
| intent = new Intent(INTENT_BLE_WRITE_FAIL_ENCRYPTED_CHARACTERISTIC); | |
| } else { | |
| intent = new Intent(INTENT_BLE_WRITE_ENCRYPTED_CHARACTERISTIC); | |
| } | |
| break; | |
| case BleEncryptedServerService.READ_DESCRIPTOR: | |
| intent = new Intent(INTENT_BLE_READ_FAIL_ENCRYPTED_DESCRIPTOR); | |
| break; | |
| case BleEncryptedServerService.WRITE_DESCRIPTOR: | |
| if (mSecure) { | |
| intent = new Intent(INTENT_BLE_WRITE_FAIL_ENCRYPTED_DESCRIPTOR); | |
| } else { | |
| intent = new Intent(INTENT_BLE_WRITE_ENCRYPTED_DESCRIPTOR); | |
| } | |
| break; | |
| default: | |
| return; | |
| } | |
| if (mBluetoothGatt != null) { | |
| mBluetoothGatt.close(); | |
| mBluetoothGatt = null; | |
| mDevice = null; | |
| mTarget = null; | |
| } | |
| sendBroadcast(intent); | |
| } | |
| } | |
| } | |
| @Override | |
| public void onServicesDiscovered(BluetoothGatt gatt, int status) { | |
| if (DEBUG){ | |
| Log.d(TAG, "onServiceDiscovered"); | |
| } | |
| if ((status == BluetoothGatt.GATT_SUCCESS) && (mBluetoothGatt.getService(SERVICE_UUID) != null)) { | |
| showMessage("Service discovered"); | |
| startEncryptedAction(); | |
| } | |
| } | |
| @Override | |
| public void onCharacteristicWrite(BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, final int status) { | |
| final String value = characteristic.getStringValue(0); | |
| UUID uid = characteristic.getUuid(); | |
| if (DEBUG) { | |
| Log.d(TAG, "onCharacteristicWrite: characteristic.val=" + value + " status=" + status + " uid=" + uid); | |
| } | |
| if (uid.equals(CHARACTERISTIC_ENCRYPTED_WRITE_UUID)) { | |
| mTaskQueue.addTask(new Runnable() { | |
| @Override | |
| public void run() { | |
| if (status == BluetoothGatt.GATT_SUCCESS) { | |
| if (mSecure) { | |
| mBluetoothGatt.disconnect(); | |
| if (WRITE_VALUE.equals(value)) { | |
| Intent intent = new Intent(INTENT_BLE_WRITE_ENCRYPTED_CHARACTERISTIC); | |
| sendBroadcast(intent); | |
| } else { | |
| showMessage("Written data is not correct"); | |
| } | |
| } | |
| } else { | |
| if (!mSecure) { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_WRITE_NOT_ENCRYPTED_CHARACTERISTIC); | |
| sendBroadcast(intent); | |
| } else { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_WRITE_FAIL_ENCRYPTED_CHARACTERISTIC); | |
| sendBroadcast(intent); | |
| } | |
| } | |
| } | |
| }, 1000); | |
| } | |
| } | |
| @Override | |
| public void onCharacteristicRead(BluetoothGatt gatt, final BluetoothGattCharacteristic characteristic, final int status) { | |
| UUID uid = characteristic.getUuid(); | |
| if (DEBUG) { | |
| Log.d(TAG, "onCharacteristicRead: status=" + status); | |
| } | |
| if (uid.equals(CHARACTERISTIC_ENCRYPTED_READ_UUID)) { | |
| mTaskQueue.addTask(new Runnable() { | |
| @Override | |
| public void run() { | |
| if (status == BluetoothGatt.GATT_SUCCESS) { | |
| if (mSecure) { | |
| mBluetoothGatt.disconnect(); | |
| if (Arrays.equals(BleEncryptedServerService.WRITE_VALUE.getBytes(), characteristic.getValue())) { | |
| Intent intent = new Intent(INTENT_BLE_READ_ENCRYPTED_CHARACTERISTIC); | |
| sendBroadcast(intent); | |
| } else { | |
| showMessage("Read data is not correct"); | |
| } | |
| } else { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_READ_NOT_ENCRYPTED_CHARACTERISTIC); | |
| sendBroadcast(intent); | |
| } | |
| } else { | |
| if (!mSecure) { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_READ_ENCRYPTED_CHARACTERISTIC); | |
| sendBroadcast(intent); | |
| } else { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_READ_FAIL_ENCRYPTED_CHARACTERISTIC); | |
| sendBroadcast(intent); | |
| } | |
| } | |
| } | |
| }, 1000); | |
| } | |
| } | |
| @Override | |
| public void onDescriptorRead(BluetoothGatt gatt, final BluetoothGattDescriptor descriptor, final int status) { | |
| if (DEBUG) { | |
| Log.d(TAG, "onDescriptorRead: status=" + status); | |
| } | |
| mTaskQueue.addTask(new Runnable() { | |
| @Override | |
| public void run() { | |
| UUID uid = descriptor.getUuid(); | |
| if ((status == BluetoothGatt.GATT_SUCCESS)) { | |
| if (uid.equals(DESCRIPTOR_ENCRYPTED_READ_UUID)) { | |
| if (mSecure) { | |
| mBluetoothGatt.disconnect(); | |
| if (Arrays.equals(BleEncryptedServerService.WRITE_VALUE.getBytes(), descriptor.getValue())) { | |
| Intent intent = new Intent(INTENT_BLE_READ_ENCRYPTED_DESCRIPTOR); | |
| sendBroadcast(intent); | |
| } else { | |
| showMessage("Read data is not correct"); | |
| } | |
| } else { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_READ_NOT_ENCRYPTED_DESCRIPTOR); | |
| sendBroadcast(intent); | |
| } | |
| } | |
| } else { | |
| if (!mSecure) { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_READ_ENCRYPTED_DESCRIPTOR); | |
| sendBroadcast(intent); | |
| } else { | |
| if (uid.equals(DESCRIPTOR_ENCRYPTED_READ_UUID)) { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_READ_FAIL_ENCRYPTED_DESCRIPTOR); | |
| sendBroadcast(intent); | |
| } | |
| } | |
| } | |
| } | |
| }, 1000); | |
| } | |
| @Override | |
| public void onDescriptorWrite(BluetoothGatt gatt, final BluetoothGattDescriptor descriptor, final int status) { | |
| if (DEBUG) { | |
| Log.d(TAG, "onDescriptorWrite: status=" + status); | |
| } | |
| mTaskQueue.addTask(new Runnable() { | |
| @Override | |
| public void run() { | |
| UUID uid = descriptor.getUuid(); | |
| if (uid.equals(DESCRIPTOR_ENCRYPTED_WRITE_UUID)) { | |
| if ((status == BluetoothGatt.GATT_SUCCESS)) { | |
| if (mSecure) { | |
| mBluetoothGatt.disconnect(); | |
| if (Arrays.equals(WRITE_VALUE.getBytes(), descriptor.getValue())) { | |
| Intent intent = new Intent(INTENT_BLE_WRITE_ENCRYPTED_DESCRIPTOR); | |
| sendBroadcast(intent); | |
| } else { | |
| showMessage("Written data is not correct"); | |
| } | |
| } | |
| } else { | |
| if (!mSecure) { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_WRITE_NOT_ENCRYPTED_DESCRIPTOR); | |
| sendBroadcast(intent); | |
| } else { | |
| mBluetoothGatt.disconnect(); | |
| Intent intent = new Intent(INTENT_BLE_WRITE_FAIL_ENCRYPTED_DESCRIPTOR); | |
| sendBroadcast(intent); | |
| } | |
| } | |
| } | |
| } | |
| }, 1000); | |
| } | |
| }; | |
| private final ScanCallback mScanCallback = new ScanCallback() { | |
| @Override | |
| public void onScanResult(int callbackType, final ScanResult result) { | |
| if (mBluetoothGatt== null) { | |
| mDevice = result.getDevice(); | |
| int bond_state = mDevice.getBondState(); | |
| if (mSecure && bond_state != BluetoothDevice.BOND_BONDED) { | |
| mLastScanError = "This test is a test of Secure.\n Before running the test, please do the pairing."; | |
| return; | |
| } else if (!mSecure && bond_state != BluetoothDevice.BOND_NONE) { | |
| mLastScanError = "This test is a test of Insecure\n Before running the test, please release the pairing."; | |
| return; | |
| } | |
| mLastScanError = null; | |
| stopScan(); | |
| mBluetoothGatt = BleClientService.connectGatt(mDevice, mContext, false, mSecure, mGattCallbacks); | |
| } | |
| } | |
| }; | |
| private void startScan() { | |
| if (DEBUG) Log.d(TAG, "startScan"); | |
| List<ScanFilter> filter = Arrays.asList(new ScanFilter.Builder().setServiceUuid( | |
| new ParcelUuid(BleEncryptedServerService.ADV_SERVICE_UUID)).build()); | |
| ScanSettings setting = new ScanSettings.Builder() | |
| .setScanMode(ScanSettings.SCAN_MODE_LOW_LATENCY).build(); | |
| mScanner.startScan(filter, setting, mScanCallback); | |
| mTaskQueue.addTask(new Runnable() { | |
| @Override | |
| public void run() { | |
| if (mLastScanError != null) { | |
| stopScan(); | |
| Toast.makeText(BleEncryptedClientService.this, mLastScanError, Toast.LENGTH_LONG).show(); | |
| mLastScanError = null; | |
| } | |
| } | |
| }, 10000); | |
| } | |
| private void stopScan() { | |
| if (DEBUG) Log.d(TAG, "stopScan"); | |
| if (mScanner != null) { | |
| mScanner.stopScan(mScanCallback); | |
| } | |
| } | |
| } |