Bluetooth connection issues with IntentService

Question

I need to transmit some data from my Android app over Bluetooth (to Arduino). I am not reading/receiving anything back from Arduino. For my single threaded needs, I went with an IntentService. After pairing, my code works fine for the first time I connect and send data. I disconnect after sending data without errors. But when I try to connect the second time onwards, I get the following error when I try myBluetoothSocket.connect() :

read failed, socket might closed or timeout, read ret: -1

Only solution is to power off the Arduino device and reconnect (it doesn't help if I force stop the app and try reconnecting).

Note that everything works fine if I spawn 2 threads (one for read and write each) regardless of how many times I connect and send data (thereby proving there is nothing wrong on the Arduino side, "holding back" an old connection).

Here is my Android code :

import android.app.IntentService;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.Intent;
import android.content.Context;
import android.os.Build;
import android.os.ParcelUuid;
import android.widget.Toast;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.util.UUID;

public class DataTransmissionService extends IntentService {

    private static final UUID MY_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
    private static final String TAG = "DataTransmissionService";

    private BluetoothAdapter btAdapter = null;
    private BluetoothSocket btSocket = null;
    private OutputStream outStream = null;
    private BluetoothDevice device = null;

    public DataTransmissionService() {
        super("DataTransmissionService");
    }

    @Override
    protected void onHandleIntent(Intent intent) {
        cleanup();
        if (intent != null){

            btAdapter = BluetoothAdapter.getDefaultAdapter();
            pairedDeviceAddress = "already_paired_device_mac_addr";

            try {
                log.d(TAG, pairedDeviceAddress);
                device = btAdapter.getRemoteDevice(pairedDeviceAddress);
                log.d(TAG, "Device bond state : " + device.getBondState());

            } catch (Exception e) {
                log.e(TAG, "Invalid address: " + e.getMessage());
                return;
            }

            try {
                btSocket = createBluetoothSocket(device);
            } catch (IOException e) {
                log.e(TAG, "Socket creation failed: " + e.getMessage());
                return;
            }

            try {

                if (!btSocket.isConnected()) {  
                    btSocket.connect();    
                    log.d(TAG, "Connected");
                } else {
                    log.d(TAG, "Already Connected");  //flow never reaches here for any use case
                }

            } catch (IOException e) {
                log.e(TAG, "btSocket.connect() failed : " + e.getMessage());
                return;
            }

            try {
                outStream = btSocket.getOutputStream();
            } catch (IOException e) {
                log.e(TAG, "Failed to get output stream:" + e.getMessage());
                return;
            }

            sendData("test");
           //cleanup();   called in onDestroy()

        }

    }

    @Override
    public void onDestroy(){
        cleanup();
        //notify ui
        super.onDestroy();
    }

    private void cleanup(){

        try {
            if (outStream != null) {
                outStream.close();
                outStream = null;
            }
        } catch (Exception e) {
            log.e(TAG, "Failed to close output stream : " + e.getMessage());
        }

        try {
            if (btSocket != null) {
                btSocket.close();
                btSocket = null;
            }
        }catch (Exception e) {
            log.e(TAG, "Failed to close connection : " + e.getMessage());
        }

    }

    private BluetoothSocket createBluetoothSocket(BluetoothDevice device) throws IOException {
        /*if(Build.VERSION.SDK_INT >= 10){
            try {
                final Method m = device.getClass().getMethod("createInsecureRfcommSocketToServiceRecord", new Class[] { UUID.class });
                return (BluetoothSocket) m.invoke(device, MY_UUID);
            } catch (Exception e) {
                log.e(TAG, "Could not create Insecure RFComm Connection",e);
            }
        }*/

        return  device.createRfcommSocketToServiceRecord(MY_UUID);
    }

    private void sendData(String message) {

        byte[] msgBuffer = message.getBytes();
        log.d(TAG, "Sending : " + message);
        try {
            outStream.write(msgBuffer);
        } catch (IOException e) {
            log.e(TAG, "failed to write " + message);
        }
    }
}

I have tested on Nexus 5 and Samsung S5 devices (running 5.1 and 5.0 respectively).

I have a feeling your problem lies in using an `IntentService` rather than a regular `Service` and/or custom `Thread`. From the `IntentService` doc: *the service is started as needed, handles each Intent in turn using a worker thread, and stops itself when it runs out of work.* This is likely to cause havoc if you are trying to maintain a BT connection across intents. — pathfinderelite, May 16 '15 at 01:18
That's exactly what I need. Connect, send data and terminate connection. The next connection would likely happen after very long, spawning a new service. Maintaining threads seems cumbersome for a simple use case like this. This also auto-ensures treatment of one device at a time (part of my use case). — dev, May 16 '15 at 01:24
What you say about the Arduino not "holding back" the connection seems reasonable, but the fact that you have to turn the Arduino off and on to be able to connect again makes me wonder. Maybe the Arduino somehow goes into a different state if you read and write on the same thread? (I know, sounds odd.) What happens if you connect to the Arduino with one phone, disconnect, then try to connect with the 2nd phone? Also, do you have any way to see the state of the Arduino's bluetooth modem, to see if it's somehow different after you disconnect the first time, compared to before that? — hBrent, May 20 '15 at 21:51
Arduino is able to connect to the second phone in the scenario you mentioned. I dont know how to check state of the modem. I also made 2 apps (one where I do everything on the main thread and the other using IntentService). If I connect using IntentService, the other app (using main thread) cannot connect to the same device. — dev, May 21 '15 at 05:40
I assume you've seen http://stackoverflow.com/a/25647197/1493426 — hBrent, May 22 '15 at 14:29

score 2 · Answer 1 · answered May 26 '15 at 14:29

2

When you try to connect the second time you have to create the corresponding socket again.

Also you must consider Arduino is a slow platform, there might be some considerable delay between closing the connection and you being able to open it again.

answered May 26 '15 at 14:29

Pat

2,670
18
27

The code I posted is creating a new socket everytime. Don't you agree ? – dev May 27 '15 at 17:16

score 0 · Accepted Answer · answered Jul 08 '15 at 08:02

I am not sure why it works, but this approach finally worked :

private BluetoothSocket createBluetoothSocket(BluetoothDevice bluetoothDevice) throws IOException {

        try {
            Method m = bluetoothDevice.getClass().getMethod(
                    "createRfcommSocket", new Class[] { int.class });
            btSocket = (BluetoothSocket) m.invoke(bluetoothDevice, 1);
        } catch (Exception e) {
            e.printStackTrace();
        }

        return btSocket;
    }

score -1 · Answer 3 · answered May 27 '15 at 03:50

The onDestroy() method is only called when the garbage collector runs. You need call the cleanup() from the onHandleIntent(Intent) as you did before otherwise the socket will remain open indefinitely. Since you left it open, you are unable to connect again.

Android's Bluetooth stack seems to be agnostic of the application lifecycle: the socket will remain open even if you force stop the application. In your current scenario, to close the socket do a disable-enable of the Bluetooth in Settings.

Bluetooth connection issues with IntentService

3 Answers3