IOIO: make the android usb connection more reliable

Author: chrisws

ioio/ioio/src/main/java/ioio/smallbasic/IOIOImpl.java

@@ -61,9 +61,16 @@ public void sync() {
 
   public void waitForConnect(int latency) {
     IOUtil.setError(null);
-    TimerUtil.setLatency(latency);
+    if (latency < 0) {
+      IOUtil.setHardReset(true);
+    } else {
+      IOUtil.setHardReset(false);
+      TimerUtil.setLatency(latency);
+    }
     IOService.getInstance().start();
+    handleError();
     lock.invoke(IOIO::waitForConnect);
+    handleError();
   }
 
   public void waitForDisconnect() {

ioio/ioio/src/main/java/ioio/smallbasic/IOUtil.java

@@ -1,9 +1,11 @@
 package ioio.smallbasic;
 
+import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 
 public class IOUtil {
   private static final AtomicReference<String> ERROR = new AtomicReference<>();
+  private static final AtomicBoolean HARD_RESET = new AtomicBoolean(false);
 
   private IOUtil() {
     // no access
@@ -13,11 +15,19 @@ public static String getError() {
     return ERROR.get();
   }
 
+  public static boolean getHardReset() {
+    return HARD_RESET.get();
+  }
+
   public static synchronized void setError(String error) {
     if (error != null && ERROR.get() != null && !ERROR.get().contains(error)) {
       ERROR.set(error + " [" + ERROR.get() + "]");
     } else {
       ERROR.set(error);
     }
   }
+
+  public static void setHardReset(boolean hardReset) {
+    HARD_RESET.set(hardReset);
+  }
 }

ioio/ioio/src/main/java/ioio/smallbasic/android/AccessoryPermissionCheck.java

@@ -11,9 +11,11 @@
 import android.os.Build;
 import android.os.Handler;
 import android.os.Looper;
+import android.widget.Toast;
 
 import ioio.lib.spi.Log;
 import ioio.smallbasic.IOIOException;
+import ioio.smallbasic.IOUtil;
 
 public class AccessoryPermissionCheck extends BroadcastReceiver {
   private static final String TAG = AccessoryPermissionCheck.class.getSimpleName();
@@ -28,7 +30,7 @@ public AccessoryPermissionCheck() {
       throw new IOIOException("No usb accessory found.");
     }
 
-    UsbManager usbManager = (UsbManager) IOIOLoader.getContext().getSystemService(Context.USB_SERVICE);
+    UsbManager usbManager = UsbUtil.getUsbManager();
     if (!usbManager.hasPermission(accessory)) {
       new Handler(Looper.getMainLooper()).post(() -> {
         Context context = IOIOLoader.getContext();
@@ -40,8 +42,9 @@ public AccessoryPermissionCheck() {
         PendingIntent pendingIntent = PendingIntent.getBroadcast(context, 0, intent, flags);
         usbManager.requestPermission(accessory, pendingIntent);
       });
-      // for some reason using a latch here caused an ANR
+      // for some reason using a latch here causes an ANR
       Log.d(TAG, "requesting permission");
+      IOUtil.setHardReset(true);
       throw new IOIOException(PERMISSION_ERROR);
     }
   }
@@ -50,8 +53,11 @@ public AccessoryPermissionCheck() {
   public synchronized void onReceive(final Context context, Intent intent) {
     Log.d(TAG, "onReceive entered");
     if (ACTION_USB_PERMISSION.equals(intent.getAction())) {
+      boolean permitted = UsbUtil.getUsbManager().hasPermission(UsbUtil.getUsbAccessory());
+      final String message = "USB access " + (permitted ? "permitted" : "denied");
       final BroadcastReceiver receiver = this;
       new Handler(Looper.getMainLooper()).post(() -> {
+        Toast.makeText(context, message, Toast.LENGTH_LONG).show();
         context.unregisterReceiver(receiver);
       });
     }

ioio/ioio/src/main/java/ioio/smallbasic/android/UsbConnection.java

@@ -35,6 +35,7 @@
 import java.io.FileDescriptor;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
+import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 
@@ -47,6 +48,8 @@
 class UsbConnection implements IOIOConnection {
   private static final String TAG = UsbConnection.class.getSimpleName();
   private static final int SOFT_RESET = 0x01;
+  private static final int HARD_RESET = 0x00;
+  private static final int MAX_RETRIES = 10;
   private ConnectionState state;
   private FixedReadBufferedInputStream inputStream;
   private OutputStream outputStream;
@@ -73,17 +76,8 @@ public boolean canClose() {
   public synchronized void disconnect() {
     Log.i(TAG, "disconnect entered");
     if (this.state != ConnectionState.DISCONNECTED) {
-      this.state = ConnectionState.DISCONNECTED;
       IOUtil.setError("USB disconnected");
-      if (fileDescriptor != null) {
-        try {
-          fileDescriptor.close();
-        } catch (java.io.IOException e) {
-          IOUtil.setError("Failed to close file descriptor");
-          Log.e(TAG, "Failed to close file descriptor.", e);
-        }
-        fileDescriptor = null;
-      }
+      close();
     }
     Log.d(TAG, "leaving disconnect");
   }
@@ -103,10 +97,6 @@ public synchronized void waitForConnect() {
     if (state != ConnectionState.INIT) {
       throw new IllegalStateException("waitForConnect() may only be called once");
     }
-    this.fileDescriptor = UsbUtil.getParcelFileDescriptor();
-    if (this.fileDescriptor == null) {
-      throw new IOIOException("Failed to obtain descriptor");
-    }
     if (open()) {
       state = ConnectionState.CONNECTED;
     } else {
@@ -119,34 +109,87 @@ protected void finalize() {
     disconnect();
   }
 
+  private void close() {
+    state = ConnectionState.DISCONNECTED;
+    try {
+      if (inputStream != null) {
+        inputStream.close();
+      }
+      if (outputStream != null) {
+        outputStream.close();
+      }
+      if (fileDescriptor != null) {
+        fileDescriptor.close();
+      }
+      inputStream = null;
+      outputStream = null;
+      fileDescriptor = null;
+    } catch (java.io.IOException e) {
+      IOUtil.setError("Failed to close file descriptor: " + e);
+      Log.e(TAG, "Failed to close file descriptor.", e);
+    }
+  }
+
+  private void handleResetResponse(int attempt) throws IOException {
+    if (attempt > 0) {
+      int response = inputStream.read();
+      Log.e(TAG, "Response:" + response + " available:" + inputStream.available());
+      if (response != SOFT_RESET) {
+        // fail
+        if (inputStream.available() == 0) {
+          try {
+            Thread.sleep(100);
+          }
+          catch (InterruptedException e) {
+            throw new IOIOException(e);
+          }
+        }
+        handleResetResponse(attempt - 1);
+      }
+    } else {
+      throw new IOIOException("USB connection failure");
+    }
+  }
+
   private boolean open() {
     boolean result = false;
     Log.i(TAG, "open() entered");
 
     try {
-      FileDescriptor fd = fileDescriptor.getFileDescriptor();
-      inputStream = new FixedReadBufferedInputStream(new FileInputStream(fd), 1024);
-      outputStream = new BufferedOutputStream(new FileOutputStream(fd), 1024);
-      outputStream.write(SOFT_RESET);
-      outputStream.flush();
-      int response = inputStream.read();
-      if (response == SOFT_RESET) {
-        result = true;
-      } else {
-        IOUtil.setError("Unexpected response: " + response);
-      }
+      openStreams();
+      resetBoard();
+      handleResetResponse(MAX_RETRIES);
+      result = true;
     } catch (java.io.IOException e) {
       IOUtil.setError("Failed to open streams: " + e);
     } finally {
       if (!result) {
-        try {
-          fileDescriptor.close();
-        } catch (java.io.IOException e) {
-          Log.e(TAG, "Failed to close file descriptor.", e);
-        }
-        fileDescriptor = null;
+        close();
       }
     }
     return result;
   }
+
+  private void openStreams() {
+    this.fileDescriptor = UsbUtil.getParcelFileDescriptor();
+    if (this.fileDescriptor == null) {
+      throw new IOIOException("Failed to obtain descriptor");
+    }
+    FileDescriptor fd = fileDescriptor.getFileDescriptor();
+    inputStream = new FixedReadBufferedInputStream(new FileInputStream(fd), 1024);
+    outputStream = new BufferedOutputStream(new FileOutputStream(fd), 1024);
+  }
+
+  private void resetBoard() throws IOException {
+    if (IOUtil.getHardReset()) {
+      outputStream.write(HARD_RESET);
+      outputStream.write('I');
+      outputStream.write('O');
+      outputStream.write('I');
+      outputStream.write('O');
+    } else {
+      outputStream.write(SOFT_RESET);
+    }
+    outputStream.flush();
+  }
 }