Change Hokuyo node to use the new AcmDeviceActivity.

Add a PollingInputStream for reading quickly from the Arduino's limited buffer.
Add some debugging output.

android_acm_serial/src/org/ros/android/acm_serial/AcmDevice.java

@@ -30,22 +30,23 @@ import java.io.OutputStream;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 
+/**
+ * @author damonkohler@google.com (Damon Kohler)
+ */
 public class AcmDevice {
 
-  private static final int TIMEOUT = 3000;
+  private static final int CONTROL_TRANSFER_TIMEOUT = 3000; // ms
 
   private final UsbDeviceConnection usbDeviceConnection;
   private final InputStream inputStream;
   private final OutputStream outputStream;
 
-  private UsbEndpoint incomingEndpoint;
-
   public AcmDevice(UsbDeviceConnection usbDeviceConnection, UsbInterface usbInterface) {
     Preconditions.checkState(usbDeviceConnection.claimInterface(usbInterface, true));
     this.usbDeviceConnection = usbDeviceConnection;
 
     UsbEndpoint outgoingEndpoint = null;
-    incomingEndpoint = null;
+    UsbEndpoint incomingEndpoint = null;
     for (int i = 0; i < usbInterface.getEndpointCount(); i++) {
       UsbEndpoint endpoint = usbInterface.getEndpoint(i);
       if (endpoint.getType() == UsbConstants.USB_ENDPOINT_XFER_BULK) {
@@ -78,7 +79,7 @@ public class AcmDevice {
     int byteCount;
     byteCount =
         usbDeviceConnection.controlTransfer(0x21, 0x20, 0, 0, lineCoding, lineCoding.length,
-            TIMEOUT);
+            CONTROL_TRANSFER_TIMEOUT);
     Preconditions.checkState(byteCount == lineCoding.length);
   }
 

android_acm_serial/src/org/ros/android/acm_serial/AcmInputStream.java

@@ -65,22 +65,24 @@ public class AcmInputStream extends InputStream {
     int byteCount = 0;
     while (byteCount == 0) {
       byteCount = connection.bulkTransfer(endpoint, slice, slice.length, TIMEOUT);
+      if (DEBUG) {
+        if (byteCount == 0) {
+          Log.i(TAG, "bulkTransfer() returned 0, retrying.");
+        }
+      }
     }
     if (byteCount < 0) {
       throw new IOException("USB read failed.");
     }
     System.arraycopy(slice, 0, buffer, offset, byteCount);
+    if (DEBUG) {
+      Log.i(TAG, "Actually read " + byteCount + " bytes.");
+    }
     return byteCount;
   }
 
   @Override
   public int read() throws IOException {
-    byte[] buffer = new byte[1];
-    int byteCount = 0;
-    while (byteCount == 0) {
-      byteCount = read(buffer, 0, 1);
-    }
-    return buffer[0];
+    throw new UnsupportedOperationException();
   }
-
 }

android_acm_serial/src/org/ros/android/acm_serial/PollingInputStream.java

@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2011 Google Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not
+ * use this file except in compliance with the License. You may obtain a copy of
+ * the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+ * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+ * License for the specific language governing permissions and limitations under
+ * the License.
+ */
+
+package org.ros.android.acm_serial;
+
+import android.os.Process;
+import org.ros.exception.RosRuntimeException;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PipedInputStream;
+import java.io.PipedOutputStream;
+
+/**
+ * @author damonkohler@google.com (Damon Kohler)
+ */
+public class PollingInputStream extends InputStream {
+
+  private final static int STREAM_BUFFER_SIZE = 8192;
+
+  private final PipedInputStream pipedInputStream;
+
+  public PollingInputStream(final InputStream inputStream) {
+    final PipedOutputStream pipedOutputStream = new PipedOutputStream();
+    try {
+      pipedInputStream = new PipedInputStream(pipedOutputStream);
+    } catch (IOException e) {
+      throw new RosRuntimeException(e);
+    }
+    new Thread() {
+      @Override
+      public void run() {
+        Process.setThreadPriority(Process.THREAD_PRIORITY_MORE_FAVORABLE);
+        byte[] buffer = new byte[STREAM_BUFFER_SIZE];
+        while (true) {
+          try {
+            int bytesRead = inputStream.read(buffer, 0, STREAM_BUFFER_SIZE);
+            pipedOutputStream.write(buffer, 0, bytesRead);
+          } catch (IOException e) {
+            throw new RosRuntimeException(e);
+          }
+        }
+      };
+    }.start();
+  }
+
+  @Override
+  public int read(byte[] buffer, int offset, int length) throws IOException {
+    return pipedInputStream.read(buffer, offset, length);
+  }
+
+  @Override
+  public int read() throws IOException {
+    return pipedInputStream.read();
+  }
+}

android_rosserial/src/org/ros/android/rosserial/MainActivity.java

@@ -23,6 +23,7 @@ import org.ros.android.acm_serial.AcmDeviceActivity;
 import org.ros.android.acm_serial.BitRate;
 import org.ros.android.acm_serial.DataBits;
 import org.ros.android.acm_serial.Parity;
+import org.ros.android.acm_serial.PollingInputStream;
 import org.ros.android.acm_serial.StopBits;
 import org.ros.node.NodeConfiguration;
 import org.ros.rosserial.RosSerial;
@@ -44,12 +45,13 @@ public class MainActivity extends AcmDeviceActivity {
 
   @Override
   protected void init(AcmDevice acmDevice) {
-    acmDevice.setLineCoding(BitRate.BPS_57600, StopBits.STOP_BITS_1, Parity.NONE,
+    acmDevice.setLineCoding(BitRate.BPS_115200, StopBits.STOP_BITS_1, Parity.NONE,
         DataBits.DATA_BITS_8);
     NodeConfiguration nodeConfiguration =
         NodeConfiguration.newPublic(InetAddressFactory.newNonLoopback().getHostName(),
             getMasterUri());
-    getNodeRunner().run(new RosSerial(acmDevice.getInputStream(), acmDevice.getOutputStream()),
-        nodeConfiguration);
+    getNodeRunner().run(
+        new RosSerial(new PollingInputStream(acmDevice.getInputStream()),
+            acmDevice.getOutputStream()), nodeConfiguration);
   }
 }

android_tutorial_hokuyo/src/org/ros/android/tutorial/hokuyo/MainActivity.java

@@ -16,103 +16,37 @@
 
 package org.ros.android.tutorial.hokuyo;
 
-import android.app.Activity;
-import android.content.Intent;
-import android.hardware.usb.UsbDevice;
-import android.hardware.usb.UsbManager;
 import android.os.Bundle;
 import org.ros.address.InetAddressFactory;
-import org.ros.android.MasterChooser;
-import org.ros.android.NodeRunnerListener;
-import org.ros.android.NodeRunnerService;
 import org.ros.android.acm_serial.AcmDevice;
+import org.ros.android.acm_serial.AcmDeviceActivity;
 import org.ros.android.hokuyo.LaserScanPublisher;
 import org.ros.android.hokuyo.Scip20Device;
-import org.ros.exception.RosRuntimeException;
 import org.ros.node.NodeConfiguration;
-import org.ros.node.NodeRunner;
-
-import java.net.URI;
-import java.net.URISyntaxException;
-import java.util.concurrent.CountDownLatch;
 
 /**
  * @author damonkohler@google.com (Damon Kohler)
  */
-public class MainActivity extends Activity {
-
-  private final CountDownLatch nodeRunnerLatch;
-
-  private NodeRunner nodeRunner;
-  private URI masterUri;
+public class MainActivity extends AcmDeviceActivity {
 
   public MainActivity() {
-    super();
-    nodeRunnerLatch = new CountDownLatch(1);
+    super("ROS Hokuyo", "ROS Hokuyo");
   }
 
   @Override
   public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.main);
-    NodeRunnerService.start(this, "ROS Hokuyo service started.", "ROS Hokuyo",
-        new NodeRunnerListener() {
-          @Override
-          public void onNewNodeRunner(NodeRunner nodeRunner) {
-            MainActivity.this.nodeRunner = nodeRunner;
-            nodeRunnerLatch.countDown();
-          }
-        });
-  }
-
-  @Override
-  protected void onResume() {
-    if (masterUri == null) {
-      startActivityForResult(new Intent(this, MasterChooser.class), 0);
-    } else {
-      Intent intent = getIntent();
-      String action = intent.getAction();
-      final UsbDevice usbDevice =
-          (UsbDevice) getIntent().getParcelableExtra(UsbManager.EXTRA_DEVICE);
-      if (usbDevice != null) {
-        if (action.equals(UsbManager.ACTION_USB_DEVICE_ATTACHED)) {
-          new Thread() {
-            @Override
-            public void run() {
-              UsbManager usbManager = (UsbManager) getSystemService(USB_SERVICE);
-              AcmDevice acmDevice =
-                  new AcmDevice(usbManager.openDevice(usbDevice), usbDevice.getInterface(1));
-              Scip20Device scipDevice =
-                  new Scip20Device(acmDevice.getInputStream(), acmDevice.getOutputStream());
-              LaserScanPublisher laserScanPublisher = new LaserScanPublisher(scipDevice);
-              NodeConfiguration nodeConfiguration =
-                  NodeConfiguration.newPublic(InetAddressFactory.newNonLoopback().getHostName(),
-                      masterUri);
-              try {
-                nodeRunnerLatch.await();
-              } catch (InterruptedException e) {
-                throw new RosRuntimeException(e);
-              }
-              nodeRunner.run(laserScanPublisher, nodeConfiguration);
-            }
-          }.start();
-        }
-        if (action.equals(UsbManager.ACTION_USB_DEVICE_DETACHED) && nodeRunner != null) {
-          nodeRunner.shutdown();
-        }
-      }
-    }
-    super.onResume();
   }
 
   @Override
-  protected void onActivityResult(int requestCode, int resultCode, Intent data) {
-    if (requestCode == 0 && resultCode == RESULT_OK) {
-      try {
-        masterUri = new URI(data.getStringExtra("ROS_MASTER_URI"));
-      } catch (URISyntaxException e) {
-        throw new RuntimeException(e);
-      }
-    }
+  protected void init(AcmDevice acmDevice) {
+    Scip20Device scipDevice =
+        new Scip20Device(acmDevice.getInputStream(), acmDevice.getOutputStream());
+    LaserScanPublisher laserScanPublisher = new LaserScanPublisher(scipDevice);
+    NodeConfiguration nodeConfiguration =
+        NodeConfiguration.newPublic(InetAddressFactory.newNonLoopback().getHostName(),
+            getMasterUri());
+    getNodeRunner().run(laserScanPublisher, nodeConfiguration);
   }
 }