Android Bluetooth Verbindung Problem

Ich versuche zum einrichten einer Bluetooth-Verbindung wie folgt :

    private class ConnectThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final BluetoothDevice mmDevice;
    BluetoothSocket connection = null;

    public ConnectThread(BluetoothDevice device) {
        mmDevice = device;
        //Get a BluetoothSocket for a connection with the
        //given BluetoothDevice            
        try {


            if(D) Log.i(TAG, "createRfcommSocket");
            Method m = mmDevice.getClass().getMethod("createRfcommSocket",new Class[] { int.class });
            connection = (BluetoothSocket) m.invoke(mmDevice, 1);

            Utils.pause(100);
        } catch (Exception e) {
            Log.e(TAG, "create() failed", e);
        }
        if(D) Log.i(TAG,"Bluetooth socket initialised");
        mmSocket = connection;
    }

    public void run() {
        if(D) Log.i(TAG, "BEGIN mConnectThread on Device : " + mmDevice);
        setName("ConnectThread");

        if (mmSocket != null) {
            //Always cancel discovery because it will slow down a connection
            if(mAdapter.isDiscovering()) {
                if(D) Log.i(TAG, "stop discovering before trying to connect");
                mAdapter.cancelDiscovery();
            }

            //Make a connection to the BluetoothSocket
            try {
                //This is a blocking call and will only return on a
                //successful connection or an exception
                if(D) Log.i(TAG, "start Bluetooth socket connection");
                mmSocket.connect();
                if(D) Log.i(TAG, "end of Bluetooth socket connection");
            } catch (Exception e1) {
                Log.e(TAG, "connect failed", e1);
                connectionFailed();
                //Reset the socket
                resetConnection(mmSocket);
                //Start the service over to restart listening mode
                if(D) Log.i(TAG, "restart connection");
                BluetoothConnectionService.this.start();
                if(D) Log.i(TAG, "return");
                return;
            }

            //Start the connected thread
            if(D) Log.i(TAG, "The device is considered as connected, call connected thread");
            connected(mmSocket, mmDevice);
        } else {
            if(D) Log.i(TAG, "connection fail");
            connectionFailed();
            BluetoothConnectionService.this.start();
        }
    }

    public void cancel() {
        if(D) Log.i(TAG,"connect thread cancel");
        resetConnection(mmSocket);
    }
}

Die Verbindung scheint OK zu sein, bekomme ich dieses log :

DEBUG/BluetoothConnectionService(3439): **connect to: 00:18:E4:21:8B:5E**
INFO/BluetoothConnectionService(3439): createRfcommSocket
INFO/BluetoothConnectionService(3439): Bluetooth socket initialised
INFO/BluetoothConnectionService(3439): BEGIN mConnectThread on Device : 00:18:E4:21:8B:5E
INFO/BluetoothConnectionService(3439): **start Bluetooth socket connection**
INFO/BluetoothConnectionService(3439): setState() 1 -> 2
INFO/ProtectionService(3439): MESSAGE_STATE_CHANGE: 1
DEBUG/ProtectionService(3439): STATE_CHANGED to STATE_LISTEN
INFO/ProtectionService(3439): MESSAGE_STATE_CHANGE: 2
DEBUG/abtfilt(2772): **Conn complete**
INFO/bluetoothd(2776): link_key_request (sba=24:21:AB:F4:69:25, dba=00:18:E4:21:8B:5E)
INFO/bluetoothd(2776): link_key_request (sba=24:21:AB:F4:69:25, dba=00:18:E4:21:8B:5E)
INFO/BluetoothConnectionService(3439): **end of Bluetooth socket connection**
INFO/BluetoothConnectionService(3439): **The device is considered as connected, call connected thread**

Den BluetoothSocket.connect() zurück, ohne Fehler.

Dann Schaffe ich die Verbindung mit dieser :

    private class ConnectedThread extends Thread {
    private final BluetoothSocket mmSocket;
    private final InputStream mmInStream;
    private final OutputStream mmOutStream;

    public ConnectedThread(BluetoothSocket socket) {
        if(D) Log.d(TAG, "create ConnectedThread");
        mmSocket = socket;

        //Get the BluetoothSocket input and output streams
        try {
            if(D) Log.i(TAG, "Get input stream");
            tmpIn = socket.getInputStream();
            if(D) Log.i(TAG, "Get output stream");
            tmpOut = socket.getOutputStream();
            if(D) Log.i(TAG, "isConnected = true");
            isConnected = true;
        } catch (IOException e) {
            Log.e(TAG, "Input and Output sockets not created", e);
            isConnected = false;
        }

        mmInStream = tmpIn;
        mmOutStream = tmpOut;
    }

    public void run() {
        if(D) Log.i(TAG, "BEGIN mConnectedThread");
        byte[] buffer = new byte[1024]; //buffer store for the stream
        int bytes; //bytes returned from read()

        //Keep listening to the InputStream until an exception occurs
        while(true) {
            try {
                //Read from the InputStream
                if(D) Log.i(TAG, "start read mmInStream");
                bytes = mmInStream.read(buffer);
                if(D) Log.i(TAG, "Bytes read : "+bytes);

                //Send the obtained bytes to the UI Activity
                mHandler.obtainMessage(MESSAGE_READ, bytes, -1, buffer).sendToTarget();
            } catch (IOException e) {
                Log.e(TAG, "ConnectedThread : disconnected", e);
                break;
            }
        }
    }

    /**
     * Write to the connected OutStream.
     * 
     * @param buffer
     *            The bytes to write
     */
    public void write(byte[] buffer) {
        try {
            mmOutStream.write(buffer);

            //Share the sent message back to the UI Activity
            mHandler.obtainMessage(MESSAGE_WRITE, -1, -1, buffer).sendToTarget();
            //mmOutStream.flush();
        } catch (IOException e) {
            Log.e(TAG, "Exception during write", e);
            connectionFailed();
        }
    }

    public void cancel() {
        if(D) Log.i(TAG,"connected Thread cancel");
        resetConnection(mmSocket);

    }
}

Und ich erhalte diese Fehlermeldung :

DEBUG/BluetoothConnectionService(3439): create ConnectedThread
INFO/BluetoothConnectionService(3439): Get input stream
INFO/BluetoothConnectionService(3439): Get output stream
INFO/BluetoothConnectionService(3439): isConnected = true
INFO/BluetoothConnectionService(3439): BEGIN mConnectedThread
INFO/BluetoothConnectionService(3439): start read mmInStream
INFO/BluetoothConnectionService(3439): setState() 2 -> 3
INFO/ProtectionService(3439): MESSAGE_STATE_CHANGE: 3
DEBUG/ProtectionService(3439): connectionEstablished
**ERROR/BluetoothConnectionService(3439): ConnectedThread : disconnected
ERROR/BluetoothConnectionService(3439): java.io.IOException: Software caused connection abort
ERROR/BluetoothConnectionService(3439):     at android.bluetooth.BluetoothSocket.readNative(Native Method)
ERROR/BluetoothConnectionService(3439):     at android.bluetooth.BluetoothSocket.read(BluetoothSocket.java:307)
ERROR/BluetoothConnectionService(3439):     at android.bluetooth.BluetoothInputStream.read(BluetoothInputStream.java:96)
ERROR/BluetoothConnectionService(3439):     at java.io.InputStream.read(InputStream.java:133)**
INFO/ProtectionService(3439): Send Bluetooth message
**ERROR/BluetoothConnectionService(3439): Exception during write
ERROR/BluetoothConnectionService(3439): java.io.IOException: Transport endpoint is not connected
ERROR/BluetoothConnectionService(3439):     at android.bluetooth.BluetoothSocket.writeNative(Native Method)
ERROR/BluetoothConnectionService(3439):     at android.bluetooth.BluetoothSocket.write(BluetoothSocket.java:317)**

Den Fehler klar zu kommen, wenn ich bin, dies zu tun :

bytes = mmInStream.read(buffer);

Was mache ich falsch ? Ich arbeite an diesem Fehler für eine Woche und ich kann nicht durch gehen...

Jede Hilfe wäre sehr apreciated !

können Sie dabei unterstützen, dieses Problem stackoverflow.com/questions/40559549/...

InformationsquelleAutor Laurent | 2011-02-24

17

Ich hatte ein sehr ähnliches problem vor einigen Tagen...

Versuchen Sie, diese Prüfung zu Ihrem code:
```
if(mmInStream.available() > 0){
   bytes = mmInStream.read(buffer);
   mHandler.obtainMessage(MESSAGE_WRITE, -1, -1, buffer).sendToTarget();
}
```
Diese Feste mein problem...

Glück 😉

Vielen Dank, Es funktioniert ! =D
Schön, genau das problem, das ich hatte.
Tatsächlich, das hinzufügen dieser code verhindert die Ausnahme, aber im Falle der Verbindung tatsächlich verloren, es verhindert, dass der thread neu gestartet und immer nach oben korrigiert. So, während ich Stimme mit der Antwort, die ich schließlich beschlossen, es nicht zu verwenden.
Was ist, wenn das problem kommt, wenn das schreiben, und nicht beim Empfang? Nur bei der mmOutStream.write(buffer)
Lauzon, Also was Sie am Ende tun?

InformationsquelleAutor Swordfish90

-1

Dies ist, wie ich das Problem gelöst: durch die Durchführung irgendeine Art von timeout. in meinem Fall 3 Sekunden. Der code ist nicht von mir, aber es funktioniert Super.
Was im Grunde passiert, ist, dass es eine zweite Schleife, etwas zu warten, um in den inputStream. wenn es etwas in den inputStream, es geht weiter und liest es. Diese Möglichkeit sollten Sie es vermeiden, Blockierung in der mmInputstream.read () - Methode.

Ich denke, es ist eine gute Lösung. Es arbeitete schön für mich: ich bin nicht der Autor.

ByteArrayOutputStream baos = new ByteArrayOutputStream();
                baos.reset();

                while (true) {
                treshHold = 0;
                    try {
                        try {
                            while (mmInStream.available() == 0 && treshHold < 3000) { //if there is something in the inputStream or after 3 seconds 
                                Thread.sleep(1);
                                treshHold++;
                            }
                        } catch (IOException e1) {
                            e1.printStackTrace();
                        } catch (InterruptedException e1) {
                            e1.printStackTrace();
                        }
                        if (treshHold < 3000) { //if less than 3 seconds timeout 
                            treshHold = 0;
                            b = mmInStream.read();
                            readBytes++;
                        } else {
                            break;
                        }

                        baos.write(b);
                        Thread.sleep(1);

                        if (b == 255) {
                            break; //this is how I know I have got the whole response
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                        break;
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                        break;
                    }
                }

Die while(true) kann geändert werden, je nachdem, was Sie erwarten, zu erhalten. In meinem Fall gehe ich von, während, wenn ich eine 0xFF oder 255. Hoffe, dass es hilft.

Als für das schreiben in den Ausgabestrom ich Folgendes:

if(mmOutStream !=null)
{
    try {
        mmOutStream.flush();
    } catch (IOException e1) {
        //log here ...
        e1.printStackTrace();
    }
    try {
        mmOutStream.write(send, 0, sendLength);
    } catch (IOException e) {
        //log here ...
        setState(STATE_NONE);
    }
}

Bitte markieren Sie die Antwort als korrekt, wenn es hilft 🙂

InformationsquelleAutor bboydflo

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.