| /* |
| * Copyright (C) 2013 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 java.util.Date; |
| import java.util.List; |
| import java.util.Timer; |
| import java.util.TimerTask; |
| import java.util.UUID; |
| |
| import android.app.Service; |
| import android.bluetooth.BluetoothAdapter; |
| import android.bluetooth.BluetoothDevice; |
| import android.bluetooth.BluetoothGatt; |
| import android.bluetooth.BluetoothGattCharacteristic; |
| import android.bluetooth.BluetoothGattDescriptor; |
| import android.bluetooth.BluetoothGattServer; |
| import android.bluetooth.BluetoothGattServerCallback; |
| import android.bluetooth.BluetoothGattService; |
| import android.bluetooth.BluetoothManager; |
| import android.bluetooth.BluetoothProfile; |
| import android.bluetooth.le.AdvertiseCallback; |
| import android.bluetooth.le.AdvertiseData; |
| import android.bluetooth.le.AdvertiseSettings; |
| import android.bluetooth.le.BluetoothLeAdvertiser; |
| 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; |
| |
| public class BleServerService extends Service { |
| |
| public static final boolean DEBUG = true; |
| public static final String TAG = "BleServerService"; |
| |
| public static final int COMMAND_ADD_SERVICE = 0; |
| public static final int COMMAND_WRITE_CHARACTERISTIC = 1; |
| public static final int COMMAND_WRITE_DESCRIPTOR = 2; |
| |
| public static final String BLE_SERVER_CONNECTED = |
| "com.android.cts.verifier.bluetooth.BLE_SERVER_CONNECTED"; |
| public static final String BLE_SERVER_DISCONNECTED = |
| "com.android.cts.verifier.bluetooth.BLE_SERVER_DISCONNECTED"; |
| public static final String BLE_SERVICE_ADDED = |
| "com.android.cts.verifier.bluetooth.BLE_SERVICE_ADDED"; |
| public static final String BLE_CHARACTERISTIC_READ_REQUEST = |
| "com.android.cts.verifier.bluetooth.BLE_CHARACTERISTIC_READ_REQUEST"; |
| public static final String BLE_CHARACTERISTIC_WRITE_REQUEST = |
| "com.android.cts.verifier.bluetooth.BLE_CHARACTERISTIC_WRITE_REQUEST"; |
| public static final String BLE_DESCRIPTOR_READ_REQUEST = |
| "com.android.cts.verifier.bluetooth.BLE_DESCRIPTOR_READ_REQUEST"; |
| public static final String BLE_DESCRIPTOR_WRITE_REQUEST = |
| "com.android.cts.verifier.bluetooth.BLE_DESCRIPTOR_WRITE_REQUEST"; |
| public static final String BLE_EXECUTE_WRITE = |
| "com.android.cts.verifier.bluetooth.BLE_EXECUTE_WRITE"; |
| public static final String BLE_OPEN_FAIL = |
| "com.android.cts.verifier.bluetooth.BLE_OPEN_FAIL"; |
| |
| 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 UPDATE_CHARACTERISTIC_UUID = |
| UUID.fromString("00009997-0000-1000-8000-00805f9b34fb"); |
| private static final UUID DESCRIPTOR_UUID = |
| UUID.fromString("00009996-0000-1000-8000-00805f9b34fb"); |
| public static final UUID ADV_SERVICE_UUID= |
| UUID.fromString("00003333-0000-1000-8000-00805f9b34fb"); |
| |
| private BluetoothManager mBluetoothManager; |
| private BluetoothGattServer mGattServer; |
| private BluetoothGattService mService; |
| private BluetoothDevice mDevice; |
| private Timer mNotificationTimer; |
| private Handler mHandler; |
| private String mReliableWriteValue; |
| private BluetoothLeAdvertiser mAdvertiser; |
| |
| @Override |
| public void onCreate() { |
| super.onCreate(); |
| |
| mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE); |
| mAdvertiser = mBluetoothManager.getAdapter().getBluetoothLeAdvertiser(); |
| mGattServer = mBluetoothManager.openGattServer(this, mCallbacks); |
| mService = createService(); |
| if (mGattServer != null) { |
| mGattServer.addService(mService); |
| } |
| mDevice = null; |
| mReliableWriteValue = null; |
| |
| mHandler = new Handler(); |
| if (mGattServer == null) { |
| notifyOpenFail(); |
| } |
| } |
| |
| @Override |
| public int onStartCommand(Intent intent, int flags, int startId) { |
| startAdvertise(); |
| return START_NOT_STICKY; |
| } |
| |
| @Override |
| public IBinder onBind(Intent intent) { |
| return null; |
| } |
| |
| @Override |
| public void onDestroy() { |
| super.onDestroy(); |
| stopAdvertise(); |
| if (mGattServer == null) { |
| return; |
| } |
| if (mDevice != null) mGattServer.cancelConnection(mDevice); |
| mGattServer.close(); |
| } |
| |
| private void writeCharacteristic(String writeValue) { |
| BluetoothGattCharacteristic characteristic = getCharacteristic(CHARACTERISTIC_UUID); |
| if (characteristic != null) return; |
| characteristic.setValue(writeValue); |
| } |
| |
| private void writeDescriptor(String writeValue) { |
| BluetoothGattDescriptor descriptor = getDescriptor(); |
| if (descriptor == null) return; |
| descriptor.setValue(writeValue.getBytes()); |
| } |
| |
| private void notifyOpenFail() { |
| if (DEBUG) Log.d(TAG, "notifyOpenFail"); |
| Intent intent = new Intent(BLE_OPEN_FAIL); |
| sendBroadcast(intent); |
| } |
| |
| private void notifyConnected() { |
| if (DEBUG) Log.d(TAG, "notifyConnected"); |
| Intent intent = new Intent(BLE_SERVER_CONNECTED); |
| sendBroadcast(intent); |
| } |
| |
| private void notifyDisconnected() { |
| if (DEBUG) Log.d(TAG, "notifyDisconnected"); |
| Intent intent = new Intent(BLE_SERVER_DISCONNECTED); |
| sendBroadcast(intent); |
| } |
| |
| private void notifyServiceAdded() { |
| if (DEBUG) Log.d(TAG, "notifyServiceAdded"); |
| Intent intent = new Intent(BLE_SERVICE_ADDED); |
| sendBroadcast(intent); |
| } |
| |
| private void notifyCharacteristicReadRequest() { |
| if (DEBUG) Log.d(TAG, "notifyCharacteristicReadRequest"); |
| Intent intent = new Intent(BLE_CHARACTERISTIC_READ_REQUEST); |
| sendBroadcast(intent); |
| } |
| |
| private void notifyCharacteristicWriteRequest() { |
| if (DEBUG) Log.d(TAG, "notifyCharacteristicWriteRequest"); |
| Intent intent = new Intent(BLE_CHARACTERISTIC_WRITE_REQUEST); |
| sendBroadcast(intent); |
| } |
| |
| private void notifyDescriptorReadRequest() { |
| if (DEBUG) Log.d(TAG, "notifyDescriptorReadRequest"); |
| Intent intent = new Intent(BLE_DESCRIPTOR_READ_REQUEST); |
| sendBroadcast(intent); |
| } |
| |
| private void notifyDescriptorWriteRequest() { |
| if (DEBUG) Log.d(TAG, "notifyDescriptorWriteRequest"); |
| Intent intent = new Intent(BLE_DESCRIPTOR_WRITE_REQUEST); |
| sendBroadcast(intent); |
| } |
| |
| private void notifyExecuteWrite() { |
| if (DEBUG) Log.d(TAG, "notifyExecuteWrite"); |
| Intent intent = new Intent(BLE_EXECUTE_WRITE); |
| sendBroadcast(intent); |
| } |
| |
| private BluetoothGattCharacteristic getCharacteristic(UUID uuid) { |
| BluetoothGattCharacteristic characteristic = |
| mService.getCharacteristic(uuid); |
| if (characteristic == null) { |
| showMessage("Characteristic not found"); |
| return null; |
| } |
| return characteristic; |
| } |
| |
| private BluetoothGattDescriptor getDescriptor() { |
| BluetoothGattCharacteristic characteristic = getCharacteristic(CHARACTERISTIC_UUID); |
| if (characteristic == null) return null; |
| |
| BluetoothGattDescriptor descriptor = characteristic.getDescriptor(DESCRIPTOR_UUID); |
| if (descriptor == null) { |
| showMessage("Descriptor not found"); |
| return null; |
| } |
| return descriptor; |
| } |
| |
| private BluetoothGattService createService() { |
| BluetoothGattService service = |
| new BluetoothGattService(SERVICE_UUID, BluetoothGattService.SERVICE_TYPE_PRIMARY); |
| BluetoothGattCharacteristic characteristic = |
| new BluetoothGattCharacteristic(CHARACTERISTIC_UUID, 0x0A, 0x11); |
| BluetoothGattDescriptor descriptor = new BluetoothGattDescriptor(DESCRIPTOR_UUID, 0x11); |
| characteristic.addDescriptor(descriptor); |
| service.addCharacteristic(characteristic); |
| |
| BluetoothGattCharacteristic notiCharacteristic = |
| new BluetoothGattCharacteristic(UPDATE_CHARACTERISTIC_UUID, 0x10, 0x00); |
| service.addCharacteristic(notiCharacteristic); |
| |
| return service; |
| } |
| |
| private void beginNotification() { |
| TimerTask task = new TimerTask() { |
| @Override |
| public void run() { |
| if (mGattServer == null) { |
| if (DEBUG) Log.d(TAG, "GattServer is null, return"); |
| return; |
| } |
| BluetoothGattCharacteristic characteristic = |
| mService.getCharacteristic(UPDATE_CHARACTERISTIC_UUID); |
| if (characteristic == null) return; |
| |
| String date = (new Date()).toString(); |
| characteristic.setValue(date); |
| mGattServer.notifyCharacteristicChanged(mDevice, characteristic, false); |
| } |
| }; |
| mNotificationTimer = new Timer(); |
| mNotificationTimer.schedule(task, 0, 1000); |
| } |
| |
| private void stopNotification() { |
| if (mNotificationTimer == null) return; |
| mNotificationTimer.cancel(); |
| mNotificationTimer = null; |
| } |
| |
| private void showMessage(final String msg) { |
| mHandler.post(new Runnable() { |
| public void run() { |
| Toast.makeText(BleServerService.this, msg, Toast.LENGTH_SHORT).show(); |
| } |
| }); |
| } |
| |
| private final BluetoothGattServerCallback mCallbacks = new BluetoothGattServerCallback() { |
| @Override |
| public void onConnectionStateChange(BluetoothDevice device, int status, int newState) { |
| if (DEBUG) Log.d(TAG, "onConnectionStateChange: newState=" + newState); |
| if (status == BluetoothGatt.GATT_SUCCESS) { |
| if (newState == BluetoothProfile.STATE_CONNECTED) { |
| mDevice = device; |
| notifyConnected(); |
| beginNotification(); |
| } else if (status == BluetoothProfile.STATE_DISCONNECTED) { |
| stopNotification(); |
| notifyDisconnected(); |
| mDevice = null; |
| } |
| } |
| } |
| |
| @Override |
| public void onServiceAdded(int status, BluetoothGattService service) { |
| if (DEBUG) Log.d(TAG, "onServiceAdded()"); |
| if (status == BluetoothGatt.GATT_SUCCESS) notifyServiceAdded(); |
| } |
| |
| @Override |
| public void onCharacteristicReadRequest(BluetoothDevice device, int requestId, |
| int offset, BluetoothGattCharacteristic characteristic) { |
| if (mGattServer == null) { |
| if (DEBUG) Log.d(TAG, "GattServer is null, return"); |
| return; |
| } |
| if (DEBUG) Log.d(TAG, "onCharacteristicReadRequest()"); |
| |
| notifyCharacteristicReadRequest(); |
| mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, 0, |
| characteristic.getValue()); |
| } |
| |
| @Override |
| public void onCharacteristicWriteRequest(BluetoothDevice device, int requestId, |
| BluetoothGattCharacteristic characteristic, |
| boolean preparedWrite, boolean responseNeeded, |
| int offset, byte[] value) { |
| if (mGattServer == null) { |
| if (DEBUG) Log.d(TAG, "GattServer is null, return"); |
| return; |
| } |
| if (DEBUG) Log.d(TAG, "onCharacteristicWriteRequest: preparedWrite=" + preparedWrite); |
| |
| notifyCharacteristicWriteRequest(); |
| if (preparedWrite) mReliableWriteValue = new String(value); |
| else characteristic.setValue(value); |
| |
| if (responseNeeded) |
| mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, 0, null); |
| } |
| |
| @Override |
| public void onDescriptorReadRequest(BluetoothDevice device, int requestId, |
| int offset, BluetoothGattDescriptor descriptor) { |
| if (mGattServer == null) { |
| if (DEBUG) Log.d(TAG, "GattServer is null, return"); |
| return; |
| } |
| if (DEBUG) Log.d(TAG, "onDescriptorReadRequest(): (descriptor == getDescriptor())=" |
| + (descriptor == getDescriptor())); |
| |
| notifyDescriptorReadRequest(); |
| mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, 0, |
| descriptor.getValue()); |
| } |
| |
| @Override |
| public void onDescriptorWriteRequest(BluetoothDevice device, int requestId, |
| BluetoothGattDescriptor descriptor, |
| boolean preparedWrite, boolean responseNeeded, |
| int offset, byte[] value) { |
| if (mGattServer == null) { |
| if (DEBUG) Log.d(TAG, "GattServer is null, return"); |
| return; |
| } |
| if (DEBUG) Log.d(TAG, "onDescriptorWriteRequest(): (descriptor == getDescriptor())=" |
| + (descriptor == getDescriptor())); |
| |
| notifyDescriptorWriteRequest(); |
| descriptor.setValue(value); |
| if (responseNeeded) |
| mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, 0, null); |
| } |
| |
| @Override |
| public void onExecuteWrite(BluetoothDevice device, int requestId, boolean execute) { |
| if (mGattServer == null) { |
| if (DEBUG) Log.d(TAG, "GattServer is null, return"); |
| return; |
| } |
| if (DEBUG) Log.d(TAG, "onExecuteWrite"); |
| if (execute) { |
| notifyExecuteWrite(); |
| getCharacteristic(CHARACTERISTIC_UUID).setValue(mReliableWriteValue); |
| mGattServer.sendResponse(device, requestId, BluetoothGatt.GATT_SUCCESS, 0, null); |
| } |
| } |
| }; |
| |
| private void startAdvertise() { |
| if (DEBUG) Log.d(TAG, "startAdvertise"); |
| AdvertiseData data = new AdvertiseData.Builder() |
| .addServiceData(new ParcelUuid(ADV_SERVICE_UUID), new byte[]{1,2,3}) |
| .addServiceUuid(new ParcelUuid(ADV_SERVICE_UUID)) |
| .build(); |
| AdvertiseSettings setting = new AdvertiseSettings.Builder() |
| .setAdvertiseMode(AdvertiseSettings.ADVERTISE_MODE_LOW_LATENCY) |
| .setTxPowerLevel(AdvertiseSettings.ADVERTISE_TX_POWER_MEDIUM) |
| .setConnectable(true) |
| .build(); |
| mAdvertiser.startAdvertising(setting, data, mAdvertiseCallback); |
| } |
| |
| private void stopAdvertise() { |
| if (DEBUG) Log.d(TAG, "stopAdvertise"); |
| mAdvertiser.stopAdvertising(mAdvertiseCallback); |
| } |
| |
| private final AdvertiseCallback mAdvertiseCallback = new AdvertiseCallback(){}; |
| } |
| |
