title: BluetoothLE BluetoothAdapter﹕ startLeScan(): null
body: <p><strong>Bluetooth LE</strong> introduced with <code>Android 4.3</code>, therefore i am using two Android devices and my both devices <code>supports</code> API Version <strong>4.4.2</strong></p>
  
  <p>Even, I already paired both the devices, but still not showing device in a List, see below screenshot</p>
  
  <p><img src="https://i.stack.imgur.com/0BOZp.jpg" alt="enter image description here"></p>
  
  <p>I have tried with both the ways:</p>
  
  <pre><code>&lt;uses-feature android:name="android.hardware.bluetooth_le" android:required="true"/&gt;
  </code></pre>
  
  <p><strong>and</strong></p>
  
  <pre><code>&lt;uses-feature android:name="android.hardware.bluetooth_le" android:required="false"/&gt;
  </code></pre>
  
  <p><strong>Log says:</strong></p>
  
  <pre><code>07-16 17:26:15.146    3857-3857/com.example.android.bluetoothlegatt D/dalvikvm﹕ Late-enabling CheckJNI
  07-16 17:26:15.146    3857-3857/com.example.android.bluetoothlegatt D/dalvikvm﹕ Try to disable coredump for pid 3857
  07-16 17:26:15.146    3857-3857/com.example.android.bluetoothlegatt D/dalvikvm﹕ Process 3857 nice name: com.example.android.bluetoothlegatt
  07-16 17:26:15.146    3857-3857/com.example.android.bluetoothlegatt D/dalvikvm﹕ Extra Options: not specified
  07-16 17:26:15.246    3857-3857/com.example.android.bluetoothlegatt D/BluetoothAdapter﹕ startLeScan(): null
  07-16 17:26:15.276    3857-3869/com.example.android.bluetoothlegatt D/BluetoothAdapter﹕ onClientRegistered() - status=0 clientIf=5
  07-16 17:26:15.296    3857-3857/com.example.android.bluetoothlegatt E/IMGSRV﹕ :0: PVRDRMOpen: TP3, ret = 50
  07-16 17:26:15.306    3857-3857/com.example.android.bluetoothlegatt E/IMGSRV﹕ :0: PVRDRMOpen: TP3, ret = 53
  07-16 17:26:15.306    3857-3857/com.example.android.bluetoothlegatt E/IMGSRV﹕ :0: PVRDRMOpen: TP3, ret = 54
  07-16 17:26:15.306    3857-3857/com.example.android.bluetoothlegatt E/IMGSRV﹕ :0: PVRDRMOpen: TP3, ret = 54
  07-16 17:26:15.306    3857-3857/com.example.android.bluetoothlegatt E/IMGSRV﹕ :0: PVRDRMOpen: TP3, ret = 54
  07-16 17:26:15.306    3857-3857/com.example.android.bluetoothlegatt E/IMGSRV﹕ :0: PVRDRMOpen: TP3, ret = 56
  07-16 17:26:15.346    3857-3857/com.example.android.bluetoothlegatt D/OpenGLRenderer﹕ Enabling debug mode 0
  07-16 17:26:25.246    3857-3857/com.example.android.bluetoothlegatt D/BluetoothAdapter﹕ stopLeScan()
  </code></pre>
  
  <p>Code:</p>
  
  <p><strong>BluetoothLeService.java:-</strong></p>
  
  <pre><code>public class BluetoothLeService extends Service {
      .......
      public final static UUID UUID_HEART_RATE_MEASUREMENT =
              UUID.fromString(SampleGattAttributes.HEART_RATE_MEASUREMENT);
  
      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;
                  mConnectionState = STATE_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;
                  mConnectionState = STATE_DISCONNECTED;
                  Log.i(TAG, "Disconnected from GATT server.");
                  broadcastUpdate(intentAction);
              }
          }
  
          @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,
                                   final BluetoothGattCharacteristic characteristic) {
          final Intent intent = new Intent(action);
  
          if (UUID_HEART_RATE_MEASUREMENT.equals(characteristic.getUuid())) {
              int flag = characteristic.getProperties();
              int format = -1;
              if ((flag &amp; 0x01) != 0) {
                  format = BluetoothGattCharacteristic.FORMAT_UINT16;
                  Log.d(TAG, "Heart rate format UINT16.");
              } else {
                  format = BluetoothGattCharacteristic.FORMAT_UINT8;
                  Log.d(TAG, "Heart rate format UINT8.");
              }
              final int heartRate = characteristic.getIntValue(format, 1);
              Log.d(TAG, String.format("Received heart rate: %d", heartRate));
              intent.putExtra(EXTRA_DATA, String.valueOf(heartRate));
          } else {
              // For all other profiles, writes the data formatted in HEX.
              final byte[] data = characteristic.getValue();
              if (data != null &amp;&amp; data.length &gt; 0) {
                  final StringBuilder stringBuilder = new StringBuilder(data.length);
                  for(byte byteChar : data)
                      stringBuilder.append(String.format("%02X ", byteChar));
                  intent.putExtra(EXTRA_DATA, new String(data) + "\n" + stringBuilder.toString());
              }
          }
          sendBroadcast(intent);
      }
  
      public class LocalBinder extends Binder {
          BluetoothLeService getService() {
              return BluetoothLeService.this;
          }
      }
  
      @Override
      public IBinder onBind(Intent intent) {
          return mBinder;
      }
  
      @Override
      public boolean onUnbind(Intent intent) {
          close();
          return super.onUnbind(intent);
      }
  
      private final IBinder mBinder = new LocalBinder();
  
      public boolean initialize() {
          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;
      }
  
      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 &amp;&amp; address.equals(mBluetoothDeviceAddress)
                  &amp;&amp; mBluetoothGatt != null) {
              Log.d(TAG, "Trying to use an existing mBluetoothGatt for connection.");
              if (mBluetoothGatt.connect()) {
                  mConnectionState = STATE_CONNECTING;
                  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;
          mConnectionState = STATE_CONNECTING;
          return true;
      }
  
     public void disconnect() {
          if (mBluetoothAdapter == null || mBluetoothGatt == null) {
              Log.w(TAG, "BluetoothAdapter not initialized");
              return;
          }
          mBluetoothGatt.disconnect();
      }
  
      public void close() {
          if (mBluetoothGatt == null) {
              return;
          }
          mBluetoothGatt.close();
          mBluetoothGatt = null;
      }
  
      public void readCharacteristic(BluetoothGattCharacteristic characteristic) {
          if (mBluetoothAdapter == null || mBluetoothGatt == null) {
              Log.w(TAG, "BluetoothAdapter not initialized");
              return;
          }
          mBluetoothGatt.readCharacteristic(characteristic);
      }
  
      public void setCharacteristicNotification(BluetoothGattCharacteristic characteristic,
                                                boolean enabled) {
          if (mBluetoothAdapter == null || mBluetoothGatt == null) {
              Log.w(TAG, "BluetoothAdapter not initialized");
              return;
          }
          mBluetoothGatt.setCharacteristicNotification(characteristic, enabled);
  
          // This is specific to Heart Rate Measurement.
          if (UUID_HEART_RATE_MEASUREMENT.equals(characteristic.getUuid())) {
              BluetoothGattDescriptor descriptor = characteristic.getDescriptor(
                      UUID.fromString(SampleGattAttributes.CLIENT_CHARACTERISTIC_CONFIG));
              descriptor.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE);
              mBluetoothGatt.writeDescriptor(descriptor);
          }
      }
  
      public List&lt;BluetoothGattService&gt; getSupportedGattServices() {
          if (mBluetoothGatt == null) return null;
  
          return mBluetoothGatt.getServices();
      }
  }
  </code></pre>
  
  <p><strong>DeviceScanActivity.java:</strong></p>
  
  <pre><code>public class DeviceScanActivity extends ListActivity {
      ......
  
      @Override
      public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          getActionBar().setTitle(R.string.title_devices);
          mHandler = new Handler();
  
  
          if (!getPackageManager().hasSystemFeature(PackageManager.FEATURE_BLUETOOTH_LE)) {
              Toast.makeText(this, R.string.ble_not_supported, Toast.LENGTH_SHORT).show();
              finish();
          }
  
          final BluetoothManager bluetoothManager =
                  (BluetoothManager) getSystemService(Context.BLUETOOTH_SERVICE);
          mBluetoothAdapter = bluetoothManager.getAdapter();
  
          if (mBluetoothAdapter == null) {
              Toast.makeText(this, R.string.error_bluetooth_not_supported, Toast.LENGTH_SHORT).show();
              finish();
              return;
          }
      }
  
      @Override
      public boolean onCreateOptionsMenu(Menu menu) {
          getMenuInflater().inflate(R.menu.main, menu);
          if (!mScanning) {
              menu.findItem(R.id.menu_stop).setVisible(false);
              menu.findItem(R.id.menu_scan).setVisible(true);
              menu.findItem(R.id.menu_refresh).setActionView(null);
          } else {
              menu.findItem(R.id.menu_stop).setVisible(true);
              menu.findItem(R.id.menu_scan).setVisible(false);
              menu.findItem(R.id.menu_refresh).setActionView(
                      R.layout.actionbar_indeterminate_progress);
          }
          return true;
      }
  
      @Override
      public boolean onOptionsItemSelected(MenuItem item) {
          switch (item.getItemId()) {
              case R.id.menu_scan:
                  mLeDeviceListAdapter.clear();
                  scanLeDevice(true);
                  break;
              case R.id.menu_stop:
                  scanLeDevice(false);
                  break;
          }
          return true;
      }
  
      @Override
      protected void onResume() {
          super.onResume();
          if (!mBluetoothAdapter.isEnabled()) {
              if (!mBluetoothAdapter.isEnabled()) {
                  Intent enableBtIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
                  startActivityForResult(enableBtIntent, REQUEST_ENABLE_BT);
              }
          }
  
          // Initializes list view adapter.
          mLeDeviceListAdapter = new LeDeviceListAdapter();
          setListAdapter(mLeDeviceListAdapter);
          scanLeDevice(true);
      }
  
      @Override
      protected void onActivityResult(int requestCode, int resultCode, Intent data) {
          if (requestCode == REQUEST_ENABLE_BT &amp;&amp; resultCode == Activity.RESULT_CANCELED) {
              finish();
              return;
          }
          super.onActivityResult(requestCode, resultCode, data);
      }
  
      @Override
      protected void onPause() {
          super.onPause();
          scanLeDevice(false);
          mLeDeviceListAdapter.clear();
      }
  
      @Override
      protected void onListItemClick(ListView l, View v, int position, long id) {
          ....
          startActivity(intent);
      }
  
      private void scanLeDevice(final boolean enable) {
          if (enable) {
              mHandler.postDelayed(new Runnable() {
                  @Override
                  public void run() {
                      mScanning = false;
                      mBluetoothAdapter.stopLeScan(mLeScanCallback);
                      invalidateOptionsMenu();
                  }
              }, SCAN_PERIOD);
  
              mScanning = true;
              mBluetoothAdapter.startLeScan(mLeScanCallback);
          } else {
              mScanning = false;
              mBluetoothAdapter.stopLeScan(mLeScanCallback);
          }
          invalidateOptionsMenu();
      }
  
      private class LeDeviceListAdapter extends BaseAdapter {
          private ArrayList&lt;BluetoothDevice&gt; mLeDevices;
          private LayoutInflater mInflator;
  
          public LeDeviceListAdapter() {
              super();
              mLeDevices = new ArrayList&lt;BluetoothDevice&gt;();
              mInflator = DeviceScanActivity.this.getLayoutInflater();
          }
  
          public void addDevice(BluetoothDevice device) {
              if(!mLeDevices.contains(device)) {
                  mLeDevices.add(device);
              }
          }
  
          public BluetoothDevice getDevice(int position) {
              return mLeDevices.get(position);
          }
  
          public void clear() {
              mLeDevices.clear();
          }
  
          @Override
          public int getCount() {
              return mLeDevices.size();
          }
  
          @Override
          public Object getItem(int i) {
              return mLeDevices.get(i);
          }
  
          @Override
          public long getItemId(int i) {
              return i;
          }
  
          @Override
          public View getView(int i, View view, ViewGroup viewGroup) {
              ViewHolder viewHolder;
              // General ListView optimization code.
              if (view == null) {
                  view = mInflator.inflate(R.layout.listitem_device, null);
                  viewHolder = new ViewHolder();
                  viewHolder.deviceAddress = (TextView) view.findViewById(R.id.device_address);
                  viewHolder.deviceName = (TextView) view.findViewById(R.id.device_name);
                  view.setTag(viewHolder);
              } else {
                  viewHolder = (ViewHolder) view.getTag();
              }
  
              BluetoothDevice device = mLeDevices.get(i);
              final String deviceName = device.getName();
              if (deviceName != null &amp;&amp; deviceName.length() &gt; 0)
                  viewHolder.deviceName.setText(deviceName);
              else
                  viewHolder.deviceName.setText(R.string.unknown_device);
              viewHolder.deviceAddress.setText(device.getAddress());
  
              return view;
          }
      }
  
      // Device scan callback.
      private BluetoothAdapter.LeScanCallback mLeScanCallback =
              new BluetoothAdapter.LeScanCallback() {
  
          @Override
          public void onLeScan(final BluetoothDevice device, int rssi, byte[] scanRecord) {
              runOnUiThread(new Runnable() {
                  @Override
                  public void run() {
                      mLeDeviceListAdapter.addDevice(device);
                      mLeDeviceListAdapter.notifyDataSetChanged();
                  }
              });
          }
      };
  .....
  }
  </code></pre>
  
  <p><strong>DeviceControlActivity.java:</strong></p>
  
  <pre><code>    public class DeviceControlActivity extends Activity {
      ........
  
      private final ServiceConnection mServiceConnection = new ServiceConnection() {
  
          @Override
          public void onServiceConnected(ComponentName componentName, IBinder service) {
              mBluetoothLeService = ((BluetoothLeService.LocalBinder) service).getService();
              if (!mBluetoothLeService.initialize()) {
                  Log.e(TAG, "Unable to initialize Bluetooth");
                  finish();
              }
  
              mBluetoothLeService.connect(mDeviceAddress);
          }
  
          @Override
          public void onServiceDisconnected(ComponentName componentName) {
              mBluetoothLeService = null;
          }
      };
  
     private final BroadcastReceiver mGattUpdateReceiver = new BroadcastReceiver() {
          @Override
          public void onReceive(Context context, Intent intent) {
              final String action = intent.getAction();
              if (BluetoothLeService.ACTION_GATT_CONNECTED.equals(action)) {
                  mConnected = true;
                  updateConnectionState(R.string.connected);
                  invalidateOptionsMenu();
              } else if (BluetoothLeService.ACTION_GATT_DISCONNECTED.equals(action)) {
                  mConnected = false;
                  updateConnectionState(R.string.disconnected);
                  invalidateOptionsMenu();
                  clearUI();
              } else if (BluetoothLeService.ACTION_GATT_SERVICES_DISCOVERED.equals(action)) {
                  // Show all the supported services and characteristics on the user interface.
                  displayGattServices(mBluetoothLeService.getSupportedGattServices());
              } else if (BluetoothLeService.ACTION_DATA_AVAILABLE.equals(action)) {
                  displayData(intent.getStringExtra(BluetoothLeService.EXTRA_DATA));
              }
          }
      };
  
      private final ExpandableListView.OnChildClickListener servicesListClickListner =
              new ExpandableListView.OnChildClickListener() {
                  @Override
                  public boolean onChildClick(ExpandableListView parent, View v, int groupPosition,
                                              int childPosition, long id) {
                      if (mGattCharacteristics != null) {
                          final BluetoothGattCharacteristic characteristic =
                                  mGattCharacteristics.get(groupPosition).get(childPosition);
                          final int charaProp = characteristic.getProperties();
                          if ((charaProp | BluetoothGattCharacteristic.PROPERTY_READ) &gt; 0) {
                              // If there is an active notification on a characteristic, clear
                              // it first so it doesn't update the data field on the user interface.
                              if (mNotifyCharacteristic != null) {
                                  mBluetoothLeService.setCharacteristicNotification(
                                          mNotifyCharacteristic, false);
                                  mNotifyCharacteristic = null;
                              }
                              mBluetoothLeService.readCharacteristic(characteristic);
                          }
                          if ((charaProp | BluetoothGattCharacteristic.PROPERTY_NOTIFY) &gt; 0) {
                              mNotifyCharacteristic = characteristic;
                              mBluetoothLeService.setCharacteristicNotification(
                                      characteristic, true);
                          }
                          return true;
                      }
                      return false;
                  }
      };
  
      private void clearUI() {
          mGattServicesList.setAdapter((SimpleExpandableListAdapter) null);
          mDataField.setText(R.string.no_data);
      }
  
      @Override
      public void onCreate(Bundle savedInstanceState) {
          super.onCreate(savedInstanceState);
          setContentView(R.layout.gatt_services_characteristics);
  
          final Intent intent = getIntent();
          mDeviceName = intent.getStringExtra(EXTRAS_DEVICE_NAME);
          mDeviceAddress = intent.getStringExtra(EXTRAS_DEVICE_ADDRESS);
  
          ((TextView) findViewById(R.id.device_address)).setText(mDeviceAddress);
          mGattServicesList = (ExpandableListView) findViewById(R.id.gatt_services_list);
          mGattServicesList.setOnChildClickListener(servicesListClickListner);
          mConnectionState = (TextView) findViewById(R.id.connection_state);
          mDataField = (TextView) findViewById(R.id.data_value);
  
          getActionBar().setTitle(mDeviceName);
          getActionBar().setDisplayHomeAsUpEnabled(true);
          Intent gattServiceIntent = new Intent(this, BluetoothLeService.class);
          bindService(gattServiceIntent, mServiceConnection, BIND_AUTO_CREATE);
      }
  
      @Override
      protected void onResume() {
          super.onResume();
          registerReceiver(mGattUpdateReceiver, makeGattUpdateIntentFilter());
          if (mBluetoothLeService != null) {
              final boolean result = mBluetoothLeService.connect(mDeviceAddress);
              Log.d(TAG, "Connect request result=" + result);
          }
      }
  
      @Override
      protected void onPause() {
          super.onPause();
          unregisterReceiver(mGattUpdateReceiver);
      }
  
      @Override
      protected void onDestroy() {
          super.onDestroy();
          unbindService(mServiceConnection);
          mBluetoothLeService = null;
      }
  
      @Override
      public boolean onCreateOptionsMenu(Menu menu) {
          getMenuInflater().inflate(R.menu.gatt_services, menu);
          if (mConnected) {
              menu.findItem(R.id.menu_connect).setVisible(false);
              menu.findItem(R.id.menu_disconnect).setVisible(true);
          } else {
              menu.findItem(R.id.menu_connect).setVisible(true);
              menu.findItem(R.id.menu_disconnect).setVisible(false);
          }
          return true;
      }
  
      @Override
      public boolean onOptionsItemSelected(MenuItem item) {
          switch(item.getItemId()) {
              case R.id.menu_connect:
                  mBluetoothLeService.connect(mDeviceAddress);
                  return true;
              case R.id.menu_disconnect:
                  mBluetoothLeService.disconnect();
                  return true;
              case android.R.id.home:
                  onBackPressed();
                  return true;
          }
          return super.onOptionsItemSelected(item);
      }
  
      private void updateConnectionState(final int resourceId) {
          runOnUiThread(new Runnable() {
              @Override
              public void run() {
                  mConnectionState.setText(resourceId);
              }
          });
      }
  
      private void displayData(String data) {
          if (data != null) {
              mDataField.setText(data);
          }
      }
  
      private void displayGattServices(List&lt;BluetoothGattService&gt; gattServices) {
          if (gattServices == null) return;
          String uuid = null;
          String unknownServiceString = getResources().getString(R.string.unknown_service);
          String unknownCharaString = getResources().getString(R.string.unknown_characteristic);
          ArrayList&lt;HashMap&lt;String, String&gt;&gt; gattServiceData = new ArrayList&lt;HashMap&lt;String, String&gt;&gt;();
          ArrayList&lt;ArrayList&lt;HashMap&lt;String, String&gt;&gt;&gt; gattCharacteristicData
                  = new ArrayList&lt;ArrayList&lt;HashMap&lt;String, String&gt;&gt;&gt;();
          mGattCharacteristics = new ArrayList&lt;ArrayList&lt;BluetoothGattCharacteristic&gt;&gt;();
  
          // Loops through available GATT Services.
          for (BluetoothGattService gattService : gattServices) {
              HashMap&lt;String, String&gt; currentServiceData = new HashMap&lt;String, String&gt;();
              uuid = gattService.getUuid().toString();
              currentServiceData.put(
                      LIST_NAME, SampleGattAttributes.lookup(uuid, unknownServiceString));
              currentServiceData.put(LIST_UUID, uuid);
              gattServiceData.add(currentServiceData);
  
              ArrayList&lt;HashMap&lt;String, String&gt;&gt; gattCharacteristicGroupData =
                      new ArrayList&lt;HashMap&lt;String, String&gt;&gt;();
              List&lt;BluetoothGattCharacteristic&gt; gattCharacteristics =
                      gattService.getCharacteristics();
              ArrayList&lt;BluetoothGattCharacteristic&gt; charas =
                      new ArrayList&lt;BluetoothGattCharacteristic&gt;();
  
              // Loops through available Characteristics.
              for (BluetoothGattCharacteristic gattCharacteristic : gattCharacteristics) {
                  charas.add(gattCharacteristic);
                  HashMap&lt;String, String&gt; currentCharaData = new HashMap&lt;String, String&gt;();
                  uuid = gattCharacteristic.getUuid().toString();
                  currentCharaData.put(
                          LIST_NAME, SampleGattAttributes.lookup(uuid, unknownCharaString));
                  currentCharaData.put(LIST_UUID, uuid);
                  gattCharacteristicGroupData.add(currentCharaData);
              }
              mGattCharacteristics.add(charas);
              gattCharacteristicData.add(gattCharacteristicGroupData);
          }
  
          SimpleExpandableListAdapter gattServiceAdapter = new SimpleExpandableListAdapter(
                  this,
                  gattServiceData,
                  android.R.layout.simple_expandable_list_item_2,
                  new String[] {LIST_NAME, LIST_UUID},
                  new int[] { android.R.id.text1, android.R.id.text2 },
                  gattCharacteristicData,
                  android.R.layout.simple_expandable_list_item_2,
                  new String[] {LIST_NAME, LIST_UUID},
                  new int[] { android.R.id.text1, android.R.id.text2 }
          );
          mGattServicesList.setAdapter(gattServiceAdapter);
      }
  
      private static IntentFilter makeGattUpdateIntentFilter() {
          final IntentFilter intentFilter = new IntentFilter();
          intentFilter.addAction(BluetoothLeService.ACTION_GATT_CONNECTED);
          intentFilter.addAction(BluetoothLeService.ACTION_GATT_DISCONNECTED);
          intentFilter.addAction(BluetoothLeService.ACTION_GATT_SERVICES_DISCOVERED);
          intentFilter.addAction(BluetoothLeService.ACTION_DATA_AVAILABLE);
          return intentFilter;
      }
  }
  </code></pre>
  
  <p>I am using <code>Google's</code> official <a href="https://github.com/googlesamples/android-BluetoothLeGatt" rel="nofollow noreferrer">BluetoothLeGatt</a> example</p>