如何在Android上实现蓝牙聊天功能？

Android实现蓝牙聊天功能需要使用Bluetooth API进行设备搜索、配对，建立连接后通过输入输出流传输消息。

Android实现蓝牙聊天功能

一、前言

随着移动设备的普及，蓝牙技术已经成为一种常见的无线通信方式，在Android平台上，通过蓝牙实现设备之间的数据传输和通讯是一种非常实用的功能，本文将详细讲解如何在Android应用中实现一个简单的蓝牙聊天功能，包括蓝牙的搜索、配对、连接以及数据的发送和接收。

二、准备工作

在开始编写代码之前，需要确保开发环境配置正确，以下是所需的工具和库：

1、Android Studio: 官方集成开发环境（IDE）。

2、BluetoothAdapter: Android提供的用于管理蓝牙功能的类。

3、BluetoothSocket: 用于蓝牙通信的套接字。

4、BluetoothDevice: 表示远程蓝牙设备。

5、Handler: 用于处理消息传递。

6、Message: 用于封装信息。

7、UUID: 通用唯一识别码，用于标识服务。

三、项目结构

为了便于管理和理解，建议按照以下目录结构组织项目：

src/main/java

com.example.bluetoothchat

BluetoothChatActivity.java: 主活动类。

BluetoothService.java: 蓝牙服务类。

Constants.java: 常量定义文件。

MessageHandler.java: 消息处理类。

四、常量定义 (Constants.java)

package com.example.bluetoothchat;
public class Constants {
    public static final String DEVICE_NAME = "MyBluetoothChat"; // 设备名称
    public static final UUID MY_UUID = java.util.UUID.randomUUID(); // 随机生成一个UUID
}

五、蓝牙服务类 (BluetoothService.java)

这个类负责蓝牙的初始化、搜索、配对和连接等操作。

package com.example.bluetoothchat;
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 java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;
public class BluetoothService {
    private static final String TAG = "BluetoothService";
    private static final int STATE_NONE = 0;          // we're doing nothing
    private static final int STATE_LISTEN = 1;        // now listening for incoming connections
    private static final int STATE_CONNECTING = 2;    // there is an active connection
    private static final int STATE_CONNECTED = 3;    // now connected to a remote device
    private BluetoothAdapter mAdapter;
    private Context mContext;
    private Handler mHandler;
    private AcceptThread mAcceptThread;
    private ConnectThread mConnectThread;
    private ConnectedThread mConnectedThread;
    private int mState;
    private UUID mUUID;
    private final BluetoothAdapter.LeScanCallback mLeScanCallback = new BluetoothAdapter.LeScanCallback() {
        @Override
        public void onLeScan(final BluetoothDevice device, int rssi, byte[] scanRecord) {
            mHandler.obtainMessage(Constants.MESSAGE_DEVICE_NAME, device).sendToTarget();
        }
    };
    public BluetoothService(Context context, Handler handler) {
        mAdapter = BluetoothAdapter.getDefaultAdapter();
        mState = STATE_NONE;
        mHandler = handler;
        mUUID = Constants.MY_UUID;
        mContext = context;
    }
    private synchronized void setState(int state) {
        mState = state;
        mHandler.obtainMessage(Constants.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
    }
    private synchronized void start() {
        if (D) Log.d(TAG, "start");
        if (mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }
        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }
        if (mAcceptThread == null) {
            mAcceptThread = new AcceptThread();
            mAcceptThread.start();
            setState(STATE_LISTEN);
        }
        if (mScanning) {
            mAdapter.stopLeScan(mLeScanCallback);
            setState(STATE_NONE);
            return;
        }
    }
    private synchronized void connect(BluetoothDevice device) {
        if (D) Log.d(TAG, "connect to: " + device);
        if (mState == STATE_CONNECTING) {
            if (mConnectThread != null) {
                mConnectThread.cancel();
                mConnectThread = null;
            }
        }
        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }
        mConnectThread = new ConnectThread(device);
        mConnectThread.start();
        setState(STATE_CONNECTING);
    }
    private synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
        if (D) Log.d(TAG, "connected");
        if (mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }
        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }
        if (mAcceptThread != null) {
            mAcceptThread.cancel();
            mAcceptThread = null;
        }
        mConnectedThread = new ConnectedThread(socket);
        mConnectedThread.start();
        setState(STATE_CONNECTED);
        Message msg = mHandler.obtainMessage(Constants.MESSAGE_TOAST);
        Bundle bundle = new Bundle();
        bundle.putString("toast", "Connected to " + device.getName());
        msg.setData(bundle);
        mHandler.sendMessage(msg);
    }
    private synchronized void stop() {
        if (D) Log.d(TAG, "stop");
        if (mConnectThread != null) {
            mConnectThread.cancel();
            mConnectThread = null;
        }
        if (mConnectedThread != null) {
            mConnectedThread.cancel();
            mConnectedThread = null;
        }
        if (mAcceptThread != null) {
            mAcceptThread.cancel();
            mAcceptThread = null;
        }
        setState(STATE_NONE);
    }
    public synchronized void write(byte[] out) {
        Log.d(TAG, "write: Write message: " + new String(out));
        if (mConnectedThread != null) {
            mConnectedThread.write(out);
        } else {
            Log.w(TAG, "write: Not connected");
        }
    }
    public void startDiscovery() {
        if (mAdapter.isDiscovering()) {
            mAdapter.cancelDiscovery();
        } else {
            mAdapter.startDiscovery();
        }
    }
    // Create a new server socket using the UUID from the profile name and listen for incoming connections.
    private class AcceptThread extends Thread {
        private final BluetoothServerSocket mmServerSocket;
        private String mSocketType;
        public AcceptThread() {
            BluetoothServerSocket tmp = null;
            mSocketType = "Secure";
            try {
                if (secure) {
                    tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
                } else {
                    tmp = mAdapter.listenUsingInsecureRfcommWithServiceRecord(NAME, MY_UUID);
                    mSocketType = "Insecure";
                }
            } catch (IOException e) {
                Log.e(TAG, "Socket Type: " + mSocketType + "createListener() failed", e);
            }
            mmServerSocket = tmp;
            mAdapter.cancelDiscovery();
        }
        public void run() {
            if (D) Log.d(TAG, "BEGIN mAcceptThread" + this);
            setName("AcceptThread");
            BluetoothSocket socket = null;
            while (mState != STATE_CONNECTED) {
                try {
                    socket = mmServerSocket.accept();
                } catch (IOException e) {
                    Log.e(TAG, "accept() failed", e);
                    break;
                }
                if (socket != null) {
                    synchronized (BluetoothService.this) {
                        switch (mState) {
                            case STATE_LISTEN:
                            case STATE_CONNECTTHEM:
                                connected(socket, socket.getRemoteDevice());
                                break;
                            case STATE_NONE:
                            case STATE_CONNECTED:
                                try {
                                    mmServerSocket.close();
                                      } catch (IOException e) {
                                          Log.e(TAG, "Could not close unwanted socket", e);
                                      } break;
                        }
                    }
                }
            }
            if (D) Log.i(TAG, "END mAcceptThread", this);
            setState(STATE_NONE);
            mAcceptThread = null;
            if (mConnectedThread != null) {
                mConnectedThread.cancel();
                mConnectedThread = null;
            }
            if (mmServerSocket != null) {
                try {
                    mmServerSocket.close();
                } catch (IOException e) {
                    Log.e(TAG, "Could not close server socket", e);
                }
            }
        }
        void cancel() {
            mAcceptThread.interrupt();
        }
    }
    // This thread runs while attempting to make an outgoing connection with a device. It runs until it either: establishes a connection and returns or each connection attempt fails to connect then records a message and quits.
    private class ConnectThread extends Thread {
        private final BluetoothSocket mmSocket;
        private final BluetoothDevice mmDevice;
        private String mSocketType;
        public ConnectThread(BluetoothDevice device) {
            mmDevice = device;
            BluetoothSocket tmp = null;
            mSocketType = "Secure";
            try {
                if (secure) {
                    tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
                } else {
                    tmp = device.createInsecureRfcommSocketToServiceRecord(MY_UUID);
                    mSocketType = "Insecure";
                }
            } catch (IOException e) {
                Log.e(TAG, "Socket Type: " + mSocketType + "create() failed", e);
            }
            mmSocket = tmp;
        }
        public void run() {
            mAdapter.cancelDiscovery();
            setName("ConnectThread");
            setState(STATE_CONNECTING);
            try {
                mmSocket.connect();
            } catch (IOException e) {
                connectionFailed();
                try {
                    mmSocket.close();
                } catch (IOException e2) {
                    Log.e(TAG, "unable to close() " + mSocketType + " socket during connection failure", e2);
                }
                return;
            } finally { }
            connected(mmSocket, mmDevice);
        }
        void cancel() {
            try {
                mmSocket.close();
            } catch (IOException e) { } because you cannot reliably close input stream here due to possible blocking by buffered I/O operations System.exit(0); } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } ) new Handler() { @Override public void handleMessage(Message msg) { switch (msg.what) { case MESSAGE_READ: byte[] readBuf = (byte[]) msg.obj; String action = new String(readBuf, 0, msg.arg1, "utf-8"); if (true) { Log.d(TAG, "Read: " + action); } return true; case MESSAGE_WRITE: byte[] writeBuf = (byte[]) msg.obj; Integer wrote = msg.arg1; if (true) { Log.d(TAG, "Write: " + new String(writeBuf, 0, writeBuf.length, "utf-8")); } return true; case MESSAGE_DEVICE_NAME: msg.obj = msg.obj + "
Rename me"; break; case MESSAGE_TOAST: Toast msg = msg.obj; msg.show(); break; case MESSAGE_STATE_CHANGE: switch (msg.arg1) { case BluetoothService.STATE_NONE: break; case BluetoothService.STATE_LISTEN: break; case BluetoothService.STATE_CONNECTING: break; case BluetoothService.STATE_CONNECTED: break; case BluetoothService.STATE_MESSAGE_READ: break; default: break; } break; default: super.handleMessage(msg); } } ); private class ConnectedThread extends Thread { private final BluetoothSocket mmSocket; private final InputStream mmInStream; private final OutputStream mmOutStream public ConnectedThread(BluetoothSocket socket) { mmSocket = socket; InputStream tmpIn = null; OutputStream tmpOut = null; 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() { byte[] buffer = new byte[1024]; int numBytes; while (true) { try { numBytes = mmInStream.read(buffer); String readMessage = new String(buffer, 0, numBytes, "UTF-8"); mHandler.obtainMessage(BluetoothService.MESSAGE_READ, buffer, 0, numBytes).sendToTarget(); } catch (IOException e) { Log.d(TAG, "Input stream was disconnected", e); break; } } } void write(byte[] bytes) { try { mmOutStream.write(bytes); mHandler.obtainMessage(BluetoothService.MESSAGE_WRITE, bytes, bytes.length).sendToTarget(); } catch (IOException e) { Log.e(TAG, "Error occurred when sending data", e); break; } finally { try { mmInStream.close(); } catch (IOException e) { Log.e(TAG, "Error closing input stream", e); } catch (NullPointerException e2) { Log.e(TAG, "Null pointer exception on input stream close", e2); } finally { try { mmOutStream.close(); } catch (IOException e) { Log.e(TAG, "Error closing output stream", e); } catch (NullPointerException e2) { Log.e(TAG, "Null pointer exception on output stream close", e2); } finally { try { mmSocket.close(); } catch (IOException e) { Log.e(TAG, "Error closing socket", e); } finally { super.finalize(); } }}}}};```

各位小伙伴们，我刚刚为大家分享了有关“Android实现蓝牙聊天功能”的知识，希望对你们有所帮助。如果您还有其他相关问题需要解决，欢迎随时提出哦！