经测试稳定可用的蓝牙链接通信Demo，记录过程中遇到的问题的思考和解决办法，并整理后给出一个Utils类可以简单调用来实现蓝牙功能
说明：这是本人在蓝牙开发过程中遇到过的问题记录和分析，以及解决办法。
在研究过程中，许多的前人给出的解决方案和思路指导对我相当有帮助，但并非都是可采取的解决方法，
经过本人对这些方法的测试和使用过后，给出自己的理解和解决方案，不一定是正确的，但这些方法的确可以解决问题。
如果有人遇到同样的问题，并且看到我的文章解决，那是我的荣幸。
！！！！！！但特别需要说明的是，看的越多，不明白的越多，我的看法可能是完全错误的，这些方法只是暂时解决了我的问题，
！！！！！！如果有人发现了我的错误，请私信或评论告知在下！不胜感激！
测试设备：小米手机两台 一台 API level 17，另一台 API level 21
蓝牙过程中的主要问题种类：
1.查找蓝牙设备报空指针异常
原因：蓝牙查找的操作，在系统中是异步的，若是直接顺序执行，可能查找操作的线程还没有执行完毕，所以返回值是空的！
解决办法：异步操作，得到返回结果后在继续执行后续操作，例如,通过Handler发送异步信息来执行
2.建立Server端失败，报错的种类有：
3.建立Client端时，connect链接出错，报错的种类有：
以上两种情况参见总结第二点！
4.可以成功建立连接并通信，但容易启动会失败，非常不稳定
原因：
有前辈说是因为服务端的监听端口号是随机生成的，当服务端和客户端的端口生成的号码恰好一致，那么可以稳定运行，如果不一致，则无法链接，这就是不稳定的原因。
并且给出了通过反射来固定端口来建立稳定链接的解决方法：
建立服务端：
BluetoothServerSocket this.Server = (BluetoothServerSocket) adapter.getClass().getMethod("listenUsingRfcommOn",new Class[]{int.class}).invoke(adapter,10);
建立服务端：
BluetoothSocket tmp = (BluetoothSocket) REMOTE_DEVICE.getClass().getMethod("createRfcommSocket",new Class[]{int.class}).invoke(REMOTE_DEVICE,10);
方案尝试与分析：经过追踪源码和检测端口号码，端口号的确是随机生成的，那么尝试采用反射的方法固定端口
测试结果：通过反射的方法的确可以建立稳定的连接，但是这样得到的Socket是无法通信的！
5.某次成功传递过数据后，没有关闭连接，照理来说，应该还是能够继续通信的，但若继续传递信息，毫无响应
原因：Log信息给出的是Socket已经关闭或时间超过或读取内容为-1.
分析：
执行链接操作会马上报错，不会是时间超过这个原因，而没有执行到读取的步骤，不会是读取内容出错！所以只能是Socket已关闭！
但问题是，我没有执行关闭Socket的操作！也就是说，这个Socket是系统自动关闭的！有可能是在关闭流的时候自动关闭了！
6.在某种情况下，确定通信成功率已经是可信赖的程度，但为了进一步完善继续调试的过程中出现问题，将代码回到先前成功的状态，也不能正常运行了
原因：
本着从可用的情况下逐步修改，直到不可用的那一步，那么这一步就是出错的原因，这个思想原本是十分有效和科学的！
可是如果这种错误的出现，这种思想毫无意义！
直到相当偶然的一次情况下，我进行了接下来的操作：关闭蓝牙，删掉应用，重启机器，再次安装应用，测试！一切回复正常，完美运行！
而在接下来的调试过程中，遇到了同样的问题，通过这样的操作，也多次验证了这个方法可以解决这个问题。（传说中的重启解决一切问题！！！！！！）
而我自己曾经遇到过一个问题：说我的应用已经注册了20个Service，已经没有可用空间了！
这里特别提醒：
1.蓝牙测试过程中，非常容易崩溃，如果动态注册了广播，而程序直接崩溃就无法执行取消注册的操作，这样就非常容易注册了20个Service，且目前为止，本人没有找到一个方法来取消应用注册的广播
2.初始化服务端，建立UUID监听，也是一个Service，如果程序直接崩溃，没有关闭，也会成为一个无法取消注册的Service
注：这个错误的的LOG信息显示，这是Native层的代码！而这种情况也会直接导致无法创建新的蓝牙设备通信的服务端！
如何解决这个问题？
重启大法：卸载应用，重启开启手机，再次安装应用！
原理：重启系统，等于重新初始化Davik虚拟机，而在初始化的时候，由于已经卸载了应用，没有加载我们写的应用的相关信息！这样一来，注册过的服务信息就取消了！
蓝牙设备在测试使用过程中，会出现多次崩溃，很容易产生问题，而蓝牙是通过JNI调用Native层代码里间接实现的，并非应用能够操作的范围！
崩溃的影响只能通过重新启动来清除！
总结：
原本有很多的问题出现，并且困扰我很久，但现在做出来了，我却已经无法再次故意产生当时的那种错误！
我只能理解为：当时之所以发生问题，是有什么地方我没有正确理解！
如果你看完这篇文章，做了同样的代码或直接用我的Util类，依然没有解决与我相同的问题，那么可能有一句话对你有帮助：
无法实现的原因，其问题不是出在代码运行上，而是处在交互过程上！
1.蓝牙服务端一个UUID，只能创建一个Server，并且用完记得关闭，若是没有关闭会影响接下来的使用。但客户端可以通过同一个UUID连接到一个Server,该功能需要设备的支持（Android版本大于lolipop）。
2.蓝牙需要遵循一用一连的模式，连完要关闭！
服务端Server若是没有关闭，不能再次创建Server，而Server没有处于accpte状态，客户端也是无法实现链接的
（这一点至关重要！这一点至关重要！这一点至关重要！
本人的很多问题都是没有遵循这一模式而出现的错误！）
本人写的Util类也没有关闭Server端创建时的ServerSocket，因为直接关闭会导致无法通信。
接下来贴出一个本人写的用于蓝牙操作的工具类，通过对这个类可以简单调用来使用蓝牙功能，相应的解释在注释里相当清楚不再多说：
public class bluetoothUtils {
//本机为NATIVE_DEVICE,连接的机器为REMOTE_DEVICE
private BluetoothDevice REMOTE_DEVICE;
//类似于Socket中的id地址，但是不知为何原因，这里必须使用这个的UUID
protected static final UUID uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB");
//蓝牙适配器，一般使用系统默认的
private BluetoothAdapter adapter;
//用来发送寻找蓝牙设备的请求码
private static final int REQUES_CODE = 1234;
private static final String ServerName = "自定义蓝牙服务器";
//存放查找到的蓝牙设备的容器
private Set<BluetoothDevice> ParieDevices;
//这里的Server是一个服务端线程对象，具体的服务端数据在线程内部操作
public BluetoothServerSocket Server; //这里属性设置为公开的，是为了提供通过util类直接操作对应线程的渠道
//客户端同服务端
public BluetoothSocket Client;
//蓝牙的搜索操作是通过广播给出结果的，所以需要在Activity中去进行接受和处理，
//如果是在Fragment中，由于Activity和Fragment是相互关联的，可以使用getActivity（）间接操作
private Activity activity;
public bluetoothUtils(Activity activity) {
this.adapter = BluetoothAdapter.getDefaultAdapter();
this.activity = activity;
}
/*
* ！这是一个异步的操作，若是顺序调用的话，容易产生空指针异常
* */
public Set<BluetoothDevice> QueryDevice() {
if (adapter.isEnabled()) {
//开启查找周围的蓝牙设备，但是搜索到的结果是通过广播消息类发送的，需要使用广播来接收结果
adapter.startDiscovery();
//获取已经绑定过的蓝牙设备
this.ParieDevices = adapter.getBondedDevices();
if (this.ParieDevices.size() > 0) {
return this.ParieDevices;
} else {
return null;
}
}else{
Intent i = new Intent(adapter.ACTION_REQUEST_ENABLE);
this.activity.startActivityForResult(i, REQUES_CODE);
adapter.enable();
//打开蓝牙设备后再次调用查找方法
return QueryDevice();
}
}
/*
* 当获取到结果后，增加记录并通知更新，但需要注意的是这个容易里存放的是已经匹配过的蓝牙设备！
* */
public void addAndNotify(BluetoothDevice device){
this.ParieDevices.add(device);
notify();
}
/*
* 这是用于匹配已经匹配过的蓝牙设备的方法，如果一个蓝牙设备未曾匹配过，则无法通过本方法实现匹配
* */
public boolean Match(String address) {
if (adapter.isDiscovering()){
adapter.cancelDiscovery();
}
this.REMOTE_DEVICE = adapter.getRemoteDevice(address);
if (this.REMOTE_DEVICE.getAddress() == address) {
//设定返回值是为了给出是否匹配成功的响应
return true;
}
return false;
}
/*
* 特别需要说明的是，本方法中的accpte方法是线程阻塞运行的
* 考虑后，选择保持他阻塞的特点，在调用时再使用异步操作，
* 这样做的好处是，保留了系统原本阻塞的特点，只在最终步骤编写的时候再去异步操作，方便调度和监听
* */
public BluetoothSocketManager createServer(){
this.Server = new Server(adapter,ServerName,uuid).getServerSocket();
BluetoothSocket temp = null;
try {
temp = this.Server.accept(30000);
} catch (IOException e) {
e.printStackTrace();
}
return new BluetoothSocketManager(temp);
}
/*
* 不要重复调用本方法，一个UUID只能使用一次，作为客户端或服务端连接对方，重复调用会失败！
* */
public BluetoothSocketManager createClient(){
return new BluetoothSocketManager(new Client(REMOTE_DEVICE).getClientSocket());
}
/*
* Server类
* @ServerName : 服务端的名称，默认使用Util类的预定名称：自定义蓝牙服务端
* @uuid : 类似与IP和域名一样，用来匹配链接的编码，原本是可以随机生成和使用的，但是为了能够正确连接客户端和服务端，默认使用Util的预定UUID
* 特别说明：安卓手机与蓝牙模块连接的话，一定要使用Util类预定义的那个UUID！
* 而蓝牙链接是一个近距离的临时连接，无需担心安全问题，可以统一使用预定义的UUID：00001101-0000-1000-8000-00805F9B34FB。
* */
class Server{
private BluetoothServerSocket Server;
public Server(BluetoothAdapter adapter,String ServerName,UUID uuid) {
try {
this.Server = adapter.listenUsingInsecureRfcommWithServiceRecord(ServerName,uuid);
} catch (IOException e) {
e.printStackTrace();
}
}
public BluetoothServerSocket getServerSocket(){
return this.Server;
}
}
/*
* Client类
* @UUID： 同Server的UUID一样，用来实现连接的身份地址，统一使用：00001101-0000-1000-8000-00805F9B34FB。
* */
class Client{
private BluetoothSocket Client;
public Client(BluetoothDevice device) {
try {
this.Client = device.createRfcommSocketToServiceRecord(uuid);
} catch (IOException e) {
e.printStackTrace();
}
run();
}
/*
* 建立了链接的信息不能马上链接，设置了本方法作为缓冲，
* 只有通过调用本方法才会去链接，然后通过getClientSocket返回本Socket的信息，用于建立Manager对象
* */
private void run() {
try {
this.Client.connect();
} catch (IOException e) {
e.printStackTrace();
}
}
public BluetoothSocket getClientSocket(){
return this.Client;
}
}
/*
* Manager类
* 说明：
* 1.通过Util类的createServer和createClient都可以获得Manager对象，这也是预定义的新建方法。
* 2.由于保持链接和消息交互需要一条独立的线程来完成，所以选择继承线程类，使得Manager对象可以被当作线程来操作
*
* @监听消息：.在新建完成后，调用线程的start方法，即可启动输入消息的监听，而监听到消息后，默认进行当前界面Toast显示，可以自行更改，只是需要注意线程调度问题
* @发送消息： 通过write（）方法来发送
*
* 特别注意：这是一个一直运行的线程对象，一定要记得调用Destory方法后，摧毁该线程，避免泄露。
* */
public class BluetoothSocketManager extends Thread{
private BluetoothSocket socket;
private InputStream inputStream;
private OutputStream outputStream;
private Handler handler;
public BluetoothSocketManager(BluetoothSocket socket) {
this.socket = socket;
this.handler = new Handler(Looper.getMainLooper());
try {
this.inputStream = this.socket.getInputStream();
this.outputStream = this.socket.getOutputStream();
} catch (IOException e) {
e.printStackTrace();
}
}
/*
* Manager对象是通过继承线程类来写的，当调用线程的start方法后，就处于不断监听的状态一直读取接收到的信息
* */
@Override
public void run() {
final byte[] bytes = new byte[1024];
int i = 0;
while (true) {
try {
while ( (i = this.inputStream.read(bytes)) != -1) {
if (i > 0) {
handler.postDelayed(new Runnable() {
@Override
public void run() {
Toast.makeText(activity.getApplicationContext(),new String(bytes),Toast.LENGTH_SHORT).show();
}
},0);
}
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public void write(String s){
try {
this.outputStream.write(s.getBytes());
} catch (IOException e) {
e.printStackTrace();
}
}
/*
* 如果想要断开该Socket链接，那么千万记得调用本方法来关闭链接
* 蓝牙是通过Native层间接调用的，如果未曾关闭，很容易出现无法使用的情况
* 如果出现这种情况，万能的解决办法：卸载应用，关闭蓝牙，重启手机，重新安装
* */
public void Destory(){
try {
this.inputStream.close();
this.outputStream.close();
this.socket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
在一个Activity中的客户端和服务端使用示例：
import android.bluetooth.BluetoothDevice;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.view.View;
import android.widget.TextView;
import java.util.Set;
/**
* Created by Andrew on 2016/10/15.
*/
public class MainActivity extends AppCompatActivity implements View.OnClickListener {
private TextView Show;
private com.bluetoothdemo.bluetoothUtils bluetoothUtils;
// private bluetoothUtils bluetoothUtils;
private Set<BluetoothDevice> device;
private Handler handler;
private String line;
private int i = 0;
private com.bluetoothdemo.bluetoothUtils.BluetoothSocketManager ServerManager;
private com.bluetoothdemo.bluetoothUtils.BluetoothSocketManager ClientManager;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
Show = (TextView) findViewById(R.id.textView);
bluetoothUtils = new bluetoothUtils(MainActivity.this);
findViewById(R.id.btn1).setOnClickListener(this);
findViewById(R.id.btn2).setOnClickListener(this);
findViewById(R.id.btn3).setOnClickListener(this);
findViewById(R.id.btn4).setOnClickListener(this);
handler = new Handler(){
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (msg.what == 10){
String line = (String) msg.obj;
Show.append(line);
}
// if (msg.what == Socket_Message){
// String line = (String) msg.obj;
// Show.append(line);
// }
}
};
handler.postDelayed(new Runnable() {
@Override
public void run() {
device = bluetoothUtils.QueryDevice();
}
},1000);
}
@Override
public void onClick(View v) {
switch (v.getId()){
case R.id.btn1:
bluetoothUtils.Match(device.iterator().next().getAddress());
ServerManager = bluetoothUtils.createServer();
Log.e("TAG","after initServer ");
ServerManager.write("hi!"+ i++);
ServerManager.start();
break;
case R.id.btn2:
bluetoothUtils.Match(device.iterator().next().getAddress());
ClientManager = bluetoothUtils.createClient();
ClientManager.start();
Log.e("TAG","after initClient");
break;
case R.id.btn3:
ServerManager.write("hi!"+ i++);
break;
case R.id.btn4:
ClientManager.write("hi!"+ i++);
break;
}
}
}
