IOException:读取失败,套接字可能已关闭-Android 4.3上的蓝牙


100

目前,当我在Nexus 7(2012)和Android 4.3(Build JWR66Y,我想是第二次4.3更新)上打开BluetoothSocket时,我正在尝试处理一个奇怪的异常。我已经看到了一些相关的帖子(例如/programming/13648373/bluetoothsocket-connect-throwing-exception-read-failed),但似乎没有一个解决此问题的方法。同样,如这些线程中所建议的那样,重新配对无济于事,并且不断尝试连接(通过愚蠢的循环)也无效。

我正在处理一个嵌入式设备(无名称的OBD-II汽车适配器,类似于http://images04.olx.com/ui/15/53/76/1316534072_254254776_2-OBD-II-BLUTOOTH-ADAPTERSCLEAR-CHECK-ENGINE- LIGHTS-WITH-YOUR-PHONE-Oceanside.jpg)。我的Android 2.3.7手机没有任何连接问题,并且同事的Xperia(Android 4.1.2)也可以使用。另一个Google Nexus(我不知道是“一个”还是“ S”,但不是“ 4”)在Android 4.3上也失败了。

这是连接建立的代码片段。它在服务内创建的自己的线程中运行。

private class ConnectThread extends Thread {

    private static final UUID EMBEDDED_BOARD_SPP = UUID
        .fromString("00001101-0000-1000-8000-00805F9B34FB");

    private BluetoothAdapter adapter;
    private boolean secure;
    private BluetoothDevice device;
    private List<UUID> uuidCandidates;
    private int candidate;
    protected boolean started;

    public ConnectThread(BluetoothDevice device, boolean secure) {
        logger.info("initiliasing connection to device "+device.getName() +" / "+ device.getAddress());
        adapter = BluetoothAdapter.getDefaultAdapter();
        this.secure = secure;
        this.device = device;

        setName("BluetoothConnectThread");

        if (!startQueryingForUUIDs()) {
            this.uuidCandidates = Collections.singletonList(EMBEDDED_BOARD_SPP);
            this.start();
        } else{
            logger.info("Using UUID discovery mechanism.");
        }
        /*
         * it will start upon the broadcast receive otherwise
         */
    }

    private boolean startQueryingForUUIDs() {
        Class<?> cl = BluetoothDevice.class;

        Class<?>[] par = {};
        Method fetchUuidsWithSdpMethod;
        try {
            fetchUuidsWithSdpMethod = cl.getMethod("fetchUuidsWithSdp", par);
        } catch (NoSuchMethodException e) {
            logger.warn(e.getMessage());
            return false;
        }

        Object[] args = {};
        try {
            BroadcastReceiver receiver = new BroadcastReceiver() {
                @Override
                public void onReceive(Context context, Intent intent) {
                    BluetoothDevice deviceExtra = intent.getParcelableExtra("android.bluetooth.device.extra.DEVICE");
                    Parcelable[] uuidExtra = intent.getParcelableArrayExtra("android.bluetooth.device.extra.UUID");

                    uuidCandidates = new ArrayList<UUID>();
                    for (Parcelable uuid : uuidExtra) {
                        uuidCandidates.add(UUID.fromString(uuid.toString()));
                    }

                    synchronized (ConnectThread.this) {
                        if (!ConnectThread.this.started) {
                            ConnectThread.this.start();
                            ConnectThread.this.started = true;
                            unregisterReceiver(this);
                        }

                    }
                }

            };
            registerReceiver(receiver, new IntentFilter("android.bleutooth.device.action.UUID"));
            registerReceiver(receiver, new IntentFilter("android.bluetooth.device.action.UUID"));

            fetchUuidsWithSdpMethod.invoke(device, args);
        } catch (IllegalArgumentException e) {
            logger.warn(e.getMessage());
            return false;
        } catch (IllegalAccessException e) {
            logger.warn(e.getMessage());
            return false;
        } catch (InvocationTargetException e) {
            logger.warn(e.getMessage());
            return false;
        }           

        return true;
    }

    public void run() {
        boolean success = false;
        while (selectSocket()) {

            if (bluetoothSocket == null) {
                logger.warn("Socket is null! Cancelling!");
                deviceDisconnected();
                openTroubleshootingActivity(TroubleshootingActivity.BLUETOOTH_EXCEPTION);
            }

            // Always cancel discovery because it will slow down a connection
            adapter.cancelDiscovery();

            // Make a connection to the BluetoothSocket
            try {
                // This is a blocking call and will only return on a
                // successful connection or an exception
                bluetoothSocket.connect();
                success = true;
                break;

            } catch (IOException e) {
                // Close the socket
                try {
                    shutdownSocket();
                } catch (IOException e2) {
                    logger.warn(e2.getMessage(), e2);
                }
            }
        }

        if (success) {
            deviceConnected();
        } else {
            deviceDisconnected();
            openTroubleshootingActivity(TroubleshootingActivity.BLUETOOTH_EXCEPTION);
        }
    }

    private boolean selectSocket() {
        if (candidate >= uuidCandidates.size()) {
            return false;
        }

        BluetoothSocket tmp;
        UUID uuid = uuidCandidates.get(candidate++);
        logger.info("Attempting to connect to SDP "+ uuid);
        try {
            if (secure) {
                tmp = device.createRfcommSocketToServiceRecord(
                        uuid);
            } else {
                tmp = device.createInsecureRfcommSocketToServiceRecord(
                        uuid);
            }
            bluetoothSocket = tmp;
            return true;
        } catch (IOException e) {
            logger.warn(e.getMessage() ,e);
        }

        return false;
    }

}

代码在失败bluetoothSocket.connect()。我得到一个java.io.IOException: read failed, socket might closed, read ret: -1。这是GitHub上的相应来源:https : //github.com/android/platform_frameworks_base/blob/android-4.3_r2/core/java/android/bluetooth/BluetoothSocket.java#L504 通过readInt()调用,从https调用://github.com/android/platform_frameworks_base/blob/android-4.3_r2/core/java/android/bluetooth/BluetoothSocket.java#L319

使用过的套接字的一些元数据转储产生以下信息。这些在Nexus 7和我的2.3.7手机上完全相同。

Bluetooth Device 'OBDII'
Address: 11:22:33:DD:EE:FF
Bond state: 12 (bonded)
Type: 1
Class major version: 7936
Class minor version: 7936
Class Contents: 0
Contents: 0

我还有其他OBD-II适配器(更多扩展功能),它们都可以工作。是否有可能我丢失了某些东西,或者这可能是Android中的错误?


我已经尝试了上述解决方案,可以在此问题上提供帮助stackoverflow.com/q/52105647/1559331
dileepVikram

Answers:


129

我终于找到了解决方法。魔术隐藏在BluetoothDevice该类的底层(请参阅https://github.com/android/platform_frameworks_base/blob/android-4.3_r2/core/java/android/bluetooth/BluetoothDevice.java#L1037)。

现在,当我收到该异常时,将实例化一个fallback BluetoothSocket,类似于下面的源代码。如您所见,createRfcommSocket通过反射调用隐藏方法。我不知道为什么隐藏这种方法。源代码将其定义为public……

Class<?> clazz = tmp.getRemoteDevice().getClass();
Class<?>[] paramTypes = new Class<?>[] {Integer.TYPE};

Method m = clazz.getMethod("createRfcommSocket", paramTypes);
Object[] params = new Object[] {Integer.valueOf(1)};

fallbackSocket = (BluetoothSocket) m.invoke(tmp.getRemoteDevice(), params);
fallbackSocket.connect();

connect()然后就不会再失败了。我仍然遇到一些问题。基本上,这有时会阻止并失败。在这种情况下,重新引导SPP设备(插入/插入)会有所帮助。有时,connect()即使设备已经绑定,我也会收到另一个配对请求。

更新:

这是一个完整的类,其中包含一些嵌套类。对于真正的实现,可以将它们作为单独的类保存。

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.lang.reflect.Method;
import java.util.List;
import java.util.UUID;

import android.bluetooth.BluetoothAdapter;
import android.bluetooth.BluetoothDevice;
import android.bluetooth.BluetoothSocket;
import android.util.Log;

public class BluetoothConnector {

    private BluetoothSocketWrapper bluetoothSocket;
    private BluetoothDevice device;
    private boolean secure;
    private BluetoothAdapter adapter;
    private List<UUID> uuidCandidates;
    private int candidate;


    /**
     * @param device the device
     * @param secure if connection should be done via a secure socket
     * @param adapter the Android BT adapter
     * @param uuidCandidates a list of UUIDs. if null or empty, the Serial PP id is used
     */
    public BluetoothConnector(BluetoothDevice device, boolean secure, BluetoothAdapter adapter,
            List<UUID> uuidCandidates) {
        this.device = device;
        this.secure = secure;
        this.adapter = adapter;
        this.uuidCandidates = uuidCandidates;

        if (this.uuidCandidates == null || this.uuidCandidates.isEmpty()) {
            this.uuidCandidates = new ArrayList<UUID>();
            this.uuidCandidates.add(UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"));
        }
    }

    public BluetoothSocketWrapper connect() throws IOException {
        boolean success = false;
        while (selectSocket()) {
            adapter.cancelDiscovery();

            try {
                bluetoothSocket.connect();
                success = true;
                break;
            } catch (IOException e) {
                //try the fallback
                try {
                    bluetoothSocket = new FallbackBluetoothSocket(bluetoothSocket.getUnderlyingSocket());
                    Thread.sleep(500);                  
                    bluetoothSocket.connect();
                    success = true;
                    break;  
                } catch (FallbackException e1) {
                    Log.w("BT", "Could not initialize FallbackBluetoothSocket classes.", e);
                } catch (InterruptedException e1) {
                    Log.w("BT", e1.getMessage(), e1);
                } catch (IOException e1) {
                    Log.w("BT", "Fallback failed. Cancelling.", e1);
                }
            }
        }

        if (!success) {
            throw new IOException("Could not connect to device: "+ device.getAddress());
        }

        return bluetoothSocket;
    }

    private boolean selectSocket() throws IOException {
        if (candidate >= uuidCandidates.size()) {
            return false;
        }

        BluetoothSocket tmp;
        UUID uuid = uuidCandidates.get(candidate++);

        Log.i("BT", "Attempting to connect to Protocol: "+ uuid);
        if (secure) {
            tmp = device.createRfcommSocketToServiceRecord(uuid);
        } else {
            tmp = device.createInsecureRfcommSocketToServiceRecord(uuid);
        }
        bluetoothSocket = new NativeBluetoothSocket(tmp);

        return true;
    }

    public static interface BluetoothSocketWrapper {

        InputStream getInputStream() throws IOException;

        OutputStream getOutputStream() throws IOException;

        String getRemoteDeviceName();

        void connect() throws IOException;

        String getRemoteDeviceAddress();

        void close() throws IOException;

        BluetoothSocket getUnderlyingSocket();

    }


    public static class NativeBluetoothSocket implements BluetoothSocketWrapper {

        private BluetoothSocket socket;

        public NativeBluetoothSocket(BluetoothSocket tmp) {
            this.socket = tmp;
        }

        @Override
        public InputStream getInputStream() throws IOException {
            return socket.getInputStream();
        }

        @Override
        public OutputStream getOutputStream() throws IOException {
            return socket.getOutputStream();
        }

        @Override
        public String getRemoteDeviceName() {
            return socket.getRemoteDevice().getName();
        }

        @Override
        public void connect() throws IOException {
            socket.connect();
        }

        @Override
        public String getRemoteDeviceAddress() {
            return socket.getRemoteDevice().getAddress();
        }

        @Override
        public void close() throws IOException {
            socket.close();
        }

        @Override
        public BluetoothSocket getUnderlyingSocket() {
            return socket;
        }

    }

    public class FallbackBluetoothSocket extends NativeBluetoothSocket {

        private BluetoothSocket fallbackSocket;

        public FallbackBluetoothSocket(BluetoothSocket tmp) throws FallbackException {
            super(tmp);
            try
            {
              Class<?> clazz = tmp.getRemoteDevice().getClass();
              Class<?>[] paramTypes = new Class<?>[] {Integer.TYPE};
              Method m = clazz.getMethod("createRfcommSocket", paramTypes);
              Object[] params = new Object[] {Integer.valueOf(1)};
              fallbackSocket = (BluetoothSocket) m.invoke(tmp.getRemoteDevice(), params);
            }
            catch (Exception e)
            {
                throw new FallbackException(e);
            }
        }

        @Override
        public InputStream getInputStream() throws IOException {
            return fallbackSocket.getInputStream();
        }

        @Override
        public OutputStream getOutputStream() throws IOException {
            return fallbackSocket.getOutputStream();
        }


        @Override
        public void connect() throws IOException {
            fallbackSocket.connect();
        }


        @Override
        public void close() throws IOException {
            fallbackSocket.close();
        }

    }

    public static class FallbackException extends Exception {

        /**
         * 
         */
        private static final long serialVersionUID = 1L;

        public FallbackException(Exception e) {
            super(e);
        }

    }
}

3
哇!很好的解决方案!
鲍勃,2015年

2
@MD我不知道如何。我刚刚测试并发现它正在工作。
鲍勃,2015年

1
它在Nexus 4上不起作用。能否请您说一下如何解决此问题。我几乎尝试了一切。谢谢。
莎阿(Shah)2015年

3
@matthes抱歉地说,但是即使您使用后备解决方案也无法解决我的问题。低于错误。Fallback failed. Cancelling. java.io.IOException: Connection refused 请帮忙。
Tushar Banne '16

2
@matthes“在这种情况下,SPP设备(插入/插入)会有所帮助。” 开/关声明是世界上被低估的。我只是浪费了3个小时,而我要做的就是打开和关闭它-_-
Adz

98

好吧,我的代码也遇到了同样的问题,这是因为自从Android 4.2蓝牙堆栈发生了变化。所以我的代码在android <4.2的设备上运行良好,在其他设备上,我遇到了著名的异常“读取失败,套接字可能关闭或超时,读取ret:-1”

问题出在socket.mPort参数上。当您使用创建套接字时socket = device.createRfcommSocketToServiceRecord(SERIAL_UUID);mPort获取整数值“ -1 ”,并且该值似乎不适用于android> = 4.2,因此您需要将其设置为“ 1 ”。坏消息是createRfcommSocketToServiceRecord仅接受UUID作为参数,mPort因此我们必须使用其他方法。@matthes发布的答案也对我有用,但我简化了:socket =(BluetoothSocket) device.getClass().getMethod("createRfcommSocket", new Class[] {int.class}).invoke(device,1);。我们需要同时使用两个套接字属性,第二个作为备用。

因此代码是(用于连接到ELM327设备上的SPP):

BluetoothAdapter btAdapter = BluetoothAdapter.getDefaultAdapter();

    if (btAdapter.isEnabled()) {
        SharedPreferences prefs_btdev = getSharedPreferences("btdev", 0);
        String btdevaddr=prefs_btdev.getString("btdevaddr","?");

        if (btdevaddr != "?")
        {
            BluetoothDevice device = btAdapter.getRemoteDevice(btdevaddr);

            UUID SERIAL_UUID = UUID.fromString("00001101-0000-1000-8000-00805f9b34fb"); // bluetooth serial port service
            //UUID SERIAL_UUID = device.getUuids()[0].getUuid(); //if you don't know the UUID of the bluetooth device service, you can get it like this from android cache

            BluetoothSocket socket = null;

            try {
                socket = device.createRfcommSocketToServiceRecord(SERIAL_UUID);
            } catch (Exception e) {Log.e("","Error creating socket");}

            try {
                socket.connect();
                Log.e("","Connected");
            } catch (IOException e) {
                Log.e("",e.getMessage());
                try {
                    Log.e("","trying fallback...");

                    socket =(BluetoothSocket) device.getClass().getMethod("createRfcommSocket", new Class[] {int.class}).invoke(device,1);
                    socket.connect();

                    Log.e("","Connected");
                }
             catch (Exception e2) {
                 Log.e("", "Couldn't establish Bluetooth connection!");
              }
            }
        }
        else
        {
            Log.e("","BT device not selected");
        }
    }

57
对于主持人:由于您无故删除了我之前的答案,因此我再次发布了它。
乔治·迪玛

2
感谢George对mPort参数的见解!恕我直言,工作流程保持不变,我只是用一些实现接口的类包装了东西。
matthes 2014年

5
是的,我已经说过您的解决方案很好,但是我想让人们理解为什么它需要使用从Android 4.2开始的这种方法
George Dima

2
SPP =串行端口配置文件(模拟通过蓝牙的串行端口),而ELM327是蓝牙<-> obd车载设备,用Google搜索。
乔治·迪玛

10
将端口值从1更改为2后,它对我有用。请看下面的代码。socket =(BluetoothSocket)device.getClass()。getMethod(“ createRfcommSocket”,new Class [] {int.class})。invoke(device,2); socket.connect();
Dinesh IT

16

首先,如果您需要与蓝牙2.x设备对话,则本文档指出:

提示:如果要连接到蓝牙串行板,请尝试使用众所周知的SPP UUID 00001101-0000-1000-8000-00805F9B34FB。但是,如果您要连接到Android对等端,请生成自己的唯一UUID。

我不认为它会起作用,而只能通过用00001101-0000-1000-8000-00805F9B34FB它替换UUID 来起作用。然而,这个代码似乎处理的SDK版本的问题,您只需更换功能device.createRfcommSocketToServiceRecord(mMyUuid);tmp = createBluetoothSocket(mmDevice);定义以下方法之后:

private BluetoothSocket createBluetoothSocket(BluetoothDevice device)
    throws IOException {
    if(Build.VERSION.SDK_INT >= 10){
        try {
            final Method m = device.getClass().getMethod("createInsecureRfcommSocketToServiceRecord", new Class[] { UUID.class });
            return (BluetoothSocket) m.invoke(device, mMyUuid);
        } catch (Exception e) {
            Log.e(TAG, "Could not create Insecure RFComm Connection",e);
        }
    }
    return  device.createRfcommSocketToServiceRecord(mMyUuid);
}

源代码不是我的,而是来自此网站


1
这解决了近2天工作制...的感谢叹息 ......如果没有这个UUID套接字会立即关闭,没有进一步解释失败。
大卫·辛克莱

非常感谢您的帮助。我的UUID是字母数字,我正在尝试连接HC-5和显示连接失败的蓝牙,但是当我使用此解决方案时,我的问题就解决了。再次谢谢你
Nikhil Shende

8

我有与此处所述相同的症状。我可以连接一次蓝牙打印机,但是无论我做什么,随后的连接都将失败,并且“套接字已关闭”。

我发现这里描述的解决方法是必要的,这有点奇怪。阅读完代码后,我发现我忘记关闭套接字的InputStream和OutputSteram,并且没有正确终止ConnectedThreads。

我使用的ConnectedThread与此处的示例相同:

http://developer.android.com/guide/topics/connectivity/bluetooth.html

请注意,ConnectThread和ConnectedThread是两个不同的类。

无论启动ConnectedThread的任何类,都必须在线程上调用interrupt()和cancel()。我在ConnectedTread.cancel()方法中添加了mmInStream.close()和mmOutStream.close()。

正确关闭线程/流/套接字后,我可以毫无问题地创建新套接字。


谢谢,遇到了同样的问题,刚才我发现我还没有关闭流和连接...
拉斐尔

尝试了以上所有情况,(除了删除其他配对设备导致确实不是解决方案的结果是...通常仅在输入流和套接字未正确关闭时才会发生..... !!
阿曼·萨蒂贾

7

好吧,我实际上已经找到了问题。

大多数尝试使用进行连接的人socket.Connect();都会收到一个名为的异常Java.IO.IOException: read failed, socket might closed, read ret: -1

在某些情况下,它还取决于您的蓝牙设备,因为有两种不同类型的蓝牙,即BLE(低能耗)和Classic。

如果要检查蓝牙设备的类型,请使用以下代码:

        String checkType;
        var listDevices = BluetoothAdapter.BondedDevices;
        if (listDevices.Count > 0)
        {
            foreach (var btDevice in listDevices)
            {
                if(btDevice.Name == "MOCUTE-032_B52-CA7E")
                {
                    checkType = btDevice.Type.ToString();
                    Console.WriteLine(checkType);
                }
            }
        }

我一直在尝试解决问题的方法,但是从今天开始,我发现了问题。不幸的是,@ matthes的解决方案仍然有一些问题,正如他已经说过的,但这是我的解决方案。

目前,我使用Xamarin Android,但这也适用于其他平台。

如果已配对的设备不止一个,则应删除其他已配对的设备。因此,仅保留您要连接的那个(请参见右图)。

在此处输入图片说明 在此处输入图片说明

在左图中,您看到我有两个配对的设备,分别是“ MOCUTE-032_B52-CA7E”和“ Blue Easy”。那是问题,但我不知道为什么会发生这个问题。也许蓝牙协议正在尝试从另一个蓝牙设备获取一些信息。

但是,目前socket.Connect();效果很好,没有任何问题。所以我只想分享这个,因为那个错误真的很烦人。

祝好运!


这在我遇到此问题的一台设备上起作用,这种情况仅在5.0手机上对我来说才发生,甚至只有在我首先启用BT,然后打开连接时才发生。如果BT已经开启,则没有连接问题!使用更高版本的Android的设备上不会出现此错误,这表明开发人员已注意到该错误并已修复,但Android BT页面对此一无所知。但是您的解决方案有效,谢谢!
John Perry

7

在较新版本的Android上,我收到此错误,因为在尝试连接到套接字时适配器仍在发现。即使我在Bluetooth适配器上调用了cancelDiscovery方法,我也必须等到通过动作BluetoothAdapter.ACTION_DISCOVERY_FINISHED调用了BroadcastReceiver的onReceive()方法的回调。

一旦我等待适配器停止发现,套接字上的connect调用就会成功。



4

万一有人对Kotlin遇到问题,我必须遵循公认的答案并做一些改动:

fun print(view: View, text: String) {
    var adapter = BluetoothAdapter.getDefaultAdapter();
    var pairedDevices = adapter.getBondedDevices()
    var uuid = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB")
    if (pairedDevices.size > 0) {
        for (device in pairedDevices) {
            var s = device.name
            if (device.getName().equals(printerName, ignoreCase = true)) {
                Thread {
                    var socket = device.createInsecureRfcommSocketToServiceRecord(uuid)
                    var clazz = socket.remoteDevice.javaClass
                    var paramTypes = arrayOf<Class<*>>(Integer.TYPE)
                    var m = clazz.getMethod("createRfcommSocket", *paramTypes)
                    var fallbackSocket = m.invoke(socket.remoteDevice, Integer.valueOf(1)) as BluetoothSocket
                    try {
                        fallbackSocket.connect()
                        var stream = fallbackSocket.outputStream
                        stream.write(text.toByteArray(Charset.forName("UTF-8")))
                    } catch (e: Exception) {
                        e.printStackTrace()
                        Snackbar.make(view, "An error occurred", Snackbar.LENGTH_SHORT).show()
                    }
                }.start()
            }
        }
    }
}

希望能帮助到你


3

蓝牙设备可以同时在经典模式和LE模式下运行。有时,它们会根据您的连接方式使用不同的MAC地址。通话socket.connect()使用的是Bluetooth Classic,因此您必须确保扫描时获得的设备确实是经典设备。

仅针对经典设备进行过滤很容易,但是:

if(BluetoothDevice.DEVICE_TYPE_LE == device.getType()){ //socket.connect() }

如果不进行此检查,则竞争条件是混合扫描将首先为您提供Classic设备还是BLE设备。它可能表现为间歇性无法连接,或者表现为某些设备能够可靠连接,而其他设备似乎无法连接。


1

我也遇到了这个问题,您可以用2种方法解决它,如前所述,使用反射来创建套接字。第二种是,客户端正在寻找具有给定UUID的服务器,如果您的服务器未与客户端并行运行,则此发生。使用给定的客户端UUID创建服务器,然后从服务器端监听并接受客户端,它将起作用。


1

我遇到了这个问题,并通过在关闭套接字之前关闭输入和输出流来解决此问题。现在,我可以断开并重新连接,没有任何问题。

https://stackoverflow.com/a/3039807/5688612

在科特林:

fun disconnect() {
    bluetoothSocket.inputStream.close()
    bluetoothSocket.outputStream.close()
    bluetoothSocket.close()
}

1

如果代码的另一部分已经使用相同的套接字和UUID建立了连接,则会出现此错误。


0

即使我遇到了同样的问题,也终于理解了我的问题,我试图从(超出范围的)蓝牙覆盖范围进行连接。


0

我遇到了这个问题,解决方案是使用特殊的魔术GUID。

            val id: UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB") // Any other GUID doesn't work.
            val device: BluetoothDevice = bta!!.bondedDevices.first { z -> z.name == deviceName }

            bts = device.createRfcommSocketToServiceRecord(id) // mPort is -1
            bts?.connect()
            // Start processing thread.

我怀疑这些是可以使用的UUID:

var did: Array<ParcelUuid?> = device.uuids

但是,我还没有尝试全部。


甚至我都使用相同的UUID。但是并没有帮助我。这仅支持连接经典蓝牙设备(不支持BLE)吗?使用Xamarin.Forms连接到BLE设备所要做的事情。这里发布[ stackoverflow.com/questions/62371859/...
SHAILESH铢

我正在使用经典的蓝牙;BLE是垃圾。
Richard Barraclough

-1

通过添加过滤器操作,我的问题得以解决

 // Register for broadcasts when a device is discovered
    IntentFilter intentFilter = new IntentFilter();
    intentFilter.addAction(BluetoothDevice.ACTION_FOUND);
    intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_STARTED);
    intentFilter.addAction(BluetoothAdapter.ACTION_DISCOVERY_FINISHED);
    registerReceiver(mReceiver, intentFilter);

-3

我也收到了同样的消息IOException,但是我发现了Android系统演示:“ BluetoothChat”项目已经工作。我确定问题是UUID。

因此,我将其替换UUID.fromString("00001001-0000-1000-8000-00805F9B34FB")UUID.fromString("8ce255c0-200a-11e0-ac64-0800200c9a66")大多数情况下都可以使用,只是有时需要重启蓝牙设备;

By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.