如果关闭BluetoothSocket，是否需要关闭InputStream / OutputStream？

Question

I have a BluetoothSocket and two streams.

Method m = device.getClass().getMethod("createRfcommSocket", new Class[] {int.class});
BluetoothSocket s = (BluetoothSocket) m.invoke(device, 1);

s.connect();

InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();

At some moment I want to close the socket. Do I have to close the streams? The problem is that each close() may throw an exception, I have to catch them, and the code becomes bloated.

IIRC in some similar case it was enough to close the main object (which would be the socket in this case), and other objects were closed automatically. But this behavior is not documented for BluetoothSocket (or I could not find it).

So:

If I close a bluetooth socket, do I have to close its streams?

(And what about Socket s? Are they different? BluetoothSocket does not inherit from Socket .)

Answer 1

I have been working on Android Bluetooth recently. I checked the sources. And it seems that you don't need to close your streams.

Indeed, you stream are respectively objects of type BluetoothInputStream and BluetoothOutputStream in the BluetoothSocket constructor:

mInputStream = new BluetoothInputStream(this);
mOutputStream = new BluetoothOutputStream(this);

Those are streams returned when you call:

InputStream in = s.getInputStream();
OutputStream out = s.getOutputStream();

But when you call .close() on these streams, you call:

public void close() throws IOException {
    mSocket.close();
}

So you only close the BluetoothSocket again.

In conclusion, you don't need to close those streams.

For your second question, the only thing that Socket and BluetoothSocket have in common is that they implement Closable: they will have a .close() method. It does not mean they do the same

Here is the complete code for BluetoothOutputStream:

/*package*/ final class BluetoothOutputStream extends OutputStream {
private BluetoothSocket mSocket;

/*package*/ BluetoothOutputStream(BluetoothSocket s) {
    mSocket = s;
}

/**
 * Close this output stream and the socket associated with it.
 */
public void close() throws IOException {
    mSocket.close();
}

/**
 * Writes a single byte to this stream. Only the least significant byte of
 * the integer {@code oneByte} is written to the stream.
 *
 * @param oneByte
 *            the byte to be written.
 * @throws IOException
 *             if an error occurs while writing to this stream.
 * @since Android 1.0
 */
public void write(int oneByte) throws IOException {
    byte b[] = new byte[1];
    b[0] = (byte)oneByte;
    mSocket.write(b, 0, 1);
}

/**
 * Writes {@code count} bytes from the byte array {@code buffer} starting
 * at position {@code offset} to this stream.
 *
 * @param b
 *            the buffer to be written.
 * @param offset
 *            the start position in {@code buffer} from where to get bytes.
 * @param count
 *            the number of bytes from {@code buffer} to write to this
 *            stream.
 * @throws IOException
 *             if an error occurs while writing to this stream.
 * @throws IndexOutOfBoundsException
 *             if {@code offset < 0} or {@code count < 0}, or if
 *             {@code offset + count} is bigger than the length of
 *             {@code buffer}.
 * @since Android 1.0
 */
public void write(byte[] b, int offset, int count) throws IOException {
    if (b == null) {
        throw new NullPointerException("buffer is null");
    }
    if ((offset | count) < 0 || count > b.length - offset) {
        throw new IndexOutOfBoundsException("invalid offset or length");
    }
    mSocket.write(b, offset, count);
}
/**
 * Wait until the data in sending queue is emptied. A polling version
 * for flush implementation. Use it to ensure the writing data afterwards will
 * be packed in the new RFCOMM frame.
 * @throws IOException
 *             if an i/o error occurs.
 * @since Android 4.2.3
 */
public void flush()  throws IOException {
    mSocket.flush();
}

}

Answer 2

You should close the streams first. Only calling close() on the socket will usually work out, but if a new connection is opened immediately following (read: unit testing), you'll have problems.

Answer 3

At some moment I want to close the socket. Do I have to close the streams? The problem is that each close() may throw an exception, I have to catch them, and the code becomes bloated.

If the documentation does not mention nothing about it, I think you should close it. If your problem is just the exception, you can have an utility method, such

public void closeStream(Closeable stream) {
   if (stream == null) {
       return;
   }

   try {
      stream.close();
   } catch (IOException e) {
       e.printStackTrace();
   }
}