- 蓝牙通信的简要设计与开发
- 实现功能
- 蓝牙通信步骤
- 蓝牙通信原理
- 具体实现
- 清单文件注册权限
- 状态描述文本及配色
- 布局文件activity_main.xml
- 菜单文件option_menu.xml
- 选择好友界面device_list.xml
- device_name.xml
- message.xml
- 蓝牙会话的服务组件ChatService
- Activity组件DeviceList
- 蓝牙会话的主Activity组件程序 BluetoothChat
- 效果展示
- 参考资料
- 源码
实现功能
使用手机蓝牙实现会话功能，即两个设备之间通过蓝牙互发消息。
蓝牙通信步骤1，首先开启蓝牙
2，搜索可用设备
3，创建蓝牙socket，获取输入输出流
4，读取和写入数据
5，断开连接关闭蓝牙
首先要知道几个类，BluetoothAdapter，BluetoothGatt，BluetoothDevice，BluetoothCattService，BluetoothCattCharacteristic。
第一个是蓝牙设配器，对蓝牙的操作都需要用到它，很重要，BluetoothGatt作为中央来使用和处理数据，使用时有一个回调方法BluetoothGattCallback返回中央的状态和周边提供的数据，BluetoothCattService作为周边来提供数据；BluetoothGattServerCallback返回周边的状态。BluetoothDevice是蓝牙设备，BluetoothCattCharacteristic是蓝牙设备的特征
蓝牙通信原理蓝牙通信和socket通信原理基本上是一致的，下面我给大家上一张图（图为Socket通信图）。
蓝牙客户端Socket的与Sokcet流程是一样的，只不过参数不同而已。如下：
1、创建客户端蓝牙Sokcet
2、创建连接
3、读写数据
4、关闭
服务端socket：
1、创建服务端蓝牙Socket
2、绑定端口号（蓝牙忽略）
3、创建监听listen（蓝牙忽略, 蓝牙没有此监听，而是通过whlie（true）死循环来一直监听的）
4、通过accept()，如果有客户端连接，会创建一个新的Socket，体现出并发性，可以同时与多个socket通讯）
5、读写数据
6、关闭
具体实现 清单文件注册权限状态描述文本及配色
在文件res/values/strings.xml里，添加程序运行过程中的状态描述文本及配色代码等。
布局文件activity_main.xmlMyBluetooth 发送 你没有链接一个设备 蓝牙不可用，离开聊天室 链接中... 连接到： 无链接 蓝牙设备搜索中... 选择一个好友链接 没有配对好友 附近没有发现好友 已配对好友 其它可连接好友 搜索好友 我的好友 设置在线 退出 开始聊天 结束聊天
在默认的主布局文件activity_main.xml里，添加1个Toolbar控件，其内包含2个水平的TextView控件；在Toolbar控件的下方添加1个ListView控件，用于显示聊天内容；最后在ListView控件的下方添加水平放置的1个EditText控件和一个Button控件。使用垂直线性布局并嵌套水平线性布局实现的代码如下：
菜单文件option_menu.xml
建立供主Activity使用的菜单文件res/menu/option_menu.xml
选择好友界面device_list.xml
选择好友（即已经配对过的蓝牙设备）的界面布局文件device_list.xml。
device_name.xml
message.xml
蓝牙会话的服务组件ChatService
本程序ChatService是蓝牙会话的服务程序， 定义了3个内部类：AcceptThread（接受新连接）、ConnectThread（发出连接）和ConnectedThread （已连接）其文件代码如下：
public class ChatService {
//本应用的主Activity组件名称
private static final String NAME = "BluetoothChat";
// UUID：通用唯一识别码,是一个128位长的数字，一般用十六进制表示
//算法的核心思想是结合机器的网卡、当地时间、一个随机数来生成
//在创建蓝牙连接
private static final UUID MY_UUID = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");
private final BluetoothAdapter mAdapter;
private final Handler mHandler;
private AcceptThread mAcceptThread;
private ConnectThread mConnectThread;
private ConnectedThread mConnectedThread;
private int mState;
public static final int STATE_NONE = 0;
public static final int STATE_LISTEN = 1;
public static final int STATE_ConNECTING = 2;
public static final int STATE_ConNECTED = 3;
//构造方法，接收UI主线程传递的对象
public ChatService(Context context, Handler handler) {
//构造方法完成蓝牙对象的创建
mAdapter = BluetoothAdapter.getDefaultAdapter();
mState = STATE_NONE;
mHandler = handler;
}
private synchronized void setState(int state) {
mState = state;
mHandler.obtainMessage(BluetoothChat.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();
}
public synchronized int getState() {
return mState;
}
public synchronized void 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);
}
//取消 ConNECTING 和 ConNECTED 状态下的相关线程，然后运行新的 mConnectThread 线程
public synchronized void connect(BluetoothDevice 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);
}
public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {
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();
Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_DEVICE_NAME);
Bundle bundle = new Bundle();
bundle.putString(BluetoothChat.DEVICE_NAME, device.getName());
msg.setData(bundle);
mHandler.sendMessage(msg);
setState(STATE_CONNECTED);
}
// 停止所有相关线程，设当前状态为 NONE
public synchronized void 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);
}
// 在 STATE_ConNECTED 状态下，调用 mConnectedThread 里的 write 方法，写入 byte
public void write(byte[] out) {
ConnectedThread r;
synchronized (this) {
if (mState != STATE_CONNECTED)
return;
r = mConnectedThread;
}
r.write(out);
}
// 连接失败的时候处理，通知 ui ，并设为 STATE_LISTEN 状态
private void connectionFailed() {
setState(STATE_LISTEN);
Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(BluetoothChat.TOAST, "链接不到设备");
msg.setData(bundle);
mHandler.sendMessage(msg);
}
// 当连接失去的时候，设为 STATE_LISTEN 状态并通知 ui
private void connectionLost() {
setState(STATE_LISTEN);
Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);
Bundle bundle = new Bundle();
bundle.putString(BluetoothChat.TOAST, "设备链接中断");
msg.setData(bundle);
mHandler.sendMessage(msg);
}
// 创建监听线程，准备接受新连接。使用阻塞方式，调用 BluetoothServerSocket.accept()
private class AcceptThread extends Thread {
private final BluetoothServerSocket mmServerSocket;
public AcceptThread() {
BluetoothServerSocket tmp = null;
try {
//使用射频端口（RF comm）监听
tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);
} catch (IOException e) {
}
mmServerSocket = tmp;
}
@Override
public void run() {
setName("AcceptThread");
BluetoothSocket socket = null;
while (mState != STATE_CONNECTED) {
try {
socket = mmServerSocket.accept();
} catch (IOException e) {
break;
}
if (socket != null) {
synchronized (ChatService.this) {
switch (mState) {
case STATE_LISTEN:
case STATE_CONNECTING:
connected(socket, socket.getRemoteDevice());
break;
case STATE_NONE:
case STATE_CONNECTED:
try {
socket.close();
} catch (IOException e) {
e.printStackTrace();
}
break;
}
}
}
}
}
public void cancel() {
try {
mmServerSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
private class ConnectThread extends Thread {
private final BluetoothSocket mmSocket;
private final BluetoothDevice mmDevice;
public ConnectThread(BluetoothDevice device) {
mmDevice = device;
BluetoothSocket tmp = null;
try {
tmp = device.createRfcommSocketToServiceRecord(MY_UUID);
} catch (IOException e) {
e.printStackTrace();
}
mmSocket = tmp;
}
@Override
public void run() {
setName("ConnectThread");
mAdapter.cancelDiscovery();
try {
mmSocket.connect();
} catch (IOException e) {
connectionFailed();
try {
mmSocket.close();
} catch (IOException e2) {
e.printStackTrace();
}
ChatService.this.start();
return;
}
synchronized (ChatService.this) {
mConnectThread = null;
}
connected(mmSocket, mmDevice);
}
public void cancel() {
try {
mmSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
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) {
e.printStackTrace();
}
mmInStream = tmpIn;
mmOutStream = tmpOut;
}
@Override
public void run() {
byte[] buffer = new byte[1024];
int bytes;
while (true) {
try {
bytes = mmInStream.read(buffer);
mHandler.obtainMessage(BluetoothChat.MESSAGE_READ, bytes, -1, buffer).sendToTarget();
} catch (IOException e) {
connectionLost();
break;
}
}
}
public void write(byte[] buffer) {
try {
mmOutStream.write(buffer);
mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer).sendToTarget();
} catch (IOException e) {
e.printStackTrace();
}
}
public void cancel() {
try {
mmSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
Activity组件DeviceList
本程序供菜单项主界面的选项菜单“我的友好”调用，用于：
（1）显示已配对的好友列表；
（2）搜索可配对的好友进行配对
（3）新选择并配对的蓝牙设备将刷新好友列表
注意：发现新的蓝牙设备并请求配对时，需要对应接受
关键技术：动态注册一个广播接收者，处理蓝牙设备扫描的结果
public class DeviceList extends AppCompatActivity{
private BluetoothAdapter mBtAdapter;
private ArrayAdapter mPairedDevicesArrayAdapter;
private ArrayAdapter mNewDevicesArrayAdapter;
public static String EXTRA_DEVICE_ADDRESS = "device_address"; //Mac地址
//定义广播接收者，用于处理扫描蓝牙设备后的结果
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
if (BluetoothDevice.ACTION_FOUND.equals(action)) {
BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
mNewDevicesArrayAdapter.add(device.getName() + "n" + device.getAddress());
}
} else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {
if (mNewDevicesArrayAdapter.getCount() == 0) {
String noDevices = getResources().getText(R.string.none_found).toString();
mNewDevicesArrayAdapter.add(noDevices);
}
}
}
};
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.device_list);
//在被调用活动里，设置返回结果码
setResult(Activity.RESULT_CANCELED);
init(); //活动界面
}
private void init() {
Button scanButton = findViewById(R.id.button_scan);
scanButton.setOnClickListener(new View.OnClickListener() {
public void onClick(View v) {
Toast.makeText(DeviceList.this, R.string.scanning, Toast.LENGTH_LONG).show();
doDiscovery(); //搜索蓝牙设备
}
});
mPairedDevicesArrayAdapter = new ArrayAdapter(this, R.layout.device_name);
mNewDevicesArrayAdapter = new ArrayAdapter(this, R.layout.device_name);
//已配对蓝牙设备列表
ListView pairedListView =findViewById(R.id.paired_devices);
pairedListView.setAdapter(mPairedDevicesArrayAdapter);
pairedListView.setOnItemClickListener(mPaireDeviceClickListener);
//未配对蓝牙设备列表
ListView newDevicesListView = findViewById(R.id.new_devices);
newDevicesListView.setAdapter(mNewDevicesArrayAdapter);
newDevicesListView.setOnItemClickListener(mNewDeviceClickListener);
//动态注册广播接收者
IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
registerReceiver(mReceiver, filter);
filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
registerReceiver(mReceiver, filter);
mBtAdapter = BluetoothAdapter.getDefaultAdapter();
Set pairedDevices = mBtAdapter.getBondedDevices();
if (pairedDevices.size() > 0) {
findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);
for (BluetoothDevice device : pairedDevices) {
mPairedDevicesArrayAdapter.add(device.getName() + "n" + device.getAddress());
}
} else {
String noDevices = getResources().getText(R.string.none_paired).toString();
mPairedDevicesArrayAdapter.add(noDevices);
}
}
@Override
protected void onDestroy() {
super.onDestroy();
if (mBtAdapter != null) {
mBtAdapter.cancelDiscovery();
}
this.unregisterReceiver(mReceiver);
}
private void doDiscovery() {
findViewById(R.id.title_new_devices).setVisibility(View.VISIBLE);
if (mBtAdapter.isDiscovering()) {
mBtAdapter.cancelDiscovery();
}
mBtAdapter.startDiscovery(); //开始搜索蓝牙设备并产生广播
//startDiscovery是一个异步方法
//找到一个设备时就发送一个BluetoothDevice.ACTION_FOUND的广播
}
private AdapterView.onItemClickListener mPaireDeviceClickListener = new AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView av, View v, int arg2, long arg3) {
mBtAdapter.cancelDiscovery();
String info = ((TextView) v).getText().toString();
String address = info.substring(info.length() - 17);
Intent intent = new Intent();
intent.putExtra(EXTRA_DEVICE_ADDRESS, address); //Mac地址
setResult(Activity.RESULT_OK, intent);
finish();
}
};
private AdapterView.onItemClickListener mNewDeviceClickListener = new AdapterView.OnItemClickListener() {
public void onItemClick(AdapterView av, View v, int arg2, long arg3) {
mBtAdapter.cancelDiscovery();
Toast.makeText(DeviceList.this, "请在蓝牙设置界面手动连接设备",Toast.LENGTH_SHORT).show();
Intent intent = new Intent(Settings.ACTION_BLUETOOTH_SETTINGS);
startActivityForResult(intent,1);
}
};
//回调方法：进入蓝牙配对设置界面返回后执行
@Override
protected void onActivityResult(int requestCode, int resultCode, Intent data) {
super.onActivityResult(requestCode, resultCode, data);
init(); //刷新好友列表
}
}
在清单文件里注册该activity
蓝牙会话的主Activity组件程序 BluetoothChat
使用菜单File→Refactor→Rename，重命名模块的MainActivity为BluetoothChat，它是蓝牙会话的主Activity组件程序，其文件代码如下：
public class BluetoothChat效果展示extends AppCompatActivity { public static final int MESSAGE_STATE_CHANGE = 1; public static final int MESSAGE_READ = 2; public static final int MESSAGE_WRITE = 3; public static final int MESSAGE_DEVICE_NAME = 4; public static final int MESSAGE_TOAST = 5; public static final String DEVICE_NAME = "device_name"; public static final String TOAST = "toast"; private static final int REQUEST_CONNECT_DEVICE = 1; //请求连接设备 private static final int REQUEST_ENABLE_BT = 2; private TextView mTitle; private ListView mConversationView; private EditText mOutEditText; private Button mSendButton; private String mConnectedDeviceName = null; private ArrayAdapter mConversationArrayAdapter; private StringBuffer mOutStringBuffer; private BluetoothAdapter mBluetoothAdapter = null; //TODO private com.example.mybluetooth.ChatService mChatService = null; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); //确认开发环境 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) { if (ContextCompat.checkSelfPermission(this, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) { ActivityCompat.requestPermissions(this, new String[]{Manifest.permission.ACCESS_COARSE_LOCATION}, 1); } } //TODO Toolbar toolbar = findViewById(R.id.toolbar); //创建选项菜单 toolbar.inflateMenu(R.menu.option_menu); //选项菜单监听 toolbar.setOnMenuItemClickListener(new MyMenuItemClickListener()); mTitle = findViewById(R.id.title_left_text); mTitle.setText(R.string.app_name); mTitle = findViewById(R.id.title_right_text); // 得到本地蓝牙适配器 mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter(); if (mBluetoothAdapter == null) { Toast.makeText(this, "蓝牙不可用", Toast.LENGTH_LONG).show(); finish(); return; } if (!mBluetoothAdapter.isEnabled()) { //若当前设备蓝牙功能未开启 Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE); startActivityForResult(enableIntent, REQUEST_ENABLE_BT); // } else { if (mChatService == null) { setupChat(); //创建会话 } } } @Override public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) { super.onRequestPermissionsResult(requestCode, permissions, grantResults); if (grantResults.length > 0) { if (grantResults[0] != PackageManager.PERMISSION_GRANTED) { Toast.makeText(this, "未授权，蓝牙搜索功能将不可用！", Toast.LENGTH_SHORT).show(); } } } @Override public synchronized void onResume() { //synchronized：同步方法实现排队调用 super.onResume(); if (mChatService != null) { if (mChatService.getState() == com.example.mybluetooth.ChatService.STATE_NONE) { mChatService.start(); } } } private void setupChat() { //初始化ListView适配器 mConversationArrayAdapter = new ArrayAdapter (this,R.layout.message); mConversationView = findViewById(R.id.in); mConversationView.setAdapter(mConversationArrayAdapter); mOutEditText = findViewById(R.id.edit_text_out); mOutEditText.setOnEditorActionListener(mWriteListener); mSendButton = findViewById(R.id.button_send); mSendButton.setOnClickListener(new View.OnClickListener() { public void onClick(View v) { TextView view = findViewById(R.id.edit_text_out); String message = view.getText().toString(); sendMessage(message); } }); //创建服务对象 mChatService = new com.example.mybluetooth.ChatService(this, mHandler); mOutStringBuffer = new StringBuffer(""); } @Override public void onDestroy() { super.onDestroy(); if (mChatService != null) mChatService.stop(); } private void ensureDiscoverable() { //修改本机蓝牙设备的可见性 //打开手机蓝牙后，能被其它蓝牙设备扫描到的时间不是永久的 if (mBluetoothAdapter.getScanMode() != BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) { Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE); //设置在300秒内可见（能被扫描） discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300); startActivity(discoverableIntent); Toast.makeText(this, "已经设置本机蓝牙设备的可见性，对方可搜索了。", Toast.LENGTH_SHORT).show(); } } private void sendMessage(String message) { if (mChatService.getState() != com.example.mybluetooth.ChatService.STATE_CONNECTED) { Toast.makeText(this, R.string.not_connected, Toast.LENGTH_SHORT).show(); return; } if (message.length() > 0) { byte[] send = message.getBytes(); mChatService.write(send); mOutStringBuffer.setLength(0); mOutEditText.setText(mOutStringBuffer); } } private TextView.onEditorActionListener mWriteListener = new TextView.OnEditorActionListener() { @Override public boolean onEditorAction(TextView view, int actionId, KeyEvent event) { if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_UP) { //软键盘里的回车也能发送消息 String message = view.getText().toString(); sendMessage(message); } return true; } }; //使用Handler对象在UI主线程与子线程之间传递消息 @SuppressLint("HandlerLeak") private final Handler mHandler = new Handler() { //消息处理 @Override public void handleMessage(Message msg) { switch (msg.what) { case MESSAGE_STATE_CHANGE: switch (msg.arg1) { case com.example.mybluetooth.ChatService.STATE_CONNECTED: mTitle.setText(R.string.title_connected_to); mTitle.append(mConnectedDeviceName); mConversationArrayAdapter.clear(); break; case com.example.mybluetooth.ChatService.STATE_CONNECTING: mTitle.setText(R.string.title_connecting); break; case com.example.mybluetooth.ChatService.STATE_LISTEN: case com.example.mybluetooth.ChatService.STATE_NONE: mTitle.setText(R.string.title_not_connected); break; } break; case MESSAGE_WRITE: byte[] writeBuf = (byte[]) msg.obj; String writeMessage = new String(writeBuf); mConversationArrayAdapter.add("我: " + writeMessage); break; case MESSAGE_READ: byte[] readBuf = (byte[]) msg.obj; String readMessage = new String(readBuf, 0, msg.arg1); mConversationArrayAdapter.add(mConnectedDeviceName + ": " + readMessage); break; case MESSAGE_DEVICE_NAME: mConnectedDeviceName = msg.getData().getString(DEVICE_NAME); Toast.makeText(getApplicationContext(), "链接到 " + mConnectedDeviceName, Toast.LENGTH_SHORT).show(); break; case MESSAGE_TOAST: Toast.makeText(getApplicationContext(), msg.getData().getString(TOAST), Toast.LENGTH_SHORT).show(); break; } } }; //返回进入好友列表操作后的数回调方法 public void onActivityResult(int requestCode, int resultCode, Intent data) { //TODO super.onActivityResult(requestCode, resultCode, data); switch (requestCode) { case REQUEST_CONNECT_DEVICE: if (resultCode == Activity.RESULT_OK) { String address = data.getExtras().getString(DeviceList.EXTRA_DEVICE_ADDRESS); BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address); mChatService.connect(device); } else if (resultCode == Activity.RESULT_CANCELED) { Toast.makeText(this, "未选择任何好友！", Toast.LENGTH_SHORT).show(); } break; case REQUEST_ENABLE_BT: if (resultCode == Activity.RESULT_OK) { setupChat(); } else { Toast.makeText(this, R.string.bt_not_enabled_leaving, Toast.LENGTH_SHORT).show(); finish(); } } } //内部类，选项菜单的单击事件处理 private class MyMenuItemClickListener implements Toolbar.onMenuItemClickListener { @Override public boolean onMenuItemClick(MenuItem item) { switch (item.getItemId()) { case R.id.scan: System.out.println("------------------------------在这--------"); //启动DeviceList这个Activity Intent serverIntent = new Intent(BluetoothChat.this, DeviceList.class); startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE); return true; case R.id.discoverable: ensureDiscoverable(); return true; case R.id.back: finish(); System.exit(0); return true; } return false; } } }
本例演示了使用手机蓝牙实现会话功能
运行步骤：
（1）在两个手机分别安装、运行本应用。如果未打开手机蓝牙，则进入打开蓝牙设置界面；
（2）在OptionMenu（选项菜单）里，选择“我的好友”，即可直接连接，再进行会话；
（3）新建好友前，需要先使用选项菜单“设置在线”，即要求对方可见（能被扫描到），然后，单击“搜索好友”按钮。
虚拟机效果：
在未连接状态输入
点击我的好友
点击设置在线
真机运行
打开软件
刚开始处于无连接状态
点击我的好友进行连接
互发消息
我的手机
对方手机
https://www.jianshu.com/p/8fbbc6723a7c
http://www.wustwzx.com/as/sy/sy09.html#mk2
源码gitee源码–蓝牙通信简要设计与开发
