连接蓝牙设备失败
Posted
技术标签:
【中文标题】连接蓝牙设备失败【英文标题】：Connection to Bluetooth device fail 【发布时间】：2016-09-01 08:19:55 【问题描述】：我有一个配对设备的listView，点击所选索引后，我将连接到它。
listView_pairedDevices.setOnItemClickListener(new AdapterView.OnItemClickListener()
@Override
public void onItemClick(AdapterView<?> adapterView, View view, int position, long id)
String deviceInfo = listAdapter_pairedDevices.getItem(position - 1);
String lines[] = deviceInfo.split("\\r?\\n");
String deviceAddress = lines[1];
BluetoothDevice selectedDevice = btAdapter.getRemoteDevice(deviceAddress);
btChatService.connect(selectedDevice, false);
);
BluetoothChatService类
/**
* This class does all the work for setting up and managing Bluetooth
* connections with other devices. It has a thread that listens for
* incoming connections, a thread for connecting with a device, and a
* thread for performing data transmissions when connected.
*/
public class BluetoothChatService
// Debugging
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_SECURE = "BluetoothChatSecure";
private static final String NAME_INSECURE = "BluetoothChatInsecure";
// Unique UUID for this application
public static final UUID MY_UUID_SECURE =
UUID.fromString("51eb1e18-700c-11e6-8b77-86f30ca893d3");
public static final UUID MY_UUID_INSECURE =
UUID.fromString("51eb1e18-700c-11e6-8b77-86f30ca893d3");
//public boolean btAutoConnect = false;
// 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
/**
* 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)
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(MainActivity.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;
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)
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, 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)
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(MainActivity.MESSAGE_DEVICE_NAME);
Bundle bundle = new Bundle();
bundle.putString(MainActivity.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 (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
Message msg = mHandler.obtainMessage(MainActivity.MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(MainActivity.TOAST, "Listening for device ...");
msg.setData(bundle);
mHandler.sendMessage(msg);
// Start the service over to restart listening mode
BluetoothChatService.this.start();
Log.e(TAG, "Connection Fail");
/**
* Indicate that the connection was lost and notify the UI Activity.
*/
private void connectionLost()
// Send a failure message back to the Activity
Message msg = mHandler.obtainMessage(MainActivity.MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(MainActivity.TOAST, "Device connection was lost");
msg.setData(bundle);
mHandler.sendMessage(msg);
// Start the service over to restart listening mode
BluetoothChatService.this.start();
//btAutoConnect = true;
/**
* 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
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 (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(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
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 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(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 (BluetoothChatService.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");
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(MainActivity.MESSAGE_READ, bytes, -1, buffer)
.sendToTarget();
catch (IOException e)
Log.e(TAG, "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(MainActivity.MESSAGE_WRITE, -1, -1, buffer)
.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);
我的 logcat 一直连接失败
09-01 16:11:32.085 3255-3255/com.example.matamatamata.mdpbtlayout D/ViewRootImpl: ViewPostImeInputStage ACTION_DOWN
09-01 16:11:32.225 3255-3255/com.example.matamatamata.mdpbtlayout D/BluetoothChatService: connect to: C4:43:8F:98:9A:9A
09-01 16:11:32.225 3255-3255/com.example.matamatamata.mdpbtlayout D/BluetoothChatService: setState() 1 -> 2
09-01 16:11:32.225 3255-15464/com.example.matamatamata.mdpbtlayout I/BluetoothChatService: BEGIN mConnectThread SocketType:Insecure
[ 09-01 16:11:32.225 4143: 4210 E/ ]
### ASSERT : external/bluetooth/bluedroid/main/../btif/src/btif_dm.c line 2025 unhandled search services event (6) ###
09-01 16:11:32.235 3255-15464/com.example.matamatamata.mdpbtlayout D/BluetoothUtils: isSocketAllowedBySecurityPolicy start : device null
09-01 16:11:32.235 3255-15464/com.example.matamatamata.mdpbtlayout W/BluetoothAdapter: getBluetoothService() called with no BluetoothManagerCallback
09-01 16:11:32.235 3255-15464/com.example.matamatamata.mdpbtlayout D/BluetoothSocket: connect(), SocketState: INIT, mPfd: ParcelFileDescriptor: FileDescriptor[54]
09-01 16:11:34.315 3255-15464/com.example.matamatamata.mdpbtlayout D/BluetoothSocket: close() in, this: android.bluetooth.BluetoothSocket@1dbcf50f, channel: -1, state: INIT
09-01 16:11:34.315 3255-15464/com.example.matamatamata.mdpbtlayout D/BluetoothSocket: close() this: android.bluetooth.BluetoothSocket@1dbcf50f, channel: -1, mSocketIS: android.net.LocalSocketImpl$SocketInputStream@14b9199c, mSocketOS: android.net.LocalSocketImpl$SocketOutputStream@23459fa5mSocket: android.net.LocalSocket@19e76f7a impl:android.net.LocalSocketImpl@3dddd32b fd:FileDescriptor[54]
09-01 16:11:34.315 3255-15464/com.example.matamatamata.mdpbtlayout D/BluetoothSocket: Closing mSocket: android.net.LocalSocket@19e76f7a impl:android.net.LocalSocketImpl@3dddd32b fd:FileDescriptor[54]
09-01 16:11:34.315 3255-15464/com.example.matamatamata.mdpbtlayout D/BluetoothChatService: start
09-01 16:11:34.315 3255-15464/com.example.matamatamata.mdpbtlayout D/BluetoothSocket: close() in, this: android.bluetooth.BluetoothSocket@1dbcf50f, channel: -1, state: CLOSED
09-01 16:11:34.315 3255-15464/com.example.matamatamata.mdpbtlayout D/BluetoothChatService: setState() 2 -> 1
09-01 16:11:34.325 3255-15464/com.example.matamatamata.mdpbtlayout E/BluetoothChatService: Connection Fail
错误信息：“连接读取失败，套接字可能关闭或超时，读取ret：-1”`
【问题讨论】：
【参考方案1】：您的代码通过更改 UUID 开始工作的原因是您稍后更改的 UUID 是 serialport 的 UUID。
每当创建一个 rfcomm 服务器时，要么为它分配你自己的 UUID，要么它使用串行端口的默认 UUID (00001101-0000-1000-8000-00805F9B34FB)。现在，当您使用自己的 UUID 时，连接到服务器的客户端应用程序也应该使用与服务器相同的 UUID，然后才会建立连接。
在您的情况下，您使用的客户端应用程序必须尝试连接到串行端口的默认 UUID，因此当您更改 UUID 时，您的代码开始工作。
Service Discovery UUIDs
【讨论】：
【参考方案2】：我将我的 UUID 更改为 00001101-0000-1000-8000-00805F9B34FB 并且出于某种原因可以正常工作。我不确定为什么，也许有人喜欢对此发表评论。
【讨论】：
以上是关于连接蓝牙设备失败的主要内容，如果未能解决你的问题，请参考以下文章