android实现主动连接和被动连接的蓝牙聊天功能

package com.bluetooth.tool; 
 
import android.bluetooth.BluetoothAdapter; 
import android.bluetooth.BluetoothDevice; 
import android.bluetooth.BluetoothSocket; 
 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.util.UUID; 
 
//蓝牙连接管理类 
public class BluetoothManage { 
 private static final Object mLock = new Object(); 
 //蓝牙类的具体实现核心成员 
 private BluetoothAdapter mBtAdapter = BluetoothAdapter.getDefaultAdapter(); 
 //蓝牙类的具体数据核心成员 
 private BluetoothSocket mTransferSocket = null; 
 //当前连接的蓝牙地址 
 String mstrName = "";//当前连接用到的IP地址 
 String mstrAddress = "";//当前连接用到的IP地址 
 //读线程 
 ReadThread mReadThread = null; 
 //从数据核心成员拿到的输入输出 
 InputStream mInputStream = null; 
 OutputStream mOutputStream = null; 
 private static BluetoothManage manage = null; 
 
 public static BluetoothManage getInstance(){ 
 synchronized (BluetoothManage.class){ 
  if(manage == null) 
  manage = new BluetoothManage(); 
 } 
 return manage; 
 } 
 
 public boolean sendData(int nLength, byte[] data) { 
 if (mOutputStream == null) return false; 
 try { 
  mOutputStream.write(data, 0, nLength); 
  return true; 
 } catch (IOException e) { 
  e.printStackTrace(); 
 } 
 return false; 
 } 
 
 ConnectListener mConnectListener = null; 
 
 public void regConnectListener(ConnectListener arg0) { 
 mConnectListener = arg0; 
 } 
 
 TopDataIOListener mIOListener = null; 
 
 public void regIOListener(TopDataIOListener arg0) { 
 mIOListener = arg0; 
 } 
 
 public void unRegIOListener() { 
 mIOListener = null; 
 } 
 
 public boolean setSelectedDevice(String strDevice) { 
 String[] strings = strDevice.split("\\|"); 
 
 if (strings.length == 2) { 
  mstrName = strings[0]; 
  mstrAddress = strings[1]; 
  return true; 
 } 
 return false; 
 } 
 
 public String getSelectedDeviceName() { 
 if (mstrAddress.length() == 0) { 
  return null; 
 } 
 
 return String.format("%s|%s", mstrName, mstrAddress); 
 } 
 
 public void connect() { 
 if (mstrAddress.length() == 0) return; 
 
 final BluetoothDevice device = mBtAdapter.getRemoteDevice(mstrAddress); 
 new Thread(new Runnable() { 
  @Override 
  public void run() { 
  synchronized (mLock) { 
   String strLogString = ""; 
   try { 
   try { 
    mTransferSocket = device.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")); 
   } catch (IOException e1) { 
    mTransferSocket = null; 
   } 
 
   if (mTransferSocket == null) { 
    if (null != mConnectListener) 
    mConnectListener.OnConnectStatusCallBack(false); 
    return; 
   } 
   long nStartMillTime = System.currentTimeMillis(); 
 
   //连接 
   try { 
    mTransferSocket.connect(); 
   } catch (IOException e1) { 
    try { 
    mTransferSocket.close(); 
    } catch (IOException e2) { 
    e2.printStackTrace(); 
    } 
    //等待一定时间 
    mTransferSocket = null; 
 
    try { 
    long havePassTime = System.currentTimeMillis() - nStartMillTime; 
    if (havePassTime < 6000) { 
     Thread.sleep(7000 - havePassTime); 
    } 
    } catch (InterruptedException e) { 
    e.printStackTrace(); 
    } 
   } 
   //连接失败 
   if (mTransferSocket == null) { 
    if (null != mConnectListener) 
    mConnectListener.OnConnectStatusCallBack(false); 
    return; 
   } 
 
   try { 
    mInputStream = mTransferSocket.getInputStream(); 
    mOutputStream = mTransferSocket.getOutputStream(); 
    mReadThread = new ReadThread(); 
    mReadThread.start(); 
 
    if (null != mConnectListener) 
    mConnectListener.OnConnectStatusCallBack(true); 
   } catch (IOException e1) { 
    //断开连接 
    try { 
    if (mTransferSocket != null) 
     mTransferSocket.close(); 
    } catch (IOException e2) { 
    e2.printStackTrace(); 
    } 
 
    mTransferSocket = null; 
    e1.printStackTrace(); 
 
    if (null != mConnectListener) 
    mConnectListener.OnConnectStatusCallBack(false); 
   } 
   } catch (Exception e) { 
   //总体异常 
   if (null != mConnectListener) 
    mConnectListener.OnConnectStatusCallBack(false); 
   } 
  } 
  }//run() 
 }).start(); 
 } 
 
 //读取数据 
 class ReadThread extends Thread { 
 public void run() { 
  int nMaxBufLength = 1024; 
  byte[] buffer = new byte[nMaxBufLength]; 
  int byteRead = -1; 
 
  synchronized (mLock) { 
  while (!isInterrupted()) { 
   try { 
   if (mInputStream != null) { 
    byteRead = mInputStream.read(buffer); 
    if (byteRead > 0 && byteRead <= buffer.length) { 
    if (mIOListener != null) 
     mIOListener.OnIOCallBack(byteRead, buffer); 
    } else /*if (byteRead < 0 || byteRead > buffer.length)*/ { 
    //连接已断开 
    if (mConnectListener != null) { 
     mConnectListener.OnDisConnectCallBack(); 
    } 
    break; 
    } 
   } else { 
    break; 
   } 
   } catch (IOException e) { 
   //连接已断开 
   if (mConnectListener != null) { 
    mConnectListener.OnDisConnectCallBack(); 
   } 
   break; 
   } 
  }//while(!isInterrupted()) 
  }//synchronized (mLock) 
 } 
 } 
 
 //断开蓝牙 
 public void disConnect() { 
 mConnectListener = null; 
 //结束读线程 
 if (mReadThread != null) { 
  mReadThread.interrupt(); 
  mReadThread = null; 
 } 
 //取消所有连接 
 if (mTransferSocket != null) { 
  try { 
  mTransferSocket.close(); 
  if (mInputStream != null) 
   mInputStream.close(); 
  if (mOutputStream != null) 
   mOutputStream.close(); 
  mInputStream = null; 
  mOutputStream = null; 
  mTransferSocket = null; 
  } catch (IOException e) { 
  e.printStackTrace(); 
  } catch (Exception e) { 
  } 
 } 
 } 
} 

/** 
 * 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. 
 */ 
 
package com.bluetooth.tool; 
 
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; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.OutputStream; 
import java.util.UUID; 
 
/** 
 * 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 
 private static final String NAME = "BluetoothChat"; 
 
 // Unique UUID for this application 
 // private static final UUID MY_UUID = 
 // UUID.fromString("fa87c0d0-afac-11de-8a39-0800200c9a66"); 
 private static final UUID MY_UUID = UUID 
  .fromString("00001101-0000-1000-8000-00805F9B34FB"); 
 // 
 
 // Member fields 
 private final BluetoothAdapter mAdapter; 
 private final Handler mHandler; 
 private AcceptThread mAcceptThread; 
 private ConnectThread mConnectThread; 
 private ConnectedThread mConnectedThread; 
 private int mState; 
 private BluetoothDevice mBluetoothDevice = null; 
 
 // 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 
 
 public static boolean mbIsOpenTimer = false; 
 /** 
 * 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) { 
  Log.d(TAG, "start mAcceptThread"); 
  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); 
 mBluetoothDevice = device; 
 } 
 
 /** 
 * 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); 
 start(); 
 } 
 
 /** 
 * 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(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 
   if(mmServerSocket != null) 
   { 
   Log.d(TAG, "waitting accept!"); 
   socket = mmServerSocket.accept(); 
   Log.d(TAG, "accpting!"); 
   } 
   else 
   { 
   setState(STATE_NONE); 
    
   if (mAcceptThread != null) { 
    mAcceptThread = null; 
   } 
    
   Log.d(TAG, "mmServerSocket = null!"); 
   break; 
   } 
   
  } 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 { 
  if(mmServerSocket != null) 
   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; 
  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 
   if(mmInStream != null ){ 
   bytes = mmInStream.read(buffer); 
   if(bytes > 0 && bytes <= buffer.length) 
   { 
    onDadaReceive(buffer,0,bytes); 
   } 
   else{ 
    Log.i("recieve", "Baddata"); 
   } 
   } 
   else{ 
   Log.i(TAG, "BadInputStream"); 
   connectionLost(); 
   break; 
   } 
  } 
  catch (IOException e) { 
   Log.i(TAG, "disconnected" + e.toString(), e); 
   connectionLost(); 
   break; 
  } catch (Exception e) { 
   e.printStackTrace(); 
  } 
  } 
 } 
 
 private void onDadaReceive(byte[] buffer, int i, int bytes) { 
  if(bytes>0) 
  { 
  //֪ͨܘַ 
  mHandler.obtainMessage(BluetoothChat.MESSAGE_READ, bytes, 
   -1, buffer).sendToTarget(); 
 
  } 
  else 
  Log.e("recieve","null"); 
 
 } 
 
 /** 
  * 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); 
  } 
 } 
 } 
 
} 

package com.bluetooth.tool; 
 
import android.content.Context; 
import android.os.Handler; 
import android.os.Message; 
import android.util.Log; 
 
/** 
 * 蓝牙服务，接收蓝牙连接 
 */ 
public class BluetoothChat { 
 // Debugging 
 private static final String TAG = "BluetoothChat"; 
 private static final boolean D = true; 
 
 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"; 
 
 private String mConnectedDeviceName = null; 
 private static StringBuffer mOutStringBuffer; 
 private static BluetoothChatService mChatService = null; 
 private static Context mContext; 
 private volatile static BluetoothChat mBluetoothChat = null; 
 TopDataIOListener mIOListener = null; 
 
 public static BluetoothChat GetInstance(Context context) { 
 if (mBluetoothChat == null && mContext == null) { 
  synchronized (BluetoothChat.class){ 
  mBluetoothChat = new BluetoothChat(); 
  mContext = context; 
  } 
 } 
 return mBluetoothChat; 
 } 
 
 
 public void onStart() { 
 if (mChatService == null) 
  setupChat(); 
 if (mChatService != null) { 
  if (mChatService.getState() == BluetoothChatService.STATE_NONE) { 
  mChatService.start(); 
  } 
 } 
 } 
 
 private void setupChat() { 
 mChatService = new BluetoothChatService(mContext,mHandler); 
 mOutStringBuffer = new StringBuffer(""); 
 } 
 
 public void onDestroy() { 
 if (mChatService != null) 
  mChatService.stop(); 
 } 
 
 public void sendMessage(String message) { 
 if (mChatService.getState() != BluetoothChatService.STATE_CONNECTED) { 
  Log.i("Show", ""); 
  return; 
 } 
 if (message.length() > 0) { 
  byte[] send = message.getBytes(); 
  mChatService.write(send); 
  mOutStringBuffer.setLength(0); 
 } 
 } 
 
 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: 
   break; 
  case BluetoothChatService.STATE_CONNECTING: 
   break; 
  case BluetoothChatService.STATE_LISTEN: 
   break; 
  case BluetoothChatService.STATE_NONE: 
   break; 
  } 
  break; 
  case MESSAGE_WRITE: 
  byte[] writeBuf = (byte[]) msg.obj; 
  String writeMessage = new String(writeBuf); 
  break; 
  case MESSAGE_READ: 
  byte[] readBuf = (byte[]) msg.obj; 
  //收到的蓝牙数据，回传给界面显示 
  if (mIOListener != null) 
   mIOListener.OnIOCallBack(readBuf.length, readBuf); 
  break; 
  case MESSAGE_DEVICE_NAME: 
  mConnectedDeviceName = msg.getData().getString(DEVICE_NAME); 
  Log.i(TAG, "MESSAGE_DEVICE_NAME " + mConnectedDeviceName); 
  break; 
  case MESSAGE_TOAST: 
  break; 
  } 
 } 
 }; 
 
 public void regIOListener(TopDataIOListener arg0) { 
 mIOListener = arg0; 
 } 
 
}