Hi ,
I am currently working on a use case where in I have to connect with
multiple Bluetooth devices concurrently and send and receive the data.
The use case says, whenever the app launches , the app should connect with
the available bluetooth devices and gets the data from the available droid
devices.
However the examples which have found is only for the device to device
client server connection.
On android site and forums also I have found solution for the chatting app
, which is onde 1-1 connection.
But for my use case i have to have multiple connections concurrently, so as
my device can talk directly with all the available Bluetooth devices
concurrently.
I would really appreciate any suggestions or a working code snippet.
The example of a library that I found
is https://github.com/arissa34/Android-Bluetooth-Library
but thats also not of much help, as i need to initiate connections and data
sendeing and receiving from master(server) app.
Thanks,
Shahnawaz
--
You received this message because you are subscribed to the Google Groups
"Android Developers" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
To post to this group, send email to [email protected].
Visit this group at https://groups.google.com/group/android-developers.
To view this discussion on the web visit
https://groups.google.com/d/msgid/android-developers/a8fa1fca-e9c9-4d14-8169-87a8f0093a0b%40googlegroups.com.
For more options, visit https://groups.google.com/d/optout.
package com.accenture.bluetoothchatlibrary.service;
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;
import com.accenture.bluetoothchatlibrary.utility.Constants;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;
/**
* This class does all the work for setting up and managing Bluetooth
* connections with other devices.
*/
public class BluetoothChatService {
// Name for the SDP record when creating server socket
private static final String NAME_SECURE = "BluetoothChatSecure";
private static final String NAME_INSECURE = "BluetoothChatInsecure";
// 8ce255c0-200a-11e0-ac64-0800200c9a66
// Unique UUID for this application
private static final UUID MY_UUID_SECURE =
UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");
private static final UUID MY_UUID_INSECURE =
UUID.fromString("8ce255c0-200a-11e0-ac64-0800200c9a66");
// Member fields
private final BluetoothAdapter mAdapter;
private final Handler mHandler;
private AcceptThread mSecureAcceptThread;
private AcceptThread mInsecureAcceptThread;
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
public static final int STATE_CONNECTION_FAILED = 4; // FAILED TO CONNECT
public static final int STATE_CONNECTION_LOST = 5; // cONNECTIONLOST
/**
* 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 = BluetoothAdapter.getDefaultAdapter();
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) {
Log.d(getClass().getName(), "setState() " + mState + " -> " + state);
mState = state;
// Give the new state to the Handler so the UI Activity can update
mHandler.obtainMessage(Constants.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() {
Log.d(getClass().getName(), "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();
}
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 secure) {
Log.d(getClass().getName(), "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, secure);
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) {
Log.d(getClass().getName(), "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(Constants.MESSAGE_DEVICE_NAME);
Bundle bundle = new Bundle();
bundle.putString(Constants.DEVICE_NAME, device.getName());
msg.setData(bundle);
mHandler.sendMessage(msg);
setState(STATE_CONNECTED);
}
/**
* Stop all threads
*/
public synchronized void stop() {
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;
}
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() {
// Send a failure message back to the Activity
setState(STATE_CONNECTION_FAILED);
// Start the service over to restart listening mode
BluetoothChatService.this.start();
}
/**
* Indicate that the connection was lost and notify the UI Activity.
*/
private void connectionLost() {
// Send a failure message back to the Activity
setState(STATE_CONNECTION_LOST);
// Start the service over to restart listening mode
BluetoothChatService.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(getClass().getName(), "Socket Type: " + mSocketType + "listen() failed", e);
}
mmServerSocket = tmp;
}
public void run() {
Log.d(getClass().getName(), "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
socket = mmServerSocket.accept();
} catch (IOException e) {
Log.e(getClass().getName(), "Socket Type: " + mSocketType + "accept() failed", e);
break;
}
// 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(),
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(getClass().getName(), "Could not close unwanted socket", e);
}
break;
}
}
}
}
Log.i(getClass().getName(), "END mAcceptThread, socket Type: " + mSocketType);
}
public void cancel() {
Log.d(getClass().getName(), "Socket Type" + mSocketType + "cancel " + this);
try {
mmServerSocket.close();
} catch (IOException e) {
Log.e(getClass().getName(), "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 BluetoothSocket mmSocket;
private final BluetoothDevice mmDevice;
private String mSocketType;
public ConnectThread(BluetoothDevice device, boolean secure) {
mmDevice = device;
BluetoothSocket tmp = null;
mSocketType = secure ? "Secure" : "Insecure";
// Get a BluetoothSocket for a connection with the
// given BluetoothDevice
try {
if (secure) {
tmp = device.createRfcommSocketToServiceRecord(
MY_UUID_SECURE);
} else {
tmp = device.createInsecureRfcommSocketToServiceRecord(
MY_UUID_INSECURE);
}
} catch (IOException e) {
Log.e(getClass().getName(), "Socket Type: " + mSocketType + "create() failed", e);
}
mmSocket = tmp;
Log.i(getClass().getName(), "mmSocket :" + mmSocket);
}
public void run() {
Log.i(getClass().getName(), "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 {
Log.e(getClass().getName(), "Couldn't establish Bluetooth connection. Exception :" + e + "Exception message : "+e.getMessage() );
// mmSocket =(BluetoothSocket) mmDevice.getClass().getMethod("createRfcommSocket", new Class[] {int.class}).invoke(mmDevice,1);
// mmSocket.connect();
mmSocket.close();
} catch (Exception e2) {
Log.e(getClass().getName(), "Failed to close socket :" + e + "Exception message : "+e.getMessage() );
}
connectionFailed();
return;
}
// Reset the ConnectThread because we're done
synchronized (BluetoothChatService.this) {
mConnectThread = null;
}
// Start the connected thread
connected(mmSocket, mmDevice, mSocketType);
}
public void cancel() {
try {
mmSocket.close();
} catch (IOException e) {
Log.e(getClass().getName(), "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(getClass().getName(), "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(getClass().getName(), "temp sockets not created", e);
}
mmInStream = tmpIn;
mmOutStream = tmpOut;
}
public void run() {
Log.i(getClass().getName(), "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
mHandler.obtainMessage(Constants.MESSAGE_READ, bytes, -1, buffer)
.sendToTarget();
} catch (IOException e) {
Log.e(getClass().getName(), "disconnected", e);
connectionLost();
// Start the service over to restart listening mode
BluetoothChatService.this.start();
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
mHandler.obtainMessage(Constants.MESSAGE_WRITE, -1, -1, buffer)
.sendToTarget();
} catch (IOException e) {
Log.e(getClass().getName(), "Exception during write", e);
}
}
public void cancel() {
try {
mmSocket.close();
} catch (IOException e) {
Log.e(getClass().getName(), "close() of connect socket failed", e);
}
}
}
}
package com.accenture.bluetoothchatlibrary.bluetooth;
import android.bluetooth.BluetoothAdapter;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Handler;
import android.os.Message;
import com.accenture.bluetoothchatlibrary.model.BluetoothDevice;
import com.accenture.bluetoothchatlibrary.service.BluetoothChatService;
import com.accenture.bluetoothchatlibrary.utility.Constants;
import java.util.ArrayList;
import java.util.List;
import java.util.Set;
import java.util.UUID;
/**
* Created by dipti.khurana on 2/24/2016.
*/
public class BluetoothConnector {
List<BluetoothDevice> newDeviceList;
List<BluetoothDevice> pairedDeviceList;
private BlueToothResponse mResponse;
private BluetoothAdapter mBtAdapter;
private Context mContext;
private String connectedDevice;
private BluetoothChatResponse chatResponse;
private BluetoothChatService mChatService = null;
public BluetoothConnector(Context ctx, BlueToothResponse response, BluetoothChatResponse chatResponse) {
this.chatResponse = chatResponse;
this.mResponse = response;
mContext = ctx;
mBtAdapter = BluetoothAdapter.getDefaultAdapter();
checkBluetoothConnectivity();
}
public BlueToothResponse getmResponse() {
return mResponse;
}
public void setmResponse(BlueToothResponse mResponse) {
this.mResponse = mResponse;
}
public List<BluetoothDevice> getPairedDevices() {
Set<android.bluetooth.BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices();
if (pairedDevices.size() > 0) {
this.pairedDeviceList = new ArrayList<>();
for (android.bluetooth.BluetoothDevice device : pairedDevices) {
pairedDeviceList.add(new BluetoothDevice(device.getName(), device.getAddress()));
}
}
return pairedDeviceList;
}
public void connectDevice(String address) {
android.bluetooth.BluetoothDevice device = mBtAdapter.getRemoteDevice(address);
// Attempt to connect to the device
/* for (int i=1; i<=1;i++){
mChatService.connect(UUID.fromString("8ce255c0-200a-11e0-ac64-0800200c9a"+i+i),device, true);
}*/
mChatService.connect(device, true);
}
public void checkBluetoothConnectivity() {
if (mBtAdapter != null && !mBtAdapter.isEnabled()) {
getmResponse().onBluetoothStatusReturned(BluetoothStatus.BLUETOOTH_NOT_AVAILABLE);
} else {
if (mBtAdapter != null && mChatService == null) {
mChatService = new BluetoothChatService(mContext, mHandler);
if (mChatService != null) {
if (mChatService.getState() == BluetoothChatService.STATE_NONE) {
// Start the Bluetooth chat services
mChatService.start();
}
}
}
}
}
public void registerReciever() {
IntentFilter filter = new IntentFilter(android.bluetooth.BluetoothDevice.ACTION_FOUND);
mContext.registerReceiver(mReceiver, filter);
// Register for broadcasts when discovery has finished
filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
mContext.registerReceiver(mReceiver, filter);
}
/**
* Sends a message.
*
* @param message A string of text to send.
*/
public void sendMessage(String message) {
// Check that we're actually connected before trying anything
if (mChatService.getState() != BluetoothChatService.STATE_CONNECTED) {
mResponse.onBluetoothStatusReturned(BluetoothStatus.BLUETOOTH_CONNECTION_LOST);
return;
}
// Check that there's actually something to send
if (message.length() > 0) {
// Get the message bytes and tell the BluetoothChatService to write
byte[] send = message.getBytes();
mChatService.write(send);
}
}
public void startScanning() {
checkBluetoothConnectivity();
registerReciever();
if (mBtAdapter.isDiscovering()) {
mBtAdapter.cancelDiscovery();
}
mBtAdapter.startDiscovery();
}
/**
* The BroadcastReceiver that listens for discovered devices and changes the title when
* discovery is finished
*/
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
// When discovery finds a device
if (android.bluetooth.BluetoothDevice.ACTION_FOUND.equals(action)) {
// Get the BluetoothDevice object from the Intent
android.bluetooth.BluetoothDevice device = intent.getParcelableExtra(android.bluetooth.BluetoothDevice.EXTRA_DEVICE);
// If it's already paired, skip it, because it's been listed already
if (device.getBondState() != android.bluetooth.BluetoothDevice.BOND_BONDED) {
newDeviceList = new ArrayList<BluetoothDevice>();
newDeviceList.add(new BluetoothDevice(device.getName(), device.getAddress()));
}
// When discovery is finished, change the Activity title
} else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
if (null != getmResponse()) {
getmResponse().onDeviceListReturned(newDeviceList);
}
mContext.unregisterReceiver(mReceiver);
}
}
};
/**
* The Handler that gets information back from the BluetoothChatService
*/
private final Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case Constants.MESSAGE_STATE_CHANGE:
switch (msg.arg1) {
case BluetoothChatService.STATE_CONNECTED:
// setStatus(getString(R.string.title_connected_to, mConnectedDeviceName));
// mConversationArrayAdapter.clear();
mResponse.onBluetoothStatusReturned(BluetoothStatus.BLUETOOTH_CONNECTED);
break;
case BluetoothChatService.STATE_CONNECTING:
mResponse.onBluetoothStatusReturned(BluetoothStatus.BLUETOOH_CONECTING);
break;
case BluetoothChatService.STATE_LISTEN:
break;
case BluetoothChatService.STATE_CONNECTION_FAILED:
mResponse.onBluetoothStatusReturned(BluetoothStatus.BLUETOOTH_CONNECTION_FAILED);
connectedDevice = null;
break;
case BluetoothChatService.STATE_CONNECTION_LOST:
mResponse.onBluetoothStatusReturned(BluetoothStatus.BLUETOOTH_CONNECTION_LOST);
connectedDevice = null;
break;
case BluetoothChatService.STATE_NONE:
break;
}
break;
case Constants.MESSAGE_WRITE:
byte[] writeBuf = (byte[]) msg.obj;
// construct a string from the buffer
String writeMessage = new String(writeBuf);
chatResponse.messageSent(writeMessage);
//Toast.makeText(mContext, "Sent :" + writeMessage, Toast.LENGTH_LONG).show();
break;
case Constants.MESSAGE_READ:
byte[] readBuf = (byte[]) msg.obj;
// construct a string from the valid bytes in the buffer
String readMessage = new String(readBuf, 0, msg.arg1);
chatResponse.onMessageRecieved(connectedDevice, readMessage);
// Toast.makeText(mContext, "Recieved :" + readMessage, Toast.LENGTH_LONG).show();
break;
case Constants.MESSAGE_DEVICE_NAME:
// save the connected device's name
connectedDevice = msg.getData().getString(Constants.DEVICE_NAME);
break;
}
}
};
public void makeDiscoverable() {
if (mBtAdapter.getScanMode() !=
BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {
Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
mContext.startActivity(discoverableIntent);
}
}
public enum BluetoothStatus {
BLUETOOTH_NOT_AVAILABLE, BLUETOOTH_CONNECTED, BLUETOOH_CONECTING, BLUETOOTH_CONNECTION_FAILED, BLUETOOTH_CONNECTION_LOST;
}
}
