Add copies of the android private headers

This uses 2.4 and 2.9 MB for the two versions, but avoids having
to keep the full source repos lying around when we only use the
headers, when the full repos take up over 900 MB and 1.7 GB
respectively.
Signed-off-by: Martin Storsjö <martin@martin.st>

.gitignore

 vlc/
-android-headers-gingerbread/
-android-headers-ics/
 android-libs/*.so
 update-cm-7.1.0.1-NS-signed.zip
 vlc-android/libs/armeabi/

android-headers-gingerbread/frameworks/base/include/android_runtime/ActivityManager.h

+/*
+ * Copyright (C) 2008 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.
+ */
+
+#ifndef ActivityManager_H
+#define ActivityManager_H
+
+#include <utils/String16.h>
+
+namespace android {
+
+// Perform a ContentProvider.openFile() call for the given URI.
+//
+// Returns the native file descriptor for the opened stream, < 0 on error.
+extern int openContentProviderFile(const String16& uri);
+
+}
+
+#endif

android-headers-gingerbread/frameworks/base/include/android_runtime/AndroidRuntime.h

+/*
+ * Copyright (C) 2005 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.
+ */
+
+//
+
+#ifndef _RUNTIME_ANDROID_RUNTIME_H
+#define _RUNTIME_ANDROID_RUNTIME_H
+
+#include <utils/Errors.h>
+#include <binder/IBinder.h>
+#include <utils/String8.h>
+#include <utils/String16.h>
+#include <utils/Vector.h>
+#include <utils/threads.h>
+#include <pthread.h>
+#include <nativehelper/jni.h>
+
+
+namespace android {
+    
+class AndroidRuntime
+{
+public:
+    AndroidRuntime();
+    virtual ~AndroidRuntime();
+
+    /**
+     * Register a set of methods in the specified class.
+     */
+    static int registerNativeMethods(JNIEnv* env,
+        const char* className, const JNINativeMethod* gMethods, int numMethods);
+
+    /**
+     * Call a static Java function that takes no arguments and returns void.
+     */
+    status_t callStatic(const char* className, const char* methodName);
+
+    /**
+     * Call a class's static main method with the given arguments,
+     */
+    status_t callMain(const char* className, int argc, const char* const argv[]);
+
+    /**
+     * Find a class, with the input either of the form 
+     * "package/class" or "package.class".
+     */
+    static jclass findClass(JNIEnv* env, const char* className);
+
+    int addVmArguments(int argc, const char* const argv[]);
+
+    void start(const char *classname, const bool startSystemServer);
+    void start();       // start in android.util.RuntimeInit
+
+    static AndroidRuntime* getRuntime();
+    
+    /**
+     * This gets called after the JavaVM has initialized.  Override it
+     * with the system's native entry point.
+     */
+    virtual void onStarted() = 0;
+
+    /**
+     * This gets called after the JavaVM has initialized after a Zygote
+     * fork. Override it to initialize threads, etc. Upon return, the
+     * correct static main will be invoked.
+     */
+    virtual void onZygoteInit() {};
+
+
+    /**
+     * Called when the Java application exits.  The default
+     * implementation calls exit(code).
+     */
+    virtual void onExit(int code);
+
+    /** create a new thread that is visible from Java */
+    static android_thread_id_t createJavaThread(const char* name, void (*start)(void *),
+        void* arg);
+
+    /** return a pointer to the VM running in this process */
+    static JavaVM* getJavaVM() { return mJavaVM; }
+
+    /** return a pointer to the JNIEnv pointer for this thread */
+    static JNIEnv* getJNIEnv();
+
+private:
+    static int startReg(JNIEnv* env);
+    void parseExtraOpts(char* extraOptsBuf);
+    int startVm(JavaVM** pJavaVM, JNIEnv** pEnv);
+
+    Vector<JavaVMOption> mOptions;
+
+    /* JNI JavaVM pointer */
+    static JavaVM* mJavaVM;
+
+    /*
+     * Thread creation helpers.
+     */
+    static int javaCreateThreadEtc(
+                                android_thread_func_t entryFunction, 
+                                void* userData,
+                                const char* threadName,
+                                int32_t threadPriority,
+                                size_t threadStackSize,
+                                android_thread_id_t* threadId);
+    static int javaThreadShell(void* args);
+};
+
+// Returns the Unix file descriptor for a ParcelFileDescriptor object
+extern int getParcelFileDescriptorFD(JNIEnv* env, jobject object);
+
+}
+
+#endif

android-headers-gingerbread/frameworks/base/include/android_runtime/android_app_NativeActivity.h

+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef _ANDROID_APP_NATIVEACTIVITY_H
+#define _ANDROID_APP_NATIVEACTIVITY_H
+
+#include <ui/InputTransport.h>
+#include <utils/Looper.h>
+
+#include <android/native_activity.h>
+
+#include "jni.h"
+
+namespace android {
+
+extern void android_NativeActivity_finish(
+        ANativeActivity* activity);
+
+extern void android_NativeActivity_setWindowFormat(
+        ANativeActivity* activity, int32_t format);
+
+extern void android_NativeActivity_setWindowFlags(
+        ANativeActivity* activity, int32_t values, int32_t mask);
+
+extern void android_NativeActivity_showSoftInput(
+        ANativeActivity* activity, int32_t flags);
+
+extern void android_NativeActivity_hideSoftInput(
+        ANativeActivity* activity, int32_t flags);
+
+} // namespace android
+
+
+/*
+ * NDK input queue API.
+ *
+ * Here is the event flow:
+ * 1. Event arrives in input consumer, and is returned by getEvent().
+ * 2. Application calls preDispatchEvent():
+ *    a. Event is assigned a sequence ID and enqueued in mPreDispatchingKeys.
+ *    b. Main thread picks up event, hands to input method.
+ *    c. Input method eventually returns sequence # and whether it was handled.
+ *    d. finishPreDispatch() is called to enqueue the information.
+ *    e. next getEvent() call will:
+ *       - finish any pre-dispatch events that the input method handled
+ *       - return the next pre-dispatched event that the input method didn't handle.
+ *    f. (A preDispatchEvent() call on this event will now return false).
+ * 3. Application calls finishEvent() with whether it was handled.
+ *    - If handled is true, the event is finished.
+ *    - If handled is false, the event is put on mUnhandledKeys, and:
+ *      a. Main thread receives event from consumeUnhandledEvent().
+ *      b. Java sends event through default key handler.
+ *      c. event is finished.
+ */
+struct AInputQueue : public android::InputEventFactoryInterface {
+public:
+    /* Creates a consumer associated with an input channel. */
+    explicit AInputQueue(const android::sp<android::InputChannel>& channel, int workWrite);
+
+    /* Destroys the consumer and releases its input channel. */
+    ~AInputQueue();
+
+    void attachLooper(ALooper* looper, int ident, ALooper_callbackFunc callback, void* data);
+
+    void detachLooper();
+
+    int32_t hasEvents();
+
+    int32_t getEvent(AInputEvent** outEvent);
+
+    bool preDispatchEvent(AInputEvent* event);
+
+    void finishEvent(AInputEvent* event, bool handled);
+
+    // ----------------------------------------------------------
+
+    inline android::InputConsumer& getConsumer() { return mConsumer; }
+
+    void dispatchEvent(android::KeyEvent* event);
+
+    void finishPreDispatch(int seq, bool handled);
+
+    android::KeyEvent* consumeUnhandledEvent();
+    android::KeyEvent* consumePreDispatchingEvent(int* outSeq);
+
+    virtual android::KeyEvent* createKeyEvent();
+    virtual android::MotionEvent* createMotionEvent();
+
+    int mWorkWrite;
+
+private:
+    void doUnhandledKey(android::KeyEvent* keyEvent);
+    bool preDispatchKey(android::KeyEvent* keyEvent);
+    void wakeupDispatch();
+
+    android::InputConsumer mConsumer;
+    android::sp<android::Looper> mLooper;
+
+    int mDispatchKeyRead;
+    int mDispatchKeyWrite;
+
+    struct in_flight_event {
+        android::InputEvent* event;
+        int seq;
+        bool doFinish;
+    };
+
+    struct finish_pre_dispatch {
+        int seq;
+        bool handled;
+    };
+
+    android::Mutex mLock;
+
+    int mSeq;
+
+    // Cache of previously allocated key events.
+    android::Vector<android::KeyEvent*> mAvailKeyEvents;
+    // Cache of previously allocated motion events.
+    android::Vector<android::MotionEvent*> mAvailMotionEvents;
+
+    // All input events that are actively being processed.
+    android::Vector<in_flight_event> mInFlightEvents;
+
+    // Key events that the app didn't handle, and are pending for