title: Android: Bluetooth - How to read incoming data
body: <p>I have successfully paired and connected with a Bluetooth device. I am now interested in receiving all data being transferred between the 2 and seeing whats what.</p>
  
  <p>I am getting the input stream from the socket and attempting to read it. I return this and just log it. </p>
  
  <p>The only way I know of doing this from what I have read is just do read with a byte buffer to return an int. However I should have loads of data coming through. How can I continually read out data being transferred, and also format as bytes rather than an int.</p>
  
  <p>Thanks.</p>
  
  <p>Full code below:</p>
  
  <pre><code>public class ConnectThread {
  
      private BluetoothSocketWrapper bluetoothSocket;
      private BluetoothDevice device;
      private boolean secure;
      private BluetoothAdapter adapter;
      private List&lt;UUID&gt; uuidCandidates;
      private int candidate;
  
  
      /**
       * @param device the device
       * @param secure if connection should be done via a secure socket
       * @param adapter the Android BT adapter
       * @param uuidCandidates a list of UUIDs. if null or empty, the Serial PP id is used
       */
      public ConnectThread(BluetoothDevice device, boolean secure, BluetoothAdapter adapter,
                                List&lt;UUID&gt; uuidCandidates) {
          this.device = device;
          this.secure = secure;
          this.adapter = adapter;
          this.uuidCandidates = uuidCandidates;
  
          if (this.uuidCandidates == null || this.uuidCandidates.isEmpty()) {
              this.uuidCandidates = new ArrayList&lt;UUID&gt;();
              this.uuidCandidates.add(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
          }
      }
  
      public BluetoothSocketWrapper connect() throws IOException {
          boolean success = false;
          while (selectSocket()) {
              adapter.cancelDiscovery();
  
              try {
                  bluetoothSocket.connect();
                  success = true;
                  break;
              } catch (IOException e) {
                  //try the fallback
                  try {
                      bluetoothSocket = new FallbackBluetoothSocket(bluetoothSocket.getUnderlyingSocket());
                      Thread.sleep(500);
                      bluetoothSocket.connect();
                      success = true;
                      break;
                  } catch (FallbackException e1) {
                      Log.w("BT", "Could not initialize FallbackBluetoothSocket classes.", e);
                  } catch (InterruptedException e1) {
                      Log.w("BT", e1.getMessage(), e1);
                  } catch (IOException e1) {
                      Log.w("BT", "Fallback failed. Cancelling.", e1);
                  }
              }
          }
  
          if (!success) {
              throw new IOException("Could not connect to device: "+ device.getAddress());
          }
  
          receiveData(bluetoothSocket);
          return bluetoothSocket;
      }
  
      private boolean selectSocket() throws IOException {
          if (candidate &gt;= uuidCandidates.size()) {
              return false;
          }
  
          BluetoothSocket tmp;
          UUID uuid = uuidCandidates.get(candidate++);
  
          Log.i("BT", "Attempting to connect to Protocol: "+ uuid);
          if (secure) {
              tmp = device.createRfcommSocketToServiceRecord(uuid);
          } else {
              tmp = device.createInsecureRfcommSocketToServiceRecord(uuid);
          }
          bluetoothSocket = new NativeBluetoothSocket(tmp);
  
          return true;
      }
  
      public static interface BluetoothSocketWrapper {
  
          InputStream getInputStream() throws IOException;
  
          OutputStream getOutputStream() throws IOException;
  
          String getRemoteDeviceName();
  
          void connect() throws IOException;
  
          String getRemoteDeviceAddress();
  
          void close() throws IOException;
  
          BluetoothSocket getUnderlyingSocket();
  
      }
  
  
      public static class NativeBluetoothSocket implements BluetoothSocketWrapper {
  
          private BluetoothSocket socket;
  
          public NativeBluetoothSocket(BluetoothSocket tmp) {
              this.socket = tmp;
          }
  
          @Override
          public InputStream getInputStream() throws IOException {
              return socket.getInputStream();
          }
  
          @Override
          public OutputStream getOutputStream() throws IOException {
              return socket.getOutputStream();
          }
  
          @Override
          public String getRemoteDeviceName() {
              return socket.getRemoteDevice().getName();
          }
  
          @Override
          public void connect() throws IOException {
              socket.connect();
          }
  
          @Override
          public String getRemoteDeviceAddress() {
              return socket.getRemoteDevice().getAddress();
          }
  
          @Override
          public void close() throws IOException {
              socket.close();
          }
  
          @Override
          public BluetoothSocket getUnderlyingSocket() {
              return socket;
          }
  
      }
  
      public class FallbackBluetoothSocket extends NativeBluetoothSocket {
  
          private BluetoothSocket fallbackSocket;
  
          public FallbackBluetoothSocket(BluetoothSocket tmp) throws FallbackException {
              super(tmp);
              try
              {
                  Class&lt;?&gt; clazz = tmp.getRemoteDevice().getClass();
                  Class&lt;?&gt;[] paramTypes = new Class&lt;?&gt;[] {Integer.TYPE};
                  Method m = clazz.getMethod("createRfcommSocket", paramTypes);
                  Object[] params = new Object[] {Integer.valueOf(1)};
                  fallbackSocket = (BluetoothSocket) m.invoke(tmp.getRemoteDevice(), params);
              }
              catch (Exception e)
              {
                  throw new FallbackException(e);
              }
          }
  
          @Override
          public InputStream getInputStream() throws IOException {
              return fallbackSocket.getInputStream();
          }
  
          @Override
          public OutputStream getOutputStream() throws IOException {
              return fallbackSocket.getOutputStream();
          }
  
  
          @Override
          public void connect() throws IOException {
              fallbackSocket.connect();
          }
  
  
          @Override
          public void close() throws IOException {
              fallbackSocket.close();
          }
  
      }
  
      public static class FallbackException extends Exception {
  
          /**
           *
           */
          private static final long serialVersionUID = 1L;
  
          public FallbackException(Exception e) {
              super(e);
          }
  
      }
  
      public void sendData(BluetoothSocketWrapper socket, int data) throws IOException{
          ByteArrayOutputStream output = new ByteArrayOutputStream(4);
          output.write(data);
          OutputStream outputStream = socket.getOutputStream();
          outputStream.write(output.toByteArray());
      }
  
      public int receiveData(BluetoothSocketWrapper socket) throws IOException{
          byte[] buffer = new byte[256];
          ByteArrayInputStream input = new ByteArrayInputStream(buffer);
          InputStream inputStream = socket.getInputStream();
          inputStream.read(buffer);
          return input.read();
      }
  }
  </code></pre>