it-swarm.com.de

IOException: Lesen fehlgeschlagen, Socket könnte geschlossen sein - Bluetooth an Android 4.3

Momentan versuche ich mit einer seltsamen Ausnahme umzugehen, wenn ich auf meinem Nexus 7 (2012) einen BluetoothSocket mit Android 4.3 öffne (Build JWR66Y, ich vermute das zweite 4.3 Update). Ich habe einige verwandte Beiträge gesehen (z. B. https://stackoverflow.com/questions/13648373/bluetoothsocket-connect-throwing-exception-read-failed ), aber keiner scheint eine Problemumgehung für dieses Problem zu bieten . Wie in diesen Threads vorgeschlagen, hilft das erneute Pairing nicht, und der ständige Versuch, eine Verbindung herzustellen (über eine blöde Schleife), hat ebenfalls keine Auswirkung.

Es handelt sich um ein eingebettetes Gerät (ein OBD-II-Autoadapter ohne Namen, ähnlich wie http://images04.olx.com/ui/15/53/76/1316534072_254254776_2-OBD-II-BLUTOOTH-ADAPTERSCLEAR-). CHECK-ENGINE-LIGHTS-WITH-YOUR-PHONE-Oceanside.jpg ). Mein Android 2.3.7-Telefon hat keine Verbindungsprobleme, und das Xperia eines Kollegen (Android 4.1.2) funktioniert auch. Ein anderes Google Nexus (ich weiß nicht, ob 'One' oder 'S', aber nicht '4') schlägt mit Android 4.3 ebenfalls fehl.

Hier ist das Snippet des Verbindungsaufbaus. Es wird in einem eigenen Thread ausgeführt, der innerhalb eines Dienstes erstellt wurde.

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;
    }

}

Der Code schlägt bei bluetoothSocket.connect() fehl. Ich erhalte einen Java.io.IOException: read failed, socket might closed, read ret: -1. Dies ist die entsprechende Quelle bei GitHub: https://github.com/Android/platform_frameworks_base/blob/Android-4.3_r2/core/Java/Android/bluetooth/BluetoothSocket.Java#L504 Es wird durchgerufen readInt (), aufgerufen von https://github.com/Android/platform_frameworks_base/blob/Android-4.3_r2/core/Java/Android/bluetooth/BluetoothSocket.Java#L319

Einige Metadaten des verwendeten Sockets ergaben die folgenden Informationen. Diese sind auf Nexus 7 und meinem 2.3.7-Telefon genau gleich.

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

Ich habe einige andere OBD-II-Adapter (mehr Expansives) und sie funktionieren alle. Gibt es eine Chance, dass mir etwas fehlt oder könnte dies ein Fehler in Android sein?

92
matthes

Ich habe endlich einen Workaround gefunden. Die Magie verbirgt sich unter der Haube der Klasse BluetoothDevice (siehe https://github.com/Android/platform_frameworks_base/blob/Android-4.3_r2/core/Java/Android/bluetooth/BluetoothDevice) .Java # L1037 ).

Wenn ich diese Ausnahme erhalte, instanziiere ich einen Fallback BluetoothSocket, ähnlich wie im folgenden Quellcode. Wie Sie sehen können, wird die versteckte Methode createRfcommSocket über Reflexionen aufgerufen. Ich habe keine Ahnung, warum diese Methode versteckt ist. Der Quellcode definiert es als public obwohl ...

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() schlägt dann nicht mehr fehl. Ich habe noch ein paar Probleme erlebt. Grundsätzlich blockiert dies manchmal und schlägt fehl. In solchen Fällen hilft ein Neustart des SPP-Gerätes (Plug-Off/Plug-In). Manchmal erhalte ich nach connect() auch dann eine weitere Pairing-Anfrage, wenn das Gerät bereits verbunden ist.

AKTUALISIEREN:

hier ist eine vollständige Klasse, die einige verschachtelte Klassen enthält. Für eine echte Implementierung könnten diese als separate Klassen abgehalten werden.

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);
        }

    }
}
123
matthes

nun, ich hatte das gleiche Problem mit meinem Code, und das liegt daran, dass sich der Android 4.2 Bluetooth-Stack geändert hat. Daher lief mein Code auf Geräten mit Android) einwandfrei <4.2, auf den anderen Geräten bekam ich die berühmte Ausnahme "Lesevorgang fehlgeschlagen, Socket möglicherweise geschlossen oder Timeout, read ret: -1"

Das Problem liegt beim Parameter socket.mPort. Wenn Sie Ihren Socket mit socket = device.createRfcommSocketToServiceRecord(SERIAL_UUID); erstellen, erhält mPort den ganzzahligen Wert "- 1", und dieser Wert scheint für Android> = 4.2, daher müssen Sie es auf "1" setzen. Die schlechte Nachricht ist, dass createRfcommSocketToServiceRecord nur UUID als Parameter akzeptiert und nicht mPort also müssen wir einen anderen Ansatz verwenden. Die Antwort von @ matthes hat auch bei mir funktioniert, aber ich habe sie vereinfacht: socket =(BluetoothSocket) device.getClass().getMethod("createRfcommSocket", new Class[] {int.class}).invoke(device,1);. Wir müssen beide Socket-Attribute verwenden, das zweite eins als Fallback.

Der Code lautet also (für die Verbindung mit einem SPP auf einem Elm327-Gerät):

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");
        }
    }
89
George Dima

Wenn Sie zuerst mit einem Bluetooth 2.x-Gerät sprechen müssen, diese Dokumentation besagt Folgendes:

Tipp: Wenn Sie eine Verbindung zu einer seriellen Bluetooth-Karte herstellen, versuchen Sie, die bekannte SPP-UUID 00001101-0000-1000-8000-00805F9B34FB zu verwenden. Wenn Sie jedoch eine Verbindung zu einem Android Peer herstellen, generieren Sie bitte Ihre eigene eindeutige UUID.

Ich hätte nicht gedacht, dass es funktionieren würde, aber nur durch Ersetzen der UUID durch 00001101-0000-1000-8000-00805F9B34FB Funktioniert es. Dieser Code scheint jedoch das Problem der SDK-Version zu lösen, und Sie können die Funktion device.createRfcommSocketToServiceRecord(mMyUuid); einfach durch tmp = createBluetoothSocket(mmDevice); ersetzen, nachdem Sie die folgende Methode definiert haben:

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);
}

Der Quellcode ist nicht von mir, sondern stammt von diese Website .

11
tobiasBora

Nun, ich habe das Problem tatsächlich gefunden.

Die meisten Leute, die versuchen, eine Verbindung mit socket.Connect(); herzustellen, erhalten eine Ausnahme mit dem Namen Java.IO.IOException: read failed, socket might closed, read ret: -1.

In einigen Fällen hängt es auch von Ihrem Bluetooth-Gerät ab, da es zwei verschiedene Bluetooth-Typen gibt, nämlich BLE (Low Energy) und Classic.

Wenn Sie den Typ Ihres Bluetooth-Geräts überprüfen möchten, ist hier der Code:

        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);
                }
            }
        }

Ich habe seit Tagen versucht, das Problem zu lösen, aber seit heute habe ich das Problem gefunden. Die Lösung von @matthes hat leider noch ein paar Probleme, wie er bereits sagte, aber hier ist meine Lösung.

Im Moment arbeite ich in Xamarin Android, aber dies sollte auch für andere Plattformen funktionieren.

[~ # ~] Lösung [~ # ~]

Wenn es mehr als ein gekoppeltes Gerät gibt, sollten Sie die anderen gekoppelten Geräte entfernen. Behalten Sie also nur die, die Sie verbinden möchten (siehe das rechte Bild).

enter image description hereenter image description here

Im linken Bild sehen Sie, dass ich zwei gekoppelte Geräte habe, nämlich "MOCUTE-032_B52-CA7E" und "Blue Easy". Das ist das Problem, aber ich habe keine Ahnung, warum dieses Problem auftritt. Möglicherweise versucht das Bluetooth-Protokoll, Informationen von einem anderen Bluetooth-Gerät abzurufen.

Die Funktion socket.Connect(); funktioniert momentan jedoch einwandfrei. Ich wollte das nur teilen, weil dieser Fehler wirklich ärgerlich ist.

Viel Glück!

7
Jamie

Ich hatte die gleichen Symptome wie hier beschrieben. Ich konnte einmal eine Verbindung zu einem Bluetooth-Drucker herstellen, aber die anschließende Verbindung schlug bei geschlossener Buchse fehl, egal was ich tat.

Ich fand es etwas seltsam, dass die hier beschriebenen Problemumgehungen notwendig wären. Nachdem ich meinen Code durchgesehen hatte, stellte ich fest, dass ich vergessen hatte, den InputStream und OutputSteram des Sockets zu schließen, und die ConnectedThreads nicht ordnungsgemäß beendet hatte.

Der von mir verwendete ConnectedThread ist derselbe wie im folgenden Beispiel:

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

Beachten Sie, dass ConnectThread und ConnectedThread zwei verschiedene Klassen sind.

Jede Klasse, die ConnectedThread startet, muss interrupt () und cancel () für den Thread aufrufen. Ich habe mmInStream.close () und mmOutStream.close () in die ConnectedTread.cancel () -Methode eingefügt.

Nachdem ich die Threads/Streams/Sockets ordnungsgemäß geschlossen habe, konnte ich problemlos neue Sockets erstellen.

7
Daniel T

Sie setzen registerReceiver(receiver, new IntentFilter("Android.bleutooth.device.action.UUID")); mit der Schreibweise "bluetooth".

6
Fizz Binn

Bei neueren Versionen von Android wurde dieser Fehler angezeigt, da der Adapter beim Versuch, eine Verbindung zum Socket herzustellen, noch ermittelt wurde. Obwohl ich die cancelDiscovery-Methode auf dem Bluetooth-Adapter aufgerufen habe, musste ich warten, bis der Rückruf der onReceive () -Methode des BroadcastReceiver mit der Aktion BluetoothAdapter.ACTION_DISCOVERY_FINISHED aufgerufen wurde.

Sobald ich darauf gewartet habe, dass der Adapter die Erkennung beendet, war der Verbindungsaufruf am Socket erfolgreich.

5
kmac.mcfarlane

Falls jemand Probleme mit Kotlin hat, musste ich die akzeptierte Antwort mit einigen Variationen befolgen:

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()
            }
        }
    }
}

Ich hoffe es hilft

Bluetooth-Geräte können gleichzeitig im klassischen und im LE-Modus betrieben werden. Manchmal verwenden sie eine andere MAC-Adresse, je nachdem, auf welche Weise Sie eine Verbindung herstellen. Das Aufrufen von socket.connect() verwendet Bluetooth Classic. Sie müssen also sicherstellen, dass das Gerät, das Sie beim Scannen erhalten haben, wirklich ein klassisches Gerät ist.

Es ist jedoch einfach, nur nach Classic-Geräten zu filtern:

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

Ohne diese Prüfung ist es eine Wettlaufsituation, ob Sie bei einem Hybrid-Scan zuerst das Classic-Gerät oder das BLE-Gerät erhalten. Es kann so aussehen, als ob eine Verbindung zeitweise nicht hergestellt werden kann, oder als ob bestimmte Geräte eine zuverlässige Verbindung herstellen können, während andere anscheinend niemals eine Verbindung herstellen können.

2
kmac.mcfarlane

ich sah mich auch mit diesem Problem konfrontiert. Sie konnten es auf zwei Arten lösen. Wie bereits erwähnt, verwenden Sie Reflection, um den Socket zu erstellen. Zweitens sucht der Client nach einem Server mit der angegebenen UUID. Wenn Ihr Server nicht parallel zum Client läuft, dann ist dies der Fall das passiert. Erstellen Sie einen Server mit der angegebenen Client-UUID, und überwachen Sie den Client und akzeptieren Sie ihn von der Serverseite. Dies funktioniert.

1

Ich bin auf dieses Problem gestoßen und habe es behoben, indem ich den Eingabe- und Ausgabestream geschlossen habe, bevor ich den Socket geschlossen habe. Jetzt kann ich ohne Probleme die Verbindung trennen und wieder herstellen.

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

In Kotlin:

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

Wenn ein anderer Teil Ihres Codes bereits eine Verbindung mit demselben Socket und derselben UUID hergestellt hat, wird dieser Fehler angezeigt.

0
S List

Sogar ich hatte das gleiche Problem, endlich verstehe ich mein Problem, ich habe versucht, eine Verbindung von (außerhalb der Reichweite) Bluetooth-Reichweite herzustellen.

0
krishnamurthy