X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=altosdroid%2Fsrc%2Forg%2Faltusmetrum%2FAltosDroid%2FAltosBluetooth.java;h=973250a567c6f754b22dbca84d8d725ec83e4593;hb=4af4e36cda96d053458eeb040e35886890917385;hp=db63b342cbb8803e8adcd3181041f219c0f7fd88;hpb=ef29a197ce3318404f37e8a0b24d235e8b024a1f;p=fw%2Faltos diff --git a/altosdroid/src/org/altusmetrum/AltosDroid/AltosBluetooth.java b/altosdroid/src/org/altusmetrum/AltosDroid/AltosBluetooth.java index db63b342..973250a5 100644 --- a/altosdroid/src/org/altusmetrum/AltosDroid/AltosBluetooth.java +++ b/altosdroid/src/org/altusmetrum/AltosDroid/AltosBluetooth.java @@ -26,9 +26,12 @@ import java.util.UUID; import android.bluetooth.BluetoothAdapter; import android.bluetooth.BluetoothDevice; import android.bluetooth.BluetoothSocket; +//import android.os.Bundle; +import android.os.Handler; +//import android.os.Message; import android.util.Log; -import org.altusmetrum.AltosLib.*; +import org.altusmetrum.altoslib_6.*; public class AltosBluetooth extends AltosLink { @@ -39,6 +42,8 @@ public class AltosBluetooth extends AltosLink { private ConnectThread connect_thread = null; private Thread input_thread = null; + private Handler handler; + private BluetoothAdapter adapter; private BluetoothDevice device; private BluetoothSocket socket; @@ -46,15 +51,74 @@ public class AltosBluetooth extends AltosLink { private OutputStream output; // Constructor - public AltosBluetooth(BluetoothDevice in_device) { + public AltosBluetooth(BluetoothDevice in_device, Handler in_handler) { +// set_debug(D); adapter = BluetoothAdapter.getDefaultAdapter(); - + device = in_device; + handler = in_handler; connect_thread = new ConnectThread(device); connect_thread.start(); - input_thread = new Thread(this); - input_thread.start(); + } + + private void connected() { + 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).sendToTarget(); + + /* Notify other waiting threads that we're connected now + */ + notifyAll(); + } + } + } catch (IOException io) { + connect_failed(); + } + } + + private void connect_failed() { + synchronized (this) { + if (socket != null) { + try { + socket.close(); + } catch (IOException e2) { + if (D) Log.e(TAG, "ConnectThread: Failed to close() socket after failed connection"); + } + socket = null; + } + input = null; + output = null; + handler.obtainMessage(TelemetryService.MSG_CONNECT_FAILED).sendToTarget(); + if (D) Log.e(TAG, "ConnectThread: Failed to establish connection"); + } + } + + private Object closing_lock = new Object(); + private boolean closing = false; + + private void disconnected() { + synchronized(closing_lock) { + if (D) Log.e(TAG, String.format("Connection lost during I/O. Closing %b", closing)); + if (!closing) { + if (D) Log.d(TAG, "Sending disconnected message"); + handler.obtainMessage(TelemetryService.MSG_DISCONNECTED).sendToTarget(); + } + } } private class ConnectThread extends Thread { @@ -72,109 +136,188 @@ public class AltosBluetooth extends AltosLink { } public void run() { - if (D) Log.i(TAG, "BEGIN ConnectThread"); + if (D) Log.d(TAG, "ConnectThread: BEGIN"); setName("ConnectThread"); // 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 - socket.connect(); - } catch (IOException e) { - // Close the socket - try { - socket.close(); - } catch (IOException e2) { - if (D) Log.e(TAG, "unable to close() socket during connection failure", e2); - } - connection_failed(); - return; - } + BluetoothSocket local_socket; try { synchronized (AltosBluetooth.this) { - input = socket.getInputStream(); - output = socket.getOutputStream(); + local_socket = socket; + } - // Reset the ConnectThread because we're done - AltosBluetooth.this.notify(); - connect_thread = null; - if (D) Log.i(TAG, "Completed connect"); + if (local_socket != null) { + // Make a connection to the BluetoothSocket + // This is a blocking call and will only return on a + // successful connection or an exception + local_socket.connect(); } - } catch (Exception e) { - if (D) Log.e(TAG, "Failed to finish connection", e); - e.printStackTrace(); + + connected(); + + } catch (IOException e) { + connect_failed(); } + + synchronized (AltosBluetooth.this) { + /* Reset the ConnectThread because we're done + */ + connect_thread = null; + } + if (D) Log.d(TAG, "ConnectThread: Connect completed"); } public void cancel() { try { - if (socket != null) - socket.close(); + BluetoothSocket local_socket; + synchronized(AltosBluetooth.this) { + local_socket = socket; + socket = null; + } + if (local_socket != null) + local_socket.close(); + } catch (IOException e) { - if (D) Log.e(TAG, "close() of connect socket failed", e); + if (D) Log.e(TAG, "ConnectThread: close() of connect socket failed", e); } } } - private synchronized void wait_connected() throws InterruptedException { - if (input == null) { + public double frequency() { + return frequency; + } + + public int telemetry_rate() { + return telemetry_rate; + } + + public void save_frequency() { + AltosPreferences.set_frequency(0, frequency); + } + + public void save_telemetry_rate() { + AltosPreferences.set_telemetry_rate(0, telemetry_rate); + } + + private synchronized void wait_connected() throws InterruptedException, IOException { + if (input == null && socket != null) { + if (D) Log.d(TAG, "wait_connected..."); wait(); + if (D) Log.d(TAG, "wait_connected done"); } + if (socket == null) + throw new IOException(); } - private void connection_failed() { - if (D) Log.i(TAG, "Bluetooth Connection failed!"); - } - public void print(String data) { byte[] bytes = data.getBytes(); + if (D) Log.d(TAG, "print(): begin"); try { - if (D) Log.i(TAG, "Entering print();"); wait_connected(); output.write(bytes); - if (D) Log.i(TAG, "Writing bytes: '" + data + "'"); + if (D) Log.d(TAG, "print(): Wrote bytes: '" + data.replace('\n', '\\') + "'"); } catch (IOException e) { - connection_failed(); + disconnected(); } catch (InterruptedException e) { - connection_failed(); + 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_failed(); - } catch (java.lang.InterruptedException e) { - connection_failed(); + disconnected(); + } catch (InterruptedException e) { + disconnected(); } - return AltosLink.ERROR; } - + + private static final int buffer_size = 1024; + + private byte[] buffer = new byte[buffer_size]; + private int buffer_len = 0; + private int buffer_off = 0; + + public int getchar() { + while (buffer_off == buffer_len) { + try { + wait_connected(); + buffer_len = input.read(buffer); + buffer_off = 0; + } catch (IOException e) { + 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; + } + } + return buffer[buffer_off++]; + } + + public void closing() { + synchronized(closing_lock) { + if (D) Log.d(TAG, "Marked closing true"); + closing = true; + } + } + + public void close() { + if (D) Log.d(TAG, "close(): begin"); + + closing(); + synchronized(this) { - if (connect_thread != null) { - connect_thread.cancel(); - connect_thread = null; + if (D) Log.d(TAG, "close(): synched"); + + if (socket != null) { + if (D) Log.d(TAG, "close(): Closing socket"); + try { + socket.close(); + } catch (IOException e) { + if (D) Log.e(TAG, "close(): unable to close() socket"); + } + socket = null; } + connect_thread = null; if (input_thread != null) { + if (D) Log.d(TAG, "close(): stopping input_thread"); try { + if (D) Log.d(TAG, "close(): input_thread.interrupt()....."); input_thread.interrupt(); + if (D) Log.d(TAG, "close(): input_thread.join()....."); input_thread.join(); } catch (Exception e) {} input_thread = null; } + input = null; + output = null; + notifyAll(); } } + // 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 public boolean can_cancel_reply() { return false; } public boolean show_reply_timeout() { return true; } public void hide_reply_timeout() { }