Add java files

android/java/.gitignore

@@ -0,0 +1,14 @@
+# Gradle files
+.gradle/
+
+# IntelliJ files
+.idea
+*.iml
+
+# Build files
+build/
+*/build/
+*.so
+
+# Local settings
+local.properties

android/java/app/build.gradle

@@ -0,0 +1,23 @@
+apply plugin: 'com.android.application'
+
+android {
+    compileSdkVersion 19
+    buildToolsVersion "21.1.0"
+
+    defaultConfig {
+        applicationId "com.mapbox.mapboxgl.app"
+        minSdkVersion 19
+        targetSdkVersion 20
+    }
+
+    buildTypes {
+        release {
+            runProguard false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+    }
+}
+
+dependencies {
+    compile project(':lib')
+}

android/java/app/lint.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<lint>
+    <issue id="HardcodedDebugMode" severity="warning" />
+</lint>

android/java/app/src/main/AndroidManifest.xml

@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.mapbox.mapboxgl.app"
+    android:versionCode="1"
+    android:versionName="1.0" >
+    
+    <uses-feature android:glEsVersion="0x00020000" />
+    
+    <uses-permission android:name="android.permission.INTERNET"/>
+
+    <application
+        android:allowBackup="false"
+        android:icon="@drawable/ic_launcher"
+        android:label="@string/app_name"
+        android:theme="@style/AppTheme" >
+        <activity
+            android:name="com.mapbox.mapboxgl.app.MainActivity"
+            android:label="@string/app_name"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenSize|smallestScreenSize">
+        </activity>
+        <activity
+            android:name="com.mapbox.mapboxgl.app.FragmentActivity"
+            android:label="@string/app_name"
+            android:configChanges="keyboard|keyboardHidden|orientation|screenSize|smallestScreenSize">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+
+</manifest>

android/java/app/src/main/java/com/mapbox/mapboxgl/app/FragmentActivity.java

@@ -0,0 +1,29 @@
+package com.mapbox.mapboxgl.app;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+
+public class FragmentActivity extends Activity {
+
+    //
+    // Static members
+    //
+
+    // Tag used for logging
+    private static final String TAG = "FragmentActivity";
+
+    //
+    // Lifecycle events
+    //
+
+    // Called when activity is created
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        Log.v(TAG, "onCreate");
+
+        // Load the layout
+        setContentView(R.layout.activity_fragment);
+    }
+}

android/java/app/src/main/java/com/mapbox/mapboxgl/app/MainActivity.java

@@ -0,0 +1,98 @@
+package com.mapbox.mapboxgl.app;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.util.Log;
+
+import com.mapbox.mapboxgl.lib.MapView;
+
+public class MainActivity extends Activity {
+
+    //
+    // Static members
+    //
+
+    // Tag used for logging
+    private static final String TAG = "MainActivity";
+
+    // The map
+    private MapView mMapView;
+
+    //
+    // Lifecycle events
+    //
+
+    // Called when the activity is created
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        Log.v(TAG, "onCreate");
+
+        // Load the layout
+        setContentView(R.layout.activity_main);
+        mMapView = (MapView) findViewById(R.id.map);
+
+        // Need to pass on any saved state to the map
+        mMapView.onCreate(savedInstanceState);
+    }
+
+    // Called when the activity is destroyed
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+        Log.v(TAG, "onDestroy");
+
+        // Need to pass on to view
+        mMapView.onDestroy();
+    }
+
+    // Called when the activity is visible
+    @Override
+    protected void onStart() {
+        super.onStart();
+        Log.v(TAG, "onStart");
+
+        // Need to pass on to view
+        mMapView.onStart();
+    }
+
+    // Called when the activity is invisible
+    @Override
+    protected void onStop() {
+        super.onStop();
+        Log.v(TAG, "onStop");
+
+        // Need to pass on to view
+        mMapView.onStop();
+    }
+
+    // Called when the activity is in the background
+    @Override
+    protected void onPause() {
+        super.onPause();
+        Log.v(TAG, "onPause");
+
+        // Need to pass on to view
+        mMapView.onPause();
+    }
+
+    // Called when the activity is no longer in the background
+    @Override
+    protected void onResume() {
+        super.onResume();
+        Log.v(TAG, "onResume");
+
+        // Need to pass on to view
+        mMapView.onResume();
+    }
+
+    // Called before activity is destroyed
+    @Override
+    protected void onSaveInstanceState(Bundle outState) {
+        Log.v(TAG, "onSaveInstanceState");
+
+        // Need to retrieve any saved state from the map
+        mMapView.onSaveInstanceState(outState);
+        super.onSaveInstanceState(outState);
+    }
+}

android/java/app/src/main/res/layout/activity_fragment.xml

@@ -0,0 +1,11 @@
+<merge xmlns:android="http://schemas.android.com/apk/res/android"
+       xmlns:tools="http://schemas.android.com/tools"
+       tools:context="${packageName}.${activityClass}" >
+
+    <fragment
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        class="com.mapbox.mapboxgl.lib.MapFragment"
+        android:id="@+id/map_fragment" />
+
+</merge>

android/java/app/src/main/res/layout/activity_main.xml

@@ -0,0 +1,11 @@
+<merge xmlns:android="http://schemas.android.com/apk/res/android"
+       xmlns:tools="http://schemas.android.com/tools"
+       tools:context="${packageName}.${activityClass}" >
+
+    <view
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        class="com.mapbox.mapboxgl.lib.MapView"
+        android:id="@+id/map" />
+
+</merge>

android/java/app/src/main/res/values-v11/styles.xml

@@ -0,0 +1,11 @@
+<resources>
+
+    <!--
+        Base application theme for API 11+. This theme completely replaces
+        AppBaseTheme from res/values/styles.xml on API 11+ devices.
+    -->
+    <style name="AppBaseTheme" parent="android:Theme.Holo.Light">
+        <!-- API 11 theme customizations can go here. -->
+    </style>
+
+</resources>

android/java/app/src/main/res/values-v14/styles.xml

@@ -0,0 +1,12 @@
+<resources>
+
+    <!--
+        Base application theme for API 14+. This theme completely replaces
+        AppBaseTheme from BOTH res/values/styles.xml and
+        res/values-v11/styles.xml on API 14+ devices.
+    -->
+    <style name="AppBaseTheme" parent="android:Theme.Holo.Light.DarkActionBar">
+        <!-- API 14 theme customizations can go here. -->
+    </style>
+
+</resources>

android/java/app/src/main/res/values/strings.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="utf-8"?>
+<resources>
+
+    <string name="app_name">Mapbox GL</string>
+
+</resources>

android/java/app/src/main/res/values/styles.xml

@@ -0,0 +1,20 @@
+<resources>
+
+    <!--
+        Base application theme, dependent on API level. This theme is replaced
+        by AppBaseTheme from res/values-vXX/styles.xml on newer devices.
+    -->
+    <style name="AppBaseTheme" parent="android:Theme.Light">
+        <!--
+            Theme customizations available in newer API levels can go in
+            res/values-vXX/styles.xml, while customizations related to
+            backward-compatibility can go here.
+        -->
+    </style>
+
+    <!-- Application theme. -->
+    <style name="AppTheme" parent="AppBaseTheme">
+        <!-- All customizations that are NOT specific to a particular API-level can go here. -->
+    </style>
+
+</resources>

android/java/build.gradle

@@ -0,0 +1,15 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.
+buildscript {
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:0.13.2'
+    }
+}
+
+allprojects {
+    repositories {
+        jcenter()
+    }
+}

android/java/gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,6 @@
+#Wed Apr 10 15:27:10 PDT 2013
+distributionBase=GRADLE_USER_HOME
+distributionPath=wrapper/dists
+zipStoreBase=GRADLE_USER_HOME
+zipStorePath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-2.1-all.zip

android/java/gradlew

@@ -0,0 +1,164 @@
+#!/usr/bin/env bash
+
+##############################################################################
+##
+##  Gradle start up script for UN*X
+##
+##############################################################################
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
+APP_NAME="Gradle"
+APP_BASE_NAME=`basename "$0"`
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD="maximum"
+
+warn ( ) {
+    echo "$*"
+}
+
+die ( ) {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+esac
+
+# For Cygwin, ensure paths are in UNIX format before anything is touched.
+if $cygwin ; then
+    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
+fi
+
+# Attempt to set APP_HOME
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >&-
+APP_HOME="`pwd -P`"
+cd "$SAVED" >&-
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD="$JAVA_HOME/jre/sh/java"
+    else
+        JAVACMD="$JAVA_HOME/bin/java"
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD="java"
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+    MAX_FD_LIMIT=`ulimit -H -n`
+    if [ $? -eq 0 ] ; then
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
+            MAX_FD="$MAX_FD_LIMIT"
+        fi
+        ulimit -n $MAX_FD
+        if [ $? -ne 0 ] ; then
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
+        fi
+    else
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
+    fi
+fi
+
+# For Darwin, add options to specify how the application appears in the dock
+if $darwin; then
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
+fi
+
+# For Cygwin, switch paths to Windows format before running java
+if $cygwin ; then
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+
+    # We build the pattern for arguments to be converted via cygpath
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
+    SEP=""
+    for dir in $ROOTDIRSRAW ; do
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
+        SEP="|"
+    done
+    OURCYGPATTERN="(^($ROOTDIRS))"
+    # Add a user-defined pattern to the cygpath arguments
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
+    fi
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    i=0
+    for arg in "$@" ; do
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
+
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
+        else
+            eval `echo args$i`="\"$arg\""
+        fi
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+function splitJvmOpts() {
+    JVM_OPTS=("$@")
+}
+eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
+
+exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"

android/java/gradlew.bat

@@ -0,0 +1,90 @@
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto init
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto init
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:init
+@rem Get command-line arguments, handling Windowz variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+if "%@eval[2+2]" == "4" goto 4NT_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+goto execute
+
+:4NT_args
+@rem Get arguments from the 4NT Shell from JP Software
+set CMD_LINE_ARGS=%$
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

android/java/lib/build.gradle

@@ -0,0 +1,31 @@
+apply plugin: 'com.android.library'
+
+android {
+    compileSdkVersion 19
+    buildToolsVersion "21.1.0"
+
+    defaultConfig {
+        applicationId "com.mapbox.mapboxgl.lib"
+        minSdkVersion 19
+        targetSdkVersion 20
+
+        ndk {
+            moduleName "NativeMapView"
+        }
+    }
+
+    buildTypes {
+        debug {
+            jniDebugBuild true
+        }
+
+        release {
+            runProguard false
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.txt'
+        }
+    }
+}
+
+dependencies {
+    compile "commons-io:commons-io:2.4"
+}

android/java/lib/lint.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="utf-8"?>
+<lint>
+    <issue id="AllowBackup" severity="ignore" />
+</lint>

android/java/lib/src/main/AndroidManifest.xml

@@ -0,0 +1,12 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.mapbox.mapboxgl.lib"
+    android:versionCode="1"
+    android:versionName="1.0" >
+    
+    <uses-feature android:glEsVersion="0x00020000" />
+    
+    <!-- <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
+    <uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE"/> -->
+    <uses-permission android:name="android.permission.INTERNET"/>
+
+</manifest>

android/java/lib/src/main/java/com/almeros/android/multitouch/gesturedetectors/BaseGestureDetector.java

@@ -0,0 +1,160 @@
+package com.almeros.android.multitouch.gesturedetectors;
+
+import android.content.Context;
+import android.view.MotionEvent;
+
+/**
+ * @author Almer Thie (code.almeros.com) Copyright (c) 2013, Almer Thie
+ *         (code.almeros.com)
+ * 
+ *         All rights reserved.
+ * 
+ *         Redistribution and use in source and binary forms, with or without
+ *         modification, are permitted provided that the following conditions
+ *         are met:
+ * 
+ *         Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ *         Redistributions in binary form must reproduce the above copyright
+ *         notice, this list of conditions and the following disclaimer in the
+ *         documentation and/or other materials provided with the distribution.
+ * 
+ *         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *         "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *         LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *         A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *         HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *         INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *         BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *         OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *         AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *         LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+ *         WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *         POSSIBILITY OF SUCH DAMAGE.
+ */
+public abstract class BaseGestureDetector {
+    protected final Context mContext;
+    protected boolean mGestureInProgress;
+
+    protected MotionEvent mPrevEvent;
+    protected MotionEvent mCurrEvent;
+
+    protected float mCurrPressure;
+    protected float mPrevPressure;
+    protected long mTimeDelta;
+
+    /**
+     * This value is the threshold ratio between the previous combined pressure
+     * and the current combined pressure. When pressure decreases rapidly
+     * between events the position values can often be imprecise, as it usually
+     * indicates that the user is in the process of lifting a pointer off of the
+     * device. This value was tuned experimentally.
+     */
+    protected static final float PRESSURE_THRESHOLD = 0.67f;
+
+    public BaseGestureDetector(Context context) {
+        mContext = context;
+    }
+
+    /**
+     * All gesture detectors need to be called through this method to be able to
+     * detect gestures. This method delegates work to handler methods
+     * (handleStartProgressEvent, handleInProgressEvent) implemented in
+     * extending classes.
+     * 
+     * @param event
+     * @return
+     */
+    public boolean onTouchEvent(MotionEvent event) {
+        final int actionCode = event.getAction() & MotionEvent.ACTION_MASK;
+        if (!mGestureInProgress) {
+            handleStartProgressEvent(actionCode, event);
+        } else {
+            handleInProgressEvent(actionCode, event);
+        }
+        return true;
+    }
+
+    /**
+     * Called when the current event occurred when NO gesture is in progress
+     * yet. The handling in this implementation may set the gesture in progress
+     * (via mGestureInProgress) or out of progress
+     * 
+     * @param actionCode
+     * @param event
+     */
+    protected abstract void handleStartProgressEvent(int actionCode,
+            MotionEvent event);
+
+    /**
+     * Called when the current event occurred when a gesture IS in progress. The
+     * handling in this implementation may set the gesture out of progress (via
+     * mGestureInProgress).
+     * 
+     * @param action
+     * @param event
+     */
+    protected abstract void handleInProgressEvent(int actionCode,
+            MotionEvent event);
+
+    protected void updateStateByEvent(MotionEvent curr) {
+        final MotionEvent prev = mPrevEvent;
+
+        // Reset mCurrEvent
+        if (mCurrEvent != null) {
+            mCurrEvent.recycle();
+            mCurrEvent = null;
+        }
+        mCurrEvent = MotionEvent.obtain(curr);
+
+        // Delta time
+        mTimeDelta = curr.getEventTime() - prev.getEventTime();
+
+        // Pressure
+        mCurrPressure = curr.getPressure(curr.getActionIndex());
+        mPrevPressure = prev.getPressure(prev.getActionIndex());
+    }
+
+    protected void resetState() {
+        if (mPrevEvent != null) {
+            mPrevEvent.recycle();
+            mPrevEvent = null;
+        }
+        if (mCurrEvent != null) {
+            mCurrEvent.recycle();
+            mCurrEvent = null;
+        }
+        mGestureInProgress = false;
+    }
+
+    /**
+     * Returns {@code true} if a gesture is currently in progress.
+     * 
+     * @return {@code true} if a gesture is currently in progress, {@code false}
+     *         otherwise.
+     */
+    public boolean isInProgress() {
+        return mGestureInProgress;
+    }
+
+    /**
+     * Return the time difference in milliseconds between the previous accepted
+     * GestureDetector event and the current GestureDetector event.
+     * 
+     * @return Time difference since the last move event in milliseconds.
+     */
+    public long getTimeDelta() {
+        return mTimeDelta;
+    }
+
+    /**
+     * Return the event time of the current GestureDetector event being
+     * processed.
+     * 
+     * @return Current GestureDetector event time in milliseconds.
+     */
+    public long getEventTime() {
+        return mCurrEvent.getEventTime();
+    }
+
+}

android/java/lib/src/main/java/com/almeros/android/multitouch/gesturedetectors/MoveGestureDetector.java

@@ -0,0 +1,188 @@
+package com.almeros.android.multitouch.gesturedetectors;
+
+import android.content.Context;
+import android.graphics.PointF;
+import android.view.MotionEvent;
+
+/**
+ * @author Almer Thie (code.almeros.com) Copyright (c) 2013, Almer Thie
+ *         (code.almeros.com)
+ * 
+ *         All rights reserved.
+ * 
+ *         Redistribution and use in source and binary forms, with or without
+ *         modification, are permitted provided that the following conditions
+ *         are met:
+ * 
+ *         Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ *         Redistributions in binary form must reproduce the above copyright
+ *         notice, this list of conditions and the following disclaimer in the
+ *         documentation and/or other materials provided with the distribution.
+ * 
+ *         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *         "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *         LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *         A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *         HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *         INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *         BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *         OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *         AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *         LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+ *         WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *         POSSIBILITY OF SUCH DAMAGE.
+ */
+public class MoveGestureDetector extends BaseGestureDetector {
+
+    /**
+     * Listener which must be implemented which is used by MoveGestureDetector
+     * to perform callbacks to any implementing class which is registered to a
+     * MoveGestureDetector via the constructor.
+     * 
+     * @see MoveGestureDetector.SimpleOnMoveGestureListener
+     */
+    public interface OnMoveGestureListener {
+        public boolean onMove(MoveGestureDetector detector);
+
+        public boolean onMoveBegin(MoveGestureDetector detector);
+
+        public void onMoveEnd(MoveGestureDetector detector);
+    }
+
+    /**
+     * Helper class which may be extended and where the methods may be
+     * implemented. This way it is not necessary to implement all methods of
+     * OnMoveGestureListener.
+     */
+    public static class SimpleOnMoveGestureListener implements
+            OnMoveGestureListener {
+        public boolean onMove(MoveGestureDetector detector) {
+            return false;
+        }
+
+        public boolean onMoveBegin(MoveGestureDetector detector) {
+            return true;
+        }
+
+        public void onMoveEnd(MoveGestureDetector detector) {
+            // Do nothing, overridden implementation may be used
+        }
+    }
+
+    private static final PointF FOCUS_DELTA_ZERO = new PointF();
+
+    private final OnMoveGestureListener mListener;
+
+    private PointF mCurrFocusInternal;
+    private PointF mPrevFocusInternal;
+    private PointF mFocusExternal = new PointF();
+    private PointF mFocusDeltaExternal = new PointF();
+
+    public MoveGestureDetector(Context context, OnMoveGestureListener listener) {
+        super(context);
+        mListener = listener;
+    }
+
+    @Override
+    protected void handleStartProgressEvent(int actionCode, MotionEvent event) {
+        switch (actionCode) {
+        case MotionEvent.ACTION_DOWN:
+            resetState(); // In case we missed an UP/CANCEL event
+
+            mPrevEvent = MotionEvent.obtain(event);
+            mTimeDelta = 0;
+
+            updateStateByEvent(event);
+            break;
+
+        case MotionEvent.ACTION_MOVE:
+            mGestureInProgress = mListener.onMoveBegin(this);
+            break;
+        }
+    }
+
+    @Override
+    protected void handleInProgressEvent(int actionCode, MotionEvent event) {
+        switch (actionCode) {
+        case MotionEvent.ACTION_UP:
+        case MotionEvent.ACTION_CANCEL:
+            mListener.onMoveEnd(this);
+            resetState();
+            break;
+
+        case MotionEvent.ACTION_MOVE:
+            updateStateByEvent(event);
+
+            // Only accept the event if our relative pressure is within
+            // a certain limit. This can help filter shaky data as a
+            // finger is lifted.
+            if (mCurrPressure / mPrevPressure > PRESSURE_THRESHOLD) {
+                final boolean updatePrevious = mListener.onMove(this);
+                if (updatePrevious) {
+                    mPrevEvent.recycle();
+                    mPrevEvent = MotionEvent.obtain(event);
+                }
+            }
+            break;
+        }
+    }
+
+    protected void updateStateByEvent(MotionEvent curr) {
+        super.updateStateByEvent(curr);
+
+        final MotionEvent prev = mPrevEvent;
+
+        // Focus intenal
+        mCurrFocusInternal = determineFocalPoint(curr);
+        mPrevFocusInternal = determineFocalPoint(prev);
+
+        // Focus external
+        // - Prevent skipping of focus delta when a finger is added or removed
+        boolean mSkipNextMoveEvent = prev.getPointerCount() != curr
+                .getPointerCount();
+        mFocusDeltaExternal = mSkipNextMoveEvent ? FOCUS_DELTA_ZERO
+                : new PointF(mCurrFocusInternal.x - mPrevFocusInternal.x,
+                        mCurrFocusInternal.y - mPrevFocusInternal.y);
+
+        // - Don't directly use mFocusInternal (or skipping will occur). Add
+        // unskipped delta values to mFocusExternal instead.
+        mFocusExternal.x += mFocusDeltaExternal.x;
+        mFocusExternal.y += mFocusDeltaExternal.y;
+    }
+
+    /**
+     * Determine (multi)finger focal point (a.k.a. center point between all
+     * fingers)
+     * 
+     * @param MotionEvent
+     *            e
+     * @return PointF focal point
+     */
+    private PointF determineFocalPoint(MotionEvent e) {
+        // Number of fingers on screen
+        final int pCount = e.getPointerCount();
+        float x = 0.0f;
+        float y = 0.0f;
+
+        for (int i = 0; i < pCount; i++) {
+            x += e.getX(i);
+            y += e.getY(i);
+        }
+
+        return new PointF(x / pCount, y / pCount);
+    }
+
+    public float getFocusX() {
+        return mFocusExternal.x;
+    }
+
+    public float getFocusY() {
+        return mFocusExternal.y;
+    }
+
+    public PointF getFocusDelta() {
+        return mFocusDeltaExternal;
+    }
+
+}

android/java/lib/src/main/java/com/almeros/android/multitouch/gesturedetectors/RotateGestureDetector.java

@@ -0,0 +1,180 @@
+package com.almeros.android.multitouch.gesturedetectors;
+
+import android.content.Context;
+import android.view.MotionEvent;
+
+/**
+ * @author Almer Thie (code.almeros.com) Copyright (c) 2013, Almer Thie
+ *         (code.almeros.com)
+ * 
+ *         All rights reserved.
+ * 
+ *         Redistribution and use in source and binary forms, with or without
+ *         modification, are permitted provided that the following conditions
+ *         are met:
+ * 
+ *         Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ *         Redistributions in binary form must reproduce the above copyright
+ *         notice, this list of conditions and the following disclaimer in the
+ *         documentation and/or other materials provided with the distribution.
+ * 
+ *         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *         "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *         LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *         A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *         HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *         INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *         BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *         OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *         AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *         LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+ *         WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *         POSSIBILITY OF SUCH DAMAGE.
+ */
+public class RotateGestureDetector extends TwoFingerGestureDetector {
+
+    /**
+     * Listener which must be implemented which is used by RotateGestureDetector
+     * to perform callbacks to any implementing class which is registered to a
+     * RotateGestureDetector via the constructor.
+     * 
+     * @see RotateGestureDetector.SimpleOnRotateGestureListener
+     */
+    public interface OnRotateGestureListener {
+        public boolean onRotate(RotateGestureDetector detector);
+
+        public boolean onRotateBegin(RotateGestureDetector detector);
+
+        public void onRotateEnd(RotateGestureDetector detector);
+    }
+
+    /**
+     * Helper class which may be extended and where the methods may be
+     * implemented. This way it is not necessary to implement all methods of
+     * OnRotateGestureListener.
+     */
+    public static class SimpleOnRotateGestureListener implements
+            OnRotateGestureListener {
+        public boolean onRotate(RotateGestureDetector detector) {
+            return false;
+        }
+
+        public boolean onRotateBegin(RotateGestureDetector detector) {
+            return true;
+        }
+
+        public void onRotateEnd(RotateGestureDetector detector) {
+            // Do nothing, overridden implementation may be used
+        }
+    }
+
+    private final OnRotateGestureListener mListener;
+    private boolean mSloppyGesture;
+
+    public RotateGestureDetector(Context context,
+            OnRotateGestureListener listener) {
+        super(context);
+        mListener = listener;
+    }
+
+    @Override
+    protected void handleStartProgressEvent(int actionCode, MotionEvent event) {
+        switch (actionCode) {
+        case MotionEvent.ACTION_POINTER_DOWN:
+            // At least the second finger is on screen now
+
+            resetState(); // In case we missed an UP/CANCEL event
+            mPrevEvent = MotionEvent.obtain(event);
+            mTimeDelta = 0;
+
+            updateStateByEvent(event);
+
+            // See if we have a sloppy gesture
+            mSloppyGesture = isSloppyGesture(event);
+            if (!mSloppyGesture) {
+                // No, start gesture now
+                mGestureInProgress = mListener.onRotateBegin(this);
+            }
+            break;
+
+        case MotionEvent.ACTION_MOVE:
+            if (!mSloppyGesture) {
+                break;
+            }
+
+            // See if we still have a sloppy gesture
+            mSloppyGesture = isSloppyGesture(event);
+            if (!mSloppyGesture) {
+                // No, start normal gesture now
+                mGestureInProgress = mListener.onRotateBegin(this);
+            }
+
+            break;
+
+        case MotionEvent.ACTION_POINTER_UP:
+            if (!mSloppyGesture) {
+                break;
+            }
+
+            break;
+        }
+    }
+
+    @Override
+    protected void handleInProgressEvent(int actionCode, MotionEvent event) {
+        switch (actionCode) {
+        case MotionEvent.ACTION_POINTER_UP:
+            // Gesture ended but
+            updateStateByEvent(event);
+
+            if (!mSloppyGesture) {
+                mListener.onRotateEnd(this);
+            }
+
+            resetState();
+            break;
+
+        case MotionEvent.ACTION_CANCEL:
+            if (!mSloppyGesture) {
+                mListener.onRotateEnd(this);
+            }
+
+            resetState();
+            break;
+
+        case MotionEvent.ACTION_MOVE:
+            updateStateByEvent(event);
+
+            // Only accept the event if our relative pressure is within
+            // a certain limit. This can help filter shaky data as a
+            // finger is lifted.
+            if (mCurrPressure / mPrevPressure > PRESSURE_THRESHOLD) {
+                final boolean updatePrevious = mListener.onRotate(this);
+                if (updatePrevious) {
+                    mPrevEvent.recycle();
+                    mPrevEvent = MotionEvent.obtain(event);
+                }
+            }
+            break;
+        }
+    }
+
+    @Override
+    protected void resetState() {
+        super.resetState();
+        mSloppyGesture = false;
+    }
+
+    /**
+     * Return the rotation difference from the previous rotate event to the
+     * current event.
+     * 
+     * @return The current rotation //difference in degrees.
+     */
+    public float getRotationDegreesDelta() {
+        double diffRadians = Math.atan2(mPrevFingerDiffY, mPrevFingerDiffX)
+                - Math.atan2(mCurrFingerDiffY, mCurrFingerDiffX);
+        return (float) (diffRadians * 180.0 / Math.PI);
+    }
+}

android/java/lib/src/main/java/com/almeros/android/multitouch/gesturedetectors/ShoveGestureDetector.java

@@ -0,0 +1,213 @@
+package com.almeros.android.multitouch.gesturedetectors;
+
+import android.content.Context;
+import android.view.MotionEvent;
+
+/**
+ * @author Robert Nordan (robert.nordan@norkart.no)
+ * 
+ *         Copyright (c) 2013, Norkart AS
+ * 
+ *         All rights reserved.
+ * 
+ *         Redistribution and use in source and binary forms, with or without
+ *         modification, are permitted provided that the following conditions
+ *         are met:
+ * 
+ *         Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ *         Redistributions in binary form must reproduce the above copyright
+ *         notice, this list of conditions and the following disclaimer in the
+ *         documentation and/or other materials provided with the distribution.
+ * 
+ *         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *         "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *         LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *         A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *         HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *         INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *         BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *         OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *         AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *         LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+ *         WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *         POSSIBILITY OF SUCH DAMAGE.
+ */
+public class ShoveGestureDetector extends TwoFingerGestureDetector {
+
+    /**
+     * Listener which must be implemented which is used by ShoveGestureDetector
+     * to perform callbacks to any implementing class which is registered to a
+     * ShoveGestureDetector via the constructor.
+     * 
+     * @see ShoveGestureDetector.SimpleOnShoveGestureListener
+     */
+    public interface OnShoveGestureListener {
+        public boolean onShove(ShoveGestureDetector detector);
+
+        public boolean onShoveBegin(ShoveGestureDetector detector);
+
+        public void onShoveEnd(ShoveGestureDetector detector);
+    }
+
+    /**
+     * Helper class which may be extended and where the methods may be
+     * implemented. This way it is not necessary to implement all methods of
+     * OnShoveGestureListener.
+     */
+    public static class SimpleOnShoveGestureListener implements
+            OnShoveGestureListener {
+        public boolean onShove(ShoveGestureDetector detector) {
+            return false;
+        }
+
+        public boolean onShoveBegin(ShoveGestureDetector detector) {
+            return true;
+        }
+
+        public void onShoveEnd(ShoveGestureDetector detector) {
+            // Do nothing, overridden implementation may be used
+        }
+    }
+
+    private float mPrevAverageY;
+    private float mCurrAverageY;
+
+    private final OnShoveGestureListener mListener;
+    private boolean mSloppyGesture;
+
+    public ShoveGestureDetector(Context context, OnShoveGestureListener listener) {
+        super(context);
+        mListener = listener;
+    }
+
+    @Override
+    protected void handleStartProgressEvent(int actionCode, MotionEvent event) {
+        switch (actionCode) {
+        case MotionEvent.ACTION_POINTER_DOWN:
+            // At least the second finger is on screen now
+
+            resetState(); // In case we missed an UP/CANCEL event
+            mPrevEvent = MotionEvent.obtain(event);
+            mTimeDelta = 0;
+
+            updateStateByEvent(event);
+
+            // See if we have a sloppy gesture
+            mSloppyGesture = isSloppyGesture(event);
+            if (!mSloppyGesture) {
+                // No, start gesture now
+                mGestureInProgress = mListener.onShoveBegin(this);
+            }
+            break;
+
+        case MotionEvent.ACTION_MOVE:
+            if (!mSloppyGesture) {
+                break;
+            }
+
+            // See if we still have a sloppy gesture
+            mSloppyGesture = isSloppyGesture(event);
+            if (!mSloppyGesture) {
+                // No, start normal gesture now
+                mGestureInProgress = mListener.onShoveBegin(this);
+            }
+
+            break;
+
+        case MotionEvent.ACTION_POINTER_UP:
+            if (!mSloppyGesture) {
+                break;
+            }
+
+            break;
+        }
+    }
+
+    @Override
+    protected void handleInProgressEvent(int actionCode, MotionEvent event) {
+        switch (actionCode) {
+        case MotionEvent.ACTION_POINTER_UP:
+            // Gesture ended but
+            updateStateByEvent(event);
+
+            if (!mSloppyGesture) {
+                mListener.onShoveEnd(this);
+            }
+
+            resetState();
+            break;
+
+        case MotionEvent.ACTION_CANCEL:
+            if (!mSloppyGesture) {
+                mListener.onShoveEnd(this);
+            }
+
+            resetState();
+            break;
+
+        case MotionEvent.ACTION_MOVE:
+            updateStateByEvent(event);
+
+            // Only accept the event if our relative pressure is within
+            // a certain limit. This can help filter shaky data as a
+            // finger is lifted. Also check that shove is meaningful.
+            if (mCurrPressure / mPrevPressure > PRESSURE_THRESHOLD
+                    && Math.abs(getShovePixelsDelta()) > 0.5f) {
+                final boolean updatePrevious = mListener.onShove(this);
+                if (updatePrevious) {
+                    mPrevEvent.recycle();
+                    mPrevEvent = MotionEvent.obtain(event);
+                }
+            }
+            break;
+        }
+    }
+
+    @Override
+    protected void resetState() {
+        super.resetState();
+        mSloppyGesture = false;
+        mPrevAverageY = 0.0f;
+        mCurrAverageY = 0.0f;
+    }
+
+    @Override
+    protected void updateStateByEvent(MotionEvent curr) {
+        super.updateStateByEvent(curr);
+
+        final MotionEvent prev = mPrevEvent;
+        float py0 = prev.getY(0);
+        float py1 = prev.getY(1);
+        mPrevAverageY = (py0 + py1) / 2.0f;
+
+        float cy0 = curr.getY(0);
+        float cy1 = curr.getY(1);
+        mCurrAverageY = (cy0 + cy1) / 2.0f;
+    }
+
+    @Override
+    protected boolean isSloppyGesture(MotionEvent event) {
+        boolean sloppy = super.isSloppyGesture(event);
+        if (sloppy)
+            return true;
+
+        // If it's not traditionally sloppy, we check if the angle between
+        // fingers
+        // is acceptable.
+        double angle = Math.abs(Math.atan2(mCurrFingerDiffY, mCurrFingerDiffX));
+        // about 20 degrees, left or right
+        return !((0.0f < angle && angle < 0.35f) || 2.79f < angle
+                && angle < Math.PI);
+    }
+
+    /**
+     * Return the distance in pixels from the previous shove event to the
+     * current event.
+     * 
+     * @return The current distance in pixels.
+     */
+    public float getShovePixelsDelta() {
+        return mCurrAverageY - mPrevAverageY;
+    }
+}

android/java/lib/src/main/java/com/almeros/android/multitouch/gesturedetectors/TwoFingerGestureDetector.java

@@ -0,0 +1,228 @@
+package com.almeros.android.multitouch.gesturedetectors;
+
+import android.content.Context;
+import android.graphics.PointF;
+import android.util.DisplayMetrics;
+import android.view.MotionEvent;
+import android.view.ViewConfiguration;
+
+/**
+ * @author Almer Thie (code.almeros.com) Copyright (c) 2013, Almer Thie
+ *         (code.almeros.com)
+ * 
+ *         All rights reserved.
+ * 
+ *         Redistribution and use in source and binary forms, with or without
+ *         modification, are permitted provided that the following conditions
+ *         are met:
+ * 
+ *         Redistributions of source code must retain the above copyright
+ *         notice, this list of conditions and the following disclaimer.
+ *         Redistributions in binary form must reproduce the above copyright
+ *         notice, this list of conditions and the following disclaimer in the
+ *         documentation and/or other materials provided with the distribution.
+ * 
+ *         THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ *         "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ *         LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ *         A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ *         HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+ *         INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+ *         BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+ *         OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
+ *         AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ *         LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY
+ *         WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ *         POSSIBILITY OF SUCH DAMAGE.
+ */
+public abstract class TwoFingerGestureDetector extends BaseGestureDetector {
+
+    private final float mEdgeSlop;
+    private float mRightSlopEdge;
+    private float mBottomSlopEdge;
+
+    protected float mPrevFingerDiffX;
+    protected float mPrevFingerDiffY;
+    protected float mCurrFingerDiffX;
+    protected float mCurrFingerDiffY;
+
+    private float mCurrLen;
+    private float mPrevLen;
+
+    private PointF mFocus;
+
+    public TwoFingerGestureDetector(Context context) {
+        super(context);
+
+        ViewConfiguration config = ViewConfiguration.get(context);
+        mEdgeSlop = config.getScaledEdgeSlop();
+    }
+
+    @Override
+    protected abstract void handleStartProgressEvent(int actionCode,
+            MotionEvent event);
+
+    @Override
+    protected abstract void handleInProgressEvent(int actionCode,
+            MotionEvent event);
+
+    protected void updateStateByEvent(MotionEvent curr) {
+        super.updateStateByEvent(curr);
+
+        final MotionEvent prev = mPrevEvent;
+
+        mCurrLen = -1;
+        mPrevLen = -1;
+
+        // Previous
+        final float px0 = prev.getX(0);
+        final float py0 = prev.getY(0);
+        final float px1 = prev.getX(1);
+        final float py1 = prev.getY(1);
+        final float pvx = px1 - px0;
+        final float pvy = py1 - py0;
+        mPrevFingerDiffX = pvx;
+        mPrevFingerDiffY = pvy;
+
+        // Current
+        final float cx0 = curr.getX(0);
+        final float cy0 = curr.getY(0);
+        final float cx1 = curr.getX(1);
+        final float cy1 = curr.getY(1);
+        final float cvx = cx1 - cx0;
+        final float cvy = cy1 - cy0;
+        mCurrFingerDiffX = cvx;
+        mCurrFingerDiffY = cvy;
+        mFocus = determineFocalPoint(curr);
+    }
+
+    /**
+     * Return the current distance between the two pointers forming the gesture
+     * in progress.
+     * 
+     * @return Distance between pointers in pixels.
+     */
+    public float getCurrentSpan() {
+        if (mCurrLen == -1) {
+            final float cvx = mCurrFingerDiffX;
+            final float cvy = mCurrFingerDiffY;
+            mCurrLen = (float) Math.sqrt(cvx * cvx + cvy * cvy);
+        }
+        return mCurrLen;
+    }
+
+    /**
+     * Return the previous distance between the two pointers forming the gesture
+     * in progress.
+     * 
+     * @return Previous distance between pointers in pixels.
+     */
+    public float getPreviousSpan() {
+        if (mPrevLen == -1) {
+            final float pvx = mPrevFingerDiffX;
+            final float pvy = mPrevFingerDiffY;
+            mPrevLen = (float) Math.sqrt(pvx * pvx + pvy * pvy);
+        }
+        return mPrevLen;
+    }
+
+    /**
+     * MotionEvent has no getRawX(int) method; simulate it pending future API
+     * approval.
+     * 
+     * @param event
+     * @param pointerIndex
+     * @return
+     */
+    protected static float getRawX(MotionEvent event, int pointerIndex) {
+        float offset = event.getX() - event.getRawX();
+        if (pointerIndex < event.getPointerCount()) {
+            return event.getX(pointerIndex) + offset;
+        }
+        return 0.0f;
+    }
+
+    /**
+     * MotionEvent has no getRawY(int) method; simulate it pending future API
+     * approval.
+     * 
+     * @param event
+     * @param pointerIndex
+     * @return
+     */
+    protected static float getRawY(MotionEvent event, int pointerIndex) {
+        float offset = event.getY() - event.getRawY();
+        if (pointerIndex < event.getPointerCount()) {
+            return event.getY(pointerIndex) + offset;
+        }
+        return 0.0f;
+    }
+
+    /**
+     * Check if we have a sloppy gesture. Sloppy gestures can happen if the edge
+     * of the user's hand is touching the screen, for example.
+     * 
+     * @param event
+     * @return
+     */
+    protected boolean isSloppyGesture(MotionEvent event) {
+        // As orientation can change, query the metrics in touch down
+        DisplayMetrics metrics = mContext.getResources().getDisplayMetrics();
+        mRightSlopEdge = metrics.widthPixels - mEdgeSlop;
+        mBottomSlopEdge = metrics.heightPixels - mEdgeSlop;
+
+        final float edgeSlop = mEdgeSlop;
+        final float rightSlop = mRightSlopEdge;
+        final float bottomSlop = mBottomSlopEdge;
+
+        final float x0 = event.getRawX();
+        final float y0 = event.getRawY();
+        final float x1 = getRawX(event, 1);
+        final float y1 = getRawY(event, 1);
+
+        boolean p0sloppy = x0 < edgeSlop || y0 < edgeSlop || x0 > rightSlop
+                || y0 > bottomSlop;
+        boolean p1sloppy = x1 < edgeSlop || y1 < edgeSlop || x1 > rightSlop
+                || y1 > bottomSlop;
+
+        if (p0sloppy && p1sloppy) {
+            return true;
+        } else if (p0sloppy) {
+            return true;
+        } else if (p1sloppy) {
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Determine (multi)finger focal point (a.k.a. center point between all
+     * fingers)
+     * 
+     * @param MotionEvent
+     *            e
+     * @return PointF focal point
+     */
+    public static PointF determineFocalPoint(MotionEvent e) {
+        // Number of fingers on screen
+        final int pCount = e.getPointerCount();
+        float x = 0.0f;
+        float y = 0.0f;
+
+        for (int i = 0; i < pCount; i++) {
+            x += e.getX(i);
+            y += e.getY(i);
+        }
+
+        return new PointF(x / pCount, y / pCount);
+    }
+
+    public float getFocusX() {
+        return mFocus.x;
+    }
+
+    public float getFocusY() {
+        return mFocus.y;
+    }
+
+}

android/java/lib/src/main/java/com/mapbox/mapboxgl/lib/LonLat.java

@@ -0,0 +1,91 @@
+package com.mapbox.mapboxgl.lib;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+public class LonLat implements Parcelable {
+
+    public static final Parcelable.Creator<LonLat> CREATOR = new Parcelable.Creator<LonLat>() {
+        public LonLat createFromParcel(Parcel in) {
+            return new LonLat(in);
+        }
+
+        public LonLat[] newArray(int size) {
+            return new LonLat[size];
+        }
+    };
+
+    private double lon;
+    private double lat;
+
+    public LonLat(double lon, double lat) {
+        this.lon = lon;
+        this.lat = lat;
+    }
+
+    private LonLat(Parcel in) {
+        lon = in.readDouble();
+        lat = in.readDouble();
+    }
+
+    public double getLon() {
+        return lon;
+    }
+
+    public void setLon(double lon) {
+        this.lon = lon;
+    }
+
+    public double getLat() {
+        return lat;
+    }
+
+    public void setLat(double lat) {
+        this.lat = lat;
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(lat);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(lon);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        LonLat other = (LonLat) obj;
+        if (Double.doubleToLongBits(lat) != Double.doubleToLongBits(other.lat))
+            return false;
+        if (Double.doubleToLongBits(lon) != Double.doubleToLongBits(other.lon))
+            return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "LonLat [lon=" + lon + ", lat=" + lat + "]";
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel out, int flags) {
+        out.writeDouble(lon);
+        out.writeDouble(lat);
+    }
+
+}

android/java/lib/src/main/java/com/mapbox/mapboxgl/lib/LonLatZoom.java

@@ -0,0 +1,124 @@
+package com.mapbox.mapboxgl.lib;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+public class LonLatZoom implements Parcelable {
+
+    public static final Parcelable.Creator<LonLatZoom> CREATOR = new Parcelable.Creator<LonLatZoom>() {
+        public LonLatZoom createFromParcel(Parcel in) {
+            return new LonLatZoom(in);
+        }
+
+        public LonLatZoom[] newArray(int size) {
+            return new LonLatZoom[size];
+        }
+    };
+
+    private double lon;
+    private double lat;
+    private double zoom;
+
+    public LonLatZoom(double lon, double lat, double zoom) {
+        this.lon = lon;
+        this.lat = lat;
+        this.zoom = zoom;
+    }
+
+    public LonLatZoom(LonLat lonLat, double zoom) {
+        this.lon = lonLat.getLon();
+        this.lat = lonLat.getLat();
+        this.zoom = zoom;
+    }
+
+    private LonLatZoom(Parcel in) {
+        lon = in.readDouble();
+        lat = in.readDouble();
+        zoom = in.readDouble();
+    }
+
+    public double getLon() {
+        return lon;
+    }
+
+    public void setLon(double lon) {
+        this.lon = lon;
+    }
+
+    public double getLat() {
+        return lat;
+    }
+
+    public void setLat(double lat) {
+        this.lat = lat;
+    }
+
+    public double getZoom() {
+        return zoom;
+    }
+
+    public void setZoom(double zoom) {
+        this.zoom = zoom;
+    }
+
+    public LonLat getLonLat() {
+        return new LonLat(lon, lat);
+    }
+
+    public void setLonLat(LonLat lonLat) {
+        this.lon = lonLat.getLon();
+        this.lat = lonLat.getLat();
+    }
+
+    @Override
+    public int hashCode() {
+        final int prime = 31;
+        int result = 1;
+        long temp;
+        temp = Double.doubleToLongBits(lat);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(lon);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        temp = Double.doubleToLongBits(zoom);
+        result = prime * result + (int) (temp ^ (temp >>> 32));
+        return result;
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (this == obj)
+            return true;
+        if (obj == null)
+            return false;
+        if (getClass() != obj.getClass())
+            return false;
+        LonLatZoom other = (LonLatZoom) obj;
+        if (Double.doubleToLongBits(lat) != Double.doubleToLongBits(other.lat))
+            return false;
+        if (Double.doubleToLongBits(lon) != Double.doubleToLongBits(other.lon))
+            return false;
+        if (Double.doubleToLongBits(zoom) != Double
+                .doubleToLongBits(other.zoom))
+            return false;
+        return true;
+    }
+
+    @Override
+    public String toString() {
+        return "LonLatZoom [lon=" + lon + ", lat=" + lat + ", zoom=" + zoom
+                + "]";
+    }
+
+    @Override
+    public int describeContents() {
+        return 0;
+    }
+
+    @Override
+    public void writeToParcel(Parcel out, int flags) {
+        out.writeDouble(lon);
+        out.writeDouble(lat);
+        out.writeDouble(zoom);
+    }
+
+}

android/java/lib/src/main/java/com/mapbox/mapboxgl/lib/MapFragment.java

@@ -0,0 +1,150 @@
+package com.mapbox.mapboxgl.lib;
+
+import android.app.Activity;
+import android.app.Fragment;
+import android.content.res.TypedArray;
+import android.os.Bundle;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+public class MapFragment extends Fragment {
+
+    //
+    // Static members
+    //
+
+    // Tag used for logging
+    private static final String TAG = "MapFragment";
+
+    // The map
+    private MapView mMapView;
+
+    // The style attrs to load into the map
+    AttributeSet mAttrs;
+
+    //
+    // Lifecycle events
+    //
+
+    // Called when the fragment is created
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        super.onCreateView(inflater, container, savedInstanceState);
+        Log.v(TAG, "onCreateView");
+
+        // Create the map
+        mMapView = new MapView(getActivity());
+
+        // Load the attributes
+        TypedArray typedArray = getActivity().obtainStyledAttributes(mAttrs,
+                R.styleable.MapFragment, 0, 0);
+        try {
+            double centerLongitude = typedArray.getFloat(
+                    R.styleable.MapFragment_centerLongitude, 0.0f);
+            double centerLatitude = typedArray.getFloat(
+                    R.styleable.MapFragment_centerLatitude, 0.0f);
+            LonLat centerCoordinate = new LonLat(centerLongitude,
+                    centerLatitude);
+            mMapView.setCenterCoordinate(centerCoordinate);
+            mMapView.setDirection(typedArray.getFloat(
+                    R.styleable.MapFragment_direction, 0.0f));
+            mMapView.setZoomLevel(typedArray.getFloat(
+                    R.styleable.MapFragment_zoomLevel, 0.0f));
+            mMapView.setZoomEnabled(typedArray.getBoolean(
+                    R.styleable.MapFragment_zoomEnabled, true));
+            mMapView.setScrollEnabled(typedArray.getBoolean(
+                    R.styleable.MapFragment_scrollEnabled, true));
+            mMapView.setRotateEnabled(typedArray.getBoolean(
+                    R.styleable.MapFragment_rotateEnabled, true));
+            mMapView.setDebugActive(typedArray.getBoolean(
+                    R.styleable.MapFragment_debugActive, false));
+        } finally {
+            typedArray.recycle();
+        }
+
+        // Need to pass on any saved state to the map
+        mMapView.onCreate(savedInstanceState);
+
+        // Return the map as the root view
+        return mMapView;
+    }
+
+    // Called when the fragment is destroyed
+    @Override
+    public void onDestroyView() {
+        super.onDestroyView();
+        Log.v(TAG, "onDestroyView");
+
+        // Need to pass on to view
+        mMapView.onDestroy();
+        mMapView = null;
+    }
+
+    // Called to load any fragment attributes set in the activity's layout
+    @Override
+    public void onInflate(Activity activity, AttributeSet attrs,
+            Bundle savedInstanceState) {
+        super.onInflate(activity, attrs, savedInstanceState);
+        Log.v(TAG, "onInflate");
+
+        // TODO seems this is called before onCreateView
+        // Kinda strange, is it supposed to be like this?
+        // Need to keep a copy of these and pass on to MapView later
+
+        mAttrs = attrs;
+    }
+
+    // Called when the fragment is visible
+    @Override
+    public void onStart() {
+        super.onStart();
+        Log.v(TAG, "onStart");
+
+        // Need to pass on to view
+        mMapView.onStart();
+    }
+
+    // Called when the fragment is invisible
+    @Override
+    public void onStop() {
+        super.onStop();
+        Log.v(TAG, "onStop");
+
+        // Need to pass on to view
+        mMapView.onStop();
+    }
+
+    // Called when the fragment is in the background
+    @Override
+    public void onPause() {
+        super.onPause();
+        Log.v(TAG, "onPause");
+
+        // Need to pass on to view
+        mMapView.onPause();
+    }
+
+    // Called when the fragment is no longer in the background
+    @Override
+    public void onResume() {
+        super.onResume();
+        Log.v(TAG, "onResume");
+
+        // Need to pass on to view
+        mMapView.onResume();
+    }
+
+    // Called before fragment is destroyed
+    @Override
+    public void onSaveInstanceState(Bundle outState) {
+        Log.v(TAG, "onSaveInstanceState");
+
+        // Need to retrieve any saved state from the map
+        mMapView.onSaveInstanceState(outState);
+        super.onSaveInstanceState(outState);
+    }
+}

android/java/lib/src/main/java/com/mapbox/mapboxgl/lib/NativeMapView.java

@@ -0,0 +1,501 @@
+package com.mapbox.mapboxgl.lib;
+
+import java.util.Set;
+
+import android.util.Log;
+import android.view.Surface;
+
+// Class that wraps the native methods for convenience
+class NativeMapView {
+
+    //
+    // Static members
+    //
+
+    // Tag used for logging
+    private static final String TAG = "NativeMapView";
+
+    //
+    // Instance members
+    //
+
+    // Holds the pointer to JNI NativeMapView
+    private long mNativeMapViewPtr = 0;
+
+    // Used for callbacks
+    private MapView mMapView;
+
+    //
+    // Static methods
+    //
+
+    static {
+        System.loadLibrary("mapbox-gl");
+    }
+
+    //
+    // Constructors
+    //
+
+    public NativeMapView(MapView mapView, String defaultStyleJSON) {
+        mMapView = mapView;
+
+        // Create the NativeMapView
+        mNativeMapViewPtr = nativeCreate(defaultStyleJSON);
+    }
+
+    //
+    // Methods
+    //
+
+    public void initializeDisplay() {
+        nativeInitializeDisplay(mNativeMapViewPtr);
+    }
+
+    public void terminateDisplay() {
+        nativeTerminateDisplay(mNativeMapViewPtr);
+    }
+
+    public void initializeContext() {
+        nativeInitializeContext(mNativeMapViewPtr);
+    }
+
+    public void terminateContext() {
+        nativeTerminateContext(mNativeMapViewPtr);
+    }
+
+    public void createSurface(Surface surface) {
+        nativeCreateSurface(mNativeMapViewPtr, surface);
+    }
+
+    public void destroySurface() {
+        nativeDestroySurface(mNativeMapViewPtr);
+    }
+
+    public void start() {
+        nativeStart(mNativeMapViewPtr);
+    }
+
+    public void stop() {
+        nativeStop(mNativeMapViewPtr);
+    }
+
+    public void rerender() {
+        nativeRerender(mNativeMapViewPtr);
+    }
+
+    public void update() {
+        nativeUpdate(mNativeMapViewPtr);
+    }
+
+    public void cleanup() {
+        nativeCleanup(mNativeMapViewPtr);
+    }
+
+    public void addDefaultSource() {
+        nativeAddDefaultSource(mNativeMapViewPtr);
+    }
+
+    public void removeDefaultSource() {
+        nativeRemoveDefaultSource(mNativeMapViewPtr);
+    }
+
+    public void addSource(String name, String url) {
+        nativeAddSource(mNativeMapViewPtr, name, url);
+    }
+
+    public void removeSource(String name) {
+        nativeRemoveSource(mNativeMapViewPtr, name);
+    }
+
+    public void resize(int width, int height) {
+        resize(width, height, 1.0f);
+    }
+
+    public void resize(int width, int height, float ratio) {
+        if (width < 0) {
+            throw new IllegalArgumentException("width cannot be negative.");
+        }
+
+        if (height < 0) {
+            throw new IllegalArgumentException("height cannot be negative.");
+        }
+
+        if (width > 65535) {
+            throw new IllegalArgumentException(
+                    "width cannot be greater than 65535.");
+        }
+
+        if (height > 65535) {
+            throw new IllegalArgumentException(
+                    "height cannot be greater than 65535.");
+        }
+
+        nativeResize(mNativeMapViewPtr, width, height, ratio);
+    }
+
+    public void resize(int width, int height, float ratio, int fbWidth,
+            int fbHeight) {
+        if (width < 0) {
+            throw new IllegalArgumentException("width cannot be negative.");
+        }
+
+        if (height < 0) {
+            throw new IllegalArgumentException("height cannot be negative.");
+        }
+
+        if (fbWidth < 0) {
+            throw new IllegalArgumentException("fbWidth cannot be negative.");
+        }
+
+        if (fbHeight < 0) {
+            throw new IllegalArgumentException("fbHeight cannot be negative.");
+        }
+
+        if (fbWidth > 65535) {
+            throw new IllegalArgumentException(
+                    "fbWidth cannot be greater than 65535.");
+        }
+
+        if (fbHeight > 65535) {
+            throw new IllegalArgumentException(
+                    "fbHeight cannot be greater than 65535.");
+        }
+        nativeResize(mNativeMapViewPtr, width, height, ratio, fbWidth, fbHeight);
+    }
+
+    public void setAppliedClasses(Set<String> appliedClasses) {
+        nativeSetAppliedClasses(mNativeMapViewPtr, appliedClasses);
+    }
+
+    public Set<String> getAppliedClasses() {
+        return nativeGetAppliedClasses(mNativeMapViewPtr);
+    }
+
+    public void setDefaultTransitionDuration() {
+        setDefaultTransitionDuration(0);
+    }
+
+    public void setDefaultTransitionDuration(long durationMilliseconds) {
+        if (durationMilliseconds < 0) {
+            throw new IllegalArgumentException(
+                    "durationMilliseconds cannot be negative.");
+        }
+
+        nativeSetDefaultTransitionDuration(mNativeMapViewPtr,
+                durationMilliseconds);
+    }
+
+    public void setStyleJSON(String newStyleJSON) {
+        nativeSetStyleJSON(mNativeMapViewPtr, newStyleJSON);
+    }
+
+    public String getStyleJSON() {
+        return nativeGetStyleJSON(mNativeMapViewPtr);
+    }
+
+    public void cancelTransitions() {
+        nativeCancelTransitions(mNativeMapViewPtr);
+    }
+
+    public void moveBy(double dx, double dy) {
+        moveBy(dx, dy, 0.0);
+    }
+
+    public void moveBy(double dx, double dy, double duration) {
+        nativeMoveBy(mNativeMapViewPtr, dx, dy, duration);
+    }
+
+    public void setLonLat(LonLat lonLat) {
+        setLonLat(lonLat, 0.0);
+    }
+
+    public void setLonLat(LonLat lonLat, double duration) {
+        nativeSetLonLat(mNativeMapViewPtr, lonLat, duration);
+    }
+
+    public LonLat getLonLat() {
+        return nativeGetLonLat(mNativeMapViewPtr);
+    }
+
+    public void startPanning() {
+        nativeStartPanning(mNativeMapViewPtr);
+    }
+
+    public void stopPanning() {
+        nativeStopPanning(mNativeMapViewPtr);
+    }
+
+    public void resetPosition() {
+        nativeResetPosition(mNativeMapViewPtr);
+    }
+
+    public void scaleBy(double ds) {
+        scaleBy(ds, -1.0, -1.0);
+    }
+
+    public void scaleBy(double ds, double cx, double cy) {
+        scaleBy(ds, cx, cy, 0.0);
+    }
+
+    public void scaleBy(double ds, double cx, double cy, double duration) {
+        nativeScaleBy(mNativeMapViewPtr, ds, cx, cy, duration);
+    }
+
+    public void setScale(double scale) {
+        setScale(scale, -1.0, -1.0);
+    }
+
+    public void setScale(double scale, double cx, double cy) {
+        setScale(scale, cx, cy, 0.0);
+    }
+
+    public void setScale(double scale, double cx, double cy, double duration) {
+        nativeSetScale(mNativeMapViewPtr, scale, cx, cy, duration);
+    }
+
+    public double getScale() {
+        return nativeGetScale(mNativeMapViewPtr);
+    }
+
+    public void setZoom(double zoom) {
+        setZoom(zoom, 0.0);
+    }
+
+    public void setZoom(double zoom, double duration) {
+        nativeSetZoom(mNativeMapViewPtr, zoom, duration);
+    }
+
+    public double getZoom() {
+        return nativeGetZoom(mNativeMapViewPtr);
+    }
+
+    public void setLonLatZoom(LonLatZoom lonLatZoom) {
+        setLonLatZoom(lonLatZoom, 0.0);
+    }
+
+    public void setLonLatZoom(LonLatZoom lonLatZoom, double duration) {
+        nativeSetLonLatZoom(mNativeMapViewPtr, lonLatZoom, duration);
+    }
+
+    public LonLatZoom getLonLatZoom() {
+        return nativeGetLonLatZoom(mNativeMapViewPtr);
+    }
+
+    public void resetZoom() {
+        nativeResetZoom(mNativeMapViewPtr);
+    }
+
+    public void startScaling() {
+        nativeStartScaling(mNativeMapViewPtr);
+    }
+
+    public void stopScaling() {
+        nativeStopScaling(mNativeMapViewPtr);
+    }
+
+    public double getMinZoom() {
+        return nativeGetMinZoom(mNativeMapViewPtr);
+    }
+
+    public double getMaxZoom() {
+        return nativeGetMaxZoom(mNativeMapViewPtr);
+    }
+
+    public void rotateBy(double sx, double sy, double ex, double ey) {
+        rotateBy(sx, sy, ex, ey, 0.0);
+    }
+
+    public void rotateBy(double sx, double sy, double ex, double ey,
+            double duration) {
+        nativeRotateBy(mNativeMapViewPtr, sx, sy, ex, ey, duration);
+    }
+
+    public void setAngle(double angle) {
+        setAngle(angle, 0.0);
+    }
+
+    public void setAngle(double angle, double duration) {
+        nativeSetAngle(mNativeMapViewPtr, angle, duration);
+    }
+
+    public void setAngle(double angle, double cx, double cy) {
+        nativeSetAngle(mNativeMapViewPtr, angle, cx, cy);
+    }
+
+    public double getAngle() {
+        return nativeGetAngle(mNativeMapViewPtr);
+    }
+
+    public void resetNorth() {
+        nativeResetNorth(mNativeMapViewPtr);
+    }
+
+    public void startRotating() {
+        nativeStartRotating(mNativeMapViewPtr);
+    }
+
+    public void stopRotating() {
+        nativeStopRotating(mNativeMapViewPtr);
+    }
+
+    public boolean canRotate() {
+        return nativeCanRotate(mNativeMapViewPtr);
+    }
+
+    public void setDebug(boolean debug) {
+        nativeSetDebug(mNativeMapViewPtr, debug);
+    }
+
+    public void toggleDebug() {
+        nativeToggleDebug(mNativeMapViewPtr);
+    }
+
+    public boolean getDebug() {
+        return nativeGetDebug(mNativeMapViewPtr);
+    }
+
+    //
+    // Callbacks
+    //
+
+    protected void onMapChanged() {
+        Log.v(TAG, "onMapChanged");
+        mMapView.onMapChanged();
+    }
+
+    //
+    // JNI methods
+    //
+
+    @Override
+    protected void finalize() throws Throwable {
+        nativeDestroy(mNativeMapViewPtr);
+        mNativeMapViewPtr = 0;
+        super.finalize();
+    }
+
+    private native long nativeCreate(String defaultStyleJSON);
+
+    private native void nativeDestroy(long nativeMapViewPtr);
+
+    private native void nativeInitializeDisplay(long nativeMapViewPtr);
+
+    private native void nativeTerminateDisplay(long nativeMapViewPtr);
+
+    private native void nativeInitializeContext(long nativeMapViewPtr);
+
+    private native void nativeTerminateContext(long nativeMapViewPtr);
+
+    private native void nativeCreateSurface(long nativeMapViewPtr,
+            Surface surface);
+
+    private native void nativeDestroySurface(long nativeMapViewPtr);
+
+    private native void nativeStart(long nativeMapViewPtr);
+
+    private native void nativeStop(long nativeMapViewPtr);
+
+    private native void nativeRerender(long nativeMapViewPtr);
+
+    private native void nativeUpdate(long nativeMapViewPtr);
+
+    private native void nativeCleanup(long nativeMapViewPtr);
+
+    private native void nativeAddDefaultSource(long nativeMapViewPtr);
+
+    private native void nativeRemoveDefaultSource(long nativeMapViewPtr);
+
+    private native void nativeAddSource(long nativeMapViewPtr, String name,
+            String url);
+
+    private native void nativeRemoveSource(long nativeMapViewPtr, String name);
+
+    private native void nativeResize(long nativeMapViewPtr, int width,
+            int height, float ratio);
+
+    private native void nativeResize(long nativeMapViewPtr, int width,
+            int height, float ratio, int fbWidth, int fbHeight);
+
+    private native void nativeSetAppliedClasses(long nativeMapViewPtr,
+            Set<String> appliedClasses);
+
+    private native Set<String> nativeGetAppliedClasses(long nativeMapViewPtr);
+
+    private native void nativeSetDefaultTransitionDuration(
+            long nativeMapViewPtr, long durationMilliseconds);
+
+    private native void nativeSetStyleJSON(long nativeMapViewPtr,
+            String newStyleJSON);
+
+    private native String nativeGetStyleJSON(long nativeMapViewPtr);
+
+    private native void nativeCancelTransitions(long nativeMapViewPtr);
+
+    private native void nativeMoveBy(long nativeMapViewPtr, double dx,
+            double dy, double duration);
+
+    private native void nativeSetLonLat(long nativeMapViewPtr, LonLat lonLat,
+            double duration);
+
+    private native LonLat nativeGetLonLat(long nativeMapViewPtr);
+
+    private native void nativeStartPanning(long nativeMapViewPtr);
+
+    private native void nativeStopPanning(long nativeMapViewPtr);
+
+    private native void nativeResetPosition(long nativeMapViewPtr);
+
+    private native void nativeScaleBy(long nativeMapViewPtr, double ds,
+            double cx, double cy, double duration);
+
+    private native void nativeSetScale(long nativeMapViewPtr, double scale,
+            double cx, double cy, double duration);
+
+    private native double nativeGetScale(long nativeMapViewPtr);
+
+    private native void nativeSetZoom(long nativeMapViewPtr, double zoom,
+            double duration);
+
+    private native double nativeGetZoom(long nativeMapViewPtr);
+
+    private native void nativeSetLonLatZoom(long nativeMapViewPtr,
+            LonLatZoom lonLatZoom, double duration);
+
+    private native LonLatZoom nativeGetLonLatZoom(long nativeMapViewPtr);
+
+    private native void nativeResetZoom(long nativeMapViewPtr);
+
+    private native void nativeStartScaling(long nativeMapViewPtr);
+
+    private native void nativeStopScaling(long nativeMapViewPtr);
+
+    private native double nativeGetMinZoom(long nativeMapViewPtr);
+
+    private native double nativeGetMaxZoom(long nativeMapViewPtr);
+
+    private native void nativeRotateBy(long nativeMapViewPtr, double sx,
+            double sy, double ex, double ey, double duration);
+
+    private native void nativeSetAngle(long nativeMapViewPtr, double angle,
+            double duration);
+
+    private native void nativeSetAngle(long nativeMapViewPtr, double angle,
+            double cx, double cy);
+
+    private native double nativeGetAngle(long nativeMapViewPtr);
+
+    private native void nativeResetNorth(long nativeMapViewPtr);
+
+    private native void nativeStartRotating(long nativeMapViewPtr);
+
+    private native void nativeStopRotating(long nativeMapViewPtr);
+
+    private native boolean nativeCanRotate(long nativeMapViewPtr);
+
+    private native void nativeSetDebug(long nativeMapViewPtr, boolean debug);
+
+    private native void nativeToggleDebug(long nativeMapViewPtr);
+
+    private native boolean nativeGetDebug(long nativeMapViewPtr);
+}

android/java/lib/src/main/res/values/attrs.xml

@@ -0,0 +1,32 @@
+<resources>
+    <attr name="centerLongitude" format="float" />
+    <attr name="centerLatitude" format="float" />
+    <attr name="zoomLevel" format="float" />
+    <attr name="direction" format="float" />
+    <attr name="zoomEnabled" format="boolean" />
+    <attr name="scrollEnabled" format="boolean" />
+    <attr name="rotateEnabled" format="boolean" />
+    <attr name="debugActive" format="boolean" />
+    
+    <declare-styleable name="MapView">
+        <attr name="centerLongitude" />
+        <attr name="centerLatitude" />
+        <attr name="zoomLevel" />
+        <attr name="direction" />
+        <attr name="zoomEnabled" />
+        <attr name="scrollEnabled" />
+        <attr name="rotateEnabled" />
+        <attr name="debugActive" />
+    </declare-styleable>
+    
+    <declare-styleable name="MapFragment">
+        <attr name="centerLongitude" />
+        <attr name="centerLatitude" />
+        <attr name="zoomLevel" />
+        <attr name="direction" />
+        <attr name="zoomEnabled" />
+        <attr name="scrollEnabled" />
+        <attr name="rotateEnabled" />
+        <attr name="debugActive" />
+    </declare-styleable>
+</resources>

android/java/lib/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+
+</resources>

android/java/settings.gradle

@@ -0,0 +1,2 @@
+include ':app'
+include ':lib'