IOException: Lesen fehlgeschlagen, Socket möglicherweise geschlossen - Bluetooth unter Android 4.3

Habe ich endlich einen workaround. Die Magie liegt verborgen unter der Kapuze des BluetoothDevice Klasse (siehe https://github.com/android/platform_frameworks_base/blob/android-4.3_r2/core/java/android/bluetooth/BluetoothDevice.java#L1037).

Nun, wenn ich erhalten, mit Ausnahme, instanziiere ich ein fallback BluetoothSocketähnlich der source-code weiter unten. Wie Sie sehen können, das aufrufen der versteckten Methode createRfcommSocket Spiegelungen. Ich habe keine Ahnung, warum diese Methode ist ausgeblendet. Der source-code 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() dann nicht mehr. Ich habe erlebt, ein paar Fragen noch. Im Grunde ist dies manchmal blockiert und versagt. Neustart des SPP-Gerät (Stecker aus - /einstecken) hilft in solchen Fällen. Manchmal bekomme ich auch einen anderen Pairing-Anfrage nach connect() auch wenn das Gerät bereits fertig verklebt.

UPDATE:

hier ist eine vollständige Klasse, die auch einige geschachtelte Klassen. für eine echte Umsetzung dieser könnte gehalten werden, als getrennte Klassen.

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

    }
}

InformationsquelleAutor der Antwort matthes

Zuerst, wenn Sie brauchen, um zu sprechen, um eine bluetooth-2.x Gerät, diese Dokumentation besagt, dass :

Hinweis: Wenn Sie eine Verbindung zu einem Bluetooth-serial-board dann versuchen Sie es mit
die bekannten SPP UUID 00001101-0000-1000-8000-00805F9B34FB. Allerdings
wenn Sie eine Verbindung zu einem Android-peer dann bitte erzeugen Sie Ihre eigenen
eindeutige UUID.

Ich glaube nicht, dass es funktionieren würde, aber nur durch den Austausch der UUID mit 00001101-0000-1000-8000-00805F9B34FB es funktioniert. Dieser code jedoch scheint Sie behandeln das problem der SDK-version, und Sie können einfach ersetzen Sie die Funktion device.createRfcommSocketToServiceRecord(mMyUuid); mit tmp = createBluetoothSocket(mmDevice); nach der Definition der folgenden Methode :

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

Den Quellcode ist nicht von mir, sondern kommt aus diese website.

InformationsquelleAutor der Antwort tobiasBora

Hatte ich die gleichen Symptome wie hier beschrieben. Ich konnte einmal verbinden zu einem bluetooth-Drucker, aber die anschließende Verbindung ist fehlgeschlagen mit "socket geschlossen", egal was ich Tat.

Fand ich es ein bisschen seltsam, dass die workarounds, die hier beschrieben werden. Nachdem er durch meinen code hatte ich vergessen zu schließen der socket - InputStream und OutputSteram und nicht beendet, die ConnectedThreads richtig.

Den ConnectedThread die ich verwende ist die gleiche wie im Beispiel hier:

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

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

Welcher Klasse beginnt die ConnectedThread muss call interrupt() und cancel() auf dem thread.
Ich fügte hinzu, mmInStream.close() und mmOutStream.schließen() in der ConnectedTread.cancel () - Methode.

Nach dem schließen der threads/streams/buchsen richtig konnte ich erstellen, neue Steckdosen, ohne jedes problem.

InformationsquelleAutor der Antwort Daniel T

Auf neuere Versionen von Android, war ich diese Fehlermeldung, weil der adapter war noch zu entdecken, wenn ich versuchte, eine Verbindung zu der Buchse. Obwohl ich rief die cancelDiscovery Methode der Bluetooth-adapter, die ich hatte, zu warten, bis der Rückruf der BroadcastReceiver die onReceive () - Methode aufgerufen wurde mit der Aktion BluetoothAdapter.ACTION_DISCOVERY_FINISHED.

Einmal, wartete ich auf den adapter zu stoppen Entdeckung, dann der Aufruf verbinden, die auf den sockel geschafft.

InformationsquelleAutor der Antwort kmac.mcfarlane

Falls jemand Probleme hat mit Kotlin, hatte ich zu Folgen, die akzeptierte Antwort mit einigen Variationen:

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

Hoffe es hilft

InformationsquelleAutor der Antwort Santiago Martí Olbrich

Habe ich auch erhalten die gleichen IOExceptionaber ich finde das Android-system demo: "BluetoothChat" - Projekt gearbeitet wird. Ich habe festgestellt, das problem ist die UUID.

Damit ich meine ersetzen UUID.fromString("00001001-0000-1000-8000-00805F9B34FB") zu UUID.fromString("8ce255c0-200a-11e0-ac64-0800200c9a66") und es funktioniert am Tatort,nur manchmal neu zu starten müssen Sie das Bluetooth-Gerät;

InformationsquelleAutor der Antwort taotao