Created
May 30, 2013 06:06
-
-
Save cnbuff410/5675975 to your computer and use it in GitHub Desktop.
Legacy Bluetooth(pre 4.0) connection code for Android
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
package xx.xx.xx.xx; | |
import java.io.IOException; | |
import java.io.InputStream; | |
import java.io.OutputStream; | |
import java.util.Arrays; | |
import java.util.UUID; | |
import android.bluetooth.BluetoothAdapter; | |
import android.bluetooth.BluetoothDevice; | |
import android.bluetooth.BluetoothServerSocket; | |
import android.bluetooth.BluetoothSocket; | |
import android.content.Context; | |
import android.os.Bundle; | |
import android.os.Handler; | |
import android.os.Message; | |
import android.util.Log; | |
public class Bluetooth { | |
// Debug | |
private static final String TAG = "BTService"; | |
private static final boolean D = true; | |
// Name for the SDP record when creating server socket | |
private static final String NAME_SECURE = "BluetoothSecure"; | |
private static final String NAME_INSECURE = "BluetoothInsecure"; | |
// Unique UUID for this application. | |
// Change this if you really care about the security | |
private static final UUID MY_UUID_SECURE = UUID | |
.fromString("00001101-0000-1000-8000-00805F9B34FB"); | |
private static final UUID MY_UUID_INSECURE = UUID | |
.fromString("00001101-0000-1000-8000-00805F9B34FB"); | |
/** Member fields */ | |
private final BluetoothAdapter mAdapter; | |
private final Handler mHandler; | |
// Used for data parsing | |
private final Worker mWorker; | |
private AcceptThread mSecureAcceptThread = null; | |
private AcceptThread mInsecureAcceptThread = null; | |
private ConnectThread mConnectThread = null; | |
private ConnectedThread mConnectedThread = null; | |
private byte[] mBuffer = new byte[1024]; | |
private int mState = -1; | |
/** 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 | |
public static final int STATE_ERROR = 4; // error | |
/** | |
* Constructor. Prepares a new Bluetooth session. | |
* | |
* @param context | |
* The UI Activity Context | |
* @param handler | |
* A Handler to send messages back to the UI Activity | |
*/ | |
public Bluetooth(Context context, Handler handler, Worker w) { | |
mAdapter = BluetoothAdapter.getDefaultAdapter(); | |
mHandler = handler; | |
mWorker = w; | |
mState = STATE_NONE; | |
} | |
/** | |
* 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 | |
Message msg = mHandler | |
.obtainMessage(ServiceManager.BTMSG_STATE_CHANGE); | |
msg.arg1 = mState; | |
msg.sendToTarget(); | |
} | |
/** | |
* Return the current connection state. | |
*/ | |
public synchronized int getState() { | |
return mState; | |
} | |
/** | |
* Start the 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; | |
} | |
setState(STATE_LISTEN); | |
// Start the thread to listen on a BluetoothServerSocket | |
if (mSecureAcceptThread == null) { | |
mSecureAcceptThread = new AcceptThread(true); | |
mSecureAcceptThread.start(); | |
} | |
// Insecure is not compatible with pre 2.3 | |
if (mInsecureAcceptThread == null) { | |
mInsecureAcceptThread = new AcceptThread(false); | |
mInsecureAcceptThread.start(); | |
} | |
} | |
/** | |
* Start the ConnectThread to initiate a connection to a remote device. | |
* | |
* @param device | |
* The BluetoothDevice to connect | |
* @param secure | |
* Socket Security type - Secure (true) , Insecure (false) | |
*/ | |
public synchronized void connect(BluetoothDevice device, boolean isSecure) { | |
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, isSecure); | |
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, final String socketType) { | |
if (D) | |
Log.d(TAG, "connected, Socket Type:" + socketType); | |
// 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 (mSecureAcceptThread != null) { | |
mSecureAcceptThread.cancel(); | |
mSecureAcceptThread = null; | |
} | |
if (mInsecureAcceptThread != null) { | |
mInsecureAcceptThread.cancel(); | |
mInsecureAcceptThread = null; | |
} | |
// Start the thread to manage the connection and perform transmissions | |
mConnectedThread = new ConnectedThread(socket, socketType); | |
mConnectedThread.start(); | |
// Send the name of the connected device back to the UI Activity | |
Message msg = mHandler.obtainMessage(ServiceManager.BTMSG_CONNECTED); | |
Bundle bundle = new Bundle(); | |
bundle.putString(ServiceManager.DEVICE_NAME_KEY, device.getName()); | |
bundle.putString(ServiceManager.DEVICE_ADDRESS_KEY, device.getAddress()); | |
msg.setData(bundle); | |
mHandler.sendMessage(msg); | |
setState(STATE_CONNECTED); | |
} | |
/** | |
* Stop all threads | |
*/ | |
public synchronized void stop() { | |
if (D) | |
Log.d(TAG, "stop"); | |
setState(STATE_NONE); | |
if (mConnectThread != null) { | |
mConnectThread.cancel(); | |
mConnectThread = null; | |
} | |
if (mConnectedThread != null) { | |
mConnectedThread.cancel(); | |
mConnectedThread = null; | |
} | |
if (mSecureAcceptThread != null) { | |
mSecureAcceptThread.cancel(); | |
mSecureAcceptThread = null; | |
} | |
if (mInsecureAcceptThread != null) { | |
mInsecureAcceptThread.cancel(); | |
mInsecureAcceptThread = null; | |
} | |
} | |
/** | |
* 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() { | |
// Unable to connect device | |
setState(STATE_ERROR); | |
// Start the service over to restart listening mode | |
// Bluetooth.this.start(); | |
} | |
/** | |
* Indicate that the connection was lost and notify the UI Activity. | |
*/ | |
private void connectionLost() { | |
// Device connection was lost | |
setState(STATE_NONE); | |
// Start the service over to restart listening mode | |
// Bluetooth.this.start(); | |
} | |
/** | |
* 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; | |
private String mSocketType; | |
public AcceptThread(boolean secure) { | |
BluetoothServerSocket tmp = null; | |
mSocketType = secure ? "Secure" : "Insecure"; | |
// Create a new listening server socket | |
try { | |
if (secure) { | |
tmp = mAdapter.listenUsingRfcommWithServiceRecord( | |
NAME_SECURE, MY_UUID_SECURE); | |
} else { | |
tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord( | |
NAME_INSECURE, MY_UUID_INSECURE); | |
} | |
} catch (IOException e) { | |
Log.e(TAG, "Socket Type: " + mSocketType + "listen() failed", e); | |
} | |
mmServerSocket = tmp; | |
} | |
public void run() { | |
if (D) | |
Log.d(TAG, "Socket Type: " + mSocketType | |
+ "BEGIN mAcceptThread" + this); | |
setName("AcceptThread" + mSocketType); | |
BluetoothSocket socket = null; | |
// Listen to the server socket if we're not connected | |
while (mState != STATE_CONNECTED) { | |
try { | |
// This is a blocking call and will only return on a | |
// successful connection or an exception | |
if (mmServerSocket != null) | |
socket = mmServerSocket.accept(); | |
} catch (IOException e) { | |
Log.e(TAG, "Socket Type: " + mSocketType | |
+ "accept() failed", e); | |
break; | |
} | |
// If a connection was accepted | |
if (socket != null) { | |
synchronized (Bluetooth.this) { | |
switch (mState) { | |
case STATE_LISTEN: | |
case STATE_CONNECTING: | |
// Situation normal. Start the connected thread. | |
connected(socket, socket.getRemoteDevice(), | |
mSocketType); | |
break; | |
case STATE_NONE: | |
case STATE_CONNECTED: | |
// Either not ready or already connected. Terminate | |
// new socket. | |
try { | |
socket.close(); | |
} catch (IOException e) { | |
Log.e(TAG, "Could not close unwanted socket", e); | |
} | |
break; | |
} | |
} | |
} | |
} | |
if (D) | |
Log.i(TAG, "END mAcceptThread, socket Type: " + mSocketType); | |
} | |
public void cancel() { | |
if (D) | |
Log.d(TAG, "Socket Type" + mSocketType + "cancel " + this); | |
try { | |
if (mmServerSocket != null) | |
mmServerSocket.close(); | |
} catch (IOException e) { | |
Log.e(TAG, "Socket Type" + mSocketType | |
+ "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 final BluetoothSocket mmSocket; | |
private final BluetoothDevice mmDevice; | |
private String mSocketType; | |
public ConnectThread(BluetoothDevice device, boolean isSecure) { | |
mmDevice = device; | |
BluetoothSocket tmp = null; | |
mSocketType = isSecure ? "Secure" : "Insecure"; | |
// Get a BluetoothSocket for a connection with the | |
// given BluetoothDevice | |
try { | |
if (isSecure) { | |
tmp = device | |
.createRfcommSocketToServiceRecord(MY_UUID_SECURE); | |
} else { | |
tmp = device | |
.createInsecureRfcommSocketToServiceRecord(MY_UUID_INSECURE); | |
} | |
} catch (IOException e) { | |
Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e); | |
} | |
mmSocket = tmp; | |
} | |
public void run() { | |
Log.i(TAG, "BEGIN mConnectThread SocketType:" + mSocketType); | |
setName("ConnectThread" + mSocketType); | |
// 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 | |
mmSocket.connect(); | |
} catch (IOException e) { | |
// Close the socket | |
try { | |
mmSocket.close(); | |
} catch (IOException e2) { | |
Log.e(TAG, "unable to close() " + mSocketType | |
+ " socket during connection failure", e2); | |
} | |
connectionFailed(); | |
return; | |
} | |
// Reset the ConnectThread because we're done | |
synchronized (Bluetooth.this) { | |
mConnectThread = null; | |
} | |
// Start the connected thread | |
connected(mmSocket, mmDevice, mSocketType); | |
} | |
public void cancel() { | |
try { | |
mmSocket.close(); | |
} catch (IOException e) { | |
Log.e(TAG, "close() of connect " + mSocketType | |
+ " 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, String socketType) { | |
Log.d(TAG, "create ConnectedThread: " + socketType); | |
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; | |
} | |
public void run() { | |
Log.i(TAG, "BEGIN mConnectedThread"); | |
int bytes; | |
// Keep listening to the InputStream while connected | |
while (true) { | |
try { | |
// Read new data from the InputStream | |
bytes = mmInStream.read(mBuffer); | |
mWorker.parseRaw(mBuffer, bytes); | |
} 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); | |
} 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); | |
} | |
} | |
} | |
} |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment