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

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;

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
  
  public BluetoothChatService(Context context, Handler handler) {
    mAdapter = BluetoothAdapter.getDefaultAdapter();
    mState = STATE_NONE;
    mHandler = handler;
  }
  
  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();
  }
  
  public synchronized int getState() {
    return mState;
  }
  
  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);
  }
  
  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);
  }
  
  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);
  }
  
  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);
  }
  
  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);
  }
  
  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);
  }
  
  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);
  }
  
  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);
      }
    }
  }
  
  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);
      }
    }
  }
  
  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;
        }
      }
    }
    
    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);
      }
    }
  }
}

您可能感兴趣的文章:Android蓝牙开发深入解析详解Android——蓝牙技术 带你实现终端间数据传输Android单片机与蓝牙模块通信实例代码Android Bluetooth蓝牙技术使用流程详解分享Android 蓝牙4.0(ble)开发的解决方案android实现蓝牙文件发送的实例代码,支持多种机型Android手机通过蓝牙连接佳博打印机的实例代码Android系统中的蓝牙连接程序编写实例教程Android 获取蓝牙Mac地址的正确方法Android实现蓝牙（BlueTooth）设备检测连接