Bluecove：SERVICE_SEARCH_DEVICE_NOT_REACHABLE 问题

Question

我尝试使用 BlueCove 连接到自定义蓝牙设备。我可以配对设备，但是当我尝试搜索服务时，我总是在 serviceSearchCompleted() 中得到 SERVICE_SEARCH_DEVICE_NOT_REACHABLE，并且没有发现任何服务。如果我在 Java 之外（在 Windows 中）尝试相同的操作，PC 蓝牙设备会发现并可以连接（使用 COM21、COM22...）到我设备上的 SPP 服务。

我做错了什么？ 我还尝试在设备发现结束后进行服务搜索。同样的问题。 请在下面找到我的代码。

非常感谢您提供有关如何解决此问题的任何想法，

阿德里安。

public class Test {
        private static Logger LOG = Logger.getLogger(Test.class.getName());

        private static final String NAME = "XXXX";
        private static final String PIN = "1234";
        private static final UUID[] UUIDS = new UUID[] {new UUID(0x0003), new UUID(0x1101)};

        private LocalDevice localDevice;
        private DiscoveryAgent discoveryAgent;
        private DiscoveryListener discoveryListener = new GDiscoveryListener();
        private Map<Integer, RemoteDevice> searchForServices = new HashMap<Integer, RemoteDevice>();
        private Collection<ServiceRecord> servicesDiscovered = new HashSet<ServiceRecord>();
        private Object lock = new Object();
        private CountDownLatch waitForDevices;

        protected void connect() {
                try {
                        localDevice = LocalDevice.getLocalDevice();
                        localDevice.setDiscoverable(DiscoveryAgent.GIAC);
                        LOG.info("Local Device: " + localDevice.getFriendlyName()
                                        + "(" + localDevice.getBluetoothAddress() + ")");
                        discoveryAgent = localDevice.getDiscoveryAgent();
                        LOG.finest("Start discovering devices");
                        discoveryAgent.startInquiry(DiscoveryAgent.GIAC, discoveryListener);
                try {
                    synchronized(lock) {
                        lock.wait();
                    }
                                if (searchForServices.size() > 0) {
                                        waitForDevices = new CountDownLatch(searchForServices.size());
                                waitForDevices.await();
                                }
                }
                catch (InterruptedException e) {
                                LOG.log(Level.WARNING, "Error waiting to terminate discovery", e);
                }
                LOG.finest(servicesDiscovered.size() + " services discovered");
                LOG.finest("Device discovery completed");
                } catch (BluetoothStateException e) {
                        LOG.log(Level.WARNING, "Error initializing Bluetooth", e);
                }

        }

        private class GDiscoveryListener implements DiscoveryListener {

                public void deviceDiscovered(RemoteDevice rd, DeviceClass dc) {
                        try {
                                String name = rd.getFriendlyName(false);
                                boolean isMine = NAME.equals(name);
                                LOG.info("Discovered: " + name + "(" + rd.getBluetoothAddress() + ")"
                                                + (isMine ? "" : " - ignoring"));
                                if (!isMine)
                                        return;
                                if (!rd.isAuthenticated()) {
                                        LOG.finest("Try to pair with " + name
+ " PIN: " + PIN);
                                        boolean paired = RemoteDeviceHelper.authenticate(rd, PIN);
                                        LOG.info("Pair with " + name + (paired ? " succesfull" : " failed"));
                                }
                                int transID = discoveryAgent.searchServices(null, UUIDS, rd, discoveryListener);
                                searchForServices.put(transID, rd);
                                LOG.finest("Searching for services for " + name + " with transaction " + transID);
                        } catch (BluetoothStateException e) {
                                LOG.log(Level.WARNING, "Cannot search services for "
                                                + rd.getBluetoothAddress(), e);
                        } catch (IOException e) {
                                LOG.log(Level.WARNING, "Error connecting ", e);
                        } catch (Throwable t) {
                                LOG.log(Level.WARNING, "Cannot search services for "
                                                + rd.getBluetoothAddress(), t);
                        }
                }

                public void inquiryCompleted(int respCode) {
                        synchronized(lock) {
                    lock.notify();
                }

                switch (respCode) {
                    case DiscoveryListener.INQUIRY_COMPLETED :
                        LOG.fine("INQUIRY_COMPLETED");
                        break;
                    case DiscoveryListener.INQUIRY_TERMINATED :
                        LOG.fine("INQUIRY_TERMINATED");
                        break;
                    case DiscoveryListener.INQUIRY_ERROR :
                        LOG.fine("INQUIRY_ERROR");
                        break;
                    default :
                        LOG.fine("Unknown Response Code - " + respCode);
                        break;
                }
                }

                public void serviceSearchCompleted(int transID, int respCode) {
                        String rd = searchForServices.get(transID).getBluetoothAddress();
                        //searchForServices.remove(transID);
                switch (respCode) {
                        case DiscoveryListener.SERVICE_SEARCH_COMPLETED:
                                LOG.fine(rd + ": The service search completed normally");
                        break;
                        case DiscoveryListener.SERVICE_SEARCH_TERMINATED:
                                LOG.fine(rd + ": The service search request was cancelled by a call to DiscoveryAgent.cancelServiceSearch(int)");
                        break;
                        case DiscoveryListener.SERVICE_SEARCH_ERROR:
                                LOG.warning(rd + ": An error occurred while processing the request");
                        break;
                        case DiscoveryListener.SERVICE_SEARCH_NO_RECORDS:
                                LOG.info(rd + ": No records were found during the service search");
                        break;
                        case DiscoveryListener.SERVICE_SEARCH_DEVICE_NOT_REACHABLE:
                                LOG.warning(rd + ": The device specified in the search request could not be reached or the local device could not establish a connection to the remote device");
                        break;
                    default:
                        LOG.warning(rd + ": Unknown Response Code - " + respCode);
                        break;
                }
                        if (waitForDevices != null)
                                waitForDevices.countDown();
                }

                public void servicesDiscovered(int transID, ServiceRecord[] srs) {
                        LOG.info("Services discovered in transaction " + transID + " : " + srs.length);
                        for (ServiceRecord sr : srs) {

LOG.info(sr.getConnectionURL(ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false));
                                servicesDiscovered.add(sr);
                        }
                }

        }

        public static void main(String[] args) {
                new Test().connect();
        }

}

Answer 1

我在连接蓝牙耳机时遇到了同样的问题。和你一样，我也一次搜索多个服务，它总是返回 SERVICE_SEARCH_DEVICE_NOT_REACHABLE。因此，我尝试只搜索一项服务，结果成功了。因此，尝试将您的代码修改为：

...
private static final UUID[] UUIDS = new UUID[] {new UUID(0x0003)}