Android 蓝牙开发实例--蓝牙聊天程序的设计和实现

最新推荐文章于 2024-03-27 09:48:03 发布

Moonhuazai

最新推荐文章于 2024-03-27 09:48:03 发布

阅读量730

点赞数

分类专栏： BL_BLE

BL_BLE 专栏收录该内容

20 篇文章 0 订阅

订阅专栏

作者在这里介绍的这个实例是Google SDK中提供的一个蓝牙聊天程序，简单但信息量巨大，非常适合初学者学习蓝牙方面的知识。

在学习这个实例前请读者仔细阅读并理解Socket的工作原理和实现机制，作者的这篇博客中有详细的介绍：

http://blog.csdn.net/dlutbrucezhang/article/details/8577810

在Android1.x的时候，相关API非常不完善，还不能简单的使用Bluetooth开发，有一个开源项目可以帮助程序员使用、开发蓝牙，支持直接方法bluetooth协议栈。在Android2以后，框架提供了一些官方API来进行蓝牙的通信，但目前的程序也比较不完善。本文主要讨论Android2后的Bluetooth通信的API使用方法。

首先看聊天室的效果图：

蓝牙设备连接的过程如下图所示：

下面这张图展示的是蓝牙聊天的时序图：

接下来将贴出源码并对源码做出详细的解释说明：

BluetoothChat.java

例程的主Activity。onCreate()得到本地BluetoothAdapter设备，检查是否支持。onStart()中检查是否启用蓝牙，并请求启用，然后执行setupChat()。setupChat()中先对界面中的控件进行初始化增加点击监听器等，然创建BluetoothChatService对象，该对象在整个应用过程中存在，并执行蓝牙连接建立、消息发送接受等实际的行为。

    Java代码   
    
  
 import android.app.Activity;  
 import android.bluetooth.BluetoothAdapter;  
 import android.bluetooth.BluetoothDevice;  
 import android.content.Intent;  
 import android.os.Bundle;  
 import android.os.Handler;  
 import android.os.Message;  
 import android.util.Log;  
 import android.view.KeyEvent;  
 import android.view.Menu;  
 import android.view.MenuInflater;  
 import android.view.MenuItem;  
 import android.view.View;  
 import android.view.Window;  
 import android.view.View.OnClickListener;  
 import android.view.inputmethod.EditorInfo;  
 import android.widget.ArrayAdapter;  
 import android.widget.Button;  
 import android.widget.EditText;  
 import android.widget.ListView;  
 import android.widget.TextView;  
 import android.widget.Toast;  
   
 /** 
  * This is the main Activity that displays the current chat session. 
  */  
 public class BluetoothChat extends Activity {  
     // Debugging  
     private static final String TAG = "BluetoothChat";  
     private static final boolean D = true;  
   
     // Message types sent from the BluetoothChatService Handler  
     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;  
   
     // Key names received from the BluetoothChatService Handler  
     public static final String DEVICE_NAME = "device_name";  
     public static final String TOAST = "toast";  
   
     // Intent request codes  
     private static final int REQUEST_CONNECT_DEVICE = 1;  
     private static final int REQUEST_ENABLE_BT = 2;  
   
     // Layout Views  
     private TextView mTitle;  
     private ListView mConversationView;  
     private EditText mOutEditText;  
     private Button mSendButton;  
   
     // Name of the connected device  
     private String mConnectedDeviceName = null;  
     // Array adapter for the conversation thread  
     private ArrayAdapter<String> mConversationArrayAdapter;  
     // String buffer for outgoing messages  
     private StringBuffer mOutStringBuffer;  
     // Local Bluetooth adapter  
     private BluetoothAdapter mBluetoothAdapter = null;  
     // Member object for the chat services  
     private BluetoothChatService mChatService = null;  
   
   
     @Override  
     public void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
         if(D) Log.e(TAG, "+++ ON CREATE +++");  
   
         // Set up the window layout  
         requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);  
         setContentView(R.layout.main);  
         getWindow().setFeatureInt(Window.FEATURE_CUSTOM_TITLE, R.layout.custom_title);  
   
         // Set up the custom title  
         mTitle = (TextView) findViewById(R.id.title_left_text);  
         mTitle.setText(R.string.app_name);  
         mTitle = (TextView) findViewById(R.id.title_right_text);  
   
         // Get local Bluetooth adapter  
         mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();  
   
         // If the adapter is null, then Bluetooth is not supported  
         if (mBluetoothAdapter == null) {  
             Toast.makeText(this, "Bluetooth is not available", Toast.LENGTH_LONG).show();  
             finish();  
             return;  
         }  
     }  
   
     @Override  
     public void onStart() {  
         super.onStart();  
         if(D) Log.e(TAG, "++ ON START ++");  
   
         // If BT is not on, request that it be enabled.  
         // setupChat() will then be called during onActivityResult  
         if (!mBluetoothAdapter.isEnabled()) {  
             Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);  
             startActivityForResult(enableIntent, REQUEST_ENABLE_BT);  
         // Otherwise, setup the chat session  
         } else {  
             if (mChatService == null) setupChat();  
         }  
     }  
   
     @Override  
     public synchronized void onResume() {  
         super.onResume();  
         if(D) Log.e(TAG, "+ ON RESUME +");  
   
         // Performing this check in onResume() covers the case in which BT was  
         // not enabled during onStart(), so we were paused to enable it...  
         // onResume() will be called when ACTION_REQUEST_ENABLE activity returns.  
         if (mChatService != null) {  
             // Only if the state is STATE_NONE, do we know that we haven't started already  
             if (mChatService.getState() == BluetoothChatService.STATE_NONE) {  
               // Start the Bluetooth chat services  
               mChatService.start();  
             }  
         }  
     }  
   
     private void setupChat() {  
         Log.d(TAG, "setupChat()");  
   
         // Initialize the array adapter for the conversation thread  
         mConversationArrayAdapter = new ArrayAdapter<String>(this, R.layout.message);  
         mConversationView = (ListView) findViewById(R.id.in);  
         mConversationView.setAdapter(mConversationArrayAdapter);  
   
         // Initialize the compose field with a listener for the return key  
         mOutEditText = (EditText) findViewById(R.id.edit_text_out);  
         mOutEditText.setOnEditorActionListener(mWriteListener);  
   
         // Initialize the send button with a listener that for click events  
         mSendButton = (Button) findViewById(R.id.button_send);  
         mSendButton.setOnClickListener(new OnClickListener() {  
             public void onClick(View v) {  
                 // Send a message using content of the edit text widget  
                 TextView view = (TextView) findViewById(R.id.edit_text_out);  
                 String message = view.getText().toString();  
                 sendMessage(message);  
             }  
         });  
   
         // Initialize the BluetoothChatService to perform bluetooth connections  
         mChatService = new BluetoothChatService(this, mHandler);  
   
         // Initialize the buffer for outgoing messages  
         mOutStringBuffer = new StringBuffer("");  
     }  
   
     @Override  
     public synchronized void onPause() {  
         super.onPause();  
         if(D) Log.e(TAG, "- ON PAUSE -");  
     }  
   
     @Override  
     public void onStop() {  
         super.onStop();  
         if(D) Log.e(TAG, "-- ON STOP --");  
     }  
   
     @Override  
     public void onDestroy() {  
         super.onDestroy();  
         // Stop the Bluetooth chat services  
         if (mChatService != null) mChatService.stop();  
         if(D) Log.e(TAG, "--- ON DESTROY ---");  
     }  
   
     private void ensureDiscoverable() {  
         if(D) Log.d(TAG, "ensure discoverable");  
         if (mBluetoothAdapter.getScanMode() !=  
             BluetoothAdapter.SCAN_MODE_CONNECTABLE_DISCOVERABLE) {  
             Intent discoverableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);  
             discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);  
             startActivity(discoverableIntent);  
         }  
     }  
   
     /** 
      * Sends a message. 
      * @param message  A string of text to send. 
      */  
     private void sendMessage(String message) {  
         // Check that we're actually connected before trying anything  
         if (mChatService.getState() != BluetoothChatService.STATE_CONNECTED) {  
             Toast.makeText(this, R.string.not_connected, Toast.LENGTH_SHORT).show();  
             return;  
         }  
   
         // Check that there's actually something to send  
         if (message.length() > 0) {  
             // Get the message bytes and tell the BluetoothChatService to write  
             byte[] send = message.getBytes();  
             mChatService.write(send);  
   
             // Reset out string buffer to zero and clear the edit text field  
             mOutStringBuffer.setLength(0);  
             mOutEditText.setText(mOutStringBuffer);  
         }  
     }  
   
     // The action listener for the EditText widget, to listen for the return key  
     private TextView.OnEditorActionListener mWriteListener =  
         new TextView.OnEditorActionListener() {  
         public boolean onEditorAction(TextView view, int actionId, KeyEvent event) {  
             // If the action is a key-up event on the return key, send the message  
             if (actionId == EditorInfo.IME_NULL && event.getAction() == KeyEvent.ACTION_UP) {  
                 String message = view.getText().toString();  
                 sendMessage(message);  
             }  
             if(D) Log.i(TAG, "END onEditorAction");  
             return true;  
         }  
     };  
   
     // The Handler that gets information back from the BluetoothChatService  
     private final Handler mHandler = new Handler() {  
         @Override  
         public void handleMessage(Message msg) {  
             switch (msg.what) {  
             case MESSAGE_STATE_CHANGE:  
                 if(D) Log.i(TAG, "MESSAGE_STATE_CHANGE: " + msg.arg1);  
                 switch (msg.arg1) {  
                 case BluetoothChatService.STATE_CONNECTED:  
                     mTitle.setText(R.string.title_connected_to);  
                     mTitle.append(mConnectedDeviceName);  
                     mConversationArrayAdapter.clear();  
                     break;  
                 case BluetoothChatService.STATE_CONNECTING:  
                     mTitle.setText(R.string.title_connecting);  
                     break;  
                 case BluetoothChatService.STATE_LISTEN:  
                 case BluetoothChatService.STATE_NONE:  
                     mTitle.setText(R.string.title_not_connected);  
                     break;  
                 }  
                 break;  
             case MESSAGE_WRITE:  
                 byte[] writeBuf = (byte[]) msg.obj;  
                 // construct a string from the buffer  
                 String writeMessage = new String(writeBuf);  
                 mConversationArrayAdapter.add("Me:  " + writeMessage);  
                 break;  
             case MESSAGE_READ:  
                 byte[] readBuf = (byte[]) msg.obj;  
                 // construct a string from the valid bytes in the buffer  
                 String readMessage = new String(readBuf, 0, msg.arg1);  
                 mConversationArrayAdapter.add(mConnectedDeviceName+":  " + readMessage);  
                 break;  
             case MESSAGE_DEVICE_NAME:  
                 // save the connected device's name  
                 mConnectedDeviceName = msg.getData().getString(DEVICE_NAME);  
                 Toast.makeText(getApplicationContext(), "Connected to "  
                                + 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) {  
         if(D) Log.d(TAG, "onActivityResult " + resultCode);  
         switch (requestCode) {  
         case REQUEST_CONNECT_DEVICE:  
             // When DeviceListActivity returns with a device to connect  
             if (resultCode == Activity.RESULT_OK) {  
                 // Get the device MAC address  
                 String address = data.getExtras()  
                                      .getString(DeviceListActivity.EXTRA_DEVICE_ADDRESS);  
                 // Get the BLuetoothDevice object  
                 BluetoothDevice device = mBluetoothAdapter.getRemoteDevice(address);  
                 // Attempt to connect to the device  
                 mChatService.connect(device);  
             }  
             break;  
         case REQUEST_ENABLE_BT:  
             // When the request to enable Bluetooth returns  
             if (resultCode == Activity.RESULT_OK) {  
                 // Bluetooth is now enabled, so set up a chat session  
                 setupChat();  
             } else {  
                 // User did not enable Bluetooth or an error occured  
                 Log.d(TAG, "BT not enabled");  
                 Toast.makeText(this, R.string.bt_not_enabled_leaving, Toast.LENGTH_SHORT).show();  
                 finish();  
             }  
         }  
     }  
   
     @Override  
     public boolean onCreateOptionsMenu(Menu menu) {  
         MenuInflater inflater = getMenuInflater();  
         inflater.inflate(R.menu.option_menu, menu);  
         return true;  
     }  
   
     @Override  
     public boolean onOptionsItemSelected(MenuItem item) {  
         switch (item.getItemId()) {  
         case R.id.scan:  
             // Launch the DeviceListActivity to see devices and do scan  
             Intent serverIntent = new Intent(this, DeviceListActivity.class);  
             startActivityForResult(serverIntent, REQUEST_CONNECT_DEVICE);  
             return true;  
         case R.id.discoverable:  
             // Ensure this device is discoverable by others  
             ensureDiscoverable();  
             return true;  
         }  
         return false;  
     }  
   
 }  

BluetoothChatService.java

public synchronized void start()：

开启mAcceptThread线程，由于样例程序是仅2人的聊天过程，故之前先检测mConnectThread和mConnectedThread是否运行，运行则先退出这些线程。

public synchronized voidconnect(BluetoothDevice device)：

取消CONNECTING和CONNECTED状态下的相关线程，然后运行新的mConnectThread线程。

public synchronized voidconnected(BluetoothSocket socket, BluetoothDevice device)：

开启一个ConnectedThread来管理对应的当前连接。之前先取消任意现存的mConnectThread、mConnectedThread、mAcceptThread线程，然后开启新mConnectedThread，传入当前刚刚接受的socket连接。最后通过Handler来通知UI连接OK。

public synchronized void stop()：

停止所有相关线程，设当前状态为NONE。

public void write(byte[] out)：

在STATE_CONNECTED状态下，调用mConnectedThread里的write方法，写入byte。

private void connectionFailed()：

连接失败的时候处理，通知ui，并设为STATE_LISTEN状态。

private void connectionLost()：

当连接失去的时候，设为STATE_LISTEN状态并通知ui。

内部类：

private class AcceptThread extendsThread：

创建监听线程，准备接受新连接。使用阻塞方式，调用BluetoothServerSocket.accept()。提供cancel方法关闭socket。

private class ConnectThread extendsThread：

这是定义的连接线程，专门用来对外发出连接对方蓝牙的请求和处理流程。构造函数里通过BluetoothDevice.createRfcommSocketToServiceRecord()，从待连接的device产生BluetoothSocket.然后在run方法中connect，成功后调用BluetoothChatSevice的connected()方法。定义cancel()在关闭线程时能够关闭相关socket。

private class ConnectedThread extendsThread：

这个是双方蓝牙连接后一直运行的线程。构造函数中设置输入输出流。Run方法中使用阻塞模式的InputStream.read()循环读取输入流，然后post到UI线程中更新聊天消息。也提供了write()将聊天消息写入输出流传输至对方，传输成功后回写入UI线程。最后cancel()关闭连接的socket。

    Java代码   
    
  
 import java.io.IOException;  
 import java.io.InputStream;  
 import java.io.OutputStream;  
 import java.util.UUID;  
   
 import android.annotation.SuppressLint;  
 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 android.util.Log;  
   
 /** 
  * 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. 
  */  
 @SuppressLint("NewApi")  
 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 = "BluetoothChat";  
   
     // Unique UUID for this application  
     private static final UUID MY_UUID = UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66");  
   
     // Member fields  
     private final BluetoothAdapter mAdapter;  
     private final Handler mHandler;  
     private AcceptThread mAcceptThread;  
     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(BluetoothChat.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;}  
   
         // Start the thread to listen on a BluetoothServerSocket  
         if (mAcceptThread == null) {  
             mAcceptThread = new AcceptThread();  
             mAcceptThread.start();  
         }  
         setState(STATE_LISTEN);  
     }  
   
     /** 
      * Start the ConnectThread to initiate a connection to a remote device. 
      * @param device  The BluetoothDevice to connect 
      */  
     public synchronized void connect(BluetoothDevice device) {  
         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);  
         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) {  
         if (D) Log.d(TAG, "connected");  
   
         // 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 (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = null;}  
   
         // Start the thread to manage the connection and perform transmissions  
         mConnectedThread = new ConnectedThread(socket);  
         mConnectedThread.start();  
   
         // Send the name of the connected device back to the UI Activity  
         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);  
     }  
   
     /** 
      * 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 (mAcceptThread != null) {mAcceptThread.cancel(); mAcceptThread = 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() {  
         setState(STATE_LISTEN);  
   
         // Send a failure message back to the Activity  
         Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);  
         Bundle bundle = new Bundle();  
         bundle.putString(BluetoothChat.TOAST, "Unable to connect device");  
         msg.setData(bundle);  
         mHandler.sendMessage(msg);  
     }  
   
     /** 
      * Indicate that the connection was lost and notify the UI Activity. 
      */  
     private void connectionLost() {  
         setState(STATE_LISTEN);  
   
         // Send a failure message back to the Activity  
         Message msg = mHandler.obtainMessage(BluetoothChat.MESSAGE_TOAST);  
         Bundle bundle = new Bundle();  
         bundle.putString(BluetoothChat.TOAST, "Device connection was lost");  
         msg.setData(bundle);  
         mHandler.sendMessage(msg);  
     }  
   
     /** 
      * 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). 
      */  
     @SuppressLint("NewApi")  
     private class AcceptThread extends Thread {  
         // The local server socket  
         private final BluetoothServerSocket mmServerSocket;  
   
         public AcceptThread() {  
             BluetoothServerSocket tmp = null;  
   
             // Create a new listening server socket  
             try {  
                 //开启监听  
                 tmp = mAdapter.listenUsingRfcommWithServiceRecord(NAME, MY_UUID);  
             } catch (IOException e) {  
                 Log.e(TAG, "listen() failed", e);  
             }  
             mmServerSocket = tmp;  
         }  
   
         public void run() {  
             if (D) Log.d(TAG, "BEGIN mAcceptThread" + this);  
             setName("AcceptThread");  
             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, "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());  
                             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");  
         }  
   
         public void cancel() {  
             if (D) Log.d(TAG, "cancel " + this);  
             try {  
                 mmServerSocket.close();  
             } catch (IOException e) {  
                 Log.e(TAG, "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;  
   
         public ConnectThread(BluetoothDevice device) {  
             mmDevice = device;  
             BluetoothSocket tmp = null;  
   
             // Get a BluetoothSocket for a connection with the  
             // given BluetoothDevice  
             try {  
                 tmp = device.createRfcommSocketToServiceRecord(MY_UUID);  
             } catch (IOException e) {  
                 Log.e(TAG, "create() failed", e);  
             }  
             mmSocket = tmp;  
         }  
   
         public void run() {  
             Log.i(TAG, "BEGIN mConnectThread");  
             setName("ConnectThread");  
   
             // 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) {  
                 connectionFailed();  
                 // Close the socket  
                 try {  
                     mmSocket.close();  
                 } catch (IOException e2) {  
                     Log.e(TAG, "unable to close() socket during connection failure", e2);  
                 }  
                 // Start the service over to restart listening mode  
                 BluetoothChatService.this.start();  
                 return;  
             }  
   
             // Reset the ConnectThread because we're done  
             synchronized (BluetoothChatService.this) {  
                 mConnectThread = null;  
             }  
   
             // Start the connected thread  
             connected(mmSocket, mmDevice);  
         }  
   
         public void cancel() {  
             try {  
                 mmSocket.close();  
             } catch (IOException e) {  
                 Log.e(TAG, "close() of connect 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) {  
             Log.d(TAG, "create ConnectedThread");  
             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(BluetoothChat.MESSAGE_READ, bytes, -1, buffer)  
                             .sendToTarget();  
                 } catch (IOException e) {  
                     Log.e(TAG, "disconnected", e);  
                     connectionLost();  
                     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(BluetoothChat.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);  
             }  
         }  
     }  
 }  

DeviceListActivity.java

该类包含UI和操作的Activity类，作用是得到系统默认蓝牙设备的已配对设备列表，以及搜索出的未配对的新设备的列表。然后提供点击后发出连接设备请求的功能。

    Java代码   
    
  
 import java.util.Set;  
   
 import android.annotation.SuppressLint;  
 import android.app.Activity;  
 import android.bluetooth.BluetoothAdapter;  
 import android.bluetooth.BluetoothDevice;  
 import android.content.BroadcastReceiver;  
 import android.content.Context;  
 import android.content.Intent;  
 import android.content.IntentFilter;  
 import android.os.Bundle;  
 import android.util.Log;  
 import android.view.View;  
 import android.view.Window;  
 import android.view.View.OnClickListener;  
 import android.widget.AdapterView;  
 import android.widget.ArrayAdapter;  
 import android.widget.Button;  
 import android.widget.ListView;  
 import android.widget.TextView;  
 import android.widget.AdapterView.OnItemClickListener;  
   
 /** 
  * This Activity appears as a dialog. It lists any paired devices and 
  * devices detected in the area after discovery. When a device is chosen 
  * by the user, the MAC address of the device is sent back to the parent 
  * Activity in the result Intent. 
  */  
 @SuppressLint("NewApi")  
 public class DeviceListActivity extends Activity {  
     // Debugging  
     private static final String TAG = "DeviceListActivity";  
     private static final boolean D = true;  
   
     // Return Intent extra  
     public static String EXTRA_DEVICE_ADDRESS = "device_address";  
   
     // Member fields  
     private BluetoothAdapter mBtAdapter;  
     private ArrayAdapter<String> mPairedDevicesArrayAdapter;  
     private ArrayAdapter<String> mNewDevicesArrayAdapter;  
   
     @Override  
     protected void onCreate(Bundle savedInstanceState) {  
         super.onCreate(savedInstanceState);  
   
         // Setup the window  
         requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);  
         setContentView(R.layout.device_list);  
   
         // Set result CANCELED incase the user backs out  
         setResult(Activity.RESULT_CANCELED);  
   
         // Initialize the button to perform device discovery  
         Button scanButton = (Button) findViewById(R.id.button_scan);  
         scanButton.setOnClickListener(new OnClickListener() {  
             public void onClick(View v) {  
                 doDiscovery();  
                 v.setVisibility(View.GONE);  
             }  
         });  
   
         // Initialize array adapters. One for already paired devices and  
         // one for newly discovered devices  
         mPairedDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);  
         mNewDevicesArrayAdapter = new ArrayAdapter<String>(this, R.layout.device_name);  
   
         // Find and set up the ListView for paired devices  
         ListView pairedListView = (ListView) findViewById(R.id.paired_devices);  
         pairedListView.setAdapter(mPairedDevicesArrayAdapter);  
         pairedListView.setOnItemClickListener(mDeviceClickListener);  
   
         // Find and set up the ListView for newly discovered devices  
         ListView newDevicesListView = (ListView) findViewById(R.id.new_devices);  
         newDevicesListView.setAdapter(mNewDevicesArrayAdapter);  
         newDevicesListView.setOnItemClickListener(mDeviceClickListener);  
   
         // Register for broadcasts when a device is discovered  
         IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);  
         this.registerReceiver(mReceiver, filter);  
   
         // Register for broadcasts when discovery has finished  
         filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);  
         this.registerReceiver(mReceiver, filter);  
   
         // Get the local Bluetooth adapter  
         mBtAdapter = BluetoothAdapter.getDefaultAdapter();  
   
         // Get a set of currently paired devices  
         Set<BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices();  
   
         // If there are paired devices, add each one to the ArrayAdapter  
         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();  
   
         // Make sure we're not doing discovery anymore  
         if (mBtAdapter != null) {  
             mBtAdapter.cancelDiscovery();  
         }  
   
         // Unregister broadcast listeners  
         this.unregisterReceiver(mReceiver);  
     }  
   
     /** 
      * Start device discover with the BluetoothAdapter 
      */  
     private void doDiscovery() {  
         if (D) Log.d(TAG, "doDiscovery()");  
   
         // Indicate scanning in the title  
         setProgressBarIndeterminateVisibility(true);  
         setTitle(R.string.scanning);  
   
         // Turn on sub-title for new devices  
         findViewById(R.id.title_new_devices).setVisibility(View.VISIBLE);  
   
         // If we're already discovering, stop it  
         if (mBtAdapter.isDiscovering()) {  
             mBtAdapter.cancelDiscovery();  
         }  
   
         // Request discover from BluetoothAdapter  
         mBtAdapter.startDiscovery();  
     }  
   
     // The on-click listener for all devices in the ListViews  
     private OnItemClickListener mDeviceClickListener = new OnItemClickListener() {  
         public void onItemClick(AdapterView<?> av, View v, int arg2, long arg3) {  
             // Cancel discovery because it's costly and we're about to connect  
             mBtAdapter.cancelDiscovery();  
   
             // Get the device MAC address, which is the last 17 chars in the View  
             String info = ((TextView) v).getText().toString();  
             String address = info.substring(info.length() - 17);  
   
             // Create the result Intent and include the MAC address  
             Intent intent = new Intent();  
             intent.putExtra(EXTRA_DEVICE_ADDRESS, address);  
   
             // Set result and finish this Activity  
             setResult(Activity.RESULT_OK, intent);  
             finish();  
         }  
     };  
   
     // The BroadcastReceiver that listens for discovered devices and  
     // changes the title when discovery is finished  
     private final BroadcastReceiver mReceiver = new BroadcastReceiver() {  
         @Override  
         public void onReceive(Context context, Intent intent) {  
             String action = intent.getAction();  
   
             // When discovery finds a device  
             if (BluetoothDevice.ACTION_FOUND.equals(action)) {  
                 // Get the BluetoothDevice object from the Intent  
                 BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);  
                 // If it's already paired, skip it, because it's been listed already  
                 if (device.getBondState() != BluetoothDevice.BOND_BONDED) {  
                     mNewDevicesArrayAdapter.add(device.getName() + "\n" + device.getAddress());  
                 }  
             // When discovery is finished, change the Activity title  
             } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)) {  
                 setProgressBarIndeterminateVisibility(false);  
                 setTitle(R.string.select_device);  
                 if (mNewDevicesArrayAdapter.getCount() == 0) {  
                     String noDevices = getResources().getText(R.string.none_found).toString();  
                     mNewDevicesArrayAdapter.add(noDevices);  
                 }  
             }  
         }  
     };  
   
 }  
 http://jishublog.iteye.com/blog/1898612
 
 
 

Moonhuazai

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Android 蓝牙开发实例--蓝牙聊天程序的设计和实现

作者在这里介绍的这个实例是Google SDK中提供的一个蓝牙聊天程序，简单但信息量巨大，非常适合初学者学习蓝牙方面的知识。在学习这个实例前请读者仔细阅读并理解Socket的工作原理和实现机制，作者的这篇博客中有详细的介绍：http://blog.csdn.net/dlutbrucezhang/article/details/8577810在Andr
复制链接

扫一扫