Fix gradle deprecation warnings.

Fix to use new rosjava message APIs.

android_gingerbread/build.gradle

@@ -16,7 +16,6 @@
 
 dependencies {
   compile 'ros.rosjava_core:rosjava:0.0.0-SNAPSHOT'
-  compile 'ros:message.sensor_msgs:0.0.0-SNAPSHOT'
 }
 
 debug.dependsOn deployTransitiveLibs

android_gingerbread/src/org/ros/android/BitmapFromCompressedImage.java

@@ -18,16 +18,17 @@ package org.ros.android;
 
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
-import org.ros.message.sensor_msgs.CompressedImage;
+import org.ros.collections.PrimitiveArrays;
 
 /**
  * @author damonkohler@google.com (Damon Kohler)
  */
-public class BitmapFromCompressedImage implements MessageCallable<Bitmap, CompressedImage> {
+public class BitmapFromCompressedImage implements
+    MessageCallable<Bitmap, sensor_msgs.CompressedImage> {
 
   @Override
-  public Bitmap call(CompressedImage message) {
-    return BitmapFactory.decodeByteArray(message.data, 0, message.data.length);
+  public Bitmap call(sensor_msgs.CompressedImage message) {
+    byte[] data = PrimitiveArrays.toByteArray(message.data());
+    return BitmapFactory.decodeByteArray(data, 0, data.length);
   }
-
 }

android_gingerbread/src/org/ros/android/BitmapFromImage.java

@@ -20,23 +20,22 @@ import com.google.common.base.Preconditions;
 
 import android.graphics.Bitmap;
 import android.graphics.Color;
-import org.ros.message.sensor_msgs.Image;
 
 /**
  * @author damonkohler@google.com (Damon Kohler)
  */
-public class BitmapFromImage implements MessageCallable<Bitmap, Image> {
+public class BitmapFromImage implements MessageCallable<Bitmap, sensor_msgs.Image> {
 
   @Override
-  public Bitmap call(Image message) {
-    Preconditions.checkArgument(message.encoding.equals("rgb8"));
+  public Bitmap call(sensor_msgs.Image message) {
+    Preconditions.checkArgument(message.encoding().equals("rgb8"));
     Bitmap bitmap =
-        Bitmap.createBitmap((int) message.width, (int) message.height, Bitmap.Config.ARGB_8888);
-    for (int x = 0; x < message.width; x++) {
-      for (int y = 0; y < message.height; y++) {
-        byte red = message.data[(int) (y * message.step + 3 * x)];
-        byte green = message.data[(int) (y * message.step + 3 * x + 1)];
-        byte blue = message.data[(int) (y * message.step + 3 * x + 2)];
+        Bitmap.createBitmap((int) message.width(), (int) message.height(), Bitmap.Config.ARGB_8888);
+    for (int x = 0; x < message.width(); x++) {
+      for (int y = 0; y < message.height(); y++) {
+        byte red = message.data().get((int) (y * message.step() + 3 * x)).byteValue();
+        byte green = message.data().get((int) (y * message.step() + 3 * x + 1)).byteValue();
+        byte blue = message.data().get((int) (y * message.step() + 3 * x + 2)).byteValue();
         bitmap.setPixel(x, y, Color.argb(255, red & 0xFF, green & 0xFF, blue & 0xFF));
       }
     }

android_gingerbread/src/org/ros/android/OrientationPublisher.java

@@ -20,9 +20,8 @@ import android.hardware.Sensor;
 import android.hardware.SensorEvent;
 import android.hardware.SensorEventListener;
 import android.hardware.SensorManager;
+import geometry_msgs.PoseStamped;
 import org.ros.message.Time;
-import org.ros.message.geometry_msgs.PoseStamped;
-import org.ros.message.geometry_msgs.Quaternion;
 import org.ros.namespace.GraphName;
 import org.ros.node.Node;
 import org.ros.node.NodeMain;
@@ -39,18 +38,10 @@ public class OrientationPublisher implements NodeMain {
 
   private final class OrientationListener implements SensorEventListener {
 
-    private final Publisher<PoseStamped> publisher;
-    private final org.ros.message.geometry_msgs.Point origin;
+    private final Publisher<geometry_msgs.PoseStamped> publisher;
 
-    private volatile int seq;
-
-    private OrientationListener(Publisher<PoseStamped> publisher) {
+    private OrientationListener(Publisher<geometry_msgs.PoseStamped> publisher) {
       this.publisher = publisher;
-      origin = new org.ros.message.geometry_msgs.Point();
-      origin.x = 0;
-      origin.y = 0;
-      origin.z = 0;
-      seq = 0;
     }
 
     @Override
@@ -62,17 +53,14 @@ public class OrientationPublisher implements NodeMain {
       if (event.sensor.getType() == Sensor.TYPE_ROTATION_VECTOR) {
         float[] quaternion = new float[4];
         SensorManager.getQuaternionFromVector(quaternion, event.values);
-        Quaternion orientation = new Quaternion();
-        orientation.w = quaternion[0];
-        orientation.x = quaternion[1];
-        orientation.y = quaternion[2];
-        orientation.z = quaternion[3];
-        PoseStamped pose = new PoseStamped();
-        pose.header.frame_id = "/map";
-        pose.header.seq = seq++;
-        pose.header.stamp = Time.fromMillis(System.currentTimeMillis());
-        pose.pose.position = origin;
-        pose.pose.orientation = orientation;
+        PoseStamped pose = publisher.newMessage();
+        pose.header().frame_id("/map");
+        // TODO(damonkohler): Should get time from the Node.
+        pose.header().stamp(Time.fromMillis(System.currentTimeMillis()));
+        pose.pose().orientation().w(quaternion[0]);
+        pose.pose().orientation().x(quaternion[1]);
+        pose.pose().orientation().y(quaternion[2]);
+        pose.pose().orientation().z(quaternion[3]);
         publisher.publish(pose);
       }
     }
@@ -90,7 +78,7 @@ public class OrientationPublisher implements NodeMain {
   @Override
   public void onStart(Node node) {
     try {
-      Publisher<org.ros.message.geometry_msgs.PoseStamped> publisher =
+      Publisher<geometry_msgs.PoseStamped> publisher =
           node.newPublisher("android/orientation", "geometry_msgs/PoseStamped");
       orientationListener = new OrientationListener(publisher);
       Sensor sensor = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);

android_gingerbread/src/org/ros/android/views/PublishingPreviewCallback.java

@@ -21,22 +21,24 @@ import com.google.common.base.Preconditions;
 import android.hardware.Camera;
 import android.hardware.Camera.PreviewCallback;
 import android.hardware.Camera.Size;
-import org.ros.message.sensor_msgs.CameraInfo;
-import org.ros.message.sensor_msgs.CompressedImage;
+import org.ros.message.Time;
 import org.ros.node.Node;
 import org.ros.node.topic.Publisher;
 
+import java.util.ArrayList;
+
 /**
  * @author damonkohler@google.com (Damon Kohler)
  */
 class PublishingPreviewCallback implements PreviewCallback {
 
   private final Node node;
-  private final Publisher<CompressedImage> imagePublisher;
-  private final Publisher<CameraInfo> cameraInfoPublisher;
+  private final Publisher<sensor_msgs.CompressedImage> imagePublisher;
+  private final Publisher<sensor_msgs.CameraInfo> cameraInfoPublisher;
 
-  public PublishingPreviewCallback(Node node, Publisher<CompressedImage> imagePublisher,
-      Publisher<CameraInfo> cameraInfoPublisher) {
+  public PublishingPreviewCallback(Node node,
+      Publisher<sensor_msgs.CompressedImage> imagePublisher,
+      Publisher<sensor_msgs.CameraInfo> cameraInfoPublisher) {
     this.node = node;
     this.imagePublisher = imagePublisher;
     this.cameraInfoPublisher = cameraInfoPublisher;
@@ -47,26 +49,26 @@ class PublishingPreviewCallback implements PreviewCallback {
     Preconditions.checkNotNull(data);
     Preconditions.checkNotNull(camera);
 
-    CompressedImage image = new CompressedImage();
-    CameraInfo cameraInfo = new CameraInfo();
+    Time currentTime = node.getCurrentTime();
     String frameId = "camera";
 
-    // TODO(ethan): Right now serialization is deferred. When serialization
-    // happens inline, we won't need to copy.
-    image.data = new byte[data.length];
-    System.arraycopy(data, 0, image.data, 0, data.length);
-
-    image.format = "jpeg";
-    image.header.stamp = node.getCurrentTime();
-    image.header.frame_id = frameId;
+    sensor_msgs.CompressedImage image = imagePublisher.newMessage();
+    image.data(new ArrayList<Short>());
+    for (byte b : data) {
+      image.data().add((short) b);
+    }
+    image.format("jpeg");
+    image.header().stamp(currentTime);
+    image.header().frame_id(frameId);
     imagePublisher.publish(image);
 
-    cameraInfo.header.stamp = image.header.stamp;
-    cameraInfo.header.frame_id = frameId;
+    sensor_msgs.CameraInfo cameraInfo = cameraInfoPublisher.newMessage();
+    cameraInfo.header().stamp(currentTime);
+    cameraInfo.header().frame_id(frameId);
 
     Size previewSize = camera.getParameters().getPreviewSize();
-    cameraInfo.width = previewSize.width;
-    cameraInfo.height = previewSize.height;
+    cameraInfo.width(previewSize.width);
+    cameraInfo.height(previewSize.height);
     cameraInfoPublisher.publish(cameraInfo);
   }
 }

android_gingerbread/src/org/ros/android/views/RosCameraPreviewView.java

@@ -18,8 +18,6 @@ package org.ros.android.views;
 
 import android.content.Context;
 import android.util.AttributeSet;
-import org.ros.message.sensor_msgs.CameraInfo;
-import org.ros.message.sensor_msgs.CompressedImage;
 import org.ros.namespace.GraphName;
 import org.ros.namespace.NameResolver;
 import org.ros.node.Node;
@@ -51,10 +49,11 @@ public class RosCameraPreviewView extends CameraPreviewView implements NodeMain
   @Override
   public void onStart(Node node) {
     NameResolver resolver = node.getResolver().newChild("camera");
-    Publisher<CompressedImage> imagePublisher =
-        node.newPublisher(resolver.resolve("image_raw/compressed"), "sensor_msgs/CompressedImage");
-    Publisher<CameraInfo> cameraInfoPublisher =
-        node.newPublisher(resolver.resolve("camera_info"), "sensor_msgs/CameraInfo");
+    Publisher<sensor_msgs.CompressedImage> imagePublisher =
+        node.newPublisher(resolver.resolve("image_raw/compressed"),
+            sensor_msgs.CompressedImage._TYPE);
+    Publisher<sensor_msgs.CameraInfo> cameraInfoPublisher =
+        node.newPublisher(resolver.resolve("camera_info"), sensor_msgs.CameraInfo._TYPE);
     setPreviewCallback(new PublishingPreviewCallback(node, imagePublisher, cameraInfoPublisher));
   }