Logo Questions Linux Laravel Mysql Ubuntu Git Menu
 

unable to make connection between 2 device bluetooth android

I have tried to connect two devices by using the Android Bluetooth Chat example on the Android developer site. It's only connecting from one of the devices and when I am trying to connect from the other device it's not connecting and pops up a message "Unable to connect: [device name here]"

I am wondering if I'm using the same code on both of the devices, why is the connection made only from one side, and being refused from the other side?

I have 2 devices - 1 running version 2.2 and 1 running v2.3.3. My request is always being sent from my Galaxy Y running 2.3.3 to a Galaxy fit-v running Android 2.2, but not vice versa. Can any one please help me out or give me suggestions based off the code below...

@Override public void onActivityResult(int requestCode, int resultCode, final Intent data) {      switch (requestCode) {     case REQUEST_CONNECT_DEVICE:          // When DeviceListActivity returns with a device to connect         if (resultCode == Activity.RESULT_OK) {             FaceCardList.requestConnection = true;             FaceCardList.deviceSelected = false;              address = data.getExtras().getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS);                            device = FaceCardList.mBluetoothAdapter.getRemoteDevice(address);              // Attempt to connect to the device             FaceCardList.mChatService.connect(device);             // Get the device MAC address         }         break;     case REQUEST_ENABLE_BT:         // When the request to enable Bluetooth returns         if (resultCode == Activity.RESULT_OK) {             // Bluetooth is now enabled, so set up a chat session             setupChat();         } else {             // User did not enable Bluetooth or an error occured             Toast.makeText(this, R.string.bt_not_enabled_leaving, Toast.LENGTH_SHORT).show();             finish();         }     } } 

and the code for my BluetoothChat service is:

public class BluetoothChatService extends Activity {     private static final String TAG = "BluetoothChatService";     private static final boolean D = true;     // Name for the SDP record when creating server socket     private static final String NAME = "BluetoothChat";     // Unique UUID for this application     private static final UUID MY_UUID =  UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");      // ("fa87c0d0-afac-11de-8a39-0800200c9a66");     // Member fields     private final BluetoothAdapter mAdapter;     private final Handler mHandler;     private AcceptThread mAcceptThread;     private ConnectThread mConnectThread;     private ConnectedThread mConnectedThread;     private int mState;     // Constants that indicate the current connection state     public static final int STATE_NONE = 0; // we're doing nothing     public static final int STATE_LISTEN = 1; // now listening for incoming connections     public static final int STATE_CONNECTING = 2; // now initiating an outgoing connection     public static final int STATE_CONNECTED = 3; // now connected to a remote device      /**      * Constructor. Prepares a new BluetoothChat session.      *       * @param context      *            The UI Activity Context      * @param handler      *            A Handler to send messages back to the UI Activity      */     public BluetoothChatService(Context context, Handler handler) {         mAdapter = FaceCardList.mBluetoothAdapter;         mState = STATE_NONE;         mHandler = handler;     }      /**      * Set the current state of the chat connection      *       * @param state      *            An integer defining the current connection state      */     private synchronized void setState(int state) {         if (D) {             //Log.d(TAG, "setState() " + mState + " -> " + state);         }         mState = state;          // Give the new state to the Handler so the UI Activity can update         mHandler.obtainMessage(FaceCardList.MESSAGE_STATE_CHANGE, state, -1)                 .sendToTarget();     }      /**      * Return the current connection state.      */     public synchronized int getState() {         return mState;     }      /**      * Start the chat service. Specifically start AcceptThread to begin a      * session in listening (server) mode. Called by the Activity onResume()      */     public synchronized void start() {         if (D) {             Log.d(TAG, "start");         }          // Cancel any thread attempting to make a connection         if (mConnectThread != null) {             mConnectThread.cancel();             mConnectThread = null;         }          // Cancel any thread currently running a connection         if (mConnectedThread != null) {             mConnectedThread.cancel();             mConnectedThread = null;         }          // Start the thread to listen on a BluetoothServerSocket         if (mAcceptThread == null) {             mAcceptThread = new AcceptThread();             mAcceptThread.start();         }         setState(STATE_LISTEN);     }      /**      * Start the ConnectThread to initiate a connection to a remote device.      *       * @param device      *            The BluetoothDevice to connect      */     public synchronized void connect(BluetoothDevice device) {         if (D) {           Log.d(TAG, "connect to: " + device);                  }          // Cancel any thread attempting to make a connection         if (mState == STATE_CONNECTING) {             if (mConnectThread != null) {                 mConnectThread.cancel();                 mConnectThread = null;             }         }          // Cancel any thread currently running a connection         if (mConnectedThread != null) {             mConnectedThread.cancel();             mConnectedThread = null;         }          // Start the thread to connect with the given device         mConnectThread = new ConnectThread(device);         mConnectThread.start();         setState(STATE_CONNECTING);     }      /**      * Start the ConnectedThread to begin managing a Bluetooth connection      *       * @param socket      *            The BluetoothSocket on which the connection was made      * @param device      *            The BluetoothDevice that has been connected      */     public synchronized void connected(BluetoothSocket socket,             BluetoothDevice device) {         if (D) {             Log.d(TAG, "######connected");         }          // Cancel the thread that completed the connection         if (mConnectThread != null) {             mConnectThread.cancel();             mConnectThread = null;         }          // Cancel any thread currently running a connection         if (mConnectedThread != null) {             mConnectedThread.cancel();             mConnectedThread = null;         }          // Cancel the accept thread because we only want to connect to one         // device         if (mAcceptThread != null) {             mAcceptThread.cancel();             mAcceptThread = null;         }          // Start the thread to manage the connection and perform transmissions         mConnectedThread = new ConnectedThread(socket);         mConnectedThread.start();          // Send the name of the connected device back to the UI Activity         Message msg = mHandler.obtainMessage(FaceCardList.MESSAGE_DEVICE_NAME);          Bundle bundle = new Bundle();         bundle.putString(FaceCardList.DEVICE_NAME, device.getName());         msg.setData(bundle);         mHandler.sendMessage(msg);          setState(STATE_CONNECTED);     }      /**      * Stop all threads      */     public synchronized void stop() {         if (D) {             Log.d(TAG, "stop");         }         if (mConnectThread != null) {         mConnectThread.cancel();         mConnectThread = null;         }         if (mConnectedThread != null) {             mConnectedThread.cancel();             mConnectedThread = null;         }         if (mAcceptThread != null) {             mAcceptThread.cancel();             mAcceptThread = null;         }         setState(STATE_NONE);     }      /**      * Write to the ConnectedThread in an unsynchronized manner      *       * @param out      *            The bytes to write      * @see ConnectedThread#write(byte[])      */     public void write(byte[] out) {         // Create temporary object         ConnectedThread r;         // Synchronize a copy of the ConnectedThread         synchronized (this) {             if (mState != STATE_CONNECTED) {                 return;             }         r = mConnectedThread;         }         // Perform the write unsynchronized         r.write(out);      }      /**      * Indicate that the connection attempt failed and notify the UI Activity.      */     private void connectionFailed() {         setState(STATE_LISTEN);          // Send a failure message back to the Activity         Message msg = mHandler.obtainMessage(FaceCardList.MESSAGE_TOAST);         Bundle bundle = new Bundle();         bundle.putString(FaceCardList.TOAST, "Unable to connect device");         msg.setData(bundle);         mHandler.sendMessage(msg);     }      /**      * Indicate that the connection was lost and notify the UI Activity.      */     private void connectionLost() {         setState(STATE_LISTEN);         // Send a failure message back to the Activity         Message msg = mHandler.obtainMessage(FaceCardList.MESSAGE_TOAST);         Bundle bundle = new Bundle();         bundle.putString(FaceCardList.TOAST, "Device connection was lost");         msg.setData(bundle);         mHandler.sendMessage(msg);     }      /**      * This thread runs while listening for incoming connections. It behaves      * like a server-side client. It runs until a connection is accepted (or      * until cancelled).      */     private class AcceptThread extends Thread {         // The local server socket         private final BluetoothServerSocket mmServerSocket;          public AcceptThread() {             BluetoothServerSocket tmp = null;              // Create a new listening server socket             try {                  tmp = mAdapter                         .listenUsingRfcommWithServiceRecord(NAME, MY_UUID); //                if(!tmp.toString().equalsIgnoreCase(null)){     //                      //          }             } catch (IOException e) {                 //Log.e(TAG, "listen() failed", e);             }             mmServerSocket = tmp;         }          @Override         public void run() {             if (D) {                Log.d(TAG, "BEGIN mAcceptThread" + this);             }              setName("AcceptThread");             BluetoothSocket socket = null;              // Listen to the server socket if we're not connected             while (mState != STATE_CONNECTED) {                       try {                         socket = mmServerSocket.accept();                     } catch (IOException e1) {                         // TODO Auto-generated catch block                         //e1.printStackTrace();                     }                   // If a connection was accepted                 if (socket != null) {                     synchronized (BluetoothChatService.this) {                         switch (mState) {                         case STATE_LISTEN:                         case STATE_CONNECTING:                             // Situation normal. Start the connected thread.                             connected(socket, socket.getRemoteDevice());                             break;                         case STATE_NONE:                         case STATE_CONNECTED:                             // Either not ready or already connected. Terminate                             // new socket.                             //Log.e("STATE_CONNECTED: service","STATE_CONNECTED: service");                              try {                                 socket.close();                             } catch (IOException e) {                                 //Log.e(TAG,"Could not close unwanted socket",                                                e);                             }                             break;                         }                     }                 }             }             if (D) {                 //Log.i(TAG, "END mAcceptThread");             }         }          public void cancel() {             if (D) {                 //Log.d(TAG, "cancel " + this);             }             try {                 mmServerSocket.close();             } catch (IOException e) {                 //Log.e(TAG, "close() of server failed", e);             }         }     }      /**      * This thread runs while attempting to make an outgoing connection with a      * device. It runs straight through; the connection either succeeds or      * fails.      */       private class ConnectThread extends Thread {         private BluetoothSocket mmSocket= null;          private final BluetoothDevice mmDevice;          public ConnectThread(BluetoothDevice device) {             mmDevice = device;             BluetoothSocket tmp = null;              System.out.println("my uuid :-"+MY_UUID);             try {                 try {                     //tmp = device.createRfcommSocketToServiceRecord(MY_UUID);                      mmSocket = device.createRfcommSocketToServiceRecord(MY_UUID);                      System.out.println("mm socket value :-"+mmSocket);                  } catch (IOException e) {                     e.printStackTrace();                     System.out.println("error in connecting :-"+e.getMessage());                      //Log.e(TAG, "create() failed", e);                      // TODO Auto-generated catch block                     //e.printStackTrace();                 }                } catch (SecurityException e) {                 // TODO Auto-generated catch block                 //e.printStackTrace();             }             //   mmSocket = tmp;             System.out.println("mm socket value as temp :-----------------");         }                @Override            public void run() {             //Log.i(TAG, "BEGIN mConnectThread");             setName("ConnectThread");              // Always cancel discovery because it will slow down a connection             mAdapter.cancelDiscovery();              // Make a connection to the BluetoothSocket             try {                 // This is a blocking call and will only return on a                 // successful connection or an exception                 System.out.println("before connection");                  mmSocket.connect();                 System.out.println("after connection ");              } catch (Exception e) {                 System.out.println("in connection failed :-"+e.getMessage());                 connectionFailed();                 // Close the socket                 try {                     mmSocket.close();                 } catch (IOException e2) {                     //Log.e(TAG,"unable to close() socket during connection failure",                                    e2);                 }                 // Start the service over to restart listening mode                  try {                     BluetoothChatService.this.start();                   } catch (Exception e2) {                     // TODO: handle exception                     e2.printStackTrace();                     System.out.println("in connection failed start bluetooth chat service :-"+e2.getMessage());                 }                  return;             }              // Reset the ConnectThread because we're done             synchronized (BluetoothChatService.this) {                 mConnectThread = null;             }              // Start the connected thread             connected(mmSocket, mmDevice);         }          public void cancel() {             try {                 mmSocket.close();             } catch (IOException e) {                 //Log.e(TAG, "close() of connect socket failed", e);             }         }     }      /**      * This thread runs during a connection with a remote device. It handles all      * incoming and outgoing transmissions.      */     private class ConnectedThread extends Thread {         private final BluetoothSocket mmSocket;          private final InputStream mmInStream;          private final OutputStream mmOutStream;          public ConnectedThread(BluetoothSocket socket) {             //Log.d(TAG, "create ConnectedThread");             mmSocket = socket;             InputStream tmpIn = null;             OutputStream tmpOut = null;              // Get the BluetoothSocket input and output streams             try {                 tmpIn = socket.getInputStream();                 tmpOut = socket.getOutputStream();             } catch (IOException e) {                 //Log.e(TAG, "temp sockets not created", e);             }              mmInStream = tmpIn;             mmOutStream = tmpOut;         }          @Override         public void run() {             //Log.i(TAG, "BEGIN mConnectedThread");             byte[] buffer = new byte[1024];             int bytes;              // Keep listening to the InputStream while connected                                                                                                                                                                                                     while (true) {                 try {                     // Read from the InputStream\                       bytes = mmInStream.read(buffer);                      // Send the obtained bytes to the UI Activity                      // XXX !!!                     String buffer2 = new String(buffer);                     buffer2= buffer2.substring(0, buffer2.length()-3)+"\n";                      mHandler.obtainMessage(FaceCardList.MESSAGE_READ, bytes, -1, buffer2.getBytes()).sendToTarget();                  } catch (IOException e) {                     //Log.e(TAG, "disconnected", e);                     connectionLost();                     break;                 }             }         }          /**          * Write to the connected OutStream.          *           * @param buffer          *            The bytes to write          */         public void write(byte[] buffer) {             try {                 mmOutStream.write(buffer);                 // Share the sent message back to the UI Activity                  // XXX !!!                 String buffer2 = new String(buffer);                 buffer2= buffer2.substring(0, buffer2.length()-2);                 mHandler.obtainMessage(FaceCardList.MESSAGE_WRITE, -1, -1,                         buffer2.getBytes()).sendToTarget();              } catch (IOException e) {                 //Log.e(TAG, "Exception during write", e);             }         }          public void cancel() {             try {                 mmSocket.close();             } catch (IOException e) {                 //Log.e(TAG, "close() of connect socket failed", e);             }         }     } } 

I am stuck. Why is the connection always made from the higher version to a lower version but not from the lower version to a higher one?

like image 536
SRam Avatar asked Mar 31 '12 09:03

SRam


People also ask

Why is my Bluetooth not connecting to other devices?

If your Bluetooth devices won't connect, it's likely because the devices are out of range, or aren't in pairing mode. If you're having persistent Bluetooth connection problems, try resetting your devices, or having your phone or tablet "forget" the connection.

Can I pair 2 Bluetooth devices to my Android phone?

Can Android Connect to Multiple Bluetooth Devices? Most Android devices can connect to two or five Bluetooth devices simultaneously, while others support up to seven devices. The number of supported connections depends on the Bluetooth module your device is equipped with.

Can you connect 2 Bluetooth devices at once?

Thankfully, with Bluetooth multipoint, you don't have to. Simply put, Bluetooth multipoint gives you the ability to pair two different Bluetooth sources—like your smartphone and laptop—to a compatible headphone, both at the same time.

Why is Bluetooth not working on Android?

Clear the Bluetooth cache and data. If the Bluetooth is not connecting android properly, you might have to clear the stored app data and cache for the Bluetooth app. Just like every other app on your phone, Bluetooth also stores some data temporarily. To clear this, kindly head over to settings.


2 Answers

I have done this,and i think you get connection lost when the device discoverable change. Please do check the device discoverable in both,you can enable it by code.

Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE); discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION,0); startActivity(discoverableIntent); 
like image 94
Emel Elias Avatar answered Oct 14 '22 21:10

Emel Elias


Saurabh, make this change please and watch it work:

                if (Build.VERSION.SDK_INT < 9) { // VK: Build.Version_Codes.GINGERBREAD is not accessible yet so using raw int value                 // VK: 9 is the API Level integer value for Gingerbread                 try {                     tmp = device.createRfcommSocketToServiceRecord(MY_UUID);                 } catch (IOException e1) {                     // TODO Auto-generated catch block                     e1.printStackTrace();                 }             } else {                 Method m = null;                 try {                     m = device.getClass().getMethod("createInsecureRfcommSocketToServiceRecord", new Class[] { UUID.class });                 } catch (NoSuchMethodException e) {                     // TODO Auto-generated catch block                     e.printStackTrace();                 }                 try {                     tmp = (BluetoothSocket) m.invoke(device, (UUID) MY_UUID);                 } catch (IllegalAccessException e) {                     // TODO Auto-generated catch block                     e.printStackTrace();                 } catch (InvocationTargetException e) {                     // TODO Auto-generated catch block                     e.printStackTrace();                 }             }         } 
like image 29
vkinra Avatar answered Oct 14 '22 20:10

vkinra