Ejemplo n.º 1
0
  /** Reads the device info characteristics and updates the UI components */
  private void readDeviceInfoCharacteristics() {
    // Get all readable characteristics and descriptors of interest and add
    // request to a request queue

    BluetoothGattCharacteristic characteristic = null;

    // Get model number
    characteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt, Constants.DEVICE_INFO_SERVICE_UUID, Constants.MODEL_NUMBER_UUID);
    mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);

    // Get manufacturer name
    characteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt,
            Constants.DEVICE_INFO_SERVICE_UUID,
            Constants.MANUFACTURER_NAME_UUID);
    mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);

    // Get system Id
    characteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt, Constants.DEVICE_INFO_SERVICE_UUID, Constants.SYSTEM_ID_UUID);
    mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);
    mRequestQueue.execute();
  }
Ejemplo n.º 2
0
 /** Write the hello input descriptor to the device */
 private void writeHelloInputCharacteristic() {
   // Set the enable/disable notification settings
   BluetoothGattCharacteristic notifyCharacteristic =
       GattUtils.getCharacteristic(
           mPickedDeviceGatt,
           Constants.HELLO_SERVICE_UUID,
           Constants.HELLO_CHARACTERISTIC_INPUT_UUID);
   int notificationState = mSpinnerHelloInput.getSelectedItemPosition();
   if (notificationState >= 0 && notificationState <= 2) {
     BluetoothGattDescriptor descriptor =
         GattUtils.getDescriptor(
             mPickedDeviceGatt,
             Constants.HELLO_SERVICE_UUID,
             Constants.HELLO_CHARACTERISTIC_INPUT_UUID,
             Constants.CLIENT_CONFIG_DESCRIPTOR_UUID);
     if (notificationState > 0) {
       mPickedDeviceGatt.setCharacteristicNotification(notifyCharacteristic, true);
       if (notificationState == 1) {
         descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
       } else if (notificationState == 2) {
         descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
       }
     } else {
       mPickedDeviceGatt.setCharacteristicNotification(notifyCharacteristic, false);
       descriptor.setValue(BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
     }
     mRequestQueue.addWriteDescriptor(mPickedDeviceGatt, descriptor);
     mRequestQueue.execute();
   }
 }
Ejemplo n.º 3
0
 /**
  * Reads the manufacturer name, model number, system id, battery level from the device and updates
  * the UI
  */
 private void readHelloConfigurationCharacteristic() {
   BluetoothGattCharacteristic characteristic = null;
   characteristic =
       GattUtils.getCharacteristic(
           mPickedDeviceGatt,
           Constants.HELLO_SERVICE_UUID,
           Constants.HELLO_CHARACTERISTIC_CONFIGURATION_UUID);
   mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);
   mRequestQueue.execute();
 }
Ejemplo n.º 4
0
  /** Reads the battery characteristics and updates the UI components */
  private void readBatteryCharacteristic() {
    // Get all readable characteristics and descriptors of interest and add
    // request to a request queue

    BluetoothGattCharacteristic characteristic = null;
    // Get battery level
    characteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt, Constants.BATTERY_SERVICE_UUID, Constants.BATTERY_LEVEL_UUID);
    mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);
    mRequestQueue.execute();
  }
Ejemplo n.º 5
0
  /** Reads the hello input characteristic and updates the UI components */
  private void readHelloInputCharacteristic() {
    // Get all readable characteristics and descriptors of interest and add
    // request to a request queue
    BluetoothGattDescriptor descriptor = null;

    // Get client config descriptor: enable/disable notification
    descriptor =
        GattUtils.getDescriptor(
            mPickedDeviceGatt,
            Constants.HELLO_SERVICE_UUID,
            Constants.HELLO_CHARACTERISTIC_INPUT_UUID,
            Constants.CLIENT_CONFIG_DESCRIPTOR_UUID);
    mRequestQueue.addReadDescriptor(mPickedDeviceGatt, descriptor);
    mRequestQueue.execute();
  }
Ejemplo n.º 6
0
  /** Write the hello configuration characteristic to the device */
  private void writeHelloConfigurationCharacteristic() {
    BluetoothGattCharacteristic characteristic = null;

    int blinks = 0;
    try {
      blinks = Integer.parseInt(mEditTextHelloConfiguration.getText().toString());
      characteristic =
          GattUtils.getCharacteristic(
              mPickedDeviceGatt,
              Constants.HELLO_SERVICE_UUID,
              Constants.HELLO_CHARACTERISTIC_CONFIGURATION_UUID);
      characteristic.setValue(blinks, BluetoothGattCharacteristic.FORMAT_UINT8, 0);
      mRequestQueue.addWriteCharacteristic(mPickedDeviceGatt, characteristic);
    } catch (Throwable t) {
      Log.w(TAG, "invalid number of notifications");
      mEditTextHelloConfiguration.setText("0");
    }
    mRequestQueue.addWriteCharacteristic(mPickedDeviceGatt, characteristic);
    mRequestQueue.execute();
  }
Ejemplo n.º 7
0
/** Main activity for the the Hello Client application */
public class MainActivity extends Activity
    implements OnClickListener, Callback, OnItemSelectedListener {
  private static final String TAG = Constants.TAG_PREFIX + "MainActivity";
  private static final String FRAGMENT_DEVICE_PICKER = "DevicePickerDialog";

  // Used to format timestamp for notification entries in the notification
  // view
  private static final SimpleDateFormat mFormatter =
      new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS");

  /**
   * Callback object that the LE Gatt service calls to report callback events that occur
   *
   * @author fredc
   */
  private class GattCallback extends BluetoothGattCallback {

    /** Callback invoked by Android framework and a LE connection state change occurs */
    @Override
    public void onConnectionStateChange(BluetoothGatt gatt, int status, int newState) {
      Log.d(
          MainActivity.TAG,
          "onConnectionStateChange(): address=="
              + gatt.getDevice().getAddress()
              + ", status = "
              + status
              + ", state="
              + newState);
      boolean isConnected = (newState == BluetoothAdapter.STATE_CONNECTED);

      boolean isOk = (status == 0);
      if (isConnected && isOk) {
        // Discover services, and return connection state = connected
        // after services discovered
        isOk = gatt.discoverServices();
        if (isOk) {
          return;
        }
      }

      // If we got here, this is a disconnect with or without error
      // close gatt connection
      if (!isOk) {
        gatt.close();
      }
      processConnectionStateChanged(false, !isOk);
    }

    /** Callback invoked by Android framework when LE service discovery completes */
    @Override
    public void onServicesDiscovered(BluetoothGatt gatt, int status) {
      if (status != 0) {
        // Error occurred. close the ocnnection and return a
        // disconnected status
        gatt.close();
        try {
          processConnectionStateChanged(false, true);
        } catch (Throwable t) {
          Log.e(TAG, "error", t);
        }
      } else {
        try {
          processConnectionStateChanged(true, false);
        } catch (Throwable t) {
          Log.e(TAG, "error", t);
        }
      }
    }

    /** Callback invoked by Android framework when a characteristic read completes */
    @Override
    public void onCharacteristicRead(
        BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
      if (status == 0) {
        try {
          processCharacteristicRead(characteristic);
        } catch (Throwable t) {
          Log.e(TAG, "error", t);
        }
      }
      mRequestQueue.next(); // Execute the next queued request, if
      // any
    }

    /** Callback invoked by Android framework when a descriptor read completes */
    @Override
    public void onDescriptorRead(
        BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
      if (status == 0) {
        try {
          processDescriptorRead(descriptor);
        } catch (Throwable t) {
          Log.e(TAG, "error", t);
        }
      }
      mRequestQueue.next(); // Execute the next queued request, if
      // any
    }

    /** Callback invoked by Android framework when a characteristic notification occurs */
    @Override
    public void onCharacteristicChanged(
        BluetoothGatt gatt, BluetoothGattCharacteristic characteristic) {
      try {
        processCharacteristicNotification(characteristic);
      } catch (Throwable t) {
        Log.e(TAG, "error", t);
      }
    }

    /** Callback invoked by Android framework when a descriptor write completes */
    @Override
    public void onDescriptorWrite(
        BluetoothGatt gatt, BluetoothGattDescriptor descriptor, int status) {
      if (status == 0) {
        try {
          processDescriptorWrite(descriptor);
        } catch (Throwable t) {
          Log.e(TAG, "error", t);
        }
      }

      mRequestQueue.next(); // Execute the next queued request, if any
    }

    /** Callback invoked by Android framework when a characteristic write completes */
    @Override
    public void onCharacteristicWrite(
        BluetoothGatt gatt, BluetoothGattCharacteristic characteristic, int status) {
      super.onCharacteristicWrite(gatt, characteristic, status);
      if (status == 0) {
        try {
          processCharacteristicWrite(characteristic);
        } catch (Throwable t) {
          Log.e(TAG, "error", t);
        }
      }

      mRequestQueue.next(); // Execute the next queued request, if any
    }
  }

  // UI Components
  // Device picker components
  private LinearLayout mButtonSelectDevice; // Button to start device picker
  private DevicePickerFragment mDevicePicker;
  private TextView mTextDeviceName; // Displays device's name
  private TextView mTextDeviceAddress; // Displays device's address

  // Connection components
  private Button mButtonConnect; // Button to connect to a device
  private Button mButtonDisconnect; // Button to connect from a device
  private TextView mTextConnectionState; // Displays current connection state

  // Hello service components
  private TextView mLabelHelloInput;
  private Spinner mSpinnerHelloInput;
  private Button mButtonReadHelloInput;
  private TextView mLabelHelloConfiguration;
  private EditText mEditTextHelloConfiguration;
  private Button mButtonReadHelloConfiguration;
  private Button mButtonWriteHelloConfiguration;

  // Device info service components
  private TextView mTextManufacturerName; // Displays the manufacterer name
  private TextView mTextModelNumber; // Displays the model number
  private TextView mTextSystemId; // Displays the system id
  private Button mButtonReadDeviceInfo; // Button to refresh the device
  // information

  // Battery service components
  private TextView mTextBatteryLevel; // Displays the battery level
  private Button mButtonReadBatteryInfo; // Button to refresh the device
  // information

  // Notification components
  private TextView mTextAreaNotification; // Displays notifications
  private Button mButtonClear; // Button to clear the notifications

  private final GattCallback mGattCallback = new GattCallback();
  private final RequestQueue mRequestQueue = GattUtils.createRequestQueue();
  private BluetoothAdapter mBtAdapter;
  private BluetoothDevice mPickedDevice;
  private BluetoothGatt mPickedDeviceGatt;
  private boolean mPickedDeviceIsConnected;
  private boolean mSyncNotificationSetting;

  /**
   * Helper function to show a toast notification message
   *
   * @param msg
   */
  private void showMessage(String msg) {
    Toast.makeText(this, msg, Toast.LENGTH_SHORT).show();
  }

  /**
   * Check Bluetooth is available and enabled, and initialize Bluetooth adapter
   *
   * @return
   */
  private boolean checkAndInitBluetooth() {
    mBtAdapter = BluetoothAdapter.getDefaultAdapter();
    if (mBtAdapter == null || !mBtAdapter.isEnabled()) {
      return false;
    }
    return true;
  }

  /**
   * Initialize the device picker
   *
   * @return
   */
  private void initDevicePicker() {
    mDevicePicker = DevicePickerFragment.createDialog(this, null, true);
  }

  /** Cleanup the device picker */
  private void cleanupDevicePicker() {
    if (mDevicePicker != null) {
      mDevicePicker = null;
    }
  }

  private void closeDevice() {
    if (mPickedDeviceGatt != null) {
      mPickedDeviceGatt.close();
      mPickedDeviceGatt = null;
    }
  }

  @Override
  public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);

    // Check bluetooth is available. If not, exit
    if (!checkAndInitBluetooth()) {
      showMessage(getString(R.string.error_bluetooth_not_available));
      finish();
      return;
    }

    // Initialize the UI components, and register a listeners
    setContentView(R.layout.main);

    // Load device picker components
    mButtonSelectDevice = (LinearLayout) findViewById(R.id.btn_selectdevice);
    mButtonSelectDevice.setOnClickListener(this);
    mTextDeviceName = (TextView) findViewById(R.id.deviceName);
    mTextDeviceAddress = (TextView) findViewById(R.id.deviceAddress);

    // Load connection components
    mButtonConnect = (Button) findViewById(R.id.btn_connect);
    mButtonConnect.setOnClickListener(this);
    mButtonDisconnect = (Button) findViewById(R.id.btn_disconnect);
    mButtonDisconnect.setOnClickListener(this);
    mTextConnectionState = (TextView) findViewById(R.id.connectionState);

    // Load hello service components
    mLabelHelloInput = (TextView) findViewById(R.id.label_hello_input);
    mLabelHelloInput.setText(
        getString(R.string.label_hello_input, Constants.HELLO_CHARACTERISTIC_INPUT_UUID));
    mSpinnerHelloInput = (Spinner) findViewById(R.id.sp_hello_input);
    mSpinnerHelloInput.setEnabled(false);

    mButtonReadHelloInput = (Button) findViewById(R.id.btn_read_hello_input);
    mButtonReadHelloInput.setOnClickListener(this);

    mLabelHelloConfiguration = (TextView) findViewById(R.id.label_hello_configuration);
    mLabelHelloConfiguration.setText(
        getString(
            R.string.label_hello_configuration, Constants.HELLO_CHARACTERISTIC_CONFIGURATION_UUID));
    mEditTextHelloConfiguration = (EditText) findViewById(R.id.value_hello_configuration);
    mButtonReadHelloConfiguration = (Button) findViewById(R.id.btn_read_hello_configuration);
    mButtonReadHelloConfiguration.setOnClickListener(this);
    mButtonWriteHelloConfiguration = (Button) findViewById(R.id.btn_write_hello_configuration);
    mButtonWriteHelloConfiguration.setOnClickListener(this);

    // Load device info components
    mTextManufacturerName = (TextView) findViewById(R.id.value_manufacturer_name);
    mTextModelNumber = (TextView) findViewById(R.id.value_model_number);
    mTextSystemId = (TextView) findViewById(R.id.value_system_id);
    mButtonReadDeviceInfo = (Button) findViewById(R.id.btn_read_device_info);
    mButtonReadDeviceInfo.setOnClickListener(this);

    // Load battery info components
    mTextBatteryLevel = (TextView) findViewById(R.id.value_battery_lvel);
    mButtonReadBatteryInfo = (Button) findViewById(R.id.btn_read_battery);
    mButtonReadBatteryInfo.setOnClickListener(this);

    // Load notification components
    mTextAreaNotification = (TextView) findViewById(R.id.value_notifications);
    mTextAreaNotification.setMovementMethod(ScrollingMovementMethod.getInstance());
    mButtonClear = (Button) findViewById(R.id.btn_clear);
    mButtonClear.setOnClickListener(this);

    // Initialize the device picker UI fragment
    initDevicePicker();

    // refresh the UI component states
    updateWidgets();
  }

  /** Updates the UI widgets based on the latest connection state */
  private void updateWidgets() {
    if (mPickedDevice == null) {
      // No devices selected: set initial state
      mButtonConnect.setEnabled(false);
      mButtonDisconnect.setEnabled(false);
      mButtonSelectDevice.setEnabled(true);
      mTextDeviceName.setText(R.string.no_device);
      mTextDeviceAddress.setText("");
    } else {
      // Device picked, always set the connect/disconnect buttons enabled
      mButtonConnect.setEnabled(true);
      mButtonDisconnect.setEnabled(true);

      if (mPickedDeviceIsConnected) {
        // Set resources when connected

        // Disable selecting new device when connected
        mButtonSelectDevice.setEnabled(false);

        // Set the connection state status
        mTextConnectionState.setText(getString(R.string.connected));

        // Update hello service components
        mSpinnerHelloInput.setEnabled(true);
        mSpinnerHelloInput.setOnItemSelectedListener(this);
        mButtonReadHelloInput.setEnabled(true);
        mEditTextHelloConfiguration.setEnabled(true);
        mButtonReadHelloConfiguration.setEnabled(true);
        mButtonWriteHelloConfiguration.setEnabled(true);

        // Update device info components
        mButtonReadDeviceInfo.setEnabled(true);

        // Update battery components
        mButtonReadBatteryInfo.setEnabled(true);

        // Update notification components
        mTextAreaNotification.setEnabled(true);
        mButtonClear.setEnabled(true);

      } else {
        // Update resources when disconnected

        // Enable selecting new device when connected
        mButtonSelectDevice.setEnabled(true);

        // Set the connection state status
        mTextConnectionState.setText(getString(R.string.disconnected));

        // Update hello service components
        mSpinnerHelloInput.setEnabled(false);
        mSpinnerHelloInput.setOnItemSelectedListener(null);
        mSpinnerHelloInput.setSelection(0);
        mButtonReadHelloInput.setEnabled(false);

        mEditTextHelloConfiguration.setEnabled(false);
        mEditTextHelloConfiguration.setText("");
        mButtonReadHelloConfiguration.setEnabled(false);
        mButtonWriteHelloConfiguration.setEnabled(false);

        // Update device info components
        mButtonReadDeviceInfo.setEnabled(false);
        mTextManufacturerName.setText(R.string.no_value);
        mTextModelNumber.setText(R.string.no_value);
        mTextSystemId.setText(R.string.no_value);

        // Update battery components
        mButtonReadBatteryInfo.setEnabled(false);
        mTextBatteryLevel.setText(R.string.no_value);

        // Update notification components
        mTextAreaNotification.setEnabled(false);
        mTextAreaNotification.setText("");
        mButtonClear.setEnabled(false);
      }
    }
  }

  @Override
  public void onDestroy() {
    closeDevice();
    cleanupDevicePicker();
    super.onDestroy();
  }

  /** Callback invoked when buttons/switches clicked */
  @Override
  public void onClick(View v) {
    if (v == mButtonSelectDevice) {
      // Start the device selector
      mDevicePicker.show(getFragmentManager(), FRAGMENT_DEVICE_PICKER);
    } else if (v == mButtonConnect) {
      // Start device connection
      connect();
    } else if (v == mButtonDisconnect) {
      // Start device disconnect
      disconnect();
    } else if (v == mButtonReadDeviceInfo) {
      // Start reading the device information characteristics
      readDeviceInfoCharacteristics();
    } else if (v == mButtonReadBatteryInfo) {
      // Start reading the battery characteristics
      readBatteryCharacteristic();
    } else if (v == mButtonReadHelloConfiguration) {
      // Start reading the hello configuration characteristics
    } else if (v == mButtonWriteHelloConfiguration) {
      // Start writing the hello configuration characteristics
      writeHelloConfigurationCharacteristic();
    } else if (v == mButtonReadHelloInput) {
      // Start reading hello input descriptors
      readHelloInputCharacteristic();
    } else if (v == mButtonClear) {
      // Clear the notification area
      mTextAreaNotification.setText("");
    }
  }

  /**
   * Called when the hello input is selected by user
   *
   * @param view
   * @param view2
   * @param pos
   * @param id
   */
  @Override
  public void onItemSelected(AdapterView<?> view, View view2, int pos, long id) {
    if (view == mSpinnerHelloInput) {
      // Update the input characteristic on the device
      writeHelloInputCharacteristic();
    }
  }

  /** Called when no hello input is selected */
  @Override
  public void onNothingSelected(AdapterView<?> view) {}

  /**
   * Callback invoked when a device was picked from the device picker
   *
   * @param device
   */
  @Override
  public void onDevicePicked(BluetoothDevice device) {
    Log.d(TAG, "onDevicePicked: " + device == null ? "" : device.getAddress());
    // Close any outstanding connections to remote devices
    closeDevice();

    // Get the remote device object
    String address = device.getAddress();
    mPickedDevice = mBtAdapter.getRemoteDevice(address);

    // Get the name
    String name = mPickedDevice.getName();
    if (name == null || name.isEmpty()) {
      name = address;
    }

    // Set UI resources
    mTextDeviceName.setText(name);
    mTextDeviceAddress.setText(address);
    // Update the connect widget
    mButtonConnect.setEnabled(true);
    mButtonDisconnect.setEnabled(true);
  }

  /** Callback invoked when a devicepicker was dismissed without a device picked */
  @Override
  public void onDevicePickError() {
    Log.d(TAG, "onDevicePickError");
  }

  /** Callback invoked when a devicepicker encountered an unexpected error */
  @Override
  public void onDevicePickCancelled() {
    Log.d(TAG, "onDevicePickCancelled");
  }

  /** Connect to the picked device */
  private void connect() {
    if (mPickedDevice == null) {
      showMessage(
          getString(R.string.error_connect, mPickedDevice.getName(), mPickedDevice.getAddress()));
      return;
    }

    mPickedDeviceGatt = mPickedDevice.connectGatt(this, false, mGattCallback);

    if (mPickedDeviceGatt == null) {
      showMessage(
          getString(R.string.error_connect, mPickedDevice.getName(), mPickedDevice.getAddress()));
    }
  }

  /** Disconnects the picked device */
  private void disconnect() {
    if (mPickedDeviceGatt != null) {
      mPickedDeviceGatt.disconnect();
      closeDevice();
    }
  }

  /**
   * Called when a gatt connection state changes. This function updates the UI
   *
   * @param gatt
   */
  private void processConnectionStateChanged(final boolean isConnected, final boolean hasError) {
    runOnUiThread(
        new Runnable() {

          @Override
          public void run() {
            if (hasError) {
              showMessage(
                  getString(
                      R.string.error_connect, mPickedDevice.getName(), mPickedDevice.getAddress()));
            }
            mPickedDeviceIsConnected = isConnected;
            updateWidgets();

            // Refresh the device information
            if (mPickedDeviceIsConnected) {
              mSyncNotificationSetting = true;
              readEverything();
            }
          }
        });
  }

  /** Reads the device info characteristics and updates the UI components */
  private void readDeviceInfoCharacteristics() {
    // Get all readable characteristics and descriptors of interest and add
    // request to a request queue

    BluetoothGattCharacteristic characteristic = null;

    // Get model number
    characteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt, Constants.DEVICE_INFO_SERVICE_UUID, Constants.MODEL_NUMBER_UUID);
    mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);

    // Get manufacturer name
    characteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt,
            Constants.DEVICE_INFO_SERVICE_UUID,
            Constants.MANUFACTURER_NAME_UUID);
    mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);

    // Get system Id
    characteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt, Constants.DEVICE_INFO_SERVICE_UUID, Constants.SYSTEM_ID_UUID);
    mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);
    mRequestQueue.execute();
  }

  /** Reads the battery characteristics and updates the UI components */
  private void readBatteryCharacteristic() {
    // Get all readable characteristics and descriptors of interest and add
    // request to a request queue

    BluetoothGattCharacteristic characteristic = null;
    // Get battery level
    characteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt, Constants.BATTERY_SERVICE_UUID, Constants.BATTERY_LEVEL_UUID);
    mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);
    mRequestQueue.execute();
  }

  /** Reads the hello input characteristic and updates the UI components */
  private void readHelloInputCharacteristic() {
    // Get all readable characteristics and descriptors of interest and add
    // request to a request queue
    BluetoothGattDescriptor descriptor = null;

    // Get client config descriptor: enable/disable notification
    descriptor =
        GattUtils.getDescriptor(
            mPickedDeviceGatt,
            Constants.HELLO_SERVICE_UUID,
            Constants.HELLO_CHARACTERISTIC_INPUT_UUID,
            Constants.CLIENT_CONFIG_DESCRIPTOR_UUID);
    mRequestQueue.addReadDescriptor(mPickedDeviceGatt, descriptor);
    mRequestQueue.execute();
  }

  /**
   * Reads the manufacturer name, model number, system id, battery level from the device and updates
   * the UI
   */
  private void readHelloConfigurationCharacteristic() {
    BluetoothGattCharacteristic characteristic = null;
    characteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt,
            Constants.HELLO_SERVICE_UUID,
            Constants.HELLO_CHARACTERISTIC_CONFIGURATION_UUID);
    mRequestQueue.addReadCharacteristic(mPickedDeviceGatt, characteristic);
    mRequestQueue.execute();
  }

  /** Read every characteristic on the device */
  private void readEverything() {
    readDeviceInfoCharacteristics();
    readBatteryCharacteristic();
    readHelloConfigurationCharacteristic();
    readHelloInputCharacteristic();
  }

  /** Write the hello configuration characteristic to the device */
  private void writeHelloConfigurationCharacteristic() {
    BluetoothGattCharacteristic characteristic = null;

    int blinks = 0;
    try {
      blinks = Integer.parseInt(mEditTextHelloConfiguration.getText().toString());
      characteristic =
          GattUtils.getCharacteristic(
              mPickedDeviceGatt,
              Constants.HELLO_SERVICE_UUID,
              Constants.HELLO_CHARACTERISTIC_CONFIGURATION_UUID);
      characteristic.setValue(blinks, BluetoothGattCharacteristic.FORMAT_UINT8, 0);
      mRequestQueue.addWriteCharacteristic(mPickedDeviceGatt, characteristic);
    } catch (Throwable t) {
      Log.w(TAG, "invalid number of notifications");
      mEditTextHelloConfiguration.setText("0");
    }
    mRequestQueue.addWriteCharacteristic(mPickedDeviceGatt, characteristic);
    mRequestQueue.execute();
  }

  /** Write the hello input descriptor to the device */
  private void writeHelloInputCharacteristic() {
    // Set the enable/disable notification settings
    BluetoothGattCharacteristic notifyCharacteristic =
        GattUtils.getCharacteristic(
            mPickedDeviceGatt,
            Constants.HELLO_SERVICE_UUID,
            Constants.HELLO_CHARACTERISTIC_INPUT_UUID);
    int notificationState = mSpinnerHelloInput.getSelectedItemPosition();
    if (notificationState >= 0 && notificationState <= 2) {
      BluetoothGattDescriptor descriptor =
          GattUtils.getDescriptor(
              mPickedDeviceGatt,
              Constants.HELLO_SERVICE_UUID,
              Constants.HELLO_CHARACTERISTIC_INPUT_UUID,
              Constants.CLIENT_CONFIG_DESCRIPTOR_UUID);
      if (notificationState > 0) {
        mPickedDeviceGatt.setCharacteristicNotification(notifyCharacteristic, true);
        if (notificationState == 1) {
          descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
        } else if (notificationState == 2) {
          descriptor.setValue(BluetoothGattDescriptor.ENABLE_INDICATION_VALUE);
        }
      } else {
        mPickedDeviceGatt.setCharacteristicNotification(notifyCharacteristic, false);
        descriptor.setValue(BluetoothGattDescriptor.DISABLE_NOTIFICATION_VALUE);
      }
      mRequestQueue.addWriteDescriptor(mPickedDeviceGatt, descriptor);
      mRequestQueue.execute();
    }
  }

  /**
   * Callback invoked by the Android framework when a read characteristic successfully completes
   *
   * @param characteristic
   */
  private void processCharacteristicRead(final BluetoothGattCharacteristic characteristic) {
    runOnUiThread(
        new Runnable() {

          @Override
          public void run() {
            UUID uuid = characteristic.getUuid();
            if (Constants.MANUFACTURER_NAME_UUID.equals(uuid)) {
              mTextManufacturerName.setText(characteristic.getStringValue(0));
            } else if (Constants.MODEL_NUMBER_UUID.equals(uuid)) {
              mTextModelNumber.setText(characteristic.getStringValue(0));
            } else if (Constants.SYSTEM_ID_UUID.equals(uuid)) {
              byte[] systemIdBytes = characteristic.getValue();
              long systemIdLong = GattUtils.unsignedBytesToLong(systemIdBytes, 8, 0);
              long manuId = 0xFFFFFFFFFFL & systemIdLong; // 40bits
              long orgId = 0xFFFFFFL & (systemIdLong >> 40);
              String manuIdString = String.format("%010X", manuId);
              String orgIdString = String.format("%06X", orgId);
              mTextSystemId.setText(orgIdString + " " + manuIdString);
            } else if (Constants.BATTERY_LEVEL_UUID.equals(uuid)) {
              int batteryLevel =
                  characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, 0);
              mTextBatteryLevel.setText(String.valueOf(batteryLevel));
            } else if (Constants.HELLO_CHARACTERISTIC_CONFIGURATION_UUID.equals(uuid)) {
              int blinks = characteristic.getIntValue(BluetoothGattCharacteristic.FORMAT_UINT8, 0);
              mEditTextHelloConfiguration.setText(String.valueOf(blinks));
            }
          }
        });
  }

  /**
   * Callback invoked by the Android framework when a read descriptor successfully completes
   *
   * @param descriptor
   */
  private void processDescriptorRead(final BluetoothGattDescriptor descriptor) {
    runOnUiThread(
        new Runnable() {

          @Override
          public void run() {
            UUID uuid = descriptor.getUuid();
            if (Constants.CLIENT_CONFIG_DESCRIPTOR_UUID.equals(uuid)) {
              byte[] descriptorBytes = descriptor.getValue();
              int notificationState = (int) GattUtils.unsignedBytesToLong(descriptorBytes, 2, 0);
              Log.d(TAG, "notificationState = " + notificationState);
              if (notificationState >= 0 && notificationState <= 2) {
                // Temporarily disable the spinner listener when we set
                // the selection
                mSpinnerHelloInput.setOnItemSelectedListener(null);
                mSpinnerHelloInput.setSelection(notificationState);
                // Re-enable the spinner listener
                mSpinnerHelloInput.setOnItemSelectedListener(MainActivity.this);
              }
              if (mSyncNotificationSetting && notificationState > 0) {
                // On initial connection, mSyncNotificationSetting is
                // set to indicate that we should set characteristic
                // notification if the descriptor is set
                mSyncNotificationSetting = false;
                BluetoothGattCharacteristic notifyCharacteristic =
                    GattUtils.getCharacteristic(
                        mPickedDeviceGatt,
                        Constants.HELLO_SERVICE_UUID,
                        Constants.HELLO_CHARACTERISTIC_INPUT_UUID);
                mPickedDeviceGatt.setCharacteristicNotification(notifyCharacteristic, true);
              }
            }
          }
        });
  }

  /**
   * Callback invoked by the Android framework when a write descriptor successfully completes
   *
   * @param descriptor
   */
  private void processDescriptorWrite(final BluetoothGattDescriptor descriptor) {
    runOnUiThread(
        new Runnable() {

          @Override
          public void run() {
            readEverything();
          }
        });
  }

  /**
   * Callback invoked by the Android framework when a write characteristic successfully completes
   *
   * @param characteristic
   */
  private void processCharacteristicWrite(final BluetoothGattCharacteristic characteristic) {
    runOnUiThread(
        new Runnable() {

          @Override
          public void run() {
            readEverything();
          }
        });
  }

  /**
   * Callback invoked by the Android framework when a characteristic notification is received
   *
   * @param characteristic
   */
  private void processCharacteristicNotification(final BluetoothGattCharacteristic characteristic) {
    runOnUiThread(
        new Runnable() {

          @Override
          public void run() {
            String s = characteristic.getStringValue(0);

            // Write a entry to the log viewer: "timestamp value"
            mTextAreaNotification.append(mFormatter.format(Calendar.getInstance().getTime()));
            mTextAreaNotification.append(" ");
            mTextAreaNotification.append(s);
            mTextAreaNotification.append("\n");

            // Auto scroll to the bottom
            Layout l = mTextAreaNotification.getLayout();
            if (l != null) {
              int scrollAmount =
                  l.getLineTop(mTextAreaNotification.getLineCount())
                      - mTextAreaNotification.getHeight();
              // if there is no need to scroll, scrollAmount will be <=0
              if (scrollAmount > 0) mTextAreaNotification.scrollTo(0, scrollAmount);
              else mTextAreaNotification.scrollTo(0, 0);
            }
          }
        });
  }
}