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

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);      }    }  }}