j2me蓝牙教程

详见http://baike.baidu.com/view/758770.htm#5


目前，很多手机已经具备了蓝牙功能。虽然MIDP2.0没有包括蓝牙API,但是JCP定义了JSR82, Java APIs for Bluetooth Wireless Technology (JABWT).这是一个可选API,很多支持MIDP2.0的手机已经实现了，比如Nokia 6600, Nokia 6670，Nokia7610等等。

目录

简介
Java 蓝牙 API
堆栈初始化
设备管理
设备发现
服务发现
通讯
实例代码
编辑本段
简介

　　对于一个开发者来说,如果目标平台支持JSR82的话，在制作联网对战类型游戏或者应用的时候，蓝牙是一个相当不错的选择。本文给出了一个最简单的蓝牙应用的J2ME程序，用以帮助开发者快速的掌握JSR82。该程序分别在2台蓝牙设备上安装后，一台设备作为服务端先运行，一台设备作为客户端后运行。在服务端上我们发布了一个服务，该服务的功能是把客户端发过来的字符串转变为大写字符串。客户端起动并搜索到服务端的服务后，我们就可以从客户端的输入框里输入任意的字符串，发送到服务端去，同时观察服务端的反馈结果。
　　本文并不具体讲述蓝牙的运行机制和JSR82的API结构，关于这些知识点，请参考本文的参考资料一节，这些参考资料会给你一个权威的精确的解释。
　　本文我们首先介绍在移动设备上进行java开发的基本原理，然后描述如何为蓝牙通讯编写java应用。
编辑本段
Java 蓝牙 API

　　Java蓝牙 API依赖java通用连接框架，一直一来这成为java 蓝牙API应用的一个局限。但是，人们建议将GCF加入到J2SE中。Java蓝牙API使得访问更多的系统成为可能。
　　Java蓝牙API定义了两个包：一个是Java蓝牙API的核心javax.bluetooth，另一个是用于对象交换协议的javax.obex（OBEX）。
　　根据JSR 82 规范，所有潜在蓝牙系统都必须支持蓝牙控制中心（BCC），该控制中心是一个控制面板，它的作用类似于可以让用户或OEM给堆栈中的某些配置参数定义具体值得应用程序，特别是，它将应用于堆栈初始化中。
　　任何蓝牙应用都有以下这些组件：堆栈初始化组件，设备管理组件，设备发现组件，服务发现组件和通讯组件。
编辑本段
堆栈初始化

　　在开始无线通讯之前，你需要以销售商预订的方式初始化蓝牙设备。（具体的堆栈初始化步骤超出了蓝牙API规范的范围。）
　　在一篇关于java与蓝牙技术起步的java net文章中，Bruce Hopkins（java与蓝牙技术的作者）向我们介绍了在Atinav java蓝牙开发平台上是如何通过一系列设置完成初始化工作的。（见列表A），在JSR 82规范不包含这些调用，这一点很重要，因为其它的JSR82实现可能包括其它的初始化堆栈的方式。
编辑本段
设备管理

　　JSR82规范介绍了用于设备管理的两个类：LocalDevice 和 RemoteDevice.
　　LocalDevice 允许你请求获得蓝牙设备的静态信息。它依靠javax.bluetooth.DeviceClass类来获得设备类型和它所提供的服务类型。
　　RemoteDevice可用来获得蓝牙邻近区的设备信息（例如，某个远程蓝牙设备的地址）。它可以代表一台远程设备（例如，一台在可到达范围内的设备），并提供相应的方法来获得关于这台设备的有关信息，包括它的蓝牙地址和名称。
　　每个蓝牙设备有一个唯一的硬件地址，像计算机的MAC地址一样。你可以设定设备发现的级别，通过调用LocalDevice 对象中的setDiscoverable（）方法可以使得其它蓝牙设备发现当前设备。（见列表B）
编辑本段
设备发现

　　无线设备需要一种机制来允许它们发现其它的设备并访问它们的功能。核心蓝牙API的DiscoveryAgent 类和DiscoveryListener接口提供了需要的发现服务。有三种方式获得可访问设备列表。DiscoveryAgent.startInquiry（）方法可将设备设置为查询模式，为了充分利用这种模式，应用必须要指定一个事件监听器来对与查询相关的事件作出反应。当查询完成或取消时，会调用DiscoveryListener.inquiryCompleted（）方法。
　　如果一台设备不想等待发现其它的设备，可以使用DiscoveryAgent.retrieveDevices（）方法来获得一个已经存在的列表。该方法或者返回一个在前面的查询中发现的设备列表，或者返回一个预知的设备列表，这些设备是由本地设备提前告诉蓝牙控制中心的它经常联系的设备。返回那种列表取决于传递的参数。列表C演示了最简单的一种方式，当检测到一台新的蓝牙设备时，对象需要使用DiscoveryAgent通过DiscoveryListener接口通知你。
编辑本段
服务发现

　　服务发现允许你发现附近的服务，而不管哪一台设备提供的该服务。DiscoveryAgent提供的方法可以用来发现蓝牙服务设备上的服务，并初始化服务发现事务。在服务可以被发现以前，必须首先在蓝牙服务设备上注册或广播该服务。服务设备负责完成很多任务，包括创建描述所提供的服务的服务记录，接受来自客户端的连接，向服务设备的服务发现数据库（SDDB）添加新的服务记录。总之，它的工作类似于web服务器。列表D是服务注册的一个例子。
编辑本段
通讯

　　两台设备必须共享通用的通讯协议才能通讯。为了应用能够访问更多的蓝牙服务，蓝牙java API提供了这样一个机制，它允许连接到使用RFCOMM， L2CAP， 或 OBEX协议的任何服务。如果服务使用了位于上面协议之上其它的协议（例如TCP/IP），只有在应用中利用CLDC通用连接框架实现额外的协议，才可以访问该服务。
　　用于服务记录的URL包括数字和符号，大体是这样的结构：
　　btspp://508031205080110F1B1B1D1C100：8.它的意思是客户应该使用蓝牙串口框架来建立到地址为508031205080110F1B1B1D1C100的设备的8号服务。设备地址和计算机的物理地址相似，列表E显示了简单的RFCOMM连接。
　　Peter V. Mikhalenko是sun公司认证的专业IT人员，是Deutsche银行的业务顾问。
编辑本段
实例代码

　　该程序包括3个java文件。一个是MIDlet,另外2个为服务端GUI和客户端GUI。该程序已经在wtk22模拟器和Nokia 6600,Nokia 6670两款手机上测试通过。
　　StupidBTMIDlet.java
　　import javax.microedition.lcdui.Alert;
　　import javax.microedition.lcdui.AlertType;
　　import javax.microedition.lcdui.Command;
　　import javax.microedition.lcdui.CommandListener;
　　import javax.microedition.lcdui.Display;
　　import javax.microedition.lcdui.Displayable;
　　import javax.microedition.lcdui.List;
　　import javax.microedition.midlet.MIDlet;
　　import javax.microedition.midlet.MIDletStateChangeException;
　　/**
　　* @author Jagie
　　*
　　* MIDlet
　　*/
　　public class StupidBTMIDlet extends MIDlet implements CommandListener {
　　List list;
　　ServerBox sb;
　　ClientBox cb;
　　/*
　　* (non-Javadoc)
　　*
　　* @see javax.microedition.midlet.MIDlet#startApp()
　　*/
　　protected void startApp() throws MIDletStateChangeException {
　　list = new List("傻瓜蓝牙入门", List.IMPLICIT);
　　list.append("Client", null);
　　list.append("Server", null);
　　list.setCommandListener(this);
　　Display.getDisplay(this).setCurrent(list);
　　}
　　/**
　　* debug方法
　　* @param s 要显示的字串
　　*/
　　public void showString(String s) {
　　Displayable dp = Display.getDisplay(this).getCurrent();
　　Alert al = new Alert(null, s, null, AlertType.INFO);
　　al.setTimeout(2000);
　　Display.getDisplay(this).setCurrent(al, dp);
　　}
　　/**
　　* 显示主菜单
　　*
　　*/
　　public void showMainMenu() {
　　Display.getDisplay(this).setCurrent(list);
　　}
　　protected void pauseApp() {
　　// TODO Auto-generated method stub
　　}
　　public void commandAction(Command com, Displayable disp) {
　　if (com == List.SELECT_COMMAND) {
　　List list = (List) disp;
　　int index = list.getSelectedIndex();
　　if (index == 1) {
　　if (sb == null) {
　　sb = new ServerBox(this);
　　}
　　sb.setString(null);
　　Display.getDisplay(this).setCurrent(sb);
　　} else {
　　//每次都生成新的客户端实例
　　cb = null;
　　System.gc();
　　cb = new ClientBox(this);
　　Display.getDisplay(this).setCurrent(cb);
　　}
　　}
　　}
　　protected void destroyApp(boolean arg0) throws MIDletStateChangeException {
　　// TODO Auto-generated method stub
　　}
　　}
　　///
　　ServerBox.java
　　import java.io.DataInputStream;
　　import java.io.DataOutputStream;
　　import java.io.IOException;
　　import java.util.Vector;
　　import javax.bluetooth.DiscoveryAgent;
　　import javax.bluetooth.LocalDevice;
　　import javax.bluetooth.ServiceRecord;
　　import javax.bluetooth.UUID;
　　import javax.microedition.io.Connector;
　　import javax.microedition.io.StreamConnection;
　　import javax.microedition.io.StreamConnectionNotifier;
　　import javax.microedition.lcdui.Command;
　　import javax.microedition.lcdui.CommandListener;
　　import javax.microedition.lcdui.Displayable;
　　import javax.microedition.lcdui.TextBox;
　　import javax.microedition.lcdui.TextField;
　　/**
　　* 服务端GUI
　　* @author Jagie
　　*
　　* TODO To change the template for this generated type comment go to
　　* Window - Preferences - Java - Code Style - Code Templates
　　*/
　　public class ServerBox extends TextBox implements Runnable, CommandListener {
　　Command com_pub = new Command("开启服务", Command.OK, 0);
　　Command com_cancel = new Command("终止服务", Command.CANCEL, 0);
　　Command com_back = new Command("返回", Command.BACK, 1);
　　LocalDevice localDevice;
　　StreamConnectionNotifier notifier;
　　ServiceRecord record;
　　boolean isClosed;
　　ClientProcessor processor;
　　StupidBTMIDlet midlet;
　　//响应服务的uuid
　　private static final UUID ECHO_SERVER_UUID = new UUID(
　　"F0E0D0C0B0A000908070605040302010", false);
　　public ServerBox(StupidBTMIDlet midlet) {
　　super(null, "", 500, TextField.ANY);
　　this.midlet = midlet;
　　this.addCommand(com_pub);
　　this.addCommand(com_back);
　　this.setCommandListener(this);
　　}
　　public void run() {
　　boolean isBTReady = false;
　　try {
　　localDevice = LocalDevice.getLocalDevice();
　　if (!localDevice.setDiscoverable(DiscoveryAgent.GIAC)) {
　　showInfo("无法设置设备发现模式");
　　return;
　　}
　　// prepare a URL to create a notifier
　　StringBuffer url = new StringBuffer("btspp://");
　　// indicate this is a server
　　url.append("localhost").append(':');
　　// add the UUID to identify this service
　　url.append(ECHO_SERVER_UUID.toString());
　　// add the name for our service
　　url.append(";name=Echo Server");
　　// request all of the client not to be authorized
　　// some devices fail on authorize=true
　　url.append(";authorize=false");
　　// create notifier now
　　notifier = (StreamConnectionNotifier) Connector
　　.open(url.toString());
　　record = localDevice.getRecord(notifier);
　　// remember we've reached this point.
　　isBTReady = true;
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　// nothing to do if no bluetooth available
　　if (isBTReady) {
　　showInfo("初始化成功，等待连接");
　　this.removeCommand(com_pub);
　　this.addCommand(com_cancel);
　　} else {
　　showInfo("初始化失败,退出");
　　return;
　　}
　　// 生成服务端服务线程对象
　　processor = new ClientProcessor();
　　// ok, start accepting connections then
　　while (!isClosed) {
　　StreamConnection conn = null;
　　try {
　　conn = notifier.acceptAndOpen();
　　} catch (IOException e) {
　　// wrong client or interrupted - continue anyway
　　continue;
　　}
　　processor.addConnection(conn);
　　}
　　}
　　public void publish() {
　　isClosed = false;
　　this.setString(null);
　　new Thread(this).start();
　　}
　　public void cancelService() {
　　isClosed = true;
　　showInfo("服务终止");
　　this.removeCommand(com_cancel);
　　this.addCommand(com_pub);
　　}
　　/*
　　* (non-Javadoc)
　　*
　　* @see javax.microedition.lcdui.CommandListener#commandAction(javax.microedition.lcdui.Command,
　　* javax.microedition.lcdui.Displayable)
　　*/
　　public void commandAction(Command arg0, Displayable arg1) {
　　if (arg0 == com_pub) {
　　//发布service
　　publish();
　　} else if (arg0 == com_cancel) {
　　cancelService();
　　} else {
　　cancelService();
　　midlet.showMainMenu();
　　}
　　}
　　/**
　　* 内部类，服务端服务线程。
　　* @author Jagie
　　*
　　* TODO To change the template for this generated type comment go to
　　* Window - Preferences - Java - Code Style - Code Templates
　　*/
　　private class ClientProcessor implements Runnable {
　　private Thread processorThread;
　　private Vector queue = new Vector();
　　private boolean isOk = true;
　　ClientProcessor() {
　　processorThread = new Thread(this);
　　processorThread.start();
　　}
　　public void run() {
　　while (!isClosed) {
　　synchronized (this) {
　　if (queue.size() == 0) {
　　try {
　　//阻塞，直到有新客户连接
　　wait();
　　} catch (InterruptedException e) {
　　}
　　}
　　}
　　//处理连接队列
　　StreamConnection conn;
　　synchronized (this) {
　　if (isClosed) {
　　return;
　　}
　　conn = (StreamConnection) queue.firstElement();
　　queue.removeElementAt(0);
　　processConnection(conn);
　　}
　　}
　　}
　　/**
　　* 往连接队列添加新连接，同时唤醒处理线程
　　* @param conn
　　*/
　　void addConnection(StreamConnection conn) {
　　synchronized (this) {
　　queue.addElement(conn);
　　notify();
　　}
　　}
　　}
　　/**
　　* 从StreamConnection读取输入
　　* @param conn
　　* @return
　　*/
　　private String readInputString(StreamConnection conn) {
　　String inputString = null;
　　try {
　　DataInputStream dis = conn.openDataInputStream();
　　inputString = dis.readUTF();
　　dis.close();
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　return inputString;
　　}
　　/**
　　* debug
　　* @param s
　　*/
　　private void showInfo(String s) {
　　StringBuffer sb = new StringBuffer(this.getString());
　　if (sb.length() > 0) {
　　sb.append("/n");
　　}
　　sb.append(s);
　　this.setString(sb.toString());
　　}
　　/**
　　* 处理客户端连接
　　* @param conn
　　*/
　　private void processConnection(StreamConnection conn) {
　　// 读取输入
　　String inputString = readInputString(conn);
　　//生成响应
　　String outputString = inputString.toUpperCase();
　　//输出响应
　　sendOutputData(outputString, conn);
　　try {
　　conn.close();
　　} catch (IOException e) {
　　} // ignore
　　showInfo("客户端输入:" + inputString + ",已成功响应!");
　　}
　　/**
　　* 输出响应
　　* @param outputData
　　* @param conn
　　*/
　　private void sendOutputData(String outputData, StreamConnection conn) {
　　try {
　　DataOutputStream dos = conn.openDataOutputStream();
　　dos.writeUTF(outputData);
　　dos.close();
　　} catch (IOException e) {
　　}
　　}
　　}
　　///
　　ClientBox.java
　　import java.io.DataInputStream;
　　import java.io.DataOutputStream;
　　import java.io.IOException;
　　import java.util.Vector;
　　import javax.microedition.io.Connector;
　　import javax.microedition.io.StreamConnection;
　　import javax.microedition.lcdui.Command;
　　import javax.microedition.lcdui.CommandListener;
　　import javax.microedition.lcdui.Displayable;
　　import javax.microedition.lcdui.Form;
　　import javax.microedition.lcdui.Gauge;
　　import javax.microedition.lcdui.StringItem;
　　import javax.microedition.lcdui.TextField;
　　//jsr082 API
　　import javax.bluetooth.BluetoothStateException;
　　import javax.bluetooth.DeviceClass;
　　import javax.bluetooth.DiscoveryAgent;
　　import javax.bluetooth.DiscoveryListener;
　　import javax.bluetooth.LocalDevice;
　　import javax.bluetooth.RemoteDevice;
　　import javax.bluetooth.ServiceRecord;
　　import javax.bluetooth.UUID;
　　/**
　　* 客户端GUI * @author Jagie *
　　* TODO To change the template for this generated type comment go to
　　* Window - Preferences - Java - Code Style - Code Templates
　　*/
　　public class ClientBox extends Form implements Runnable, CommandListener, DiscoveryListener {
　　//字串输入框
　　TextField input = new TextField(null, "", 50, TextField.ANY);
　　//loger
　　StringItem result = new StringItem("结果:", "");
　　private DiscoveryAgent discoveryAgent;
　　private UUID[] uuidSet;
　　//响应服务的UUID
　　private static final UUID ECHO_SERVER_UUID = new UUID( "F0E0D0C0B0A000908070605040302010", false);
　　//设备集合
　　Vector devices = new Vector();
　　//服务集合
　　Vector records = new Vector();
　　//服务搜索的事务id集合
　　int[] transIDs;
　　StupidBTMIDlet midlet;
　　public ClientBox(StupidBTMIDlet midlet) {
　　super("");
　　this.midlet=midlet;
　　this.append(result);
　　this.addCommand(new Command("取消",Command.CANCEL,1));
　　this.setCommandListener(this);
　　new Thread(this).start();
　　}
　　public void commandAction(Command arg0, Displayable arg1) {
　　if(arg0.getCommandType()==Command.CANCEL){
　　midlet.showMainMenu();
　　}else{
　　//匿名内部Thread，访问远程服务。
　　Thread fetchThread=new Thread(){
　　public void run(){
　　for(int i=0;i<records.size();i++){
　　ServiceRecord sr=(ServiceRecord)records.elementAt(i);
　　if(accessService(sr)){ //访问到一个可用的服务即可
　　break;
　　}
　　}
　　}
　　};
　　fetchThread.start();
　　}
　　}
　　private boolean accessService(ServiceRecord sr){
　　boolean result=false;
　　try {
　　String url = sr.getConnectionURL(
　　ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);
　　StreamConnection conn = (StreamConnection) Connector.open(url);
　　DataOutputStream dos=conn.openDataOutputStream();
　　dos.writeUTF(input.getString());
　　dos.close();
　　DataInputStream dis=conn.openDataInputStream();
　　String echo=dis.readUTF();
　　dis.close();
　　showInfo("反馈结果是:"+echo);
　　result=true;
　　} catch (IOException e) {
　　}
　　return result;
　　}
　　public synchronized void run() {
　　//发现设备和服务的过程中，给用户以Gauge
　　Gauge g=new Gauge(null,false,Gauge.INDEFINITE,Gauge.CONTINUOUS_RUNNING);
　　this.append(g);
　　showInfo("蓝牙初始化...");
　　boolean isBTReady = false;
　　try {
　　LocalDevice localDevice = LocalDevice.getLocalDevice();
　　discoveryAgent = localDevice.getDiscoveryAgent();
　　isBTReady = true;
　　} catch (Exception e) {
　　e.printStackTrace();
　　}
　　if (!isBTReady) {
　　showInfo("蓝牙不可用");
　　//删除Gauge
　　this.delete(1);
　　return;
　　} uuidSet = new UUID[2];
　　//标志我们的响应服务的UUID集合
　　uuidSet[0] = new UUID(0x1101);
　　uuidSet[1] = ECHO_SERVER_UUID;
　　try {
　　discoveryAgent.startInquiry(DiscoveryAgent.GIAC, this);
　　} catch (BluetoothStateException e) {
　　}
　　try {
　　//阻塞,由inquiryCompleted()回调方法唤醒
　　wait();
　　} catch (InterruptedException e1) {
　　e1.printStackTrace();
　　}
　　showInfo("设备搜索完毕,共找到"+devices.size()+"个设备,开始搜索服务");
　　transIDs = new int[devices.size()];
　　for (int i = 0; i < devices.size(); i++) {
　　RemoteDevice rd = (RemoteDevice) devices.elementAt(i);
　　try {
　　//记录每一次服务搜索的事务id
　　transIDs = discoveryAgent.searchServices(null, uuidSet,
　　rd, this);
　　} catch (BluetoothStateException e) {
　　continue;
　　}
　　}
　　try {
　　//阻塞,由serviceSearchCompleted()回调方法在所有设备都搜索完的情况下唤醒
　　wait();
　　} catch (InterruptedException e1) {
　　e1.printStackTrace();
　　}
　　showInfo("服务搜索完毕,共找到"+records.size()+"个服务,准备发送请求");
　　if(records.size()>0){
　　this.append(input);
　　this.addCommand(new Command("发送",Command.OK,0));
　　}
　　//删除Gauge
　　this.delete(1);
　　}
　　/**
　　* debug
　　* @param s
　　*/
　　private void showInfo(String s){
　　StringBuffer sb=new StringBuffer(result.getText());
　　if(sb.length()>0){
　　sb.append("/n");
　　}
　　sb.append(s);
　　result.setText(sb.toString());
　　}
　　/** * 回调方法 */
　　public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
　　if (devices.indexOf(btDevice) == -1) {
　　devices.addElement(btDevice);
　　}
　　}
　　/** * 回调方法，唤醒初始化线程 */
　　public void inquiryCompleted(int discType) {
　　synchronized (this) {
　　notify();
　　}
　　}
　　/** * 回调方法 */
　　public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
　　for (int i = 0; i < servRecord.length; i++) {
　　records.addElement(servRecord);
　　}
　　}
　　/** * 回调方法，唤醒初始化线程 */
　　public void serviceSearchCompleted(int transID, int respCode) {
　　for (int i = 0; i < transIDs.length; i++) {
　　if (transIDs == transID) {
　　transIDs = -1;
　　break;
　　}
　　}
　　//如果所有的设备都已经搜索服务完毕，则唤醒初始化线程。
　　boolean finished = true;
　　for (int i = 0; i < transIDs.length; i++) {
　　if (transIDs != -1) {
　　finished = false;
　　break;
　　}
　　}
　　if (finished) {
　　synchronized (this) {
　　notify();
　　}
　　}
　　}
　　}












另一个不错的教程:

http://hi.baidu.com/jacobi198711 ... 30c62c6059f399.html








/**
    LocalDevice类标识了本地蓝牙设备。蓝牙应用程序和LocalDevice之间的关系是典型的一对一关系：
    本地设备提供了方法来返回关于本地设备的信息，并且能够进入Bluetooth manager：
    .getBluetoothAddress()返回蓝牙设备地址。
    .getDeviceClass()返回设备类。
    .getFriendlyName()返回设备友好名称，蓝牙设备名通常是用户在蓝牙控制中心为其设置的。
    .getRecord()返回一个指定蓝牙连接的服务记录。
    .updateRecord()方法用来为指定的ServiceRecord更新SDDB服务记录。
    .getDiscoverable()返回设备的可发现状态。
    .setDiscoverable()设置设备的可发现状态。
    .getDiscoveryAgent()返回一个参考给发现代理。
    .getProperty()返回一个设备的蓝牙属性
    通过调用getProperty()方法你可以得到的属性包括：
    .bluetooth.api.version，蓝牙API版本
    .bluetooth.sd.attr.retrievable.max，一次性能够被获得的服务记录属性的最大值
    .bluetooth.connected.devices.max，支持的连接设备的最大值
    .bluetooth.sd.trans.max，同时发生的服务发现处理的最大值
    .bluetooth.l2cap.receiveMTU.max，L2CAP最大发射单元
   */

/**
    设备发现: discoveryAgent = localDevice.getDiscoveryAgent();
    使用DiscoveryAgent类的"设备发现"方法来开始和取消设备发现：
    .retrieveDevices()重新获得已经发现或者附近的已知设备
    .startInquiry() 启动发现附近设备，也叫inquiry
    .cancelInquiry()取消当前进行的任何请求
    蓝牙发现代理在请求阶段的不同时候会分别调用DiscoveryListener（发现监听器）不同的回调方法：
    .deviceDiscovered() 指出是否有设备被发现。
    .inquiryCompleted() 指出是否请求已经成功、触发一个错误或已被取消。
    设备发现以调用startInquiry()函数开始。
    在请求进行时，蓝牙发现代理会在适当的时候调用回调方法DeviceDiscovered()和inquiryCompleted()。
    服务发现:
    可以使用发现代理的服务发现方法来开始或取消服务发现：
    .selectService()启动服务发现搜索。（原文有误，根据API手册应为尝试定位一个服务）
    .searchServices()启动服务发现搜索。
    .cancelServiceSearch()取消在正在进行中的任何的服务发现搜索操作。
    蓝牙发现代理在服务发现阶段的不同时候会分别调用DiscoveryListener的服务发现回调方法：
    .servicesDiscovered() 表示是否服务已被发现。
    .serviceSearchCompleted()表示服务发现是否已经完成。
    服务发现的状态改变结束于DiscoveryListener的回调方法的返回。
    服务发现开始于对searchServices()的调用。当服务搜索进行时，
    蓝牙发现代理会在适当的时候回调servicesDiscovered()和 serviceSearchCompleted()方法。
   */
/**
   一个RemoteDevice的实例代表了一个远端蓝牙设备。
   在一个蓝牙客户端应用程序可以进行服务，消费之前，它必须发送一个设备请求来发现远端设备。
   典型的蓝牙应用程序和远端设备之间的关系是一对多：
   远端设备（RemoteDevice）提供的方法中，有些很类似于本地设备（LocalDevice）里提供的方法：
   .getBluetoothAddress()返回蓝牙地址。
   .getFriendlyName()返回蓝牙设备名。
   .getRemoteDevice()返回相应的被指定蓝牙连接的远端设备。
   .authenticate()尝试识别验证远端设备。
   .authorize()为指定的蓝牙连接去尝试批准远端设备访问本地设备。
   .encrypt()尝试为指定的蓝牙连接开启或关闭加密。
   .isAuthenticated()测试是否远端设备可以被验证。
   .isAuthorized()测试是否远端设备已经被蓝牙控制中心授权访问本地设备以进行蓝牙连接。
   .isEncrypted()测试是否本地设备和远端设备之间的通信被加密。
   .isTrustedDevice()测试是否远端设备被蓝牙控制中心指定为可信任的。
   */