M7350v1_en_gpl

base/include/android_runtime/ActivityManager.h

@@ -0,0 +1,31 @@
+/*
+ * 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

base/include/android_runtime/AndroidRuntime.h

@@ -0,0 +1,127 @@
+/*
+ * 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

base/include/android_runtime/android_app_NativeActivity.h

@@ -0,0 +1,153 @@
+/*
+ * 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
+    // delivery to the activity's default key handling.
+    android::Vector<android::KeyEvent*> mUnhandledKeys;
+
+    // Keys that arrived in the Java framework and need to be
+    // dispatched to the app.
+    android::Vector<android::KeyEvent*> mDispatchingKeys;
+
+    // Key events that are pending to be pre-dispatched to the IME.
+    android::Vector<in_flight_event> mPreDispatchingKeys;
+
+    // Event sequence numbers that we have finished pre-dispatching.
+    android::Vector<finish_pre_dispatch> mFinishPreDispatches;
+};
+
+#endif // _ANDROID_APP_NATIVEACTIVITY_H

base/include/android_runtime/android_content_res_Configuration.h

@@ -0,0 +1,36 @@
+/*
+ * 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_CONTENT_RES_CONFIGURATION_H
+#define _ANDROID_CONTENT_RES_CONFIGURATION_H
+
+#include <utils/ResourceTypes.h>
+#include <android/configuration.h>
+
+#include "jni.h"
+
+struct AConfiguration : android::ResTable_config {
+};
+
+namespace android {
+
+extern void android_Configuration_getFromJava(
+        JNIEnv* env, jobject clazz, struct AConfiguration* out);
+
+} // namespace android
+
+
+#endif // _ANDROID_CONTENT_RES_CONFIGURATION_H

base/include/android_runtime/android_util_AssetManager.h

@@ -0,0 +1,30 @@
+/*
+ * 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 android_util_AssetManager_H
+#define android_util_AssetManager_H
+
+#include <utils/AssetManager.h>
+
+#include "jni.h"
+
+namespace android {
+
+extern AssetManager* assetManagerForJavaObject(JNIEnv* env, jobject assetMgr);
+
+}
+
+#endif

base/include/android_runtime/android_view_Surface.h

@@ -0,0 +1,31 @@
+/*
+ * 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_VIEW_SURFACE_H
+#define _ANDROID_VIEW_SURFACE_H
+
+#include <android/native_window.h>
+
+#include "jni.h"
+
+namespace android {
+
+extern sp<ANativeWindow> android_Surface_getNativeWindow(
+        JNIEnv* env, jobject clazz);
+
+} // namespace android
+
+#endif // _ANDROID_VIEW_SURFACE_H