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?
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 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.
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.
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.
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);
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(); } } }
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With