private void findDevice(){
 // 獲得已經(jīng)保存的配對(duì)設(shè)備
 Set<BluetoothDevice> pairedDevices = BluetoothAdapter.getDefaultAdapter().getBondedDevices();
 if (pairedDevices.size() > 0) {
  mGroupFriendListData.clear();
  GroupInfo groupInfo = new GroupInfo();
  groupInfo.setGroupName(BluetoothAdapter.getDefaultAdapter().getName());
  List<FriendInfo> friendInfoList = new ArrayList<>();
  for (BluetoothDevice device : pairedDevices) {
   FriendInfo friendInfo = new FriendInfo();
   friendInfo.setIdentificationName(device.getName());
   friendInfo.setDeviceAddress(device.getAddress());
   friendInfo.setFriendNickName(device.getName());
   friendInfo.setOnline(false);
   friendInfo.setJoinTime(DateTime.getStringByFormat(new Date(), DateTime.DEFYMDHMS));
   friendInfo.setBluetoothDevice(device);
   friendInfoList.add(friendInfo);
  }
  groupInfo.setFriendList(friendInfoList);
  groupInfo.setOnlineNumber(0);
  mGroupFriendListData.add(groupInfo);
  mGroupFriendAdapter.setGroupInfoList(mGroupFriendListData);
 }
}

Intent discoverableIntent = new
Intent(BluetoothAdapter.ACTION_REQUEST_DISCOVERABLE);
discoverableIntent.putExtra(BluetoothAdapter.EXTRA_DISCOVERABLE_DURATION, 300);
startActivity(discoverableIntent);

public class ScanBroadcastReceiver extends BroadcastReceiver {

 private IScanCallback<BluetoothDevice> scanCallback;
 private final Map<String, BluetoothDevice> mDeviceMap = new HashMap<>();

 public ScanBroadcastReceiver(IScanCallback<BluetoothDevice> scanCallback) {
  this.scanCallback = scanCallback;
 }

 @Override
 public void onReceive(Context context, Intent intent) {
  if (scanCallback == null) {
   return;
  }
  if(intent.getAction().equals(BluetoothDevice.ACTION_FOUND)){
   //掃描到藍(lán)牙設(shè)備
   BluetoothDevice bluetoothDevice = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
   if (bluetoothDevice == null) {
    return;
   }
   if (!mDeviceMap.containsKey(bluetoothDevice.getAddress())) {
    mDeviceMap.put(bluetoothDevice.getAddress(), bluetoothDevice);
   }
   scanCallback.discoverDevice(bluetoothDevice);
  }else if(intent.getAction().equals(BluetoothAdapter.ACTION_DISCOVERY_FINISHED)) {
   //掃描設(shè)備結(jié)束
   final List<BluetoothDevice> deviceList = new ArrayList<>(mDeviceMap.values());
   if(deviceList != null && deviceList.size() > 0){
    scanCallback.scanFinish(deviceList);
   } else{
    scanCallback.scanTimeout();
   }
  }
 }
}

public class PairBroadcastReceiver extends BroadcastReceiver {

 private IPairCallback pairCallback;

 public PairBroadcastReceiver(IPairCallback pairCallback) {
  this.pairCallback = pairCallback;
 }

 @Override
 public void onReceive(Context context, Intent intent) {
  if(intent.getAction().equals(BluetoothDevice.ACTION_BOND_STATE_CHANGED)){
   //取得狀態(tài)改變的設(shè)備，更新設(shè)備列表信息（配對(duì)狀態(tài)）
   BluetoothDevice device = intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
   if(device != null){
    resolveBondingState(device.getBondState());
   }
  }
 }

 private void resolveBondingState(final int bondState) {
  if (pairCallback == null) {
   return;
  }
  switch (bondState) {
   case BluetoothDevice.BOND_BONDED://已配對(duì)
    pairCallback.bonded();
    break;
   case BluetoothDevice.BOND_BONDING://配對(duì)中
    pairCallback.bonding();
    break;
   case BluetoothDevice.BOND_NONE://未配對(duì)
    pairCallback.unBonded();
    break;
   default:
    pairCallback.bondFail();
    break;
  }
 }
}

public class AcceptThread extends Thread {

 private BluetoothChatHelper mHelper;
 private final BluetoothServerSocket mServerSocket;
 private String mSocketType;

 public AcceptThread(BluetoothChatHelper bluetoothChatHelper, boolean secure) {
  mHelper = bluetoothChatHelper;
  BluetoothServerSocket tmp = null;
  mSocketType = secure ? "Secure" : "Insecure";

  try {
   if (secure) {
    tmp = mHelper.getAdapter().listenUsingRfcommWithServiceRecord(ChatConstant.NAME_SECURE, ChatConstant.UUID_SECURE);
   } else {
    tmp = mHelper.getAdapter().listenUsingInsecureRfcommWithServiceRecord(ChatConstant.NAME_INSECURE, ChatConstant.UUID_INSECURE);
   }
  } catch (IOException e) {
   BleLog.e("Socket Type: " + mSocketType + "listen() failed", e);
  }
  mServerSocket = tmp;
 }

 public void run() {
  BleLog.i("Socket Type: " + mSocketType + "BEGIN mAcceptThread" + this);
  setName("AcceptThread" + mSocketType);

  BluetoothSocket socket = null;

  while (mHelper.getState() != com.vise.basebluetooth.common.State.STATE_CONNECTED) {
   try {
    BleLog.i("wait new socket:" + mServerSocket);
    socket = mServerSocket.accept();
   } catch (IOException e) {
    BleLog.e("Socket Type: " + mSocketType + " accept() failed", e);
    break;
   }
   if (socket != null) {
    synchronized (this) {
     if(mHelper.getState() == com.vise.basebluetooth.common.State.STATE_LISTEN
       || mHelper.getState() == com.vise.basebluetooth.common.State.STATE_CONNECTING){
      BleLog.i("mark CONNECTING");
      mHelper.connected(socket, socket.getRemoteDevice(), mSocketType);
     } else if(mHelper.getState() == com.vise.basebluetooth.common.State.STATE_NONE
       || mHelper.getState() == com.vise.basebluetooth.common.State.STATE_CONNECTED){
      try {
       socket.close();
      } catch (IOException e) {
       BleLog.e("Could not close unwanted socket", e);
      }
     }
    }
   }
  }
  BleLog.i("END mAcceptThread, socket Type: " + mSocketType);
 }

 public void cancel() {
  BleLog.i("Socket Type" + mSocketType + "cancel " + this);
  try {
   mServerSocket.close();
  } catch (IOException e) {
   BleLog.e("Socket Type" + mSocketType + "close() of server failed", e);
  }
 }
}

public class ConnectThread extends Thread {

 private BluetoothChatHelper mHelper;
 private final BluetoothSocket mSocket;
 private final BluetoothDevice mDevice;
 private String mSocketType;

 public ConnectThread(BluetoothChatHelper bluetoothChatHelper, BluetoothDevice device, boolean secure) {
  mHelper = bluetoothChatHelper;
  mDevice = device;
  BluetoothSocket tmp = null;
  mSocketType = secure ? "Secure" : "Insecure";

  try {
   if (secure) {
    tmp = device.createRfcommSocketToServiceRecord(ChatConstant.UUID_SECURE);
   } else {
    tmp = device.createInsecureRfcommSocketToServiceRecord(ChatConstant.UUID_INSECURE);
   }
  } catch (IOException e) {
   BleLog.e("Socket Type: " + mSocketType + "create() failed", e);
  }
  mSocket = tmp;
 }

 public void run() {
  BleLog.i("BEGIN mConnectThread SocketType:" + mSocketType);
  setName("ConnectThread" + mSocketType);

  mHelper.getAdapter().cancelDiscovery();

  try {
   mSocket.connect();
  } catch (IOException e) {
   try {
    mSocket.close();
   } catch (IOException e2) {
    BleLog.e("unable to close() " + mSocketType + " socket during connection failure", e2);
   }
   mHelper.connectionFailed();
   return;
  }

  synchronized (this) {
   mHelper.setConnectThread(null);
  }

  mHelper.connected(mSocket, mDevice, mSocketType);
 }

 public void cancel() {
  try {
   mSocket.close();
  } catch (IOException e) {
   BleLog.e("close() of connect " + mSocketType
     + " socket failed", e);
  }
 }
}

public class ConnectedThread extends Thread {

 private final BluetoothChatHelper mHelper;
 private final BluetoothSocket mSocket;
 private final InputStream mInStream;
 private final OutputStream mOutStream;

 public ConnectedThread(BluetoothChatHelper bluetoothChatHelper, BluetoothSocket socket, String socketType) {
  BleLog.i("create ConnectedThread: " + socketType);
  mHelper = bluetoothChatHelper;
  mSocket = socket;
  InputStream tmpIn = null;
  OutputStream tmpOut = null;

  try {
   tmpIn = socket.getInputStream();
   tmpOut = socket.getOutputStream();
  } catch (IOException e) {
   BleLog.e("temp sockets not created", e);
  }

  mInStream = tmpIn;
  mOutStream = tmpOut;
 }

 public void run() {
  BleLog.i("BEGIN mConnectedThread");
  int bytes;
  byte[] buffer = new byte[1024];

  // Keep listening to the InputStream while connected
  while (true) {
   try {
    bytes = mInStream.read(buffer);
    byte[] data = new byte[bytes];
    System.arraycopy(buffer, 0, data, 0, data.length);
    mHelper.getHandler().obtainMessage(ChatConstant.MESSAGE_READ, bytes, -1, data).sendToTarget();
   } catch (IOException e) {
    BleLog.e("disconnected", e);
    mHelper.start(false);
    break;
   }
  }
 }

 public void write(byte[] buffer) {
  if(mSocket.isConnected()){
   try {
    mOutStream.write(buffer);
    mHelper.getHandler().obtainMessage(ChatConstant.MESSAGE_WRITE, -1, -1, buffer).sendToTarget();
   } catch (IOException e) {
    BleLog.e("Exception during write", e);
   }
  }
 }

 public void cancel() {
  try {
   mSocket.close();
  } catch (IOException e) {
   BleLog.e("close() of connect socket failed", e);
  }
 }
}