Android Open Source - Enlights R B L Service

• Back to App/control  ↑

From Project

Back to project page Enlights.

License

The source code is released under:

Apache License

Java Source Code

/*
 * Copyright (C) 2013 The Android Open Source Project
 *//w  ww.  j a va 2 s.  c o m
 * 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 edu.wisc.enlight.enlights;

import java.util.UUID;

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.content.Context;
import android.content.Intent;
import android.os.Binder;
import android.os.IBinder;
import android.util.Log;

/**
 * Service for managing connection and data communication with a GATT server
 * hosted on a given Bluetooth LE device.
 */
public class RBLService extends Service {
  private final static String TAG = RBLService.class.getSimpleName();

  private BluetoothManager mBluetoothManager;
  private BluetoothAdapter mBluetoothAdapter;
  private String mBluetoothDeviceAddress;
  private BluetoothGatt mBluetoothGatt;

  public final static String ACTION_GATT_CONNECTED = "ACTION_GATT_CONNECTED";
  public final static String ACTION_GATT_DISCONNECTED = "ACTION_GATT_DISCONNECTED";
  public final static String ACTION_GATT_SERVICES_DISCOVERED = "ACTION_GATT_SERVICES_DISCOVERED";
  public final static String ACTION_GATT_RSSI = "ACTION_GATT_RSSI";
  public final static String ACTION_DATA_AVAILABLE = "ACTION_DATA_AVAILABLE";
  public final static String EXTRA_DATA = "EXTRA_DATA";

  public final static UUID UUID_BLE_SHIELD_TX = UUID
      .fromString(RBLGattAttributes.BLE_SHIELD_TX);
  public final static UUID UUID_BLE_SHIELD_RX = UUID
      .fromString(RBLGattAttributes.BLE_SHIELD_RX);
  public final static UUID UUID_BLE_SHIELD_SERVICE = UUID
      .fromString(RBLGattAttributes.BLE_SHIELD_SERVICE);

  private final BluetoothGattCallback mGattCallback = new BluetoothGattCallback() {
    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status,
        int newState) {
      String intentAction;

      if (newState == BluetoothProfile.STATE_CONNECTED) {
        intentAction = ACTION_GATT_CONNECTED;
        broadcastUpdate(intentAction);
        Log.i(TAG, "Connected to GATT server.");
        // Attempts to discover services after successful connection.
        Log.i(TAG, "Attempting to start service discovery:"
            + mBluetoothGatt.discoverServices());
      } else if (newState == BluetoothProfile.STATE_DISCONNECTED) {
        intentAction = ACTION_GATT_DISCONNECTED;
        Log.i(TAG, "Disconnected from GATT server.");
        broadcastUpdate(intentAction);
      }
    }

    public void onReadRemoteRssi(BluetoothGatt gatt, int rssi, int status) {
      if (status == BluetoothGatt.GATT_SUCCESS) {
        broadcastUpdate(ACTION_GATT_RSSI, rssi);
      } else {
        Log.w(TAG, "onReadRemoteRssi received: " + status);
      }
    };

    @Override
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
      if (status == BluetoothGatt.GATT_SUCCESS) {
        broadcastUpdate(ACTION_GATT_SERVICES_DISCOVERED);
      } else {
        Log.w(TAG, "onServicesDiscovered received: " + status);
      }
    }

    @Override
    public void onCharacteristicRead(BluetoothGatt gatt,
        BluetoothGattCharacteristic characteristic, int status) {
      if (status == BluetoothGatt.GATT_SUCCESS) {
        broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic);
      }
    }

    @Override
    public void onCharacteristicChanged(BluetoothGatt gatt,
        BluetoothGattCharacteristic characteristic) {
      broadcastUpdate(ACTION_DATA_AVAILABLE, characteristic);
    }
  };

  private void broadcastUpdate(final String action) {
    final Intent intent = new Intent(action);
    sendBroadcast(intent);
  }

  private void broadcastUpdate(final String action, int rssi) {
    final Intent intent = new Intent(action);
    intent.putExtra(EXTRA_DATA, String.valueOf(rssi));
    sendBroadcast(intent);
  }

  private void broadcastUpdate(final String action,
      final BluetoothGattCharacteristic characteristic) {
    final Intent intent = new Intent(action);

    // This is special handling for the Heart Rate Measurement profile. Data
    // parsing is
    // carried out as per profile specifications:
    // http://developer.bluetooth.org/gatt/characteristics/Pages/CharacteristicViewer.aspx?u=org.bluetooth.characteristic.heart_rate_measurement.xml
    if (UUID_BLE_SHIELD_RX.equals(characteristic.getUuid())) {
      final byte[] rx = characteristic.getValue();
      intent.putExtra(EXTRA_DATA, rx);
    }

    sendBroadcast(intent);
  }

  public class LocalBinder extends Binder {
    RBLService getService() {
      return RBLService.this;
    }
  }

  @Override
  public IBinder onBind(Intent intent) {
    return mBinder;
  }

  @Override
  public boolean onUnbind(Intent intent) {
    // After using a given device, you should make sure that
    // BluetoothGatt.close() is called
    // such that resources are cleaned up properly. In this particular
    // example, close() is
    // invoked when the UI is disconnected from the Service.
    close();
    return super.onUnbind(intent);
  }

  private final IBinder mBinder = new LocalBinder();

  /**
   * Initializes a reference to the local Bluetooth adapter.
   * 
   * @return Return true if the initialization is successful.
   */
  public boolean initialize() {
    // For API level 18 and above, get a reference to BluetoothAdapter
    // through
    // BluetoothManager.
    if (mBluetoothManager == null) {
      mBluetoothManager = (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
      if (mBluetoothManager == null) {
        Log.e(TAG, "Unable to initialize BluetoothManager.");
        return false;
      }
    }

    mBluetoothAdapter = mBluetoothManager.getAdapter();
    if (mBluetoothAdapter == null) {
      Log.e(TAG, "Unable to obtain a BluetoothAdapter.");
      return false;
    }

    return true;
  }

  /**
   * Connects to the GATT server hosted on the Bluetooth LE device.
   * 
   * @param address
   *            The device address of the destination device.
   * 
   * @return Return true if the connection is initiated successfully. The
   *         connection result is reported asynchronously through the
   *         {@code BluetoothGattCallback#onConnectionStateChange(android.bluetooth.BluetoothGatt, int, int)}
   *         callback.
   */
  public boolean connect(final String address) {
    if (mBluetoothAdapter == null || address == null) {
      Log.w(TAG,
          "BluetoothAdapter not initialized or unspecified address.");
      return false;
    }

    // Previously connected device. Try to reconnect.
    if (mBluetoothDeviceAddress != null
        && address.equals(mBluetoothDeviceAddress)
        && mBluetoothGatt != null) {
      Log.d(TAG,
          "Trying to use an existing mBluetoothGatt for connection.");
      if (mBluetoothGatt.connect()) {
        return true;
      } else {
        return false;
      }
    }

    final BluetoothDevice device = mBluetoothAdapter
        .getRemoteDevice(address);
    if (device == null) {
      Log.w(TAG, "Device not found.  Unable to connect.");
      return false;
    }
    // We want to directly connect to the device, so we are setting the
    // autoConnect
    // parameter to false.
    mBluetoothGatt = device.connectGatt(this, false, mGattCallback);
    Log.d(TAG, "Trying to create a new connection.");
    mBluetoothDeviceAddress = address;

    return true;
  }

  /**
   * Disconnects an existing connection or cancel a pending connection. The
   * disconnection result is reported asynchronously through the
   * {@code BluetoothGattCallback#onConnectionStateChange(android.bluetooth.BluetoothGatt, int, int)}
   * callback.
   */
  public void disconnect() {
    if (mBluetoothAdapter == null || mBluetoothGatt == null) {
      Log.w(TAG, "BluetoothAdapter not initialized");
      return;
    }
    mBluetoothGatt.disconnect();
  }

  /**
   * After using a given BLE device, the app must call this method to ensure
   * resources are released properly.
   */
  public void close() {
    if (mBluetoothGatt == null) {
      return;
    }
    mBluetoothGatt.close();
    mBluetoothGatt = null;
  }

  /**
   * Request a read on a given {@code BluetoothGattCharacteristic}. The read
   * result is reported asynchronously through the
   * {@code BluetoothGattCallback#onCharacteristicRead(android.bluetooth.BluetoothGatt, android.bluetooth.BluetoothGattCharacteristic, int)}
   * callback.
   * 
   * @param characteristic
   *            The characteristic to read from.
   */
  public void readCharacteristic(BluetoothGattCharacteristic characteristic) {
    if (mBluetoothAdapter == null || mBluetoothGatt == null) {
      Log.w(TAG, "BluetoothAdapter not initialized");
      return;
    }

    mBluetoothGatt.readCharacteristic(characteristic);
  }

  public void readRssi() {
    if (mBluetoothAdapter == null || mBluetoothGatt == null) {
      Log.w(TAG, "BluetoothAdapter not initialized");
      return;
    }

    mBluetoothGatt.readRemoteRssi();
  }

  public void writeCharacteristic(BluetoothGattCharacteristic characteristic) {
    if (mBluetoothAdapter == null || mBluetoothGatt == null) {
      Log.w(TAG, "BluetoothAdapter not initialized");
      return;
    }

    mBluetoothGatt.writeCharacteristic(characteristic);
  }

  /**
   * Enables or disables notification on a give characteristic.
   * 
   * @param characteristic
   *            Characteristic to act on.
   * @param enabled
   *            If true, enable notification. False otherwise.
   */
  public void setCharacteristicNotification(
      BluetoothGattCharacteristic characteristic, boolean enabled) {
    if (mBluetoothAdapter == null || mBluetoothGatt == null) {
      Log.w(TAG, "BluetoothAdapter not initialized");
      return;
    }
    mBluetoothGatt.setCharacteristicNotification(characteristic, enabled);

    if (UUID_BLE_SHIELD_RX.equals(characteristic.getUuid())) {
      BluetoothGattDescriptor descriptor = characteristic
          .getDescriptor(UUID
              .fromString(RBLGattAttributes.CLIENT_CHARACTERISTIC_CONFIG));
      descriptor
          .setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
      mBluetoothGatt.writeDescriptor(descriptor);
    }
  }

  public BluetoothGattService getSupportedGattService() {
    if (mBluetoothGatt == null)
      return null;

    return mBluetoothGatt.getService(UUID_BLE_SHIELD_SERVICE);
  }
}

Java Source Code List

• Back to App/control  ↑