在Android（服务器）和pc（客户端）上的bluecove之间初始化蓝牙连接

我知道还有其他相关的话题，但在我的例子中，我希望Android设备将蓝牙连接初始化为服务器。我按照文档的说明编写了服务器：

private class AcceptThread implements Runnable {
    private final BluetoothServerSocket mmServerSocket;

    public AcceptThread() {

        BluetoothServerSocket tmp = null;
        try {
            tmp = mBluetooth.listenUsingRfcommWithServiceRecord(
                    "myService", mUuid);
        } catch (IOException e) { }
        mmServerSocket = tmp;
    }

    public void run() {
        BluetoothSocket socket = null;
        // Keep listening until exception occurs or a socket is returned
        while (true) {
            try {
                System.out.println("SERVER SOCKET LISTENING");
                socket = mmServerSocket.accept();
            } catch (IOException e) {
                break;
            }
            // If a connection was accepted
            if (socket != null) {
                System.out.println("SIGNAL RECEIVED");
                // Do work to manage the connection (in a separate thread)
                Toast.makeText(getApplicationContext(), "SIGNAL RECEIVED", Toast.LENGTH_LONG).show();
                try {
                    mmServerSocket.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
                break;
            }
        }
    }

    /** Will cancel the listening socket, and cause the thread to finish */
    public void cancel() {
        try {
            mmServerSocket.close();
        } catch (IOException e) { }
    }
}

另一方面，我使用bluecove API来发现远程设备和服务

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.util.Vector;

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.microedition.io.StreamConnection;

/**
* A simple SPP client that connects with an SPP server
*/
public class SampleSPPClient implements DiscoveryListener{

    //object used for waiting
    private static Object lock=new Object();

    //vector containing the devices discovered
    private static Vector vecDevices=new Vector();

    private static String connectionURL=null;

    public static void main(String[] args) throws IOException {

        SampleSPPClient client=new SampleSPPClient();

        //display local device address and name
        LocalDevice localDevice = LocalDevice.getLocalDevice();
        System.out.println("Address: "+localDevice.getBluetoothAddress());
        System.out.println("Name: "+localDevice.getFriendlyName());

        //find devices
        DiscoveryAgent agent = localDevice.getDiscoveryAgent();

        System.out.println("Starting device inquiry...");
        agent.startInquiry(DiscoveryAgent.GIAC, client);

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


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

        //print all devices in vecDevices
        int deviceCount=vecDevices.size();

        if(deviceCount <= 0){
            System.out.println("No Devices Found .");
            System.exit(0);
        }
        else{
            //print bluetooth device addresses and names in the format [ No. address (name) ]
            System.out.println("Bluetooth Devices: ");
            for (int i = 0; i <deviceCount; i++) {
                RemoteDevice remoteDevice=(RemoteDevice)vecDevices.elementAt(i);
                System.out.println((i+1)+". "+remoteDevice.getBluetoothAddress()+" ("+remoteDevice.getFriendlyName(true)+")");
            }
        }

        System.out.print("Choose Device index: ");
        BufferedReader bReader=new BufferedReader(new InputStreamReader(System.in));

        String chosenIndex=bReader.readLine();
        int index=Integer.parseInt(chosenIndex.trim());

        //check for spp service
        RemoteDevice remoteDevice=(RemoteDevice)vecDevices.elementAt(index-1);
        UUID[] uuidSet = new UUID[1];
        uuidSet[0]=new UUID("4e3aea40e2a511e095720800200c9a66", false);

        System.out.println("\nSearching for service...");
        agent.searchServices(null,uuidSet,remoteDevice,client);

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

        if(connectionURL==null){
            System.out.println("Device does not support Simple SPP Service.");
            System.exit(0);
        }

        //connect to the server and send a line of text
        StreamConnection streamConnection=(StreamConnection)Connector.open(connectionURL);

        //send string
        OutputStream outStream=streamConnection.openOutputStream();
        PrintWriter pWriter=new PrintWriter(new OutputStreamWriter(outStream));
        pWriter.write("Test String from SPP Client\r\n");
        pWriter.flush();


        //read response
        InputStream inStream=streamConnection.openInputStream();
        BufferedReader bReader2=new BufferedReader(new InputStreamReader(inStream));
        String lineRead=bReader2.readLine();
        System.out.println(lineRead);


    }//main

    //methods of DiscoveryListener
    public void deviceDiscovered(RemoteDevice btDevice, DeviceClass cod) {
        //add the device to the vector
        if(!vecDevices.contains(btDevice)){
            vecDevices.addElement(btDevice);
        }
    }

    //implement this method since services are not being discovered
    public void servicesDiscovered(int transID, ServiceRecord[] servRecord) {
        System.out.println(servRecord[0].getConnectionURL(ServiceRecord.NOAUTHENTICATE_NOENCRYPT, false));
        if(servRecord!=null && servRecord.length>0){
            connectionURL=servRecord[0].getConnectionURL(ServiceRecord.AUTHENTICATE_ENCRYPT,false);
        }
        synchronized(lock){
            lock.notify();
        }
    }

    //implement this method since services are not being discovered
    public void serviceSearchCompleted(int transID, int respCode) {
        synchronized(lock){
            lock.notify();
        }
    }


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

    }//end method



}

导入java.io.BufferedReader；
导入java.io.IOException；
导入java.io.InputStream；
导入java.io.InputStreamReader；
导入java.io.OutputStream；
导入java.io.OutputStreamWriter；
导入java.io.PrintWriter；
导入java.util.Vector；
导入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.microedition.io.StreamConnection；
/**
*与SPP服务器连接的简单SPP客户端
*/
公共类SampleSPPClient实现DiscoveryListener{
//用于等待的对象
私有静态对象锁=新对象（）；
//包含已发现设备的向量
私有静态向量vecDevices=新向量（）；
私有静态字符串connectionURL=null；
公共静态void main（字符串[]args）引发IOException{
SampleSPPClient客户端=新建SampleSPPClient（）；
//显示本地设备地址和名称
LocalDevice LocalDevice=LocalDevice.getLocalDevice（）；
System.out.println（“地址：+localDevice.getBluetoothAddress（））；
System.out.println（“名称：+localDevice.getFriendlyName（））；
//查找设备
DiscoveryAgent=localDevice.getDiscoveryAgent（）；
System.out.println（“启动设备查询…”）；
startInquiry代理（DiscoveryAgent.GIAC，客户）；
试一试{
已同步（锁定）{
lock.wait（）；
}
}
捕捉（中断异常e）{
e、 printStackTrace（）；
}
System.out.println（“设备查询完成”）；
//在vecDevices中打印所有设备
int-deviceCount=vecDevices.size（）；
如果（deviceCount我在使用时找到了一些电话服务记录：

    UUID[] uuidSet = new UUID[1];
    uuidSet[0]=new UUID(0x0100);
    int[] attrIds = { 0x0100 };

    System.out.println("\nSearching for service...");
    agent.searchServices(attrIds, uuidSet, remoteDevice, client);

在serviceSearch之后，您将调用lock.notify（）两次，请在servicesDiscovered函数中删除它

您还应该浏览服务记录并查找您感兴趣的服务记录。URL将显示btgoep://或btspp://

在for循环中搜索时，使用此代码列出服务名称

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

for（int i=0；i

我有一个确切的问题，android api似乎没有向SDP注册ServiceRecord，以便Bluecove api可以找到它。
无论我使用什么UUID，它都只会找到我的手机默认注册的UUID，即音频网关和电话簿OBEX推送等

编辑---
我也遇到了同样的问题，但我意识到我实际上还没有调用ListenusingSecureRfcomSocket。然后它没有注册服务记录。
但在那之后，一切都很好