X-Git-Url: https://git.gag.com/?p=fw%2Faltos;a=blobdiff_plain;f=altosdroid%2Fsrc%2Forg%2Faltusmetrum%2FAltosDroid%2FAltosBluetooth.java;h=da75ffddaf5ffdbd0a8c82049a16cba7f650e751;hp=0aea06f1cf22a242cf89489768070522caafdf15;hb=cdd7ad469728fde178c69b9c99d70d6e0ab3f12d;hpb=8d1d8d2a3c129cdbd55427bcda0f26715b02f1ee diff --git a/altosdroid/src/org/altusmetrum/AltosDroid/AltosBluetooth.java b/altosdroid/src/org/altusmetrum/AltosDroid/AltosBluetooth.java index 0aea06f1..da75ffdd 100644 --- a/altosdroid/src/org/altusmetrum/AltosDroid/AltosBluetooth.java +++ b/altosdroid/src/org/altusmetrum/AltosDroid/AltosBluetooth.java @@ -31,7 +31,7 @@ import android.os.Handler; //import android.os.Message; import android.util.Log; -import org.altusmetrum.altoslib_1.*; +import org.altusmetrum.altoslib_6.*; public class AltosBluetooth extends AltosLink { @@ -45,107 +45,190 @@ public class AltosBluetooth extends AltosLink { private Handler handler; private BluetoothAdapter adapter; - private BluetoothDevice device; private BluetoothSocket socket; private InputStream input; private OutputStream output; // Constructor - public AltosBluetooth(BluetoothDevice in_device, Handler in_handler) { + public AltosBluetooth(BluetoothDevice device, Handler handler) { +// set_debug(D); adapter = BluetoothAdapter.getDefaultAdapter(); - device = in_device; - handler = in_handler; + this.handler = handler; - connect_thread = new ConnectThread(device); + create_socket(device); + connect_thread = new ConnectThread(); connect_thread.start(); + } + + private Object closed_lock = new Object(); + private boolean closed = false; + private boolean closed() { + synchronized(closed_lock) { + return closed; + } } - private class ConnectThread extends Thread { - private final UUID SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); + private void connected() { + if (closed()) { + if (D) Log.d(TAG, "connected after closed"); + return; + } + + try { + synchronized(this) { + if (socket != null) { + input = socket.getInputStream(); + output = socket.getOutputStream(); + + input_thread = new Thread(this); + input_thread.start(); + + // Configure the newly connected device for telemetry + print("~\nE 0\n"); + set_monitor(false); + if (D) Log.d(TAG, "ConnectThread: connected"); + + /* Let TelemetryService know we're connected + */ + handler.obtainMessage(TelemetryService.MSG_CONNECTED, this).sendToTarget(); + + /* Notify other waiting threads that we're connected now + */ + notifyAll(); + } + } + } catch (IOException io) { + connect_failed(); + } + } + + private void connect_failed() { + if (closed()) { + if (D) Log.d(TAG, "connect_failed after closed"); + return; + } + + close_socket(); + input = null; + output = null; + handler.obtainMessage(TelemetryService.MSG_CONNECT_FAILED, this).sendToTarget(); + if (D) Log.e(TAG, "ConnectThread: Failed to establish connection"); + } + + private void disconnected() { + if (closed()) { + if (D) Log.d(TAG, "disconnected after closed"); + return; + } + + if (D) Log.d(TAG, "Sending disconnected message"); + handler.obtainMessage(TelemetryService.MSG_DISCONNECTED, this).sendToTarget(); + } + + private void close_socket() { + BluetoothSocket tmp_socket; - public ConnectThread(BluetoothDevice device) { - BluetoothSocket tmp_socket = null; + synchronized(this) { + tmp_socket = socket; + socket = null; + } + if (tmp_socket != null) { try { - tmp_socket = device.createInsecureRfcommSocketToServiceRecord(SPP_UUID); + tmp_socket.close(); } catch (IOException e) { - e.printStackTrace(); + if (D) Log.e(TAG, "close_socket failed"); } + } + } + + private final UUID SPP_UUID = UUID.fromString("00001101-0000-1000-8000-00805F9B34FB"); + + private void create_socket(BluetoothDevice device) { + + BluetoothSocket tmp_socket = null; + + try { + tmp_socket = device.createInsecureRfcommSocketToServiceRecord(SPP_UUID); + } catch (IOException e) { + e.printStackTrace(); + } + if (socket != null) { + if (D) Log.d(TAG, String.format("Socket already allocated %s", socket.toString())); + close_socket(); + } + synchronized (this) { socket = tmp_socket; } + } + + private class ConnectThread extends Thread { public void run() { if (D) Log.d(TAG, "ConnectThread: BEGIN"); setName("ConnectThread"); // Always cancel discovery because it will slow down a connection - adapter.cancelDiscovery(); + try { + adapter.cancelDiscovery(); + } catch (Exception e) { + if (D) Log.d(TAG, String.format("cancelDiscovery exception %s", e.toString())); + } + + BluetoothSocket local_socket = null; synchronized (AltosBluetooth.this) { - // Make a connection to the BluetoothSocket + if (!closed()) + local_socket = socket; + } + + if (local_socket != null) { try { + // Make a connection to the BluetoothSocket // This is a blocking call and will only return on a // successful connection or an exception - socket.connect(); - - input = socket.getInputStream(); - output = socket.getOutputStream(); + local_socket.connect(); } catch (IOException e) { - // Close the socket - try { - socket.close(); - } catch (IOException e2) { - if (D) Log.e(TAG, "ConnectThread: Failed to close() socket after failed connection"); - } - input = null; - output = null; - AltosBluetooth.this.notifyAll(); - handler.obtainMessage(TelemetryService.MSG_CONNECT_FAILED).sendToTarget(); - if (D) Log.e(TAG, "ConnectThread: Failed to establish connection"); - return; + if (D) Log.d(TAG, String.format("Connect exception %s", e.toString())); + local_socket = null; } + } - input_thread = new Thread(AltosBluetooth.this); - input_thread.start(); - - // Configure the newly connected device for telemetry - print("~\nE 0\n"); - set_monitor(false); + if (local_socket != null) { + connected(); + } else { + connect_failed(); + } - // Let TelemetryService know we're connected - handler.obtainMessage(TelemetryService.MSG_CONNECTED).sendToTarget(); + if (D) Log.d(TAG, "ConnectThread: completed"); + } + } - // Notify other waiting threads, now that we're connected - AltosBluetooth.this.notifyAll(); + public double frequency() { + return frequency; + } - // Reset the ConnectThread because we're done - connect_thread = null; + public int telemetry_rate() { + return telemetry_rate; + } - if (D) Log.d(TAG, "ConnectThread: Connect completed"); - } - } + public void save_frequency() { + AltosPreferences.set_frequency(0, frequency); + } - public void cancel() { - try { - if (socket != null) - socket.close(); - } catch (IOException e) { - if (D) Log.e(TAG, "ConnectThread: close() of connect socket failed", e); - } - } + public void save_telemetry_rate() { + AltosPreferences.set_telemetry_rate(0, telemetry_rate); } private synchronized void wait_connected() throws InterruptedException, IOException { - if (input == null) { + if (input == null && socket != null) { + if (D) Log.d(TAG, "wait_connected..."); wait(); - if (input == null) throw new IOException(); + if (D) Log.d(TAG, "wait_connected done"); } - } - - private void connection_lost() { - if (D) Log.e(TAG, "Connection lost during I/O"); - handler.obtainMessage(TelemetryService.MSG_DISCONNECTED).sendToTarget(); + if (socket == null) + throw new IOException(); } public void print(String data) { @@ -156,40 +239,83 @@ public class AltosBluetooth extends AltosLink { output.write(bytes); if (D) Log.d(TAG, "print(): Wrote bytes: '" + data.replace('\n', '\\') + "'"); } catch (IOException e) { - connection_lost(); + disconnected(); } catch (InterruptedException e) { - connection_lost(); + disconnected(); } } - public int getchar() { + public void putchar(byte c) { + byte[] bytes = { c }; + if (D) Log.d(TAG, "print(): begin"); try { wait_connected(); - return input.read(); + output.write(bytes); + if (D) Log.d(TAG, "print(): Wrote byte: '" + c + "'"); } catch (IOException e) { - connection_lost(); - } catch (java.lang.InterruptedException e) { - connection_lost(); + disconnected(); + } catch (InterruptedException e) { + disconnected(); } - return AltosLink.ERROR; } - public void close() { - if (D) Log.d(TAG, "close(): begin"); - synchronized(this) { - if (D) Log.d(TAG, "close(): synched"); + private static final int buffer_size = 1024; - if (connect_thread != null) { - if (D) Log.d(TAG, "close(): stopping connect_thread"); - connect_thread.cancel(); - connect_thread = null; - } - if (D) Log.d(TAG, "close(): Closing socket"); + private byte[] buffer = new byte[buffer_size]; + private int buffer_len = 0; + private int buffer_off = 0; + + private byte[] debug_chars = new byte[buffer_size]; + private int debug_off; + + private void debug_input(byte b) { + if (b == '\n') { + Log.d(TAG, " " + new String(debug_chars, 0, debug_off)); + debug_off = 0; + } else { + if (debug_off < buffer_size) + debug_chars[debug_off++] = b; + } + } + + public int getchar() { + while (buffer_off == buffer_len) { try { - socket.close(); + wait_connected(); + buffer_len = input.read(buffer); + buffer_off = 0; } catch (IOException e) { - if (D) Log.e(TAG, "close(): unable to close() socket"); + if (D) Log.d(TAG, "getchar IOException"); + disconnected(); + return AltosLink.ERROR; + } catch (java.lang.InterruptedException e) { + if (D) Log.d(TAG, "getchar Interrupted"); + disconnected(); + return AltosLink.ERROR; } + } + if (D) + debug_input(buffer[buffer_off]); + return buffer[buffer_off++]; + } + + public void closing() { + synchronized(closed_lock) { + if (D) Log.d(TAG, "Marked closed true"); + closed = true; + } + } + + + public void close() { + if (D) Log.d(TAG, "close(): begin"); + + closing(); + + close_socket(); + + synchronized(this) { + if (input_thread != null) { if (D) Log.d(TAG, "close(): stopping input_thread"); try { @@ -206,14 +332,6 @@ public class AltosBluetooth extends AltosLink { } } - - // We override this method so that we can add some debugging. Not 100% elegant, but more useful - // than debugging one char at a time above in getchar()! - public void add_reply(AltosLine line) throws InterruptedException { - if (D) Log.d(TAG, String.format("Got REPLY: %s", line.line)); - super.add_reply(line); - } - //public void flush_output() { super.flush_output(); } // Stubs of required methods when extending AltosLink