it-swarm.com.de

Wie kann ich verhindern, dass die Android Bluetooth-RFCOMM-Verbindung unmittelbar nach .connect () unterbrochen wird?

Dieses Problem wurde behoben! Vielen Dank an Brad, Denis und Junkie! Du bist der Held! :)

Dies ist der Arbeitscode. Es stellt eine Verbindung zu Zeemote her und liest Daten daraus.

===== Code =====

 öffentliche Klasse ZeeTest erweitert Activity {
 @Override 
 public void onCreate (Bundle savedInstanceState) {
 super.onCreate (savedInstanceState); 
 setContentView ( R.Layout.main); 
 Versuche {
 Für (int i = 0; i <3; i ++) {
 Test (); 
} 
} catch (Ausnahme e) {
 e.printStackTrace (); 
} 
} 
 
 private boolean connected = false; 
 privater BluetoothSocket-Sockel; 
 privater InputStream; 
 öffentlicher Void-Test () wirft Ausnahme {
 wenn (verbunden) {
 zurück; 
} 
 BluetoothDevice zee = BluetoothAdapter.getDefaultAdapter (). 
 GetRemoteDevice ("00: 1C: 4D: 02: A6: 55"); 
 Methode m = zee.getClass () .getMethod ("createRfcommSocket", 
 neue Klasse [] {int.class}); 
 sock = (BluetoothSoc ket) m.invoke (zee, Integer.valueOf (1)); 
 Log.d ("ZeeTest", "++++ Connecting"); 
 sock.connect (); 
 Log.d ("ZeeTest", "++++ Connected"); 
 In = sock.getInputStream (); 
 Byte [] Puffer = neues Byte [50]; 
 int read = 0; 
 Log.d ("ZeeTest", "++++ Listening ..."); 
 try {
 while (true) ) {
 read = in.read (Puffer); 
 connected = true; 
 StringBuilder buf = new StringBuilder (); 
 for (int i = 0; Ich lese; i ++) {
 int b = Puffer [i] & 0xff; 
 if (b <0x10) {
 buf.append ("0"); 
} 
 buf.append (Integer.toHexString (b)). append (""); 
} 
 Log.d ("ZeeTest", "++++ Read" + read + "bytes:" + buf.toString ()); 
} 
} catch (IOException e) {} 
 Log.d ("ZeeTest", "+++ + Fertig: test () "); 
} 
 @Override 
 Public void onDestroy () {
 Try {
 If (in! = null) {
 in.close (); 
} 
 if (sock! = null) {
 sock.close (); 
} 
} catch (IOException e) {
 e.printStackTrace (); 
} 
 super.onDestroy (); 
} 
} 

===== Ursprüngliche Frage =====

Ich versuche eine Verbindung zu einem Zeemote ( http://zeemote.com/ ) Gaming-Controller von Moto Droid herzustellen, auf dem die Firmware 2.0.1 ausgeführt wird. Die unten stehende Testanwendung stellt eine Verbindung zum Gerät her (LED blinkt), die Verbindung wird jedoch sofort unterbrochen.

Ich füge unten zwei Test-Apps ein: eine, die tatsächlich versucht, aus dem Eingabestream zu lesen, und eine, die nur dort sitzt und darauf wartet, dass das Gerät nach 5 Sekunden die Verbindung trennt. Und ja, ich habe die dritte Version :), die zuerst auf ACL_CONNECTED wartet und dann den Socket öffnet, aber an ihrem Verhalten ist nichts Neues.

Einige Hintergrundinformationen: Ich kann mit Bluez-Tools (auch als Protokoll beigefügt) eine einwandfreie Verbindung mit dem Zeemote von meinem Laptop aus herstellen. Ich weiß mit Sicherheit, dass Droid auch mit Zeemote sprechen kann , da "Game Pro" vom Markt gut damit funktioniert (aber dann ist es ein Treiber)/service verwendet also möglicherweise eine API niedrigerer Ebene?).

Mir ist aufgefallen, dass 'adb bugreport' weder UUID- noch RFCOMM-Kanal für Zeemote meldet, während dies für alle anderen Geräte (einschließlich des Headsets Moto HS815, eines anderen blöden Geräts, für das 'sdp browse' nichts meldet) der Fall ist. Beim Booten des Geräts hat Zeemote die Priorität 0 (andere haben die Priorität 100+).

Ich bin hier ziemlich ratlos, ich habe so lange daran gearbeitet, dass mir die Ideen ausgehen, sodass jede Hilfe sehr geschätzt wird (auch wenn Sie nicht wissen , dass antworte :))

Danke, Max

Testanwendung Nr. 1

Diese App versucht, tatsächlich vom Gerät zu lesen.

===== Code =====

 öffentliche Klasse ZeeTest erweitert Activity {
 @Override 
 public void onCreate (Bundle savedInstanceState) {
 super.onCreate (savedInstanceState); 
 setContentView ( R.layout.main); 
 Try {
 Test (); 
} Catch (IOException e) {
 E.printStackTrace (); 
} 
} 
 
 privater BluetoothSocket-Sockel; 
 privater InputStream; 
 öffentlicher Void-Test () löst IOException {
 BluetoothDevice aus zee = BluetoothAdapter.getDefaultAdapter (). 
 getRemoteDevice ("00: 1C: 4D: 02: A6: 55"); 
 sock = zee.createRfcommSocketToServiceRecord (
 UUID.fromString ( "8e1f0cf7-508f-4875-b62c-fbb67fd34812"); 
 Log.d ("ZeeTest", "++++ Connecting"); 
 Sock.connect (); 
 Log.d ("ZeeTest", "++++ Connected"); 
 In = sock.getInputStream (); 
 byte [] buffer = new byte [1]; 
 int bytes = 0; 
 int x = 0; 
 Log.d ("ZeeTest", "++++ Listening") ... "); 
 while (x <2) {
 x ++; 
 try {
 bytes = in.read (buffer); 
 Log.d ("ZeeTest", "++++ Read" + Bytes + "Bytes"); 
} Catch (IOException e) {
 E.printStackTrace (); 
 try {Thread.sleep (100); } catch (InterruptedException ie) {} 
} 
} 
 Log.d ("ZeeTest", "++++ Done: test ()"); 
} 
 @Override 
 Public void onDestroy () {
 Try {
 If (in! = Null) {
 In.close () ; 
} 
 if (sock! = null) {
 sock.close (); 
} 
} catch (IOException e) {
 e.printStackTrace (); 
} 
 super.onDestroy (); 
} 
} 

===== Log =====

 04-19 22: 27: 01.147: DEBUG/ZeeTest (8619): ++++ Connecting 
 04-19 22: 27: 04.085: INFO/usbd (1062): process_usb_uevent_message () : buffer = add @/devices/virtual/bluetooth/hci0/hci0: 1 
 04-19 22: 27: 04.085: INFO/usbd (1062): main (): call select (...) 
 04-19 22: 27: 04.327: ERROR/BluetoothEventLoop.cpp (4029): event_filter: Empfangenes Signal org.bluez.Device: PropertyChanged from /org/bluez/4121/hci0/dev_00_1C_4D_02_A6_55[.____.ull4 -19 22: 27: 04.491: VERBOSE/BluetoothEventRedirector (7499): Erhaltene Android.bleutooth.device.action.UUID 
 04-19 22: 27: 04.905: DEBUG/ZeeTest (8619): ++++ Connected 
 04-19 22: 27: 04.905: DEBUG/ZeeTest (8619): ++++ Listening ... 
 04-19 22: 27: 05.538: WARN/System.err ( 8619): Java.io.IOException: Software verursachte Verbindungsabbruch 
 04-19 22: 27: 05.600: WARN/System.err (8619): bei Android.bluetooth.BluetoothSocket.readNative (native Methode) 
 ... 
 04-19 22: 27: 05.717: WARN/System.err (8619): Java.io.IOException: Software verursacht conne Abbruch der Aktion 
 04-19 22: 27: 05.717: WARN/System.err (8619): bei Android.bluetooth.BluetoothSocket.readNative (native Methode) 
 ... 
 04-19 22: 27: 05.819: DEBUG/ZeeTest (8619): ++++ Done: test () 
 04-19 22: 27: 07.155: VERBOSE/BluetoothEventRedirector (7499): Android.bleutooth empfangen .device.action.UUID 
 04-19 22: 27: 09.077: INFO/usbd (1062): process_usb_uevent_message (): buffer = remove @/devices/virtual/bluetooth/hci0/hci0: 1 
 04-19 22: 27: 09.085: INFO/usbd (1062): main (): Anrufauswahl (...) 
 04-19 22: 27: 09.139: ERROR/BluetoothEventLoop.cpp (4029 ): event_filter: Received signal org.bluez.Device: PropertyChanged from /org/bluez/4121/hci0/dev_00_1C_4D_02_A6_55

Testanwendung Nr. 2

Dieser Test stellt eine Verbindung her und wartet - nützlich, um das Problem der automatischen Trennung anzuzeigen.

===== Code =====

 öffentliche Klasse ZeeTest erweitert Activity {
 @Override 
 public void onCreate (Bundle savedInstanceState) {
 super.onCreate (savedInstanceState); 
 setContentView ( R.layout.main); 
 GetApplicationContext (). RegisterReceiver (Empfänger, 
 New IntentFilter (BluetoothDevice.ACTION_ACL_CONNECTED)); 
 GetApplicationContext (). RegisterReceiver (Empfänger, 
 new IntentFilter (BluetoothDevice.ACTION_ACL_DISCONNECTED); 
 try {
 BluetoothDevice zee = BluetoothAdapter.getDefaultAdapter (). 
 getRemoteDevice ("00: 1C: 4D: 02: A6: 55 "); 
 Sock = zee.createRfcommSocketToServiceRecord (
 UUID.fromString (" 8e1f0cf7-508f-4875-b62c-fbb67fd34812 "); 
 
 Log. d ("ZeeTest", "++++ Connecting"); 
 sock.connect (); 
 Log.d ("ZeeTest", "+++ + Verbunden "); 
} Catch (IOException e) {
 E.printStackTrace (); 
} 
} 
 
 private static final LogBroadcastReceiver receiver = new LogBroadcastReceiver (); 
 public static class LogBroadcastReceiver erweitert BroadcastReceiver {
 @Override 
 public void onReceive (Kontextkontext, Absicht) {
 Log.d ("ZeeReceiver", intent.toString ()); 
 Bundle-Extras = intent.getExtras (); 
 Für (String k: extras.keySet ()) {
 Log.d ("ZeeReceiver", "Extra:" + extras.get (k) .toString ()); 
} 
} 
} 
 
 private BluetoothSocket-Socke; 
 @Override 
 public void onDestroy () {
 getApplicationContext (). unregisterReceiver (receiver); 
 if (sock! = null) {
 try {
 sock.close (); 
 } catch (IOException e) {
 e.printStackTrace (); 
} 
} 
 super.onDestroy (); 
} 
} 

===== Log =====

 04-19 22: 06: 34.944: DEBUG/ZeeTest (7986): ++++ Connecting 
 04-19 22: 06: 38.202: INFO/usbd (1062): process_usb_uevent_message () : buffer = add @/devices/virtual/bluetooth/hci0/hci0: 1 
 04-19 22: 06: 38.202: INFO/usbd (1062): main (): call select (...) 
 04-19 22: 06: 38.217: ERROR/BluetoothEventLoop.cpp (4029): event_filter: Empfangenes Signal org.bluez.Device: PropertyChanged from /org/bluez/4121/hci0/dev_00_1C_4D_02_A6_55[.____.ull4 -19 22: 06: 38.428: VERBOSE/BluetoothEventRedirector (7499): Erhaltene Android.bleutooth.device.action.UUID 
 04-19 22: 06: 38.968: DEBUG/ZeeTest (7986): ++++ Connected 
 04-19 22: 06: 39.061: DEBUG/ZeeReceiver (7986): Intent {act = Android.bluetooth.device.action.ACL_CONNECTED (mit Extras)} 
 04-19 22: 06: 39.108: DEBUG/ZeeReceiver (7986): Extra: 00: 1C: 4D: 02: A6: 55 
 04-19 22: 06: 39.538: INFO/ActivityManager (4029): Angezeigte Aktivität zee.test /.ZeeTest: 5178 ms (insgesamt 5178 ms) 
 04-19 22: 06: 41.014: VERBOSE/BluetoothEventRedirector (7499): Erhaltene Android.bleutooth.device.action.UUID 
 04-19 22: 06: 43.038: INFO/usbd (1062): process_usb_uevent_message (): buffer = remove @/devices/virtual/bluetooth/hci0/hci0: 1 
 04-19 22: 06: 43.038: INFO/usbd (1062): main (): Anrufauswahl (...) 
 04-19 22: 06: 43.069: ERROR/BluetoothEventLoop .cpp (4029): event_filter: Empfangenes Signal org.bluez.Device: PropertyChanged from /org/bluez/4121/hci0/dev_00_1C_4D_02_A6_55[.____ .04-19 22: 06: 43.124: DEBUG/ZeeReceiver (7986): Intent {act = Android.bluetooth.device.action.ACL_DISCONNECTED (hat Extras)} 
 04-19 22: 06: 43.124: DEBUG/ZeeReceiver (7986): Extra: 00: 1C: 4D: 02: A6: 55 

Systemprotokolle

===== Terminal Log =====

 $ sdptool durchsuchen 
 Nachfragen ... 
 Durchsuchen von 00: 1C: 4D: 02: A6: 55 ... 
 
 $ sdptool-Datensätzen 00: 1C: 4D: 02: A6: 55 
 Dienstname: Zeemote 
 Dienstumgehung: 0x10015 
 Dienstklassen-ID-Liste: 
 UUID 128: 8e1f0cf7-508f -4875-b62c-fbb67fd34812 
 Protokolldeskriptorliste: 
 "L2CAP" (0x0100) 
 "RFCOMM" (0x0003) 
 Kanal: 1 
 Sprachbasisattr-Liste: 
 Code_ISO639: 0x656e 
 Codierung: 0x6a 
 Basisoffset: 0x100 
 
 $ Rfcomm connect/dev/tty10 00: 1C: 4D: 02: A6: 55 
 Verbunden/dev/rfcomm0 mit 00: 1C: 4D: 02: A6: 55 auf Kanal 1 
 Drücken Sie STRG-C, um aufzulegen 
 
 # rfcomm show /dev/tty10[.____.)rfcomm0: 00: 1F: 3A: E4: C8: 40 -> 00: 1C: 4D: 02: A6: 55 channel 1 connected [Reuse-DC-Release- on-hup tty-attached] 
 
 # cat /dev/tty10[.____.‹ (hier nichts) 
 
 # hcidump 
 HCI sniffer - Bluetooth Packet Analyzer Version 1.42 
 Gerät: hci0 snap_len: 1028 Filter: 0xf fffffff 
 <HCI-Befehl: Verbindung herstellen (0x01 | 0x0005) plen 13 
> HCI-Ereignis: Befehlsstatus (0x0f) plen 4 
> HCI-Ereignis: Verbindung hergestellt (0x03) plen 11 
 <HCI-Befehl: Fernunterstützte Funktionen lesen (0x01 | 0x001b) plen 2 
> HCI-Ereignis: Fernunterstützte Funktionen lesen (0x0b) plen 11 
 <ACL-Daten: handle 11 Flags 0x02 dlen 10 
 L2CAP (s): Info erforderlich: Typ 2 
> HCI-Ereignis: Befehlsstatus (0x0f) plen 4 
> HCI-Ereignis: Änderung des Seiten-Scan-Wiederholungsmodus ( 0x20) plen 7 
> HCI-Ereignis: Max Slots Change (0x1b) plen 3 
 <HCI-Befehl: Remote Name Request (0x01 | 0x0019) plen 10 
> HCI-Ereignis: Command Status (0x0f) plen 4 
> ACL-Daten: 11 Flags behandeln 0x02 dlen 16 
 L2CAP (s): Info rsp: Typ 2 Ergebnis 0 
 Erweiterte Feature-Maske 0x0000 
 <ACL-Daten: Verarbeiten von 11 Flags 0x02 dlen 12 
 L2CAP (s): Verbindungsanforderung: psm 3 scid 0x0040 
> HCI-Ereignis: Anzahl abgeschlossener Pakete (0x13) plen 5 
> ACL-Daten: Handl e 11 Flags 0x02 dlen 16 
 L2CAP (s): Connect rsp: dcid 0x04fb scid 0x0040 Ergebnis 1 Status 2 
 Verbindung ausstehend - Autorisierung ausstehend 
> HCI-Ereignis: Remote Name Req Complete (0x07) plen 255 
> ACL-Daten: 11 Flags verarbeiten 0x02 dlen 16 
 L2CAP (s): Verbindung herstellen rsp: dcid 0x04fb scid 0x0040 Ergebnis 0 Status 0 
 Verbindung erfolgreich 
 <ACL-Daten: Verarbeiten von 11 Flags 0x02 dlen 16 
 L2CAP (s): Konfigurationsanforderung: dcid 0x04fb-Flags 0x00 clen 4 
 MTU 1013 
 (Ereignisse werden ordnungsgemäß mit empfangen bluez) 

===== Teil des AdB-Fehlerberichts =====

 - Bekannte Geräte - 
 00: 19: A1: 2D: 16: EA Bonded (0) LG U830 
 00001105-0000-1000- 8000-00805f9b34fb RFCOMM-Kanal = 17 
 00: 1C: 4D: 02: A6: 55 gebunden (0) Zeemote JS1 
 00: 0B: 2E: 6E: 6F: 00 gebunden (0) Motorola HS815 
 00001108-0000-1000-8000-00805f9b34fb RFCOMM-Kanal = 1 
 0000111e-0000-1000-8000-00805f9b34fb RFCOMM-Kanal = 2 
 00: 1F: 3A: E4: C8: 40 gebundenes (0) BRCM BT4X 
 00001105-0000-1000-8000-00805f9b34fb RFCOMM-Kanal = 9 
 00: 18: 42: EC: E2: 99 gebundenes (0) N95 
 00001105-0000-1000-8000-00805f9b34fb RFCOMM-Kanal = 9 

===== Auszug aus dem Startprotokoll =====

 04-18 21: 55: 10.382: VERBOSE/BluetoothEventRedirector (1985): Android.bluetooth.adapter.action.STATE_CHANGED 
 04-18 21: 55: 10.421: DEBUG/BT HSHFP ( 1237): Geladene Priorität 00: 19: A1: 2D: 16: EA = 100 
 04-18 21: 55: 10.428: DEBUG/BT HSHFP (1237): Geladene Priorität 00: 1C: 4D: 02: A6: 55 = 0 
 04-18 21: 55: 10.444: DEBUG/BT HSHFP (1237): Geladene Priorität 00: 0B: 2E: 6E: 6F: 00 = 101 
 04-18 21: 55: 10.749: DEBUG/BT HSHFP (1237): Geladene Priorität 00: 1F: 3A: E4: C8: 40 = 100 
 04-18 21: 55: 10.780: DEBUG/BT HSHFP (1237) : Geladene Priorität 00: 18: 42: EC: E2: 99 = 100 
48
Gilead

Versuchen Sie, Ihren Code zum Erstellen von RfcommSocket zu ändern:

sock = zee.createRfcommSocketToServiceRecord(
                      UUID.fromString("8e1f0cf7-508f-4875-b62c-fbb67fd34812"));

für diesen Code:

Method m = zee.getClass().getMethod("createRfcommSocket", new Class[] { int.class });
sock = (BluetoothSocket) m.invoke(device, 1);

Versuchen Sie auch, den Argumentwert im Bereich 1-3 in diesem m.invoke (Gerät, 1); .__ zu ändern. Wenn die Verbindung hergestellt wird, aber beim Versuch abgebrochen wird, rufen Sie Ihre Methode test () erneut in einer Schleife aufSo einfach:

for(int i=0;i<3;i++){  if(!testDone) test(); }
25
Denis L

Ich habe Code, den ich geschrieben hatte, und Code von [Android-Anfängern] Re: Serial over Bluetooth von XCaffeinated] 1 und dem obigen Beitrag zusammengeführt.

So erstellen Sie ein möglichst einfaches Bluetooth-Programm. 

Der wichtigste Zusatz für diesen Code ist die Verbesserung der Handhabung der Ausnahmen, die von connect() ausgelöst werden. 

Suchen Sie nach "@todo", um es an Ihre Bedürfnisse anzupassen. 

Ich hoffe, das erspart dir etwas Zeit! 

package com.xxx; // @todo Change to your package.   

import Java.io.IOException;
import Java.io.OutputStream;
import Java.lang.reflect.InvocationTargetException;
import Java.lang.reflect.Method;

import Android.app.Activity;
import Android.bluetooth.BluetoothAdapter;
import Android.bluetooth.BluetoothDevice;
import Android.bluetooth.BluetoothSocket;
import Android.os.Bundle;
import Android.util.Log;

/**
 * This is the simplest bluetooth program. It sends one message to one bluetooth
 * device. The message and the bluetooth hardware id for the device are hard
 * coded. <br>
 * <br>
 * It does <b>not</b> receive any data. It does not do any thread processing. <br>
 * <br>
 * 
 * This application will be useful to communicate with a bluetooth hardware
 * device such as a bar code reader, Lego Mindstorm, a PC with a com port
 * application, a PC with a terminal program with 'listening' to a com port, a
 * second Android device with a terminal program such as <a href=
 * "http://www.tec-it.com/en/software/data-acquisition/getblue/Android-smartphone/Default.aspx"
 * >GetBlue</a>. It is not a full Android bluetooth application but more a proof
 * of concept that the bluetooth works.
 * 
 * <br>
 * <br>
 * 
 * This code should cut and paste into the <a
 * href="http://developer.Android.com/resources/tutorials/hello-world.html>
 * 'HelloAndroid' example</a>. It does not use any screen io.
 * 
 * Add to your Android Manifest.xml file: <uses-permission
 * Android:name="Android.permission.BLUETOOTH" /> <uses-permission
 * Android:name="Android.permission.BLUETOOTH_ADMIN" />
 * 
 * For a proper bluetooth example with threading and receiving data see: <a
 * href=
 * "http://developer.Android.com/resources/samples/BluetoothChat/index.html"
 * >http://developer.Android.com/resources/samples/BluetoothChat/index.html</a>
 * 
 * @see <a
 *      href="http://developer.Android.com/guide/topics/wireless/bluetooth.html">
 *      http://developer.Android.com/guide/topics/wireless/bluetooth.html</a>
 * 
 */
public class BlueToothTesterActivity extends Activity {

    /** The BluetoothAdapter is the gateway to all bluetooth functions **/
    protected BluetoothAdapter bluetoothAdapter = null;

    /** We will write our message to the socket **/
    protected BluetoothSocket socket = null;

    /** The Bluetooth is an external device, which will receive our message **/
    BluetoothDevice blueToothDevice = null;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        // Grab the BlueToothAdapter. The first line of most bluetooth programs.
        bluetoothAdapter = BluetoothAdapter.getDefaultAdapter();

        // if the BluetoothAdapter.getDefaultAdapter(); returns null then the
        // device does not have bluetooth hardware. Currently the emulator
        // does not support bluetooth so this will this condition will be true.
        // i.e. This code only runs on a hardware device an not on the emulator.
        if (bluetoothAdapter == null) {
            Log.e(this.toString(), "Bluetooth Not Available.");
            return;
        }

        // This will find the remote device given the bluetooth hardware
        // address.
        // @todo: Change the address to the your device address
        blueToothDevice = bluetoothAdapter.getRemoteDevice("00:00:00:00:00:00");

        for (Integer port = 1; port <= 3; port++) {
            simpleComm(Integer.valueOf(port));
        }
    }

    protected void simpleComm(Integer port) {
        // byte [] inputBytes = null;

        // The documents tell us to cancel the discovery process.
        bluetoothAdapter.cancelDiscovery();

        Log.d(this.toString(), "Port = " + port);
        try {
            // This is a hack to access "createRfcommSocket which is does not
            // have public access in the current api.
            // Note: BlueToothDevice.createRfcommSocketToServiceRecord (UUID
            // uuid) does not work in this type of application. .
            Method m = blueToothDevice.getClass().getMethod(
                    "createRfcommSocket", new Class[] { int.class });
            socket = (BluetoothSocket) m.invoke(blueToothDevice, port);

            // debug check to ensure socket was set.
            assert (socket != null) : "Socket is Null";

            // attempt to connect to device
            socket.connect();
            try {
                Log.d(this.toString(),
                        "************ CONNECTION SUCCEES! *************");

                // Grab the outputStream. This stream will send bytes to the
                // external/second device. i.e it will sent it out.
                // Note: this is a Java.io.OutputStream which is used in several
                // types of Java programs such as file io, so you may be
                // familiar with it.
                OutputStream outputStream = socket.getOutputStream();

                // Create the String to send to the second device.
                // Most devices require a '\r' or '\n' or both at the end of the
                // string.
                // @todo set your message
                String message = "Data from Android and tester program!\r";

                // Convert the message to bytes and blast it through the
                // bluetooth
                // to the second device. You may want to use:
                // public byte[] getBytes (Charset charset) for proper String to
                // byte conversion.
                outputStream.write(message.getBytes());

            } finally {
                // close the socket and we are done.
                socket.close();
            }
            // IOExcecption is thrown if connect fails.
        } catch (IOException ex) {
            Log.e(this.toString(), "IOException " + ex.getMessage());
            // NoSuchMethodException IllegalAccessException
            // InvocationTargetException
            // are reflection exceptions.
        } catch (NoSuchMethodException ex) {
            Log.e(this.toString(), "NoSuchMethodException " + ex.getMessage());
        } catch (IllegalAccessException ex) {
            Log.e(this.toString(), "IllegalAccessException " + ex.getMessage());
        } catch (InvocationTargetException ex) {
            Log.e(this.toString(),
                    "InvocationTargetException " + ex.getMessage());
        }
    }

}
8
fishjd

Wenn ich es richtig verstanden habe, kann Ihre App überhaupt keine Daten vom Gerät sehen? 

Eine kleine Sache: Versuchen Sie Ihre UUID ohne Hiphens. In meinen RFCOMM-Apps definiere ich die UUID tatsächlich als Konstante für eine lange Ganzzahl.

Die Art und Weise, wie Ihre test () -Methode geschrieben wird, lässt mich glauben, dass test () die Verbindung herstellt, einen Thread definiert, dass er gestartet wird und sofort zurückkehrt. Mit anderen Worten, Ihr Thread referenziert eine Variable von außerhalb des Threads, die Teil der test () -Methode ist, aber wenn test () stirbt, tun dies auch seine Variablen. 

Kurz gesagt, testen Sie Ihre Tests außerhalb eines Threads und lassen Sie ihn zuerst dort arbeiten. Eine einfache Möglichkeit, dies zu tun, wäre die Verwendung von Thread.run () anstelle von thread.start (). .run () führt es im Vordergrund aus (und blockiert daher test (), damit es nicht zurückkehrt, bevor der Thread beendet ist). 

Für eine längerfristige Lösung möchten Sie möglicherweise Ihre Bluetooth-Variablen als Gloibal/Member-Variablen definieren, damit sie nicht außerhalb des Gültigkeitsbereichs liegen und Ihrem Thread immer zur Verfügung stehen. 

5
Brad Hein

Der obige Code funktionierte auf Samsung Galaxy Tab 2 mit 4.0.4 nicht. BTSocket.connect hat immer das Bluetooth-Pairing-Dialogfeld ausgelöst und ist dann fehlgeschlagen, auch wenn die richtige PIN eingegeben wurde. Das Ändern von "createRfcommSocket" in "createInsecureRfcommSocket" hat das Problem behoben. Ich hoffe, das hilft, ich habe mehr als 3 Stunden mit diesem Thema gekämpft.

0
vanomart

Versuchen Sie es mit der bekannten UUID: 00001101-0000-1000-8000-00805F9B34FB

0
android_junkie