Initial commit of BasicGestureDetect sample.

Change-Id: I211a2b27070a8b9f1b80d8e84e7355b0d3e552e9
(cherry picked from commit 9298bd7885bdf87cf91f1e68a06e7654650d7762)

28 files changed, 1235 insertions, 0 deletions

diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/build.gradle b/input/gestures/BasicGestureDetect/BasicGestureDetect/build.gradle
new file mode 100644
index 00000000..15c24fcb
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/build.gradle
@@ -0,0 +1,27 @@
+buildscript {
+    repositories {
+        mavenCentral()
+    }
+    dependencies {
+        classpath 'com.android.tools.build:gradle:0.5.+'
+    }
+}
+apply plugin: 'android'
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    compile 'com.android.support:support-v4:13.0.+'
+}
+
+android {
+    compileSdkVersion 18
+    buildToolsVersion "17.0.0"
+
+    defaultConfig {
+        minSdkVersion 7
+        targetSdkVersion 16
+    }
+}
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/libs/android-support-v4.jar b/input/gestures/BasicGestureDetect/BasicGestureDetect/libs/android-support-v4.jar
new file mode 100644
index 00000000..428bdbc0
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/libs/android-support-v4.jar
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/AndroidManifest.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/AndroidManifest.xml
new file mode 100755
index 00000000..9c6ec99e
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/AndroidManifest.xml
@@ -0,0 +1,42 @@
+<!--
+  Copyright 2013 The Android Open Source Project
+
+  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.
+  -->
+
+<manifest
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    package="com.example.android.basicgesturedetect"
+    android:versionCode="1"
+    android:versionName="1.0">
+
+    <uses-sdk android:minSdkVersion="8" android:targetSdkVersion="17" />
+
+    <application
+        android:label="@string/app_name"
+        android:icon="@drawable/ic_launcher"
+        android:theme="@style/Theme.Sample"
+        android:allowBackup="true">
+
+        <activity
+            android:name=".MainActivity"
+            android:label="@string/app_name"
+            android:uiOptions="splitActionBarWhenNarrow">
+
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <category android:name="android.intent.category.LAUNCHER" />
+            </intent-filter>
+        </activity>
+    </application>
+</manifest>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/basicgesturedetect/GestureListener.java b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/basicgesturedetect/GestureListener.java
new file mode 100644
index 00000000..2e2921d4
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/basicgesturedetect/GestureListener.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 com.example.android.basicgesturedetect;
+
+import android.view.GestureDetector;
+import android.view.MotionEvent;
+
+import com.example.android.common.logger.Log;
+
+public class GestureListener extends GestureDetector.SimpleOnGestureListener {
+
+    public static final String TAG = "GestureListener";
+
+    // BEGIN_INCLUDE(init_gestureListener)
+    @Override
+    public boolean onSingleTapUp(MotionEvent e) {
+        // Up motion completing a single tap occurred.
+        Log.i(TAG, "Single Tap Up");
+        return false;
+    }
+
+    @Override
+    public void onLongPress(MotionEvent e) {
+        // Touch has been long enough to indicate a long press.
+        // Does not indicate motion is complete yet (no up event necessarily)
+        Log.i(TAG, "Long Press");
+    }
+
+    @Override
+    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX,
+    float distanceY) {
+        // User attempted to scroll
+        Log.i(TAG, "Scroll");
+        return false;
+    }
+
+    @Override
+    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX,
+    float velocityY) {
+        // Fling event occurred.  Notification of this one happens after an "up" event.
+        Log.i(TAG, "Fling");
+        return false;
+    }
+
+    @Override
+    public void onShowPress(MotionEvent e) {
+        // User performed a down event, and hasn't moved yet.
+        Log.i(TAG, "Show Press");
+    }
+
+    @Override
+    public boolean onDown(MotionEvent e) {
+        // "Down" event - User touched the screen.
+        Log.i(TAG, "Down");
+        return false;
+    }
+
+    @Override
+    public boolean onDoubleTap(MotionEvent e) {
+        // User tapped the screen twice.
+        Log.i(TAG, "Double tap");
+        return false;
+    }
+
+    @Override
+    public boolean onDoubleTapEvent(MotionEvent e) {
+        // Since double-tap is actually several events which are considered one aggregate
+        // gesture, there's a separate callback for an individual event within the doubletap
+        // occurring.  This occurs for down, up, and move.
+        Log.i(TAG, "Event within double tap");
+        return false;
+    }
+
+    @Override
+    public boolean onSingleTapConfirmed(MotionEvent e) {
+        // A confirmed single-tap event has occurred.  Only called when the detector has
+        // determined that the first tap stands alone, and is not part of a double tap.
+        Log.i(TAG, "Single tap confirmed");
+        return false;
+    }
+    // END_INCLUDE(init_gestureListener)
+}
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/basicgesturedetect/LogFragment.java b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/basicgesturedetect/LogFragment.java
new file mode 100644
index 00000000..849edacc
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/basicgesturedetect/LogFragment.java
@@ -0,0 +1,58 @@
+// Copyright 2013 Google Inc. All Rights Reserved.
+
+package com.example.android.basicgesturedetect;
+
+import com.example.android.common.logger.LogView;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.text.Editable;
+import android.text.TextWatcher;
+
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ScrollView;
+
+/**
+ * Simple fraggment which contains a LogView and uses is to output log data it receives
+ * through the LogNode interface.
+ */
+public class LogFragment extends Fragment {
+
+    private LogView mLogView;
+
+    public LogFragment() {}
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+
+        View result = inflater.inflate(R.layout.log_fragment, container, false);
+
+        mLogView = (LogView) result.findViewById(R.id.sample_output);
+
+        // Wire up so when the text changes, the view scrolls down.
+        final ScrollView scrollView =
+                ((ScrollView) result.findViewById(R.id.log_scroll));
+
+        mLogView.addTextChangedListener(new TextWatcher() {
+            @Override
+            public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
+
+            @Override
+            public void onTextChanged(CharSequence s, int start, int before, int count) {}
+
+            @Override
+            public void afterTextChanged(Editable s) {
+                scrollView.fullScroll(ScrollView.FOCUS_DOWN);
+            }
+        });
+
+        return result;
+    }
+
+    public LogView getLogView() {
+        return mLogView;
+    }
+}
\ No newline at end of file
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/basicgesturedetect/MainActivity.java b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/basicgesturedetect/MainActivity.java
new file mode 100755
index 00000000..4654ac95
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/basicgesturedetect/MainActivity.java
@@ -0,0 +1,131 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 com.example.android.basicgesturedetect;
+
+import android.os.Bundle;
+import android.support.v4.app.FragmentActivity;
+import android.util.TypedValue;
+import android.view.GestureDetector;
+import android.view.Menu;
+import android.view.MenuItem;
+import android.view.MotionEvent;
+import android.view.View;
+
+import com.example.android.common.logger.LogWrapper;
+import com.example.android.common.logger.Log;
+import com.example.android.common.widgets.SimpleTextFragment;
+import com.example.android.common.logger.MessageOnlyLogFilter;
+
+/**
+ * Sample application demonstrating how to use GestureDetector go detect when a user performs
+ * a gesture that's recognized by the framework.  This example uses SimpleGestureDetector.  If you
+ * want to detect
+ * as well as customize that shortcut with metadata to send along to the application it activates.
+ * Code is also included for removing your shortcut from the homescreen, for situations where that
+ * is necessary (for instance, removing a shortcut to some data when that data is deleted from your
+ * app).
+ */
+public class MainActivity extends FragmentActivity {
+
+    public static final String TAG = "Basic Gesture Detector";
+
+    // Reference to the fragment showing events, so we can clear it with a button as necessary.
+    private LogFragment mLogFragment;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.activity_main);
+
+        SimpleTextFragment actionFragment = (SimpleTextFragment)
+                    getSupportFragmentManager().findFragmentById(R.id.intro_fragment);
+        actionFragment.setText(R.string.intro_message);
+        actionFragment.getView().setClickable(true);
+        actionFragment.getView().setFocusable(true);
+        actionFragment.getTextView().setTextSize(TypedValue.COMPLEX_UNIT_DIP, 16.0f);
+
+
+        // BEGIN_INCLUDE(init_detector)
+
+        // First create the GestureListener that will include all our callbacks.
+        // Then create the GestureDetector, which takes that listener as an argument.
+        GestureDetector.SimpleOnGestureListener gestureListener = getGestureListener();
+        final GestureDetector gd = new GestureDetector(this, gestureListener);
+
+        /* For the view where gestures will occur, create an onTouchListener that sends
+         * all motion events to the gesture detector.  When the gesture detector
+         * actually detects an event, it will use the callbacks you created in the
+         * SimpleOnGestureListener to alert your application.
+        */
+
+        actionFragment.getView().setOnTouchListener(new View.OnTouchListener() {
+            @Override
+            public boolean onTouch(View view, MotionEvent motionEvent) {
+                gd.onTouchEvent(motionEvent);
+                return false;
+            }
+        });
+        // END_INCLUDE(init_detector)
+
+        initializeLogging();
+    }
+
+    /** Create a gesture listener which will be attached to the GestureDetector.
+     *  This listener is where you can write all your callbacks for when certain events occur.
+     * @return The listener your GestureDetector will use to inform your application when
+     * the supported gestures occur.
+     */
+    public GestureDetector.SimpleOnGestureListener getGestureListener() {
+        return new GestureListener();
+    }
+
+    @Override
+    public boolean onCreateOptionsMenu(Menu menu) {
+        getMenuInflater().inflate(R.menu.main, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.sample_action:
+                // Clears the log fragment when clicked.
+                mLogFragment.getLogView().setText("");
+                return true;
+        }
+        return false;
+    }
+
+    /** Create a chain of targets that will receive log data */
+    public void initializeLogging() {
+        // Wraps Android's native log framework.
+        LogWrapper logWrapper = new LogWrapper();
+        // Using Log, front-end to the logging chain, emulates android.util.log method signatures.
+        Log.setLogNode(logWrapper);
+
+        // Filter strips out everything except the message text.
+        MessageOnlyLogFilter msgFilter = new MessageOnlyLogFilter();
+        logWrapper.setNext(msgFilter);
+
+        // On screen logging via a fragment with a TextView.
+        mLogFragment =
+                (LogFragment) getSupportFragmentManager().findFragmentById(R.id.log_fragment);
+        msgFilter.setNext(mLogFragment.getLogView());
+
+        Log.i(TAG, "Ready");
+    }
+}
\ No newline at end of file
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/Log.java b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/Log.java
new file mode 100644
index 00000000..a87f299e
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/Log.java
@@ -0,0 +1,236 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * 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 com.example.android.common.logger;
+
+/**
+ * Helper class for a list (or tree) of LoggerNodes.
+ *
+ * <p>When this is set as the head of the list,
+ * an instance of it can function as a drop-in replacement for {@link android.util.Log}.
+ * Most of the methods in this class server only to map a method call in Log to its equivalent
+ * in LogNode.</p>
+ */
+public class Log {
+    // Grab the native values from Android's native logging facilities,
+    // to make for easy migration and interop.
+    public static final int NONE = -1;
+    public static final int VERBOSE = android.util.Log.VERBOSE;
+    public static final int DEBUG = android.util.Log.DEBUG;
+    public static final int INFO = android.util.Log.INFO;
+    public static final int WARN = android.util.Log.WARN;
+    public static final int ERROR = android.util.Log.ERROR;
+    public static final int ASSERT = android.util.Log.ASSERT;
+
+    // Stores the beginning of the LogNode topology.
+    private static LogNode mLogNode;
+
+    /**
+     * Returns the next LogNode in the linked list.
+     */
+    public static LogNode getLogNode() {
+        return mLogNode;
+    }
+
+    /**
+     * Sets the LogNode data will be sent to.
+     */
+    public static void setLogNode(LogNode node) {
+        mLogNode = node;
+    }
+
+    /**
+     * Instructs the LogNode to print the log data provided. Other LogNodes can
+     * be chained to the end of the LogNode as desired.
+     *
+     * @param priority Log level of the data being logged. Verbose, Error, etc.
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public static void println(int priority, String tag, String msg, Throwable tr) {
+        if (mLogNode != null) {
+            mLogNode.println(priority, tag, msg, tr);
+        }
+    }
+
+    /**
+     * Instructs the LogNode to print the log data provided. Other LogNodes can
+     * be chained to the end of the LogNode as desired.
+     *
+     * @param priority Log level of the data being logged. Verbose, Error, etc.
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged. The actual message to be logged.
+     */
+    public static void println(int priority, String tag, String msg) {
+        println(priority, tag, msg, null);
+    }
+
+   /**
+     * Prints a message at VERBOSE priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public static void v(String tag, String msg, Throwable tr) {
+        println(VERBOSE, tag, msg, tr);
+    }
+
+    /**
+     * Prints a message at VERBOSE priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     */
+    public static void v(String tag, String msg) {
+        v(tag, msg, null);
+    }
+
+
+    /**
+     * Prints a message at DEBUG priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public static void d(String tag, String msg, Throwable tr) {
+        println(DEBUG, tag, msg, tr);
+    }
+
+    /**
+     * Prints a message at DEBUG priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     */
+    public static void d(String tag, String msg) {
+        d(tag, msg, null);
+    }
+
+    /**
+     * Prints a message at INFO priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public static void i(String tag, String msg, Throwable tr) {
+        println(INFO, tag, msg, tr);
+    }
+
+    /**
+     * Prints a message at INFO priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     */
+    public static void i(String tag, String msg) {
+        i(tag, msg, null);
+    }
+
+    /**
+     * Prints a message at WARN priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public static void w(String tag, String msg, Throwable tr) {
+        println(WARN, tag, msg, tr);
+    }
+
+    /**
+     * Prints a message at WARN priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     */
+    public static void w(String tag, String msg) {
+        w(tag, msg, null);
+    }
+
+    /**
+     * Prints a message at WARN priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public static void w(String tag, Throwable tr) {
+        w(tag, null, tr);
+    }
+
+    /**
+     * Prints a message at ERROR priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public static void e(String tag, String msg, Throwable tr) {
+        println(ERROR, tag, msg, tr);
+    }
+
+    /**
+     * Prints a message at ERROR priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     */
+    public static void e(String tag, String msg) {
+        e(tag, msg, null);
+    }
+
+    /**
+     * Prints a message at ASSERT priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public static void wtf(String tag, String msg, Throwable tr) {
+        println(ASSERT, tag, msg, tr);
+    }
+
+    /**
+     * Prints a message at ASSERT priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param msg The actual message to be logged.
+     */
+    public static void wtf(String tag, String msg) {
+        wtf(tag, msg, null);
+    }
+
+    /**
+     * Prints a message at ASSERT priority.
+     *
+     * @param tag Tag for for the log data. Can be used to organize log statements.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public static void wtf(String tag, Throwable tr) {
+        wtf(tag, null, tr);
+    }
+}
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/LogNode.java b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/LogNode.java
new file mode 100644
index 00000000..bc37cabc
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/LogNode.java
@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * 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 com.example.android.common.logger;
+
+/**
+ * Basic interface for a logging system that can output to one or more targets.
+ * Note that in addition to classes that will output these logs in some format,
+ * one can also implement this interface over a filter and insert that in the chain,
+ * such that no targets further down see certain data, or see manipulated forms of the data.
+ * You could, for instance, write a "ToHtmlLoggerNode" that just converted all the log data
+ * it received to HTML and sent it along to the next node in the chain, without printing it
+ * anywhere.
+ */
+public interface LogNode {
+
+    /**
+     * Instructs first LogNode in the list to print the log data provided.
+     * @param priority Log level of the data being logged.  Verbose, Error, etc.
+     * @param tag Tag for for the log data.  Can be used to organize log statements.
+     * @param msg The actual message to be logged. The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    public void println(int priority, String tag, String msg, Throwable tr);
+
+}
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/LogView.java b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/LogView.java
new file mode 100644
index 00000000..d86a88ba
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/LogView.java
@@ -0,0 +1,121 @@
+package com.example.android.common.logger;
+
+import android.content.Context;
+import android.text.method.ScrollingMovementMethod;
+import android.util.*;
+import android.widget.TextView;
+
+/**
+ * Created by alexlucas on 6/4/13.
+ */
+
+
+public class LogView extends TextView implements LogNode {
+
+    public LogView(Context context) {
+        super(context);
+    }
+
+    public LogView(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public LogView(Context context, AttributeSet attrs, int defStyle) {
+        super(context, attrs, defStyle);
+    }
+
+    /**
+     * Formats the log data and prints it out to the LogView.
+     * @param priority Log level of the data being logged.  Verbose, Error, etc.
+     * @param tag Tag for for the log data.  Can be used to organize log statements.
+     * @param msg The actual message to be logged. The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    @Override
+    public void println(int priority, String tag, String msg, Throwable tr) {
+        String priorityStr = null;
+
+        // For the purposes of this View, we want to print the priority as readable text.
+        switch(priority) {
+            case android.util.Log.VERBOSE:
+                priorityStr = "VERBOSE";
+                break;
+            case android.util.Log.DEBUG:
+                priorityStr = "DEBUG";
+                break;
+            case android.util.Log.INFO:
+                priorityStr = "INFO";
+                break;
+            case android.util.Log.WARN:
+                priorityStr = "WARN";
+                break;
+            case android.util.Log.ERROR:
+                priorityStr = "ERROR";
+                break;
+            case android.util.Log.ASSERT:
+                priorityStr = "ASSERT";
+                break;
+            default:
+                break;
+        }
+
+        // Handily, the Log class has a facility for converting a stack trace into a useable string.
+        String exceptionStr = null;
+        if (tr != null) {
+            exceptionStr = android.util.Log.getStackTraceString(tr);
+        }
+
+        // Take the priority, tag, message, and exception, and concatonate as necessary
+        // into one usable line of text.
+        String outputStr =  "";
+        outputStr = appendIfNotNull(outputStr, priorityStr, "\t");
+        outputStr = appendIfNotNull(outputStr, tag, "\t");
+        outputStr = appendIfNotNull(outputStr, msg, "\t");
+        outputStr = appendIfNotNull(outputStr, exceptionStr, "\t");
+
+        // Actually display the text we just generated within the LogView.
+        appendToLog(outputStr);
+
+        if (mNext != null) {
+            mNext.println(priority, tag, msg, tr);
+        }
+    }
+
+    public LogNode getNext() {
+        return mNext;
+    }
+
+    public void setNext(LogNode node) {
+        mNext = node;
+    }
+
+    /** Takes a string and adds to it, with a seperator, if the bit to be added isn't null. Since
+     * the logger takes so many arguments that might be null, this method helps cut out some of the
+     * agonizing tedium of writing the same 3 lines over and over.
+     * @param sourceStr The String to append to.
+     * @param appendStr The String to append
+     * @param delimiter The String to seperate the source and appendee strings. A tab or comma,
+     *                  for instance.
+     * @return The fully concatonated String
+     */
+    private String appendIfNotNull(String sourceStr, String appendStr, String delimiter) {
+        if (appendStr != null) {
+            if (appendStr.length() == 0) {
+                delimiter = "";
+            }
+            sourceStr += delimiter + appendStr;
+        }
+        return sourceStr;
+    }
+
+    // The next LogNode in the chain.
+    LogNode mNext;
+
+    /** Outputs the string as a new line of log data in the LogView. */
+    public void appendToLog(String s) {
+        append("\n" + s);
+    }
+
+
+}
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/LogWrapper.java b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/LogWrapper.java
new file mode 100644
index 00000000..16a9e7ba
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/LogWrapper.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * 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 com.example.android.common.logger;
+
+import android.util.Log;
+
+/**
+ * Helper class which wraps Android's native Log utility in the Logger interface.  This way
+ * normal DDMS output can be one of the many targets receiving and outputting logs simultaneously.
+ */
+public class LogWrapper implements LogNode {
+
+    // For piping:  The next node to receive Log data after this one has done its work.
+    private LogNode mNext;
+
+    /**
+     * Returns the next LogNode in the linked list.
+     */
+    public LogNode getNext() {
+        return mNext;
+    }
+
+    /**
+     * Sets the LogNode data will be sent to..
+     */
+    public void setNext(LogNode node) {
+        mNext = node;
+    }
+
+    /**
+     * Prints data out to the console using Android's native log mechanism.
+     * @param priority Log level of the data being logged.  Verbose, Error, etc.
+     * @param tag Tag for for the log data.  Can be used to organize log statements.
+     * @param msg The actual message to be logged. The actual message to be logged.
+     * @param tr If an exception was thrown, this can be sent along for the logging facilities
+     *           to extract and print useful information.
+     */
+    @Override
+    public void println(int priority, String tag, String msg, Throwable tr) {
+        // There actually are log methods that don't take a msg parameter.  For now,
+        // if that's the case, just convert null to the empty string and move on.
+        String useMsg = msg;
+        if (useMsg == null) {
+            useMsg = "";
+        }
+
+        // If an exeption was provided, convert that exception to a usable string and attach
+        // it to the end of the msg method.
+        if (tr != null) {
+            msg += "\n" + Log.getStackTraceString(tr);
+        }
+
+        // This is functionally identical to Log.x(tag, useMsg);
+        // For instance, if priority were Log.VERBOSE, this would be the same as Log.v(tag, useMsg)
+        Log.println(priority, tag, useMsg);
+
+        // If this isn't the last node in the chain, move things along.
+        if (mNext != null) {
+            mNext.println(priority, tag, msg, tr);
+        }
+    }
+}
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/MessageOnlyLogFilter.java b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/MessageOnlyLogFilter.java
new file mode 100644
index 00000000..6b72771c
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/logger/MessageOnlyLogFilter.java
@@ -0,0 +1,60 @@
+/*
+ * Copyright (C) 2013 The Android Open Source Project
+ *
+ * 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 com.example.android.common.logger;
+
+/**
+ * Simple {@link LogNode} filter, removes everything except the message.
+ * Useful for situations like on-screen log output where you don't want a lot of metadata displayed,
+ * just easy-to-read message updates as they're happening.
+ */
+public class MessageOnlyLogFilter implements LogNode {
+
+    LogNode mNext;
+
+    /**
+     * Takes the "next" LogNode as a parameter, to simplify chaining.
+     *
+     * @param next The next LogNode in the pipeline.
+     */
+    public MessageOnlyLogFilter(LogNode next) {
+        mNext = next;
+    }
+
+    public MessageOnlyLogFilter() {
+    }
+
+    @Override
+    public void println(int priority, String tag, String msg, Throwable tr) {
+        if (mNext != null) {
+            getNext().println(Log.NONE, null, msg, null);
+        }
+    }
+
+    /**
+     * Returns the next LogNode in the linked list.
+     */
+    public LogNode getNext() {
+        return mNext;
+    }
+
+    /**
+     * Sets the LogNode data will be sent to..
+     */
+    public void setNext(LogNode node) {
+        mNext = node;
+    }
+
+}
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/widgets/SimpleTextFragment.java b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/widgets/SimpleTextFragment.java
new file mode 100644
index 00000000..bd51a1c1
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/java/com/example/android/common/widgets/SimpleTextFragment.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2013 The Android Open Source Project
+ *
+ * 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 com.example.android.common.widgets;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.util.Log;
+import android.view.Gravity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+/**
+ * Simple fragment containing only a TextView.  Used by TextPagerAdapter to create
+ * tutorial-style pages for apps.
+ */
+public class SimpleTextFragment extends Fragment {
+
+    // Contains the text that will be displayed by this Fragment
+    String mText;
+
+    // Contains a resource ID for the text that will be displayed by this fragment.
+    int mTextId = -1;
+
+    // Keys which will be used to store/retrieve text passed in via setArguments.
+    public static final String TEXT_KEY = "text";
+    public static final String TEXT_ID_KEY = "text_id";
+
+    // For situations where the app wants to modify text at Runtime, exposing the TextView.
+    private TextView mTextView;
+
+    public SimpleTextFragment() {
+    }
+
+    @Override
+    public View onCreateView(LayoutInflater inflater, ViewGroup container,
+            Bundle savedInstanceState) {
+        // Before initializing the textView, check if any arguments were provided via setArguments.
+        processArguments();
+
+        // Create a new TextView and set its text to whatever was provided.
+        mTextView = new TextView(getActivity());
+        mTextView.setGravity(Gravity.CENTER);
+
+        if (mText != null) {
+            mTextView.setText(mText);
+            Log.i("SimpleTextFragment", mText);
+        }
+        return mTextView;
+    }
+
+    public TextView getTextView() {
+        return mTextView;
+    }
+
+    /**
+     * Changes the text for this TextView, according to the resource ID provided.
+     * @param stringId A resource ID representing the text content for this Fragment's TextView.
+     */
+    public void setText(int stringId) {
+        getTextView().setText(getActivity().getString(stringId));
+    }
+
+    /**
+     * Processes the arguments passed into this Fragment via setArguments method.
+     * Currently the method only looks for text or a textID, nothing else.
+     */
+    public void processArguments() {
+        // For most objects we'd handle the multiple possibilities for initialization variables
+        // as multiple constructors.  For Fragments, however, it's customary to use
+        // setArguments / getArguments.
+        if (getArguments() != null) {
+            Bundle args = getArguments();
+            if (args.containsKey(TEXT_KEY)) {
+                mText = args.getString(TEXT_KEY);
+                Log.d("Constructor", "Added Text.");
+            } else if (args.containsKey(TEXT_ID_KEY)) {
+                mTextId = args.getInt(TEXT_ID_KEY);
+                mText = getString(mTextId);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-hdpi/ic_launcher.png b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-hdpi/ic_launcher.png
new file mode 100755
index 00000000..22ce6061
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-hdpi/ic_launcher.png
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-mdpi/ic_launcher.png b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-mdpi/ic_launcher.png
new file mode 100755
index 00000000..f21e17b6
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-mdpi/ic_launcher.png
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-xhdpi/ic_launcher.png b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-xhdpi/ic_launcher.png
new file mode 100755
index 00000000..64b80590
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-xhdpi/ic_launcher.png
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-xxhdpi/ic_launcher.png b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-xxhdpi/ic_launcher.png
new file mode 100755
index 00000000..6b4434a8
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/drawable-xxhdpi/ic_launcher.png
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/layout/activity_main.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/layout/activity_main.xml
new file mode 100755
index 00000000..471748f1
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/layout/activity_main.xml
@@ -0,0 +1,40 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  Copyright 2013 The Android Open Source Project
+
+  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.
+  -->
+
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="vertical"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent">
+    <fragment
+        android:name="com.example.android.common.SimpleTextFragment"
+        android:id="@+id/intro_fragment"
+        android:layout_weight="1"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+    <View
+        android:layout_width="fill_parent"
+        android:layout_height="1dp"
+        android:background="@android:color/darker_gray"/>
+    <fragment
+        android:name="com.example.android.basicgesturedetect.LogFragment"
+        android:id="@+id/log_fragment"
+        android:layout_weight="1"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+</LinearLayout>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/layout/log_fragment.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/layout/log_fragment.xml
new file mode 100644
index 00000000..6d795484
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/layout/log_fragment.xml
@@ -0,0 +1,33 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  Copyright 2013 The Android Open Source Project
+
+  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.
+  -->
+
+<ScrollView xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/log_scroll"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+
+    <com.example.android.common.logger.LogView
+        android:id="@+id/sample_output"
+        style="@style/Log"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:clickable="true"
+        android:focusable="true"
+        android:text=""
+        android:gravity="bottom" />
+</ScrollView>
\ No newline at end of file
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/menu/main.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/menu/main.xml
new file mode 100644
index 00000000..d0ffa142
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/menu/main.xml
@@ -0,0 +1,21 @@
+<!--
+  Copyright 2013 The Android Open Source Project
+
+  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.
+  -->
+
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <item android:id="@+id/sample_action"
+        android:showAsAction="ifRoom|withText"
+        android:title="@string/clear_text" />
+</menu>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-sw600dp/dimens.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-sw600dp/dimens.xml
new file mode 100644
index 00000000..886b05fa
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-sw600dp/dimens.xml
@@ -0,0 +1,4 @@
+<resources>
+    <!-- Customize dimensions originally defined in res/values/dimens.xml (such as
+         screen margins) for sw600dp devices (e.g. 7" tablets) here. -->
+</resources>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-sw600dp/styles.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-sw600dp/styles.xml
new file mode 100644
index 00000000..ffcbe8ac
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-sw600dp/styles.xml
@@ -0,0 +1,28 @@
+<!--
+  Copyright 2013 The Android Open Source Project
+
+  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.
+  -->
+
+<resources>
+
+    <style name="Widget.SampleOutput">
+        <item name="android:paddingTop">@dimen/margin_medium</item>
+        <item name="android:paddingBottom">@dimen/margin_medium</item>
+        <item name="android:paddingLeft">@dimen/margin_huge</item>
+        <item name="android:paddingRight">@dimen/margin_huge</item>
+        <item name="android:textAppearance">?android:textAppearanceLarge</item>
+        <item name="android:lineSpacingMultiplier">1.2</item>
+    </style>
+
+</resources>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-sw720dp-land/dimens.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-sw720dp-land/dimens.xml
new file mode 100644
index 00000000..00059fc5
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-sw720dp-land/dimens.xml
@@ -0,0 +1,5 @@
+<resources>
+    <!-- Customize dimensions originally defined in res/values/dimens.xml (such as
+         screen margins) for sw720dp devices (e.g. 10" tablets) in landscape here. -->
+    <dimen name="activity_horizontal_margin">128dp</dimen>
+</resources>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-v11/styles.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-v11/styles.xml
new file mode 100644
index 00000000..c6c648b4
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-v11/styles.xml
@@ -0,0 +1,19 @@
+<!--
+  Copyright 2013 The Android Open Source Project
+
+  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.
+  -->
+
+<resources>
+    <style name="Theme.Base" parent="android:Theme.Holo.Light" />
+</resources>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-v14/styles.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values-v14/styles.xml
new file mode 100644
index 00000000..a91fd037
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/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>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values/dimens.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values/dimens.xml
new file mode 100644
index 00000000..4f69897d
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values/dimens.xml
@@ -0,0 +1,24 @@
+<!--
+  Copyright 2013 The Android Open Source Project
+
+  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.
+  -->
+
+<resources>
+
+    <!-- Define standard dimensions to comply with Holo-style grids and rhythm. -->
+
+    <dimen name="margin_medium">16dp</dimen>
+    <dimen name="margin_huge">64dp</dimen>
+
+</resources>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values/strings.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values/strings.xml
new file mode 100755
index 00000000..ce1ad02a
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values/strings.xml
@@ -0,0 +1,25 @@
+<!--
+  Copyright 2013 The Android Open Source Project
+
+  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.
+  -->
+
+<resources>
+    <string name="app_name">Basic Gesture Detect</string>
+
+    <string name="intro_message">Welcome to Basic Gesture Detect!
+        In order to try this sample out, try dragging or tapping this text to see what happens!
+    </string>
+
+    <string name="clear_text">Clear Text</string>
+</resources>
diff --git a/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values/styles.xml b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values/styles.xml
new file mode 100644
index 00000000..4d9bb984
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/BasicGestureDetect/src/main/res/values/styles.xml
@@ -0,0 +1,40 @@
+<!--
+  Copyright 2013 The Android Open Source Project
+
+  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 thegi 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.
+  -->
+
+<resources>
+
+    <!-- Activity themes -->
+
+    <style name="Theme.Base" parent="android:Theme.Light" />
+
+    <style name="Theme.Sample" parent="Theme.Base" />
+
+    <!-- Widget styling -->
+
+    <style name="Widget" />
+
+    <style name="Widget.SampleOutput">
+        <item name="android:padding">@dimen/margin_medium</item>
+        <item name="android:textAppearance">?android:textAppearanceMedium</item>
+        <item name="android:lineSpacingMultiplier">1.1</item>
+    </style>
+
+    <style name="Log" parent="Widget.SampleOutput">
+        <item name="android:typeface">monospace</item>
+    </style>
+
+
+</resources>
diff --git a/input/gestures/BasicGestureDetect/build.gradle b/input/gestures/BasicGestureDetect/build.gradle
new file mode 100644
index 00000000..495c5038
--- /dev/null
+++ b/input/gestures/BasicGestureDetect/build.gradle
@@ -0,0 +1 @@
+// Top-level build file where you can add configuration options common to all sub-projects/modules.