Add additional views.

Add virtual joystick, distance view, map view, and pan-tilt-zoom view.

android/README

@@ -0,0 +1 @@
+This work is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/ or send a letter to Creative Commons, 444 Castro Street, Suite 900, Mountain View, California, 94041, USA.

android/res/layout/pan_tilt.xml

@@ -0,0 +1,328 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="400px" android:layout_height="300px" android:id="@+id/pan_tilt_layout">
+
+
+  <ImageView android:id="@+id/background" android:src="@drawable/background"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" />
+
+  <ImageView android:id="@+id/pt_outline" android:src="@drawable/pt_bg"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" />
+
+  <ImageView android:id="@+id/pt_home_marker" android:src="@drawable/pt_home_marker"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="15px"
+    android:translationY="-24px" android:alpha="0.6" />
+
+  <ImageView android:id="@+id/pt_divet" android:src="@drawable/pan_tilt_controller"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="15px"
+    android:translationY="-24px" />
+
+
+
+
+  <!-- Small Pan marker 0 (left most) -->
+  <ImageView android:id="@+id/pan_small_marker_0" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="-102px"
+    android:translationY="-122px" />
+
+  <!-- Small Pan marker 1 -->
+  <ImageView android:id="@+id/pan_small_marker_1" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="-76px"
+    android:translationY="-122px" />
+
+  <!-- Small Pan marker 2 -->
+  <ImageView android:id="@+id/pan_small_marker_2" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="-50px"
+    android:translationY="-122px" />
+
+  <!-- Small Pan marker 3 -->
+  <ImageView android:id="@+id/pan_small_marker_3" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="-24px"
+    android:translationY="-122px" />
+
+  <!-- Small Pan marker 4 -->
+  <ImageView android:id="@+id/pan_small_marker_4" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="2px"
+    android:translationY="-122px" />
+
+  <!-- Small Pan marker 5 -->
+  <ImageView android:id="@+id/pan_small_marker_5" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="28px"
+    android:translationY="-122px" />
+
+  <!-- Small Pan marker 6 -->
+  <ImageView android:id="@+id/pan_small_marker_6" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="54px"
+    android:translationY="-122px" />
+
+  <!-- Small Pan marker 7 -->
+  <ImageView android:id="@+id/pan_small_marker_7" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="80px"
+    android:translationY="-122px" />
+
+  <!-- Small Pan marker 8 -->
+  <ImageView android:id="@+id/pan_small_marker_8" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="106px"
+    android:translationY="-122px" />
+
+  <!-- Small Pan marker 9 (right most) -->
+  <ImageView android:id="@+id/pan_small_marker_9" android:src="@drawable/small_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="133px"
+    android:translationY="-122px" />
+
+
+
+  <!-- Large Pan marker 0 (left most) -->
+  <ImageView android:id="@+id/pan_large_marker_0" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="-102px"
+    android:translationY="-130px" />
+
+  <!-- Large Pan marker 1 -->
+  <ImageView android:id="@+id/pan_large_marker_1" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="-76px"
+    android:translationY="-130px" />
+
+  <!-- Large Pan marker 2 -->
+  <ImageView android:id="@+id/pan_large_marker_2" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="-50px"
+    android:translationY="-130px" />
+
+  <!-- Large Pan marker 3 -->
+  <ImageView android:id="@+id/pan_large_marker_3" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="-24px"
+    android:translationY="-130px" />
+
+  <!-- Large Pan marker 4 -->
+  <ImageView android:id="@+id/pan_large_marker_4" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="2px"
+    android:translationY="-130px" />
+
+  <!-- Large Pan marker 5 -->
+  <ImageView android:id="@+id/pan_large_marker_5" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="28px"
+    android:translationY="-130px" />
+
+  <!-- Large Pan marker 6 -->
+  <ImageView android:id="@+id/pan_large_marker_6" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="54px"
+    android:translationY="-130px" />
+
+  <!-- Large Pan marker 7 -->
+  <ImageView android:id="@+id/pan_large_marker_7" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="80px"
+    android:translationY="-130px" />
+
+  <!-- Large Pan marker 8 -->
+  <ImageView android:id="@+id/pan_large_marker_8" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="106px"
+    android:translationY="-130px" />
+
+  <!-- Large Pan marker 9 (right most) -->
+  <ImageView android:id="@+id/pan_large_marker_9" android:src="@drawable/large_pan_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="133px"
+    android:translationY="-130px" />
+
+
+
+
+
+
+
+
+
+
+
+  <!-- Small Tilt marker 0 (top most) -->
+  <ImageView android:id="@+id/tilt_small_marker_0" android:src="@drawable/small_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="172px"
+    android:translationY="-82px" />
+
+  <!-- Small Tilt marker 1 -->
+  <ImageView android:id="@+id/tilt_small_marker_1" android:src="@drawable/small_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="172px"
+    android:translationY="-51px" />
+
+  <!-- Small Tilt marker 2 -->
+  <ImageView android:id="@+id/tilt_small_marker_2" android:src="@drawable/small_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="172px"
+    android:translationY="-20px" />
+
+  <!-- Small Tilt marker 3 -->
+  <ImageView android:id="@+id/tilt_small_marker_3" android:src="@drawable/small_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="172px"
+    android:translationY="11px" />
+
+  <!-- Small Tilt marker 4 -->
+  <ImageView android:id="@+id/tilt_small_marker_4" android:src="@drawable/small_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="172px"
+    android:translationY="42px" />
+
+  <!-- Small Tilt marker 5 -->
+  <ImageView android:id="@+id/tilt_small_marker_5" android:src="@drawable/small_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="172px"
+    android:translationY="73px" />
+
+  <!-- Small Tilt marker 6 (bottom most) -->
+  <ImageView android:id="@+id/tilt_small_marker_6" android:src="@drawable/small_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="172px"
+    android:translationY="105px" />
+
+
+
+  <!-- Large Tilt marker 0 (top most) -->
+  <ImageView android:id="@+id/tilt_large_marker_0" android:src="@drawable/large_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="180px"
+    android:translationY="-82px" />
+
+  <!-- Large Tilt marker 1 -->
+  <ImageView android:id="@+id/tilt_large_marker_1" android:src="@drawable/large_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="180px"
+    android:translationY="-51px" />
+
+  <!-- Large Tilt marker 2 -->
+  <ImageView android:id="@+id/tilt_large_marker_2" android:src="@drawable/large_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="180px"
+    android:translationY="-20px" />
+
+  <!-- Large Tilt marker 3 -->
+  <ImageView android:id="@+id/tilt_large_marker_3" android:src="@drawable/large_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="180px"
+    android:translationY="11px" />
+
+  <!-- Large Tilt marker 4 -->
+  <ImageView android:id="@+id/tilt_large_marker_4" android:src="@drawable/large_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="180px"
+    android:translationY="42px" />
+
+  <!-- Large Tilt marker 5 -->
+  <ImageView android:id="@+id/tilt_large_marker_5" android:src="@drawable/large_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="180px"
+    android:translationY="73px" />
+
+  <!-- Large Tilt marker 6 (bottom most) -->
+  <ImageView android:id="@+id/tilt_large_marker_6" android:src="@drawable/large_tilt_marker_3"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="180px"
+    android:translationY="105px" />
+
+
+
+
+  <!-- Horizon -->
+  <ImageView android:id="@+id/horizon" android:src="@drawable/horizon_original"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:scaleX="0.71" android:scaleY="0.7"
+    android:translationX="16px" android:translationY="27px" />
+
+
+
+
+
+
+  <!-- Zoom shell -->
+  <ImageView android:id="@+id/pan_tilt_zoom_shell" android:src="@drawable/zoom_bg"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:scaleY="0.82" android:translationY="12px" />
+
+  <!-- Top zoom in (not pressed) -->
+  <ImageView android:id="@+id/zoom_in_button_not_pressed" android:src="@drawable/zoom_in_normal"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:layout_centerInParent="true" android:translationX="-165px"
+    android:translationY="-75px" />
+
+  <!-- Top zoom out (not pressed) -->
+  <ImageView android:id="@+id/zoom_out_button_not_pressed"
+    android:src="@drawable/zoom_out_normal" android:layout_width="wrap_content"
+    android:layout_height="wrap_content" android:layout_centerInParent="true"
+    android:translationX="-165px" android:translationY="103px" />
+
+  <!-- Non-lit zoom bar 0 (top) -->
+  <ImageView android:id="@+id/zoom_bar_notlit_0" android:src="@drawable/zoom_bar_notlit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="105px" />
+
+  <!-- Non-lit zoom bar 1 -->
+  <ImageView android:id="@+id/zoom_bar_notlit_1" android:src="@drawable/zoom_bar_notlit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="130px" />
+
+  <!-- Non-lit zoom bar 2 -->
+  <ImageView android:id="@+id/zoom_bar_notlit_2" android:src="@drawable/zoom_bar_notlit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="155px" />
+
+  <!-- Non-lit zoom bar 3 -->
+  <ImageView android:id="@+id/zoom_bar_notlit_3" android:src="@drawable/zoom_bar_notlit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="180px" />
+
+  <!-- Non-lit zoom bar 4 (bottom) -->
+  <ImageView android:id="@+id/zoom_bar_notlit_4" android:src="@drawable/zoom_bar_notlit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="205px" />
+
+  <!-- Lit zoom bar 0 (top) -->
+  <ImageView android:id="@+id/zoom_bar_lit_0" android:src="@drawable/zoom_bar_lit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="105px" android:visibility="invisible" />
+
+  <!-- Lit zoom bar 1 -->
+  <ImageView android:id="@+id/zoom_bar_lit_1" android:src="@drawable/zoom_bar_lit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="130px" android:visibility="invisible" />
+
+  <!-- Lit zoom bar 2 -->
+  <ImageView android:id="@+id/zoom_bar_lit_2" android:src="@drawable/zoom_bar_lit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="155px" android:visibility="invisible" />
+
+  <!-- Lit zoom bar 3 -->
+  <ImageView android:id="@+id/zoom_bar_lit_3" android:src="@drawable/zoom_bar_lit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="180px" android:visibility="invisible" />
+
+  <!-- Lit zoom bar 4 (bottom) -->
+  <ImageView android:id="@+id/zoom_bar_lit_4" android:src="@drawable/zoom_bar_lit"
+    android:layout_width="wrap_content" android:layout_height="wrap_content"
+    android:translationX="12px" android:translationY="205px" android:visibility="invisible" />
+
+
+
+</RelativeLayout>

android/res/layout/virtual_joystick.xml

@@ -0,0 +1,194 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+  android:layout_width="fill_parent" android:layout_height="fill_parent"
+  android:id="@+id/virtual_joystick_layout">
+
+  <!-- The black backgroud on which all the other images will be displayed. -->
+  <ImageView android:id="@+id/black_background" android:layout_width="fill_parent"
+    android:layout_height="fill_parent" android:src="@drawable/black_background"
+    android:layout_centerInParent="true" />
+
+  <!-- Outer ring representing the maximum magnitude. -->
+  <ImageView android:id="@+id/outer_ring" android:layout_width="fill_parent"
+    android:layout_height="fill_parent" android:src="@drawable/grey_ring_notched"
+    android:layout_centerInParent="true"></ImageView>
+
+  <!-- The intensity circle representing current magnitude. -->
+  <ImageView android:id="@+id/intensity" android:src="@drawable/intensity"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"></ImageView>
+
+  <!-- Magnitude text display -->
+  <TextView android:id="@+id/magnitude" android:layout_width="wrap_content"
+    android:layout_height="wrap_content" android:layout_centerInParent="true"
+    android:textSize="15px" android:text="0%" />
+
+  <!-- 0 degree marker -->
+  <ImageView android:id="@+id/widget_0_degrees" android:src="@drawable/large_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"></ImageView>
+
+  <!-- 15 degree marker -->
+  <ImageView android:id="@+id/widget_15_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="15.0" />
+
+  <!-- 30 degree marker -->
+  <ImageView android:id="@+id/widget_30_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="30.0" />
+
+  <!-- 45 degree marker -->
+  <ImageView android:id="@+id/widget_45_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="45.0" />
+
+  <!-- 60 degree marker -->
+  <ImageView android:id="@+id/widget_60_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="60.0" />
+
+  <!-- 75 degree marker -->
+  <ImageView android:id="@+id/widget_75_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="75.0" />
+
+  <!-- 90 degree marker -->
+  <ImageView android:id="@+id/widget_90_degrees" android:src="@drawable/large_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="90.0" />
+
+  <!-- 105 degree marker -->
+  <ImageView android:id="@+id/widget_105_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="105.0" />
+
+  <!-- 120 degree marker -->
+  <ImageView android:id="@+id/widget_120_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="120.0" />
+
+  <!-- 135 degree marker -->
+  <ImageView android:id="@+id/widget_135_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="135.0" />
+
+  <!-- 150 degree marker -->
+  <ImageView android:id="@+id/widget_150_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="150.0" />
+
+  <!-- 165 degree marker -->
+  <ImageView android:id="@+id/widget_165_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="165.0" />
+
+  <!-- 180 degree marker -->
+  <ImageView android:id="@+id/widget_180_degrees" android:src="@drawable/large_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="180.0" />
+
+  <!-- 195 degree marker -->
+  <ImageView android:id="@+id/widget_195_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="195.0" />
+
+  <!-- 210 degree marker -->
+  <ImageView android:id="@+id/widget_210_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="210.0" />
+
+  <!-- 225 degree marker -->
+  <ImageView android:id="@+id/widget_225_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="225.0" />
+
+  <!-- 240 degree marker -->
+  <ImageView android:id="@+id/widget_240_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="240.0" />
+
+  <!-- 255 degree marker -->
+  <ImageView android:id="@+id/widget_255_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="255.0" />
+
+  <!-- 270 degree marker -->
+  <ImageView android:id="@+id/widget_270_degrees" android:src="@drawable/large_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="270.0" />
+
+  <!-- 285 degree marker -->
+  <ImageView android:id="@+id/widget_285_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="285.0" />
+
+  <!-- 300 degree marker -->
+  <ImageView android:id="@+id/widget_300_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="300.0" />
+
+  <!-- 315 degree marker -->
+  <ImageView android:id="@+id/widget_315_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="315.0" />
+
+  <!-- 330 degree marker -->
+  <ImageView android:id="@+id/widget_330_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="330.0" />
+
+  <!-- 345 degree marker -->
+  <ImageView android:id="@+id/widget_345_degrees" android:src="@drawable/small_d_widget_3"
+    android:layout_width="fill_parent" android:layout_height="fill_parent"
+    android:layout_centerInParent="true" android:antialias="true"
+    android:rotation="345.0" />
+
+  <ImageView android:id="@+id/top_angle_slice" android:layout_height="fill_parent"
+    android:layout_width="fill_parent" android:src="@drawable/top_angle_slice"
+    android:layout_centerInParent="true"></ImageView>
+
+  <ImageView android:id="@+id/mid_angle_slice" android:layout_height="fill_parent"
+    android:layout_width="fill_parent" android:src="@drawable/mid_angle_slice"
+    android:layout_centerInParent="true" android:alpha="0.5"></ImageView>
+
+
+  <!-- Previous velocity divet -->
+  <ImageView android:id="@+id/previous_velocity_divet" android:src="@drawable/previous_velocity"
+    android:layout_centerInParent="true" android:layout_width="wrap_content"
+    android:layout_height="wrap_content" android:antialias="true" />
+
+  <!-- The size of the center divet should always remain the same, since it's supposed 
+    to represent a deadzone that is dependent on the size of a human finger. -->
+  <ImageView android:id="@+id/center_divet" android:layout_height="wrap_content"
+    android:layout_width="wrap_content" android:src="@drawable/center_widget"
+    android:layout_centerInParent="true"></ImageView>
+
+  <!-- Thumb divet -->
+  <ImageView android:id="@+id/thumb_divet" android:src="@drawable/directional_arrow"
+    android:layout_centerInParent="true" android:layout_width="wrap_content"
+    android:layout_height="wrap_content" android:antialias="true" />
+
+</RelativeLayout>

android/src/org/ros/rosjava/android/views/DistancePoints.java

@@ -0,0 +1,241 @@
+/*
+ * 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.rosjava.android.views;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * Helper function for the DistanceRenderer that creates the polygons, lines,
+ * points, etc based on the received data.
+ * 
+ * @author munjaldesai@google.com (Munjal Desai)
+ */
+class DistancePoints {
+  // Members for displaying the range vertices and polygons.
+  private FloatBuffer rangeVertexBuffer;
+  private ByteBuffer rangeVertexByteBuffer;
+  private List<Float> rangeVertices = new ArrayList<Float>();
+  private float[] rangeVertexArray = new float[0];
+  private int rangeVertexCount;
+  // Members for showing the robot shape.
+  private FloatBuffer robotVertexBuffer;
+  private int robotVertexCount;
+  // Members for showing the reference markers.
+  private FloatBuffer referenceVertexBuffer;
+
+  public DistancePoints() {
+    initRobot();
+    initReferenceMarker();
+  }
+
+  /**
+   * Updates the range buffer for displaying the polygons and the points based
+   * on incoming range data.
+   */
+  public void updateRange(List<Float> range, float maxRange, float minRange, float minimumTheta,
+      float thetaIncrement) {
+    // Clear the previous values.
+    rangeVertices.clear();
+    // The 90 degrees need to be added to offset the orientation differences
+    // between the ROS coordinate system and the one used by OpenGL.
+    minimumTheta += Math.toRadians(90.0);
+    // Adding the center coordinate since it's needed for GL10.GL_TRIANGLE_FAN
+    // to render the range polygons.
+    rangeVertices.add(0.0f);
+    rangeVertices.add(0.0f);
+    rangeVertices.add(0.0f);
+    // Calculate the coordinates for the range points. If the range is out of
+    // bounds then do not display them.
+    for (float rangeValue : range) {
+      // Display the point if it's within the min and max valid range.
+      if (rangeValue < maxRange && rangeValue > minRange) {
+        // x
+        rangeVertices.add((float) (rangeValue * Math.cos(minimumTheta)));
+        // y
+        rangeVertices.add((float) (rangeValue * Math.sin(minimumTheta)));
+        // z
+        rangeVertices.add(0.0f);
+      }
+      // Increment the theta for the next iteration.
+      minimumTheta += thetaIncrement;
+    }
+    if (rangeVertexArray.length != rangeVertices.size()) {
+      rangeVertexArray = new float[rangeVertices.size()];
+    }
+    // Move the contents of the List to the array.
+    for (int i = 0; i < rangeVertices.size(); i++) {
+      rangeVertexArray[i] = rangeVertices.get(i);
+    }
+    rangeVertexCount = rangeVertexArray.length / 3;
+    // Update the buffers with the latest coordinates.
+    rangeVertexByteBuffer = ByteBuffer.allocateDirect(rangeVertices.size() * Float.SIZE / 8);
+    rangeVertexByteBuffer.order(ByteOrder.nativeOrder());
+    rangeVertexBuffer = rangeVertexByteBuffer.asFloatBuffer();
+    rangeVertexBuffer.put(rangeVertexArray);
+    rangeVertexBuffer.position(0);
+  }
+
+  /**
+   * Draws the open region in light gray and the objects seen by the laser in
+   * red.
+   * 
+   * @param gl
+   *          The GL interface.
+   */
+  public void drawRange(GL10 gl) {
+    try {
+      gl.glDisable(GL10.GL_CULL_FACE);
+      gl.glFrontFace(GL10.GL_CW);
+      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, rangeVertexBuffer);
+      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glColor4f(0.35f, 0.35f, 0.35f, 0.7f);
+      // Draw the vertices as triangle strip
+      gl.glDrawArrays(GL10.GL_TRIANGLE_FAN, 0, rangeVertexCount);
+      gl.glPointSize(3);
+      gl.glColor4f(0.8f, 0.1f, 0.1f, 1f);
+      // Draw the vertices as points.
+      gl.glDrawArrays(GL10.GL_POINTS, 1, rangeVertexCount - 1);
+      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+    } catch (NullPointerException npe) {
+      // Don't care.
+    }
+  }
+
+  /**
+   * Draws the reference markers that show the current scale or zoom.
+   * 
+   * @param gl
+   *          The GL interface.
+   */
+  public void drawReferenceMarker(GL10 gl) {
+    gl.glEnable(GL10.GL_LINE_SMOOTH);
+    gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+    gl.glVertexPointer(3, GL10.GL_FLOAT, 0, referenceVertexBuffer);
+    gl.glColor4f(0.7f, 0.7f, 0.7f, 1f);
+    // Hard coding the number of vertices since the count will not change
+    // dynamically.
+    gl.glDrawArrays(GL10.GL_LINES, 0, 10);
+    gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+    gl.glDisable(GL10.GL_LINE_SMOOTH);
+  }
+
+  /**
+   * Draws the robot.
+   * 
+   * @param gl
+   *          The GL interface.
+   */
+  public void drawRobot(GL10 gl) {
+    gl.glEnable(GL10.GL_LINE_SMOOTH);
+    gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+    gl.glVertexPointer(3, GL10.GL_FLOAT, 0, robotVertexBuffer);
+    gl.glColor4f(0.6f, 0, 0, 1f);
+    gl.glDrawArrays(GL10.GL_LINE_LOOP, 0, robotVertexCount);
+    gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+    gl.glDisable(GL10.GL_LINE_SMOOTH);
+  }
+
+  private void initRobot() {
+    float[] robotVertices = new float[4 * 3];
+    // TODO: The size of the robot is hard coded right now. Once the
+    // transformations library is implemented, the shape of the robot should be
+    // based on footprint of the robot.
+    // Manually entering the coordinates for the robot. (The turtlebot is 1.1
+    // square feet).
+    // Top right
+    robotVertices[0] = 0.1651f;
+    robotVertices[1] = 0.1651f;
+    robotVertices[2] = 0.0f;
+    // Bottom right
+    robotVertices[3] = 0.1651f;
+    robotVertices[4] = -0.1651f;
+    robotVertices[5] = 0.0f;
+    // Bottom left
+    robotVertices[6] = -0.1651f;
+    robotVertices[7] = -0.1651f;
+    robotVertices[8] = 0.0f;
+    // Top left
+    robotVertices[9] = -0.1651f;
+    robotVertices[10] = 0.1651f;
+    robotVertices[11] = 0.0f;
+    robotVertexCount = robotVertices.length / 3;
+    // Load the coordinates into the buffer.
+    ByteBuffer vertexByteBuffer = ByteBuffer.allocateDirect(robotVertices.length * Float.SIZE / 8);
+    vertexByteBuffer.order(ByteOrder.nativeOrder());
+    robotVertexBuffer = vertexByteBuffer.asFloatBuffer();
+    robotVertexBuffer.put(robotVertices);
+    robotVertexBuffer.position(0);
+  }
+
+  private void initReferenceMarker() {
+    float[] referenceVertices = new float[10 * 3];
+    float yOffset = -2f;
+    float yDelta = 0.25f;
+    // Horizontal line left point.
+    referenceVertices[0] = -1.5f;
+    referenceVertices[1] = yOffset;
+    referenceVertices[2] = 0f;
+    // Horizontal line right point.
+    referenceVertices[3] = 1.5f;
+    referenceVertices[4] = yOffset;
+    referenceVertices[5] = 0f;
+    // Vertical line (first from left) top.
+    referenceVertices[6] = -1.5f;
+    referenceVertices[7] = yOffset - yDelta;
+    referenceVertices[8] = 0f;
+    // Vertical line (first from left) bottom.
+    referenceVertices[9] = -1.5f;
+    referenceVertices[10] = yOffset + yDelta;
+    referenceVertices[11] = 0f;
+    // Vertical line (second from left) top.
+    referenceVertices[12] = -0.5f;
+    referenceVertices[13] = yOffset - yDelta;
+    referenceVertices[14] = 0f;
+    // Vertical line (second from left) bottom.
+    referenceVertices[15] = -0.5f;
+    referenceVertices[16] = yOffset + yDelta;
+    referenceVertices[17] = 0f;
+    // Vertical line (third from left) top.
+    referenceVertices[18] = 0.5f;
+    referenceVertices[19] = yOffset - yDelta;
+    referenceVertices[20] = 0f;
+    // Vertical line (third from left) bottom.
+    referenceVertices[21] = 0.5f;
+    referenceVertices[22] = yOffset + yDelta;
+    referenceVertices[23] = 0f;
+    // Vertical line (fourth from left) top.
+    referenceVertices[24] = 1.5f;
+    referenceVertices[25] = yOffset - yDelta;
+    referenceVertices[26] = 0f;
+    // Vertical line (fourth from left) bottom.
+    referenceVertices[27] = 1.5f;
+    referenceVertices[28] = yOffset + yDelta;
+    referenceVertices[29] = 0f;
+    ByteBuffer referenceVertexByteBuffer =
+        ByteBuffer.allocateDirect(referenceVertices.length * Float.SIZE / 8);
+    referenceVertexByteBuffer.order(ByteOrder.nativeOrder());
+    referenceVertexBuffer = referenceVertexByteBuffer.asFloatBuffer();
+    referenceVertexBuffer.put(referenceVertices);
+    referenceVertexBuffer.position(0);
+  }
+}

android/src/org/ros/rosjava/android/views/DistanceRenderer.java

@@ -0,0 +1,283 @@
+/*
+ * 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.rosjava.android.views;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.opengl.GLSurfaceView;
+import android.opengl.GLU;
+import android.preference.PreferenceManager;
+
+import java.util.List;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * The OpenGL renderer that creates and manages the surface.
+ * 
+ * @author munjaldesai@google.com (Munjal Desai)
+ */
+class DistanceRenderer implements GLSurfaceView.Renderer {
+
+  /**
+   * The minimum distance that must be visible in the distance view. A value of
+   * {@value #MIN_FOV_DISTANCE} indicates that the distance view will at least
+   * show objects within {@link #MIN_FOV_DISTANCE}/2 meters above, below, to the
+   * left, and to the right of the robot.
+   */
+  private static final float MIN_FOV_DISTANCE = 3f;
+  /**
+   * The same as {@link #MIN_FOV_DISTANCE} except limits the maximum area around
+   * the robot that will be shown.
+   */
+  private static final float MAX_FOV_DISTANCE = 8f;
+  /**
+   * The distance from the origin (0,0,0) on the z-axis for the camera to be
+   * placed to see {@value #MIN_FOV_DISTANCE} around the robot.X The value is
+   * calculated based on simple trigonometry ( {@value #MIN_FOV_DISTANCE}
+   * /tan(30)). 60 degrees being the field of view of the camera. This is used
+   * to save some computation, since this boundary condition occurs often.
+   */
+  private static final float MIN_DISTANCE_ZOOM = -5.196152424f;
+  /**
+   * Similar concept as {@link #MIN_DISTANCE_ZOOM}.
+   */
+  private static final float MAX_DISTANCE_ZOOM = -13.856406465f;
+  /**
+   * The field of view of the camera in degrees.
+   */
+  private static final float DISTANCE_VIEW_FIELD_OF_VIEW = 60f;
+  /**
+   * Value to be multiplied with the opposite side (distance from the center of
+   * the view that must be visible) of the triangle to get the adjacent side of
+   * the triangle (distance of the camera from the origin).
+   */
+  private static final double DISTANCE_VIEW_ZOOM_MULTIPLIER = 1 / Math.tan(Math
+      .toRadians(DISTANCE_VIEW_FIELD_OF_VIEW / 2));
+  /**
+   * The key used to save the state of {@link #zoomLocked} in shared
+   * preferences.
+   */
+  private static final String DISTANCE_VIEW_ZOOM_LOCK_KEY = "DISTANCE_VIEW_ZOOM_LOCK";
+  /**
+   * The key used to save the state of {@link #zoomMode} in shared preferences.
+   */
+  private static final String DISTANCE_VIEW_ZOOM_MODE_KEY = "DISTANCE_VIEW_ZOOM_MODE";
+  /**
+   * The key used to save the state of {@link #zoom} in shared preferences.
+   */
+  private static final String DISTANCE_VIEW_ZOOM_VALUE_KEY = "DISTANCE_VIEW_ZOOM_VALUE";
+  /**
+   * Instance of the helper class that draws the sensor values.
+   */
+  private DistancePoints rangeLines;
+  /**
+   * The amount of rotation (in degrees) applied to the camera.
+   * 
+   * TODO: This must be updated based on the current pan of the front facing
+   * camera used to navigate.
+   */
+  private float theta;
+  /**
+   * The amount of zoom. The value for {@link #zoom} represents the distance
+   * between the camera and the plane on which the points are rendered.
+   */
+  private float zoom = MAX_DISTANCE_ZOOM;
+  /**
+   * The current mode of zoom for the view.
+   */
+  private ZoomMode zoomMode = ZoomMode.CLUTTER_ZOOM_MODE;
+  /**
+   * True when zooming is disabled and false otherwise.
+   */
+  private boolean zoomLocked;
+  private SharedPreferences sharedPreferences;
+  private SharedPreferences.Editor editor;
+
+  @Override
+  public void onSurfaceChanged(GL10 gl, int w, int h) {
+    gl.glViewport(0, 0, w, h);
+    gl.glMatrixMode(GL10.GL_PROJECTION);
+    gl.glLoadIdentity();
+    GLU.gluPerspective(gl, DISTANCE_VIEW_FIELD_OF_VIEW, (float) w / (float) h, 0.1f, 100.0f);
+    gl.glMatrixMode(GL10.GL_MODELVIEW);
+    gl.glLoadIdentity();
+    gl.glHint(GL10.GL_POLYGON_SMOOTH_HINT, GL10.GL_NICEST);
+  }
+
+  @Override
+  public void onSurfaceCreated(GL10 gl, EGLConfig arg1) {
+    gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
+    rangeLines = new DistancePoints();
+  }
+
+  @Override
+  public void onDrawFrame(GL10 gl) {
+    gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
+    gl.glLoadIdentity();
+    // Move the camera up/down based on desired zoom level.
+    gl.glTranslatef(0, 0, zoom);
+    // Draw the distance triangles.
+    rangeLines.drawRange(gl);
+    // Draw the reference lines.
+    rangeLines.drawReferenceMarker(gl);
+    // Draw the robot.
+    rangeLines.drawRobot(gl);
+    gl.glRotatef(theta, 0, 0, -1f);
+  }
+
+  /**
+   * Rotate the entire display.
+   * 
+   * @param theta
+   *          The amount in degrees by which the display should be rotated.
+   */
+  public void setRotation(float theta) {
+    this.theta = theta;
+  }
+
+  /**
+   * Updates the zoom distance based on the normalized value if the
+   * {@link #zoomMode} is set to CUSTOM_ZOOM_MODE.
+   * 
+   * @param normalizedZoomValue
+   *          The zoom value between 0 and 1.
+   */
+  public void setNormalizedZoom(float normalizedZoomValue) {
+    if (zoomMode == ZoomMode.CUSTOM_ZOOM_MODE) {
+      setZoom((1 - normalizedZoomValue) * (MAX_FOV_DISTANCE - MIN_FOV_DISTANCE) + MIN_FOV_DISTANCE);
+    }
+  }
+
+  /**
+   * Sets the zoom mode.
+   */
+  public void setZoomMode(ZoomMode mode) {
+    zoomMode = mode;
+  }
+
+  /**
+   * Prevent the zoom level to be changed.
+   */
+  public void lockZoom() {
+    zoomLocked = true;
+  }
+
+  /**
+   * Allow the zoom level to be changed.
+   */
+  public void unlockZoom() {
+    zoomLocked = false;
+  }
+
+  /**
+   * If {@link #zoomMode} if set to VELOCITY_ZOOM_MODE, {@link #zoom} is changed
+   * based on the normalized linear velocity.
+   * 
+   * @param speed
+   *          Linear velocity between 1 and -1;
+   */
+  public void currentSpeed(double speed) {
+    if (zoomMode == ZoomMode.VELOCITY_ZOOM_MODE) {
+      setZoom((float) (Math.abs(speed) * ((MAX_FOV_DISTANCE - MIN_FOV_DISTANCE) + MIN_FOV_DISTANCE)));
+    }
+  }
+
+  /**
+   * The new range values are forwarded to {@link #rangeLines} and if
+   * {@link #zoomMode} is set to CLUTTER_ZOOM_MODE then {@link #zoom} is based
+   * on the distance to the closest object around the robot.
+   * 
+   * @param range
+   *          New set of range values.
+   * @param maxRange
+   *          Maximum range to be considered valid.
+   * @param minRange
+   *          Minimum range to be considered valid.
+   * @param minTh
+   *          The starting theta for the range values.
+   * @param thIncrement
+   *          The delta between incremental range scans.
+   * @param minDistToObject
+   *          The distance to the closest object.
+   */
+  public void updateRange(List<Float> range, float maxRange, float minRange, float minTh,
+      float thIncrement, float minDistToObject) {
+    if (zoomMode == ZoomMode.CLUTTER_ZOOM_MODE) {
+      // The closest object should be at the 80% of FOV mark.
+      setZoom(minDistToObject * 1.25f);
+    }
+    // Update the distance ranges based on the incoming data.
+    rangeLines.updateRange(range, maxRange, minRange, minTh, thIncrement);
+  }
+
+  /**
+   * Reads the settings stored in {@link #sharedPreferences} and applies them.
+   * 
+   * @param context
+   *          The context of the application calling this.
+   */
+  public void loadPreferences(Context context) {
+    sharedPreferences = PreferenceManager.getDefaultSharedPreferences(context);
+    int tmpMode =
+        sharedPreferences.getInt(DISTANCE_VIEW_ZOOM_MODE_KEY, ZoomMode.CUSTOM_ZOOM_MODE.ordinal());
+    if (tmpMode == ZoomMode.CUSTOM_ZOOM_MODE.ordinal()) {
+      zoomMode = ZoomMode.CUSTOM_ZOOM_MODE;
+    } else if (tmpMode == ZoomMode.CLUTTER_ZOOM_MODE.ordinal()) {
+      zoomMode = ZoomMode.CLUTTER_ZOOM_MODE;
+    } else if (tmpMode == ZoomMode.VELOCITY_ZOOM_MODE.ordinal()) {
+      zoomMode = ZoomMode.VELOCITY_ZOOM_MODE;
+    }
+    zoomLocked = sharedPreferences.getBoolean(DISTANCE_VIEW_ZOOM_LOCK_KEY, false);
+    editor = sharedPreferences.edit();
+  }
+
+  /**
+   * Saves the existing settings in {@link #sharedPreferences} via the
+   * {@link #editor}.
+   * 
+   * @param context
+   *          The context of the application calling this.
+   */
+  public void savePreferences(Context context) {
+    editor = sharedPreferences.edit();
+    editor.putInt(DISTANCE_VIEW_ZOOM_MODE_KEY, zoomMode.ordinal());
+    editor.putFloat(DISTANCE_VIEW_ZOOM_VALUE_KEY, zoom);
+    editor.putBoolean(DISTANCE_VIEW_ZOOM_LOCK_KEY, zoomLocked);
+    editor.apply();
+  }
+
+  /**
+   * Calculate the height of the camera based on the desired field of view.
+   * 
+   * @param distanceFromCenter
+   *          The region around the robot (in meters) that must be visible.
+   */
+  private void setZoom(float distanceFromCenter) {
+    if (!zoomLocked) {
+      // Bounds checking.
+      if (distanceFromCenter < MIN_FOV_DISTANCE) {
+        zoom = MIN_DISTANCE_ZOOM;
+      } else if (distanceFromCenter > MAX_FOV_DISTANCE) {
+        zoom = MAX_DISTANCE_ZOOM;
+      } else {
+        zoom = (float) (-distanceFromCenter * DISTANCE_VIEW_ZOOM_MULTIPLIER);
+      }
+    }
+  }
+}

android/src/org/ros/rosjava/android/views/DistanceView.java

@@ -0,0 +1,231 @@
+/*
+ * 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.rosjava.android.views;
+
+import com.google.common.base.Preconditions;
+
+import android.content.Context;
+import android.graphics.PixelFormat;
+import android.opengl.GLSurfaceView;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnTouchListener;
+import org.ros.message.MessageListener;
+import org.ros.message.geometry_msgs.Twist;
+import org.ros.message.sensor_msgs.LaserScan;
+import org.ros.node.DefaultNodeFactory;
+import org.ros.node.Node;
+import org.ros.node.NodeConfiguration;
+import org.ros.node.NodeMain;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * An OpenGL view that displayed data from a laser scanner (or similar sensors
+ * like a kinect). This view can zoom in/out based in one of three modes. The
+ * user can change the zoom level through a pinch/reverse-pinch, the zoom level
+ * can auto adjust based on the speed of the robot, and the zoom level can also
+ * auto adjust based on the distance to the closest object around the robot.
+ * 
+ * @author munjaldesai@google.com (Munjal Desai)
+ */
+public class DistanceView extends GLSurfaceView implements OnTouchListener, NodeMain,
+    MessageListener<org.ros.message.sensor_msgs.LaserScan> {
+
+  /**
+   * Topic for the distance scans that this view subscribes to.
+   */
+  private String laserTopic;
+  /**
+   * Distance between 2 contacts on the view (in pixels). Used while zooming
+   * in/out.
+   */
+  private double contactDistance;
+  /**
+   * Zoom value between 1 and 0. 1 represents maximum zoom in and 0 maximum zoom
+   * out.
+   */
+  private double normalizedZoomValue;
+  /**
+   * An instance of {@link DistanceRenderer} that implements
+   * {@link GLSurfaceView.Renderer} and is used to render the distance view.
+   */
+  private DistanceRenderer distanceRenderer;
+  private Node node;
+
+  /**
+   * Initialize the rendering surface.
+   * 
+   * @param context
+   */
+  public DistanceView(Context context) {
+    super(context);
+    distanceRenderer = new DistanceRenderer();
+    setEGLConfigChooser(8, 8, 8, 8, 16, 0);
+    getHolder().setFormat(PixelFormat.TRANSLUCENT);
+    setZOrderOnTop(true);
+    setRenderer(distanceRenderer);
+    // This is important since the display needs to be updated only when new
+    // data is received.
+    setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
+  }
+
+  /**
+   * Sets the topic that the distance view node should subscribe to.
+   * 
+   * @param topicName
+   *          Name of the ROS topic.
+   */
+  public void setTopicName(String topicName) {
+    this.laserTopic = topicName;
+  }
+
+  @Override
+  public void main(NodeConfiguration nodeConfiguration) throws Exception {
+    if (node == null) {
+      Preconditions.checkNotNull(nodeConfiguration);
+    }
+    node = new DefaultNodeFactory().newNode("android/distance_view", nodeConfiguration);
+    // Subscribe to the laser scans.
+    node.newSubscriber(laserTopic, "sensor_msgs/LaserScan", this);
+    // Subscribe to the command velocity. This is needed for auto adjusting the
+    // zoom in ZoomMode.VELOCITY_ZOOM_MODE mode.
+    node.newSubscriber("cmd_vel", "geometry_msgs/Twist", new MessageListener<Twist>() {
+      @Override
+      public void onNewMessage(final Twist robotVelocity) {
+        post(new Runnable() {
+          @Override
+          public void run() {
+            distanceRenderer.currentSpeed(robotVelocity.linear.x);
+          }
+        });
+      }
+    });
+    setOnTouchListener(this);
+    // Load the last saved setting.
+    distanceRenderer.loadPreferences(this.getContext());
+  }
+
+  @Override
+  public void shutdown() {
+    Preconditions.checkNotNull(node);
+    node.shutdown();
+    node = null;
+    // Save the existing settings before exiting.
+    distanceRenderer.savePreferences(this.getContext());
+  }
+
+  @Override
+  public void onNewMessage(final LaserScan message) {
+    queueEvent(new Runnable() {
+      @Override
+      public void run() {
+        List<Float> outRanges = new ArrayList<Float>();
+        float minDistToObject = message.range_max;
+        // Find the distance to the closest object and also create an List
+        // for the ranges.
+        for (float range : message.ranges) {
+          outRanges.add(range);
+          minDistToObject = (minDistToObject > range) ? range : minDistToObject;
+        }
+        // Update the renderer with the latest range values.
+        distanceRenderer.updateRange(outRanges, message.range_max, message.range_min,
+            message.angle_min, message.angle_increment, minDistToObject);
+        // Request to render the surface.
+        requestRender();
+      }
+    });
+  }
+
+  /**
+   * Sets the zoom mode to one of the modes in {@link ZoomMode}.
+   * 
+   * @param mode
+   *          The zoom mode that must be set.
+   */
+  public void setZoomMode(ZoomMode mode) {
+    distanceRenderer.setZoomMode(mode);
+  }
+
+  /**
+   * Prevents changes to the zoom level.
+   */
+  public void lockZoom() {
+    distanceRenderer.lockZoom();
+  }
+
+  /**
+   * Unlocks the zoom allowing it to be changed.
+   */
+  public void unlockZoom() {
+    distanceRenderer.unlockZoom();
+  }
+
+  /**
+   * Updates the current speed in {@link #distanceRenderer} which then can
+   * adjust the zoom level in velocity mode.
+   * 
+   * @param speed
+   *          The linear velocity of the robot.
+   */
+  public void currentSpeed(double speed) {
+    distanceRenderer.currentSpeed(speed);
+  }
+
+  @Override
+  public boolean onTouch(View v, MotionEvent event) {
+    final int action = event.getAction();
+    switch (action & MotionEvent.ACTION_MASK) {
+      case MotionEvent.ACTION_MOVE: {
+        // Only zoom when there are exactly 2 contacts on the view.
+        if (event.getPointerCount() == 2) {
+          // Get the current distance between the 2 contacts.
+          double currentContactDistance =
+              calculateDistance(event.getX(0), event.getY(0), event.getX(1), event.getY(1));
+          // Calculate the delta between the current contact location and the
+          // previous contact locations. Then add (a fraction of) that delta to
+          // the existing normalized value for zoom.
+          // Using half the width of the view provides an appropriate level of
+          // sensitivity while zooming.
+          normalizedZoomValue += (currentContactDistance - contactDistance) / (this.getWidth() / 2);
+          if (normalizedZoomValue > 1) {
+            normalizedZoomValue = 1;
+          } else if (normalizedZoomValue < 0) {
+            normalizedZoomValue = 0;
+          }
+          distanceRenderer.setNormalizedZoom((float) normalizedZoomValue);
+          // Remember the current distance between coordinates for later.
+          contactDistance = currentContactDistance;
+        }
+        break;
+      }
+        // When the second contact touches the screen initialize contactDistance
+        // for the immediate round of interaction.
+      case MotionEvent.ACTION_POINTER_1_DOWN: {
+        contactDistance =
+            calculateDistance(event.getX(0), event.getY(0), event.getX(1), event.getY(1));
+        break;
+      }
+    }
+    return true;
+  }
+
+  private double calculateDistance(float x1, float y1, float x2, float y2) {
+    return Math.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
+  }
+}

android/src/org/ros/rosjava/android/views/MapPoints.java

@@ -0,0 +1,649 @@
+/*
+ * 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.rosjava.android.views;
+
+import android.graphics.Point;
+import org.ros.message.geometry_msgs.Pose;
+import org.ros.message.geometry_msgs.Quaternion;
+import org.ros.message.nav_msgs.OccupancyGrid;
+import org.ros.message.nav_msgs.Path;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.FloatBuffer;
+import java.nio.ShortBuffer;
+import java.util.ArrayList;
+import java.util.List;
+
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * The helper function that draws the various aspect of the map.
+ * 
+ * @author munjaldesai@google.com (Munjal Desai)
+ * 
+ *         TODO(munjaldesai): The robot size should be drawn based on the robot
+ *         radius or the footprint published.
+ */
+class MapPoints {
+  /**
+   * The largest number that can be represented by an unsigned short.
+   */
+  private static final int UNSIGNED_SHORT_MAX = 65535;
+  /**
+   * Vertices for the empty region.
+   */
+  private FloatBuffer emptyVertexBuffer;
+  /**
+   * Vertices for the occupied region.
+   */
+  private FloatBuffer occupiedVertexBuffer;
+  /**
+   * Indices of the vertices for the robot's shape.
+   */
+  private ShortBuffer robotIndexBuffer;
+  /**
+   * Vertices for the robot's shape.
+   */
+  private FloatBuffer robotVertexBuffer;
+  /**
+   * Vertices for the robot's outline used while zoomed out.
+   */
+  private FloatBuffer robotOutlineVertexBuffer;
+  /**
+   * Vertices for the current goal shape.
+   */
+  private FloatBuffer currentGoalVertexBuffer;
+  /**
+   * Vertices for the shape used when the user specifies a destination.
+   */
+  private FloatBuffer userGoalVertexBuffer;
+  /**
+   * Vertices for the path.
+   */
+  private FloatBuffer pathVertexBuffer;
+  /**
+   * Vertices for the lines used to show the region selected for annotation.
+   */
+  private FloatBuffer regionVertexBuffer;
+  /**
+   * True when the vertex and index buffers have been initialized.
+   */
+  private boolean ready;
+  private int robotIndexCount;
+  private int goalIndexCount;
+  private int pathIndexCount;
+  private int robotOutlineIndexCount;
+  private Pose robotPose = new Pose();
+  private Pose currentGoalPose = new Pose();
+  private Pose userGoalPose = new Pose();
+  private float robotTheta;
+  private float currentGoalTheta;
+  private float userGoalTheta;
+  private int totalEmptyCells;
+  private int totalOccupiedCells;
+
+  /**
+   * Creates a new set of points to render based on the incoming occupancy grid.
+   * 
+   * @param newMap
+   *          OccupancyGrid representing the map data.
+   */
+  public void updateMap(OccupancyGrid newMap) {
+    List<Float> emptyVertices = new ArrayList<Float>();
+    List<Float> occupiedVertices = new ArrayList<Float>();
+    int occupancyGridState = 0;
+    // Reset the count of empty and occupied cells.
+    totalOccupiedCells = 0;
+    totalEmptyCells = 0;
+    // Iterate over all the cells in the map.
+    for (int h = 0; h < newMap.info.height; h++) {
+      for (int w = 0; w < newMap.info.width; w++) {
+        occupancyGridState = newMap.data[(int) (newMap.info.width * h + w)];
+        // If the cell is empty.
+        if (occupancyGridState == 0) {
+          // Add the coordinates of the cell to the empty list.
+          emptyVertices.add((float) w);
+          emptyVertices.add((float) h);
+          emptyVertices.add(0f);
+          totalEmptyCells++;
+        } // If the cell is occupied.
+        else if (occupancyGridState == 100) {
+          // Add the coordinates of the cell to the occupied list.
+          occupiedVertices.add((float) w);
+          occupiedVertices.add((float) h);
+          occupiedVertices.add(0f);
+          totalOccupiedCells++;
+        }
+      }
+    }
+    // Convert the Lists to arrays.
+    float[] emptyFloatArray = new float[emptyVertices.size()];
+    for (int i = 0; i < emptyFloatArray.length; i++) {
+      emptyFloatArray[i] = emptyVertices.get(i);
+    }
+    float[] occupiedFloatArray = new float[occupiedVertices.size()];
+    for (int i = 0; i < occupiedFloatArray.length; i++) {
+      occupiedFloatArray[i] = occupiedVertices.get(i);
+    }
+    // Move the data from the float arrays to byte buffers for OpenGL
+    // consumption.
+    ByteBuffer emptyVertexByteBuffer =
+        ByteBuffer.allocateDirect(emptyVertices.size() * Float.SIZE / 8);
+    emptyVertexByteBuffer.order(ByteOrder.nativeOrder());
+    emptyVertexBuffer = emptyVertexByteBuffer.asFloatBuffer();
+    emptyVertexBuffer.put(emptyFloatArray);
+    emptyVertexBuffer.position(0);
+    ByteBuffer occupiedVertexByteBuffer =
+        ByteBuffer.allocateDirect(occupiedVertices.size() * Float.SIZE / 8);
+    occupiedVertexByteBuffer.order(ByteOrder.nativeOrder());
+    occupiedVertexBuffer = occupiedVertexByteBuffer.asFloatBuffer();
+    occupiedVertexBuffer.put(occupiedFloatArray);
+    occupiedVertexBuffer.position(0);
+    // Initialize the other components of the OpenGL display (if needed).
+    if (!ready) {
+      initRobot();
+      initRobotOutline();
+      initCurrentGoal();
+      initUserGoal();
+      initPath();
+      setRegion(0, 0, 0, 0);
+      ready = true;
+    }
+  }
+
+  /**
+   * Creates a new set of points to render. These points represent the path
+   * generated by the navigation planner.
+   * 
+   * @param path
+   *          The path generated by the planner.
+   * @param res
+   *          The resolution of the current map.
+   */
+  public void updatePath(Path path, float res) {
+    float[] pathVertices = new float[path.poses.size() * 3];
+    // Add the path coordinates to the array.
+    for (int i = 0; i < path.poses.size(); i++) {
+      pathVertices[i * 3] = (float) path.poses.get(i).pose.position.x / res;
+      pathVertices[i * 3 + 1] = (float) path.poses.get(i).pose.position.y / res;
+      pathVertices[i * 3 + 2] = 0f;
+    }
+    ByteBuffer pathVertexByteBuffer =
+        ByteBuffer.allocateDirect(pathVertices.length * Float.SIZE / 8);
+    pathVertexByteBuffer.order(ByteOrder.nativeOrder());
+    pathVertexBuffer = pathVertexByteBuffer.asFloatBuffer();
+    pathVertexBuffer.put(pathVertices);
+    pathVertexBuffer.position(0);
+    pathIndexCount = path.poses.size();
+  }
+
+  /**
+   * Renders the points representing the empty and occupied spaces on the map.
+   * 
+   * @param gl
+   *          Instance of the GL interface.
+   */
+  public void drawMap(GL10 gl) {
+    if (ready) {
+      gl.glEnable(GL10.GL_POINT_SMOOTH);
+      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glPointSize(5);
+      // Draw empty regions.
+      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, emptyVertexBuffer);
+      gl.glColor4f(0.5f, 0.5f, 0.5f, 0.7f);
+      // This is needed because OpenGLES only allows for a max of
+      // UNSIGNED_SHORT_MAX vertices to be read. Hence all the vertices are
+      // displayed in chunks of UNSIGNED_SHORT_MAX.
+      for (int i = 0; i < totalEmptyCells / UNSIGNED_SHORT_MAX; i++) {
+        gl.glDrawArrays(GL10.GL_POINTS, i * UNSIGNED_SHORT_MAX, (UNSIGNED_SHORT_MAX * (i + 1)));
+      }
+      // (totalEmptyCells / UNSIGNED_SHORT_MAX) * UNSIGNED_SHORT_MAX is not the
+      // same as totalEmptyCells. It's integer math.
+      gl.glDrawArrays(GL10.GL_POINTS, (totalEmptyCells / UNSIGNED_SHORT_MAX) * UNSIGNED_SHORT_MAX,
+          (totalEmptyCells % UNSIGNED_SHORT_MAX));
+      // Draw occupied regions.
+      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, occupiedVertexBuffer);
+      gl.glColor4f(0.8f, 0.1f, 0.1f, 1f);
+      for (int i = 0; i < totalOccupiedCells / UNSIGNED_SHORT_MAX; i++) {
+        gl.glDrawArrays(GL10.GL_POINTS, i * UNSIGNED_SHORT_MAX, (UNSIGNED_SHORT_MAX * (i + 1)));
+      }
+      gl.glDrawArrays(GL10.GL_POINTS, (totalOccupiedCells / UNSIGNED_SHORT_MAX)
+          * UNSIGNED_SHORT_MAX, (totalOccupiedCells % UNSIGNED_SHORT_MAX));
+      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glDisable(GL10.GL_POINT_SMOOTH);
+    }
+  }
+
+  /**
+   * Renders the path.
+   * 
+   * @param gl
+   *          Instance of the GL interface.
+   */
+  public void drawPath(GL10 gl) {
+    if (ready) {
+      gl.glEnable(GL10.GL_POINT_SMOOTH);
+      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, pathVertexBuffer);
+      gl.glPointSize(2);
+      gl.glColor4f(0.2f, 0.8f, 0.2f, 1f);
+      gl.glDrawArrays(GL10.GL_POINTS, 0, pathIndexCount);
+      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glDisable(GL10.GL_POINT_SMOOTH);
+    }
+  }
+
+  /**
+   * Renders the region currently selected by the user as a rectangle.
+   * 
+   * @param gl
+   *          Instance of the GL interface.
+   */
+  public void drawRegion(GL10 gl) {
+    if (ready) {
+      gl.glEnable(GL10.GL_LINE_SMOOTH);
+      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, regionVertexBuffer);
+      gl.glLineWidth(5f);
+      gl.glColor4f(0.2f, 0.2f, 0.8f, 1f);
+      gl.glDrawArrays(GL10.GL_LINE_LOOP, 0, 4);
+      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glDisable(GL10.GL_LINE_SMOOTH);
+    }
+  }
+
+  /**
+   * Renders the footprint of the robot.
+   * 
+   * @param gl
+   *          Instance of the GL interface.
+   */
+  public void drawRobot(GL10 gl) {
+    if (ready) {
+      gl.glPushMatrix();
+      gl.glDisable(GL10.GL_CULL_FACE);
+      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glTranslatef((float) robotPose.position.x, (float) robotPose.position.y, 0);
+      gl.glRotatef(robotTheta - 90, 0, 0, 1);
+      gl.glPointSize(15);
+      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, robotVertexBuffer);
+      gl.glColor4f(1f, 0.0f, 0.0f, 1f);
+      gl.glDrawElements(GL10.GL_TRIANGLES, robotIndexCount, GL10.GL_UNSIGNED_SHORT,
+          robotIndexBuffer);
+      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glPopMatrix();
+    }
+  }
+
+  /**
+   * Renders the outline of the robot's footprint based on the current zoom
+   * level. It compensates for the zoom level allowing the size of the outline
+   * to remain constant and hence always visible.
+   * 
+   * @param gl
+   *          Instance of the GL interface.
+   * @param scaleFactor
+   *          The amount by which the outline of the robot should be scaled.
+   */
+  public void drawRobotOutline(GL10 gl, float scaleFactor) {
+    if (ready) {
+      gl.glPushMatrix();
+      gl.glEnable(GL10.GL_LINE_SMOOTH);
+      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glTranslatef((float) robotPose.position.x, (float) robotPose.position.y, 0);
+      gl.glRotatef(robotTheta - 90, 0, 0, 1);
+      gl.glScalef(scaleFactor, scaleFactor, scaleFactor);
+      gl.glLineWidth(2);
+      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, robotOutlineVertexBuffer);
+      gl.glColor4f(1f, 1.0f, 1.0f, 1f);
+      gl.glDrawArrays(GL10.GL_LINE_LOOP, 0, robotOutlineIndexCount);
+      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glDisable(GL10.GL_LINE_SMOOTH);
+      gl.glPopMatrix();
+    }
+  }
+
+  /**
+   * Renders the current goal specified by the user.
+   * 
+   * @param gl
+   *          Instance of the GL interface.
+   */
+  public void drawCurrentGoal(GL10 gl) {
+    if (ready) {
+      gl.glPushMatrix();
+      gl.glDisable(GL10.GL_CULL_FACE);
+      gl.glFrontFace(GL10.GL_CW);
+      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, currentGoalVertexBuffer);
+      gl.glTranslatef((float) currentGoalPose.position.x, (float) currentGoalPose.position.y, 0);
+      gl.glRotatef(currentGoalTheta - 90, 0, 0, 1);
+      gl.glColor4f(0.180392157f, 0.71372549f, 0.909803922f, 0.5f);
+      gl.glDrawArrays(GL10.GL_TRIANGLE_FAN, 0, goalIndexCount);
+      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glPopMatrix();
+    }
+  }
+
+  /**
+   * Renders a shape similar to the shape used to show the current goal.
+   * However, this shape is bigger, has a constant size regardless of the zoom
+   * level and is colored pink.
+   * 
+   * @param gl
+   *          Instance of the GL interface.
+   * @param scaleFactor
+   *          The amount by which the goal shape should be scaled.
+   */
+  public void drawUserGoal(GL10 gl, float scaleFactor) {
+    if (ready) {
+      gl.glPushMatrix();
+      gl.glDisable(GL10.GL_CULL_FACE);
+      gl.glFrontFace(GL10.GL_CW);
+      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, userGoalVertexBuffer);
+      gl.glTranslatef((float) userGoalPose.position.x, (float) userGoalPose.position.y, 0);
+      gl.glRotatef(userGoalTheta - 90, 0, 0, 1);
+      gl.glScalef(scaleFactor, scaleFactor, scaleFactor);
+      gl.glColor4f(0.847058824f, 0.243137255f, 0.8f, 1f);
+      gl.glDrawArrays(GL10.GL_TRIANGLE_FAN, 0, goalIndexCount);
+      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
+      gl.glPopMatrix();
+    }
+  }
+
+  /**
+   * Update the robot's location and orientation.
+   * 
+   * @param pose
+   *          Current pose of the robot.
+   * @param res
+   *          The resolution of the map
+   */
+  public void updateRobotPose(Pose pose, float res) {
+    this.robotPose = pose;
+    this.robotPose.position.x /= res;
+    this.robotPose.position.y /= res;
+    robotTheta = calculateHeading(pose.orientation);
+  }
+
+  /**
+   * Update the location and orientation of the current goal.
+   * 
+   * @param pose
+   *          Pose of the current goal.
+   * @param res
+   *          The resolution of the map
+   */
+  public void updateCurrentGoalPose(Pose pose, float res) {
+    this.currentGoalPose = pose;
+    this.currentGoalPose.position.x /= res;
+    this.currentGoalPose.position.y /= res;
+    currentGoalTheta = calculateHeading(pose.orientation);
+  }
+
+  /**
+   * Update the location of the goal that the user is trying to specify.
+   * 
+   * @param realWorldLocation
+   *          The real world coordinates (in meters) representing the location
+   *          of the user's desired goal.
+   */
+  public void updateUserGoalLocation(Point realWorldLocation) {
+    this.userGoalPose.position.x = -realWorldLocation.x;
+    this.userGoalPose.position.y = -realWorldLocation.y;
+  }
+
+  /**
+   * Update the orientation of the goal that the user is trying to specify.
+   * 
+   * @param theta
+   *          The orientation of the desired goal in degrees.
+   */
+  public void updateUserGoalOrientation(float theta) {
+    userGoalTheta = theta;
+  }
+
+  /**
+   * Update the coordinates of the region currently selected by the user.
+   * 
+   * @param p1
+   *          The real world coordinate (in meters) of one of the contacts used
+   *          to specify the region.
+   * @param p2
+   *          The real world coordinate (in meters) of the other contact used to
+   *          specify the region.
+   */
+  public void updateRegion(Point p1, Point p2) {
+    setRegion(-p1.x, -p2.x, -p1.y, -p2.y);
+  }
+
+  private float calculateHeading(Quaternion orientation) {
+    double heading;
+    double w = orientation.w;
+    double x = orientation.x;
+    double y = orientation.z;
+    double z = orientation.y;
+    heading = Math.atan2(2 * y * w - 2 * x * z, x * x - y * y - z * z + w * w) * 180 / Math.PI;
+    return (float) heading;
+  }
+
+  private void initRobot() {
+    float[] robotVertices = new float[12];
+    // The arrow shaped robot.
+    // 0,0
+    robotVertices[0] = 0f;
+    robotVertices[1] = 0f;
+    robotVertices[2] = 0f;
+    // -2,-1
+    robotVertices[3] = -2f;
+    robotVertices[4] = -2f;
+    robotVertices[5] = 0f;
+    // 2,-1
+    robotVertices[6] = 2f;
+    robotVertices[7] = -2f;
+    robotVertices[8] = 0f;
+    // 0,5
+    robotVertices[9] = 0f;
+    robotVertices[10] = 5f;
+    robotVertices[11] = 0f;
+    // Indices for the robot.
+    short[] robotIndices = new short[6];
+    // Left triangle (counter-clockwise)
+    robotIndices[0] = 0;
+    robotIndices[1] = 3;
+    robotIndices[2] = 1;
+    // Right triangle (counter-clockwise)
+    robotIndices[3] = 0;
+    robotIndices[4] = 2;
+    robotIndices[5] = 3;
+    ByteBuffer robotVertexByteBuffer =
+        ByteBuffer.allocateDirect(robotVertices.length * Float.SIZE / 8);
+    robotVertexByteBuffer.order(ByteOrder.nativeOrder());
+    robotVertexBuffer = robotVertexByteBuffer.asFloatBuffer();
+    robotVertexBuffer.put(robotVertices);
+    robotVertexBuffer.position(0);
+    ByteBuffer robotIndexByteBuffer =
+        ByteBuffer.allocateDirect(robotIndices.length * Integer.SIZE / 8);
+    robotIndexByteBuffer.order(ByteOrder.nativeOrder());
+    robotIndexBuffer = robotIndexByteBuffer.asShortBuffer();
+    robotIndexBuffer.put(robotIndices);
+    robotIndexBuffer.position(0);
+    robotIndexCount = robotIndices.length;
+  }
+
+  private void initRobotOutline() {
+    float[] robotOutlineVertices = new float[12];
+    // The arrow shaped outline of the robot.
+    // -2,-1
+    robotOutlineVertices[0] = -2f;
+    robotOutlineVertices[1] = -2f;
+    robotOutlineVertices[2] = 0f;
+    // 0,0
+    robotOutlineVertices[3] = 0f;
+    robotOutlineVertices[4] = 0f;
+    robotOutlineVertices[5] = 0f;
+    // 2,-1
+    robotOutlineVertices[6] = 2f;
+    robotOutlineVertices[7] = -2f;
+    robotOutlineVertices[8] = 0f;
+    // 0,5
+    robotOutlineVertices[9] = 0f;
+    robotOutlineVertices[10] = 5f;
+    robotOutlineVertices[11] = 0f;
+    ByteBuffer robotOutlineVertexByteBuffer =
+        ByteBuffer.allocateDirect(robotOutlineVertices.length * Float.SIZE / 8);
+    robotOutlineVertexByteBuffer.order(ByteOrder.nativeOrder());
+    robotOutlineVertexBuffer = robotOutlineVertexByteBuffer.asFloatBuffer();
+    robotOutlineVertexBuffer.put(robotOutlineVertices);
+    robotOutlineVertexBuffer.position(0);
+    robotOutlineIndexCount = 4;
+  }
+
+  private void initCurrentGoal() {
+    float[] goalVertices = new float[10 * 3];
+    goalVertices[0] = 0f;
+    goalVertices[1] = 0f;
+    goalVertices[2] = 0f;
+    goalVertices[3] = 0f;
+    goalVertices[4] = 14f;
+    goalVertices[5] = 0f;
+    goalVertices[6] = 2f;
+    goalVertices[7] = 2f;
+    goalVertices[8] = 0f;
+    goalVertices[9] = 7f;
+    goalVertices[10] = 0f;
+    goalVertices[11] = 0f;
+    goalVertices[12] = 2f;
+    goalVertices[13] = -2f;
+    goalVertices[14] = 0f;
+    goalVertices[15] = 0f;
+    goalVertices[16] = -7f;
+    goalVertices[17] = 0f;
+    goalVertices[18] = -2f;
+    goalVertices[19] = -2f;
+    goalVertices[20] = 0f;
+    goalVertices[21] = -7f;
+    goalVertices[22] = 0f;
+    goalVertices[23] = 0f;
+    goalVertices[24] = -2f;
+    goalVertices[25] = 2f;
+    goalVertices[26] = 0f;
+    // Repeat of point 1
+    goalVertices[27] = 0f;
+    goalVertices[28] = 14f;
+    goalVertices[29] = 0f;
+    ByteBuffer goalVertexByteBuffer =
+        ByteBuffer.allocateDirect(goalVertices.length * Float.SIZE / 8);
+    goalVertexByteBuffer.order(ByteOrder.nativeOrder());
+    currentGoalVertexBuffer = goalVertexByteBuffer.asFloatBuffer();
+    currentGoalVertexBuffer.put(goalVertices);
+    currentGoalVertexBuffer.position(0);
+    userGoalVertexBuffer = goalVertexByteBuffer.asFloatBuffer();
+    userGoalVertexBuffer.put(goalVertices);
+    userGoalVertexBuffer.position(0);
+    goalIndexCount = goalVertices.length / 3;
+  }
+
+  private void initUserGoal() {
+    float[] goalVertices = new float[10 * 3];
+    goalVertices[0] = 0f;
+    goalVertices[1] = 0f;
+    goalVertices[2] = 0f;
+    goalVertices[3] = 0f;
+    goalVertices[4] = 21f;
+    goalVertices[5] = 0f;
+    goalVertices[6] = 3f;
+    goalVertices[7] = 3f;
+    goalVertices[8] = 0f;
+    goalVertices[9] = 10.5f;
+    goalVertices[10] = 0f;
+    goalVertices[11] = 0f;
+    goalVertices[12] = 3f;
+    goalVertices[13] = -3f;
+    goalVertices[14] = 0f;
+    goalVertices[15] = 0f;
+    goalVertices[16] = -10.5f;
+    goalVertices[17] = 0f;
+    goalVertices[18] = -3f;
+    goalVertices[19] = -3f;
+    goalVertices[20] = 0f;
+    goalVertices[21] = -10.5f;
+    goalVertices[22] = 0f;
+    goalVertices[23] = 0f;
+    goalVertices[24] = -3f;
+    goalVertices[25] = 3f;
+    goalVertices[26] = 0f;
+    // Repeat of point 1
+    goalVertices[27] = 0f;
+    goalVertices[28] = 21f;
+    goalVertices[29] = 0f;
+    ByteBuffer goalVertexByteBuffer =
+        ByteBuffer.allocateDirect(goalVertices.length * Float.SIZE / 8);
+    goalVertexByteBuffer.order(ByteOrder.nativeOrder());
+    userGoalVertexBuffer = goalVertexByteBuffer.asFloatBuffer();
+    userGoalVertexBuffer.put(goalVertices);
+    userGoalVertexBuffer.position(0);
+  }
+
+  private void initPath() {
+    float[] pathVertices = new float[3];
+    // 0,0
+    pathVertices[0] = 0f;
+    pathVertices[1] = 0f;
+    pathVertices[2] = 0f;
+    ByteBuffer pathVertexByteBuffer =
+        ByteBuffer.allocateDirect(pathVertices.length * Float.SIZE / 8);
+    pathVertexByteBuffer.order(ByteOrder.nativeOrder());
+    pathVertexBuffer = pathVertexByteBuffer.asFloatBuffer();
+    pathVertexBuffer.put(pathVertices);
+    pathVertexBuffer.position(0);
+    pathIndexCount = 0;
+  }
+
+  private void setRegion(float minX, float maxX, float minY, float maxY) {
+    float[] regionVertices = new float[4 * 3];
+    // Location of points.
+    // 0------1
+    //
+    //
+    // 3------2
+    // Point 0
+    regionVertices[0] = minX;
+    regionVertices[1] = maxY;
+    regionVertices[2] = 0f;
+    // Point 1
+    regionVertices[3] = maxX;
+    regionVertices[4] = maxY;
+    regionVertices[5] = 0f;
+    // Point 2
+    regionVertices[6] = maxX;
+    regionVertices[7] = minY;
+    regionVertices[8] = 0f;
+    // Point 3
+    regionVertices[9] = minX;
+    regionVertices[10] = minY;
+    regionVertices[11] = 0f;
+    ByteBuffer regionVertexByteBuffer =
+        ByteBuffer.allocateDirect(regionVertices.length * Float.SIZE / 8);
+    regionVertexByteBuffer.order(ByteOrder.nativeOrder());
+    regionVertexBuffer = regionVertexByteBuffer.asFloatBuffer();
+    regionVertexBuffer.put(regionVertices);
+    regionVertexBuffer.position(0);
+  }
+}

android/src/org/ros/rosjava/android/views/MapRenderer.java

@@ -0,0 +1,338 @@
+/*
+ * 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.rosjava.android.views;
+
+import android.graphics.Point;
+import android.opengl.GLSurfaceView;
+import android.opengl.GLU;
+import org.ros.message.geometry_msgs.Pose;
+import org.ros.message.geometry_msgs.Quaternion;
+import org.ros.message.nav_msgs.OccupancyGrid;
+import org.ros.message.nav_msgs.Path;
+
+import javax.microedition.khronos.egl.EGLConfig;
+import javax.microedition.khronos.opengles.GL10;
+
+/**
+ * The renderer that creates and manages the OpenGL surface for the MapView.
+ * 
+ * @author munjaldesai@google.com (Munjal Desai)
+ */
+class MapRenderer implements GLSurfaceView.Renderer {
+  /**
+   * Most the user can zoom in (distance of the camera from origin) in the map
+   * centric view.
+   */
+  private static final float MIN_ZOOM_MAP_CENTRIC_MODE = -70;
+  /**
+   * Most the user can zoom out (distance of the camera from origin) in the map
+   * centric view.
+   */
+  private static final float MAX_ZOOM_MAP_CENTRIC_MODE = -400;
+  /**
+   * Most the user can zoom in (distance of the camera from origin) in the robot
+   * centric view.
+   */
+  private static final float MIN_ZOOM_ROBOT_CENTRIC_MODE = -100;
+  /**
+   * Most the user can zoom out (distance of the camera from origin) in the
+   * robot centric view.
+   */
+  private static final float MAX_ZOOM_ROBOT_CENTRIC_MODE = -400;
+  /**
+   * Instance of the helper class that draws the map, robot, etc.
+   */
+  private MapPoints map;
+  /**
+   * Real world (x,y) coordinates of the camera. The depth (z-axis) is based on
+   * {@link #zoom}.
+   */
+  private Point cameraLocation = new Point(0, 0);
+  /**
+   * The max x and y coordinates of the map in meters. In the current
+   * Implementation the assumption is that the 0,0 cell of the map is at the
+   * origin of the coordinates system.
+   * 
+   * TODO: This is not a necessary assumption and should not be required.
+   */
+  private Point maxCoords = new Point();
+  /**
+   * The distance of the OpenGL camera from the origin. By default it will
+   * zoomed in all the way.
+   */
+  private float zoom = MIN_ZOOM_MAP_CENTRIC_MODE;
+  /**
+   * True when the map is supposed to be in the robot centric mode and false
+   * when the map is supposed to be in the map centric mode.
+   */
+  private boolean robotCentricMode;
+  /**
+   * True when the camera should follow the robot in the map centric mode, false
+   * otherwise.
+   */
+  private boolean centerOnRobot = true;
+  /**
+   * Robot's x coordinate in the real world.
+   */
+  private float robotX;
+  /**
+   * Robot's y coordinate in the real world.
+   */
+  private float robotY;
+  /**
+   * Robot's orientation (in radians) coordinate in the real world.
+   */
+  private float robotTheta;
+  /**
+   * True when the icon for the user to specify a goal must be shown, false
+   * otherwise.
+   */
+  private boolean showUserGoal;
+  /**
+   * True is the regions should be shown, false otherwise.
+   */
+  private boolean showRegion;
+
+  private int viewportHalfWidth;
+
+  @Override
+  public void onSurfaceChanged(GL10 gl, int w, int h) {
+    gl.glViewport(0, 0, w, h);
+    gl.glMatrixMode(GL10.GL_PROJECTION);
+    gl.glLoadIdentity();
+    // The aspect ratio is currently set to 1.
+    GLU.gluPerspective(gl, 60.0f, 1f, 1f, 450.0f);
+    viewportHalfWidth = w / 2;
+    gl.glMatrixMode(GL10.GL_MODELVIEW);
+    gl.glLoadIdentity();
+    gl.glHint(GL10.GL_POLYGON_SMOOTH_HINT, GL10.GL_NICEST);
+  }
+
+  @Override
+  public void onSurfaceCreated(GL10 gl, EGLConfig arg1) {
+    map = new MapPoints();
+  }
+
+  @Override
+  public void onDrawFrame(GL10 gl) {
+    gl.glClearColor(0, 0, 0.0f, 0.0f);
+    gl.glClear(GL10.GL_COLOR_BUFFER_BIT);
+    gl.glLoadIdentity();
+    // If the map view is supposed to be robot centric then move the
+    // camera to the x,y coordinate of the robot and rotate it so it aligns with
+    // the robot's orientation.
+    if (robotCentricMode) {
+      gl.glRotatef(robotTheta - 90, 0, 0, -1f);
+      gl.glTranslatef(robotX - getCenterCoordinates(), robotY - getCenterCoordinates(), zoom);
+    } else {
+      gl.glRotatef(0, 0, 0, -1f);
+      gl.glTranslatef(cameraLocation.x, cameraLocation.y, zoom);
+    }
+    map.drawMap(gl);
+    map.drawPath(gl);
+    map.drawCurrentGoal(gl);
+    if (showRegion) {
+      map.drawRegion(gl);
+    }
+    map.drawRobot(gl);
+    map.drawRobotOutline(gl, zoom / MIN_ZOOM_MAP_CENTRIC_MODE);
+    if (showUserGoal) {
+      map.drawUserGoal(gl, zoom / MIN_ZOOM_MAP_CENTRIC_MODE);
+    }
+  }
+
+  public void updateMap(OccupancyGrid newMap) {
+    map.updateMap(newMap);
+    maxCoords.x = (int) -newMap.info.width;
+    maxCoords.y = (int) -newMap.info.height;
+  }
+
+  public void updatePath(Path path, float res) {
+    map.updatePath(path, res);
+  }
+
+  /**
+   * Draw the region selection box based on the specified pixel coordinates.
+   */
+  public void drawRegion(int x1, int y1, int x2, int y2) {
+    showRegion = true;
+    map.updateRegion(getWorldCoordinate(x1, y1), getWorldCoordinate(x2, y2));
+  }
+
+  public void moveCamera(Point point) {
+    // Since the movement can be relative and need not be based on the real
+    // world coordinates, the change in coordinates is divided by 3 to maintain
+    // a descent panning pace.
+    cameraLocation.x += point.x / 3;
+    cameraLocation.y -= point.y / 3;
+    // Bounds checking to prevent the user from panning too much.
+    if (cameraLocation.x > 0) {
+      cameraLocation.x = 0;
+    } else if (cameraLocation.x < maxCoords.x) {
+      cameraLocation.x = maxCoords.x;
+    }
+    if (cameraLocation.y > 0) {
+      cameraLocation.y = 0;
+    } else if (cameraLocation.y < maxCoords.y) {
+      cameraLocation.y = maxCoords.y;
+    }
+    // Disabling the centerOnRobot when the user moves the map is similar to the
+    // navigation app in android.
+    centerOnRobot = false;
+  }
+
+  public void zoomCamera(float zoomLevel) {
+    // Diving by 3 to maintain a steady pace for zooming in/out.
+    zoom += zoomLevel / 3f;
+    if (robotCentricMode) {
+      if (zoom < MAX_ZOOM_ROBOT_CENTRIC_MODE) {
+        zoom = MAX_ZOOM_ROBOT_CENTRIC_MODE;
+      } else if (zoom > MIN_ZOOM_ROBOT_CENTRIC_MODE) {
+        zoom = MIN_ZOOM_ROBOT_CENTRIC_MODE;
+      }
+    } else {
+      if (zoom < MAX_ZOOM_MAP_CENTRIC_MODE) {
+        zoom = MAX_ZOOM_MAP_CENTRIC_MODE;
+      } else if (zoom > MIN_ZOOM_MAP_CENTRIC_MODE) {
+        zoom = MIN_ZOOM_MAP_CENTRIC_MODE;
+      }
+    }
+  }
+
+  public void hideRegion() {
+    showRegion = false;
+  }
+
+  public void enableCenterOnRobot() {
+    centerOnRobot = true;
+    centerCamera();
+  }
+
+  public void userGoalVisible(boolean visibility) {
+    showUserGoal = visibility;
+  }
+
+  /**
+   * Returns the real world equivalent of the viewport coordinates specified.
+   * 
+   * @param x
+   *          Coordinate of the view in pixels.
+   * @param y
+   *          Coordinate of the view in pixels.
+   * @return Real world coordinate.
+   */
+  public Point getWorldCoordinate(float x, float y) {
+    Point realCoord = new Point();
+    float multiplier = (float) (Math.tan(30 * Math.PI / 180f) * (-zoom));
+    float onePixelToMeter = multiplier / viewportHalfWidth;
+    realCoord.x = cameraLocation.x - (int) ((viewportHalfWidth - x) * onePixelToMeter);
+    realCoord.y = cameraLocation.y - (int) ((viewportHalfWidth - y) * onePixelToMeter);
+    return realCoord;
+  }
+
+  /**
+   * Passes the robot's pose to be updated on the map.
+   * 
+   * @param pose
+   *          Robot's pose in real world coordinate.
+   * @param res
+   *          The resolution of the current map in meters/cell.
+   */
+  public void updateRobotPose(Pose pose, float res) {
+    map.updateRobotPose(pose, res);
+    robotX = (float) (-pose.position.x);
+    robotY = (float) (-pose.position.y);
+    robotTheta = calculateHeading(pose.orientation);
+    // If the camera is supposed to be centered on the robot then move the
+    // camera to the same coordinates as the robot.
+    if (centerOnRobot) {
+      centerCamera();
+    }
+  }
+
+  /**
+   * Selects the map centric mode or the robot centric mode.
+   * 
+   * @param isRobotCentricMode
+   *          True selects the robot centric mode and false selects the map
+   *          centric mode.
+   */
+  public void setViewMode(boolean isRobotCentricMode) {
+    robotCentricMode = isRobotCentricMode;
+    if (robotCentricMode) {
+      if (zoom < MAX_ZOOM_ROBOT_CENTRIC_MODE) {
+        zoom = MAX_ZOOM_ROBOT_CENTRIC_MODE;
+      } else if (zoom > MIN_ZOOM_ROBOT_CENTRIC_MODE) {
+        zoom = MIN_ZOOM_ROBOT_CENTRIC_MODE;
+      }
+    }
+  }
+
+  public void updateCurrentGoalPose(Pose goalPose, float res) {
+    map.updateCurrentGoalPose(goalPose, res);
+  }
+
+  public void updateUserGoalLocation(Point goalScreenPoint) {
+    map.updateUserGoalLocation(getWorldCoordinate(goalScreenPoint.x, goalScreenPoint.y));
+  }
+
+  public void updateUserGoalOrientation(float theta) {
+    map.updateUserGoalOrientation(theta);
+  }
+
+  /**
+   * Updates the coordinates of the map.
+   * 
+   * @param x
+   *          The real world x coordinate for the camera.
+   * @param y
+   *          The real world y coordinate for the camera.
+   */
+  public void moveCamera(float x, float y) {
+    cameraLocation.x = (int) x;
+    cameraLocation.y = (int) y;
+  }
+
+  /**
+   * Returns the heading (in degree) from the quaternion passed to it.
+   */
+  private float calculateHeading(Quaternion orientation) {
+    double w = orientation.w;
+    double x = orientation.x;
+    double y = orientation.z;
+    double z = orientation.y;
+    return (float) Math.toDegrees(Math.atan2(2 * y * w - 2 * x * z, x * x - y * y - z * z + w * w));
+  }
+
+  /**
+   * Returns the real world coordinates that matches the center of the viewport.
+   */
+  private float getCenterCoordinates() {
+    float multiplier = (float) (Math.tan(Math.toRadians(30)) * (-zoom));
+    float oneMeterToPixel = viewportHalfWidth / multiplier;
+    return oneMeterToPixel;
+  }
+
+  /**
+   * Sets the camera coordinates to that of the robot's. Hence the camera starts
+   * to follow the robot. Though the camera orientation is not changed.
+   */
+  private void centerCamera() {
+    cameraLocation.x = (int) robotX;
+    cameraLocation.y = (int) robotY;
+  }
+}

android/src/org/ros/rosjava/android/views/MapView.java

@@ -0,0 +1,533 @@
+/*
+ * 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.rosjava.android.views;
+
+import com.google.common.base.Preconditions;
+
+import android.content.Context;
+import android.graphics.PixelFormat;
+import android.graphics.Point;
+import android.opengl.GLSurfaceView;
+import android.os.Handler;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnTouchListener;
+import org.ros.message.MessageListener;
+import org.ros.message.Time;
+import org.ros.message.geometry_msgs.PoseStamped;
+import org.ros.message.geometry_msgs.PoseWithCovarianceStamped;
+import org.ros.message.geometry_msgs.Quaternion;
+import org.ros.message.nav_msgs.MapMetaData;
+import org.ros.message.nav_msgs.OccupancyGrid;
+import org.ros.message.nav_msgs.Path;
+import org.ros.node.DefaultNodeFactory;
+import org.ros.node.Node;
+import org.ros.node.NodeConfiguration;
+import org.ros.node.NodeMain;
+import org.ros.node.topic.Publisher;
+
+import java.util.Calendar;
+
+/**
+ * Displays a map and other data on a OpenGL surface. This is an interactive map
+ * that allows the user to pan, zoom, specify goals, initial pose, and regions.
+ * 
+ * @author munjaldesai@google.com (Munjal Desai)
+ */
+public class MapView extends GLSurfaceView implements NodeMain, OnTouchListener {
+
+  private enum InteractionMode {
+    // Default mode.
+    INVALID,
+    // When the user starts moves the map but the distance moved is less than
+    // FINAL_MAP_MODE_DISTANCE_THRESHOLD.
+    MOVE_MAP,
+    // When the user starts moves the map and the distance moved is greater than
+    // FINAL_MAP_MODE_DISTANCE_THRESHOLD.
+    MOVE_MAP_FINAL_MODE,
+    // When the user is zooming in/out.
+    ZOOM_MAP,
+    // When the user is trying to specify a location (either a goal or initial
+    // pose).
+    SPECIFY_LOCATION,
+    // When the user is trying to select a region.
+    SELECT_REGION
+  }
+
+  /**
+   * Topic name for the map.
+   */
+  private static final String MAP_TOPIC_NAME = "map";
+  /**
+   * Topic name at which the initial pose will be published.
+   */
+  private static final String INITIAL_POSE_TOPIC_NAME = "initialpose";
+  /**
+   * Topic name at which the goal message will be published.
+   */
+  private static final String SIMPLE_GOAL_TOPIC = "move_base_simple/goal";
+  /**
+   * Topic name for the subscribed AMCL pose.
+   */
+  private static final String ROBOT_POSE_TOPIC = "pose";
+  /**
+   * Topic name for the subscribed path.
+   */
+  private static final String PATH_TOPIC = "move_base_node/NavfnROS/plan";
+  /**
+   * If the contact on the view moves more than this distance in pixels the
+   * interaction mode is switched to MOVE_MAP_FINAL_MODE.
+   */
+  private static final float FINAL_MAP_MODE_DISTANCE_THRESHOLD = 20f;
+  /**
+   * Time in milliseconds after which taps are not considered to be double taps.
+   */
+  private static final int DOUBLE_TAP_TIME = 200;
+  /**
+   * Time in milliseconds for which the user must keep the contact down without
+   * moving to trigger a press and hold gesture.
+   */
+  private static final int PRESS_AND_HOLD_TIME = 600;
+  /**
+   * The OpenGL renderer that creates and manages the surface.
+   */
+  private MapRenderer mapRenderer;
+  private InteractionMode currentInteractionMode = InteractionMode.INVALID;
+  /**
+   * A sub-mode of InteractionMode.SPECIFY_LOCATION. True when the user is
+   * trying to set the initial pose of the robot. False when the user is
+   * specifying the goal point for the robot to autonomously navigate to.
+   */
+  private boolean initialPoseMode;
+  /**
+   * Information (resolution, width, height, etc) about the map.
+   */
+  private MapMetaData mapMetaData = new MapMetaData();
+  /**
+   * Time in milliseconds when the last contact down occurred. Used to determine
+   * a double tap event.
+   */
+  private long previousContactDownTime;
+  private int goalHeaderSequence;
+  private boolean firstMapRendered;
+  /**
+   * Records the on-screen location (in pixels) of the contact down event. Later
+   * when it is determined that the user was specifying a destination this
+   * points is translated to a position in the real world.
+   */
+  private Point goalContact = new Point();
+  /**
+   * Keeps the latest coordinates of up to 2 contacts.
+   */
+  private Point[] previousContact = new Point[2];
+  /**
+   * Used to determine a long press and hold event in conjunction with
+   * {@link #longPressRunnable}.
+   */
+  private Handler longPressHandler = new Handler();
+  /**
+   * Publisher for the initial pose of the robot for AMCL.
+   */
+  private Publisher<PoseWithCovarianceStamped> initialPose;
+  /**
+   * Publisher for user specified goal for autonomous navigation.
+   */
+  private Publisher<PoseStamped> goalPublisher;
+  /**
+   * The node for map view.
+   */
+  private Node node;
+  public final Runnable longPressRunnable = new Runnable() {
+    @Override
+    public void run() {
+      // TODO: Draw a state diagram and check what states can transition here.
+      // This might help with the somewhat scattered removeCallbacks.
+      longPressHandler.removeCallbacks(longPressRunnable);
+      // The user is trying to specify a location to the robot.
+      currentInteractionMode = InteractionMode.SPECIFY_LOCATION;
+      // Show the goal icon.
+      mapRenderer.userGoalVisible(true);
+      // Move the goal icon to the correct location in the map.
+      mapRenderer.updateUserGoalLocation(goalContact);
+      requestRender();
+    }
+  };
+
+  public MapView(Context context) {
+    super(context);
+    mapRenderer = new MapRenderer();
+    setEGLConfigChooser(8, 8, 8, 8, 16, 0);
+    getHolder().setFormat(PixelFormat.TRANSLUCENT);
+    setZOrderOnTop(true);
+    setRenderer(mapRenderer);
+    // This is important since the display needs to be updated only when new
+    // data is received.
+    setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
+    previousContact[0] = new Point();
+    previousContact[1] = new Point();
+  }
+
+  @Override
+  public void main(NodeConfiguration nodeConfiguration) throws Exception {
+    if (node == null) {
+      Preconditions.checkNotNull(nodeConfiguration);
+      node = new DefaultNodeFactory().newNode("android/map_view", nodeConfiguration);
+    }
+    // Initialize the goal publisher.
+    goalPublisher = node.newPublisher(SIMPLE_GOAL_TOPIC, "geometry_msgs/PoseStamped");
+    // Initialize the initial pose publisher.
+    initialPose =
+        node.newPublisher(INITIAL_POSE_TOPIC_NAME, "geometry_msgs/PoseWithCovarianceStamped");
+    // Subscribe to the map.
+    node.newSubscriber(MAP_TOPIC_NAME, "nav_msgs/OccupancyGrid",
+        new MessageListener<OccupancyGrid>() {
+          @Override
+          public void onNewMessage(final OccupancyGrid map) {
+            post(new Runnable() {
+              @Override
+              public void run() {
+                // Show the map.
+                mapRenderer.updateMap(map);
+                mapMetaData = map.info;
+                // If this is the first time map data is received then center
+                // the camera on the map.
+                if (!firstMapRendered) {
+                  mapRenderer.moveCamera(-mapMetaData.width / 2, -mapMetaData.height / 2);
+                  firstMapRendered = true;
+                }
+                requestRender();
+              }
+            });
+          }
+        });
+    // Subscribe to the pose.
+    node.newSubscriber(ROBOT_POSE_TOPIC, "geometry_msgs/PoseStamped",
+        new MessageListener<PoseStamped>() {
+          @Override
+          public void onNewMessage(final PoseStamped message) {
+            post(new Runnable() {
+              @Override
+              public void run() {
+                // Update the robot's location on the map.
+                mapRenderer.updateRobotPose(message.pose, mapMetaData.resolution);
+                requestRender();
+              }
+            });
+          }
+        });
+    // Subscribe to the current goal.
+    node.newSubscriber(SIMPLE_GOAL_TOPIC, "geometry_msgs/PoseStamped",
+        new MessageListener<PoseStamped>() {
+          @Override
+          public void onNewMessage(final PoseStamped goal) {
+            post(new Runnable() {
+              @Override
+              public void run() {
+                // Update the location of the current goal on the map.
+                mapRenderer.updateCurrentGoalPose(goal.pose, mapMetaData.resolution);
+                requestRender();
+              }
+            });
+          }
+        });
+    // Subscribe to the current path plan.
+    node.newSubscriber(PATH_TOPIC, "nav_msgs/Path", new MessageListener<Path>() {
+      @Override
+      public void onNewMessage(final Path path) {
+        post(new Runnable() {
+          @Override
+          public void run() {
+            // Update the path on the map.
+            mapRenderer.updatePath(path, mapMetaData.resolution);
+          }
+        });
+      }
+    });
+    // Start listening for touch events.
+    setOnTouchListener(this);
+  }
+
+  @Override
+  public void shutdown() {
+    Preconditions.checkNotNull(node);
+    node.shutdown();
+    node = null;
+  }
+
+  @Override
+  public boolean onTouch(View v, MotionEvent event) {
+    final int action = event.getAction();
+    switch (action & MotionEvent.ACTION_MASK) {
+      case MotionEvent.ACTION_MOVE: {
+        contactMove(event);
+        break;
+      }
+      case MotionEvent.ACTION_DOWN: {
+        return contactDown(event);
+      }
+      case MotionEvent.ACTION_POINTER_1_DOWN: {
+        // If the user is trying to specify a location on the map.
+        if (currentInteractionMode == InteractionMode.SPECIFY_LOCATION) {
+          // Cancel the currently specified location and reset the interaction
+          // state machine.
+          resetInteractionState();
+        }
+        // If the annotate mode is not selected.
+        else if (currentInteractionMode != InteractionMode.SELECT_REGION) {
+          // Assume that the user is trying to zoom the map.
+          currentInteractionMode = InteractionMode.ZOOM_MAP;
+        }
+        previousContact[1].x = (int) event.getX(event.getActionIndex());
+        previousContact[1].y = (int) event.getY(event.getActionIndex());
+        break;
+      }
+      case MotionEvent.ACTION_POINTER_2_DOWN: {
+        // If there is a third contact on the screen then reset the interaction
+        // state machine.
+        resetInteractionState();
+        break;
+      }
+      case MotionEvent.ACTION_UP: {
+        contactUp(event);
+        break;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Sets the map in robot centric or map centric mode. In robot centric mode
+   * the robot is always facing up and the map move and rotates to accommodate
+   * that. In map centric mode the map does not rotate. The robot can be
+   * centered if the user double taps on the view.
+   * 
+   * @param isRobotCentricMode
+   *          True for robot centric mode and false for map centric mode.
+   */
+  public void setViewMode(boolean isRobotCentricMode) {
+    mapRenderer.setViewMode(isRobotCentricMode);
+  }
+
+  /**
+   * Enable the initial pose selection mode. Next time the user specifies a pose
+   * it will be published as {@link #initialPose}. This mode is automatically
+   * disabled once an initial pose has been specified or if a user cancels the
+   * pose selection gesture (second finger on the screen).
+   */
+  public void initialPose() {
+    initialPoseMode = true;
+  }
+
+  /**
+   * Temporarily enables the annotate region mode. In this mode user can select
+   * a region of interest by putting two fingers down.
+   * 
+   * TODO: Currently region information is not stored or used in any way. The
+   * map coordinates of the selected region are known and can either be stored
+   * or published along with additional information like region name.
+   */
+  public void annotateRegion() {
+    currentInteractionMode = InteractionMode.SELECT_REGION;
+  }
+
+  private void contactMove(MotionEvent event) {
+    // If only one contact is on the view.
+    if (event.getPointerCount() == 1) {
+      // And the user is moving the map.
+      if (currentInteractionMode == InteractionMode.MOVE_MAP
+          || currentInteractionMode == InteractionMode.MOVE_MAP_FINAL_MODE) {
+        // Move the map.
+        mapRenderer.moveCamera(new Point((int) event.getX(0) - previousContact[0].x, (int) event
+            .getY(0) - previousContact[0].y));
+        // If the user moved further than some distance from the location of the
+        // contact down.
+        if (currentInteractionMode != InteractionMode.MOVE_MAP_FINAL_MODE
+            && triggerMoveFinalMode(event.getX(0), event.getY(0))) {
+          // Then enter the MOVE_MAP_FINAL_MODE mode.
+          currentInteractionMode = InteractionMode.MOVE_MAP_FINAL_MODE;
+          // And remove the press and hold callback since the user is moving the
+          // map and not trying to do a press and hold.
+          longPressHandler.removeCallbacks(longPressRunnable);
+        }
+      }
+      // And the user is specifying an orientation for a pose on the map.
+      else if (currentInteractionMode == InteractionMode.SPECIFY_LOCATION) {
+        // Set orientation of the goal pose.
+        mapRenderer.updateUserGoalOrientation(getGoalOrientation(event.getX(0), event.getY(0)));
+      }
+      // Store current contact position.
+      previousContact[0].x = (int) event.getX(0);
+      previousContact[0].y = (int) event.getY(0);
+    }
+    // If there are two contacts on the view.
+    else if (event.getPointerCount() == 2) {
+      // In zoom mode.
+      if (currentInteractionMode == InteractionMode.ZOOM_MAP) {
+        // Zoom in/out based on the distance between locations of current
+        // contacts and previous contacts.
+        mapRenderer.zoomCamera(calcDistance(event.getX(0), event.getY(0), event.getX(1),
+            event.getY(1))
+            - calcDistance(previousContact[0].x, previousContact[0].y, previousContact[1].x,
+                previousContact[1].y));
+      }
+      // In select region mode.
+      else if (currentInteractionMode == InteractionMode.SELECT_REGION) {
+        mapRenderer.drawRegion(this.getWidth() - (int) event.getX(0), (int) event.getY(0),
+            this.getWidth() - (int) event.getX(1), (int) event.getY(1));
+      }
+      // Update contact information.
+      previousContact[0].x = (int) event.getX(0);
+      previousContact[0].y = (int) event.getY(0);
+      previousContact[1].x = (int) event.getX(1);
+      previousContact[1].y = (int) event.getY(1);
+      // Prevent transition into SPECIFY_GOAL mode.
+      longPressHandler.removeCallbacks(longPressRunnable);
+    }
+    requestRender();
+  }
+
+  private void contactUp(MotionEvent event) {
+    // If the user was trying to specify a pose and just lifted the contact then
+    // publish the position based on the initial contact down location and the
+    // orientation based on the current contact up location.
+    if (currentInteractionMode == InteractionMode.SPECIFY_LOCATION) {
+      Point goalPoint = mapRenderer.getWorldCoordinate(goalContact.x, goalContact.y);
+      PoseStamped poseStamped = new PoseStamped();
+      poseStamped.header.seq = goalHeaderSequence++;
+      poseStamped.header.frame_id = "map";
+      poseStamped.header.stamp = new Time();
+      poseStamped.pose.position.x = -goalPoint.x * mapMetaData.resolution;
+      poseStamped.pose.position.y = -goalPoint.y * mapMetaData.resolution;
+      poseStamped.pose.position.z = 0;
+      poseStamped.pose.orientation =
+          getQuaternion(Math.toRadians(getGoalOrientation(event.getX(0), event.getY(0))), 0, 0);
+      // If the user was trying to specify an initial pose.
+      if (initialPoseMode) {
+        PoseWithCovarianceStamped poseWithCovarianceStamped = new PoseWithCovarianceStamped();
+        poseWithCovarianceStamped.header.frame_id = "map";
+        poseWithCovarianceStamped.pose.pose = poseStamped.pose;
+        // Publish the initial pose.
+        initialPose.publish(poseWithCovarianceStamped);
+      } else {
+        goalPublisher.publish(poseStamped);
+      }
+    }
+    resetInteractionState();
+  }
+
+  private boolean contactDown(MotionEvent event) {
+    boolean returnValue = true;
+    // If it's been less than DOUBLE_TAP_TIME milliseconds since the last
+    // contact down then the user just performed a double tap gesture.
+    if (Calendar.getInstance().getTimeInMillis() - previousContactDownTime < DOUBLE_TAP_TIME) {
+      // Shift the viewport to center on the robot.
+      mapRenderer.enableCenterOnRobot();
+      requestRender();
+      // Further information from this contact is no longer needed.
+      returnValue = false;
+    } else {
+      // Since this is not a double tap, start the timer to detect a
+      // press and hold.
+      longPressHandler.postDelayed(longPressRunnable, PRESS_AND_HOLD_TIME);
+    }
+    previousContact[0].x = (int) event.getX(0);
+    previousContact[0].y = (int) event.getY(0);
+    goalContact.x = this.getWidth() - previousContact[0].x;
+    goalContact.y = previousContact[0].y;
+    mapRenderer.getWorldCoordinate(previousContact[0].x, previousContact[0].y);
+    if (currentInteractionMode == InteractionMode.INVALID) {
+      currentInteractionMode = InteractionMode.MOVE_MAP;
+    }
+    previousContactDownTime = Calendar.getInstance().getTimeInMillis();
+    return returnValue;
+  }
+
+  private void resetInteractionState() {
+    currentInteractionMode = InteractionMode.INVALID;
+    longPressHandler.removeCallbacks(longPressRunnable);
+    initialPoseMode = false;
+    mapRenderer.userGoalVisible(false);
+    mapRenderer.hideRegion();
+  }
+
+  /**
+   * Calculates the distance between the 2 specified points.
+   */
+  private float calcDistance(float x1, float y1, float x2, float y2) {
+    return (float) (Math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)));
+  }
+
+  /**
+   * Returns the orientation of the specified point relative to
+   * {@link #goalContact}.
+   * 
+   * @param x
+   *          The x-coordinate of the contact in pixels on the view.
+   * @param y
+   *          The y-coordinate of the contact in pixels on the view.
+   * @return The angle between passed coordinates and {@link #goalContact} in
+   *         degrees (0 to 360).
+   */
+  private float getGoalOrientation(float x, float y) {
+    return (float) (360 - Math.toDegrees(Math.atan2(y - goalContact.y,
+        x + goalContact.x - this.getWidth())));
+  }
+
+  /**
+   * Return the quaternion representing the specified heading, attitude, and
+   * bank values.
+   * 
+   * @param heading
+   *          The heading in radians.
+   * @param attitude
+   *          The attitude in radians.
+   * @param bank
+   *          The bank in radians.
+   * @return The quaternion based on the arguments passed.
+   */
+  private Quaternion getQuaternion(double heading, double attitude, double bank) {
+    // Assuming the angles are in radians.
+    double c1 = Math.cos(heading / 2);
+    double s1 = Math.sin(heading / 2);
+    double c2 = Math.cos(attitude / 2);
+    double s2 = Math.sin(attitude / 2);
+    double c3 = Math.cos(bank / 2);
+    double s3 = Math.sin(bank / 2);
+    double c1c2 = c1 * c2;
+    double s1s2 = s1 * s2;
+    Quaternion quaternion = new Quaternion();
+    // Modified math (the order for w,x,y, and z needs to be changed).
+    quaternion.w = c1c2 * c3 - s1s2 * s3;
+    quaternion.x = c1c2 * s3 + s1s2 * c3;
+    quaternion.z = s1 * c2 * c3 + c1 * s2 * s3;
+    quaternion.y = c1 * s2 * c3 - s1 * c2 * s3;
+    return quaternion;
+  }
+
+  /**
+   * Returns true if the user has moved the map beyond
+   * {@link #FINAL_MAP_MODE_DISTANCE_THRESHOLD}.
+   */
+  private boolean triggerMoveFinalMode(float currentX, float currentY) {
+    if (Math.sqrt((currentX - (this.getWidth() - goalContact.x))
+        * (currentX - (this.getWidth() - goalContact.x))
+        + (currentY - previousContact[0].y * (currentY - previousContact[0].y))) > FINAL_MAP_MODE_DISTANCE_THRESHOLD) {
+      return true;
+    }
+    return false;
+  }
+}

android/src/org/ros/rosjava/android/views/PanTiltView.java

@@ -0,0 +1,563 @@
+/*
+ * 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.rosjava.android.views;
+
+import android.util.Log;
+
+import android.graphics.Point;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnTouchListener;
+import android.widget.ImageView;
+import android.widget.RelativeLayout;
+import org.ros.node.DefaultNodeFactory;
+import org.ros.node.Node;
+import org.ros.node.NodeConfiguration;
+import org.ros.node.topic.Publisher;
+import org.ros.address.InetAddressFactory;
+
+import java.net.URI;
+import java.util.ArrayList;
+
+/**
+ * PanTiltZoomView creates a rosjava view that can be used to control a pan tilt
+ * device.
+ * 
+ * @author munjaldesai@google.com (Munjal Desai)
+ */
+public class PanTiltView extends RelativeLayout implements OnTouchListener {
+
+  private static final int INVALID_POINTER_ID = -1;
+  private static final int INVALID_POINTER_LOCATION = -1;
+  /**
+   * MIDDLE_AREA This, {@link #RIGHT_AREA}, and {@link #TOP_AREA} are values
+   * that represent the section of the view where the POINTER_DOWN event
+   * occurred. The MIDDLE_AREA represents the area below the top guide (pan
+   * marker) and left of the right guide (tilt marker).
+   * 
+   * TODO(munjaldesai): Since these 3 values are used very often, replace the
+   * logic with bitwise operations.
+   */
+  private static final int MIDDLE_AREA = 0;
+  /**
+   * TOP_AREA This, {@link #MIDDLE_AREA}, and {@link #RIGHT_AREA} are values
+   * that represent the section of the view where the POINTER_DOWN event
+   * occurred. The TOP_AREA represents the area above the top guide (pan
+   * marker).
+   */
+  private static final int TOP_AREA = 1;
+  /**
+   * RIGHT_AREA This, {@link #MIDDLE_AREA}, and {@link #TOP_AREA} are values
+   * that represent the section of the view where the POINTER_DOWN event
+   * occurred. The RIGHT_AREA represents the area to the right of right guide
+   * (tilt marker).
+   */
+  private static final int RIGHT_AREA = 2;
+  /**
+   * MIN_TACK_COORDINATE The minimum padding used by {@link #panTack} and
+   * {@link #tiltTack}.
+   */
+  private static final int MIN_TACK_COORDINATE = 35;
+  /**
+   * MAX_TACK_COORDINATE The maximum padding used by {@link #panTack} and
+   * {@link #tiltTack}.
+   */
+  private static final int MAX_TACK_COORDINATE = 184;
+  /**
+   * CENTER_TACK_OFFSET The offset used to move the {@link #desiredTack} to the
+   * coordinates of the pointer.
+   */
+  private static final float CENTER_TACK_OFFSET = 16.0f;
+  /**
+   * GUIDE_LENGTH The length of the pan and tilt guides in pixels. This values
+   * is used to normalize the coordinates to -1:+1.
+   */
+  private static final float GUIDE_LENGTH = (MAX_TACK_COORDINATE - MIN_TACK_COORDINATE);
+  private static final String SHARED_PREFERENCE_NAME = "PAN_TILT_VIEW_PREFERENCE";
+  private static final String MIN_PAN_KEY_NAME = "MIN_PAN";
+  private static final String MAX_PAN_KEY_NAME = "MAX_PAN";
+  private static final String MIN_TILT_KEY_NAME = "MIN_TILT";
+  private static final String MAX_TILT_KEY_NAME = "MAX_TILT";
+  private static final String HOME_PAN_KEY_NAME = "HOME_PAN";
+  private static final String HOME_TILT_KEY_NAME = "HOME_TILT";
+
+  private Publisher<org.ros.message.sensor_msgs.JointState> publisher;
+  private Node node;
+  /**
+   * mainLayout The parent layout that contains all other elements.
+   */
+  private RelativeLayout mainLayout;
+  private ImageView[] topLargeTack;
+  private ImageView[] topSmallTack;
+  private ImageView[] rightLargeTack;
+  private ImageView[] rightSmallTack;
+  private ImageView[] zoomLitBar;
+  private ImageView desiredTack;
+  private ImageView homeIcon;
+  /**
+   * initialPointerLocation Remembers the location where DOWN occurred for the
+   * active pointer. Possible values are {@link #MIDDLE_AREA}, {@link #TOP_AREA}
+   * , and {@link #RIGHT_AREA}.
+   */
+  private int initialPointerLocation;
+  /**
+   * minPan The minimum pan value for the pan tilt device being controlled. By
+   * default the pan range is normalized from -1 (left) to 1 (right).
+   */
+  private float minPan = -1.0f;
+  /**
+   * maxPan The maximum pan value for the pan tilt device being controlled. By
+   * default the pan range is normalized from -1 (left) to 1 (right).
+   */
+  private float maxPan = 1.0f;
+  /**
+   * minTilt The minimum tilt value for the pan tilt device being controlled. By
+   * default the tilt range is normalized from -1 (down) to 1 (up).
+   */
+  private float minTilt = -1.0f;
+  /**
+   * maxTilt The maximum tilt value for the pan tilt device being controlled. By
+   * default the tilt range is normalized from -1 (down) to 1 (up).
+   */
+  private float maxTilt = 1.0f;
+  /**
+   * homePan The pan value for the home position for the pan tilt device.
+   */
+  private float homePan = 0f;
+  /**
+   * homeTilt The tilt value for the home position for the pan tilt device.
+   */
+  private float homeTilt = 0f;
+  /**
+   * pointerId Used to keep track of the contact that initiated the interaction.
+   * All other contacts are ignored.
+   */
+  private int pointerId = INVALID_POINTER_ID;
+
+  private int zoomValue = 0;
+
+  public PanTiltView(Context context) {
+    super(context);
+    // Instantiate the elements from the layout XML file.
+    LayoutInflater.from(context).inflate(org.ros.rosjava.android.R.layout.pan_tilt, this, true);
+    // Load settings (minPan, maxPan, etc) from the shared preferences.
+    loadSettings();
+    initPanTiltWidget();
+  }
+
+  /**
+   * Specify the location of the master node. Unless this method is called the
+   * widget will not be displayed and hence no messages will be published.
+   * 
+   * @param masterUri
+   *          The location of the master node.
+   */
+  public void setMasterUri(URI masterUri) {
+    // Setup the publisher first.
+    initPublisher(masterUri);
+    this.setOnTouchListener(this);
+  }
+
+  @Override
+  public boolean onTouch(View v, MotionEvent event) {
+    final int action = event.getAction();
+
+    switch (action & MotionEvent.ACTION_MASK) {
+      case MotionEvent.ACTION_MOVE: {
+        // Only proceed if the pointer that initiated the interaction is still
+        // in contact with the screen.
+        if (pointerId == INVALID_POINTER_ID) {
+          break;
+        }
+        onContactMove(event.getX(event.findPointerIndex(pointerId)),
+            event.getY(event.findPointerIndex(pointerId)));
+        break;
+      }
+      case MotionEvent.ACTION_DOWN: {
+        // Get the coordinates of the pointer that is initiating the
+        // interaction.
+        pointerId = event.getPointerId(event.getActionIndex());
+        onContactDown(event.getX(event.getActionIndex()), event.getY(event.getActionIndex()));
+        break;
+      }
+      case MotionEvent.ACTION_POINTER_UP:
+      case MotionEvent.ACTION_UP: {
+        // When any pointer (primary or otherwise) fires an UP, prevent further
+        // the interaction.
+        pointerId = INVALID_POINTER_ID;
+        initialPointerLocation = INVALID_POINTER_LOCATION;
+        break;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Calls the necessary methods to update the value(s) (pan and/or tilt) based
+   * on the pointer's initial location.
+   * 
+   * @param x
+   *          The x coordinate of the pointer relative to the parent.
+   * @param y
+   *          The y coordinate of the pointer relative to the parent.
+   */
+  private void onContactMove(float x, float y) {
+    // Since movement of the images is done relative to the bottom left of
+    // the parent, the y value needs to be updated to reflect the coordinates
+    // relative to the bottom of the parent.
+    // y = mainLayout.getHeight() - y;
+    if (initialPointerLocation == MIDDLE_AREA) {
+      updateTopTack(x);
+      updateRightTack(y);
+    } else if (initialPointerLocation == TOP_AREA) {
+      updateTopTack(x);
+    } else if (initialPointerLocation == RIGHT_AREA) {
+      updateRightTack(y);
+    } else if (x < 75 && y > 120 && y < 248) {
+      float tmp = (248 - 120) / 6;
+      if (y < 120 + tmp) {
+        zoomValue = 5;
+      } else if (y < 120 + tmp * 2) {
+        zoomValue = 4;
+      } else if (y < 120 + tmp * 3) {
+        zoomValue = 3;
+      } else if (y < 120 + tmp * 4) {
+        zoomValue = 2;
+      } else if (y < 120 + tmp * 5) {
+        zoomValue = 1;
+      } else if (y < 120 + tmp * 6) {
+        zoomValue = 0;
+      }
+      updateZoomBars();
+    }
+
+  }
+
+  /**
+   * Calls the necessary methods to update the value(s) (pan and/or tilt). Also
+   * sets the initial location based on the location of the DOWN event.
+   * 
+   * @param x
+   *          The x coordinate of the pointer relative to the parent.
+   * @param y
+   *          The y coordinate of the pointer relative to the parent.
+   */
+  private void onContactDown(float x, float y) {
+    if (x > 75 && x < 357 && y > 50 && y < 278) {
+      initialPointerLocation = MIDDLE_AREA;
+      updateTopTack(x);
+      updateRightTack(y);
+    } else if (y < 40 && x > 75 && x < 357) {
+      initialPointerLocation = TOP_AREA;
+      updateTopTack(x);
+    } else if (x > 361 && y > 45 && y < 366) {
+      initialPointerLocation = RIGHT_AREA;
+      updateRightTack(y);
+    } else if (x < 75 && y > 55 && y < 120) {
+      // Quick hack
+      zoomValue += 1;
+      if (zoomValue > 5) {
+        zoomValue = 5;
+      }
+      updateZoomBars();
+    } else if (x < 75 && y > 248) {
+      // Quick hack
+      zoomValue -= 1;
+      if (zoomValue < 0) {
+        zoomValue = 0;
+      }
+      updateZoomBars();
+    } else if (x < 75 && y > 120 && y < 248) {
+      float tmp = (248 - 120) / 6;
+      if (y < 120 + tmp) {
+        zoomValue = 5;
+      } else if (y < 120 + tmp * 2) {
+        zoomValue = 4;
+      } else if (y < 120 + tmp * 3) {
+        zoomValue = 3;
+      } else if (y < 120 + tmp * 4) {
+        zoomValue = 2;
+      } else if (y < 120 + tmp * 5) {
+        zoomValue = 1;
+      } else if (y < 120 + tmp * 6) {
+        zoomValue = 0;
+      }
+      updateZoomBars();
+    }
+
+  }
+
+  private void updateZoomBars() {
+    // Quick hack
+    for (int i = 0; i < zoomLitBar.length; i++) {
+      zoomLitBar[4 - i].setVisibility(INVISIBLE);
+    }
+    for (int i = 0; i < zoomValue; i++) {
+      zoomLitBar[4 - i].setVisibility(VISIBLE);
+    }
+  }
+
+  /**
+   * Updates the location of the tilt tack on the right and the center tack. It
+   * also calls {@link #publishTilt(float)}.
+   * 
+   * @param y
+   *          The y coordinate of the pointer relative to the bottom of the
+   *          parent.
+   */
+  private void updateRightTack(float y) {
+    float offset = desiredTack.getHeight() / 2;
+    if (y < 40.0f + offset) {
+      y = 40.0f + offset;
+    } else if (y > 278.0f - offset) {
+      y = 278.0f - offset;
+    } else if (y < (homeIcon.getTranslationY() + homeIcon.getHeight() / 5 + getHeight() / 2)
+        && y > (homeIcon.getTranslationY() + getHeight() / 2 - homeIcon.getHeight() / 5)) {
+      y = homeIcon.getTranslationY() + getHeight() / 2;
+    }
+    desiredTack.setTranslationY(y - mainLayout.getHeight() / 2);
+    publishTilt(y);
+
+    float rangeLarge = 12.0f;
+    float rangeSmall = 50.0f;
+    for (int i = 0; i < rightLargeTack.length; i++) {
+      if (Math.abs(y - mainLayout.getHeight() / 2 - rightLargeTack[i].getTranslationY()) < rangeLarge) {
+        rightLargeTack[i].setAlpha(1.0f);
+      } else {
+        rightLargeTack[i].setAlpha(0.0f);
+      }
+    }
+
+    for (int i = 0; i < rightSmallTack.length; i++) {
+      if (Math.abs(y - mainLayout.getHeight() / 2 - rightSmallTack[i].getTranslationY()) < rangeSmall) {
+        rightSmallTack[i].setAlpha(1.0f
+            - Math.abs(y - mainLayout.getHeight() / 2 - rightSmallTack[i].getTranslationY())
+            / rangeSmall);
+      } else {
+        rightSmallTack[i].setAlpha(0.0f);
+      }
+    }
+
+  }
+
+  /**
+   * Updates the location of the pan tack on the top and the center tack. It
+   * also calls {@link #publishPan(float)}.
+   * 
+   * @param x
+   *          The x coordinate of the pointer relative to the parent.
+   */
+  private void updateTopTack(float x) {
+    float offset = desiredTack.getWidth() / 2;
+    if (x < 75 + offset) {
+      x = 75 + offset;
+    } else if (x > 357 - offset) {
+      x = 357 - offset;
+    } else if (x < (homeIcon.getTranslationX() + homeIcon.getWidth() / 5 + getWidth() / 2)
+        && x > (homeIcon.getTranslationX() + getWidth() / 2 - homeIcon.getWidth() / 5)) {
+      x = homeIcon.getTranslationX() + getWidth() / 2;
+    }
+    desiredTack.setTranslationX(x - mainLayout.getWidth() / 2);
+    publishPan(x);
+
+    float rangeLarge = 13.0f;
+    float rangeSmall = 50.0f;
+    for (int i = 0; i < topLargeTack.length; i++) {
+      if (Math.abs(x - mainLayout.getWidth() / 2 - topLargeTack[i].getTranslationX()) < rangeLarge) {
+        topLargeTack[i].setAlpha(1.0f);
+        // topLargeTack[i].setAlpha(1.0f
+        // - Math.abs(x - mainLayout.getWidth() / 2 -
+        // topLargeTack[i].getTranslationX())
+        // / rangeLarge);
+      } else {
+        topLargeTack[i].setAlpha(0.0f);
+      }
+    }
+
+    for (int i = 0; i < topSmallTack.length; i++) {
+      if (Math.abs(x - mainLayout.getWidth() / 2 - topSmallTack[i].getTranslationX()) < rangeSmall) {
+        topSmallTack[i].setAlpha(1.0f
+            - Math.abs(x - mainLayout.getWidth() / 2 - topSmallTack[i].getTranslationX())
+            / rangeSmall);
+      } else {
+        topSmallTack[i].setAlpha(0.0f);
+      }
+    }
+
+  }
+
+  private void initPanTiltWidget() {
+    mainLayout = (RelativeLayout) findViewById(org.ros.rosjava.android.R.id.pan_tilt_layout);
+    desiredTack = (ImageView) findViewById(org.ros.rosjava.android.R.id.pt_divet);
+    topLargeTack = new ImageView[10];
+    topSmallTack = new ImageView[10];
+    rightLargeTack = new ImageView[7];
+    rightSmallTack = new ImageView[7];
+    for (int i = 0; i < topLargeTack.length; i++) {
+      topLargeTack[i] = new ImageView(getContext());
+      topSmallTack[i] = new ImageView(getContext());
+    }
+    topLargeTack[0] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_0);
+    topLargeTack[1] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_1);
+    topLargeTack[2] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_2);
+    topLargeTack[3] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_3);
+    topLargeTack[4] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_4);
+    topLargeTack[5] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_5);
+    topLargeTack[6] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_6);
+    topLargeTack[7] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_7);
+    topLargeTack[8] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_8);
+    topLargeTack[9] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_large_marker_9);
+    topSmallTack[0] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_0);
+    topSmallTack[1] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_1);
+    topSmallTack[2] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_2);
+    topSmallTack[3] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_3);
+    topSmallTack[4] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_4);
+    topSmallTack[5] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_5);
+    topSmallTack[6] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_6);
+    topSmallTack[7] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_7);
+    topSmallTack[8] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_8);
+    topSmallTack[9] = (ImageView) findViewById(org.ros.rosjava.android.R.id.pan_small_marker_9);
+    for (int i = 0; i < topLargeTack.length; i++) {
+      topLargeTack[i].setAlpha(0.0f);
+      topSmallTack[i].setAlpha(0.0f);
+    }
+    for (int i = 0; i < rightLargeTack.length; i++) {
+      rightLargeTack[i] = new ImageView(getContext());
+      rightSmallTack[i] = new ImageView(getContext());
+    }
+    rightLargeTack[0] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_large_marker_0);
+    rightLargeTack[1] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_large_marker_1);
+    rightLargeTack[2] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_large_marker_2);
+    rightLargeTack[3] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_large_marker_3);
+    rightLargeTack[4] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_large_marker_4);
+    rightLargeTack[5] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_large_marker_5);
+    rightLargeTack[6] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_large_marker_6);
+    rightSmallTack[0] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_small_marker_0);
+    rightSmallTack[1] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_small_marker_1);
+    rightSmallTack[2] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_small_marker_2);
+    rightSmallTack[3] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_small_marker_3);
+    rightSmallTack[4] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_small_marker_4);
+    rightSmallTack[5] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_small_marker_5);
+    rightSmallTack[6] = (ImageView) findViewById(org.ros.rosjava.android.R.id.tilt_small_marker_6);
+    for (int i = 0; i < rightLargeTack.length; i++) {
+      rightLargeTack[i].setAlpha(0.0f);
+      rightSmallTack[i].setAlpha(0.0f);
+    }
+
+    zoomLitBar = new ImageView[5];
+    zoomLitBar[0] = (ImageView) findViewById(org.ros.rosjava.android.R.id.zoom_bar_lit_0);
+    zoomLitBar[1] = (ImageView) findViewById(org.ros.rosjava.android.R.id.zoom_bar_lit_1);
+    zoomLitBar[2] = (ImageView) findViewById(org.ros.rosjava.android.R.id.zoom_bar_lit_2);
+    zoomLitBar[3] = (ImageView) findViewById(org.ros.rosjava.android.R.id.zoom_bar_lit_3);
+    zoomLitBar[4] = (ImageView) findViewById(org.ros.rosjava.android.R.id.zoom_bar_lit_4);
+
+    homeIcon = (ImageView) findViewById(org.ros.rosjava.android.R.id.pt_home_marker);
+  }
+
+  public void initPublisher(URI masterUri) {
+    try {
+      NodeConfiguration nodeConfiguration =
+          NodeConfiguration.newPublic(InetAddressFactory.newNonLoopback().getHostAddress()
+              .toString(), masterUri);
+      node = new DefaultNodeFactory().newNode("pan_tilt_view", nodeConfiguration);
+      publisher = node.newPublisher("/ptu_cmd", "sensor_msgs/JointState");
+    } catch (Exception e) {
+      if (node != null) {
+        node.getLog().fatal(e);
+      } else {
+        e.printStackTrace();
+      }
+    }
+  }
+
+  private void loadSettings() {
+    // Load the settings from the shared preferences.
+    SharedPreferences settings =
+        this.getContext().getSharedPreferences(SHARED_PREFERENCE_NAME, Context.MODE_PRIVATE);
+    settings.getFloat(MAX_PAN_KEY_NAME, maxPan);
+    settings.getFloat(MIN_PAN_KEY_NAME, minPan);
+    settings.getFloat(MAX_TILT_KEY_NAME, maxTilt);
+    settings.getFloat(MIN_TILT_KEY_NAME, minTilt);
+    settings.getFloat(HOME_PAN_KEY_NAME, homePan);
+    settings.getFloat(HOME_TILT_KEY_NAME, homeTilt);
+  }
+
+  /**
+   * Publish the pan position.
+   * 
+   * @param x
+   *          The x coordinate corrected for the tack size, but not normalized.
+   */
+  private void publishPan(float x) {
+    // Normalize the pan value from the current range to (-1:+1).
+    float pan = 1.0f - (MAX_TACK_COORDINATE - x) / GUIDE_LENGTH;
+    // Transform the normalized pan value to the pan range for the device.
+    pan = (maxPan - minPan) * pan + minPan;
+    // Initialize the message with the pan position value and publish it.
+    org.ros.message.sensor_msgs.JointState jointState =
+        new org.ros.message.sensor_msgs.JointState();
+    jointState.name = new ArrayList<String>();
+    jointState.name.add("pan");
+    jointState.position = new double[] { pan };
+    jointState.effort = new double[] {};
+    jointState.velocity = new double[] {};
+    publisher.publish(jointState);
+  }
+
+  /**
+   * Publish the tilt position.
+   * 
+   * @param y
+   *          The y coordinate corrected for the tack size, but not normalized.
+   */
+  private void publishTilt(float y) {
+    // Normalize the tilt value from the current range to (-1:+1).
+    float tilt = 1.0f - (MAX_TACK_COORDINATE - y) / GUIDE_LENGTH;
+    // Transform the normalized tilt value to the pan range for the device.
+    tilt = (maxTilt - minTilt) * tilt + minTilt;
+    // Initialize the message with the tilt position value and publish it.
+    org.ros.message.sensor_msgs.JointState jointState =
+        new org.ros.message.sensor_msgs.JointState();
+    jointState.name = new ArrayList<String>();
+    jointState.name.add("tilt");
+    jointState.position = new double[] { tilt };
+    jointState.effort = new double[] {};
+    jointState.velocity = new double[] {};
+    publisher.publish(jointState);
+  }
+
+  // Future work.
+  // private void setDefaultValues() {
+  // SharedPreferences settings =
+  // this.getContext().getSharedPreferences(SHARED_PREFERENCE_NAME,
+  // Context.MODE_PRIVATE);
+  // SharedPreferences.Editor editor = settings.edit();
+  //
+  // // Perform a synchronous atomic commit.
+  // if (!editor.commit()) {
+  // Toast toast =
+  // Toast.makeText(this.getContext(),
+  // "Could not save the settings for the pan tilt widget",
+  // Toast.LENGTH_LONG);
+  // toast.show();
+  // }
+  // }
+}

android/src/org/ros/rosjava/android/views/VirtualJoystickView.java

@@ -0,0 +1,956 @@
+/*
+ * 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.rosjava.android.views;
+
+import android.content.Context;
+import android.graphics.Point;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.MotionEvent;
+import android.view.View;
+import android.view.View.OnTouchListener;
+import android.view.animation.Animation;
+import android.view.animation.Animation.AnimationListener;
+import android.view.animation.AnimationSet;
+import android.view.animation.LinearInterpolator;
+import android.view.animation.RotateAnimation;
+import android.view.animation.ScaleAnimation;
+import android.widget.ImageView;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+import org.ros.address.InetAddressFactory;
+import org.ros.message.MessageListener;
+import org.ros.message.nav_msgs.Odometry;
+import org.ros.node.DefaultNodeFactory;
+import org.ros.node.Node;
+import org.ros.node.NodeConfiguration;
+import org.ros.node.topic.Publisher;
+
+import java.net.URI;
+import java.util.Timer;
+import java.util.TimerTask;
+
+/**
+ * VirtualJoystickView creates a virtual joystick view that publishes velocity
+ * as (geometry_msgs.Twist) messages. The current version contains the following
+ * features: snap to axes, turn in place, and resume previous velocity.
+ * 
+ * @author munjaldesai@google.com (Munjal Desai)
+ */
+public class VirtualJoystickView extends RelativeLayout implements OnTouchListener,
+    AnimationListener, MessageListener<org.ros.message.nav_msgs.Odometry> {
+
+  /**
+   * BOX_TO_CIRCLE_RATIO The dimensions of the square box that contains the
+   * circle, rings, etc are 300x300. The circles, rings, etc have a diameter of
+   * 220. The ratio of the box to the circles is 300/220 = 1.363636. This ratio
+   * stays the same regardless of the size of the virtual joystick.
+   */
+  private static final float BOX_TO_CIRCLE_RATIO = 1.363636f;
+  /**
+   * MAGNET_THETA The number of degrees before and after the major axes (0, 90,
+   * 180, and 270) where the orientation is automatically adjusted to 0, 90,
+   * 180, or 270. For example, if the contactTheta is 85 degrees and
+   * MAGNET_THETA is 10, the contactTheta will be changed to 90.
+   */
+  private float magnetTheta = 10.0f;
+  /**
+   * ORIENTATION_TACK_FADE_RANGE The range in degrees around the current
+   * orientation where the {@link #orientationWidget}s will be visible.
+   */
+  private static final float ORIENTATION_TACK_FADE_RANGE = 40.0f;
+  /**
+   * TURN_IN_PLACE_CONFIRMATION_DELAY Time (in milliseconds) to wait before
+   * visually changing to turn-in-place mode.
+   */
+  private static final long TURN_IN_PLACE_CONFIRMATION_DELAY = 200L;
+  /**
+   * FLOAT_EPSILON Used for comparing float values.
+   */
+  private static final float FLOAT_EPSILON = 0.001f;
+  /**
+   * THUMB_DIVET_RADIUS The radius of the {@link #thumbDivet}. This is also the
+   * distance threshold around the {@link #contactUpLocation} that triggers the
+   * previous-velocity-mode {@link #previousVelocityMode}. This radius is also
+   * the same for the {@link #lastVelocityDivet}.
+   */
+  private static final float THUMB_DIVET_RADIUS = 16.5f;
+  /**
+   * POST_LOCK_MAGNET_THETA Replaces {@link #magnetTheta} once the contact has
+   * been magnetized/snapped around 90/270.
+   */
+  private static final float POST_LOCK_MAGNET_THETA = 20.0f;
+  private static final int INVALID_POINTER_ID = -1;
+  private Publisher<org.ros.message.geometry_msgs.Twist> publisher;
+  private Node node;
+  /**
+   * mainLayout The parent layout that contains all the elements of the virtual
+   * joystick.
+   */
+  private RelativeLayout mainLayout;
+  /**
+   * intensity The intensity circle that is used to show the current magnitude.
+   */
+  private ImageView intensity;
+  /**
+   * thumbDivet The divet that is underneath the user's thumb. When there is no
+   * contact it moves to the center (over the center divet). An arrow inside it
+   * is used to indicate the orientation.
+   */
+  private ImageView thumbDivet;
+  /**
+   * lastVelocityDivet The divet that shows the location of last contact. If a
+   * contact is placed within ({@link #THUMB_DIVET_RADIUS}) to this, the
+   * {@link #previousVelocityMode} is triggered.
+   */
+  private ImageView lastVelocityDivet;
+  /**
+   * orientationWidget 4 long tacks on the major axes and 20 small tacks off of
+   * the major axes at 15 degree increments. These fade in and fade out to
+   * collectively indicate the current orientation.
+   */
+  private ImageView[] orientationWidget;
+  /**
+   * magnitudeIndicator Shows the current linear velocity as a percent value.
+   * This TextView will be on the opposite side of the contact to ensure that is
+   * it visible most of the time. The font size and distance from the center of
+   * the widget are automatically computed based on the size of parent
+   * container.
+   */
+  private TextView magnitudeText;
+  /** contactTheta The current orientation of the virtual joystick in degrees. */
+  private float contactTheta;
+  /**
+   * normalizedMagnitude This is the distance between the center divet and the
+   * point of contact normalized between 0 and 1. The linear velocity is based
+   * on this.
+   */
+  private float normalizedMagnitude;
+  /**
+   * contactRadius This is the distance between the center of the widget and the
+   * point of contact normalized between 0 and 1. This is mostly used for
+   * animation/display calculations.
+   * 
+   * TODO(munjaldesai): Omnigraffle this for better documentation.
+   */
+  private float contactRadius;
+  /**
+   * deadZoneRatio ...
+   * 
+   * TODO(munjaldesai): Write a simple explanation for this. Currently not easy
+   * to immediately comprehend it's meaning.
+   * 
+   * TODO(munjaldesai): Omnigraffle this for better documentation.
+   */
+  private float deadZoneRatio = Float.NaN;
+  /**
+   * joystickRadius The center coordinates of the parent layout holding all the
+   * elements of the virtual joystick. The coordinates are relative to the
+   * immediate parent (mainLayout). Since the parent must be a square centerX =
+   * centerY = radius.
+   */
+  private float joystickRadius = Float.NaN;
+  /**
+   * parentSize The length (width==height ideally) of a side of the parent
+   * container that holds the virtual joystick.
+   */
+  private float parentSize = Float.NaN;
+  /**
+   * normalizingMultiplier Used to convert any distance from pixels to a
+   * normalized value between 0 and 1. 0 is the center of widget and 1 is the
+   * normalized distance to the {@link #outerRing} from the center of the
+   * widget.
+   */
+  private float normalizingMultiplier;
+  /**
+   * currentRotationRange The (15 degree) green slice/arc used to indicate
+   * turn-in-place behavior.
+   */
+  private ImageView currentRotationRange;
+  /**
+   * previousRotationRange The (30 degree) green slice/arc used to indicate
+   * turn-in-place behavior.
+   */
+  private ImageView previousRotationRange;
+  /**
+   * turnInPlaceMode True when the virtual joystick is in turn-in-place mode.
+   * False otherwise.
+   */
+  private volatile boolean turnInPlaceMode;
+  /**
+   * turnInPlaceStartTheta The orientation of the robot when the turn-in-place
+   * mode is initiated.
+   */
+  private float turnInPlaceStartTheta = Float.NaN;
+  /**
+   * rightTurnOffset The rotation offset in degrees applied to
+   * {@link #currentRotationRange} and {@link #previousRotationRange} when the
+   * robot is turning clockwise (right) in turn-in-place mode.
+   */
+  private float rightTurnOffset;
+  /**
+   * currentOrientation The orientation of the robot in degrees.
+   */
+  private volatile float currentOrientation;
+  /**
+   * pointerId Used to keep track of the contact that initiated the interaction
+   * with the virtual joystick. All other contacts are ignored.
+   */
+  private int pointerId = INVALID_POINTER_ID;
+  /**
+   * contactUpLocation The location of the primary contact when it is lifted off
+   * of the screen.
+   */
+  private Point contactUpLocation;
+  /**
+   * previousVelocityMode True when the new contact position is within
+   */
+  private boolean previousVelocityMode;
+  /**
+   * magnetizedXAxis True when the contact has been snapped to the x-axis, false
+   * otherwise.
+   */
+  private boolean magnetizedXAxis;
+  /**
+   * Velocity commands are published when this is true. Not published otherwise.
+   * This is to prevent spamming velocity commands.
+   */
+  private volatile boolean publishVelocity;
+  /**
+   * Used to publish velocity commands at a specific rate.
+   */
+  private Timer publisherTimer;
+  org.ros.message.geometry_msgs.Twist vel = new org.ros.message.geometry_msgs.Twist();
+  TimerTask timerTask = new TimerTask() {
+    @Override
+    public void run() {
+      if (publishVelocity) {
+        publisher.publish(vel);
+      }
+    }
+  };
+
+  public VirtualJoystickView(Context context) {
+    super(context);
+    // All the virtual joystick elements must be centered on the parent.
+    setGravity(Gravity.CENTER);
+    // Instantiate the elements from the layout XML file.
+    LayoutInflater.from(context).inflate(org.ros.rosjava.android.R.layout.virtual_joystick, this,
+        true);
+    initVirtualJoystick();
+  }
+
+  /**
+   * Initialize the node and register the publisher and subscriber.
+   * 
+   * @param masterUri
+   *          The address of the master node.
+   */
+  private void initNode(final URI masterUri) {
+    try {
+      NodeConfiguration nodeConfiguration =
+          NodeConfiguration.newPublic(InetAddressFactory.newNonLoopback().getHostAddress()
+              .toString(), masterUri);
+      node = new DefaultNodeFactory().newNode("virtual_joystick", nodeConfiguration);
+      publisher = node.newPublisher("cmd_vel", "geometry_msgs/Twist");
+      node.newSubscriber("odom", "nav_msgs/Odometry", this);
+      publisherTimer.schedule(timerTask, 0, 80);
+    } catch (Exception e) {
+      if (node != null) {
+        node.getLog().fatal(e);
+      } else {
+        android.util.Log.e("VIRTUAL_JOYSTICK", e.toString());
+      }
+    }
+  }
+
+  @Override
+  public void onAnimationEnd(Animation animation) {
+    contactRadius = 0f;
+    normalizedMagnitude = 0f;
+    updateMagnitudeText();
+  }
+
+  @Override
+  public void onAnimationRepeat(Animation animation) {
+  }
+
+  @Override
+  public void onAnimationStart(Animation animation) {
+  }
+
+  @Override
+  public void onNewMessage(final Odometry message) {
+    double heading;
+    // For some reason the values of z and y seem to be interchanged. If they
+    // are not swapped then heading is always incorrect.
+    double w = message.pose.pose.orientation.w;
+    double x = message.pose.pose.orientation.x;
+    double y = message.pose.pose.orientation.z;
+    double z = message.pose.pose.orientation.y;
+    heading = Math.atan2(2 * y * w - 2 * x * z, x * x - y * y - z * z + w * w) * 180 / Math.PI;
+    // Negating the orientation to make the math for rotation in
+    // turn-in-place mode easy. Since the actual heading is irrelevant it does
+    // no harm.
+    currentOrientation = (float) -heading;
+    // Only update the orientation images if the turn-in-place mode is active.
+    if (turnInPlaceMode) {
+      post(new Runnable() {
+        @Override
+        public void run() {
+          updateTurnInPlaceRotation();
+        }
+      });
+      postInvalidate();
+    }
+  }
+
+  @Override
+  public boolean onTouch(View v, MotionEvent event) {
+    final int action = event.getAction();
+    switch (action & MotionEvent.ACTION_MASK) {
+      case MotionEvent.ACTION_MOVE: {
+        // If the primary contact point is no longer on the screen then ignore
+        // the event.
+        if (pointerId != INVALID_POINTER_ID) {
+          // If the virtual joystick is in resume-previous-velocity mode.
+          if (previousVelocityMode) {
+            // And the current contact is close to the contact location prior to
+            // ContactUp.
+            if (inLastContactRange(event.getX(event.getActionIndex()),
+                event.getY(event.getActionIndex()))) {
+              // Then use the previous velocity.
+              onContactMove(contactUpLocation.x + joystickRadius, contactUpLocation.y
+                  + joystickRadius);
+            }
+            // Since the current contact is not close to the prior location.
+            else {
+              // Exit the resume-previous-velocity mode.
+              previousVelocityMode = false;
+            }
+          }
+          // Since the resume-previous-velocity mode is not active generate
+          // velocities based on current contact position.
+          else {
+            onContactMove(event.getX(event.findPointerIndex(pointerId)),
+                event.getY(event.findPointerIndex(pointerId)));
+          }
+        }
+        break;
+      }
+      case MotionEvent.ACTION_DOWN: {
+        // Get the coordinates of the pointer that is initiating the
+        // interaction.
+        pointerId = event.getPointerId(event.getActionIndex());
+        onContactDown();
+        // If the current contact is close to the location of the contact prior
+        // to contactUp.
+        if (inLastContactRange(event.getX(event.getActionIndex()),
+            event.getY(event.getActionIndex()))) {
+          // Trigger resume-previous-velocity mode.
+          previousVelocityMode = true;
+          // The animation calculations/operations are performed in
+          // onContactMove(). If this is not called and the user's finger stays
+          // perfectly still after the down event, no operation is performed.
+          // Calling onContactMove avoids this.
+          onContactMove(contactUpLocation.x + joystickRadius, contactUpLocation.y + joystickRadius);
+        } else {
+          onContactMove(event.getX(event.getActionIndex()), event.getY(event.getActionIndex()));
+        }
+        break;
+      }
+      case MotionEvent.ACTION_POINTER_UP:
+      case MotionEvent.ACTION_UP: {
+        // Check if the contact that initiated the interaction is up.
+        if ((action & MotionEvent.ACTION_POINTER_ID_MASK) >> MotionEvent.ACTION_POINTER_ID_SHIFT == pointerId) {
+          onContactUp();
+        }
+        break;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Allows the user the option to turn on the auto-snap feature.
+   */
+  public void EnableSnapping() {
+    magnetTheta = 10;
+  }
+
+  /**
+   * Allows the user the option to turn off the auto-snap feature.
+   */
+  public void DisableSnapping() {
+    magnetTheta = 1;
+  }
+
+  /**
+   * Initialize the fields with values that can only be determined once the
+   * layout for the views has been determined.
+   */
+  @Override
+  protected void onLayout(boolean changed, int l, int t, int r, int b) {
+    // Call the parent's onLayout to setup the views.
+    super.onLayout(changed, l, t, r, b);
+    // The parent container must be a square. A square container simplifies the
+    // code. A non-square container does not provide any benefit over a
+    // square.
+    if (mainLayout.getWidth() != mainLayout.getHeight()) {
+      // TODO(munjaldesai): Need to throw an exception/error. For now the
+      // touch events will not be processed.
+      this.setOnTouchListener(null);
+    }
+    parentSize = mainLayout.getWidth();
+    if (parentSize < 200 || parentSize > 400) {
+      // TODO: Need to throw an exception for attempting to create
+      // a virtual joystick that is either too small or too big. For now the
+      // touch events will be processed.
+      this.setOnTouchListener(null);
+    }
+    // Calculate the center coordinates (radius) of parent container
+    // (mainLayout).
+    joystickRadius = mainLayout.getWidth() / 2;
+    normalizingMultiplier = BOX_TO_CIRCLE_RATIO / (parentSize / 2);
+    // Calculate the radius of the center divet as a normalize value.
+    deadZoneRatio = THUMB_DIVET_RADIUS * normalizingMultiplier;
+    // Determine the font size for the text view showing linear velocity. 8.3%
+    // of the overall size seems to work well.
+    magnitudeText.setTextSize(parentSize / 12);
+  }
+
+  /**
+   * Scale and rotate the intensity circle instantaneously. The key difference
+   * between this method and {@link #animateIntensityCircle(float, long)} is
+   * that this method does not attach an animation listener and the animation is
+   * instantaneous.
+   * 
+   * @param endScale
+   *          The scale factor that must be attained at the end of the
+   *          animation.
+   */
+  private void animateIntensityCircle(float endScale) {
+    AnimationSet intensityCircleAnimation = new AnimationSet(true);
+    intensityCircleAnimation.setInterpolator(new LinearInterpolator());
+    intensityCircleAnimation.setFillAfter(true);
+    RotateAnimation rotateAnim;
+    rotateAnim = new RotateAnimation(contactTheta, contactTheta, joystickRadius, joystickRadius);
+    rotateAnim.setInterpolator(new LinearInterpolator());
+    rotateAnim.setDuration(0);
+    rotateAnim.setFillAfter(true);
+    intensityCircleAnimation.addAnimation(rotateAnim);
+    ScaleAnimation scaleAnim;
+    scaleAnim =
+        new ScaleAnimation(contactRadius, endScale, contactRadius, endScale, joystickRadius,
+            joystickRadius);
+    scaleAnim.setDuration(0);
+    scaleAnim.setFillAfter(true);
+    intensityCircleAnimation.addAnimation(scaleAnim);
+    // Apply the animation.
+    intensity.startAnimation(intensityCircleAnimation);
+  }
+
+  /**
+   * Scale and rotate the intensity circle over the specified duration. Unlike
+   * {@link #animateIntensityCircle(float)} this method registers an animation
+   * listener.
+   * 
+   * @param endScale
+   *          The scale factor that must be attained at the end of the
+   *          animation.
+   * @param duration
+   *          The duration in milliseconds the animation should take.
+   */
+  private void animateIntensityCircle(float endScale, long duration) {
+    AnimationSet intensityCircleAnimation = new AnimationSet(true);
+    intensityCircleAnimation.setInterpolator(new LinearInterpolator());
+    intensityCircleAnimation.setFillAfter(true);
+    // The listener is needed to set the magnitude text to 0 only after the
+    // animation is over.
+    intensityCircleAnimation.setAnimationListener(this);
+    RotateAnimation rotateAnim;
+    rotateAnim = new RotateAnimation(contactTheta, contactTheta, joystickRadius, joystickRadius);
+    rotateAnim.setInterpolator(new LinearInterpolator());
+    rotateAnim.setDuration(duration);
+    rotateAnim.setFillAfter(true);
+    intensityCircleAnimation.addAnimation(rotateAnim);
+    ScaleAnimation scaleAnim;
+    scaleAnim =
+        new ScaleAnimation(contactRadius, endScale, contactRadius, endScale, joystickRadius,
+            joystickRadius);
+    scaleAnim.setDuration(duration);
+    scaleAnim.setFillAfter(true);
+    intensityCircleAnimation.addAnimation(scaleAnim);
+    // Apply the animation.
+    intensity.startAnimation(intensityCircleAnimation);
+  }
+
+  /**
+   * Fade in and fade out the {@link #orientationWidget}s. The widget best
+   * aligned with the {@link #contactTheta} will be the brightest and the
+   * successive ones within {@link #ORIENTATION_TACK_FADE_RANGE} the will be
+   * faded out proportionally. The tacks out of that range will have alpha set
+   * to 0.
+   */
+  private void animateOrientationWidgets() {
+    float deltaTheta;
+    for (int i = 0; i < orientationWidget.length; i++) {
+      deltaTheta = differenceBetweenAngles(i * 15, contactTheta);
+      if (deltaTheta < ORIENTATION_TACK_FADE_RANGE) {
+        orientationWidget[i].setAlpha(1.0f - deltaTheta / ORIENTATION_TACK_FADE_RANGE);
+      } else {
+        orientationWidget[i].setAlpha(0.0f);
+      }
+    }
+  }
+
+  /**
+   * From http://actionsnippet.com/?p=1451. Calculates the difference between 2
+   * angles. The result is always the minimum difference between 2 angles (0<
+   * result <= 360).
+   * 
+   * @param angle0
+   *          One of 2 angles used to calculate difference. The order of
+   *          arguments does not matter. Must be in degrees.
+   * @param angle1
+   *          One of 2 angles used to calculate difference. The order of
+   *          arguments does not matter. Must be in degrees.
+   * @return The difference between the 2 arguments in degrees.
+   */
+  private float differenceBetweenAngles(float angle0, float angle1) {
+    return Math.abs((angle0 + 180 - angle1) % 360 - 180);
+  }
+
+  /**
+   * Sets {@link #turnInPlaceMode} to false indicating that the turn-in-place is
+   * no longer active. It also changes the alpha values appropriately.
+   */
+  private void endTurnInPlaceRotation() {
+    turnInPlaceMode = false;
+    currentRotationRange.setAlpha(0.0f);
+    previousRotationRange.setAlpha(0.0f);
+    intensity.setAlpha(1.0f);
+  }
+
+  /**
+   * Sets up the visual elements of the virtual joystick.
+   */
+  private void initVirtualJoystick() {
+    mainLayout =
+        (RelativeLayout) findViewById(org.ros.rosjava.android.R.id.virtual_joystick_layout);
+    magnitudeText = (TextView) findViewById(org.ros.rosjava.android.R.id.magnitude);
+    intensity = (ImageView) findViewById(org.ros.rosjava.android.R.id.intensity);
+    thumbDivet = (ImageView) findViewById(org.ros.rosjava.android.R.id.thumb_divet);
+    orientationWidget = new ImageView[24];
+    for (ImageView widget : orientationWidget) {
+      widget = new ImageView(getContext());
+    }
+    orientationWidget[0] = (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_0_degrees);
+    orientationWidget[1] = (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_15_degrees);
+    orientationWidget[2] = (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_30_degrees);
+    orientationWidget[3] = (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_45_degrees);
+    orientationWidget[4] = (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_60_degrees);
+    orientationWidget[5] = (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_75_degrees);
+    orientationWidget[6] = (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_90_degrees);
+    orientationWidget[7] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_105_degrees);
+    orientationWidget[8] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_120_degrees);
+    orientationWidget[9] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_135_degrees);
+    orientationWidget[10] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_150_degrees);
+    orientationWidget[11] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_165_degrees);
+    orientationWidget[12] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_180_degrees);
+    orientationWidget[13] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_195_degrees);
+    orientationWidget[14] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_210_degrees);
+    orientationWidget[15] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_225_degrees);
+    orientationWidget[16] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_240_degrees);
+    orientationWidget[17] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_255_degrees);
+    orientationWidget[18] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_270_degrees);
+    orientationWidget[19] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_285_degrees);
+    orientationWidget[20] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_300_degrees);
+    orientationWidget[21] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_315_degrees);
+    orientationWidget[22] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_330_degrees);
+    orientationWidget[23] =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.widget_345_degrees);
+    // Initially hide all the widgets.
+    for (ImageView tack : orientationWidget) {
+      tack.setAlpha(0.0f);
+      tack.setVisibility(INVISIBLE);
+    }
+    // The value (radius) 40 is arbitrary, but small enough to work for the
+    // smallest sized virtual joystick. Once the layout is set a value is
+    // calculated based on the size of the virtual joystick.
+    magnitudeText.setTranslationX((float) (40 * Math.cos((90 + contactTheta) * Math.PI / 180.0)));
+    magnitudeText.setTranslationY((float) (40 * Math.sin((90 + contactTheta) * Math.PI / 180.0)));
+    // Hide the intensity circle.
+    animateIntensityCircle(0);
+    // Initially the orientationWidgets should point to 0 degrees.
+    contactTheta = 0;
+    animateOrientationWidgets();
+    currentRotationRange = (ImageView) findViewById(org.ros.rosjava.android.R.id.top_angle_slice);
+    previousRotationRange = (ImageView) findViewById(org.ros.rosjava.android.R.id.mid_angle_slice);
+    // Hide the slices/arcs used during the turn-in-place mode.
+    currentRotationRange.setAlpha(0.0f);
+    previousRotationRange.setAlpha(0.0f);
+    lastVelocityDivet =
+        (ImageView) findViewById(org.ros.rosjava.android.R.id.previous_velocity_divet);
+    contactUpLocation = new Point(0, 0);
+    for (ImageView tack : orientationWidget) {
+      tack.setVisibility(INVISIBLE);
+    }
+    // Create a timer.
+    publisherTimer = new Timer();
+  }
+
+  /**
+   * Update the virtual joystick to indicate a contact down has occurred.
+   */
+  private void onContactDown() {
+    // The divets should be completely opaque indicating
+    // the virtual joystick is active.
+    thumbDivet.setAlpha(1.0f);
+    magnitudeText.setAlpha(1.0f);
+    // Previous contact location need not be shown any more.
+    lastVelocityDivet.setAlpha(0.0f);
+    // Restore the orientation tacks.
+    for (ImageView tack : orientationWidget) {
+      tack.setVisibility(VISIBLE);
+    }
+    publishVelocity = true;
+  }
+
+  /**
+   * Updates the virtual joystick layout based on the location of the contact.
+   * Generates the velocity messages. Switches in and out of turn-in-place.
+   * 
+   * @param x
+   *          The x coordinates of the contact relative to the parent container.
+   * @param y
+   *          The y coordinates of the contact relative to the parent container.
+   */
+  private void onContactMove(float x, float y) {
+    // Get the coordinates of the contact relative to the center of the main
+    // layout.
+    float thumbDivetX = x - joystickRadius;
+    float thumbDivetY = y - joystickRadius;
+    // Convert the coordinates from Cartesian to Polar.
+    contactTheta = (float) (Math.atan2(thumbDivetY, thumbDivetX) * 180 / Math.PI + 90);
+    contactRadius =
+        (float) Math.sqrt(thumbDivetX * thumbDivetX + thumbDivetY * thumbDivetY)
+            * normalizingMultiplier;
+    // Calculate the distance (0 to 1) from the center divet to the contact
+    // point.
+    normalizedMagnitude = (contactRadius - deadZoneRatio) / (1 - deadZoneRatio);
+    // Perform bounds checking.
+    if (contactRadius >= 1f) {
+      // Since the contact is outside the outer ring, reset the coordinate for
+      // the thumb divet to the on the outer ring.
+      thumbDivetX /= contactRadius;
+      thumbDivetY /= contactRadius;
+      // The magnitude should not exceed 1.
+      normalizedMagnitude = 1f;
+      contactRadius = 1f;
+    } else if (contactRadius < deadZoneRatio) {
+      // Since the contact is inside the dead zone snap the thumb divet to the
+      // dead zone. It should stay there till the contact gets outside the
+      // deadzone area.
+      thumbDivetX = 0;
+      thumbDivetY = 0;
+      // Prevent normalizedMagnitude going negative inside the deadzone.
+      normalizedMagnitude = 0f;
+    }
+
+    // Magnetize!
+    // If the contact is not snapped to the x axis.
+    if (!magnetizedXAxis) {
+      // Check if the contact should be snapped to either axis.
+      if ((contactTheta + 360) % 90 < magnetTheta) {
+        // If the current angle is within MAGNET_THETA degrees + 0, 90, 180, or
+        // 270 then subtract the additional degrees so that the current theta is
+        // 0, 90, 180, or 270.
+        contactTheta -= ((contactTheta + 360) % 90);
+      } else if ((contactTheta + 360) % 90 > (90 - magnetTheta)) {
+        // If the current angle is within MAGNET_THETA degrees - 0, 90, 180, or
+        // 270 then add the additional degrees so that the current theta is 0,
+        // 90, 180, or 270.
+        contactTheta += (90 - ((contactTheta + 360) % 90));
+      }
+      // Indicate that the contact has been snapped to the x-axis.
+      if (floatCompare(contactTheta, 90) || floatCompare(contactTheta, 270)) {
+        magnetizedXAxis = true;
+      }
+    } else {
+      // Use a wider range to keep the contact snapped in.
+      if (differenceBetweenAngles((contactTheta + 360) % 360, 90) < POST_LOCK_MAGNET_THETA) {
+        contactTheta = 90;
+      } else if (differenceBetweenAngles((contactTheta + 360) % 360, 270) < POST_LOCK_MAGNET_THETA) {
+        contactTheta = 270;
+      }
+      // Indicate that the contact is not snapped to the x-axis.
+      else {
+        magnetizedXAxis = false;
+      }
+    }
+
+    // Update the size and location (scale and rotation) of various elements.
+    animateIntensityCircle(contactRadius);
+    animateOrientationWidgets();
+    updateThumbDivet(thumbDivetX, thumbDivetY);
+    updateMagnitudeText();
+    // Publish the velocities.
+    publishVelocity(normalizedMagnitude * Math.cos(contactTheta * Math.PI / 180.0),
+        normalizedMagnitude * Math.sin(contactTheta * Math.PI / 180.0));
+    // Check if the turn-in-place mode needs to be activated/deactivated.
+    updateTurnInPlaceMode();
+  }
+
+  /**
+   * Enable/Disable turn-in-place mode.
+   */
+  private void updateTurnInPlaceMode() {
+    if (!turnInPlaceMode) {
+      if (floatCompare(contactTheta, 270)) {
+        // If the user is turning left and the turn-in-place mode is not active
+        // then activate it for a left turn.
+        turnInPlaceMode = true;
+        rightTurnOffset = 0;
+      } else if (floatCompare(contactTheta, 90)) {
+        // If the user is turning right and the turn-in-place mode is not active
+        // then activate it for a right turn.
+        turnInPlaceMode = true;
+        rightTurnOffset = 15;
+      } else {
+        // Nothing to do while not in turn-in-place mode and not at 270/90.
+        return;
+      }
+      // Initiate the turn-in-place mode but wait some time before changing the
+      // images. This is to avoid the users getting seizures because of the
+      // quick changes every time they cross 270 or 90.
+      initiateTurnInPlace();
+      // Start a timer and if the user is still turning in place when the timer
+      // is up, then visually indicate entering turn-in-place mode.
+      new Timer().schedule(new TimerTask() {
+        @Override
+        public void run() {
+          post(new Runnable() {
+            @Override
+            public void run() {
+              if (turnInPlaceMode) {
+                currentRotationRange.setAlpha(1.0f);
+                previousRotationRange.setAlpha(1.0f);
+                intensity.setAlpha(0.2f);
+              }
+            }
+          });
+          postInvalidate();
+        }
+      }, TURN_IN_PLACE_CONFIRMATION_DELAY);
+    } else if (!(floatCompare(contactTheta, 270) || floatCompare(contactTheta, 90))) {
+      // If the user was in turn-in-place mode and is now no longer on the x
+      // axis, then exit turn-in-place mode.
+      endTurnInPlaceRotation();
+    }
+  }
+
+  /**
+   * The divets and the ring are made transparent to reflect that the virtual
+   * joystick is no longer active. The intensity circle is slowly scaled to 0.
+   */
+  private void onContactUp() {
+    // TODO(munjaldesai): The 1000 should eventually be replaced with a number
+    // that reflects the physical characteristics of the motor controller along
+    // with the latency associated with the connection.
+    animateIntensityCircle(0, (long) (normalizedMagnitude * 1000));
+    magnitudeText.setAlpha(0.4f);
+    // Place the lastVelocityDivet at the location of the last known contact.
+    lastVelocityDivet.setTranslationX(thumbDivet.getTranslationX());
+    lastVelocityDivet.setTranslationY(thumbDivet.getTranslationY());
+    lastVelocityDivet.setAlpha(0.4f);
+    contactUpLocation.x = (int) (thumbDivet.getTranslationX());
+    contactUpLocation.y = (int) (thumbDivet.getTranslationY());
+    // Move the thumb divet back to the center.
+    updateThumbDivet(0, 0);
+    // Reset the pointer id.
+    pointerId = INVALID_POINTER_ID;
+    // The robot should stop moving.
+    publishVelocity(0, 0);
+    // Turn-in-place should not be active anymore.
+    endTurnInPlaceRotation();
+    // Hide the orientation tacks.
+    for (ImageView tack : orientationWidget) {
+      tack.setVisibility(INVISIBLE);
+    }
+    // Stop publishing the velocity since the contact is no longer on the
+    // screen.
+    publishVelocity = false;
+  }
+
+  /**
+   * Publish the velocity as a ROS Twist message.
+   * 
+   * @param linearV
+   *          The normalized linear velocity (-1 to 1).
+   * @param angularV
+   *          The normalized angular velocity (-1 to 1).
+   */
+  private void publishVelocity(double linearV, double angularV) {
+    vel.linear.x = linearV;
+    vel.linear.y = 0;
+    vel.linear.z = 0;
+    vel.angular.x = 0;
+    vel.angular.y = 0;
+    vel.angular.z = -angularV;
+  }
+
+  /**
+   * Specify the location of the master node to which the velocity messages will
+   * be published. Unless this method is called no messages will be published.
+   * 
+   * @param masterUri
+   *          The location of the master node.
+   */
+  public void setMasterUri(URI masterUri) {
+    // Setup the publisher first.
+    initNode(masterUri);
+    this.setOnTouchListener(this);
+  }
+
+  /**
+   * Called each time turn-in-place mode is initiated.
+   */
+  private void initiateTurnInPlace() {
+    // Record the orientation when the turn-in-place was initiated.
+    turnInPlaceStartTheta = (currentOrientation + 360) % 360;
+    RotateAnimation rotateAnim;
+    rotateAnim =
+        new RotateAnimation(rightTurnOffset, rightTurnOffset, joystickRadius, joystickRadius);
+    rotateAnim.setInterpolator(new LinearInterpolator());
+    rotateAnim.setDuration(0);
+    rotateAnim.setFillAfter(true);
+    currentRotationRange.startAnimation(rotateAnim);
+    rotateAnim = new RotateAnimation(15, 15, joystickRadius, joystickRadius);
+    rotateAnim.setInterpolator(new LinearInterpolator());
+    rotateAnim.setDuration(0);
+    rotateAnim.setFillAfter(true);
+    previousRotationRange.startAnimation(rotateAnim);
+  }
+
+  /**
+   * Update the linear velocity text view.
+   */
+  private void updateMagnitudeText() {
+    // Don't update when the user is turning in place.
+    if (!turnInPlaceMode) {
+      magnitudeText.setText(String.valueOf((int) (normalizedMagnitude * 100)) + "%");
+      magnitudeText.setTranslationX((float) (parentSize / 4 * Math.cos((90 + contactTheta)
+          * Math.PI / 180.0)));
+      magnitudeText.setTranslationY((float) (parentSize / 4 * Math.sin((90 + contactTheta)
+          * Math.PI / 180.0)));
+    }
+  }
+
+  /**
+   * Based on the difference between the current orientation and the orientation
+   * when the turn-in-place mode was initiated, update the visuals.
+   */
+  private void updateTurnInPlaceRotation() {
+    final float currentTheta = (currentOrientation + 360) % 360;
+    float offsetTheta;
+    // Calculate the difference between the orientations.
+    offsetTheta = (turnInPlaceStartTheta - currentTheta + 360) % 360;
+    offsetTheta = 360 - offsetTheta;
+    // Show the current rotation amount.
+    magnitudeText.setText(String.valueOf((int) offsetTheta));
+    // Calculate theta in increments of 15 degrees. (0-14 => 0, 15-29=>15, etc).
+    offsetTheta = (int) (offsetTheta - (offsetTheta % 15));
+    // Rotate the 2 arcs based on the offset in orientation.
+    RotateAnimation rotateAnim;
+    rotateAnim =
+        new RotateAnimation(offsetTheta + rightTurnOffset, offsetTheta + rightTurnOffset,
+            joystickRadius, joystickRadius);
+    rotateAnim.setInterpolator(new LinearInterpolator());
+    rotateAnim.setDuration(0);
+    rotateAnim.setFillAfter(true);
+    currentRotationRange.startAnimation(rotateAnim);
+    rotateAnim =
+        new RotateAnimation(offsetTheta + 15, offsetTheta + 15, joystickRadius, joystickRadius);
+    rotateAnim.setInterpolator(new LinearInterpolator());
+    rotateAnim.setDuration(0);
+    rotateAnim.setFillAfter(true);
+    previousRotationRange.startAnimation(rotateAnim);
+  }
+
+  /**
+   * Moves the {@link #thumbDivet} to the specified coordinates (under the
+   * contact) and also orients it so that is facing the direction opposite to
+   * the center of the {@link #mainLayout}.
+   * 
+   * @param x
+   *          The x coordinate relative to the center of the {@link #mainLayout}
+   * @param y
+   *          The Y coordinate relative to the center of the {@link #mainLayout}
+   */
+  private void updateThumbDivet(float x, float y) {
+    // Offset the specified coordinates to ensure that the center of the thumb
+    // divet is under the thumb.
+    thumbDivet.setTranslationX(-THUMB_DIVET_RADIUS);
+    thumbDivet.setTranslationY(-THUMB_DIVET_RADIUS);
+    // Set the orientation. This must be done before translation.
+    thumbDivet.setRotation(contactTheta);
+    thumbDivet.setTranslationX(x);
+    thumbDivet.setTranslationY(y);
+  }
+
+  /**
+   * Comparing 2 float values.
+   * 
+   * @param v1
+   * @param v2
+   * @return True if v1 and v2 and within {@value #FLOAT_EPSILON} of each other.
+   *         False otherwise.
+   */
+  private boolean floatCompare(float v1, float v2) {
+    if (Math.abs(v1 - v2) < FLOAT_EPSILON) {
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  private boolean inLastContactRange(float x, float y) {
+    if (Math.sqrt((x - contactUpLocation.x - joystickRadius)
+        * (x - contactUpLocation.x - joystickRadius) + (y - contactUpLocation.y - joystickRadius)
+        * (y - contactUpLocation.y - joystickRadius)) < THUMB_DIVET_RADIUS) {
+      return true;
+    }
+    return false;
+  }
+}

android/src/org/ros/rosjava/android/views/ZoomMode.java

@@ -0,0 +1,40 @@
+/*
+ * 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.rosjava.android.views;
+
+/**
+ * @author munjaldesai@google.com (Munjal Desai)
+ */
+public enum ZoomMode {
+  /**
+   * In the CLUTTER_ZOOM_MODE the {@link DistanceView} will auto adjust the
+   * level of zoom based on proximity to objects near by. The view will zoom in
+   * further when there are objects closer to the robot and vice versa.
+   */
+  CLUTTER_ZOOM_MODE,
+  /**
+   * In the VELOCITY_ZOOM_MODE the {@link DistanceView} will auto adjust the
+   * level of zoom based on the current linear velocity of the robot. The faster
+   * the robot moves the move zoomed out the view will be.
+   */
+  VELOCITY_ZOOM_MODE,
+  /**
+   * In CUSTOM_ZOOM_MODE the {@link DistanceView} allows the user to change the
+   * zoom level via pinch and reverse-pinch gestures.
+   */
+  CUSTOM_ZOOM_MODE
+}