logo
搜索
我的图书馆

发文章

发文工具

其他工具

留言交流
搜索
分享

Ophone平台蓝牙编程之蓝牙聊天分析(二)

 WindySky 2016-06-23
接着上一篇没有完成的任务，我们继续分析这个蓝牙聊天程序的实现，本文主要包括以下两个部分的内容：其一，分析扫描设备部分DeviceListActivity，其二，分析具体的聊天过程的完整通信方案，包括端口监听、链接配对、消息发送和接收等，如果有对上一篇文章不太熟悉的，可以返回去在过一次，这样会有利于本文的理解。


　　设备扫描（DeviceListActivity）
　　在上一篇文章的介绍中，当用户点击了扫描按钮之后，则会执行如下代码：

 
  1. // 启动DeviceListActivity查看设备并扫描   
  2. 　　Intent serverIntent = new Intent(this, DeviceListActivity.class);   
  3. 　　startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);  


　　该代码将跳转到DeviceListActivity进行设备的扫描，并且通过REQUEST_CONNECT_DEVICE来请求链接扫描到的设备。从AndroidManifest.xml文件中我们知道DeviceListActivity将为定义为一个对话框的风格，下图是该应用程序中，扫描蓝牙设备的截图。

　　其中DeviceListActivity则为图中对话框部分，其界面的布局如下代码所示。

  1. "http://schemas./apk/res/android"  
  2. 　　android:orientation="vertical"  
  3. 　　android:layout_width="match_parent"  
  4. 　　android:layout_height="match_parent"  
  5. 　　>   
  6. 　　   
  7. 　　"@+id/title_paired_devices"  
  8. 　　android:layout_width="match_parent"  
  9. 　　android:layout_height="wrap_content"  
  10. 　　android:text="@string/title_paired_devices"  
  11. 　　android:visibility="gone"  
  12. 　　android:background="#666"  
  13. 　　android:textColor="#fff"  
  14. 　　android:paddingLeft="5dp"  
  15. 　　/>   
  16. 　　   
  17. 　　"@+id/paired_devices"  
  18. 　　android:layout_width="match_parent"  
  19. 　　android:layout_height="wrap_content"  
  20. 　　android:stackFromBottom="true"  
  21. 　　android:layout_weight="1"  
  22. 　　/>   
  23. 　　   
  24. 　　"@+id/title_new_devices"  
  25. 　　android:layout_width="match_parent"  
  26. 　　android:layout_height="wrap_content"  
  27. 　　android:text="@string/title_other_devices"  
  28. 　　android:visibility="gone"  
  29. 　　android:background="#666"  
  30. 　　android:textColor="#fff"  
  31. 　　android:paddingLeft="5dp"  
  32. 　　/>   
  33. 　　   
  34. 　　"@+id/new_devices"  
  35. 　　android:layout_width="match_parent"  
  36. 　　android:layout_height="wrap_content"  
  37. 　　android:stackFromBottom="true"  
  38. 　　android:layout_weight="2"  
  39. 　　/>   
  40. 　　   
  41. 　　"@+id/button_scan"  
  42. 　　android:layout_width="match_parent"  
  43. 　　android:layout_height="wrap_content"  
  44. 　　android:text="@string/button_scan"  
  45. 　　/>   
  46. 　　  


　　该布局整体由一个线性布局LinearLayout组成，其中包含了两个textview中来显示已经配对的设备和信扫描出来的设备（还没有经过配对）和两个ListView分别用于显示已经配对和没有配对的设备的相关信息。按钮则用于执行扫描过程用，整个结构很简单，下面我们开始分析如何编码实现了。
　　同样开始之前，我们先确定该类中的变量的作用，定义如下：

  1. public class DeviceListActivity extends Activity {   
  2. 　　// Debugging   
  3. 　　private static final String TAG = "DeviceListActivity";   
  4. 　　private static final boolean D = true;   
  5.   
  6. 　　// Return Intent extra   
  7. 　　public static String EXTRA_DEVICE_ADDRESS = "device_address";   
  8.   
  9. 　　// 蓝牙适配器   
  10. 　　private BluetoothAdapter mBtAdapter;   
  11. 　　//已经配对的蓝牙设备   
  12. 　　private ArrayAdapter mPairedDevicesArrayAdapter;   
  13. 　　//新的蓝牙设备   
  14. 　　private ArrayAdapter mNewDevicesArrayAdapter;  

　　其中Debugging部分，同样用于调试，这里定义了一个EXTRA_DEVICE_ADDRESS，用于在通过Intent传递数据时的附加信息，即设备的地址，当扫描出来之后，返回到BluetoothChat中的onActivityResult函数的REQUEST_CONNECT_DEVICE命令，这是我们就需要通过DeviceListActivity.EXTRA_DEVICE_ADDRESS来取得该设备的Mac地址，因此当我们扫描完成之后在反馈扫描结果时就需要绑定设备地址作为EXTRA_DEVICE_ADDRESS的附加值，这和我们上一篇介绍的并不矛盾。另外其他几个变量则分别是本地蓝牙适配器、已经配对的蓝牙列表和扫描出来还没有配对的蓝牙设备列表，稍后我们可以看到对他们的使用。
　　进入DeviceListActivity之后我们首先分析onCreate，首先通过如下代码对窗口进行了设置：

  1. // 设置窗口   
  2. 　　requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);   
  3. 　　setContentView(R.layout.device_list);   
  4. 　　setResult(Activity.RESULT_CANCELED);  


　　这里我们设置了窗口需要带一个进度条，当我们在扫描时就看有很容易的高速用户扫描进度。具体布局则设置为device_list.xml也是我们文本第一段代码的内容，接下来首先初始化扫描按钮，代码如下：

  1. // 初始化扫描按钮   
  2. 　　Button scanButton = (Button) findViewById(R.id.button_scan);   
  3. 　　scanButton.setOnClickListener(new OnClickListener() {   
  4. 　　public void onClick(View v) {   
  5. 　　doDiscovery();   
  6. 　　v.setVisibility(View.GONE);   
  7. 　　}   
  8. 　　});  

　　首先取得按钮对象，然后为其设置一个事件监听，当事件触发时就通过doDiscovery函数来执行扫描操作即可，具体扫描过程稍后分析。
　　然后需要初始化用来显示设备的列表和数据源，使用如下代码即可：

  1. //初始化ArrayAdapter，一个是已经配对的设备，一个是新发现的设备   
  2. 　　mPairedDevicesArrayAdapter = new ArrayAdapter(this, R.layout.device_name);   
  3. 　　mNewDevicesArrayAdapter = new ArrayAdapter(this, R.layout.device_name);   
  4.   
  5. 　　// 检测并设置已配对的设备ListView   
  6. 　　ListView pairedListView = (ListView) findViewById(R.id.paired_devices);   
  7. 　　pairedListView.setAdapter(mPairedDevicesArrayAdapter);   
  8. 　　pairedListView.setOnItemClickListener(mDeviceClickListener);   
  9.   
  10. 　　// 检查并设置行发现的蓝牙设备ListView   
  11. 　　ListView newDevicesListView = (ListView) findViewById(R.id.new_devices);   
  12. 　　newDevicesListView.setAdapter(mNewDevicesArrayAdapter);   
  13. 　　newDevicesListView.setOnItemClickListener(mDeviceClickListener);  


　　并分别对这些列表中的选项设置了监听mDeviceClickListener，用来处理，当选择该选项时，就进行链接和配对操作。既然是扫描，我们就需要对扫描的结果进行监控，这里我们构建了一个广播BroadcastReceiver来对扫描的结果进行处理，代码如下：

  1. 　// 当一个设备被发现时，需要注册一个广播   
  2. 　　IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);   
  3. 　　this.registerReceiver(mReceiver, filter);   
  4.   
  5. 　　// 当显示检查完毕的时候，需要注册一个广播   
  6. 　　filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);   
  7. 　　this.registerReceiver(mReceiver, filter);  


　　这里我们注册到广播mReceiver的IntentFilter主要包括了发现蓝牙设备（BluetoothDevice.ACTION_FOUND）和扫描结束（BluetoothAdapter.ACTION_DISCOVERY_FINISHED），稍后我们分析如何在mReceiver中来处理这些事件。
　　最后我们需要取得本地蓝牙适配器和一些初始的蓝牙设备数据显示列表进行处理，代码如下：

  1. // 得到本地的蓝牙适配器   
  2. 　　mBtAdapter = BluetoothAdapter.getDefaultAdapter();   
  3.   
  4. 　　// 得到一个已经匹配到本地适配器的BluetoothDevice类的对象集合   
  5. 　　Set pairedDevices = mBtAdapter.getBondedDevices();   
  6.   
  7. 　　// 如果有配对成功的设备则添加到ArrayAdapter   
  8. 　　if (pairedDevices.size() > 0) {   
  9. 　　findViewById(R.id.title_paired_devices).setVisibility(View.VISIBLE);   
  10. 　　for (BluetoothDevice device : pairedDevices) {   
  11. 　　mPairedDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());   
  12. 　　}   
  13. 　　} else {   
  14. 　　 //否则添加一个没有被配对的字符串   
  15. 　　String noDevices = getResources().getText(R.string.none_paired).toString();   
  16. 　　mPairedDevicesArrayAdapter.add(noDevices);   
  17. 　　}  


　　首先通过蓝牙适配器的getBondedDevices函数取得已经配对的蓝牙设备，并将其添加到mPairedDevicesArrayAdapter数据源中，会显示到pairedListView列表视图中，如果没有已经配对的蓝牙设备，则显示一个R.string.none_paired字符串表示目前没有配对成功的设备。
　　onDestroy函数中会制定销毁操作，主要包括蓝牙适配器和广播的注销操作，代码如下：

  1. @Override  
  2. 　　protected void onDestroy() {   
  3. 　　super.onDestroy();   
  4. 　　// 确保我们没有发现，检测设备   
  5. 　　if (mBtAdapter != null) {   
  6. 　　mBtAdapter.cancelDiscovery();   
  7. 　　}   
  8. 　　// 卸载所注册的广播   
  9. 　　this.unregisterReceiver(mReceiver);   
  10. 　　}  

　　对于蓝牙适配器的取消方式则调用cancelDiscovery()函数即可，卸载mReceiver则需要调用unregisterReceiver即可。
　　做好初始化工作之后，下面我们开始分析扫描函数doDiscovery()，其扫描过程的实现很就简单，代码如下：

  1. /**  
  2. 　　* 请求能被发现的设备  
  3. 　　*/  
  4. 　　private void doDiscovery() {   
  5. 　　if (D) Log.d(TAG, "doDiscovery()");   
  6.   
  7. 　　// 设置显示进度条   
  8. 　　setProgressBarIndeterminateVisibility(true);   
  9. 　　// 设置title为扫描状态   
  10. 　　setTitle(R.string.scanning);   
  11.   
  12. 　　// 显示新设备的子标题   
  13. 　　findViewById(R.id.title_new_devices).setVisibility(View.VISIBLE);   
  14.   
  15. 　　// 如果已经在请求现实了，那么就先停止   
  16. 　　if (mBtAdapter.isDiscovering()) {   
  17. 　　mBtAdapter.cancelDiscovery();   
  18. 　　}   
  19.   
  20. 　　// 请求从蓝牙适配器得到能够被发现的设备   
  21. 　　mBtAdapter.startDiscovery();   
  22. 　　}  

　　首先通过setProgressBarIndeterminateVisibility将进度条设置为显示状态，设置标题title为R.string.scanning字符串，表示正在扫描中，代码中所说的新设备的子标题，其实就是上面我们所说的扫描到的没有经过配对的设备的title，对应于R.id.title_new_devices。扫描之前我们首先通过isDiscovering函数检测当前是否正在扫描，如果正在扫描则调用cancelDiscovery函数来取消当前的扫描，最后调用startDiscovery函数开始执行扫描操作。
　　现在已经开始扫描了，下面我们就需要对扫描过程进行监控和对扫描的结果进行处理。即我们所定义的广播mReceiver，其实现如下所示。

  1. //监听扫描蓝牙设备   
  2. 　　private final BroadcastReceiver mReceiver = new BroadcastReceiver() {   
  3. 　　@Override  
  4. 　　public void onReceive(Context context, Intent intent) {   
  5. 　　String action = intent.getAction();   
  6. 　　// 当发现一个设备时   
  7. 　　if (BluetoothDevice.ACTION_FOUND.equals(action)) {   
  8. 　　// 从Intent得到蓝牙设备对象   
  9. 　　BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);   
  10. 　　// 如果已经配对，则跳过，因为他已经在设备列表中了   
  11. 　　if (device.getBondState() != BluetoothDevice.BOND_BONDED) {   
  12. 　　 //否则添加到设备列表   
  13. 　　mNewDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());   
  14. 　　}   
  15. 　　// 当扫描完成之后改变Activity的title   
  16. 　　} else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {   
  17. 　　 //设置进度条不显示   
  18. 　　setProgressBarIndeterminateVisibility(false);   
  19. 　　//设置title   
  20. 　　setTitle(R.string.select_device);   
  21. 　　//如果计数为0，则表示没有发现蓝牙   
  22. 　　if (mNewDevicesArrayAdapter.getCount() == 0) {   
  23. 　　String noDevices = getResources().getText(R.string.none_found).toString();   
  24. 　　mNewDevicesArrayAdapter.add(noDevices);   
  25. 　　}   
  26. 　　}   
  27. 　　}   
  28. 　　};  


　　其中我们通过intent.getAction()可以取得一个动作，然后判断如果动作为BluetoothDevice.ACTION_FOUND，则表示发现一个蓝牙设备，然后通过BluetoothDevice.EXTRA_DEVICE常量可以取得Intent中的蓝牙设备对象（BluetoothDevice），然后通过条件"device.getBondState() != BluetoothDevice.BOND_BONDED"来判断设备是否配对，如果没有配对则添加到行设备列表数据源mNewDevicesArrayAdapter中，另外，当我们取得的动作为BluetoothAdapter.ACTION_DISCOVERY_FINISHED，则表示扫描过程完毕，这时首先需要设置进度条不现实，并且设置窗口的标题为选择一个设备（R.string.select_device）。当然如果扫描完成之后没有发现新的设备，则添加一个没有发现新的设备字符串（R.string.none_found）到mNewDevicesArrayAdapter中。
　　最后，扫描界面上还有一个按钮，其监听mDeviceClickListener的实现如下：

  1. // ListViews中所有设备的点击事件监听   
  2. 　　private OnItemClickListener mDeviceClickListener = new OnItemClickListener() {   
  3. 　　public void onItemClick(AdapterView av, View v, int arg2, long arg3) {   
  4. 　　// 取消检测扫描发现设备的过程,因为内非常耗费资源   
  5. 　　mBtAdapter.cancelDiscovery();   
  6.   
  7. 　　// 得到mac地址   
  8. 　　String info = ((TextView) v).getText().toString();   
  9. 　　String address = info.substring(info.length() - 17);   
  10.   
  11. 　　// 创建一个包括Mac地址的Intent请求   
  12. 　　Intent intent = new Intent();   
  13. 　　intent.putExtra(EXTRA_DEVICE_ADDRESS, address);   
  14.   
  15. 　　// 设置result并结束Activity   
  16. 　　setResult(Activity.RESULT_OK, intent);   
  17. 　　finish();   
  18. 　　}   
  19. 　　};  

　　当用户点击该按钮时，首先取消扫描进程，因为扫描过程是一个非常耗费资源的过程，然后去的设备的mac地址，构建一个Intent 对象，通过附加数据EXTRA_DEVICE_ADDRESS将mac地址传递到BluetoothChat中，然后调用finish来结束该界面。这时就会回到上一篇文章我们介绍的BluetoothChat中的onActivityResult函数中去执行请求代码为REQUEST_CONNECT_DEVICE的片段，用来连接一个设备。


　　BluetoothChatService
　　对于设备的监听，连接管理都将由REQUEST_CONNECT_DEVICE来实现，其中又包括三个主要部分，三个进程分贝是：请求连接的监听线程（AcceptThread）、连接一个设备的进程（ConnectThread）、连接之后的管理进程（ConnectedThread）。同样我们先熟悉一下该类的成员变量的作用，定义如下：

  1. // Debugging   
  2. 　　private static final String TAG = "BluetoothChatService";   
  3. 　　private static final boolean D = true;   
  4.   
  5. 　　//当创建socket服务时的SDP名称   
  6. 　　private static final String NAME = "BluetoothChat";   
  7.   
  8. 　　// 应用程序的唯一UUID   
  9. 　　private static final UUID MY_UUID = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");   
  10.   
  11. 　　// 本地蓝牙适配器   
  12. 　　private final BluetoothAdapter mAdapter;   
  13. 　　//Handler   
  14. 　　private final Handler mHandler;   
  15. 　　//请求链接的监听线程   
  16. 　　private AcceptThread mAcceptThread;   
  17. 　　//链接一个设备的线程   
  18. 　　private ConnectThread mConnectThread;   
  19. 　　//已经链接之后的管理线程   
  20. 　　private ConnectedThread mConnectedThread;   
  21. 　　//当前的状态   
  22. 　　private int mState;   
  23.   
  24. 　　// 各种状态   
  25. 　　public static final int STATE_NONE = 0;     
  26. 　　public static final int STATE_LISTEN = 1;    
  27. 　　public static final int STATE_CONNECTING = 2;    
  28. 　　public static final int STATE_CONNECTED = 3;  

　　Debugging为调试相关，NAME 是当我们在创建一个socket监听服务时的一个SDP名称，另外还包括一个状态变量mState，其值则分别是下面的"各种状态"部分，另外还有一个本地蓝牙适配器和三个不同的进程对象，由此可见，本地蓝牙适配器的确是任何蓝牙操作的基础对象，下面我们会分别介绍这些进程的实现。
　　首先是初始化操作，即构造函数，代码如下：

  1. public BluetoothChatService(Context context, Handler handler) {   
  2. 　　 //得到本地蓝牙适配器   
  3. 　　mAdapter = BluetoothAdapter.getDefaultAdapter();   
  4. 　　//设置状态   
  5. 　　mState = STATE_NONE;   
  6. 　　//设置Handler   
  7. 　　mHandler = handler;   
  8. 　　}  

　　取得本地蓝牙适配器、设置状态为STATE_NONE，设置传递进来的mHandler。接下来需要控制当状态改变之后，我们需要通知UI界面也同时更改状态，下面是得到状态和设置状态的实现部分，如下：

  1. private synchronized void setState(int state) {   
  2. 　　if (D) Log.d(TAG, "setState() " + mState + " -> " + state);   
  3. 　　mState = state;   
  4.   
  5. 　　// 状态更新之后UI Activity也需要更新   
  6. 　　mHandler.obtainMessage(BluetoothChat.MESSAGE_STATE_CHANGE, state, -1).sendToTarget();   
  7. 　　}   
  8.   
  9. 　　public synchronized int getState() {   
  10. 　　return mState;   
  11. 　　}  

　　得到状态没有什么特别的，关键在于设置状态之后需要通过obtainMessage来发送一个消息到Handler，通知UI界面也同时更新其状态，对应的Handler的实现则位于BluetoothChat中的private final Handler mHandler = new Handler()部分，从上面的代码中，我们可以看到关于状态更改的之后会发送一个BluetoothChat.MESSAGE_STATE_CHANGE消息到UI线程中，下面我们看一下UI线程中如何处理这些消息的，代码如下：

  1. case MESSAGE_STATE_CHANGE:   
  2. 　　if(D) Log.i(TAG, "MESSAGE_STATE_CHANGE: " + msg.arg1);   
  3. 　　switch (msg.arg1) {   
  4. 　　case BluetoothChatService.STATE_CONNECTED:   
  5. 　　 //设置状态为已经链接   
  6. 　　mTitle.setText(R.string.title_connected_to);   
  7. 　　//添加设备名称   
  8. 　　mTitle.append(mConnectedDeviceName);   
  9. 　　//清理聊天记录   
  10. 　　mConversationArrayAdapter.clear();   
  11. 　　break;   
  12. 　　case BluetoothChatService.STATE_CONNECTING:   
  13. 　　 //设置正在链接   
  14. 　　mTitle.setText(R.string.title_connecting);   
  15. 　　break;   
  16. 　　case BluetoothChatService.STATE_LISTEN:   
  17. 　　case BluetoothChatService.STATE_NONE:   
  18. 　　 //处于监听状态或者没有准备状态，则显示没有链接   
  19. 　　mTitle.setText(R.string.title_not_connected);   
  20. 　　break;   
  21. 　　}   
  22. 　　break;  

　　可以看出，当不同的状态在更改之后会进行不同的设置，但是大多数都是根据不同的状态设置显示了不同的title，当已经链接（STATE_CONNECTED）之后,设置了标题为链接的设备名，并同时还mConversationArrayAdapter进行了清除操作，即清除聊天记录。
　　现在，初始化操作已经完成了，下面我们可以调用start函数来开启一个服务进程了，也即是在BluetoothChat中的onResume函数中所调用的start操作，其具体实现如下：

  1. public synchronized void start() {   
  2. 　　if (D) Log.d(TAG, "start");   
  3.   
  4. 　　// 取消任何线程视图建立一个连接   
  5. 　　if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}   
  6.   
  7. 　　// 取消任何正在运行的链接   
  8. 　　if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}   
  9.   
  10. 　　// 启动AcceptThread线程来监听BluetoothServerSocket   
  11. 　　if (mAcceptThread == null) {   
  12. 　　mAcceptThread = new AcceptThread();   
  13. 　　mAcceptThread.start();   
  14. 　　}   
  15. 　　//设置状态为监听，，等待链接   
  16. 　　setState(STATE_LISTEN);   
  17. 　　}  

　　操作过程很简单，首先取消另外两个进程，新建一个AcceptThread进程，并启动AcceptThread进程，最后设置状态变为监听(STATE_LISTEN)，这时UI界面的title也将更新为监听状态，即等待设备的连接。关于AcceptThread的具体实现如下所示。

  1. private class AcceptThread extends Thread {   
  2. 　　// 本地socket服务   
  3. 　　private final BluetoothServerSocket mmServerSocket;   
  4.   
  5. 　　public AcceptThread() {   
  6. 　　BluetoothServerSocket tmp = null;   
  7.   
  8. 　　// 创建一个新的socket服务监听   
  9. 　　try {   
  10. 　　tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);   
  11. 　　} catch (IOException e) {   
  12. 　　Log.e(TAG, "listen() failed", e);   
  13. 　　}   
  14. 　　mmServerSocket = tmp;   
  15. 　　}   
  16.   
  17. 　　public void run() {   
  18. 　　if (D) Log.d(TAG, "BEGIN mAcceptThread" + this);   
  19. 　　setName("AcceptThread");   
  20. 　　BluetoothSocket socket = null;   
  21.   
  22. 　　// 如果当前没有链接则一直监听socket服务   
  23. 　　while (mState != STATE_CONNECTED) {   
  24. 　　try {   
  25. 　　 //如果有请求链接，则接受   
  26. 　　 //这是一个阻塞调用，将之返回链接成功和一个异常   
  27. 　　socket = mmServerSocket.accept();   
  28. 　　} catch (IOException e) {   
  29. 　　Log.e(TAG, "accept() failed", e);   
  30. 　　break;   
  31. 　　}   
  32.   
  33. 　　// 如果接受了一个链接   
  34. 　　if (socket != null) {   
  35. 　　synchronized (BluetoothChatService.this) {   
  36. 　　switch (mState) {   
  37. 　　case STATE_LISTEN:   
  38. 　　case STATE_CONNECTING:   
  39. 　　// 如果状态为监听或者正在链接中，，则调用connected来链接   
  40. 　　connected(socket, socket.getRemoteDevice());   
  41. 　　break;   
  42. 　　case STATE_NONE:   
  43. 　　case STATE_CONNECTED:   
  44. 　　// 如果为没有准备或者已经链接，这终止该socket   
  45. 　　try {   
  46. 　　socket.close();   
  47. 　　} catch (IOException e) {   
  48. 　　Log.e(TAG, "Could not close unwanted socket", e);   
  49. 　　}   
  50. 　　break;   
  51. 　　}   
  52. 　　}   
  53. 　　}   
  54. 　　}   
  55. 　　if (D) Log.i(TAG, "END mAcceptThread");   
  56. 　　}   
  57. 　　//关闭BluetoothServerSocket   
  58. 　　public void cancel() {   
  59. 　　if (D) Log.d(TAG, "cancel " + this);   
  60. 　　try {   
  61. 　　mmServerSocket.close();   
  62. 　　} catch (IOException e) {   
  63. 　　Log.e(TAG, "close() of server failed", e);   
  64. 　　}   
  65. 　　}   
  66. 　　}  


　　首先通过listenUsingRfcommWithServiceRecord创建一个socket服务，用来监听设备的连接，当进程启动之后直到有设备连接时，这段时间都将通过accept来监听和接收一个连接请求，如果连接无效则调用close来关闭即可，如果连接有效则调用connected进入连接进程，进入连接进程之后会取消当前的监听进程，取消过程则直接调用cancel通过mmServerSocket.close()来关闭即可。下面我们分析连接函数connect的实现，如下：

  1. public synchronized void connect(BluetoothDevice device) {   
  2. 　　if (D) Log.d(TAG, "connect to: " + device);   
  3.   
  4. 　　// 取消任何链接线程，视图建立一个链接   
  5. 　　if (mState == STATE_CONNECTING) {   
  6. 　　if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}   
  7. 　　}   
  8.   
  9. 　　// 取消任何正在运行的线程   
  10. 　　if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}   
  11.   
  12. 　　// 启动一个链接线程链接指定的设备   
  13. 　　mConnectThread = new ConnectThread(device);   
  14. 　　mConnectThread.start();   
  15. 　　setState(STATE_CONNECTING);   
  16. 　　}  


　　同样，首先关闭其他两个进程，然后新建一个ConnectThread进程，并启动，通知UI界面状态更改为正在连接的状态（STATE_CONNECTING）。具体的连接进程由ConnectThread来实现，如下：

  1. private class ConnectThread extends Thread {   
  2. 　　 //蓝牙Socket   
  3. 　　private final BluetoothSocket mmSocket;   
  4. 　　//蓝牙设备   
  5. 　　private final BluetoothDevice mmDevice;   
  6.   
  7. 　　public ConnectThread(BluetoothDevice device) {   
  8. 　　mmDevice = device;   
  9. 　　BluetoothSocket tmp = null;   
  10.   
  11. 　　//得到一个给定的蓝牙设备的BluetoothSocket   
  12. 　　try {   
  13. 　　tmp = device.createRfcommSocketToServiceRecord(MY_UUID);   
  14. 　　} catch (IOException e) {   
  15. 　　Log.e(TAG, "create() failed", e);   
  16. 　　}   
  17. 　　mmSocket = tmp;   
  18. 　　}   
  19.   
  20. 　　public void run() {   
  21. 　　Log.i(TAG, "BEGIN mConnectThread");   
  22. 　　setName("ConnectThread");   
  23.   
  24. 　　// 取消可见状态，将会进行链接   
  25. 　　mAdapter.cancelDiscovery();   
  26.   
  27. 　　// 创建一个BluetoothSocket链接   
  28. 　　try {   
  29. 　　//同样是一个阻塞调用，返回成功和异常   
  30. 　　mmSocket.connect();   
  31. 　　} catch (IOException e) {   
  32. 　　 //链接失败   
  33. 　　connectionFailed();   
  34. 　　// 如果异常则关闭socket   
  35. 　　try {   
  36. 　　mmSocket.close();   
  37. 　　} catch (IOException e2) {   
  38. 　　Log.e(TAG, "unable to close() socket during connection failure", e2);   
  39. 　　}   
  40. 　　// 重新启动监听服务状态   
  41. 　　BluetoothChatService.this.start();   
  42. 　　return;   
  43. 　　}   
  44.   
  45. 　　// 完成则重置ConnectThread   
  46. 　　synchronized (BluetoothChatService.this) {   
  47. 　　mConnectThread = null;   
  48. 　　}   
  49.   
  50. 　　// 开启ConnectedThread（正在运行中...）线程   
  51. 　　connected(mmSocket, mmDevice);   
  52. 　　}   
  53. 　　//取消链接线程ConnectThread   
  54. 　　public void cancel() {   
  55. 　　try {   
  56. 　　mmSocket.close();   
  57. 　　} catch (IOException e) {   
  58. 　　Log.e(TAG, "close() of connect socket failed", e);   
  59. 　　}   
  60. 　　}   
  61. 　　}  

　　在创建该进程时，就已经知道当前需要被连接的蓝牙设备，然后通过createRfcommSocketToServiceRecord可以构建一个蓝牙设备的BluetoothSocket对象，当进入连接状态时，就可以调用cancelDiscovery来取消蓝牙的可见状态，然后通过调用connect函数进行链接操作，如果出现异常则表示链接失败，则调用connectionFailed函数通知UI进程更新界面的显示为链接失败状态，然后关闭BluetoothSocket，调用start函数重新开启一个监听服务AcceptThread，对于链接失败的处理实现如下：

  1. private void connectionFailed() {   
  2. 　　setState(STATE_LISTEN);   
  3.   
  4. 　　// 发送链接失败的消息到UI界面   
  5. 　　Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);   
  6. 　　Bundle bundle = new Bundle();   
  7. 　　bundle.putString(BluetoothChat.TOAST, "Unable to connect device");   
  8. 　　msg.setData(bundle);   
  9. 　　mHandler.sendMessage(msg);   
  10. 　　}  

　　首先更改状态为STATE_LISTEN，然后发送一个Message带UI界面，通知UI更新，显示一个Toast告知用户，当BluetoothChat中的mHandler接收到BluetoothChat.TOAST消息时，就会直接更新UI界面的显示，如果连接成功则将调用connected函数进入连接管理进程，其实现如下：

  1. public synchronized void connected(BluetoothSocket socket, BluetoothDevice device) {   
  2. 　　if (D) Log.d(TAG, "connected");   
  3.   
  4. 　　// 取消ConnectThread链接线程   
  5. 　　if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}   
  6.   
  7. 　　// 取消所有正在链接的线程   
  8. 　　if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}   
  9.   
  10. 　　// 取消所有的监听线程，因为我们已经链接了一个设备   
  11. 　　if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}   
  12.   
  13. 　　// 启动ConnectedThread线程来管理链接和执行翻译   
  14. 　　mConnectedThread = new ConnectedThread(socket);   
  15. 　　mConnectedThread.start();   
  16.   
  17. 　　// 发送链接的设备名称到UI Activity界面   
  18. 　　Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_DEVICE_NAME);   
  19. 　　Bundle bundle = new Bundle();   
  20. 　　bundle.putString(BluetoothChat.DEVICE_NAME, device.getName());   
  21. 　　msg.setData(bundle);   
  22. 　　mHandler.sendMessage(msg);   
  23. 　　//状态变为已经链接，即正在运行中   
  24. 　　setState(STATE_CONNECTED);   
  25. 　　}  

　　首先，关闭所有的进程，构建一个ConnectedThread进程，并准备一个Message消息，就设备名称（BluetoothChat.DEVICE_NAME）也发送到UI进程，因为UI进程需要显示当前连接的设备名称，当UI进程收到BluetoothChat.MESSAGE_DEVICE_NAME消息时就会更新相应的UI界面，就是设置窗口的title，这里我们就不贴出代码了，下面我们分析一下ConnectedThread的实现，代码如下：

  1. private class ConnectedThread extends Thread {   
  2. 　　 //BluetoothSocket   
  3. 　　private final BluetoothSocket mmSocket;   
  4. 　　//输入输出流   
  5. 　　private final InputStream mmInStream;   
  6. 　　private final OutputStream mmOutStream;   
  7.   
  8. 　　public ConnectedThread(BluetoothSocket socket) {   
  9. 　　Log.d(TAG, "create ConnectedThread");   
  10. 　　mmSocket = socket;   
  11. 　　InputStream tmpIn = null;   
  12. 　　OutputStream tmpOut = null;   
  13.   
  14. 　　// 得到BluetoothSocket的输入输出流   
  15. 　　try {   
  16. 　　tmpIn = socket.getInputStream();   
  17. 　　tmpOut = socket.getOutputStream();   
  18. 　　} catch (IOException e) {   
  19. 　　Log.e(TAG, "temp sockets not created", e);   
  20. 　　}   
  21.   
  22. 　　mmInStream = tmpIn;   
  23. 　　mmOutStream = tmpOut;   
  24. 　　}   
  25.   
  26. 　　public void run() {   
  27. 　　Log.i(TAG, "BEGIN mConnectedThread");   
  28. 　　byte[] buffer = new byte[1024];   
  29. 　　int bytes;   
  30.   
  31. 　　// 监听输入流   
  32. 　　while (true) {   
  33. 　　try {   
  34. 　　// 从输入流中读取数据   
  35. 　　bytes = mmInStream.read(buffer);   
  36.   
  37. 　　// 发送一个消息到UI线程进行更新   
  38. 　　mHandler.obtainMessage(BluetoothChat.MESSAGE_READ, bytes, -1, buffer)   
  39. 　　.sendToTarget();   
  40. 　　} catch (IOException e) {   
  41. 　　 //出现异常，则链接丢失   
  42. 　　Log.e(TAG, "disconnected", e);   
  43. 　　connectionLost();   
  44. 　　break;   
  45. 　　}   
  46. 　　}   
  47. 　　}   
  48.   
  49. 　　/**  
  50. 　　* 写入药发送的消息  
  51. 　　* @param buffer  The bytes to write  
  52. 　　*/  
  53. 　　public void write(byte[] buffer) {   
  54. 　　try {   
  55. 　　mmOutStream.write(buffer);   
  56.   
  57. 　　// 将写的消息同时传递给UI界面   
  58. 　　mHandler.obtainMessage(BluetoothChat.MESSAGE_WRITE, -1, -1, buffer)   
  59. 　　.sendToTarget();   
  60. 　　} catch (IOException e) {   
  61. 　　Log.e(TAG, "Exception during write", e);   
  62. 　　}   
  63. 　　}   
  64. 　　//取消ConnectedThread链接管理线程   
  65. 　　public void cancel() {   
  66. 　　try {   
  67. 　　mmSocket.close();   
  68. 　　} catch (IOException e) {   
  69. 　　Log.e(TAG, "close() of connect socket failed", e);   
  70. 　　}   
  71. 　　}   
  72. 　　}  

　　连接之后的主要操作就是发送和接收聊天消息了，因为需要通过其输入（出）流来操作具体信息，进程会一直从输入流中读取信息，并通过obtainMessage函数将读取的信息以BluetoothChat.MESSAGE_READ命令发送到UI进程，到UI进程收到是，就需要将其显示到消息列表之中，同时对于发送消息，需要实行写操作write，其操作就是将要发送的消息写入到输出流mmOutStream中，并且以BluetoothChat.MESSAGE_WRITE命令的方式发送到UI进程中，进行同步更新，如果在读取消息时失败或者产生了异常，则表示连接丢失，这是就调用connectionLost函数来处理连接丢失，代码如下：

  1. private void connectionLost() {   
  2. 　　setState(STATE_LISTEN);   
  3.   
  4. 　　// 发送失败消息到UI界面   
  5. 　　Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);   
  6. 　　Bundle bundle = new Bundle();   
  7. 　　bundle.putString(BluetoothChat.TOAST, "Device connection was lost");   
  8. 　　msg.setData(bundle);   
  9. 　　mHandler.sendMessage(msg);   
  10. 　　}  

　　操作同样简单，首先改变状态为STATE_LISTEN，然后BluetoothChat.MESSAGE_TOAST命令发送一个消息Message到UI进程，通知UI进程更新显示画面即可。对于写操作，是调用了BluetoothChatService.write来实现，其实现代码如下：

  1. //写入自己要发送出来的消息   
  2. 　　public void write(byte[] out) {   
  3. 　　// Create temporary object   
  4. 　　ConnectedThread r;   
  5. 　　// Synchronize a copy of the ConnectedThread   
  6. 　　synchronized (this) {   
  7. 　　 //判断是否处于已经链接状态   
  8. 　　if (mState != STATE_CONNECTED) return;   
  9. 　　r = mConnectedThread;   
  10. 　　}   
  11. 　　// 执行写   
  12. 　　r.write(out);   
  13. 　　}  

　　其实就是检测，当前的状态是否处于已经链接状态STATE_CONNECTED，然后调用ConnectedThread 进程中的write操作，来完成消息的发送。因此这时我们可以回过头来看BluetoothChat中的sendMessage的实现了，如下所示：

  1. private void sendMessage(String message) {   
  2. 　　// 检查是否处于连接状态   
  3. 　　if (mChatService.getState() != BluetoothChatService.STATE_CONNECTED) {   
  4. 　　Toast.makeText(this, R.string.not_connected, Toast.LENGTH_SHORT).show();   
  5. 　　return;   
  6. 　　}   
  7.   
  8. 　　// 如果输入的消息不为空才发送，否则不发送   
  9. 　　if (message.length() > 0) {   
  10. 　　// Get the message bytes and tell the BluetoothChatService to write   
  11. 　　byte[] send = message.getBytes();   
  12. 　　mChatService.write(send);   
  13.   
  14. 　　// Reset out string buffer to zero and clear the edit text field   
  15. 　　mOutStringBuffer.setLength(0);   
  16. 　　mOutEditText.setText(mOutStringBuffer);   
  17. 　　}   
  18. 　　}  

　　同样首先检测了当前的状态是否为已经连接状态，然后对要发送的消息是否为null进行了判断，如果为空则不需要发送，否则调用mChatService.write（即上面所说的ConnectedThread 中的wirte操作）来发送消息。然后一个小的细节就是设置编辑框的内容为null即可。最后我们可以看一下在BluetoothChat中如何处理这些接收到的消息，主要位于mHandler中的handleMessage函数中，对于状态改变的消息我们已经分析过了，下面是其他几个消息的处理：

  1. case MESSAGE_WRITE:   
  2. 　　byte[] writeBuf = (byte[]) msg.obj;   
  3. 　　// 将自己写入的消息也显示到会话列表中   
  4. 　　String writeMessage = new String(writeBuf);   
  5. 　　mConversationArrayAdapter.add("Me:  " + writeMessage);   
  6. 　　break;   
  7. 　　case MESSAGE_READ:   
  8. 　　byte[] readBuf = (byte[]) msg.obj;   
  9. 　　// 取得内容并添加到聊天对话列表中   
  10. 　　String readMessage = new String(readBuf, 0, msg.arg1);   
  11. 　　mConversationArrayAdapter.add(mConnectedDeviceName+":  " + readMessage);   
  12. 　　break;   
  13. 　　case MESSAGE_DEVICE_NAME:   
  14. 　　// 保存链接的设备名称，并显示一个toast提示   
  15. 　　mConnectedDeviceName = msg.getData().getString(DEVICE_NAME);   
  16. 　　Toast.makeText(getApplicationContext(), "Connected to "  
  17. 　　+ mConnectedDeviceName, Toast.LENGTH_SHORT).show();   
  18. 　　break;   
  19. 　　case MESSAGE_TOAST:   
  20. 　　 //处理链接(发送)失败的消息   
  21. 　　Toast.makeText(getApplicationContext(), msg.getData().getString(TOAST),   
  22. 　　Toast.LENGTH_SHORT).show();   
  23. 　　break;  

　　分别是读取消息和写消息（发送消息），对于一些信息提示消息MESSAGE_TOAST，则通过Toast显示出来即可。如果消息是设备名称MESSAGE_DEVICE_NAME，则提示用户当前连接的设备的名称。对于写消息（MESSAGE_WRITE）和读消息（MESSAGE_READ）我们就不重复了，大家看看代码都已经加入了详细的注释了。
　　最后当我们在需要停止这些进程时就看有直接调用stop即可，具体实现如下：

  1. //停止所有的线程   
  2. 　　public synchronized void stop() {   
  3. 　　if (D) Log.d(TAG, "stop");   
  4. 　　if (mConnectThread != null) {mConnectThread.cancel(); mConnectThread = null;}   
  5. 　　if (mConnectedThread != null) {mConnectedThread.cancel(); mConnectedThread = null;}   
  6. 　　if (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}   
  7. 　　//状态设置为准备状态   
  8. 　　setState(STATE_NONE);   
  9. 　　}  

　　分别检测三个进程是否为null，然后调用各自的cancel函数来取消进程，最后不要忘记将状态恢复到STATE_NONE即可。


　　总结
　　终于完成了对蓝牙聊天程序的实现和分析，该示例程序比较全面，基本上包括了蓝牙编程的各个方面，希望通过这几篇文章的问题，能够帮助大家理解在Ophone平台上进行蓝牙编程，同时将蓝牙技术运用到其他应用程序中实现应用程序的网络化，联机性。或许你有更多的用处。

    本站是提供个人知识管理的网络存储空间，所有内容均由用户发布，不代表本站观点。请注意甄别内容中的联系方式、诱导购买等信息，谨防诈骗。如发现有害或侵权内容，请点击一键举报。
    转藏 分享 献花（0）

    来自： WindySky > 《蓝牙技术》

    举报/认领

    0条评论

    发表

    请遵守用户 评论公约

    类似文章 更多