Android蓝牙通信编程_Android

项目涉及蓝牙通信，所以就简单的学了学，下面是自己参考了一些资料后的总结，希望对大家有帮助。
 以下是开发中的几个关键步骤：
1、首先开启蓝牙 
2、搜索可用设备 
3、创建蓝牙socket，获取输入输出流 
4、读取和写入数据
5、断开连接关闭蓝牙 

下面是一个蓝牙聊天demo 
效果图： 

在使用蓝牙是 BluetoothAdapter 对蓝牙开启，关闭，获取设备列表，发现设备，搜索等核心功能 

下面对它进行封装： 

package com.xiaoyu.bluetooth;

import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
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;

public class BTManage {

// private List<BTItem> mListDeviceBT=null;
 private BluetoothAdapter mBtAdapter =null;
 private static BTManage mag=null;

 private BTManage(){
// mListDeviceBT=new ArrayList<BTItem>();
 mBtAdapter=BluetoothAdapter.getDefaultAdapter();
 }

 public static BTManage getInstance(){
 if(null==mag)
 mag=new BTManage();
 return mag;
 }

 private StatusBlueTooth blueStatusLis=null;
 public void setBlueListner(StatusBlueTooth blueLis){
 this.blueStatusLis=blueLis;
 }

 public BluetoothAdapter getBtAdapter(){
 return this.mBtAdapter;
 }

 public void openBluetooth(Activity activity){
 if(null==mBtAdapter){ ////Device does not support Bluetooth
 AlertDialog.Builder dialog = new AlertDialog.Builder(activity);
 dialog.setTitle("No bluetooth devices");
 dialog.setMessage("Your equipment does not support bluetooth, please change device"); 

 dialog.setNegativeButton("cancel",
  new DialogInterface.OnClickListener() {
  @Override
  public void onClick(DialogInterface dialog, int which) { 

  }
  });
 dialog.show();
 return;
 }
 // If BT is not on, request that it be enabled.
 if (!mBtAdapter.isEnabled()) {
 /*Intent enableIntent = new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
 activity.startActivityForResult(enableIntent, 3);*/
 mBtAdapter.enable();
 }
 }

 public void closeBluetooth(){
 if(mBtAdapter.isEnabled())
 mBtAdapter.disable();
 }

 public boolean isDiscovering(){
 return mBtAdapter.isDiscovering();
 }

 public void scanDevice(){
// mListDeviceBT.clear();
 if(!mBtAdapter.isDiscovering())
 mBtAdapter.startDiscovery();
 }

 public void cancelScanDevice(){
 if(mBtAdapter.isDiscovering())
 mBtAdapter.cancelDiscovery();
 }

 public void registerBluetoothReceiver(Context mcontext){
 // Register for broadcasts when start bluetooth search
 IntentFilter startSearchFilter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
 mcontext.registerReceiver(mBlueToothReceiver, startSearchFilter);
 // Register for broadcasts when a device is discovered
 IntentFilter discoveryFilter = new IntentFilter(BluetoothDevice.ACTION_FOUND);
 mcontext.registerReceiver(mBlueToothReceiver, discoveryFilter);
 // Register for broadcasts when discovery has finished
 IntentFilter foundFilter = new IntentFilter(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
 mcontext.registerReceiver(mBlueToothReceiver, foundFilter);
 }

 public void unregisterBluetooth(Context mcontext){
 cancelScanDevice();
 mcontext.unregisterReceiver(mBlueToothReceiver);
 }

 public List<BTItem> getPairBluetoothItem(){
 List<BTItem> mBTitemList=null;
 // Get a set of currently paired devices
 Set<BluetoothDevice> pairedDevices = mBtAdapter.getBondedDevices();
 Iterator<BluetoothDevice> it=pairedDevices.iterator();
 while(it.hasNext()){
 if(mBTitemList==null)
 mBTitemList=new ArrayList<BTItem>();

 BluetoothDevice device=it.next();
 BTItem item=new BTItem();
 item.setBuletoothName(device.getName());
 item.setBluetoothAddress(device.getAddress());
 item.setBluetoothType(BluetoothDevice.BOND_BONDED);
 mBTitemList.add(item);
 }
 return mBTitemList;
 }

 private final BroadcastReceiver mBlueToothReceiver = new BroadcastReceiver() {
 @Override
 public void onReceive(Context context, Intent intent) {
 String action = intent.getAction();
 if(BluetoothAdapter.ACTION_DISCOVERY_STARTED.equals(action)) {
 if(blueStatusLis!=null)
 blueStatusLis.BTDeviceSearchStatus(StatusBlueTooth.SEARCH_START);
 }
 else if (BluetoothDevice.ACTION_FOUND.equals(action)){
 // When discovery finds a device
  // Get the BluetoothDevice object from the Intent
  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) {
  BTItem item=new BTItem();
  item.setBuletoothName(device.getName());
  item.setBluetoothAddress(device.getAddress());
  item.setBluetoothType(device.getBondState());

  if(blueStatusLis!=null)
 blueStatusLis.BTSearchFindItem(item);
 // mListDeviceBT.add(item);
  }
 }
 else if (BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)){
 // When discovery is finished, change the Activity title
 if(blueStatusLis!=null)
 blueStatusLis.BTDeviceSearchStatus(StatusBlueTooth.SEARCH_END);
 }
 }
 }; 

}

蓝牙开发和socket一致，分为server，client

server功能类封装： 

package com.xiaoyu.bluetooth;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.util.UUID;

import com.xiaoyu.utils.ThreadPool;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothServerSocket;
import android.bluetooth.BluetoothSocket;
import android.os.Handler;
import android.os.Message;

public class BTServer {

 /* 一些常量，代表服务器的名称 */
 public static final String PROTOCOL_SCHEME_L2CAP = "btl2cap";
 public static final String PROTOCOL_SCHEME_RFCOMM = "btspp";
 public static final String PROTOCOL_SCHEME_BT_OBEX = "btgoep";
 public static final String PROTOCOL_SCHEME_TCP_OBEX = "tcpobex";

 private BluetoothServerSocket btServerSocket = null;
 private BluetoothSocket btsocket = null;
 private BluetoothAdapter mBtAdapter =null;
 private BufferedInputStream bis=null;
 private BufferedOutputStream bos=null;

 private Handler detectedHandler=null;

 public BTServer(BluetoothAdapter mBtAdapter,Handler detectedHandler){
 this.mBtAdapter=mBtAdapter;
 this.detectedHandler=detectedHandler;
 }

 public void startBTServer() {
 ThreadPool.getInstance().excuteTask(new Runnable() {
 public void run() {
 try {
 btServerSocket = mBtAdapter.listenUsingRfcommWithServiceRecord(PROTOCOL_SCHEME_RFCOMM,
 UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));

 Message msg = new Message();
  msg.obj = "请稍候，正在等待客户端的连接...";
  msg.what = 0;
  detectedHandler.sendMessage(msg); 

  btsocket=btServerSocket.accept();
 Message msg2 = new Message();
 String info = "客户端已经连接上！可以发送信息。";
  msg2.obj = info;
  msg.what = 0;
  detectedHandler.sendMessage(msg2); 

 receiverMessageTask();
 } catch(EOFException e){
 Message msg = new Message();
  msg.obj = "client has close!";
  msg.what = 1;
  detectedHandler.sendMessage(msg);
 }catch (IOException e) {
 e.printStackTrace();
 Message msg = new Message();
  msg.obj = "receiver message error! please make client try again connect!";
  msg.what = 1;
  detectedHandler.sendMessage(msg);
 }
 }
 });
 }

 private void receiverMessageTask(){
 ThreadPool.getInstance().excuteTask(new Runnable() {
 public void run() {
 byte[] buffer = new byte[2048];
 int totalRead;
 /*InputStream input = null;
 OutputStream output=null;*/
 try {
 bis=new BufferedInputStream(btsocket.getInputStream());
 bos=new BufferedOutputStream(btsocket.getOutputStream());
 } catch (IOException e) {
 e.printStackTrace();
 }

 try {
 // ByteArrayOutputStream arrayOutput=null;
 while((totalRead = bis.read(buffer)) > 0 ){
 // arrayOutput=new ByteArrayOutputStream();
 String txt = new String(buffer, 0, totalRead, "UTF-8");
 Message msg = new Message();
  msg.obj = txt;
  msg.what = 1;
  detectedHandler.sendMessage(msg);
 }
 } catch (IOException e) {
 e.printStackTrace();
 }
 }
 });
 }

 public boolean sendmsg(String msg){
 boolean result=false;
 if(null==btsocket||bos==null)
 return false;
 try {
 bos.write(msg.getBytes());
 bos.flush();
 result=true;
 } catch (IOException e) {
 e.printStackTrace();
 }
 return result;
 }

 public void closeBTServer(){
 try{
 if(bis!=null)
 bis.close();
 if(bos!=null)
 bos.close();
 if(btServerSocket!=null)
 btServerSocket.close();
 if(btsocket!=null)
 btsocket.close();
 }catch(IOException e){
 e.printStackTrace();
 }
 }

}

 client功能封装：

package com.xiaoyu.bluetooth;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.EOFException;
import java.io.IOException;
import java.util.UUID;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.os.Handler;
import android.os.Message;
import android.util.Log;

import com.xiaoyu.utils.ThreadPool;

public class BTClient {

 final String Tag=getClass().getSimpleName();
 private BluetoothSocket btsocket = null;
 private BluetoothDevice btdevice = null;
 private BufferedInputStream bis=null;
 private BufferedOutputStream bos=null;
 private BluetoothAdapter mBtAdapter =null;

 private Handler detectedHandler=null;

 public BTClient(BluetoothAdapter mBtAdapter,Handler detectedHandler){
 this.mBtAdapter=mBtAdapter;
 this.detectedHandler=detectedHandler;
 }

 public void connectBTServer(String address){
 //check address is correct
 if(BluetoothAdapter.checkBluetoothAddress(address)){
 btdevice = mBtAdapter.getRemoteDevice(address);
 ThreadPool.getInstance().excuteTask(new Runnable() {
 public void run() {
 try {
 btsocket = btdevice.createRfcommSocketToServiceRecord(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));

 Message msg2 = new Message();
  msg2.obj = "请稍候，正在连接服务器:"+BluetoothMsg.BlueToothAddress;
  msg2.what = 0;
  detectedHandler.sendMessage(msg2); 

  btsocket.connect();
  Message msg = new Message();
  msg.obj = "已经连接上服务端！可以发送信息。";
  msg.what = 0;
  detectedHandler.sendMessage(msg);
 receiverMessageTask();
 } catch (IOException e) {
 e.printStackTrace();
 Log.e(Tag, e.getMessage());

 Message msg = new Message();
  msg.obj = "连接服务端异常！请检查服务器是否正常，断开连接重新试一试。";
  msg.what = 0;
  detectedHandler.sendMessage(msg);
 }

 }
 });
 }
 }

 private void receiverMessageTask(){
 ThreadPool.getInstance().excuteTask(new Runnable() {
 public void run() {
 byte[] buffer = new byte[2048];
 int totalRead;
 /*InputStream input = null;
 OutputStream output=null;*/
 try {
 bis=new BufferedInputStream(btsocket.getInputStream());
 bos=new BufferedOutputStream(btsocket.getOutputStream());
 } catch (IOException e) {
 e.printStackTrace();
 }

 try {
 // ByteArrayOutputStream arrayOutput=null;
 while((totalRead = bis.read(buffer)) > 0 ){
 // arrayOutput=new ByteArrayOutputStream();
 String txt = new String(buffer, 0, totalRead, "UTF-8");
 Message msg = new Message();
  msg.obj = "Receiver: "+txt;
  msg.what = 1;
  detectedHandler.sendMessage(msg);
 }
 } catch(EOFException e){
 Message msg = new Message();
  msg.obj = "server has close!";
  msg.what = 1;
  detectedHandler.sendMessage(msg);
 }catch (IOException e) {
 e.printStackTrace();
 Message msg = new Message();
  msg.obj = "receiver message error! make sure server is ok,and try again connect!";
  msg.what = 1;
  detectedHandler.sendMessage(msg);
 }
 }
 });
 }

 public boolean sendmsg(String msg){
 boolean result=false;
 if(null==btsocket||bos==null)
 return false;
 try {
 bos.write(msg.getBytes());
 bos.flush();
 result=true;
 } catch (IOException e) {
 e.printStackTrace();
 }
 return result;
 }

 public void closeBTClient(){
 try{
 if(bis!=null)
 bis.close();
 if(bos!=null)
 bos.close();
 if(btsocket!=null)
 btsocket.close();
 }catch(IOException e){
 e.printStackTrace();
 }
 }

}

聊天界面，使用上面分装好的类，处理信息 

package com.xiaoyu.communication;

import java.util.ArrayList;
import java.util.List;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.text.TextUtils;
import android.view.Menu;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.inputmethod.InputMethodManager;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.RadioGroup;
import android.widget.RadioGroup.OnCheckedChangeListener;
import android.widget.Toast;

import com.xiaoyu.bluetooth.BTClient;
import com.xiaoyu.bluetooth.BTManage;
import com.xiaoyu.bluetooth.BTServer;
import com.xiaoyu.bluetooth.BluetoothMsg;

public class BTChatActivity extends Activity {

 private ListView mListView;
 private Button sendButton;
 private Button disconnectButton;
 private EditText editMsgView;
 private ArrayAdapter<String> mAdapter;
 private List<String> msgList=new ArrayList<String>();

 private BTClient client;
 private BTServer server;

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.bt_chat);
 initView();

 }

 private Handler detectedHandler = new Handler(){
 public void handleMessage(android.os.Message msg) {
 msgList.add(msg.obj.toString());
 mAdapter.notifyDataSetChanged();
 mListView.setSelection(msgList.size() - 1);
 };
 };

 private void initView() { 

 mAdapter=new ArrayAdapter<String>(this, android.R.layout.simple_list_item_1, msgList);
 mListView = (ListView) findViewById(R.id.list);
 mListView.setAdapter(mAdapter);
 mListView.setFastScrollEnabled(true);
 editMsgView= (EditText)findViewById(R.id.MessageText);
 editMsgView.clearFocus(); 

 RadioGroup group = (RadioGroup)this.findViewById(R.id.radioGroup);
 group.setOnCheckedChangeListener(new OnCheckedChangeListener() {
// @Override
// public void onCheckedChanged(RadioGroup arg0, int arg1) {
//  int radioId = arg0.getCheckedRadioButtonId();
//
// }
 @Override
 public void onCheckedChanged(RadioGroup group, int checkedId) {
 switch(checkedId){
 case R.id.radioNone:
 BluetoothMsg.serviceOrCilent = BluetoothMsg.ServerOrCilent.NONE;
 if(null!=client){
 client.closeBTClient();
 client=null;
 }
 if(null!=server){
 server.closeBTServer();
 server=null;
 }
 break;
 case R.id.radioClient:
 BluetoothMsg.serviceOrCilent = BluetoothMsg.ServerOrCilent.CILENT;
 Intent it=new Intent(getApplicationContext(),BTDeviceActivity.class);
  startActivityForResult(it, 100);
 break;
 case R.id.radioServer:
 BluetoothMsg.serviceOrCilent = BluetoothMsg.ServerOrCilent.SERVICE;
 initConnecter();
 break;
 }
 }
 });

 sendButton= (Button)findViewById(R.id.btn_msg_send);
 sendButton.setOnClickListener(new OnClickListener() {
 @Override
 public void onClick(View arg0) { 

  String msgText =editMsgView.getText().toString();
  if (msgText.length()>0) {
  if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.CILENT){
  if(null==client)
  return;
  if(client.sendmsg(msgText)){
  Message msg = new Message();
  msg.obj = "send: "+msgText;
  msg.what = 1;
  detectedHandler.sendMessage(msg);
  }else{
  Message msg = new Message();
  msg.obj = "send fail!! ";
  msg.what = 1;
  detectedHandler.sendMessage(msg);
  }
  }
  else if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.SERVICE) {
  if(null==server)
  return;
  if(server.sendmsg(msgText)){
  Message msg = new Message();
  msg.obj = "send: "+msgText;
  msg.what = 1;
  detectedHandler.sendMessage(msg);
  }else{
  Message msg = new Message();
  msg.obj = "send fail!! ";
  msg.what = 1;
  detectedHandler.sendMessage(msg);
  }
  }
  editMsgView.setText("");
//  editMsgView.clearFocus();
//  //close InputMethodManager
//  InputMethodManager imm = (InputMethodManager)getSystemService(Context.INPUT_METHOD_SERVICE);
//  imm.hideSoftInputFromWindow(editMsgView.getWindowToken(), 0);
  }else{
  Toast.makeText(getApplicationContext(), "发送内容不能为空！", Toast.LENGTH_SHORT).show();
  }
 }
 }); 

 disconnectButton= (Button)findViewById(R.id.btn_disconnect);
 disconnectButton.setOnClickListener(new OnClickListener() {
 @Override
 public void onClick(View arg0) {
  if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.CILENT){
  if(null==client)
  return;
  client.closeBTClient();
  }
  else if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.SERVICE) {
  if(null==server)
  return;
  server.closeBTServer();
  }
  BluetoothMsg.isOpen = false;
  BluetoothMsg.serviceOrCilent=BluetoothMsg.ServerOrCilent.NONE;
  Toast.makeText(getApplicationContext(), "已断开连接！", Toast.LENGTH_SHORT).show();
 }
 });
 } 

 @Override
 protected void onResume() {
 super.onResume();

 if (BluetoothMsg.isOpen) {
 Toast.makeText(getApplicationContext(), "连接已经打开，可以通信。如果要再建立连接，请先断开！",
 Toast.LENGTH_SHORT).show();
 }
 }

 @Override
 protected void onActivityResult(int requestCode, int resultCode, Intent data) {
 super.onActivityResult(requestCode, resultCode, data);
 if(requestCode==100){
 //从设备列表返回
 initConnecter();
 }
 }

 private void initConnecter(){
 if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.CILENT) {
 String address = BluetoothMsg.BlueToothAddress;
 if (!TextUtils.isEmpty(address)) {
 if(null==client)
 client=new BTClient(BTManage.getInstance().getBtAdapter(), detectedHandler);
 client.connectBTServer(address);
 BluetoothMsg.isOpen = true;
 } else {
 Toast.makeText(getApplicationContext(), "address is empty please choose server address !",
 Toast.LENGTH_SHORT).show();
 }
 } else if (BluetoothMsg.serviceOrCilent == BluetoothMsg.ServerOrCilent.SERVICE) {
 if(null==server)
 server=new BTServer(BTManage.getInstance().getBtAdapter(), detectedHandler);
 server.startBTServer();
 BluetoothMsg.isOpen = true;
 }
 }

 @Override
 public boolean onCreateOptionsMenu(Menu menu) {
 // Inflate the menu; this adds items to the action bar if it is present.
 getMenuInflater().inflate(R.menu.main, menu);
 return true;
 }

}

 client搜索设备列表，连接选择server界面：

package com.xiaoyu.communication;

import java.util.ArrayList;
import java.util.List;

import android.app.Activity;
import android.app.AlertDialog;
import android.content.DialogInterface;
import android.content.Intent;
import android.os.Bundle;
import android.view.View;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.ArrayAdapter;
import android.widget.Button;
import android.widget.ListView;

import com.xiaoyu.bluetooth.BTItem;
import com.xiaoyu.bluetooth.BTManage;
import com.xiaoyu.bluetooth.BluetoothMsg;
import com.xiaoyu.bluetooth.StatusBlueTooth;

public class BTDeviceActivity extends Activity implements OnItemClickListener
 ,View.OnClickListener ,StatusBlueTooth{ 

// private List<BTItem> mListDeviceBT=new ArrayList<BTItem>();
 private ListView deviceListview;
 private Button btserch;
 private BTDeviceAdapter adapter;
 private boolean hasregister=false; 

 @Override
 protected void onCreate(Bundle savedInstanceState) {
 super.onCreate(savedInstanceState);
 setContentView(R.layout.finddevice);
 setView();

 BTManage.getInstance().setBlueListner(this);
 }

 private void setView(){
 deviceListview=(ListView)findViewById(R.id.devicelist);
 deviceListview.setOnItemClickListener(this);
 adapter=new BTDeviceAdapter(getApplicationContext());
 deviceListview.setAdapter(adapter);
 deviceListview.setOnItemClickListener(this);
 btserch=(Button)findViewById(R.id.start_seach);
 btserch.setOnClickListener(this);
 } 

 @Override
 protected void onStart() {
 super.onStart();
 //注册蓝牙接收广播
 if(!hasregister){
 hasregister=true;
 BTManage.getInstance().registerBluetoothReceiver(getApplicationContext());
 }
 }

 @Override
 protected void onResume() {
 // TODO Auto-generated method stub
 super.onResume();
 }

 @Override
 protected void onPause() {
 // TODO Auto-generated method stub
 super.onPause();
 }

 @Override
 protected void onStop() {
 super.onStop();
 if(hasregister){
 hasregister=false;
 BTManage.getInstance().unregisterBluetooth(getApplicationContext());
 }
 }

 @Override
 protected void onDestroy() {
 super.onDestroy();

 }

 @Override
 public void onItemClick(AdapterView<?> parent, View view, int position,
 long id) {

 final BTItem item=(BTItem)adapter.getItem(position);

 AlertDialog.Builder dialog = new AlertDialog.Builder(this);// 定义一个弹出框对象
 dialog.setTitle("Confirmed connecting device");
 dialog.setMessage(item.getBuletoothName());
 dialog.setPositiveButton("connect",
 new DialogInterface.OnClickListener() {
  @Override
  public void onClick(DialogInterface dialog, int which) {
  // btserch.setText("repeat search");
  BTManage.getInstance().cancelScanDevice();
  BluetoothMsg.BlueToothAddress=item.getBluetoothAddress(); 

  if(BluetoothMsg.lastblueToothAddress!=BluetoothMsg.BlueToothAddress){
  BluetoothMsg.lastblueToothAddress=BluetoothMsg.BlueToothAddress;
  }
  setResult(100);
  finish();
  }
 });
 dialog.setNegativeButton("cancel",
 new DialogInterface.OnClickListener() {
  @Override
  public void onClick(DialogInterface dialog, int which) {
  BluetoothMsg.BlueToothAddress = null;
  }
 });
 dialog.show();
 }

 @Override
 public void onClick(View v) {
 BTManage.getInstance().openBluetooth(this);

 if(BTManage.getInstance().isDiscovering()){
 BTManage.getInstance().cancelScanDevice();
 btserch.setText("start search");
 }else{
 BTManage.getInstance().scanDevice();
 btserch.setText("stop search");
 }
 }

 @Override
 public void BTDeviceSearchStatus(int resultCode) {
 switch(resultCode){
 case StatusBlueTooth.SEARCH_START:
 adapter.clearData();
 adapter.addDataModel(BTManage.getInstance().getPairBluetoothItem());
 break;
 case StatusBlueTooth.SEARCH_END:
 break;
 }
 }

 @Override
 public void BTSearchFindItem(BTItem item) {
 adapter.addDataModel(item);
 }

 @Override
 public void BTConnectStatus(int result) {

 }

}

 搜索列表adapter:

package com.xiaoyu.communication;

import java.util.ArrayList;
import java.util.List;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.BaseAdapter;
import android.widget.TextView;

import com.xiaoyu.bluetooth.BTItem;

public class BTDeviceAdapter extends BaseAdapter{

 private List<BTItem> mListItem=new ArrayList<BTItem>();;
 private Context mcontext=null;
 private LayoutInflater mInflater=null;

 public BTDeviceAdapter(Context context){
 this.mcontext=context;
 // this.mListItem=mListItem;
 this.mInflater=(LayoutInflater)context.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

 }

 void clearData(){
 mListItem.clear();
 }

 void addDataModel(List<BTItem> itemList){
 if(itemList==null || itemList.size()==0)
 return;
 mListItem.addAll(itemList);
 notifyDataSetChanged();
 }
 void addDataModel(BTItem item){
 mListItem.add(item);
 notifyDataSetChanged();
 }

 @Override
 public int getCount() {

 return mListItem.size();
 }

 @Override
 public Object getItem(int position) {

 return mListItem.get(position);
 }

 @Override
 public long getItemId(int position) {

 return position;
 }

 @Override
 public View getView(int position, View convertView, ViewGroup parent) {
 ViewHolder holder=null;

 if(convertView==null){
 holder=new ViewHolder();
 convertView = mInflater.inflate(R.layout.device_item_row, null);
 holder.tv=(TextView)convertView.findViewById(R.id.itemText);
 convertView.setTag(holder);
 }else{
 holder=(ViewHolder)convertView.getTag();
 }

 holder.tv.setText(mListItem.get(position).getBuletoothName());
 return convertView;
 }

 class ViewHolder{
 TextView tv;
 }

}

 列表model:

package com.xiaoyu.bluetooth;

public class BTItem {

 private String buletoothName=null;
 private String bluetoothAddress=null;
 private int bluetoothType=-1;

 public String getBuletoothName() {
 return buletoothName;
 }
 public void setBuletoothName(String buletoothName) {
 this.buletoothName = buletoothName;
 }
 public String getBluetoothAddress() {
 return bluetoothAddress;
 }
 public void setBluetoothAddress(String bluetoothAddress) {
 this.bluetoothAddress = bluetoothAddress;
 }
 public int getBluetoothType() {
 return bluetoothType;
 }
 public void setBluetoothType(int bluetoothType) {
 this.bluetoothType = bluetoothType;
 }

}

 使用到的辅助类：

package com.xiaoyu.bluetooth;

public class BluetoothMsg {

 public enum ServerOrCilent{
 NONE,
 SERVICE,
 CILENT
 };
 //蓝牙连接方式
 public static ServerOrCilent serviceOrCilent = ServerOrCilent.NONE;
 //连接蓝牙地址
 public static String BlueToothAddress = null,lastblueToothAddress=null;
 //通信线程是否开启
 public static boolean isOpen = false;
}

 package com.xiaoyu.bluetooth;

public interface StatusBlueTooth {

 final static int SEARCH_START=110;
 final static int SEARCH_END=112;

 final static int serverCreateSuccess=211;
 final static int serverCreateFail=212;
 final static int clientCreateSuccess=221;
 final static int clientCreateFail=222;
 final static int connectLose=231;

 void BTDeviceSearchStatus(int resultCode);
 void BTSearchFindItem(BTItem item);
 void BTConnectStatus(int result);

}

 package com.xiaoyu.utils;

import java.util.concurrent.LinkedBlockingQueue;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;

public class ThreadPool {

 private AtomicBoolean mStopped = new AtomicBoolean(Boolean.FALSE);
 private ThreadPoolExecutor mQueue;
 private final int coreSize=2;
 private final int maxSize=10;
 private final int timeOut=2;
 private static ThreadPool pool=null;

 private ThreadPool() {
 mQueue = new ThreadPoolExecutor(coreSize, maxSize, timeOut, TimeUnit.SECONDS, new LinkedBlockingQueue<Runnable>(), sThreadFactory);
 // mQueue.allowCoreThreadTimeOut(true);
 } 

 public static ThreadPool getInstance(){
 if(null==pool)
 pool=new ThreadPool();
 return pool;
 }

 public void excuteTask(Runnable run) {
 mQueue.execute(run);
 } 

 public void closeThreadPool() {
 if (!mStopped.get()) {
 mQueue.shutdownNow();
 mStopped.set(Boolean.TRUE);
 }
 } 

 private static final ThreadFactory sThreadFactory = new ThreadFactory() {
 private final AtomicInteger mCount = new AtomicInteger(1); 

 @Override
 public Thread newThread(Runnable r) {
 return new Thread(r, "ThreadPool #" + mCount.getAndIncrement());
 }
 }; 

}

最后别忘了加入权限 
<uses-permission android:name="android.permission.BLUETOOTH"/>
 <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />
 <uses-permission android:name="android.permission.READ_CONTACTS"/>

在编程中遇到的问题:
 Exception:  Unable to start Service Discovery
java.io.IOException: Unable to start Service Discovery错误 

1、必须保证客户端，服务器端中的UUID统一,客户端格式为：UUID格式一般是"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"

 例如：UUID.fromString("81403000-13df-b000-7cf4-350b4a2110ee");
 2、必须进行配对处理后方可能够连接 

扩展：蓝牙后台配对实现（网上看到的整理如下）

static public boolean createBond(Class btClass, BluetoothDevice btDevice)
 throws Exception {
 Method createBondMethod = btClass.getMethod("createBond");
 Log.i("life", "createBondMethod = " + createBondMethod.getName());
 Boolean returnValue = (Boolean) createBondMethod.invoke(btDevice);
 return returnValue.booleanValue();
 }

 static public boolean setPin(Class btClass, BluetoothDevice btDevice,
 String str) throws Exception {
 Boolean returnValue = null;
 try {
 Method removeBondMethod = btClass.getDeclaredMethod("setPin",
 new Class[] { byte[].class });
 returnValue = (Boolean) removeBondMethod.invoke(btDevice,
 new Object[] { str.getBytes() });
 Log.i("life", "returnValue = " + returnValue);
 } catch (SecurityException e) {
 // throw new RuntimeException(e.getMessage());
 e.printStackTrace();
 } catch (IllegalArgumentException e) {
 // throw new RuntimeException(e.getMessage());
 e.printStackTrace();
 } catch (Exception e) {
 // TODO Auto-generated catch block
 e.printStackTrace();
 }
 return returnValue;
 }

 // 取消用户输入
 static public boolean cancelPairingUserInput(Class btClass,
 BluetoothDevice device) throws Exception {
 Method createBondMethod = btClass.getMethod("cancelPairingUserInput");
 // cancelBondProcess()
 Boolean returnValue = (Boolean) createBondMethod.invoke(device);
 Log.i("life", "cancelPairingUserInputreturnValue = " + returnValue);
 return returnValue.booleanValue();
 }

 

然后监听蓝牙配对的广播  匹配“android.bluetooth.device.action.PAIRING_REQUEST”这个action
 然后调用上面的setPin(mDevice.getClass(), mDevice, "1234"); // 手机和蓝牙采集器配对
 createBond(mDevice.getClass(), mDevice);
 cancelPairingUserInput(mDevice.getClass(), mDevice);
 mDevice是你要去连接的那个蓝牙的对象，1234为配对的pin码

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索android
， 蓝牙
通信
蓝牙通信编程、android 蓝牙编程、android wifi通信编程、android蓝牙编程书籍、android蓝牙编程入门，以便于您获取更多的相关知识。

时间： 2025-01-02 02:56:59

Android蓝牙通信编程_Android的相关文章

Android 串口通信编程及串口协议分析_Android

Android 串口通信编程:嵌入式编程和可穿戴设备及智能设备都会用到串口,这里就带大家分析下, 一,android串口通信 串口通信采用一个第三方开源项目,实现串口数据收发. 1. 使用了http://code.google.com/p/android-serialport-api/的项目的serialport api和jni: 2. 支持4串口同时收发,有定时自动发送功能,收发模式可选Txt或Hex模式: 3.  n,8,1,没得选: 4. 为减轻界面卡顿的情况,接收区的刷新采用单独的线程进

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

很不错的蓝牙通信demo实现发送和接受功能,就用了两个类就实现了,具体内容如下 说下思路把 主要有两个类 主界面类 和 蓝牙聊天服务类 . 首先创建线程 实际上就是创建BluetoothChatService() (蓝牙聊天服务类) 这个时候把handler 传过去 这样就可以操作UI 界面了,在线程中不断轮询读取蓝牙消息,当主界面点击发送按钮时 调用BluetoothChatService 的发送方法write 方法,这里的write 方法 使用了handler 发送消息,在主界面显示,另一个

Android蓝牙通信概述

通常情况下,我们对蓝牙的操作主要有:开启和关闭蓝牙.搜索周边设备.能被周边设备所发现.获取配对设备.蓝牙设备间的数据传输. 1.打开蓝牙(当然首先要确保你的手机是有蓝牙设备的) 蓝牙设备主要分为两部分,一部分为本地设备,另一部分为远程设备. BluetoothAdapter--本地设备,对蓝牙操作首先就需要有一个BluetoothAdapter实例.常用的几个方法如下: cancelDiscovery()--取消本地蓝牙设备的搜索操作,如果本地设备正在进行搜索,那么调用该方法后将停止搜索操作.

android-关于Android蓝牙通信的问题

问题描述 关于Android蓝牙通信的问题 想实现Android 和PC之间的蓝牙通信,在网上查找后发现有手机端和PC端两个代码要写,但是我不知道PC端的代码是写在手机端的那个APP里,还是单独再创建一个APP写作新的APP里面 解决方案 最近同学要做一个手机与蓝牙模块的通信的毕业设计,让我帮忙写一个手机端的应用,匆匆的找了些资料,总算是能勉强实现通信,总结一些关键的步骤:首先,android蓝牙通信步骤:1:打开蓝牙2:搜索蓝牙设备3:选择设备进行配对(连接前必须先配对)4:对配对好的设备建立

arduino与android蓝牙通信

问题描述 arduino与android蓝牙通信 Arduino与android蓝牙通信.在做一个Arduino的项目,在Arduino的板子上装有温度传感器,然后希望通过蓝牙实时传输到android,请问怎么实现? 解决方案 http://blog.csdn.net/xieyan0811/article/details/21476415 解决方案二: Arduino与Android蓝牙通信笔记

android应用-android蓝牙通信，制图

问题描述 android蓝牙通信,制图 目的是做一个android应用,从蓝牙接受数据,数据是16进制的,将其绘制成波形 我的问题是----毫无头绪... S0 S320 S396 S450 S508 S536 S506 S517 S546 S531 S509 S497 S503 S485 S470 S496 S506 S518 S511 S514 S522 S504 S491 S489 S484 S484 S493 S485 S516 S497 S512 S524 S516 S507 S500

Phone 蓝牙通信编程(初级)

原文地址:http://tech.it168.com/a2010/0114/837/000000837727.shtml iPhone OS 3.0的最佳功能是GameKit框架,这个框架包括了允许基于蓝牙网络进行通信的API,你可以更轻松地创建点到点的游戏和应用程序.与其它移动平台不一样,在iPhone中使用蓝牙作为一个通信信道比预期的要容易得多,因此,本文将向你展示如何构建一个简单的应用程序,实现iPhone和iPod之间的相互通信. 注意:如果要测试本文所介绍的内容,需要两部iPhone(

iPhone 掌握蓝牙通信编程

原文地址不详.  iPhone OS 3.0的最佳功能是GameKit框架,这个框架包括了允许基于蓝牙网络进行通信的API,你可以更轻松地创建点到点的游戏和应用程序.与其它移动平台不一样,在iPhone中使用蓝牙作为一个通信信道比预期的要容易得多,因此,本文将向你展示如何构建一个简单的应用程序,实现iPhone和iPod之间的相互通信. 注意:如果要测试本文所介绍的内容,需要两部iPhone(3G或3GS),或使用iPhone OS 3.0或更高版本的iPod设备(二代或更新版本). 创建一个项

android 蓝牙通信

问题描述 小弟现在正在做一个安卓的app,其中一个功能需要使用到蓝牙技术具体功能是通过蓝牙对接连个设备,然后由其中一台向另一台发送字符串数据,另一台接受数据.求大神指点一下该这么做啊... 解决方案 解决方案二:蓝牙api,,或者用类库解决方案三:android.bluetooth,BluetoothDevice类好好研究解决方案四:我最近也在做这个,但做app的时候碰到了一个问题,你的app做成功了没