Java 检查已连接的蓝牙设备状态

在传递数据之前，如何知道蓝牙设备是否仍连接到笔记本电脑？我使用lib编写了一个java程序，用于发现数据并通过笔记本电脑传递数据。在第一次传递数据后，如何在下次传递数据之前检查设备是否仍连接到笔记本电脑

---

我看到了类似的问题。但是他们询问了如何检查连接到android的蓝牙设备状态。

在设备之间搜索和共享文件时，您可以按照一系列步骤创建一个异步任务来验证连接

查找设备和完成查询时执行的函数是

deviceDiscovered（）

和

querycompleted（）

如果设备断开连接，您将从inqueryCompleted方法中获得通知，并在以下行中进行处理：

try {
                    synchronized(lock){
                        lock.wait();
                    }
                }

                catch (InterruptedException e) {
                    e.printStackTrace();
                }

在

InterruptedException

中，您可以处理错误

package bt;

import java.io.OutputStream;
import java.util.ArrayList;

import javax.bluetooth.DataElement;
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;
import javax.microedition.io.Connector;
import javax.obex.ClientSession;
import javax.obex.HeaderSet;
import javax.obex.Operation;
import javax.obex.ResponseCodes;

import bt.BTListener.MyDeviceListenerFilter;

public class MyDiscoveryListener implements DiscoveryListener{

    private static Object lock=new Object();
    public ArrayList<RemoteDevice> devices;

    public MyDiscoveryListener() {
        devices = new ArrayList<RemoteDevice>();
    }

    public static void main(String[] args) {

        MyDiscoveryListener listener =  new MyDiscoveryListener();

        try{
            LocalDevice localDevice = LocalDevice.getLocalDevice();
            DiscoveryAgent agent = localDevice.getDiscoveryAgent();
            agent.startInquiry(DiscoveryAgent.GIAC, listener);

            try {
                synchronized(lock){
                    lock.wait();
                }
            }
            catch (InterruptedException e) {
                e.printStackTrace();
                return;
            }


            System.out.println("Device Inquiry Completed. ");


            UUID[] uuidSet = new UUID[1];
            uuidSet[0]=new UUID(0x1105); //OBEX Object Push service

            int[] attrIDs =  new int[] {
                    0x0100 // Service name
            };

            for (RemoteDevice device : listener.devices) {
                agent.searchServices(
                        attrIDs,uuidSet,device,listener);


                try {
                    synchronized(lock){
                        lock.wait();
                    }
                }
                catch (InterruptedException e) {
                    e.printStackTrace();
                    return;
                }


                System.out.println("Service search finished.");
            }

        } catch (Exception e) {
            e.printStackTrace();
        }
    }



    @Override
    public void deviceDiscovered(RemoteDevice btDevice, DeviceClass arg1) {
        String name;
        try {
            name = btDevice.getFriendlyName(false);
        } catch (Exception e) {
            name = btDevice.getBluetoothAddress();
        }

        devices.add(btDevice);
        System.out.println("device found: " + name);

    }

    @Override
    public void inquiryCompleted(int arg0) {
        synchronized(lock){
            lock.notify();
        }
    }

    @Override
    public void serviceSearchCompleted(int arg0, int arg1) {
        synchronized (lock) {
            lock.notify();
        }
    }

    @Override
    public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
        for (int i = 0; i < servRecord.length; i++) {
            String url = servRecord[i].getConnectionURL(ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false);
            if (url == null) {
                continue;
            }
            DataElement serviceName = servRecord[i].getAttributeValue(0x0100);
            if (serviceName != null) {
                System.out.println("service " + serviceName.getValue() + " found " + url);

                if(serviceName.getValue().equals("OBEX Object Push")){
                    sendMessageToDevice(url);                
                }
            } else {
                System.out.println("service found " + url);
            }


        }
    }

    private static void sendMessageToDevice(String serverURL){
        try{
            System.out.println("Connecting to " + serverURL);

            ClientSession clientSession = (ClientSession) Connector.open(serverURL);
            HeaderSet hsConnectReply = clientSession.connect(null);
            if (hsConnectReply.getResponseCode() != ResponseCodes.OBEX_HTTP_OK) {
                System.out.println("Failed to connect");
                return;
            }

            HeaderSet hsOperation = clientSession.createHeaderSet();
            hsOperation.setHeader(HeaderSet.NAME, "Hello.txt");
            hsOperation.setHeader(HeaderSet.TYPE, "text");

            //Create PUT Operation
            Operation putOperation = clientSession.put(hsOperation);

            // Send some text to server
            byte data[] = "Hello World !!!".getBytes("iso-8859-1");
            OutputStream os = putOperation.openOutputStream();
            os.write(data);
            os.close();

            putOperation.close();

            clientSession.disconnect(null);

            clientSession.close();
        }
        catch (Exception e) {
            e.printStackTrace();
        }
    }

}

包bt；
导入java.io.OutputStream；
导入java.util.ArrayList；
导入javax.bluetooth.DataElement；
导入javax.bluetooth.DeviceClass；
导入javax.bluetooth.DiscoveryAgent；
导入javax.bluetooth.DiscoveryListener；
导入javax.bluetooth.LocalDevice；
导入javax.bluetooth.RemoteDevice；
导入javax.bluetooth.ServiceRecord；
导入javax.bluetooth.UUID；
导入javax.microedition.io.Connector；
导入javax.obex.ClientSession；
导入javax.obex.HeaderSet；
导入javax.obex.Operation；
导入javax.obex.ResponseCodes；
导入bt.BTListener.MyDeviceListenerFilter；
公共类MyDiscoveryListener实现DiscoveryListener{
私有静态对象锁=新对象（）；
公共阵列列表设备；
公共MyDiscoveryListener（）{
设备=新的ArrayList（）；
}
公共静态void main（字符串[]args）{
MyDiscoveryListener=新建MyDiscoveryListener（）；
试一试{
LocalDevice LocalDevice=LocalDevice.getLocalDevice（）；
DiscoveryAgent=localDevice.getDiscoveryAgent（）；
代理startInquiry（DiscoveryAgent.GIAC，listener）；
试一试{
已同步（锁定）{
lock.wait（）；
}
}
捕捉（中断异常e）{
e、 printStackTrace（）；
返回；
}
System.out.println（“设备查询完成”）；
UUID[]uuidSet=新的UUID[1]；
UUISet[0]=新UUID（0x1105）；//OBEX对象推送服务
int[]attrIDs=新int[]{
0x0100//服务名称
};
用于（远程设备：listener.devices）{
代理搜索服务(
属性、UUISet、设备、侦听器）；
试一试{
已同步（锁定）{
lock.wait（）；
}
}
捕捉（中断异常e）{
e、 printStackTrace（）；
返回；
}
System.out.println（“服务搜索完成”）；
}
}捕获（例外e）{
e、 printStackTrace（）；
}
}
@凌驾
发现公共无效设备（远程设备btDevice，设备类arg1）{
字符串名；
试一试{
name=btDevice.getFriendlyName（false）；
}捕获（例外e）{
name=btDevice.getBluetoothAddress（）；
}
设备。添加（btDevice）；
System.out.println（“找到的设备：+名称”）；
}
@凌驾
公共无效查询已完成（int arg0）{
已同步（锁定）{
lock.notify（）；
}
}
@凌驾
public void serviceSearchCompleted（int arg0，int arg1）{
已同步（锁定）{
lock.notify（）；
}
}
@凌驾
发现公共无效服务（int transID，ServiceRecord[]servRecord）{
for（int i=0；i