android 蓝牙开发

最新推荐文章于 2024-01-05 09:00:00 发布
最新推荐文章于 2024-01-05 09:00:00 发布
阅读量983 收藏 2
点赞数
分类专栏： Android 文章标签： android 蓝牙 bluetooth
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/annieLiu502/article/details/39671333
版权

android蓝牙可以进行短距离的数据传输（10m内），所以可用于智能控制。

研究了几天，mark一下具体的操作；

1、蓝牙相关的类

1）BluetoothAdapter ：操作本机的蓝牙

1.1）获取本机蓝牙：BluetoothAdapter.getDefaultAdapter(); 如果返回null,则表示此手机不支持蓝牙。

1.2）开启蓝牙：

                                              Intent intent=new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);

                                              startActivity(intent);

1.3）获取已配对的设备：bluetoothAdapter.getBondedDevices();返回Set<BluetoothDevice>；

1.4）根据物理地址获取蓝牙设备：bluetoothAdapter.getRemoteDevice(device.getAddress());返回BluetoothDevice；

1.5）根据bluetoothDevice.createInsecureRfcommSocketToServiceRecord(UUID);获取BluetoothSocket；

2）BluetoothSocket／BluetoothServerSocket：用于蓝牙间的数据通信；用法类似于Socket／ServerSocket;具体可参见API。


2、代码实现

写了一个简单的蓝牙通信程序，代码如下：

1）权限设置：

<uses-permission android:name="android.permission.BLUETOOTH" />
<uses-permission android:name="android.permission.BLUETOOTH_ADMIN" />//作为服务器端时的权限


2）扫描所有可用设备：

bluetoothAdapter.getBondedDevices();获取已配对的设备；

bluetoothAdapter.startDiscovery();获取可配对的设备。注册一个广播接收器捕获设备发现其他蓝牙设备的时候发出的广播；

点击蓝牙设备，进入通信界面；

package com.dream.bluetoothcontrol;

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.view.View;
import android.view.View.OnClickListener;
import android.widget.AdapterView;
import android.widget.AdapterView.OnItemClickListener;
import android.widget.Button;
import android.widget.ListView;

public class MainActivity extends Activity {
	
	private ListView listview;
	private Button btnSearch;
	
	private BluetoothAdapter bluetoothAdapter;
	
	private ArrayList<Device> deviceList=new ArrayList<Device>();
	private DeviceAdapter deviceAdapter;
	private DeviceSearchBroadcastReceiver receiver;
	

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		setContentView(R.layout.device_found_fragment);		
		init();		
	}

	private void init() {
		bluetoothAdapter=BluetoothAdapter.getDefaultAdapter();
		// no blueTooth
		if(bluetoothAdapter==null){
			showPromptDialog(getResources().getString(R.string.msg_no_support_bluetooth));
		}
		
		receiver=new DeviceSearchBroadcastReceiver();
		IntentFilter filter=new IntentFilter();
		filter.addAction(BluetoothDevice.ACTION_FOUND);
		filter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
		this.registerReceiver(receiver,filter);
		
		initView();
	}
	

	private void initView() {
		listview=(ListView)findViewById(R.id.lv_devicefound_devicelist);
		deviceAdapter=new DeviceAdapter(deviceList, this);
		listview.setAdapter(deviceAdapter);
		listview.setOnItemClickListener(new OnItemClickListener() {

			@Override
			public void onItemClick(AdapterView<?> arg0, View arg1, int arg2,
					long arg3) {
				if(deviceAdapter.getItem(arg2).getType()
						==DeviceAdapter.VIEW_TYPE_DEVICE)
						clickItem(deviceAdapter.getItem(arg2));
			}
		});
		
		btnSearch=(Button)findViewById(R.id.btn_devicefound_search);
		btnSearch.setOnClickListener(new OnClickListener() {
			
			@Override
			public void onClick(View v) {
				searchBoundedDevice();
			}
		});
	}
	
	protected void searchBoundedDevice() {
		if(bluetoothAdapter.isDiscovering()){
			
		}else{
			deviceList.clear();
			
			Set<BluetoothDevice> btdSet=bluetoothAdapter.getBondedDevices();
			deviceList.add(new Device("Bounded Device",null,true,DeviceAdapter.VIEW_TYPE_HEADER));
			if(btdSet.size()>0){
				for(BluetoothDevice btd : btdSet){
					Device device=new Device();
					device.setName(btd.getName());
					device.setAddress(btd.getAddress());
					device.setSiri(true);
					device.setType(deviceAdapter.VIEW_TYPE_DEVICE);
					deviceList.add(device);
				}
				
				deviceAdapter.dataChanged(deviceList);
				listview.setSelection(listview.getCount()-1);
			}
			
			deviceList.add(new Device("Avaliable Device",null,false,DeviceAdapter.VIEW_TYPE_HEADER));
			bluetoothAdapter.startDiscovery();
			
		}
	}

	@Override
	protected void onStart() {
		// TODO Auto-generated method stub
		super.onStart();
		// open bluetooth
		if(!bluetoothAdapter.isEnabled()){
			Intent intent=new Intent(BluetoothAdapter.ACTION_REQUEST_ENABLE);
			startActivity(intent);
		}
		
		
	}
	
	@Override
	protected void onDestroy() {
		// TODO Auto-generated method stub
		super.onDestroy();
		this.unregisterReceiver(receiver);
	}
	
	private void showPromptDialog(String msg){
		AlertDialog.Builder builder=new AlertDialog.Builder(this);
		builder.setTitle("Tips");
		builder.setMessage(msg);
		builder.setPositiveButton("OK", new DialogInterface.OnClickListener() {
			
			@Override
			public void onClick(DialogInterface dialog, int which) {
				finish();
			}
		});
		builder.show();
	}

	private void clickItem(Device device) {
		Intent intent=new Intent(MainActivity.this,ChatActivity.class);
		intent.putExtra("device", device);
		startActivity(intent);
	}
	
	class DeviceSearchBroadcastReceiver extends BroadcastReceiver{
		
		@Override
		public void onReceive(Context context, Intent intent) {
			String action=intent.getAction();
			Device boundedDevice=new Device();
			// find a new device add into the devicelist
			if(BluetoothDevice.ACTION_FOUND.equals(action)){
				BluetoothDevice device=intent.getParcelableExtra(BluetoothDevice.EXTRA_DEVICE);
				if(device.getBondState()!=BluetoothDevice.BOND_BONDED){
					boundedDevice.setName(device.getName());
					boundedDevice.setAddress(device.getAddress());
					boundedDevice.setSiri(false);
					boundedDevice.setType(DeviceAdapter.VIEW_TYPE_DEVICE);
				}
			}else if(BluetoothAdapter.ACTION_DISCOVERY_FINISHED.equals(action)){
				if(listview.getCount()==0){
					boundedDevice.setName("no device to bound");
					boundedDevice.setAddress("");
					boundedDevice.setSiri(false);
					boundedDevice.setType(DeviceAdapter.VIEW_TYPE_DEVICE);
					deviceList.add(boundedDevice);				
				}
			}
			deviceList.add(boundedDevice);
			deviceAdapter.dataChanged(deviceList);
			listview.setSelection(listview.getCount()-1);
		}
		
	}
}

3）与其他蓝牙设备进行通信：

获取BluetoothSocket来进行通信；使用Handler进行UI操作；

package com.dream.bluetoothcontrol;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.util.ArrayList;
import java.util.UUID;

import android.annotation.SuppressLint;
import android.app.Activity;
import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.content.Context;
import android.os.Bundle;
import android.os.Handler;
import android.view.View;
import android.view.View.OnClickListener;
import android.view.inputmethod.InputMethodManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.ListView;
import android.widget.Toast;

public class ChatActivity extends Activity {

	private ListView listView;
	private Button btnSend;
	private EditText etSend;

	private ArrayList<SiriMessage> msgList = new ArrayList<ChatActivity.SiriMessage>();
	private ChatMsgAdapter adapter;
	private Device device;
	private BluetoothAdapter bluetoothAdapter;
	private BluetoothDevice btd;
	private BluetoothSocket socket;

	private ConnectionThread connectionThread;
	private ReceiveThread receiveThread;

	@Override
	protected void onCreate(Bundle savedInstanceState) {
		// TODO Auto-generated method stub
		super.onCreate(savedInstanceState);
		setContentView(R.layout.chat_fragment);

		device = (Device) this.getIntent().getSerializableExtra("device");

		initView();
		initSocket();
	}

	private void initView() {
		listView = (ListView) findViewById(R.id.lv_chatFragment_chatlist);
		adapter = new ChatMsgAdapter(msgList, this);
		listView.setAdapter(adapter);

		etSend = (EditText) findViewById(R.id.et_chatfragment_sendmsg);
		btnSend = (Button) findViewById(R.id.btn_chatfragment_send);
		btnSend.setOnClickListener(new OnClickListener() {

			@Override
			public void onClick(View v) {
				sendMessage();
			}
		});
	}

	protected void sendMessage() {
		String msgToSend = etSend.getText().toString();
		if (msgToSend.length() > 0) {
			sendMessage(msgToSend);
			etSend.getText().clear();

			InputMethodManager manager = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
			manager.hideSoftInputFromWindow(etSend.getWindowToken(), 0);
		} else {
			Toast.makeText(ChatActivity.this,
					"the messge to send cannot be null", Toast.LENGTH_LONG)
					.show();
		}
	}

	@SuppressLint("NewApi")
	public void sendMessage(final String msg) {
		if (socket == null) {
			Toast.makeText(ChatActivity.this, "no connection",
					Toast.LENGTH_SHORT).show();
			return;
		}

		try {
			OutputStream os = socket.getOutputStream();
			os.write(msg.getBytes());
			handler.obtainMessage(1, msg).sendToTarget();
		} catch (IOException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}

	}

	@SuppressLint("NewApi")
	private void initSocket() {
		bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();
		btd = bluetoothAdapter.getRemoteDevice(device.getAddress());
		connectionThread = new ConnectionThread();
		connectionThread.start();
	}

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

	protected void onDestroy() {
		super.onDestroy();
		new Thread() {
			@Override
			public void run() {

				try {
					if (connectionThread != null) {
						connectionThread.interrupt();
						connectionThread = null;
					}

					if (receiveThread != null) {
						receiveThread.interrupt();
						receiveThread = null;
					}

					if (socket != null) {
						try {
							socket.close();
						} catch (IOException e) {
							// TODO Auto-generated catch block
							e.printStackTrace();
						}
						socket = null;
					}
				} catch (Exception e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}.start();

	};

	class ConnectionThread extends Thread {
		@SuppressLint("NewApi")
		@Override
		public void run() {
			try {
				socket = btd.createInsecureRfcommSocketToServiceRecord(UUID
						.fromString(Const.uuid));
				handler.obtainMessage(0, "connecting,please wait a second")
						.sendToTarget();
				socket.connect();
				handler.obtainMessage(0, "connected success").sendToTarget();
				receiveThread = new ReceiveThread();
				receiveThread.start();
			} catch (Exception e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
				handler.obtainMessage(0, "there are some mistake please try again").sendToTarget();
			}
		}
	}

	class ReceiveThread extends Thread {
		@Override
		public void run() {
			InputStream is = null;
			try {
				is = socket.getInputStream();
			} catch (Exception e2) {
				// TODO Auto-generated catch block
				e2.printStackTrace();
			}
			byte[] buffer = new byte[1024];
			int len;
			while (true) {
				try {
					if ((len = is.read(buffer)) > 0) {
						byte[] data = new byte[len];
						for (int i = 0; i < len; i++) {
							data[i] = buffer[i];
						}

						String msg = new String(data);
						handler.obtainMessage(0, msg).sendToTarget();
					}
				} catch (Exception e) {
					try {
						is.close();
					} catch (Exception e1) {
						// TODO Auto-generated catch block
						e1.printStackTrace();
					}
				}
			}

		}
	}

	class SendThread extends Thread {
		private String msg;

		public SendThread(String msg) {
			this.msg = msg;
		}

		@Override
		public void run() {
			try {
				OutputStream os = socket.getOutputStream();
				os.write(msg.getBytes());
				handler.obtainMessage(1, msg).sendToTarget();
			} catch (IOException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
	}

	Handler handler = new Handler() {
		public void handleMessage(android.os.Message msg) {
			String sms = (String) msg.obj;
			SiriMessage sm = null;
			switch (msg.what) {
			case 0:
				sm = new SiriMessage(sms, false);
				break;
			case 1:
				sm = new SiriMessage(sms, true);
				break;
			}
			msgList.add(sm);
			adapter.dataChanged(msgList);
		};
	};

	class SiriMessage {
		private String msg;
		private boolean isSiri;

		public SiriMessage(String msg, boolean isSiri) {
			super();
			this.msg = msg;
			this.isSiri = isSiri;
		}

		public String getMsg() {
			return msg;
		}

		public void setMsg(String msg) {
			this.msg = msg;
		}

		public boolean isSiri() {
			return isSiri;
		}

		public void setSiri(boolean isSiri) {
			this.isSiri = isSiri;
		}

	}

}

4）效果图





在进行测试的过程中，如果没有两台手机，可以使用串口小助手，在PC端设置一个蓝牙接收器，就可以很方便的进行测试了


其他相关的蓝牙开发资料：

常用API：http://blog.csdn.net/xingfuyusheng/article/details/6745560





annieLiu502
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android Bluetooth-蓝牙
weixin_30454481的博客
03-21 82
bluetooth 一.开启蓝牙 1.获取BluetoothAdapter BluetoothAdapter.getDefaultAdapter() 2.判断手机设备是否 有蓝牙模块 3.开启蓝牙设备 4.扫描蓝牙设备 5.进行链接设备 二.蓝牙权限 1.允许程序连接到已配对的蓝牙设备 android.permission...
Android蓝牙（一）
tea_gag的博客
08-29 365
蓝牙的基本介绍和使用，主要是打开、关闭和搜索附近设备
Android蓝牙开发详解
yfwang0810的博客
08-02 637
一、相关API详解（API>=18） BluetoothAdapter 本地蓝牙的适配器，蓝牙交互入口，使用已知的MAC地址来实例化一个BluetoothDevice对象，支持Android4.3（API18）及以上版本 BuletoothDevice 代表一个远程的蓝牙设备，通过这个类可以查询远程设备的物理地址, 名称, 连接状态等信息;
Android获取input设备的相关信息(VID、PID等)
weixin_39966398的博客
12-02 1835
1.通过查询proc/bus/input/devices文件 # cat proc/bus/input/devices I: Bus=0019 Vendor=0001 Product=0001 Version=0100 N: Name="ff420030.pwm" P: Phys=gpio-keys/remotectl S: Sysfs=/devices/platform/ff420030.pwm/input/input0 U: Uniq= H: Handlers=event0 cpufreq dmcf
Android实现蓝牙连接步骤
shanhe_yuchuan的博客
01-05 642
蓝牙的API类本地的蓝牙适配器。通过这个类可以发现其他蓝牙设备，查询已配对的设备列表，使用一个已知的地址实例化一个BluetoothDevice，以及创建BluetoothServerSocket监听器。远程蓝牙设备，使用这个类来请求一个与远程设备的BluetoothSocket连接，或者查询设备名称、地址、连接状态等信息。代表一个蓝牙socket的接口。它允许一个应用与其他蓝牙设备通过InputStream和OutputStream交换数据。代表一个开放的服务器socket，它监听接受的请求。
Android蓝牙开发
03-26
Android蓝牙开发
android蓝牙开发工具包
05-07
这个是配合文章android蓝牙开发，通过Sbbluetooth.aar文件连接蓝牙设备并上传与解析数据使用的框架包，如果有问题私聊我，
Android蓝牙开发深入解析
09-04
由于近期正在开发一个通过蓝牙进行数据传递的模块，在参考了有关资料，并详细阅读了Android的官方文档后，总结了Android中蓝牙模块的使用
android蓝牙开发步骤.pdf
09-27
Android 蓝牙开发步骤详解 Android 蓝牙开发步骤是一个复杂的过程，它涉及到硬件、Linux 内核、库、框架和应用程序等多个方面。在本文中，我们将详细介绍 Android 蓝牙开发的步骤，从硬件到应用程序的所有方面。 ...
蓝牙4.0开发，可同时对多个蓝牙设备进行
08-13
蓝牙4.0开发，可同时对多个蓝牙设备进行连接，并进行简单数据通信 蓝牙4.0开发，可同时对多个蓝牙设备进行连接，并进行简单数据通信
蓝牙设备也有VendorId ProductId ?
Android/Linux的专栏
07-24 3784
在做一个蓝牙HID设备的时候，从机使用的SensorTile，主机使用的Android 5.0平板（内核3.4），在内核中的HID驱动和HID设备是通过VID PID匹配的，而这个SensorTile的VID PID一直是0x00, 0x00。为了快速验证，我把generic-usb或者hid-multitouch的hid_device_id表中添加了如下代码以兜底这个VID PID均为0x00的...
Android蓝牙协议详解
学无止境
10-18 2197
第一代蓝牙：关于短距离通讯早期的探索，使用的是BR技术，此时蓝牙的理论传输速率，只能达到721.2Kbps。第二代蓝牙：新增的技术，使得蓝牙设备的传输率可达3Mbps。第三代蓝牙：核心是，这是一种全新的交替射频技术，支持动态地选择正确射频，传输速率高达24Mbps第四代蓝牙：主推Low Energy低功耗，低功耗功能第五代蓝牙：开启「物联网」时代大门，在低功耗模式下具备更快更远的传输能力和。这两种技术都包括搜索（discovery）管理、连接（connection。
Android 蓝牙开发——获取已配对蓝牙并显示
weixin_42602900的博客
03-09 1901
Android 蓝牙开发——获取已配对蓝牙并显示
Android开发——蓝牙多设备连接（四）
热门推荐
Mr_Four
09-20 1万+
讲述蓝牙多设备连接的方法，设备的自动连接，怎么区分蓝牙设备返回的数据，实现蓝牙信息和返回结果进行持久化等。
android 蓝牙 列表,android蓝牙列表配对设备的例子
weixin_35880151的博客
05-27 578
BluetoothAdapter类的getBoundedDevices()方法提供了一个包含所有配对或绑定的蓝牙设备的列表的集合。在此示例中，我们正在检查蓝牙是否已关闭，如果是，则将其打开并列出所有配对的设备。activity_main.xml从面板上拖动一个textview，现在activity_main.xml文件将如下所示：xmlns:tools="http://schemas.androi...
actionBar+SearchView实现搜索功能
annieLiu502的专栏
10-20 3968
在项目中有使用到ActionBar和
android实现视频播放的几种方式
annieLiu502的专栏
10-09 3018
android实现视频播放主要有以下三种方式，可以根据
Appium自动化测试
annieLiu502的专栏
02-24 2918
使用 Appium 进行Android 自动化测试
Android 蓝牙开发
最新发布
01-30
Android蓝牙开发可以通过Android Bluetooth API来实现。使用Bluetooth API，Android应用可以执行以下操作： 1. 检查设备是否支持蓝牙功能： ```java BluetoothAdapter bluetoothAdapter = BluetoothAdapter....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值