Android蓝牙通信聊天实现发送和接受功能

很不错的蓝牙通信demo实现发送和接受功能,就用了两个类就实现了，具体内容如下

说下思路把 主要有两个类 主界面类 和 蓝牙聊天服务类 。 首先创建线程 实际上就是创建BluetoothChatService() (蓝牙聊天服务类) 这个时候把handler 传过去 这样就可以操作UI 界面了，在线程中不断轮询读取蓝牙消息，当主界面点击发送按钮时 调用BluetoothChatService 的发送方法write 方法，这里的write 方法 使用了handler 发送消息，在主界面显示，另一个 客户端 不断读取蓝牙消息 类似的有个read 方法 同样显示到界面上去，这样就完成了通信了。

import java.util.ArrayList;
import java.util.Set;

import android.app.Activity;
import android.app.AlertDialog;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.Window;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;

public class BluetoothChat extends Activity {

// 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;

private TextView mTitle;
 private EditText text_chat;
 private EditText text_input;
 private Button but_On_Off;
 private Button but_search; // ------> 在菜单中可以搜索
 private Button but_create; // ------> 在菜单中设置"可被发现"
 private Button mSendButton;
 // 连接到的蓝牙设备的名称
 private String mConnectedDeviceName;
 // 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;

private ArrayList<String> mPairedDevicesList = new ArrayList<String>();
 private ArrayList<String> mNewDevicesList = new ArrayList<String>();
 private String[] strName;
 private String address;

@Override
 public void onCreate(Bundle savedInstanceState) {
   super.onCreate(savedInstanceState);
   requestWindowFeature(Window.FEATURE_CUSTOM_TITLE);
   setContentView(R.layout.main);

mTitle = (TextView) this.findViewById(R.id.text_title);
   text_chat = (EditText) this.findViewById(R.id.text_chat);
   text_input = (EditText) this.findViewById(R.id.text_input);
   but_On_Off = (Button) this.findViewById(R.id.but_off_on);
   but_search = (Button) this.findViewById(R.id.but_search_div);
   but_create = (Button) this.findViewById(R.id.but_cjlj);
   mSendButton = (Button) this.findViewById(R.id.but_fsxx);

// 获得本地的蓝牙适配器
   mBluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
   // 如果为null,说明没有蓝牙设备
   if (mBluetoothAdapter == null) {
     Toast.makeText(this, "没有蓝牙设备", Toast.LENGTH_LONG).show();
     finish();
     return;
   }

if (mBluetoothAdapter.isEnabled()) {
     but_On_Off.setText("关闭蓝牙");
   } else {
     but_On_Off.setText("开启蓝牙");
   }

but_On_Off.setOnClickListener(new OnClickListener() {

@Override
     public void onClick(View v) {
       if (!mBluetoothAdapter.isEnabled()) {
         mBluetoothAdapter.enable();
         Toast.makeText(BluetoothChat.this, "蓝牙已开启",
             Toast.LENGTH_SHORT).show();
         but_On_Off.setText("关闭蓝牙");
       } else {
         mBluetoothAdapter.disable();
         Toast.makeText(BluetoothChat.this, "蓝牙已关闭",
             Toast.LENGTH_SHORT).show();
         but_On_Off.setText("开启蓝牙");
       }
     }
   });

but_search.setOnClickListener(new OnClickListener() {

@Override
     public void onClick(View v) {
       searchDevice();
     }
   });

but_create.setOnClickListener(new OnClickListener() {

@Override
     public void onClick(View v) {

final EditText et = new EditText(BluetoothChat.this);
       et.setSingleLine();
       et.setText(mBluetoothAdapter.getName());

new AlertDialog.Builder(BluetoothChat.this)
           .setTitle("请输入房间名：")
           .setView(et)
           .setPositiveButton("确定",
               new DialogInterface.OnClickListener() {

@Override
                 public void onClick(DialogInterface dialog,
                     int which) {
                   String name = et.getText().toString()
                       .trim();
                   if (name.equals("")) {
                     Toast.makeText(BluetoothChat.this,
                         "请输入房间名",
                         Toast.LENGTH_SHORT).show();
                     return;
                   }
                   // 设置房间名
                   mBluetoothAdapter.setName(name);
                 }

})
           .setNegativeButton("取消",
               new DialogInterface.OnClickListener() {

@Override
                 public void onClick(DialogInterface dialog,
                     int which) {

}
               }).create().show();

// 创建连接，也就是设备本地蓝牙设备可被其他用户的蓝牙搜到
       ensureDiscoverable();
     }
   });

// 获得一个已经配对的蓝牙设备的set集合
   Set<BluetoothDevice> pairedDevices = mBluetoothAdapter
       .getBondedDevices();
   if (pairedDevices.size() > 0) {
     for (BluetoothDevice device : pairedDevices) {
       mPairedDevicesList.add("已配对：" + device.getName() + "\n"
           + device.getAddress());
     }
   } else {
     Toast.makeText(this, "没有已配对的设备", Toast.LENGTH_SHORT).show();
   }

// 当发现一个新的蓝牙设备时注册广播
   IntentFilter filter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
   this.registerReceiver(mReceiver, filter);

// 当搜索完毕后注册广播
   filter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
   this.registerReceiver(mReceiver, filter);

}

@Override
 public void onStart() {
   super.onStart();
   // 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();
   // 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() {

mSendButton.setOnClickListener(new OnClickListener() {
     public void onClick(View v) {
       // Send a message using content of the edit text widget
       String message = text_input.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 void onDestroy() {
   super.onDestroy();
   // Stop the Bluetooth chat services
   if (mChatService != null)
     mChatService.stop();

// Make sure we're not doing discovery anymore
   if (mBluetoothAdapter != null) {
     mBluetoothAdapter.cancelDiscovery();
   }
   // Unregister broadcast listeners
   this.unregisterReceiver(mReceiver);
 }

/** 使本地的蓝牙设备可被发现 */
 private void ensureDiscoverable() {
   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, "没有连接上", 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);
     text_input.setText(mOutStringBuffer);
   }
 }

// 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:
       switch (msg.arg1) {
       case BluetoothChatService.STATE_CONNECTED:
         mTitle.setText("已经连接");
         mTitle.append(mConnectedDeviceName);
         // mConversationArrayAdapter.clear();
         break;
       case BluetoothChatService.STATE_CONNECTING:
         mTitle.setText("正在连接中...");
         break;
       case BluetoothChatService.STATE_LISTEN:
       case BluetoothChatService.STATE_NONE:
         mTitle.setText("未连接上");
         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);
       text_chat.append("我：" + writeMessage + "\n");
       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);
       text_chat.append(mConnectedDeviceName + "：" + readMessage
           + "\n");
       break;
     case MESSAGE_DEVICE_NAME:
       // save the connected device's 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;
     }
   }
 };

// 连接蓝牙设备
 private void linkDevice() {
   if (mBluetoothAdapter.isDiscovering()) {
     mBluetoothAdapter.cancelDiscovery();
   }
   int cou = mPairedDevicesList.size() + mNewDevicesList.size();
   if (cou == 0) {
     Toast.makeText(BluetoothChat.this, "没有搜索到可用的蓝牙设备",
         Toast.LENGTH_SHORT).show();
     return;
   }

// 把已经配对的蓝牙设备和新发现的蓝牙设备的名称都放入数组中，以便在对话框列表中显示
   strName = new String[cou];
   for (int i = 0; i < mPairedDevicesList.size(); i++) {
     strName[i] = mPairedDevicesList.get(i);
   }
   for (int i = mPairedDevicesList.size(); i < strName.length; i++) {
     strName[i] = mNewDevicesList.get(i - mPairedDevicesList.size());
   }
   address = strName[0].substring(strName[0].length() - 17);
   new AlertDialog.Builder(BluetoothChat.this)
       .setTitle("搜索到的蓝牙设备：")
       .setSingleChoiceItems(strName, 0,
           new DialogInterface.OnClickListener() {

@Override
             public void onClick(DialogInterface dialog,
                 int which) {
               // 当用户点击选中的蓝牙设备时，取出选中的蓝牙设备的MAC地址
               address = strName[which].split("\\n")[1].trim();
             }
           })
       .setPositiveButton("连接", new DialogInterface.OnClickListener() {

@Override
         public void onClick(DialogInterface dialog, int which) {
           if (address == null) {
             Toast.makeText(BluetoothChat.this, "请先连接外部蓝牙设备",
                 Toast.LENGTH_SHORT).show();
             return;
           }

Log.i("sxd", "address:" + address);
           // Get the BLuetoothDevice object
           BluetoothDevice device = mBluetoothAdapter
               .getRemoteDevice(address);
           // Attempt to connect to the device
           mChatService.connect(device);
         }
       })
       .setNegativeButton("取消", new DialogInterface.OnClickListener() {

@Override
         public void onClick(DialogInterface dialog, int which) {

}
       }).create().show();
 }

// 搜索蓝牙设备蓝牙设备
 private void searchDevice() {
   mTitle.setText("正在努力搜索中...");
   setProgressBarIndeterminateVisibility(true);
   if (mBluetoothAdapter.isDiscovering()) {
     mBluetoothAdapter.cancelDiscovery();
   }
   mNewDevicesList.clear();
   mBluetoothAdapter.startDiscovery();
 }

@Override
 public boolean onCreateOptionsMenu(Menu menu) {
   menu.add(0, 1, 0, "搜索设备");
   menu.add(0, 2, 0, "可被发现");
   return true;
 }

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 it's already paired, skip it, because it's been listed
       // already
       if (device.getBondState() != BluetoothDevice.BOND_BONDED) {
         String s = "未配对： " + device.getName() + "\n"
             + device.getAddress();
         if (!mNewDevicesList.contains(s))
           mNewDevicesList.add(s);
       }
       // When discovery is finished, change the Activity title
     } else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED
         .equals(action)) {
       setProgressBarIndeterminateVisibility(false);
       if (mNewDevicesList.size() == 0) {
         Toast.makeText(BluetoothChat.this, "没有发现新设备",
             Toast.LENGTH_SHORT).show();
       }
       mTitle.setText("未连接");
       linkDevice();
     }
   }
 };

@Override
 public boolean onOptionsItemSelected(MenuItem item) {
   switch (item.getItemId()) {
   case 1:
     searchDevice();
     return true;
   case 2:
     // Ensure this device is discoverable by others
     ensureDiscoverable();
     return true;
   }
   return false;
 }

}

package com.it2388.bluetooth;

/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*   http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.UUID;

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.
*
* *这个类做所有的工作，建立和管理蓝牙 与其他设备的连接。它有一个线程监听 传入的连接，一个用于连接一个设备的线程，和一个 当连接时执行数据传输的线程。
*/
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 对于SDP记录名称创建服务器套接字时
 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, "不能连接到设备");
   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, "设备连接中断");
   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).
  */
 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("sxd", " ======== ufcomm exception =======", 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("sxd", "---> accept socket 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) {
       Log.e("sxd", "链接发生了异常", 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);
     }
   }
 }
}