diff options
Diffstat (limited to 'core/jni')
116 files changed, 38472 insertions, 0 deletions
diff --git a/core/jni/ActivityManager.cpp b/core/jni/ActivityManager.cpp new file mode 100644 index 0000000..9017827 --- /dev/null +++ b/core/jni/ActivityManager.cpp @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2006 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. + */ + +#include <unistd.h> +#include <android_runtime/ActivityManager.h> +#include <utils/IBinder.h> +#include <utils/IServiceManager.h> +#include <utils/Parcel.h> +#include <utils/String8.h> + +namespace android { + +const uint32_t OPEN_CONTENT_URI_TRANSACTION = IBinder::FIRST_CALL_TRANSACTION + 4; + +// Perform ContentProvider.openFile() on the given URI, returning +// the resulting native file descriptor. Returns < 0 on error. +int openContentProviderFile(const String16& uri) +{ + int fd = -1; + + sp<IServiceManager> sm = defaultServiceManager(); + sp<IBinder> am = sm->getService(String16("activity")); + if (am != NULL) { + Parcel data, reply; + data.writeInterfaceToken(String16("android.app.IActivityManager")); + data.writeString16(uri); + status_t ret = am->transact(OPEN_CONTENT_URI_TRANSACTION, data, &reply); + if (ret == NO_ERROR) { + int32_t exceptionCode = reply.readInt32(); + if (!exceptionCode) { + // Success is indicated here by a nonzero int followed by the fd; + // failure by a zero int with no data following. + if (reply.readInt32() != 0) { + fd = dup(reply.readFileDescriptor()); + } + } else { + // An exception was thrown back; fall through to return failure + LOGD("openContentUri(%s) caught exception %d\n", + String8(uri).string(), exceptionCode); + } + } + } + + return fd; +} + +} /* namespace android */ diff --git a/core/jni/Android.mk b/core/jni/Android.mk new file mode 100644 index 0000000..e9009e6 --- /dev/null +++ b/core/jni/Android.mk @@ -0,0 +1,176 @@ +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_CFLAGS += -DHAVE_CONFIG_H -DKHTML_NO_EXCEPTIONS -DGKWQ_NO_JAVA +LOCAL_CFLAGS += -DNO_SUPPORT_JS_BINDING -DQT_NO_WHEELEVENT -DKHTML_NO_XBL +LOCAL_CFLAGS += -U__APPLE__ + +ifeq ($(TARGET_ARCH), arm) + LOCAL_CFLAGS += -DPACKED="__attribute__ ((packed))" +else + LOCAL_CFLAGS += -DPACKED="" +endif + +LOCAL_SRC_FILES:= \ + ActivityManager.cpp \ + AndroidRuntime.cpp \ + CursorWindow.cpp \ + com_google_android_gles_jni_EGLImpl.cpp \ + com_google_android_gles_jni_GLImpl.cpp.arm \ + android_database_CursorWindow.cpp \ + android_database_SQLiteDebug.cpp \ + android_database_SQLiteDatabase.cpp \ + android_database_SQLiteProgram.cpp \ + android_database_SQLiteQuery.cpp \ + android_database_SQLiteStatement.cpp \ + android_view_Display.cpp \ + android_view_Surface.cpp \ + android_view_ViewRoot.cpp \ + android_text_AndroidCharacter.cpp \ + android_text_KeyCharacterMap.cpp \ + android_os_Debug.cpp \ + android_os_Exec.cpp \ + android_os_FileUtils.cpp \ + android_os_MemoryFile.cpp \ + android_os_ParcelFileDescriptor.cpp \ + android_os_Power.cpp \ + android_os_StatFs.cpp \ + android_os_SystemClock.cpp \ + android_os_SystemProperties.cpp \ + android_os_UEventObserver.cpp \ + android_os_NetStat.cpp \ + android_os_Hardware.cpp \ + android_net_LocalSocketImpl.cpp \ + android_net_NetUtils.cpp \ + android_net_wifi_Wifi.cpp \ + android_nio_utils.cpp \ + android_pim_EventRecurrence.cpp \ + android_pim_Time.cpp \ + android_security_Md5MessageDigest.cpp \ + android_util_AssetManager.cpp \ + android_util_Binder.cpp \ + android_util_EventLog.cpp \ + android_util_Log.cpp \ + android_util_FloatMath.cpp \ + android_util_Process.cpp \ + android_util_StringBlock.cpp \ + android_util_XmlBlock.cpp \ + android_util_Base64.cpp \ + android/graphics/Bitmap.cpp \ + android/graphics/BitmapFactory.cpp \ + android/graphics/Camera.cpp \ + android/graphics/Canvas.cpp \ + android/graphics/ColorFilter.cpp \ + android/graphics/DrawFilter.cpp \ + android/graphics/CreateJavaOutputStreamAdaptor.cpp \ + android/graphics/Graphics.cpp \ + android/graphics/Interpolator.cpp \ + android/graphics/LayerRasterizer.cpp \ + android/graphics/MaskFilter.cpp \ + android/graphics/Matrix.cpp \ + android/graphics/Movie.cpp \ + android/graphics/NIOBuffer.cpp \ + android/graphics/NinePatch.cpp \ + android/graphics/NinePatchImpl.cpp \ + android/graphics/Paint.cpp \ + android/graphics/Path.cpp \ + android/graphics/PathMeasure.cpp \ + android/graphics/PathEffect.cpp \ + android_graphics_PixelFormat.cpp \ + android/graphics/Picture.cpp \ + android/graphics/PorterDuff.cpp \ + android/graphics/Rasterizer.cpp \ + android/graphics/Region.cpp \ + android/graphics/Shader.cpp \ + android/graphics/Typeface.cpp \ + android/graphics/Xfermode.cpp \ + android_media_AudioSystem.cpp \ + android_media_ToneGenerator.cpp \ + android_hardware_Camera.cpp \ + android_hardware_SensorManager.cpp \ + android_debug_JNITest.cpp \ + android_util_FileObserver.cpp \ + android/opengl/poly_clip.cpp.arm \ + android/opengl/util.cpp.arm \ + android_bluetooth_Database.cpp \ + android_bluetooth_HeadsetBase.cpp \ + android_bluetooth_common.cpp \ + android_bluetooth_BluetoothAudioGateway.cpp \ + android_bluetooth_RfcommSocket.cpp \ + android_bluetooth_ScoSocket.cpp \ + android_server_BluetoothDeviceService.cpp \ + android_server_BluetoothEventLoop.cpp \ + android_message_digest_sha1.cpp \ + android_ddm_DdmHandleNativeHeap.cpp \ + android_location_GpsLocationProvider.cpp \ + com_android_internal_os_ZygoteInit.cpp \ + com_android_internal_graphics_NativeUtils.cpp + +LOCAL_C_INCLUDES += \ + $(JNI_H_INCLUDE) \ + $(LOCAL_PATH)/android/graphics \ + $(call include-path-for, corecg graphics) \ + $(call include-path-for, libhardware)/hardware \ + $(LOCAL_PATH)/../../include/ui \ + $(LOCAL_PATH)/../../include/utils \ + external/sqlite/dist \ + external/sqlite/android \ + external/expat/lib \ + external/openssl/include \ + external/tremor/Tremor \ + external/icu4c/i18n \ + external/icu4c/common \ + +LOCAL_SHARED_LIBRARIES := \ + libexpat \ + libnativehelper \ + libcutils \ + libutils \ + libnetutils \ + libui \ + libsgl \ + libcorecg \ + libsqlite \ + libdvm \ + libGLES_CM \ + libhardware \ + libsonivox \ + libcrypto \ + libssl \ + libicuuc \ + libicui18n \ + libicudata \ + libmedia \ + libwpa_client + +ifeq ($(BOARD_HAVE_BLUETOOTH),true) +LOCAL_C_INCLUDES += \ + external/dbus \ + external/bluez/libs/include +LOCAL_CFLAGS += -DHAVE_BLUETOOTH +LOCAL_SHARED_LIBRARIES += libbluedroid libdbus +endif + +ifeq ($(TARGET_ARCH),arm) +LOCAL_SHARED_LIBRARIES += \ + libdl +endif + +LOCAL_LDLIBS += -lpthread -ldl + +ifeq ($(TARGET_OS),linux) +ifeq ($(TARGET_ARCH),x86) +LOCAL_LDLIBS += -lrt +endif +endif + +ifeq ($(WITH_MALLOC_LEAK_CHECK),true) + LOCAL_CFLAGS += -DMALLOC_LEAK_CHECK +endif + +LOCAL_MODULE:= libandroid_runtime + +include $(BUILD_SHARED_LIBRARY) + + +include $(call all-makefiles-under,$(LOCAL_PATH)) diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp new file mode 100644 index 0000000..2a1184f --- /dev/null +++ b/core/jni/AndroidRuntime.cpp @@ -0,0 +1,1151 @@ +/* //device/libs/android_runtime/AndroidRuntime.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "AndroidRuntime" +//#define LOG_NDEBUG 0 + +#include <android_runtime/AndroidRuntime.h> +#include <utils/IBinder.h> +#include <utils/IServiceManager.h> +#include <utils/Log.h> +#include <utils/misc.h> +#include <utils/Parcel.h> +#include <utils/string_array.h> +#include <utils/threads.h> +#include <cutils/properties.h> + +#include <SkGraphics.h> +#include <SkImageDecoder.h> + +#include "jni.h" +#include "JNIHelp.h" +#include "android_util_Binder.h" + +#include <stdio.h> +#include <signal.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <signal.h> +#include <dirent.h> +#include <assert.h> + + +using namespace android; + +extern void register_BindTest(); + +extern int register_android_os_Binder(JNIEnv* env); +extern int register_android_os_Process(JNIEnv* env); +extern int register_android_graphics_Bitmap(JNIEnv*); +extern int register_android_graphics_BitmapFactory(JNIEnv*); +extern int register_android_graphics_Camera(JNIEnv* env); +extern int register_android_graphics_Graphics(JNIEnv* env); +extern int register_android_graphics_Interpolator(JNIEnv* env); +extern int register_android_graphics_LayerRasterizer(JNIEnv*); +extern int register_android_graphics_MaskFilter(JNIEnv* env); +extern int register_android_graphics_Movie(JNIEnv* env); +extern int register_android_graphics_NinePatch(JNIEnv*); +extern int register_android_graphics_PathEffect(JNIEnv* env); +extern int register_android_graphics_Region(JNIEnv* env); +extern int register_android_graphics_Shader(JNIEnv* env); +extern int register_android_graphics_Typeface(JNIEnv* env); + +extern int register_com_google_android_gles_jni_EGLImpl(JNIEnv* env); +extern int register_com_google_android_gles_jni_GLImpl(JNIEnv* env); + +extern int register_android_hardware_Camera(JNIEnv *env); + +extern int register_android_hardware_SensorManager(JNIEnv *env); + +extern int register_android_media_AudioSystem(JNIEnv *env); +extern int register_android_media_ToneGenerator(JNIEnv *env); + +extern int register_android_message_digest_sha1(JNIEnv *env); + +extern int register_android_util_FloatMath(JNIEnv* env); + +namespace android { + +/* + * JNI-based registration functions. Note these are properly contained in + * namespace android. + */ +extern int register_android_content_AssetManager(JNIEnv* env); +extern int register_android_util_EventLog(JNIEnv* env); +extern int register_android_util_Log(JNIEnv* env); +extern int register_android_content_StringBlock(JNIEnv* env); +extern int register_android_content_XmlBlock(JNIEnv* env); +extern int register_android_graphics_Canvas(JNIEnv* env); +extern int register_android_graphics_ColorFilter(JNIEnv* env); +extern int register_android_graphics_DrawFilter(JNIEnv* env); +extern int register_android_graphics_Matrix(JNIEnv* env); +extern int register_android_graphics_Paint(JNIEnv* env); +extern int register_android_graphics_Path(JNIEnv* env); +extern int register_android_graphics_PathMeasure(JNIEnv* env); +extern int register_android_graphics_Picture(JNIEnv*); +extern int register_android_graphics_PorterDuff(JNIEnv* env); +extern int register_android_graphics_Rasterizer(JNIEnv* env); +extern int register_android_graphics_Xfermode(JNIEnv* env); +extern int register_android_graphics_PixelFormat(JNIEnv* env); +extern int register_com_android_internal_graphics_NativeUtils(JNIEnv *env); +extern int register_android_view_Display(JNIEnv* env); +extern int register_android_view_Surface(JNIEnv* env); +extern int register_android_view_ViewRoot(JNIEnv* env); +extern int register_android_database_CursorWindow(JNIEnv* env); +extern int register_android_database_SQLiteDatabase(JNIEnv* env); +extern int register_android_database_SQLiteDebug(JNIEnv* env); +extern int register_android_database_SQLiteProgram(JNIEnv* env); +extern int register_android_database_SQLiteQuery(JNIEnv* env); +extern int register_android_database_SQLiteStatement(JNIEnv* env); +extern int register_android_debug_JNITest(JNIEnv* env); +extern int register_android_nio_utils(JNIEnv* env); +extern int register_android_pim_EventRecurrence(JNIEnv* env); +extern int register_android_pim_Time(JNIEnv* env); +extern int register_android_os_Debug(JNIEnv* env); +extern int register_android_os_ParcelFileDescriptor(JNIEnv *env); +extern int register_android_os_Power(JNIEnv *env); +extern int register_android_os_StatFs(JNIEnv *env); +extern int register_android_os_SystemProperties(JNIEnv *env); +extern int register_android_os_Hardware(JNIEnv* env); +extern int register_android_os_Exec(JNIEnv *env); +extern int register_android_os_SystemClock(JNIEnv* env); +extern int register_android_os_FileObserver(JNIEnv *env); +extern int register_android_os_FileUtils(JNIEnv *env); +extern int register_android_os_UEventObserver(JNIEnv* env); +extern int register_android_os_NetStat(JNIEnv* env); +extern int register_android_os_MemoryFile(JNIEnv* env); +extern int register_android_net_LocalSocketImpl(JNIEnv* env); +extern int register_android_net_NetworkUtils(JNIEnv* env); +extern int register_android_net_wifi_WifiManager(JNIEnv* env); +extern int register_android_security_Md5MessageDigest(JNIEnv *env); +extern int register_android_text_AndroidCharacter(JNIEnv *env); +extern int register_android_text_KeyCharacterMap(JNIEnv *env); +extern int register_android_opengl_classes(JNIEnv *env); +extern int register_android_bluetooth_Database(JNIEnv* env); +extern int register_android_bluetooth_HeadsetBase(JNIEnv* env); +extern int register_android_bluetooth_BluetoothAudioGateway(JNIEnv* env); +extern int register_android_bluetooth_RfcommSocket(JNIEnv *env); +extern int register_android_bluetooth_ScoSocket(JNIEnv *env); +extern int register_android_server_BluetoothDeviceService(JNIEnv* env); +extern int register_android_server_BluetoothEventLoop(JNIEnv *env); +extern int register_android_ddm_DdmHandleNativeHeap(JNIEnv *env); +extern int register_com_android_internal_os_ZygoteInit(JNIEnv* env); +extern int register_android_util_Base64(JNIEnv* env); +extern int register_android_location_GpsLocationProvider(JNIEnv* env); + +static AndroidRuntime* gCurRuntime = NULL; + +static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL) +{ + if (jniThrowException(env, exc, msg) != 0) + assert(false); +} + +/* + * Code written in the Java Programming Language calls here from main(). + */ +static void com_android_internal_os_RuntimeInit_finishInit(JNIEnv* env, jobject clazz) +{ + gCurRuntime->onStarted(); +} + +static void com_android_internal_os_RuntimeInit_zygoteInit(JNIEnv* env, jobject clazz) +{ + gCurRuntime->onZygoteInit(); +} + +static jint com_android_internal_os_RuntimeInit_isComputerOn(JNIEnv* env, jobject clazz) +{ + return 1; +} + +static void com_android_internal_os_RuntimeInit_turnComputerOn(JNIEnv* env, jobject clazz) +{ +} + +static jint com_android_internal_os_RuntimeInit_getQwertyKeyboard(JNIEnv* env, jobject clazz) +{ + char* value = getenv("qwerty"); + if (value != NULL && strcmp(value, "true") == 0) { + return 1; + } + + return 0; +} + +/* + * JNI registration. + */ +static JNINativeMethod gMethods[] = { + { "finishInit", "()V", + (void*) com_android_internal_os_RuntimeInit_finishInit }, + { "zygoteInitNative", "()V", + (void*) com_android_internal_os_RuntimeInit_zygoteInit }, + { "isComputerOn", "()I", + (void*) com_android_internal_os_RuntimeInit_isComputerOn }, + { "turnComputerOn", "()V", + (void*) com_android_internal_os_RuntimeInit_turnComputerOn }, + { "getQwertyKeyboard", "()I", + (void*) com_android_internal_os_RuntimeInit_getQwertyKeyboard }, +}; + +int register_com_android_internal_os_RuntimeInit(JNIEnv* env) +{ + return jniRegisterNativeMethods(env, "com/android/internal/os/RuntimeInit", + gMethods, NELEM(gMethods)); +} + +// ---------------------------------------------------------------------- + +/*static*/ JavaVM* AndroidRuntime::mJavaVM = NULL; + + +AndroidRuntime::AndroidRuntime() +{ + SkGraphics::Init(false); // true means run unittests (slow) + // this sets our preference for 16bit images during decode + // in case the src is opaque and 24bit + SkImageDecoder::SetDeviceConfig(SkBitmap::kRGB_565_Config); + + // Pre-allocate enough space to hold a fair number of options. + mOptions.setCapacity(20); + + assert(gCurRuntime == NULL); // one per process + gCurRuntime = this; +} + +AndroidRuntime::~AndroidRuntime() +{ + SkGraphics::Term(); +} + +/* + * Register native methods using JNI. + */ +/*static*/ int AndroidRuntime::registerNativeMethods(JNIEnv* env, + const char* className, const JNINativeMethod* gMethods, int numMethods) +{ + return jniRegisterNativeMethods(env, className, gMethods, numMethods); +} + +/* + * Call a static Java Programming Language function that takes no arguments and returns void. + */ +status_t AndroidRuntime::callStatic(const char* className, const char* methodName) +{ + JNIEnv* env; + jclass clazz; + jmethodID methodId; + + env = getJNIEnv(); + if (env == NULL) + return UNKNOWN_ERROR; + + clazz = findClass(env, className); + if (clazz == NULL) { + LOGE("ERROR: could not find class '%s'\n", className); + return UNKNOWN_ERROR; + } + methodId = env->GetStaticMethodID(clazz, methodName, "()V"); + if (methodId == NULL) { + LOGE("ERROR: could not find method %s.%s\n", className, methodName); + return UNKNOWN_ERROR; + } + + env->CallStaticVoidMethod(clazz, methodId); + + return NO_ERROR; +} + +status_t AndroidRuntime::callMain( + const char* className, int argc, const char* const argv[]) +{ + JNIEnv* env; + jclass clazz; + jmethodID methodId; + + env = getJNIEnv(); + if (env == NULL) + return UNKNOWN_ERROR; + + clazz = findClass(env, className); + if (clazz == NULL) { + LOGE("ERROR: could not find class '%s'\n", className); + return UNKNOWN_ERROR; + } + + methodId = env->GetStaticMethodID(clazz, "main", "([Ljava/lang/String;)V"); + if (methodId == NULL) { + LOGE("ERROR: could not find method %s.main(String[])\n", className); + return UNKNOWN_ERROR; + } + + /* + * We want to call main() with a String array with our arguments in it. + * Create an array and populate it. + */ + jclass stringClass; + jobjectArray strArray; + + stringClass = env->FindClass("java/lang/String"); + strArray = env->NewObjectArray(argc, stringClass, NULL); + + for (int i = 0; i < argc; i++) { + jstring argStr = env->NewStringUTF(argv[i]); + env->SetObjectArrayElement(strArray, i, argStr); + } + + env->CallStaticVoidMethod(clazz, methodId, strArray); + return NO_ERROR; +} + +/* + * Find the named class. + */ +jclass AndroidRuntime::findClass(JNIEnv* env, const char* className) +{ + char* convName = NULL; + + if (env->ExceptionCheck()) { + LOGE("ERROR: exception pending on entry to findClass()\n"); + return NULL; + } + + /* + * JNI FindClass uses class names with slashes, but ClassLoader.loadClass + * uses the dotted "binary name" format. We don't need to convert the + * name with the new approach. + */ +#if 0 + /* (convName only created if necessary -- use className) */ + for (char* cp = const_cast<char*>(className); *cp != '\0'; cp++) { + if (*cp == '.') { + if (convName == NULL) { + convName = strdup(className); + cp = convName + (cp-className); + className = convName; + } + *cp = '/'; + } + } +#endif + + /* + * This is a little awkward because the JNI FindClass call uses the + * class loader associated with the native method we're executing in. + * Because this native method is part of a "boot" class, JNI doesn't + * look for the class in CLASSPATH, which unfortunately is a likely + * location for it. (Had we issued the FindClass call before calling + * into the VM -- at which point there isn't a native method frame on + * the stack -- the VM would have checked CLASSPATH. We have to do + * this because we call into Java Programming Language code and + * bounce back out.) + * + * JNI lacks a "find class in a specific class loader" operation, so we + * have to do things the hard way. + */ + jclass cls = NULL; + //cls = env->FindClass(className); + + jclass javaLangClassLoader; + jmethodID getSystemClassLoader, loadClass; + jobject systemClassLoader; + jstring strClassName; + + /* find the "system" class loader; none of this is expected to fail */ + javaLangClassLoader = env->FindClass("java/lang/ClassLoader"); + assert(javaLangClassLoader != NULL); + getSystemClassLoader = env->GetStaticMethodID(javaLangClassLoader, + "getSystemClassLoader", "()Ljava/lang/ClassLoader;"); + loadClass = env->GetMethodID(javaLangClassLoader, + "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;"); + assert(getSystemClassLoader != NULL && loadClass != NULL); + systemClassLoader = env->CallStaticObjectMethod(javaLangClassLoader, + getSystemClassLoader); + assert(systemClassLoader != NULL); + + /* create an object for the class name string; alloc could fail */ + strClassName = env->NewStringUTF(className); + if (env->ExceptionCheck()) { + LOGE("ERROR: unable to convert '%s' to string\n", className); + goto bail; + } + LOGV("system class loader is %p, loading %p (%s)\n", + systemClassLoader, strClassName, className); + + /* try to find the named class */ + cls = (jclass) env->CallObjectMethod(systemClassLoader, loadClass, + strClassName); + if (env->ExceptionCheck()) { + LOGE("ERROR: unable to load class '%s' from %p\n", + className, systemClassLoader); + cls = NULL; + goto bail; + } + +bail: + free(convName); + return cls; +} + +/* + * The VM calls this through the "exit" hook. + */ +static void runtime_exit(int code) +{ + gCurRuntime->onExit(code); + exit(code); +} + +/* + * The VM calls this through the "vfprintf" hook. + * + * We ignore "fp" and just write the results to the log file. + */ +static void runtime_vfprintf(FILE* fp, const char* format, va_list ap) +{ + LOG_PRI_VA(ANDROID_LOG_INFO, "vm-printf", format, ap); +} + + +/** + * Add VM arguments to the to-be-executed VM + * Stops at first non '-' argument (also stops at an argument of '--') + * Returns the number of args consumed + */ +int AndroidRuntime::addVmArguments(int argc, const char* const argv[]) +{ + int i; + + for (i = 0; i<argc; i++) { + if (argv[i][0] != '-') { + return i; + } + if (argv[i][1] == '-' && argv[i][2] == 0) { + return i+1; + } + + JavaVMOption opt; + memset(&opt, 0, sizeof(opt)); + opt.optionString = (char*)argv[i]; + mOptions.add(opt); + } + return i; +} + +static int hasDir(const char* dir) +{ + struct stat s; + int res = stat(dir, &s); + if (res == 0) { + return S_ISDIR(s.st_mode); + } + return 0; +} + +/* + * We just want failed write() calls to just return with an error. + */ +static void blockSigpipe() +{ + sigset_t mask; + + sigemptyset(&mask); + sigaddset(&mask, SIGPIPE); + if (sigprocmask(SIG_BLOCK, &mask, NULL) != 0) + LOGW("WARNING: SIGPIPE not blocked\n"); +} + +/* + * Read the persistent locale from file. + */ +static void readLocale(char* language, char* region) +{ + char path[512]; + char propLang[PROPERTY_VALUE_MAX], propRegn[PROPERTY_VALUE_MAX]; + char *dataDir = getenv("ANDROID_DATA"); + bool found = false; + if (dataDir && strlen(dataDir) < 500) { + strcpy(path, dataDir); + } else { + strcpy(path, "/data"); + } + strcat(path, "/locale"); + + FILE* localeFile = fopen(path, "r"); + if (localeFile) { + char line[10]; + char *got = fgets(line, 10, localeFile); + /* Locale code is ll_rr */ + if (got != NULL && strlen(line) >= 5) { + strncat(language, line, 2); + strncat(region, line + 3, 2); + found = true; + } + fclose(localeFile); + } + + if (!found) { + /* Set to ro properties, default is en_US */ + property_get("ro.product.locale.language", propLang, "en"); + property_get("ro.product.locale.region", propRegn, "US"); + strncat(language, propLang, 2); + strncat(region, propRegn, 2); + } + + //LOGD("language=%s region=%s\n", language, region); +} + +void AndroidRuntime::start(const char* className, const bool startSystemServer) +{ + LOGD("\n>>>>>>>>>>>>>> AndroidRuntime START <<<<<<<<<<<<<<\n"); + + JNIEnv* env; + JavaVMInitArgs initArgs; + JavaVMOption opt; + char propBuf[PROPERTY_VALUE_MAX]; + char enableAssertBuf[4 + PROPERTY_VALUE_MAX]; + char stackTraceFileBuf[PROPERTY_VALUE_MAX]; + char* stackTraceFile = NULL; + char* slashClassName = NULL; + char* cp; + bool checkJni = false; + bool logStdio = false; + bool verifyJava = true; + enum { kEMDefault, kEMIntPortable, kEMIntFast } executionMode = kEMDefault; + + blockSigpipe(); + + /* + * 'startSystemServer == true' means runtime is obslete and not run from + * init.rc anymore, so we print out the boot start event here. + */ + if (startSystemServer) { + /* track our progress through the boot sequence */ + const int LOG_BOOT_PROGRESS_START = 3000; + LOG_EVENT_LONG(LOG_BOOT_PROGRESS_START, + ns2ms(systemTime(SYSTEM_TIME_MONOTONIC))); + } + + property_get("dalvik.vm.checkjni", propBuf, ""); + if (strcmp(propBuf, "true") == 0) { + checkJni = true; + } else if (strcmp(propBuf, "false") != 0) { + /* property is neither true nor false; fall back on kernel parameter */ + property_get("ro.kernel.android.checkjni", propBuf, ""); + if (propBuf[0] == '1') { + checkJni = true; + } + } + + property_get("dalvik.vm.verify-bytecode", propBuf, ""); + if (strcmp(propBuf, "true") == 0) { + verifyJava = true; + } else if (strcmp(propBuf, "false") == 0) { + verifyJava = false; + } else { + /* bad value or not defined; use default */ + } + + property_get("dalvik.vm.execution-mode", propBuf, ""); + if (strcmp(propBuf, "int:portable") == 0) { + executionMode = kEMIntPortable; + } else if (strcmp(propBuf, "int:fast") == 0) { + executionMode = kEMIntFast; + } + + property_get("dalvik.vm.stack-trace-file", stackTraceFileBuf, ""); + + property_get("log.redirect-stdio", propBuf, ""); + if (strcmp(propBuf, "true") == 0) { + logStdio = true; + } + + strcpy(enableAssertBuf, "-ea:"); + property_get("dalvik.vm.enableassertions", enableAssertBuf+4, ""); + + const char* rootDir = getenv("ANDROID_ROOT"); + if (rootDir == NULL) { + rootDir = "/system"; + if (!hasDir("/system")) { + LOG_FATAL("No root directory specified, and /android does not exist."); + return; + } + setenv("ANDROID_ROOT", rootDir, 1); + } + + const char* kernelHack = getenv("LD_ASSUME_KERNEL"); + //LOGD("Found LD_ASSUME_KERNEL='%s'\n", kernelHack); + + /* route exit() to our handler */ + opt.extraInfo = (void*) runtime_exit; + opt.optionString = "exit"; + mOptions.add(opt); + + /* route fprintf() to our handler */ + opt.extraInfo = (void*) runtime_vfprintf; + opt.optionString = "vfprintf"; + mOptions.add(opt); + + opt.extraInfo = NULL; + + /* enable verbose; standard options are { jni, gc, class } */ + //options[curOpt++].optionString = "-verbose:jni"; + opt.optionString = "-verbose:gc"; + mOptions.add(opt); + //options[curOpt++].optionString = "-verbose:class"; + + /* limit memory use to 16MB */ + opt.optionString = "-Xmx16m"; + mOptions.add(opt); + + /* enable Java "assert" statements in all non-system code */ + //options[curOpt++].optionString = "-ea"; + + /* + * Enable or disable bytecode verification. We currently force optimization + * to be enabled when the verifier is off; this is a bad idea, but + * useful while we fiddle with the verifier. + * + * This should be coordinated with: + * //device/dalvik/libcore/android/src/main/native/dalvik_system_TouchDex.cpp + */ + if (verifyJava) { + opt.optionString = "-Xverify:all"; + mOptions.add(opt); + opt.optionString = "-Xdexopt:verified"; + mOptions.add(opt); + } else { + opt.optionString = "-Xverify:none"; + mOptions.add(opt); + //opt.optionString = "-Xdexopt:all"; + opt.optionString = "-Xdexopt:verified"; + mOptions.add(opt); + } + + /* enable debugging; set suspend=y to pause during VM init */ +#ifdef HAVE_ANDROID_OS + /* use android ADB transport */ + opt.optionString = + "-agentlib:jdwp=transport=dt_android_adb,suspend=n,server=y"; +#else + /* use TCP socket; address=0 means start at port 8000 and probe up */ + LOGI("Using TCP socket for JDWP\n"); + opt.optionString = + "-agentlib:jdwp=transport=dt_socket,suspend=n,server=y,address=0"; +#endif + mOptions.add(opt); + + char enableDPBuf[sizeof("-Xdeadlockpredict:") + PROPERTY_VALUE_MAX]; + property_get("dalvik.vm.deadlock-predict", propBuf, ""); + if (strlen(propBuf) > 0) { + strcpy(enableDPBuf, "-Xdeadlockpredict:"); + strcat(enableDPBuf, propBuf); + opt.optionString = enableDPBuf; + mOptions.add(opt); + } + + LOGD("CheckJNI is %s\n", checkJni ? "ON" : "OFF"); + if (checkJni) { + /* extended JNI checking */ + opt.optionString = "-Xcheck:jni"; + mOptions.add(opt); + + /* set a cap on JNI global references */ + opt.optionString = "-Xjnigreflimit:2000"; + mOptions.add(opt); + + /* with -Xcheck:jni, this provides a JNI function call trace */ + //opt.optionString = "-verbose:jni"; + //mOptions.add(opt); + } + if (executionMode == kEMIntPortable) { + opt.optionString = "-Xint:portable"; + mOptions.add(opt); + } else if (executionMode == kEMIntFast) { + opt.optionString = "-Xint:fast"; + mOptions.add(opt); + } + if (logStdio) { + /* convert stdout/stderr to log messages */ + opt.optionString = "-Xlog-stdio"; + mOptions.add(opt); + } + + if (enableAssertBuf[4] != '\0') { + /* accept "all" to mean "all classes and packages" */ + if (strcmp(enableAssertBuf+4, "all") == 0) + enableAssertBuf[3] = '\0'; + LOGI("Assertions enabled: '%s'\n", enableAssertBuf); + opt.optionString = enableAssertBuf; + mOptions.add(opt); + } else { + LOGV("Assertions disabled\n"); + } + + if (stackTraceFileBuf[0] != '\0') { + static const char* stfOptName = "-Xstacktracefile:"; + + stackTraceFile = (char*) malloc(strlen(stfOptName) + + strlen(stackTraceFileBuf) +1); + strcpy(stackTraceFile, stfOptName); + strcat(stackTraceFile, stackTraceFileBuf); + opt.optionString = stackTraceFile; + mOptions.add(opt); + } + + /* Set the properties for locale */ + { + char langOption[sizeof("-Duser.language=") + 3]; + char regionOption[sizeof("-Duser.region=") + 3]; + strcpy(langOption, "-Duser.language="); + strcpy(regionOption, "-Duser.region="); + readLocale(langOption, regionOption); + opt.extraInfo = NULL; + opt.optionString = langOption; + mOptions.add(opt); + opt.optionString = regionOption; + mOptions.add(opt); + } + + /* + * We don't have /tmp on the device, but we often have an SD card. Apps + * shouldn't use this, but some test suites might want to exercise it. + */ + opt.optionString = "-Djava.io.tmpdir=/sdcard"; + mOptions.add(opt); + + initArgs.version = JNI_VERSION_1_4; + initArgs.options = mOptions.editArray(); + initArgs.nOptions = mOptions.size(); + initArgs.ignoreUnrecognized = JNI_FALSE; + + /* + * Initialize the VM. + * + * The JavaVM* is essentially per-process, and the JNIEnv* is per-thread. + * If this call succeeds, the VM is ready, and we can start issuing + * JNI calls. + */ + if (JNI_CreateJavaVM(&mJavaVM, &env, &initArgs) < 0) { + LOGE("JNI_CreateJavaVM failed\n"); + goto bail; + } + + /* + * Register android functions. + */ + if (startReg(env) < 0) { + LOGE("Unable to register all android natives\n"); + goto bail; + } + + /* + * We want to call main() with a String array with arguments in it. + * At present we only have one argument, the class name. Create an + * array to hold it. + */ + jclass stringClass; + jobjectArray strArray; + jstring classNameStr; + jstring startSystemServerStr; + + stringClass = env->FindClass("java/lang/String"); + assert(stringClass != NULL); + strArray = env->NewObjectArray(2, stringClass, NULL); + assert(strArray != NULL); + classNameStr = env->NewStringUTF(className); + assert(classNameStr != NULL); + env->SetObjectArrayElement(strArray, 0, classNameStr); + startSystemServerStr = env->NewStringUTF(startSystemServer ? + "true" : "false"); + env->SetObjectArrayElement(strArray, 1, startSystemServerStr); + + /* + * Start VM. This thread becomes the main thread of the VM, and will + * not return until the VM exits. + */ + jclass startClass; + jmethodID startMeth; + + slashClassName = strdup(className); + for (cp = slashClassName; *cp != '\0'; cp++) + if (*cp == '.') + *cp = '/'; + + startClass = env->FindClass(slashClassName); + if (startClass == NULL) { + LOGE("JavaVM unable to locate class '%s'\n", slashClassName); + /* keep going */ + } else { + startMeth = env->GetStaticMethodID(startClass, "main", + "([Ljava/lang/String;)V"); + if (startMeth == NULL) { + LOGE("JavaVM unable to find main() in '%s'\n", className); + /* keep going */ + } else { + env->CallStaticVoidMethod(startClass, startMeth, strArray); + +#if 0 + if (env->ExceptionCheck()) + threadExitUncaughtException(env); +#endif + } + } + + LOGD("Shutting down VM\n"); + if (mJavaVM->DetachCurrentThread() != JNI_OK) + LOGW("Warning: unable to detach main thread\n"); + if (mJavaVM->DestroyJavaVM() != 0) + LOGW("Warning: VM did not shut down cleanly\n"); + +bail: + free(slashClassName); + free(stackTraceFile); +} + +void AndroidRuntime::start() +{ + start("com.android.internal.os.RuntimeInit", + false /* Don't start the system server */); +} + +void AndroidRuntime::onExit(int code) +{ + LOGI("AndroidRuntime onExit calling exit(%d)", code); + exit(code); +} + +/* + * Get the JNIEnv pointer for this thread. + * + * Returns NULL if the slot wasn't allocated or populated. + */ +/*static*/ JNIEnv* AndroidRuntime::getJNIEnv() +{ + JNIEnv* env; + JavaVM* vm = AndroidRuntime::getJavaVM(); + assert(vm != NULL); + + if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) + return NULL; + return env; +} + +/* + * Makes the current thread visible to the VM. + * + * The JNIEnv pointer returned is only valid for the current thread, and + * thus must be tucked into thread-local storage. + */ +static int javaAttachThread(const char* threadName, JNIEnv** pEnv) +{ + JavaVMAttachArgs args; + JavaVM* vm; + jint result; + + vm = AndroidRuntime::getJavaVM(); + assert(vm != NULL); + + args.version = JNI_VERSION_1_4; + args.name = (char*) threadName; + args.group = NULL; + + result = vm->AttachCurrentThread(pEnv, (void*) &args); + if (result != JNI_OK) + LOGE("ERROR: thread attach failed\n"); + + return result; +} + +/* + * Detach the current thread from the set visible to the VM. + */ +static int javaDetachThread(void) +{ + JavaVM* vm; + jint result; + + vm = AndroidRuntime::getJavaVM(); + assert(vm != NULL); + + result = vm->DetachCurrentThread(); + if (result != JNI_OK) + LOGE("ERROR: thread detach failed\n"); + return result; +} + +/* + * When starting a native thread that will be visible from the VM, we + * bounce through this to get the right attach/detach action. + * Note that this function calls free(args) + */ +/*static*/ int AndroidRuntime::javaThreadShell(void* args) { + void* start = ((void**)args)[0]; + void* userData = ((void **)args)[1]; + char* name = (char*) ((void **)args)[2]; // we own this storage + free(args); + JNIEnv* env; + int result; + + /* hook us into the VM */ + if (javaAttachThread(name, &env) != JNI_OK) + return -1; + + /* start the thread running */ + result = (*(android_thread_func_t)start)(userData); + + /* unhook us */ + javaDetachThread(); + free(name); + + return result; +} + +/* + * This is invoked from androidCreateThreadEtc() via the callback + * set with androidSetCreateThreadFunc(). + * + * We need to create the new thread in such a way that it gets hooked + * into the VM before it really starts executing. + */ +/*static*/ int AndroidRuntime::javaCreateThreadEtc( + android_thread_func_t entryFunction, + void* userData, + const char* threadName, + int32_t threadPriority, + size_t threadStackSize, + android_thread_id_t* threadId) +{ + void** args = (void**) malloc(3 * sizeof(void*)); // javaThreadShell must free + int result; + + assert(threadName != NULL); + + args[0] = (void*) entryFunction; + args[1] = userData; + args[2] = (void*) strdup(threadName); // javaThreadShell must free + + result = androidCreateRawThreadEtc(AndroidRuntime::javaThreadShell, args, + threadName, threadPriority, threadStackSize, threadId); + return result; +} + +/* + * Create a thread that is visible from the VM. + * + * This is called from elsewhere in the library. + */ +/*static*/ void AndroidRuntime::createJavaThread(const char* name, + void (*start)(void *), void* arg) +{ + javaCreateThreadEtc((android_thread_func_t) start, arg, name, + ANDROID_PRIORITY_DEFAULT, 0, NULL); +} + +#if 0 +static void quickTest(void* arg) +{ + const char* str = (const char*) arg; + + printf("In quickTest: %s\n", str); +} +#endif + +#ifdef NDEBUG + #define REG_JNI(name) { name } + struct RegJNIRec { + int (*mProc)(JNIEnv*); + }; +#else + #define REG_JNI(name) { name, #name } + struct RegJNIRec { + int (*mProc)(JNIEnv*); + const char* mName; + }; +#endif + +typedef void (*RegJAMProc)(); + +static int register_jni_procs(const RegJNIRec array[], size_t count, JNIEnv* env) +{ + for (size_t i = 0; i < count; i++) { + if (array[i].mProc(env) < 0) { +#ifndef NDEBUG + LOGD("----------!!! %s failed to load\n", array[i].mName); +#endif + return -1; + } + } + return 0; +} + +static void register_jam_procs(const RegJAMProc array[], size_t count) +{ + for (size_t i = 0; i < count; i++) { + array[i](); + } +} + +static const RegJNIRec gRegJNI[] = { + REG_JNI(register_android_debug_JNITest), + REG_JNI(register_com_android_internal_os_RuntimeInit), + REG_JNI(register_android_os_SystemClock), + REG_JNI(register_android_util_EventLog), + REG_JNI(register_android_util_Log), + REG_JNI(register_android_util_FloatMath), + REG_JNI(register_android_pim_Time), + REG_JNI(register_android_pim_EventRecurrence), + REG_JNI(register_android_content_AssetManager), + REG_JNI(register_android_content_StringBlock), + REG_JNI(register_android_content_XmlBlock), + REG_JNI(register_android_security_Md5MessageDigest), + REG_JNI(register_android_text_AndroidCharacter), + REG_JNI(register_android_text_KeyCharacterMap), + REG_JNI(register_android_os_Process), + REG_JNI(register_android_os_Binder), + REG_JNI(register_android_os_Hardware), + REG_JNI(register_android_view_Display), + REG_JNI(register_android_nio_utils), + REG_JNI(register_android_graphics_PixelFormat), + REG_JNI(register_android_graphics_Graphics), + REG_JNI(register_android_view_Surface), + REG_JNI(register_android_view_ViewRoot), + REG_JNI(register_com_google_android_gles_jni_EGLImpl), + REG_JNI(register_com_google_android_gles_jni_GLImpl), + + REG_JNI(register_android_graphics_Bitmap), + REG_JNI(register_android_graphics_BitmapFactory), + REG_JNI(register_android_graphics_Camera), + REG_JNI(register_android_graphics_Canvas), + REG_JNI(register_android_graphics_ColorFilter), + REG_JNI(register_android_graphics_DrawFilter), + REG_JNI(register_android_graphics_Interpolator), + REG_JNI(register_android_graphics_LayerRasterizer), + REG_JNI(register_android_graphics_MaskFilter), + REG_JNI(register_android_graphics_Matrix), + REG_JNI(register_android_graphics_Movie), + REG_JNI(register_android_graphics_NinePatch), + REG_JNI(register_android_graphics_Paint), + REG_JNI(register_android_graphics_Path), + REG_JNI(register_android_graphics_PathMeasure), + REG_JNI(register_android_graphics_PathEffect), + REG_JNI(register_android_graphics_Picture), + REG_JNI(register_android_graphics_PorterDuff), + REG_JNI(register_android_graphics_Rasterizer), + REG_JNI(register_android_graphics_Region), + REG_JNI(register_android_graphics_Shader), + REG_JNI(register_android_graphics_Typeface), + REG_JNI(register_android_graphics_Xfermode), + REG_JNI(register_com_android_internal_graphics_NativeUtils), + + REG_JNI(register_android_database_CursorWindow), + REG_JNI(register_android_database_SQLiteDatabase), + REG_JNI(register_android_database_SQLiteDebug), + REG_JNI(register_android_database_SQLiteProgram), + REG_JNI(register_android_database_SQLiteQuery), + REG_JNI(register_android_database_SQLiteStatement), + REG_JNI(register_android_os_Debug), + REG_JNI(register_android_os_Exec), + REG_JNI(register_android_os_FileObserver), + REG_JNI(register_android_os_FileUtils), + REG_JNI(register_android_os_ParcelFileDescriptor), + REG_JNI(register_android_os_Power), + REG_JNI(register_android_os_StatFs), + REG_JNI(register_android_os_SystemProperties), + REG_JNI(register_android_os_UEventObserver), + REG_JNI(register_android_net_LocalSocketImpl), + REG_JNI(register_android_net_NetworkUtils), + REG_JNI(register_android_net_wifi_WifiManager), + REG_JNI(register_android_os_NetStat), + REG_JNI(register_android_os_MemoryFile), + REG_JNI(register_com_android_internal_os_ZygoteInit), + REG_JNI(register_android_hardware_Camera), + REG_JNI(register_android_hardware_SensorManager), + REG_JNI(register_android_media_AudioSystem), + REG_JNI(register_android_media_ToneGenerator), + + REG_JNI(register_android_opengl_classes), + REG_JNI(register_android_bluetooth_Database), + REG_JNI(register_android_bluetooth_HeadsetBase), + REG_JNI(register_android_bluetooth_BluetoothAudioGateway), + REG_JNI(register_android_bluetooth_RfcommSocket), + REG_JNI(register_android_bluetooth_ScoSocket), + REG_JNI(register_android_server_BluetoothDeviceService), + REG_JNI(register_android_server_BluetoothEventLoop), + REG_JNI(register_android_message_digest_sha1), + REG_JNI(register_android_ddm_DdmHandleNativeHeap), + REG_JNI(register_android_util_Base64), + REG_JNI(register_android_location_GpsLocationProvider), +}; + +/* + * Register android native functions with the VM. + */ +/*static*/ int AndroidRuntime::startReg(JNIEnv* env) +{ + /* + * This hook causes all future threads created in this process to be + * attached to the JavaVM. (This needs to go away in favor of JNI + * Attach calls.) + */ + androidSetCreateThreadFunc((android_create_thread_fn) javaCreateThreadEtc); + + LOGD("--- registering native functions ---\n"); + + /* + * Every "register" function calls one or more things that return + * a local reference (e.g. FindClass). Because we haven't really + * started the VM yet, they're all getting stored in the base frame + * and never released. Use Push/Pop to manage the storage. + */ + env->PushLocalFrame(200); + + if (register_jni_procs(gRegJNI, NELEM(gRegJNI), env) < 0) { + env->PopLocalFrame(NULL); + return -1; + } + env->PopLocalFrame(NULL); + + //createJavaThread("fubar", quickTest, (void*) "hello"); + + return 0; +} + +AndroidRuntime* AndroidRuntime::getRuntime() +{ + return gCurRuntime; +} + +/** + * Used by WithFramework to register native functions. + */ +extern "C" +jint Java_com_android_internal_util_WithFramework_registerNatives( + JNIEnv* env, jclass clazz) { + return register_jni_procs(gRegJNI, NELEM(gRegJNI), env); +} + +/** + * Used by LoadClass to register native functions. + */ +extern "C" +jint Java_LoadClass_registerNatives(JNIEnv* env, jclass clazz) { + return register_jni_procs(gRegJNI, NELEM(gRegJNI), env); +} + +} // namespace android diff --git a/core/jni/BindTest.cpp b/core/jni/BindTest.cpp new file mode 100644 index 0000000..5fae400 --- /dev/null +++ b/core/jni/BindTest.cpp @@ -0,0 +1,289 @@ +/* //device/libs/android_runtime/BindTest.cpp +** +** Copyright 2006, 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. +*/ + +#include <stdio.h> +#include <stdlib.h> +#include <jam-public.h> + +static u4 offset_instanceString; +static FieldBlock *fb_classString = NULL; +static Class *class_ReturnedObject = NULL; +static MethodBlock *mb_ReturnedObject_setReturnedString = NULL; +static MethodBlock *mb_Java_Lang_Object_Equals = NULL; + +static u4 offset_mObj; +static u4 offset_mBool; +static u4 offset_mInt; +static u4 offset_mString; +static u4 offset_mDouble; +static u4 offset_mLong; + + +/* native String getString(); */ +static uintptr_t * +getString(Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + RETURN_OBJ (createString ("String")); +} + +/* native String getNullString(); */ +static uintptr_t * +getNullString(Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + RETURN_OBJ (createString (NULL)); +} + +/* native String getBooleanTrue(); */ +static uintptr_t * +getBooleanTrue(Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + RETURN_BOOLEAN (TRUE); +} + +/* native String getBooleanFalse(); */ +static uintptr_t * +getBooleanFalse(Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + RETURN_BOOLEAN (FALSE); +} + +/* native Object nonvoidThrowsException() */ +static uintptr_t * +nonvoidThrowsException (Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + if (1) { + signalException("java/lang/NullPointerException", NULL); + goto exception; + } + + RETURN_OBJ (NULL); +exception: + RETURN_VOID; +} + +/* native void setInstanceString(String s); */ +static uintptr_t * +setInstanceString (Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + Object *jthis = (Object *) ostack[0]; + + JOBJ_set_obj(jthis, offset_instanceString, ostack[1]); + + RETURN_VOID; +} + +/* native void setClassString(String s) */ +static uintptr_t * +setClassString (Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ +// Object *jthis = (Object *) ostack[0]; + + fb_classString->static_value = ostack[1]; + + RETURN_VOID; +} + +/* native String makeStringFromThreeChars(char a, char b, char c); */ +static uintptr_t * +makeStringFromThreeChars (Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + // Object *jthis = ostack[0]; + char a = (char) ostack[1]; + char b = (char) ostack[2]; + char c = (char) ostack[3]; + + char str[4]; + + str[0] = a; + str[1] = b; + str[2] = c; + str[3] = 0; + + RETURN_OBJ(createString(str)); +} + +/* native ReturnedObject makeReturnedObject(String a); */ +static uintptr_t * +makeReturnedObject (Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + //Object *jthis = (Object*)ostack[0]; + Object *a = (Object*)ostack[1]; + + Object *ret; + + ret = allocObject(class_ReturnedObject); + + executeMethod(ret, mb_ReturnedObject_setReturnedString, a); + + RETURN_OBJ (ret); +} + +/* native double addDoubles(double a, double b); */ +static uintptr_t * +addDoubles (Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + //Object *jthis = (Object*)ostack[0]; + double a = JARG_get_double(1); + double b = JARG_get_double(3); + + RETURN_DOUBLE(a+b); +} + +/* native void setAll (Object obj, boolean bool, int i, String str, double d, long l) */ +static uintptr_t * +setAll (Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + Object *jthis = JARG_get_obj(0); + + Object *obj = JARG_get_obj(1); + bool b = JARG_get_bool(2); + int i = JARG_get_int(3); + char *str = JARG_get_cstr_strdup(4); + double d = JARG_get_double(5); + long long ll = JARG_get_long_long(5+2); + + JOBJ_set_obj(jthis, offset_mObj, obj); + JOBJ_set_bool(jthis, offset_mBool, b); + JOBJ_set_int(jthis, offset_mInt, i); + JOBJ_set_cstr(jthis, offset_mString, str); + free(str); + str = NULL; + JOBJ_set_double(jthis, offset_mDouble, d); + JOBJ_set_long_long(jthis, offset_mLong, ll); + + RETURN_VOID; +} + +/* native void compareAll (Object obj, boolean bool, int i, String str, double d, long l) */ +static uintptr_t * +compareAll (Class *clazz, MethodBlock *mb, uintptr_t *ostack) +{ + Object *jthis = JARG_get_obj(0); + + Object *obj = JARG_get_obj(1); + bool b = JARG_get_bool(2); + int i = JARG_get_int(3); + Object *strObj = JARG_get_obj(4); + double d = JARG_get_double(5); + long long ll = JARG_get_long_long(5+2); + + bool ret; + + void *result; + + Object *mStringObj = JOBJ_get_obj(jthis, offset_mString); + + char *s = JARG_get_cstr_strdup(4); + + result = executeMethod (strObj, lookupVirtualMethod(strObj,mb_Java_Lang_Object_Equals), + JOBJ_get_obj(jthis, offset_mString)); + + if (exceptionOccurred()) { + RETURN_VOID; + } + + ret = (*(uintptr_t *)result != 0) + && (obj == JOBJ_get_obj(jthis, offset_mObj)) + && (b == JOBJ_get_bool(jthis, offset_mBool)) + && (i == JOBJ_get_int(jthis, offset_mInt)) + && (d == JOBJ_get_double(jthis, offset_mDouble)) + && (ll == JOBJ_get_long_long(jthis, offset_mLong)); + + + RETURN_BOOLEAN(ret); +} + +static VMMethod methods[] = { + {"getString", getString}, + {"getNullString", getNullString}, + {"getBooleanTrue", getBooleanTrue}, + {"getBooleanFalse", getBooleanFalse}, + {"nonvoidThrowsException", nonvoidThrowsException}, + {"setInstanceString", setInstanceString}, + {"setClassString", setClassString}, + {"makeStringFromThreeChars", makeStringFromThreeChars}, + {"makeReturnedObject", makeReturnedObject}, + {"addDoubles", addDoubles}, + {"setAll", setAll}, + {"compareAll", compareAll}, + {NULL, NULL} +}; + + +void register_BindTest() +{ + jamvm_registerClass("BindTest", methods); + + Class *clazz = NULL; + + clazz = findClassFromClassLoader("BindTest", getSystemClassLoader()); + + if (clazz == NULL) { + fprintf(stderr, "Error: BindTest not found\n"); + clearException(); + return; + } + + FieldBlock *fb; + + fb = findField(clazz, "instanceString", "Ljava/lang/String;"); + + if (fb == NULL || ((fb->access_flags & ACC_STATIC) == ACC_STATIC)) { + fprintf(stderr, "Error: BindTest.instanceString not found or error\n"); + return; + } + + offset_instanceString = fb->offset; + + fb_classString = findField(clazz, "classString", "Ljava/lang/String;"); + + if (fb_classString == NULL || ((fb_classString->access_flags & ACC_STATIC) != ACC_STATIC)) { + fprintf(stderr, "Error: BindTest.classString not found or error\n"); + return; + } + + + class_ReturnedObject = findClassFromClassLoader("ReturnedObject", getSystemClassLoader()); + + if (class_ReturnedObject == NULL) { + fprintf(stderr, "Error: ReturnedObject class not found or error\n"); + return; + } + + mb_ReturnedObject_setReturnedString= + findMethod (class_ReturnedObject, "setReturnedString", "(Ljava/lang/String;)V"); + + if (mb_ReturnedObject_setReturnedString == NULL) { + fprintf(stderr, "Error: ReturnedObject.setReturnedString class not found or error\n"); + return; + } + + offset_mObj = findField(clazz, "mObj", "Ljava/lang/Object;")->offset; + offset_mBool = findField(clazz, "mBool", "Z" )->offset; + offset_mInt = findField(clazz, "mInt", "I")->offset; + offset_mString = findField(clazz, "mString", "Ljava/lang/String;")->offset; + offset_mDouble = findField(clazz, "mDouble", "D")->offset; + offset_mLong = findField(clazz, "mLong", "J")->offset; + + + mb_Java_Lang_Object_Equals = findMethod ( + findClassFromClassLoader("java/lang/Object", getSystemClassLoader()), + "equals", "(Ljava/lang/Object;)Z"); + +} + + diff --git a/core/jni/CursorWindow.cpp b/core/jni/CursorWindow.cpp new file mode 100644 index 0000000..fb891c9 --- /dev/null +++ b/core/jni/CursorWindow.cpp @@ -0,0 +1,412 @@ +/* + * Copyright (C) 2006-2007 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. + */ + +#undef LOG_TAG +#define LOG_TAG "CursorWindow" + +#include <utils/Log.h> +#include <utils/MemoryDealer.h> + +#include <assert.h> +#include <string.h> +#include <stdlib.h> + +#include <jni.h> +#include <JNIHelp.h> + +#include "CursorWindow.h" + + +namespace android { + +CursorWindow::CursorWindow(size_t maxSize) : + mMaxSize(maxSize) +{ +} + +bool CursorWindow::setMemory(sp<IMemory> memory) +{ + mMemory = memory; + mData = (uint8_t *) memory->pointer(); + if (mData == NULL) { + return false; + } + mHeader = (window_header_t *) mData; + + // Make the window read-only + mHeap = NULL; + ssize_t size = memory->size(); + mSize = size; + mMaxSize = size; + mFreeOffset = size; +LOG_WINDOW("Created CursorWindow from existing IMemory: mFreeOffset = %d, numRows = %d, numColumns = %d, mSize = %d, mMaxSize = %d, mData = %p", mFreeOffset, mHeader->numRows, mHeader->numColumns, mSize, mMaxSize, mData); + return true; +} + +bool CursorWindow::initBuffer(bool localOnly) +{ + //TODO Use a non-memory dealer mmap region for localOnly + + mHeap = new MemoryDealer(new SharedHeap(mMaxSize, 0, "CursorWindow")); + if (mHeap != NULL) { + mMemory = mHeap->allocate(mMaxSize); + if (mMemory != NULL) { + mData = (uint8_t *) mMemory->pointer(); + if (mData) { + mHeader = (window_header_t *) mData; + mSize = mMaxSize; + + // Put the window into a clean state + clear(); + LOG_WINDOW("Created CursorWindow with new MemoryDealer: mFreeOffset = %d, mSize = %d, mMaxSize = %d, mData = %p", mFreeOffset, mSize, mMaxSize, mData); + return true; + } + } + LOGE("memory dealer allocation failed"); + return false; + } else { + LOGE("failed to create the memory dealer"); + return false; + } +} + +CursorWindow::~CursorWindow() +{ + // Everything that matters is a smart pointer +} + +void CursorWindow::clear() +{ + mHeader->numRows = 0; + mHeader->numColumns = 0; + mFreeOffset = sizeof(window_header_t) + ROW_SLOT_CHUNK_SIZE; + // Mark the first chunk's next 'pointer' as null + *((uint32_t *)(mData + mFreeOffset - sizeof(uint32_t))) = 0; +} + +int32_t CursorWindow::freeSpace() +{ + int32_t freeSpace = mSize - mFreeOffset; + if (freeSpace < 0) { + freeSpace = 0; + } + return freeSpace; +} + +field_slot_t * CursorWindow::allocRow() +{ + // Fill in the row slot + row_slot_t * rowSlot = allocRowSlot(); + if (rowSlot == NULL) { + return NULL; + } + + // Allocate the slots for the field directory + size_t fieldDirSize = mHeader->numColumns * sizeof(field_slot_t); + uint32_t fieldDirOffset = alloc(fieldDirSize); + if (!fieldDirOffset) { + mHeader->numRows--; + LOGE("The row failed, so back out the new row accounting from allocRowSlot %d", mHeader->numRows); + return NULL; + } + field_slot_t * fieldDir = (field_slot_t *)offsetToPtr(fieldDirOffset); + memset(fieldDir, 0x0, fieldDirSize); + +LOG_WINDOW("Allocated row %u, rowSlot is at offset %u, fieldDir is %d bytes at offset %u\n", (mHeader->numRows - 1), ((uint8_t *)rowSlot) - mData, fieldDirSize, fieldDirOffset); + rowSlot->offset = fieldDirOffset; + + return fieldDir; +} + +uint32_t CursorWindow::alloc(size_t requestedSize, bool aligned) +{ + int32_t size; + uint32_t padding; + if (aligned) { + // 4 byte alignment + padding = 4 - (mFreeOffset & 0x3); + } else { + padding = 0; + } + + size = requestedSize + padding; + + if (size > freeSpace()) { + LOGE("need to grow: mSize = %d, size = %d, freeSpace() = %d, numRows = %d", mSize, size, freeSpace(), mHeader->numRows); + // Only grow the window if the first row doesn't fit + if (mHeader->numRows > 1) { +LOGE("not growing since there are already %d row(s), max size %d", mHeader->numRows, mMaxSize); + return 0; + } + + // Find a new size that will fit the allocation + int allocated = mSize - freeSpace(); + int newSize = mSize + WINDOW_ALLOCATION_SIZE; + while (size > (newSize - allocated)) { + newSize += WINDOW_ALLOCATION_SIZE; + if (newSize > mMaxSize) { + LOGE("Attempting to grow window beyond max size (%d)", mMaxSize); + return 0; + } + } +LOG_WINDOW("found size %d", newSize); + mSize = newSize; + } + + uint32_t offset = mFreeOffset + padding; + mFreeOffset += size; + return offset; +} + +row_slot_t * CursorWindow::getRowSlot(int row) +{ + LOG_WINDOW("enter getRowSlot current row num %d, this row %d", mHeader->numRows, row); + int chunkNum = row / ROW_SLOT_CHUNK_NUM_ROWS; + int chunkPos = row % ROW_SLOT_CHUNK_NUM_ROWS; + int chunkPtrOffset = sizeof(window_header_t) + ROW_SLOT_CHUNK_SIZE - sizeof(uint32_t); + uint8_t * rowChunk = mData + sizeof(window_header_t); + for (int i = 0; i < chunkNum; i++) { + rowChunk = offsetToPtr(*((uint32_t *)(mData + chunkPtrOffset))); + chunkPtrOffset = rowChunk - mData + (ROW_SLOT_CHUNK_NUM_ROWS * sizeof(row_slot_t)); + } + return (row_slot_t *)(rowChunk + (chunkPos * sizeof(row_slot_t))); + LOG_WINDOW("exit getRowSlot current row num %d, this row %d", mHeader->numRows, row); +} + +row_slot_t * CursorWindow::allocRowSlot() +{ + int chunkNum = mHeader->numRows / ROW_SLOT_CHUNK_NUM_ROWS; + int chunkPos = mHeader->numRows % ROW_SLOT_CHUNK_NUM_ROWS; + int chunkPtrOffset = sizeof(window_header_t) + ROW_SLOT_CHUNK_SIZE - sizeof(uint32_t); + uint8_t * rowChunk = mData + sizeof(window_header_t); +LOG_WINDOW("Allocating row slot, mHeader->numRows is %d, chunkNum is %d, chunkPos is %d", mHeader->numRows, chunkNum, chunkPos); + for (int i = 0; i < chunkNum; i++) { + uint32_t nextChunkOffset = *((uint32_t *)(mData + chunkPtrOffset)); +LOG_WINDOW("nextChunkOffset is %d", nextChunkOffset); + if (nextChunkOffset == 0) { + // Allocate a new row chunk + nextChunkOffset = alloc(ROW_SLOT_CHUNK_SIZE, true); + if (nextChunkOffset == 0) { + return NULL; + } + rowChunk = offsetToPtr(nextChunkOffset); +LOG_WINDOW("allocated new chunk at %d, rowChunk = %p", nextChunkOffset, rowChunk); + *((uint32_t *)(mData + chunkPtrOffset)) = rowChunk - mData; + // Mark the new chunk's next 'pointer' as null + *((uint32_t *)(rowChunk + ROW_SLOT_CHUNK_SIZE - sizeof(uint32_t))) = 0; + } else { +LOG_WINDOW("follwing 'pointer' to next chunk, offset of next pointer is %d", chunkPtrOffset); + rowChunk = offsetToPtr(nextChunkOffset); + chunkPtrOffset = rowChunk - mData + (ROW_SLOT_CHUNK_NUM_ROWS * sizeof(row_slot_t)); + } + } + mHeader->numRows++; + + return (row_slot_t *)(rowChunk + (chunkPos * sizeof(row_slot_t))); +} + +field_slot_t * CursorWindow::getFieldSlotWithCheck(int row, int column) +{ + if (row < 0 || row >= mHeader->numRows || column < 0 || column >= mHeader->numColumns) { + LOGE("Bad request for field slot %d,%d. numRows = %d, numColumns = %d", row, column, mHeader->numRows, mHeader->numColumns); + return NULL; + } + row_slot_t * rowSlot = getRowSlot(row); + if (!rowSlot) { + LOGE("Failed to find rowSlot for row %d", row); + return NULL; + } + if (rowSlot->offset == 0 || rowSlot->offset >= mSize) { + LOGE("Invalid rowSlot, offset = %d", rowSlot->offset); + return NULL; + } + int fieldDirOffset = rowSlot->offset; + return ((field_slot_t *)offsetToPtr(fieldDirOffset)) + column; +} + +uint32_t CursorWindow::read_field_slot(int row, int column, field_slot_t * slotOut) +{ + if (row < 0 || row >= mHeader->numRows || column < 0 || column >= mHeader->numColumns) { + LOGE("Bad request for field slot %d,%d. numRows = %d, numColumns = %d", row, column, mHeader->numRows, mHeader->numColumns); + return -1; + } + row_slot_t * rowSlot = getRowSlot(row); + if (!rowSlot) { + LOGE("Failed to find rowSlot for row %d", row); + return -1; + } + if (rowSlot->offset == 0 || rowSlot->offset >= mSize) { + LOGE("Invalid rowSlot, offset = %d", rowSlot->offset); + return -1; + } +LOG_WINDOW("Found field directory for %d,%d at rowSlot %d, offset %d", row, column, (uint8_t *)rowSlot - mData, rowSlot->offset); + field_slot_t * fieldDir = (field_slot_t *)offsetToPtr(rowSlot->offset); +LOG_WINDOW("Read field_slot_t %d,%d: offset = %d, size = %d, type = %d", row, column, fieldDir[column].data.buffer.offset, fieldDir[column].data.buffer.size, fieldDir[column].type); + + // Copy the data to the out param + slotOut->data.buffer.offset = fieldDir[column].data.buffer.offset; + slotOut->data.buffer.size = fieldDir[column].data.buffer.size; + slotOut->type = fieldDir[column].type; + return 0; +} + +void CursorWindow::copyIn(uint32_t offset, uint8_t const * data, size_t size) +{ + assert(offset + size <= mSize); + memcpy(mData + offset, data, size); +} + +void CursorWindow::copyIn(uint32_t offset, int64_t data) +{ + assert(offset + sizeof(int64_t) <= mSize); + memcpy(mData + offset, (uint8_t *)&data, sizeof(int64_t)); +} + +void CursorWindow::copyIn(uint32_t offset, double data) +{ + assert(offset + sizeof(double) <= mSize); + memcpy(mData + offset, (uint8_t *)&data, sizeof(double)); +} + +void CursorWindow::copyOut(uint32_t offset, uint8_t * data, size_t size) +{ + assert(offset + size <= mSize); + memcpy(data, mData + offset, size); +} + +int64_t CursorWindow::copyOutLong(uint32_t offset) +{ + int64_t value; + assert(offset + sizeof(int64_t) <= mSize); + memcpy(&value, mData + offset, sizeof(int64_t)); + return value; +} + +double CursorWindow::copyOutDouble(uint32_t offset) +{ + double value; + assert(offset + sizeof(double) <= mSize); + memcpy(&value, mData + offset, sizeof(double)); + return value; +} + +bool CursorWindow::putLong(unsigned int row, unsigned int col, int64_t value) +{ + field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col); + if (!fieldSlot) { + return false; + } + +#if WINDOW_STORAGE_INLINE_NUMERICS + fieldSlot->data.l = value; +#else + int offset = alloc(sizeof(int64_t)); + if (!offset) { + return false; + } + + copyIn(offset, value); + + fieldSlot->data.buffer.offset = offset; + fieldSlot->data.buffer.size = sizeof(int64_t); +#endif + fieldSlot->type = FIELD_TYPE_INTEGER; + return true; +} + +bool CursorWindow::putDouble(unsigned int row, unsigned int col, double value) +{ + field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col); + if (!fieldSlot) { + return false; + } + +#if WINDOW_STORAGE_INLINE_NUMERICS + fieldSlot->data.d = value; +#else + int offset = alloc(sizeof(int64_t)); + if (!offset) { + return false; + } + + copyIn(offset, value); + + fieldSlot->data.buffer.offset = offset; + fieldSlot->data.buffer.size = sizeof(double); +#endif + fieldSlot->type = FIELD_TYPE_FLOAT; + return true; +} + +bool CursorWindow::putNull(unsigned int row, unsigned int col) +{ + field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col); + if (!fieldSlot) { + return false; + } + + fieldSlot->type = FIELD_TYPE_NULL; + fieldSlot->data.buffer.offset = 0; + fieldSlot->data.buffer.size = 0; + return true; +} + +bool CursorWindow::getLong(unsigned int row, unsigned int col, int64_t * valueOut) +{ + field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col); + if (!fieldSlot || fieldSlot->type != FIELD_TYPE_INTEGER) { + return false; + } + +#if WINDOW_STORAGE_INLINE_NUMERICS + *valueOut = fieldSlot->data.l; +#else + *valueOut = copyOutLong(fieldSlot->data.buffer.offset); +#endif + return true; +} + +bool CursorWindow::getDouble(unsigned int row, unsigned int col, double * valueOut) +{ + field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col); + if (!fieldSlot || fieldSlot->type != FIELD_TYPE_FLOAT) { + return false; + } + +#if WINDOW_STORAGE_INLINE_NUMERICS + *valueOut = fieldSlot->data.d; +#else + *valueOut = copyOutDouble(fieldSlot->data.buffer.offset); +#endif + return true; +} + +bool CursorWindow::getNull(unsigned int row, unsigned int col, bool * valueOut) +{ + field_slot_t * fieldSlot = getFieldSlotWithCheck(row, col); + if (!fieldSlot) { + return false; + } + + if (fieldSlot->type != FIELD_TYPE_NULL) { + *valueOut = false; + } else { + *valueOut = true; + } + return true; +} + +}; // namespace android diff --git a/core/jni/CursorWindow.h b/core/jni/CursorWindow.h new file mode 100644 index 0000000..0fb074f --- /dev/null +++ b/core/jni/CursorWindow.h @@ -0,0 +1,203 @@ +/* + * Copyright (C) 2006 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__DATABASE_WINDOW_H +#define _ANDROID__DATABASE_WINDOW_H + +#include <cutils/log.h> +#include <stddef.h> +#include <stdint.h> + +#include <utils/MemoryDealer.h> +#include <utils/RefBase.h> + +#include <jni.h> + +#define DEFAULT_WINDOW_SIZE 4096 +#define MAX_WINDOW_SIZE (1024 * 1024) +#define WINDOW_ALLOCATION_SIZE 4096 + +#define ROW_SLOT_CHUNK_NUM_ROWS 16 + +// Row slots are allocated in chunks of ROW_SLOT_CHUNK_NUM_ROWS, +// with an offset after the rows that points to the next chunk +#define ROW_SLOT_CHUNK_SIZE ((ROW_SLOT_CHUNK_NUM_ROWS * sizeof(row_slot_t)) + sizeof(uint32_t)) + + +#if LOG_NDEBUG + +#define IF_LOG_WINDOW() if (false) +#define LOG_WINDOW(...) + +#else + +#define IF_LOG_WINDOW() IF_LOG(LOG_DEBUG, "CursorWindow") +#define LOG_WINDOW(...) LOG(LOG_DEBUG, "CursorWindow", __VA_ARGS__) + +#endif + + +// When defined to true strings are stored as UTF8, otherwise they're UTF16 +#define WINDOW_STORAGE_UTF8 1 + +// When defined to true numberic values are stored inline in the field_slot_t, otherwise they're allocated in the window +#define WINDOW_STORAGE_INLINE_NUMERICS 1 + +namespace android { + +typedef struct +{ + uint32_t numRows; + uint32_t numColumns; +} window_header_t; + +typedef struct +{ + uint32_t offset; +} row_slot_t; + +typedef struct +{ + uint8_t type; + union { + double d; + int64_t l; + struct { + uint32_t offset; + uint32_t size; + } buffer; + } data; +} __attribute__((packed)) field_slot_t; + +#define FIELD_TYPE_INTEGER 1 +#define FIELD_TYPE_FLOAT 2 +#define FIELD_TYPE_STRING 3 +#define FIELD_TYPE_BLOB 4 +#define FIELD_TYPE_NULL 5 + +/** + * This class stores a set of rows from a database in a buffer. The begining of the + * window has first chunk of row_slot_ts, which are offsets to the row directory, followed by + * an offset to the next chunk in a linked-list of additional chunk of row_slot_ts in case + * the pre-allocated chunk isn't big enough to refer to all rows. Each row directory has a + * field_slot_t per column, which has the size, offset, and type of the data for that field. + * Note that the data types come from sqlite3.h. + */ +class CursorWindow +{ +public: + CursorWindow(size_t maxSize); + CursorWindow(){} + bool setMemory(sp<IMemory>); + ~CursorWindow(); + + bool initBuffer(bool localOnly); + sp<IMemory> getMemory() {return mMemory;} + + size_t size() {return mSize;} + uint8_t * data() {return mData;} + uint32_t getNumRows() {return mHeader->numRows;} + uint32_t getNumColumns() {return mHeader->numColumns;} + void freeLastRow() { + if (mHeader->numRows > 0) { + mHeader->numRows--; + } + } + bool setNumColumns(uint32_t numColumns) + { + uint32_t cur = mHeader->numColumns; + if (cur > 0 && cur != numColumns) { + LOGE("Trying to go from %d columns to %d", cur, numColumns); + return false; + } + mHeader->numColumns = numColumns; + return true; + } + + int32_t freeSpace(); + + void clear(); + + /** + * Allocate a row slot and its directory. The returned + * pointer points to the begining of the row's directory + * or NULL if there wasn't room. The directory is + * initialied with NULL entries for each field. + */ + field_slot_t * allocRow(); + + /** + * Allocate a portion of the window. Returns the offset + * of the allocation, or 0 if there isn't enough space. + * If aligned is true, the allocation gets 4 byte alignment. + */ + uint32_t alloc(size_t size, bool aligned = false); + + uint32_t read_field_slot(int row, int column, field_slot_t * slot); + + /** + * Copy data into the window at the given offset. + */ + void copyIn(uint32_t offset, uint8_t const * data, size_t size); + void copyIn(uint32_t offset, int64_t data); + void copyIn(uint32_t offset, double data); + + void copyOut(uint32_t offset, uint8_t * data, size_t size); + int64_t copyOutLong(uint32_t offset); + double copyOutDouble(uint32_t offset); + + bool putLong(unsigned int row, unsigned int col, int64_t value); + bool putDouble(unsigned int row, unsigned int col, double value); + bool putNull(unsigned int row, unsigned int col); + + bool getLong(unsigned int row, unsigned int col, int64_t * valueOut); + bool getDouble(unsigned int row, unsigned int col, double * valueOut); + bool getNull(unsigned int row, unsigned int col, bool * valueOut); + + uint8_t * offsetToPtr(uint32_t offset) {return mData + offset;} + + row_slot_t * allocRowSlot(); + + row_slot_t * getRowSlot(int row); + + /** + * return NULL if Failed to find rowSlot or + * Invalid rowSlot + */ + field_slot_t * getFieldSlotWithCheck(int row, int column); + field_slot_t * getFieldSlot(int row, int column) + { + int fieldDirOffset = getRowSlot(row)->offset; + return ((field_slot_t *)offsetToPtr(fieldDirOffset)) + column; + } + +private: + uint8_t * mData; + size_t mSize; + size_t mMaxSize; + window_header_t * mHeader; + sp<MemoryDealer> mHeap; + sp<IMemory> mMemory; + + /** + * Offset of the lowest unused data byte in the array. + */ + uint32_t mFreeOffset; +}; + +}; // namespace android + +#endif diff --git a/core/jni/GraphicsExternGlue.h b/core/jni/GraphicsExternGlue.h new file mode 100644 index 0000000..290dbd5 --- /dev/null +++ b/core/jni/GraphicsExternGlue.h @@ -0,0 +1,25 @@ +/* //device/libs/android_runtime/GraphicsExternGlue.h +** +** Copyright 2006, 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. +*/ + +extern void register_android_Paint(); +extern void register_android_Canvas(); +extern void register_android_ColorFilter(); +extern void register_android_Matrix(); +extern void register_android_Path(); +extern void register_android_PorterDuff(); +extern void register_android_Rasterizer(); +extern void register_android_Xfermode(); diff --git a/core/jni/GraphicsRegisterGlue.h b/core/jni/GraphicsRegisterGlue.h new file mode 100644 index 0000000..4054e83 --- /dev/null +++ b/core/jni/GraphicsRegisterGlue.h @@ -0,0 +1,25 @@ +/* //device/libs/android_runtime/GraphicsRegisterGlue.h +** +** Copyright 2006, 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. +*/ + +register_android_Paint(); +register_android_Canvas(); +register_android_ColorFilter(); +register_android_Matrix(); +register_android_Path(); +register_android_PorterDuff(); +register_android_Rasterizer(); +register_android_Xfermode(); diff --git a/core/jni/MODULE_LICENSE_APACHE2 b/core/jni/MODULE_LICENSE_APACHE2 new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/core/jni/MODULE_LICENSE_APACHE2 diff --git a/core/jni/NOTICE b/core/jni/NOTICE new file mode 100644 index 0000000..c5b1efa --- /dev/null +++ b/core/jni/NOTICE @@ -0,0 +1,190 @@ + + Copyright (c) 2005-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. + + 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. + + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + diff --git a/core/jni/android/graphics/Bitmap.cpp b/core/jni/android/graphics/Bitmap.cpp new file mode 100644 index 0000000..8628ec0 --- /dev/null +++ b/core/jni/android/graphics/Bitmap.cpp @@ -0,0 +1,573 @@ +#include "SkBitmap.h" +#include "SkImageDecoder.h" +#include "SkColorPriv.h" +#include "GraphicsJNI.h" +#include "SkDither.h" + +#include "Parcel.h" +#include "android_util_Binder.h" +#include "android_nio_utils.h" +#include "CreateJavaOutputStreamAdaptor.h" + +#include <jni.h> + +#if 0 + #define TRACE_BITMAP(code) code +#else + #define TRACE_BITMAP(code) +#endif + +/////////////////////////////////////////////////////////////////////////////// +// Conversions to/from SkColor, for get/setPixels, and the create method, which +// is basically like setPixels + +typedef void (*FromColorProc)(void* dst, const SkColor src[], int width, + int x, int y); + +static void FromColor_D32(void* dst, const SkColor src[], int width, + int, int) { + SkPMColor* d = (SkPMColor*)dst; + + for (int i = 0; i < width; i++) { + *d++ = SkPreMultiplyColor(*src++); + } +} + +static void FromColor_D565(void* dst, const SkColor src[], int width, + int x, int y) { + uint16_t* d = (uint16_t*)dst; + + DITHER_565_SCAN(y); + for (int stop = x + width; x < stop; x++) { + SkColor c = *src++; + *d++ = SkDitherRGBTo565(SkColorGetR(c), SkColorGetG(c), SkColorGetB(c), + DITHER_VALUE(x)); + } +} + +static void FromColor_D4444(void* dst, const SkColor src[], int width, + int x, int y) { + SkPMColor16* d = (SkPMColor16*)dst; + + DITHER_4444_SCAN(y); + for (int stop = x + width; x < stop; x++) { + SkPMColor c = SkPreMultiplyColor(*src++); + *d++ = SkDitherARGB32To4444(c, DITHER_VALUE(x)); +// *d++ = SkPixel32ToPixel4444(c); + } +} + +// can return NULL +static FromColorProc ChooseFromColorProc(SkBitmap::Config config) { + switch (config) { + case SkBitmap::kARGB_8888_Config: + return FromColor_D32; + case SkBitmap::kARGB_4444_Config: + return FromColor_D4444; + case SkBitmap::kRGB_565_Config: + return FromColor_D565; + default: + break; + } + return NULL; +} + +bool GraphicsJNI::SetPixels(JNIEnv* env, jintArray srcColors, + int srcOffset, int srcStride, + int x, int y, int width, int height, + const SkBitmap& dstBitmap) { + SkAutoLockPixels alp(dstBitmap); + void* dst = dstBitmap.getPixels(); + FromColorProc proc = ChooseFromColorProc(dstBitmap.config()); + + if (NULL == dst || NULL == proc) { + return false; + } + + jint* array = env->GetIntArrayElements(srcColors, NULL); + const SkColor* src = (const SkColor*)array + srcOffset; + + // reset to to actual choice from caller + dst = dstBitmap.getAddr(x, y); + // now copy/convert each scanline + for (int y = 0; y < height; y++) { + proc(dst, src, width, x, y); + src += srcStride; + dst = (char*)dst + dstBitmap.rowBytes(); + } + + env->ReleaseIntArrayElements(srcColors, array, 0); + return true; +} + +//////////////////// ToColor procs + +typedef void (*ToColorProc)(SkColor dst[], const void* src, int width, + SkColorTable*); + +static inline SkColor pmcolorToColor(SkPMColor c) { + if (0 == c) { + return 0; + } + + unsigned a = SkGetPackedA32(c); + unsigned r = SkGetPackedR32(c); + unsigned g = SkGetPackedG32(c); + unsigned b = SkGetPackedB32(c); + + if (a < 255) { + SkFixed scale = SK_Fixed1 / a; + r = SkFixedRound(r * scale); + g = SkFixedRound(g * scale); + b = SkFixedRound(b * scale); + SkASSERT(r <= 0xFF); + SkASSERT(g <= 0xFF); + SkASSERT(b <= 0xFF); + } + + return SkColorSetARGB(a, r, g, b); +} + +static void ToColor_S32_Alpha(SkColor dst[], const void* src, int width, + SkColorTable*) { + SkASSERT(width > 0); + const SkPMColor* s = (const SkPMColor*)src; + do { + *dst++ = pmcolorToColor(*s++); + } while (--width != 0); +} + +static void ToColor_S32_Opaque(SkColor dst[], const void* src, int width, + SkColorTable*) { + SkASSERT(width > 0); + const SkPMColor* s = (const SkPMColor*)src; + do { + SkPMColor c = *s++; + *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c), + SkGetPackedB32(c)); + } while (--width != 0); +} + +static void ToColor_S4444_Alpha(SkColor dst[], const void* src, int width, + SkColorTable*) { + SkASSERT(width > 0); + const SkPMColor16* s = (const SkPMColor16*)src; + do { + *dst++ = pmcolorToColor(SkPixel4444ToPixel32(*s++)); + } while (--width != 0); +} + +static void ToColor_S4444_Opaque(SkColor dst[], const void* src, int width, + SkColorTable*) { + SkASSERT(width > 0); + const SkPMColor* s = (const SkPMColor*)src; + do { + SkPMColor c = SkPixel4444ToPixel32(*s++); + *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c), + SkGetPackedB32(c)); + } while (--width != 0); +} + +static void ToColor_S565(SkColor dst[], const void* src, int width, + SkColorTable*) { + SkASSERT(width > 0); + const uint16_t* s = (const uint16_t*)src; + do { + uint16_t c = *s++; + *dst++ = SkColorSetRGB(SkPacked16ToR32(c), SkPacked16ToG32(c), + SkPacked16ToB32(c)); + } while (--width != 0); +} + +static void ToColor_SI8_Alpha(SkColor dst[], const void* src, int width, + SkColorTable* ctable) { + SkASSERT(width > 0); + const uint8_t* s = (const uint8_t*)src; + const SkPMColor* colors = ctable->lockColors(); + do { + *dst++ = pmcolorToColor(colors[*s++]); + } while (--width != 0); + ctable->unlockColors(false); +} + +static void ToColor_SI8_Opaque(SkColor dst[], const void* src, int width, + SkColorTable* ctable) { + SkASSERT(width > 0); + const uint8_t* s = (const uint8_t*)src; + const SkPMColor* colors = ctable->lockColors(); + do { + SkPMColor c = colors[*s++]; + *dst++ = SkColorSetRGB(SkGetPackedR32(c), SkGetPackedG32(c), + SkGetPackedB32(c)); + } while (--width != 0); + ctable->unlockColors(false); +} + +// can return NULL +static ToColorProc ChooseToColorProc(const SkBitmap& src) { + switch (src.config()) { + case SkBitmap::kARGB_8888_Config: + return src.isOpaque() ? ToColor_S32_Opaque : ToColor_S32_Alpha; + case SkBitmap::kARGB_4444_Config: + return src.isOpaque() ? ToColor_S4444_Opaque : ToColor_S4444_Alpha; + case SkBitmap::kRGB_565_Config: + return ToColor_S565; + case SkBitmap::kIndex8_Config: + if (src.getColorTable() == NULL) { + return NULL; + } + return src.isOpaque() ? ToColor_SI8_Opaque : ToColor_SI8_Alpha; + default: + break; + } + return NULL; +} + +/////////////////////////////////////////////////////////////////////////////// +/////////////////////////////////////////////////////////////////////////////// + +static jobject Bitmap_creator(JNIEnv* env, jobject, jintArray jColors, + int offset, int stride, int width, int height, + SkBitmap::Config config, jboolean isMutable) { + if (width <= 0 || height <= 0) { + doThrowIAE(env, "width and height must be > 0"); + return NULL; + } + + if (NULL != jColors) { + size_t n = env->GetArrayLength(jColors); + if (n < SkAbs32(stride) * (size_t)height) { + doThrowAIOOBE(env); + return NULL; + } + } + + SkBitmap bitmap; + + bitmap.setConfig(config, width, height); + if (!GraphicsJNI::setJavaPixelRef(env, &bitmap, NULL)) { + return NULL; + } + + if (jColors != NULL) { + GraphicsJNI::SetPixels(env, jColors, offset, stride, + 0, 0, width, height, bitmap); + } + + return GraphicsJNI::createBitmap(env, new SkBitmap(bitmap), isMutable, + NULL); +} + +static jobject Bitmap_copy(JNIEnv* env, jobject, const SkBitmap* src, + SkBitmap::Config dstConfig, jboolean isMutable) { + SkBitmap result; + JavaPixelAllocator allocator(env); + + if (!src->copyTo(&result, dstConfig, &allocator)) { + return NULL; + } + + return GraphicsJNI::createBitmap(env, new SkBitmap(result), isMutable, + NULL); +} + +static void Bitmap_destructor(JNIEnv* env, jobject, SkBitmap* bitmap) { + delete bitmap; +} + +static void Bitmap_recycle(JNIEnv* env, jobject, SkBitmap* bitmap) { + bitmap->setPixels(NULL, NULL); +} + +// These must match the int values in Bitmap.java +enum JavaEncodeFormat { + kJPEG_JavaEncodeFormat = 0, + kPNG_JavaEncodeFormat = 1 +}; + +static bool Bitmap_compress(JNIEnv* env, jobject clazz, SkBitmap* bitmap, + int format, int quality, + jobject jstream, jbyteArray jstorage) { + SkImageEncoder::Type fm; + + switch (format) { + case kJPEG_JavaEncodeFormat: + fm = SkImageEncoder::kJPEG_Type; + break; + case kPNG_JavaEncodeFormat: + fm = SkImageEncoder::kPNG_Type; + break; + default: + return false; + } + + bool success = false; + SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage); + if (NULL != strm) { + SkImageEncoder* encoder = SkImageEncoder::Create(fm); + if (NULL != encoder) { + success = encoder->encodeStream(strm, *bitmap, quality); + delete encoder; + } + delete strm; + } + return success; +} + +static void Bitmap_erase(JNIEnv* env, jobject, SkBitmap* bitmap, jint color) { + bitmap->eraseColor(color); +} + +static int Bitmap_width(JNIEnv* env, jobject, SkBitmap* bitmap) { + return bitmap->width(); +} + +static int Bitmap_height(JNIEnv* env, jobject, SkBitmap* bitmap) { + return bitmap->height(); +} + +static int Bitmap_rowBytes(JNIEnv* env, jobject, SkBitmap* bitmap) { + return bitmap->rowBytes(); +} + +static int Bitmap_config(JNIEnv* env, jobject, SkBitmap* bitmap) { + return bitmap->config(); +} + +static jboolean Bitmap_hasAlpha(JNIEnv* env, jobject, SkBitmap* bitmap) { + return !bitmap->isOpaque(); +} + +/////////////////////////////////////////////////////////////////////////////// + +static jobject Bitmap_createFromParcel(JNIEnv* env, jobject, jobject parcel) { + if (parcel == NULL) { + SkDebugf("-------- unparcel parcel is NULL\n"); + return NULL; + } + + android::Parcel* p = android::parcelForJavaObject(env, parcel); + + const bool isMutable = p->readInt32() != 0; + const SkBitmap::Config config = (SkBitmap::Config)p->readInt32(); + const int width = p->readInt32(); + const int height = p->readInt32(); + const int rowBytes = p->readInt32(); + + if (SkBitmap::kARGB_8888_Config != config && + SkBitmap::kRGB_565_Config != config && + SkBitmap::kARGB_4444_Config != config && + SkBitmap::kIndex8_Config != config && + SkBitmap::kA8_Config != config) { + SkDebugf("Bitmap_createFromParcel unknown config: %d\n", config); + return NULL; + } + + SkBitmap* bitmap = new SkBitmap; + + bitmap->setConfig(config, width, height, rowBytes); + + SkColorTable* ctable = NULL; + if (config == SkBitmap::kIndex8_Config) { + int count = p->readInt32(); + if (count > 0) { + size_t size = count * sizeof(SkPMColor); + const SkPMColor* src = (const SkPMColor*)p->readInplace(size); + ctable = new SkColorTable(src, count); + } + } + + if (!GraphicsJNI::setJavaPixelRef(env, bitmap, ctable)) { + ctable->safeUnref(); + delete bitmap; + return NULL; + } + + ctable->safeUnref(); + + size_t size = bitmap->getSize(); + bitmap->lockPixels(); + memcpy(bitmap->getPixels(), p->readInplace(size), size); + bitmap->unlockPixels(); + + return GraphicsJNI::createBitmap(env, bitmap, isMutable, NULL); +} + +static jboolean Bitmap_writeToParcel(JNIEnv* env, jobject, + const SkBitmap* bitmap, + jboolean isMutable, jobject parcel) { + if (parcel == NULL) { + SkDebugf("------- writeToParcel null parcel\n"); + return false; + } + + android::Parcel* p = android::parcelForJavaObject(env, parcel); + + p->writeInt32(isMutable); + p->writeInt32(bitmap->config()); + p->writeInt32(bitmap->width()); + p->writeInt32(bitmap->height()); + p->writeInt32(bitmap->rowBytes()); + + if (bitmap->getConfig() == SkBitmap::kIndex8_Config) { + SkColorTable* ctable = bitmap->getColorTable(); + if (ctable != NULL) { + int count = ctable->count(); + p->writeInt32(count); + memcpy(p->writeInplace(count * sizeof(SkPMColor)), + ctable->lockColors(), count * sizeof(SkPMColor)); + ctable->unlockColors(false); + } else { + p->writeInt32(0); // indicate no ctable + } + } + + size_t size = bitmap->getSize(); + bitmap->lockPixels(); + memcpy(p->writeInplace(size), bitmap->getPixels(), size); + bitmap->unlockPixels(); + return true; +} + +static jobject Bitmap_extractAlpha(JNIEnv* env, jobject clazz, + const SkBitmap* src, const SkPaint* paint, + jintArray offsetXY) { + SkIPoint offset; + SkBitmap* dst = new SkBitmap; + + src->extractAlpha(dst, paint, &offset); + if (offsetXY != 0 && env->GetArrayLength(offsetXY) >= 2) { + int* array = env->GetIntArrayElements(offsetXY, NULL); + array[0] = offset.fX; + array[1] = offset.fY; + env->ReleaseIntArrayElements(offsetXY, array, 0); + } + + return GraphicsJNI::createBitmap(env, dst, true, NULL); +} + +/////////////////////////////////////////////////////////////////////////////// + +static int Bitmap_getPixel(JNIEnv* env, jobject, const SkBitmap* bitmap, + int x, int y) { + SkAutoLockPixels alp(*bitmap); + + ToColorProc proc = ChooseToColorProc(*bitmap); + if (NULL == proc) { + return 0; + } + const void* src = bitmap->getAddr(x, y); + if (NULL == src) { + return 0; + } + + SkColor dst[1]; + proc(dst, src, 1, bitmap->getColorTable()); + return dst[0]; +} + +static void Bitmap_getPixels(JNIEnv* env, jobject, const SkBitmap* bitmap, + jintArray pixelArray, int offset, int stride, + int x, int y, int width, int height) { + SkAutoLockPixels alp(*bitmap); + + ToColorProc proc = ChooseToColorProc(*bitmap); + if (NULL == proc) { + return; + } + const void* src = bitmap->getAddr(x, y); + if (NULL == src) { + return; + } + + SkColorTable* ctable = bitmap->getColorTable(); + jint* dst = env->GetIntArrayElements(pixelArray, NULL); + SkColor* d = (SkColor*)dst + offset; + while (--height >= 0) { + proc(d, src, width, ctable); + d += stride; + src = (void*)((const char*)src + bitmap->rowBytes()); + } + env->ReleaseIntArrayElements(pixelArray, dst, 0); +} + +/////////////////////////////////////////////////////////////////////////////// + +static void Bitmap_setPixel(JNIEnv* env, jobject, const SkBitmap* bitmap, + int x, int y, SkColor color) { + SkAutoLockPixels alp(*bitmap); + if (NULL == bitmap->getPixels()) { + return; + } + + FromColorProc proc = ChooseFromColorProc(bitmap->config()); + if (NULL == proc) { + return; + } + + proc(bitmap->getAddr(x, y), &color, 1, x, y); +} + +static void Bitmap_setPixels(JNIEnv* env, jobject, const SkBitmap* bitmap, + jintArray pixelArray, int offset, int stride, + int x, int y, int width, int height) { + GraphicsJNI::SetPixels(env, pixelArray, offset, stride, + x, y, width, height, *bitmap); +} + +static void Bitmap_copyPixelsToBuffer(JNIEnv* env, jobject, + const SkBitmap* bitmap, jobject jbuffer) { + SkAutoLockPixels alp(*bitmap); + const void* src = bitmap->getPixels(); + + if (NULL != src) { + android::AutoBufferPointer abp(env, jbuffer, JNI_TRUE); + + // the java side has already checked that buffer is large enough + memcpy(abp.pointer(), src, bitmap->getSize()); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +#include <android_runtime/AndroidRuntime.h> + +static JNINativeMethod gBitmapMethods[] = { + { "nativeCreate", "([IIIIIIZ)Landroid/graphics/Bitmap;", + (void*)Bitmap_creator }, + { "nativeCopy", "(IIZ)Landroid/graphics/Bitmap;", + (void*)Bitmap_copy }, + { "nativeDestructor", "(I)V", (void*)Bitmap_destructor }, + { "nativeRecycle", "(I)V", (void*)Bitmap_recycle }, + { "nativeCompress", "(IIILjava/io/OutputStream;[B)Z", + (void*)Bitmap_compress }, + { "nativeErase", "(II)V", (void*)Bitmap_erase }, + { "nativeWidth", "(I)I", (void*)Bitmap_width }, + { "nativeHeight", "(I)I", (void*)Bitmap_height }, + { "nativeRowBytes", "(I)I", (void*)Bitmap_rowBytes }, + { "nativeConfig", "(I)I", (void*)Bitmap_config }, + { "nativeHasAlpha", "(I)Z", (void*)Bitmap_hasAlpha }, + { "nativeCreateFromParcel", + "(Landroid/os/Parcel;)Landroid/graphics/Bitmap;", + (void*)Bitmap_createFromParcel }, + { "nativeWriteToParcel", "(IZLandroid/os/Parcel;)Z", + (void*)Bitmap_writeToParcel }, + { "nativeExtractAlpha", "(II[I)Landroid/graphics/Bitmap;", + (void*)Bitmap_extractAlpha }, + { "nativeGetPixel", "(III)I", (void*)Bitmap_getPixel }, + { "nativeGetPixels", "(I[IIIIIII)V", (void*)Bitmap_getPixels }, + { "nativeSetPixel", "(IIII)V", (void*)Bitmap_setPixel }, + { "nativeSetPixels", "(I[IIIIIII)V", (void*)Bitmap_setPixels }, + { "nativeCopyPixelsToBuffer", "(ILjava/nio/Buffer;)V", + (void*)Bitmap_copyPixelsToBuffer } +}; + +#define kClassPathName "android/graphics/Bitmap" + +int register_android_graphics_Bitmap(JNIEnv* env); +int register_android_graphics_Bitmap(JNIEnv* env) +{ + return android::AndroidRuntime::registerNativeMethods(env, kClassPathName, + gBitmapMethods, SK_ARRAY_COUNT(gBitmapMethods)); +} + diff --git a/core/jni/android/graphics/BitmapFactory.cpp b/core/jni/android/graphics/BitmapFactory.cpp new file mode 100644 index 0000000..90822a1 --- /dev/null +++ b/core/jni/android/graphics/BitmapFactory.cpp @@ -0,0 +1,505 @@ +#include "SkImageDecoder.h" +#include "SkPixelRef.h" +#include "SkStream.h" +#include "GraphicsJNI.h" +#include "SkTemplates.h" +#include "SkUtils.h" +#include "CreateJavaOutputStreamAdaptor.h" + +#include <android_runtime/AndroidRuntime.h> +#include <utils/Asset.h> +#include <utils/ResourceTypes.h> +#include <netinet/in.h> +#include <sys/mman.h> + +static jclass gOptions_class; +static jfieldID gOptions_justBoundsFieldID; +static jfieldID gOptions_sampleSizeFieldID; +static jfieldID gOptions_configFieldID; +static jfieldID gOptions_ditherFieldID; +static jfieldID gOptions_widthFieldID; +static jfieldID gOptions_heightFieldID; +static jfieldID gOptions_mimeFieldID; + +static jclass gFileDescriptor_class; +static jfieldID gFileDescriptor_descriptor; + +#if 0 + #define TRACE_BITMAP(code) code +#else + #define TRACE_BITMAP(code) +#endif + +//#define MIN_SIZE_TO_USE_MMAP (4*1024) + +/////////////////////////////////////////////////////////////////////////////// + +class AutoDecoderCancel { +public: + AutoDecoderCancel(jobject options, SkImageDecoder* decoder); + ~AutoDecoderCancel(); + + static bool RequestCancel(jobject options); + +private: + AutoDecoderCancel* fNext; + jobject fJOptions; // java options object + SkImageDecoder* fDecoder; +}; + +static SkMutex gAutoDecoderCancelMutex; +static AutoDecoderCancel* gAutoDecoderCancel; + +AutoDecoderCancel::AutoDecoderCancel(jobject joptions, + SkImageDecoder* decoder) { + fJOptions = joptions; + fDecoder = decoder; + + // only need to be in the list if we have options + if (NULL != joptions) { + SkAutoMutexAcquire ac(gAutoDecoderCancelMutex); + + fNext = gAutoDecoderCancel; + gAutoDecoderCancel = this; + } +} + +AutoDecoderCancel::~AutoDecoderCancel() { + const jobject joptions = fJOptions; + + if (NULL != joptions) { + SkAutoMutexAcquire ac(gAutoDecoderCancelMutex); + + // remove us + AutoDecoderCancel* pair = gAutoDecoderCancel; + AutoDecoderCancel* prev = NULL; + while (pair != NULL) { + AutoDecoderCancel* next = pair->fNext; + if (pair->fJOptions == joptions) { + SkASSERT(pair->fDecoder == fDecoder); + if (prev) { + prev->fNext = next; + } else { + gAutoDecoderCancel = next; + } + return; + } + pair = next; + } + SkDebugf("xxxxxxxxxxxxxxxxxxxxxxx not found in pair list %p %p\n", + fJOptions, fDecoder); + } +} + +bool AutoDecoderCancel::RequestCancel(jobject joptions) { + SkAutoMutexAcquire ac(gAutoDecoderCancelMutex); + + AutoDecoderCancel* pair = gAutoDecoderCancel; + while (pair != NULL) { + if (pair->fJOptions == joptions) { + pair->fDecoder->cancelDecode(); + return true; + } + pair = pair->fNext; + } + return false; +} + +/////////////////////////////////////////////////////////////////////////////// + +using namespace android; + +class NinePatchPeeker : public SkImageDecoder::Peeker { +public: + NinePatchPeeker() { + fPatchIsValid = false; + } + + ~NinePatchPeeker() { + if (fPatchIsValid) { + free(fPatch); + } + } + + bool fPatchIsValid; + Res_png_9patch* fPatch; + + virtual bool peek(const char tag[], const void* data, size_t length) { + if (strcmp("npTc", tag) == 0 && length >= sizeof(Res_png_9patch)) { + Res_png_9patch* patch = (Res_png_9patch*) data; + size_t patchSize = patch->serializedSize(); + assert(length == patchSize); + // You have to copy the data because it is owned by the png reader + Res_png_9patch* patchNew = (Res_png_9patch*) malloc(patchSize); + memcpy(patchNew, patch, patchSize); + Res_png_9patch::deserialize(patchNew); + patchNew->fileToDevice(); + if (fPatchIsValid) { + free(fPatch); + } + fPatch = patchNew; + //printf("9patch: (%d,%d)-(%d,%d)\n", + // fPatch.sizeLeft, fPatch.sizeTop, + // fPatch.sizeRight, fPatch.sizeBottom); + fPatchIsValid = true; + } else { + fPatch = NULL; + } + return true; // keep on decoding + } +}; + +class AssetStreamAdaptor : public SkStream { +public: + AssetStreamAdaptor(Asset* a) : fAsset(a) {} + + virtual bool rewind() { + off_t pos = fAsset->seek(0, SEEK_SET); + return pos != (off_t)-1; + } + + virtual size_t read(void* buffer, size_t size) { + ssize_t amount; + + if (NULL == buffer) { + if (0 == size) { // caller is asking us for our total length + return fAsset->getLength(); + } + // asset->seek returns new total offset + // we want to return amount that was skipped + + off_t oldOffset = fAsset->seek(0, SEEK_CUR); + if (-1 == oldOffset) { + return 0; + } + off_t newOffset = fAsset->seek(size, SEEK_CUR); + if (-1 == newOffset) { + return 0; + } + amount = newOffset - oldOffset; + } else { + amount = fAsset->read(buffer, size); + } + + if (amount < 0) { + amount = 0; + } + return amount; + } + +private: + Asset* fAsset; +}; + +/////////////////////////////////////////////////////////////////////////////// + +static inline int32_t validOrNeg1(bool isValid, int32_t value) { +// return isValid ? value : -1; + SkASSERT((int)isValid == 0 || (int)isValid == 1); + return ((int32_t)isValid - 1) | value; +} + +static jstring getMimeTypeString(JNIEnv* env, SkImageDecoder::Format format) { + static const struct { + SkImageDecoder::Format fFormat; + const char* fMimeType; + } gMimeTypes[] = { + { SkImageDecoder::kBMP_Format, "image/bmp" }, + { SkImageDecoder::kGIF_Format, "image/gif" }, + { SkImageDecoder::kICO_Format, "image/x-ico" }, + { SkImageDecoder::kJPEG_Format, "image/jpeg" }, + { SkImageDecoder::kPNG_Format, "image/png" }, + { SkImageDecoder::kWBMP_Format, "image/vnd.wap.wbmp" } + }; + + const char* cstr = NULL; + for (size_t i = 0; i < SK_ARRAY_COUNT(gMimeTypes); i++) { + if (gMimeTypes[i].fFormat == format) { + cstr = gMimeTypes[i].fMimeType; + break; + } + } + + jstring jstr = 0; + if (NULL != cstr) { + jstr = env->NewStringUTF(cstr); + } + return jstr; +} + +static jobject doDecode(JNIEnv* env, SkStream* stream, jobject padding, + jobject options) { + + int sampleSize = 1; + SkImageDecoder::Mode mode = SkImageDecoder::kDecodePixels_Mode; + SkBitmap::Config prefConfig = SkBitmap::kNo_Config; + bool doDither = true; + + if (NULL != options) { + sampleSize = env->GetIntField(options, gOptions_sampleSizeFieldID); + if (env->GetBooleanField(options, gOptions_justBoundsFieldID)) { + mode = SkImageDecoder::kDecodeBounds_Mode; + } + // initialize these, in case we fail later on + env->SetIntField(options, gOptions_widthFieldID, -1); + env->SetIntField(options, gOptions_heightFieldID, -1); + env->SetObjectField(options, gOptions_mimeFieldID, 0); + + jobject jconfig = env->GetObjectField(options, gOptions_configFieldID); + prefConfig = GraphicsJNI::getNativeBitmapConfig(env, jconfig); + doDither = env->GetBooleanField(options, gOptions_ditherFieldID); + } + + SkImageDecoder* decoder = SkImageDecoder::Factory(stream); + if (NULL == decoder) { + return NULL; + } + + decoder->setSampleSize(sampleSize); + decoder->setDitherImage(doDither); + + NinePatchPeeker peeker; + JavaPixelAllocator allocator(env); + SkBitmap* bitmap = new SkBitmap; + Res_png_9patch dummy9Patch; + + SkAutoTDelete<SkImageDecoder> add(decoder); + SkAutoTDelete<SkBitmap> adb(bitmap); + + decoder->setPeeker(&peeker); + decoder->setAllocator(&allocator); + + AutoDecoderCancel adc(options, decoder); + + if (!decoder->decode(stream, bitmap, prefConfig, mode)) { + return NULL; + } + + // update options (if any) + if (NULL != options) { + env->SetIntField(options, gOptions_widthFieldID, bitmap->width()); + env->SetIntField(options, gOptions_heightFieldID, bitmap->height()); + // TODO: set the mimeType field with the data from the codec. + // but how to reuse a set of strings, rather than allocating new one + // each time? + env->SetObjectField(options, gOptions_mimeFieldID, + getMimeTypeString(env, decoder->getFormat())); + } + + // if we're in justBounds mode, return now (skip the java bitmap) + if (SkImageDecoder::kDecodeBounds_Mode == mode) { + return NULL; + } + + jbyteArray ninePatchChunk = NULL; + if (peeker.fPatchIsValid) { + size_t ninePatchArraySize = peeker.fPatch->serializedSize(); + ninePatchChunk = env->NewByteArray(ninePatchArraySize); + if (NULL == ninePatchChunk) { + return NULL; + } + jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(ninePatchChunk, + NULL); + if (NULL == array) { + return NULL; + } + peeker.fPatch->serialize(array); + env->ReleasePrimitiveArrayCritical(ninePatchChunk, array, 0); + } + + // detach bitmap from its autotdeleter, since we want to own it now + adb.detach(); + + if (padding) { + if (peeker.fPatchIsValid) { + GraphicsJNI::set_jrect(env, padding, + peeker.fPatch->paddingLeft, + peeker.fPatch->paddingTop, + peeker.fPatch->paddingRight, + peeker.fPatch->paddingBottom); + } else { + GraphicsJNI::set_jrect(env, padding, -1, -1, -1, -1); + } + } + + // promise we will never change our pixels (great for sharing and pictures) + SkPixelRef* ref = bitmap->pixelRef(); + SkASSERT(ref); + ref->setImmutable(); + + return GraphicsJNI::createBitmap(env, bitmap, false, ninePatchChunk); +} + +static jobject nativeDecodeStream(JNIEnv* env, jobject clazz, + jobject is, // InputStream + jbyteArray storage, // byte[] + jobject padding, + jobject options) { // BitmapFactory$Options + jobject bitmap = NULL; + SkStream* stream = CreateJavaInputStreamAdaptor(env, is, storage); + + if (stream) { + bitmap = doDecode(env, stream, padding, options); + stream->unref(); + } + return bitmap; +} + +static ssize_t getFDSize(int fd) { + off_t curr = ::lseek(fd, 0, SEEK_CUR); + if (curr < 0) { + return 0; + } + size_t size = ::lseek(fd, 0, SEEK_END); + ::lseek(fd, curr, SEEK_SET); + return size; +} + +/** Restore the file descriptor's offset in our destructor + */ +class AutoFDSeek { +public: + AutoFDSeek(int fd) : fFD(fd) { + fCurr = ::lseek(fd, 0, SEEK_CUR); + } + ~AutoFDSeek() { + if (fCurr >= 0) { + ::lseek(fFD, fCurr, SEEK_SET); + } + } +private: + int fFD; + off_t fCurr; +}; + +static jobject nativeDecodeFileDescriptor(JNIEnv* env, jobject clazz, + jobject fileDescriptor, + jobject padding, + jobject bitmapFactoryOptions) { + NPE_CHECK_RETURN_ZERO(env, fileDescriptor); + + jint descriptor = env->GetIntField(fileDescriptor, + gFileDescriptor_descriptor); + +#ifdef MIN_SIZE_TO_USE_MMAP + // First try to use mmap + size_t size = getFDSize(descriptor); + if (size >= MIN_SIZE_TO_USE_MMAP) { + void* addr = mmap(NULL, size, PROT_READ, MAP_PRIVATE, descriptor, 0); +// SkDebugf("-------- mmap returned %p %d\n", addr, size); + if (MAP_FAILED != addr) { + SkMemoryStream strm(addr, size); + jobject obj = doDecode(env, &strm, padding, bitmapFactoryOptions); + munmap(addr, size); + return obj; + } + } +#endif + + // we pass false for closeWhenDone, since the caller owns the descriptor + SkFDStream file(descriptor, false); + if (!file.isValid()) { + return NULL; + } + + /* Restore our offset when we leave, so the caller doesn't have to. + This is a real feature, so we can be called more than once with the + same descriptor. + */ + AutoFDSeek as(descriptor); + + return doDecode(env, &file, padding, bitmapFactoryOptions); +} + +static jobject nativeDecodeAsset(JNIEnv* env, jobject clazz, + jint native_asset, // Asset + jobject padding, // Rect + jobject options) { // BitmapFactory$Options + AssetStreamAdaptor mystream((Asset*)native_asset); + + return doDecode(env, &mystream, padding, options); +} + +static jobject nativeDecodeByteArray(JNIEnv* env, jobject, jbyteArray byteArray, + int offset, int length, jobject options) { + AutoJavaByteArray ar(env, byteArray); + SkMemoryStream stream(ar.ptr() + offset, length); + + return doDecode(env, &stream, NULL, options); +} + +static void nativeRequestCancel(JNIEnv*, jobject joptions) { + (void)AutoDecoderCancel::RequestCancel(joptions); +} + +/////////////////////////////////////////////////////////////////////////////// + +static JNINativeMethod gMethods[] = { + { "nativeDecodeStream", + "(Ljava/io/InputStream;[BLandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", + (void*)nativeDecodeStream + }, + + { "nativeDecodeFileDescriptor", + "(Ljava/io/FileDescriptor;Landroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", + (void*)nativeDecodeFileDescriptor + }, + + { "nativeDecodeAsset", + "(ILandroid/graphics/Rect;Landroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", + (void*)nativeDecodeAsset + }, + + { "nativeDecodeByteArray", + "([BIILandroid/graphics/BitmapFactory$Options;)Landroid/graphics/Bitmap;", + (void*)nativeDecodeByteArray + } +}; + +static JNINativeMethod gOptionsMethods[] = { + { "requestCancel", "()V", (void*)nativeRequestCancel } +}; + +static jclass make_globalref(JNIEnv* env, const char classname[]) { + jclass c = env->FindClass(classname); + SkASSERT(c); + return (jclass)env->NewGlobalRef(c); +} + +static jfieldID getFieldIDCheck(JNIEnv* env, jclass clazz, + const char fieldname[], const char type[]) { + jfieldID id = env->GetFieldID(clazz, fieldname, type); + SkASSERT(id); + return id; +} + +#define kClassPathName "android/graphics/BitmapFactory" + +#define RETURN_ERR_IF_NULL(value) \ + do { if (!(value)) { assert(0); return -1; } } while (false) + +int register_android_graphics_BitmapFactory(JNIEnv* env); +int register_android_graphics_BitmapFactory(JNIEnv* env) { + gOptions_class = make_globalref(env, "android/graphics/BitmapFactory$Options"); + gOptions_justBoundsFieldID = getFieldIDCheck(env, gOptions_class, "inJustDecodeBounds", "Z"); + gOptions_sampleSizeFieldID = getFieldIDCheck(env, gOptions_class, "inSampleSize", "I"); + gOptions_configFieldID = getFieldIDCheck(env, gOptions_class, "inPreferredConfig", + "Landroid/graphics/Bitmap$Config;"); + gOptions_ditherFieldID = getFieldIDCheck(env, gOptions_class, "inDither", "Z"); + gOptions_widthFieldID = getFieldIDCheck(env, gOptions_class, "outWidth", "I"); + gOptions_heightFieldID = getFieldIDCheck(env, gOptions_class, "outHeight", "I"); + gOptions_mimeFieldID = getFieldIDCheck(env, gOptions_class, "outMimeType", "Ljava/lang/String;"); + + gFileDescriptor_class = make_globalref(env, "java/io/FileDescriptor"); + gFileDescriptor_descriptor = getFieldIDCheck(env, gFileDescriptor_class, "descriptor", "I"); + + int ret = AndroidRuntime::registerNativeMethods(env, + "android/graphics/BitmapFactory$Options", + gOptionsMethods, + SK_ARRAY_COUNT(gOptionsMethods)); + if (ret) { + return ret; + } + return android::AndroidRuntime::registerNativeMethods(env, kClassPathName, + gMethods, SK_ARRAY_COUNT(gMethods)); +} diff --git a/core/jni/android/graphics/Camera.cpp b/core/jni/android/graphics/Camera.cpp new file mode 100644 index 0000000..980003e --- /dev/null +++ b/core/jni/android/graphics/Camera.cpp @@ -0,0 +1,102 @@ +#include "jni.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkCamera.h" + +static jfieldID gNativeInstanceFieldID; + +static void Camera_constructor(JNIEnv* env, jobject obj) { + Sk3DView* view = new Sk3DView; + env->SetIntField(obj, gNativeInstanceFieldID, (int)view); +} + +static void Camera_destructor(JNIEnv* env, jobject obj) { + delete (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); +} + +static void Camera_save(JNIEnv* env, jobject obj) { + Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + v->save(); +} + +static void Camera_restore(JNIEnv* env, jobject obj) { + Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + v->restore(); +} + +static void Camera_translate(JNIEnv* env, jobject obj, + float dx, float dy, float dz) { + Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + v->translate(SkFloatToScalar(dx), SkFloatToScalar(dy), SkFloatToScalar(dz)); +} + +static void Camera_rotateX(JNIEnv* env, jobject obj, float degrees) { + Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + v->rotateX(SkFloatToScalar(degrees)); +} + +static void Camera_rotateY(JNIEnv* env, jobject obj, float degrees) { + Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + v->rotateY(SkFloatToScalar(degrees)); +} + +static void Camera_rotateZ(JNIEnv* env, jobject obj, float degrees) { + Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + v->rotateZ(SkFloatToScalar(degrees)); +} + +static void Camera_getMatrix(JNIEnv* env, jobject obj, int native_matrix) { + Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + v->getMatrix((SkMatrix*)native_matrix); +} + +static void Camera_applyToCanvas(JNIEnv* env, jobject obj, int native_canvas) { + Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + v->applyToCanvas((SkCanvas*)native_canvas); +} + +static float Camera_dotWithNormal(JNIEnv* env, jobject obj, + float x, float y, float z) { + Sk3DView* v = (Sk3DView*)env->GetIntField(obj, gNativeInstanceFieldID); + SkScalar dot = v->dotWithNormal(SkFloatToScalar(x), SkFloatToScalar(y), + SkFloatToScalar(z)); + return SkScalarToFloat(dot); +} + +// ---------------------------------------------------------------------------- + +/* + * JNI registration. + */ +static JNINativeMethod gCameraMethods[] = { + /* name, signature, funcPtr */ + + { "nativeConstructor", "()V", (void*)Camera_constructor }, + { "nativeDestructor", "()V", (void*)Camera_destructor }, + { "save", "()V", (void*)Camera_save }, + { "restore", "()V", (void*)Camera_restore }, + { "translate", "(FFF)V", (void*)Camera_translate }, + { "rotateX", "(F)V", (void*)Camera_rotateX }, + { "rotateY", "(F)V", (void*)Camera_rotateY }, + { "rotateZ", "(F)V", (void*)Camera_rotateZ }, + { "nativeGetMatrix", "(I)V", (void*)Camera_getMatrix }, + { "nativeApplyToCanvas", "(I)V", (void*)Camera_applyToCanvas }, + { "dotWithNormal", "(FFF)F", (void*)Camera_dotWithNormal } +}; + +int register_android_graphics_Camera(JNIEnv* env); +int register_android_graphics_Camera(JNIEnv* env) { + jclass clazz = env->FindClass("android/graphics/Camera"); + if (clazz == 0) { + return -1; + } + gNativeInstanceFieldID = env->GetFieldID(clazz, "native_instance", "I"); + if (gNativeInstanceFieldID == 0) { + return -1; + } + return android::AndroidRuntime::registerNativeMethods(env, + "android/graphics/Camera", + gCameraMethods, + SK_ARRAY_COUNT(gCameraMethods)); +} + diff --git a/core/jni/android/graphics/Canvas.cpp b/core/jni/android/graphics/Canvas.cpp new file mode 100644 index 0000000..841fe49 --- /dev/null +++ b/core/jni/android/graphics/Canvas.cpp @@ -0,0 +1,934 @@ +/* + * Copyright (C) 2006-2007 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. + */ + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkCanvas.h" +#include "SkDevice.h" +#include "SkGLCanvas.h" +#include "SkShader.h" +#include "SkTemplates.h" + +#define TIME_DRAWx + +static uint32_t get_thread_msec() { +#if defined(HAVE_POSIX_CLOCKS) + struct timespec tm; + + clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tm); + + return tm.tv_sec * 1000LL + tm.tv_nsec / 1000000; +#else + struct timeval tv; + + gettimeofday(&tv, NULL); + return tv.tv_sec * 1000LL + tv.tv_usec / 1000; +#endif +} + +namespace android { + +class SkCanvasGlue { +public: + + static void finalizer(JNIEnv* env, jobject clazz, SkCanvas* canvas) { + canvas->unref(); + } + + static SkCanvas* initRaster(JNIEnv* env, jobject, SkBitmap* bitmap) { + return bitmap ? new SkCanvas(*bitmap) : new SkCanvas; + } + + static SkCanvas* initGL(JNIEnv* env, jobject) { + return new SkGLCanvas; + } + + static void freeGlCaches(JNIEnv* env, jobject) { + SkGLCanvas::DeleteAllTextures(); + } + + static jboolean isOpaque(JNIEnv* env, jobject jcanvas) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + + /* + Currently we cannot support transparency in GL-based canvas' at + the view level. Therefore we cannot base our answer on the device's + bitmap, but need to hard-code the answer. If we relax this + limitation in views, we can simplify the following code as well. + + Use the getViewport() call to find out if we're gl-based... + */ + if (canvas->getViewport(NULL)) { + return true; + } + + // normal technique, rely on the device's bitmap for the answer + return canvas->getDevice()->accessBitmap(false).isOpaque(); + } + + static int getWidth(JNIEnv* env, jobject jcanvas) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + return canvas->getDevice()->accessBitmap(false).width(); + } + + static int getHeight(JNIEnv* env, jobject jcanvas) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + return canvas->getDevice()->accessBitmap(false).height(); + } + + static void setViewport(JNIEnv* env, jobject, SkCanvas* canvas, + int width, int height) { + canvas->setViewport(width, height); + } + + static void setBitmap(JNIEnv* env, jobject, SkCanvas* canvas, + SkBitmap* bitmap) { + canvas->setBitmapDevice(*bitmap); + } + + static int saveAll(JNIEnv* env, jobject jcanvas) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(); + } + + static int save(JNIEnv* env, jobject jcanvas, SkCanvas::SaveFlags flags) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + return GraphicsJNI::getNativeCanvas(env, jcanvas)->save(flags); + } + + static int saveLayer(JNIEnv* env, jobject, SkCanvas* canvas, jobject bounds, + SkPaint* paint, int flags) { + SkRect* bounds_ = NULL; + SkRect storage; + if (bounds != NULL) { + GraphicsJNI::jrectf_to_rect(env, bounds, &storage); + bounds_ = &storage; + } + return canvas->saveLayer(bounds_, paint, (SkCanvas::SaveFlags)flags); + } + + static int saveLayer4F(JNIEnv* env, jobject, SkCanvas* canvas, + jfloat l, jfloat t, jfloat r, jfloat b, + SkPaint* paint, int flags) { + SkRect bounds; + bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r), + SkFloatToScalar(b)); + return canvas->saveLayer(&bounds, paint, (SkCanvas::SaveFlags)flags); + } + + static int saveLayerAlpha(JNIEnv* env, jobject, SkCanvas* canvas, + jobject bounds, int alpha, int flags) { + SkRect* bounds_ = NULL; + SkRect storage; + if (bounds != NULL) { + GraphicsJNI::jrectf_to_rect(env, bounds, &storage); + bounds_ = &storage; + } + return canvas->saveLayerAlpha(bounds_, alpha, + (SkCanvas::SaveFlags)flags); + } + + static int saveLayerAlpha4F(JNIEnv* env, jobject, SkCanvas* canvas, + jfloat l, jfloat t, jfloat r, jfloat b, + int alpha, int flags) { + SkRect bounds; + bounds.set(SkFloatToScalar(l), SkFloatToScalar(t), SkFloatToScalar(r), + SkFloatToScalar(b)); + return canvas->saveLayerAlpha(&bounds, alpha, + (SkCanvas::SaveFlags)flags); + } + + static void restore(JNIEnv* env, jobject jcanvas) { + NPE_CHECK_RETURN_VOID(env, jcanvas); + SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + if (canvas->getSaveCount() <= 1) { // cannot restore anymore + doThrowISE(env, "Underflow in restore"); + return; + } + canvas->restore(); + } + + static int getSaveCount(JNIEnv* env, jobject jcanvas) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + return GraphicsJNI::getNativeCanvas(env, jcanvas)->getSaveCount(); + } + + static void restoreToCount(JNIEnv* env, jobject jcanvas, int restoreCount) { + NPE_CHECK_RETURN_VOID(env, jcanvas); + SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + if (restoreCount < 1) { + doThrowIAE(env, "Underflow in restoreToCount"); + return; + } + canvas->restoreToCount(restoreCount); + } + + static void translate(JNIEnv* env, jobject jcanvas, jfloat dx, jfloat dy) { + NPE_CHECK_RETURN_VOID(env, jcanvas); + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->translate(dx_, dy_); + } + + static void scale__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { + NPE_CHECK_RETURN_VOID(env, jcanvas); + SkScalar sx_ = SkFloatToScalar(sx); + SkScalar sy_ = SkFloatToScalar(sy); + (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->scale(sx_, sy_); + } + + static void rotate__F(JNIEnv* env, jobject jcanvas, jfloat degrees) { + NPE_CHECK_RETURN_VOID(env, jcanvas); + SkScalar degrees_ = SkFloatToScalar(degrees); + (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->rotate(degrees_); + } + + static void skew__FF(JNIEnv* env, jobject jcanvas, jfloat sx, jfloat sy) { + NPE_CHECK_RETURN_VOID(env, jcanvas); + SkScalar sx_ = SkFloatToScalar(sx); + SkScalar sy_ = SkFloatToScalar(sy); + (void)GraphicsJNI::getNativeCanvas(env, jcanvas)->skew(sx_, sy_); + } + + static void concat(JNIEnv* env, jobject, SkCanvas* canvas, + const SkMatrix* matrix) { + canvas->concat(*matrix); + } + + static void setMatrix(JNIEnv* env, jobject, SkCanvas* canvas, + const SkMatrix* matrix) { + if (NULL == matrix) { + canvas->resetMatrix(); + } else { + canvas->setMatrix(*matrix); + } + } + + static jboolean clipRect_FFFF(JNIEnv* env, jobject jcanvas, jfloat left, + jfloat top, jfloat right, jfloat bottom) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + SkRect r; + r.set(SkFloatToScalar(left), SkFloatToScalar(top), + SkFloatToScalar(right), SkFloatToScalar(bottom)); + SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); + return c->clipRect(r); + } + + static jboolean clipRect_IIII(JNIEnv* env, jobject jcanvas, jint left, + jint top, jint right, jint bottom) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + SkRect r; + r.set(SkIntToScalar(left), SkIntToScalar(top), + SkIntToScalar(right), SkIntToScalar(bottom)); + return GraphicsJNI::getNativeCanvas(env, jcanvas)->clipRect(r); + } + + static jboolean clipRect_RectF(JNIEnv* env, jobject jcanvas, jobject rectf) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + NPE_CHECK_RETURN_ZERO(env, rectf); + SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); + SkRect tmp; + return c->clipRect(*GraphicsJNI::jrectf_to_rect(env, rectf, &tmp)); + } + + static jboolean clipRect_Rect(JNIEnv* env, jobject jcanvas, jobject rect) { + NPE_CHECK_RETURN_ZERO(env, jcanvas); + NPE_CHECK_RETURN_ZERO(env, rect); + SkCanvas* c = GraphicsJNI::getNativeCanvas(env, jcanvas); + SkRect tmp; + return c->clipRect(*GraphicsJNI::jrect_to_rect(env, rect, &tmp)); + } + + static jboolean clipRect(JNIEnv* env, jobject, SkCanvas* canvas, + float left, float top, float right, float bottom, + int op) { + SkRect rect; + rect.set(SkFloatToScalar(left), SkFloatToScalar(top), + SkFloatToScalar(right), SkFloatToScalar(bottom)); + return canvas->clipRect(rect, (SkRegion::Op)op); + } + + static jboolean clipPath(JNIEnv* env, jobject, SkCanvas* canvas, + SkPath* path, int op) { + return canvas->clipPath(*path, (SkRegion::Op)op); + } + + static jboolean clipRegion(JNIEnv* env, jobject, SkCanvas* canvas, + SkRegion* deviceRgn, int op) { + return canvas->clipRegion(*deviceRgn, (SkRegion::Op)op); + } + + static void setDrawFilter(JNIEnv* env, jobject, SkCanvas* canvas, + SkDrawFilter* filter) { + canvas->setDrawFilter(filter); + } + + static jboolean quickReject__RectFI(JNIEnv* env, jobject, SkCanvas* canvas, + jobject rect, int edgetype) { + SkRect rect_; + GraphicsJNI::jrectf_to_rect(env, rect, &rect_); + return canvas->quickReject(rect_, (SkCanvas::EdgeType)edgetype); + } + + static jboolean quickReject__PathI(JNIEnv* env, jobject, SkCanvas* canvas, + SkPath* path, int edgetype) { + return canvas->quickReject(*path, (SkCanvas::EdgeType)edgetype); + } + + static jboolean quickReject__FFFFI(JNIEnv* env, jobject, SkCanvas* canvas, + jfloat left, jfloat top, jfloat right, + jfloat bottom, int edgetype) { + SkRect r; + r.set(SkFloatToScalar(left), SkFloatToScalar(top), + SkFloatToScalar(right), SkFloatToScalar(bottom)); + return canvas->quickReject(r, (SkCanvas::EdgeType)edgetype); + } + + static void drawRGB(JNIEnv* env, jobject, SkCanvas* canvas, + jint r, jint g, jint b) { + canvas->drawARGB(0xFF, r, g, b); + } + + static void drawARGB(JNIEnv* env, jobject, SkCanvas* canvas, + jint a, jint r, jint g, jint b) { + canvas->drawARGB(a, r, g, b); + } + + static void drawColor__I(JNIEnv* env, jobject, SkCanvas* canvas, + jint color) { + canvas->drawColor(color); + } + + static void drawColor__II(JNIEnv* env, jobject, SkCanvas* canvas, + jint color, SkPorterDuff::Mode mode) { + canvas->drawColor(color, mode); + } + + static void drawPaint(JNIEnv* env, jobject, SkCanvas* canvas, + SkPaint* paint) { + canvas->drawPaint(*paint); + } + + static void doPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, + jint offset, jint count, jobject jpaint, + SkCanvas::PointMode mode) { + NPE_CHECK_RETURN_VOID(env, jcanvas); + NPE_CHECK_RETURN_VOID(env, jptsArray); + NPE_CHECK_RETURN_VOID(env, jpaint); + SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint); + + AutoJavaFloatArray autoPts(env, jptsArray); + float* floats = autoPts.ptr(); + const int length = autoPts.length(); + + if ((offset | count) < 0 || offset + count > length) { + doThrowAIOOBE(env); + return; + } + + // now convert the floats into SkPoints + count >>= 1; // now it is the number of points + SkAutoSTMalloc<32, SkPoint> storage(count); + SkPoint* pts = storage.get(); + const float* src = floats + offset; + for (int i = 0; i < count; i++) { + pts[i].set(SkFloatToScalar(src[0]), SkFloatToScalar(src[1])); + src += 2; + } + canvas->drawPoints(mode, count, pts, paint); + } + + static void drawPoints(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, + jint offset, jint count, jobject jpaint) { + doPoints(env, jcanvas, jptsArray, offset, count, jpaint, + SkCanvas::kPoints_PointMode); + } + + static void drawLines(JNIEnv* env, jobject jcanvas, jfloatArray jptsArray, + jint offset, jint count, jobject jpaint) { + doPoints(env, jcanvas, jptsArray, offset, count, jpaint, + SkCanvas::kLines_PointMode); + } + + static void drawPoint(JNIEnv* env, jobject jcanvas, float x, float y, + jobject jpaint) { + NPE_CHECK_RETURN_VOID(env, jcanvas); + NPE_CHECK_RETURN_VOID(env, jpaint); + SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + const SkPaint& paint = *GraphicsJNI::getNativePaint(env, jpaint); + + canvas->drawPoint(SkFloatToScalar(x), SkFloatToScalar(y), paint); + } + + static void drawLine__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, + jfloat startX, jfloat startY, jfloat stopX, + jfloat stopY, SkPaint* paint) { + canvas->drawLine(SkFloatToScalar(startX), SkFloatToScalar(startY), + SkFloatToScalar(stopX), SkFloatToScalar(stopY), + *paint); + } + + static void drawRect__RectFPaint(JNIEnv* env, jobject, SkCanvas* canvas, + jobject rect, SkPaint* paint) { + SkRect rect_; + GraphicsJNI::jrectf_to_rect(env, rect, &rect_); + canvas->drawRect(rect_, *paint); + } + + static void drawRect__FFFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, + jfloat left, jfloat top, jfloat right, + jfloat bottom, SkPaint* paint) { + SkScalar left_ = SkFloatToScalar(left); + SkScalar top_ = SkFloatToScalar(top); + SkScalar right_ = SkFloatToScalar(right); + SkScalar bottom_ = SkFloatToScalar(bottom); + canvas->drawRectCoords(left_, top_, right_, bottom_, *paint); + } + + static void drawOval(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval, + SkPaint* paint) { + SkRect oval; + GraphicsJNI::jrectf_to_rect(env, joval, &oval); + canvas->drawOval(oval, *paint); + } + + static void drawCircle(JNIEnv* env, jobject, SkCanvas* canvas, jfloat cx, + jfloat cy, jfloat radius, SkPaint* paint) { + canvas->drawCircle(SkFloatToScalar(cx), SkFloatToScalar(cy), + SkFloatToScalar(radius), *paint); + } + + static void drawArc(JNIEnv* env, jobject, SkCanvas* canvas, jobject joval, + jfloat startAngle, jfloat sweepAngle, + jboolean useCenter, SkPaint* paint) { + SkRect oval; + GraphicsJNI::jrectf_to_rect(env, joval, &oval); + canvas->drawArc(oval, SkFloatToScalar(startAngle), + SkFloatToScalar(sweepAngle), useCenter, *paint); + } + + static void drawRoundRect(JNIEnv* env, jobject, SkCanvas* canvas, + jobject jrect, jfloat rx, jfloat ry, + SkPaint* paint) { + SkRect rect; + GraphicsJNI::jrectf_to_rect(env, jrect, &rect); + canvas->drawRoundRect(rect, SkFloatToScalar(rx), SkFloatToScalar(ry), + *paint); + } + + static void drawPath(JNIEnv* env, jobject, SkCanvas* canvas, SkPath* path, + SkPaint* paint) { + canvas->drawPath(*path, *paint); + } + + static void drawPicture(JNIEnv* env, jobject, SkCanvas* canvas, + SkPicture* picture) { + SkASSERT(canvas); + SkASSERT(picture); + +#ifdef TIME_DRAW + SkMSec now = get_thread_msec(); //SkTime::GetMSecs(); +#endif + canvas->drawPicture(*picture); +#ifdef TIME_DRAW + LOGD("---- picture playback %d ms\n", get_thread_msec() - now); +#endif + } + + static void drawBitmap__BitmapFFPaint(JNIEnv* env, jobject, + SkCanvas* canvas, SkBitmap* bitmap, + jfloat left, jfloat top, + SkPaint* paint) { + SkScalar left_ = SkFloatToScalar(left); + SkScalar top_ = SkFloatToScalar(top); + canvas->drawBitmap(*bitmap, left_, top_, paint); + } + + static void doDrawBitmap(JNIEnv* env, SkCanvas* canvas, SkBitmap* bitmap, + jobject srcIRect, const SkRect& dst, SkPaint* paint) { + SkIRect src, *srcPtr = NULL; + + if (NULL != srcIRect) { + GraphicsJNI::jrect_to_irect(env, srcIRect, &src); + srcPtr = &src; + } + canvas->drawBitmapRect(*bitmap, srcPtr, dst, paint); + } + + static void drawBitmapRF(JNIEnv* env, jobject, SkCanvas* canvas, + SkBitmap* bitmap, jobject srcIRect, + jobject dstRectF, SkPaint* paint) { + SkRect dst; + GraphicsJNI::jrectf_to_rect(env, dstRectF, &dst); + doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint); + } + + static void drawBitmapRR(JNIEnv* env, jobject, SkCanvas* canvas, + SkBitmap* bitmap, jobject srcIRect, + jobject dstRect, SkPaint* paint) { + SkRect dst; + GraphicsJNI::jrect_to_rect(env, dstRect, &dst); + doDrawBitmap(env, canvas, bitmap, srcIRect, dst, paint); + } + + static void drawBitmapArray(JNIEnv* env, jobject, SkCanvas* canvas, + jintArray jcolors, int offset, int stride, + int x, int y, int width, int height, + jboolean hasAlpha, SkPaint* paint) + { + SkBitmap bitmap; + + bitmap.setConfig(hasAlpha ? SkBitmap::kARGB_8888_Config : + SkBitmap::kRGB_565_Config, width, height); + if (!bitmap.allocPixels()) { + return; + } + + if (!GraphicsJNI::SetPixels(env, jcolors, offset, stride, + 0, 0, width, height, bitmap)) { + return; + } + + canvas->drawBitmap(bitmap, SkIntToScalar(x), SkIntToScalar(y), paint); + } + + static void drawBitmapMatrix(JNIEnv* env, jobject, SkCanvas* canvas, + const SkBitmap* bitmap, const SkMatrix* matrix, + const SkPaint* paint) { + canvas->drawBitmapMatrix(*bitmap, *matrix, paint); + } + + static void drawBitmapMesh(JNIEnv* env, jobject, SkCanvas* canvas, + const SkBitmap* bitmap, int meshWidth, int meshHeight, + jfloatArray jverts, int vertIndex, jintArray jcolors, + int colorIndex, const SkPaint* paint) { + + const int ptCount = (meshWidth + 1) * (meshHeight + 1); + const int indexCount = meshWidth * meshHeight * 6; + + AutoJavaFloatArray vertA(env, jverts, vertIndex + (ptCount << 1)); + AutoJavaIntArray colorA(env, jcolors, colorIndex + ptCount); + + /* Our temp storage holds 2 or 3 arrays. + texture points [ptCount * sizeof(SkPoint)] + optionally vertex points [ptCount * sizeof(SkPoint)] if we need a + copy to convert from float to fixed + indices [ptCount * sizeof(uint16_t)] + */ + ssize_t storageSize = ptCount * sizeof(SkPoint); // texs[] +#ifdef SK_SCALAR_IS_FIXED + storageSize += ptCount * sizeof(SkPoint); // storage for verts +#endif + storageSize += indexCount * sizeof(uint16_t); // indices[] + + SkAutoMalloc storage(storageSize); + SkPoint* texs = (SkPoint*)storage.get(); + SkPoint* verts; + uint16_t* indices; +#ifdef SK_SCALAR_IS_FLOAT + verts = (SkPoint*)(vertA.ptr() + vertIndex); + indices = (uint16_t*)(texs + ptCount); +#else + verts = texs + ptCount; + indices = (uint16_t*)(verts + ptCount); + // convert floats to fixed + { + const float* src = vertA.ptr() + vertIndex; + for (int i = 0; i < ptCount; i++) { + verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1])); + src += 2; + } + } +#endif + + // cons up texture coordinates and indices + { + const SkScalar w = SkIntToScalar(bitmap->width()); + const SkScalar h = SkIntToScalar(bitmap->height()); + const SkScalar dx = w / meshWidth; + const SkScalar dy = h / meshHeight; + + SkPoint* texsPtr = texs; + SkScalar y = 0; + for (int i = 0; i <= meshHeight; i++) { + if (i == meshHeight) { + y = h; // to ensure numerically we hit h exactly + } + SkScalar x = 0; + for (int j = 0; j < meshWidth; j++) { + texsPtr->set(x, y); + texsPtr += 1; + x += dx; + } + texsPtr->set(w, y); + texsPtr += 1; + y += dy; + } + SkASSERT(texsPtr - texs == ptCount); + } + + // cons up indices + { + uint16_t* indexPtr = indices; + int index = 0; + for (int i = 0; i < meshHeight; i++) { + for (int j = 0; j < meshWidth; j++) { + // lower-left triangle + *indexPtr++ = index; + *indexPtr++ = index + meshWidth + 1; + *indexPtr++ = index + meshWidth + 2; + // upper-right triangle + *indexPtr++ = index; + *indexPtr++ = index + meshWidth + 2; + *indexPtr++ = index + 1; + // bump to the next cell + index += 1; + } + // bump to the next row + index += 1; + } + SkASSERT(indexPtr - indices == indexCount); + SkASSERT((char*)indexPtr - (char*)storage.get() == storageSize); + } + + // double-check that we have legal indices +#ifdef SK_DEBUG + { + for (int i = 0; i < indexCount; i++) { + SkASSERT((unsigned)indices[i] < (unsigned)ptCount); + } + } +#endif + + // cons-up a shader for the bitmap + SkPaint tmpPaint; + if (paint) { + tmpPaint = *paint; + } + SkShader* shader = SkShader::CreateBitmapShader(*bitmap, + SkShader::kClamp_TileMode, SkShader::kClamp_TileMode); + tmpPaint.setShader(shader)->safeUnref(); + + canvas->drawVertices(SkCanvas::kTriangles_VertexMode, ptCount, verts, + texs, (const SkColor*)colorA.ptr(), NULL, indices, + indexCount, tmpPaint); + } + + static void drawVertices(JNIEnv* env, jobject, SkCanvas* canvas, + SkCanvas::VertexMode mode, int vertexCount, + jfloatArray jverts, int vertIndex, + jfloatArray jtexs, int texIndex, + jintArray jcolors, int colorIndex, + jshortArray jindices, int indexIndex, + int indexCount, const SkPaint* paint) { + + AutoJavaFloatArray vertA(env, jverts, vertIndex + vertexCount); + AutoJavaFloatArray texA(env, jtexs, texIndex + vertexCount); + AutoJavaIntArray colorA(env, jcolors, colorIndex + vertexCount); + AutoJavaShortArray indexA(env, jindices, indexIndex + indexCount); + + const int ptCount = vertexCount >> 1; + + SkPoint* verts; + SkPoint* texs = NULL; +#ifdef SK_SCALAR_IS_FLOAT + verts = (SkPoint*)(vertA.ptr() + vertIndex); + if (jtexs != NULL) { + texs = (SkPoint*)(texA.ptr() + texIndex); + } +#else + int count = ptCount; // for verts + if (jtexs != NULL) { + count += ptCount; // += for texs + } + SkAutoMalloc storage(count * sizeof(SkPoint)); + verts = (SkPoint*)storage.get(); + const float* src = vertA.ptr() + vertIndex; + for (int i = 0; i < ptCount; i++) { + verts[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1])); + src += 2; + } + if (jtexs != NULL) { + texs = verts + ptCount; + src = texA.ptr() + texIndex; + for (int i = 0; i < ptCount; i++) { + texs[i].set(SkFloatToFixed(src[0]), SkFloatToFixed(src[1])); + src += 2; + } + } +#endif + + const SkColor* colors = NULL; + const uint16_t* indices = NULL; + if (jcolors != NULL) { + colors = (const SkColor*)(colorA.ptr() + colorIndex); + } + if (jindices != NULL) { + indices = (const uint16_t*)(indexA.ptr() + indexIndex); + } + + canvas->drawVertices(mode, ptCount, verts, texs, colors, NULL, + indices, indexCount, *paint); + } + + static void drawText___CIIFFPaint(JNIEnv* env, jobject, SkCanvas* canvas, + jcharArray text, int index, int count, + jfloat x, jfloat y, SkPaint* paint) { + jchar* textArray = env->GetCharArrayElements(text, NULL); + jsize textCount = env->GetArrayLength(text); + SkScalar x_ = SkFloatToScalar(x); + SkScalar y_ = SkFloatToScalar(y); + textArray += index; + canvas->drawText(textArray, count << 1, x_, y_, *paint); + env->ReleaseCharArrayElements(text, textArray, 0); + } + + static void drawText__StringIIFFPaint(JNIEnv* env, jobject, + SkCanvas* canvas, jstring text, int start, int end, + jfloat x, jfloat y, SkPaint* paint) { + const void* text_ = env->GetStringChars(text, NULL); + SkScalar x_ = SkFloatToScalar(x); + SkScalar y_ = SkFloatToScalar(y); + canvas->drawText((const uint16_t*)text_ + start, (end - start) << 1, + x_, y_, *paint); + env->ReleaseStringChars(text, (const jchar*) text_); + } + + static void drawString(JNIEnv* env, jobject canvas, jstring text, + jfloat x, jfloat y, jobject paint) { + NPE_CHECK_RETURN_VOID(env, canvas); + NPE_CHECK_RETURN_VOID(env, paint); + NPE_CHECK_RETURN_VOID(env, text); + size_t count = env->GetStringLength(text); + if (0 == count) { + return; + } + const jchar* text_ = env->GetStringChars(text, NULL); + SkCanvas* c = GraphicsJNI::getNativeCanvas(env, canvas); + c->drawText(text_, count << 1, SkFloatToScalar(x), SkFloatToScalar(y), + *GraphicsJNI::getNativePaint(env, paint)); + env->ReleaseStringChars(text, text_); + } + + static void drawPosText___CII_FPaint(JNIEnv* env, jobject, SkCanvas* canvas, + jcharArray text, int index, int count, + jfloatArray pos, SkPaint* paint) { + jchar* textArray = text ? env->GetCharArrayElements(text, NULL) : NULL; + jsize textCount = text ? env->GetArrayLength(text) : NULL; + float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; + int posCount = pos ? env->GetArrayLength(pos) >> 1: 0; + SkPoint* posPtr = posCount > 0 ? new SkPoint[posCount] : NULL; + int indx; + for (indx = 0; indx < posCount; indx++) { + posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]); + posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]); + } + textArray += index; + canvas->drawPosText(textArray, count << 1, posPtr, *paint); + if (text) { + env->ReleaseCharArrayElements(text, textArray, 0); + } + if (pos) { + env->ReleaseFloatArrayElements(pos, posArray, 0); + } + delete[] posPtr; + } + + static void drawPosText__String_FPaint(JNIEnv* env, jobject, + SkCanvas* canvas, jstring text, + jfloatArray pos, SkPaint* paint) { + const void* text_ = text ? env->GetStringChars(text, NULL) : NULL; + int byteLength = text ? env->GetStringLength(text) : 0; + float* posArray = pos ? env->GetFloatArrayElements(pos, NULL) : NULL; + int posCount = pos ? env->GetArrayLength(pos) >> 1: 0; + SkPoint* posPtr = posCount > 0 ? new SkPoint[posCount] : NULL; + + for (int indx = 0; indx < posCount; indx++) { + posPtr[indx].fX = SkFloatToScalar(posArray[indx << 1]); + posPtr[indx].fY = SkFloatToScalar(posArray[(indx << 1) + 1]); + } + canvas->drawPosText(text_, byteLength << 1, posPtr, *paint); + if (text) { + env->ReleaseStringChars(text, (const jchar*) text_); + } + if (pos) { + env->ReleaseFloatArrayElements(pos, posArray, 0); + } + delete[] posPtr; + } + + static void drawTextOnPath___CIIPathFFPaint(JNIEnv* env, jobject, + SkCanvas* canvas, jcharArray text, int index, int count, + SkPath* path, jfloat hOffset, jfloat vOffset, SkPaint* paint) { + + jchar* textArray = env->GetCharArrayElements(text, NULL); + canvas->drawTextOnPathHV(textArray + index, count << 1, *path, + SkFloatToScalar(hOffset), SkFloatToScalar(vOffset), *paint); + env->ReleaseCharArrayElements(text, textArray, 0); + } + + static void drawTextOnPath__StringPathFFPaint(JNIEnv* env, jobject, + SkCanvas* canvas, jstring text, SkPath* path, + jfloat hOffset, jfloat vOffset, SkPaint* paint) { + const jchar* text_ = env->GetStringChars(text, NULL); + int byteLength = env->GetStringLength(text) << 1; + canvas->drawTextOnPathHV(text_, byteLength, *path, + SkFloatToScalar(hOffset), SkFloatToScalar(vOffset), *paint); + env->ReleaseStringChars(text, text_); + } + + static bool getClipBounds(JNIEnv* env, jobject, SkCanvas* canvas, + jobject bounds) { + SkRect r; + SkIRect ir; + bool result = canvas->getClipBounds(&r); + + r.round(&ir); + (void)GraphicsJNI::irect_to_jrect(ir, env, bounds); + return result; + } + + static void getCTM(JNIEnv* env, jobject, SkCanvas* canvas, + SkMatrix* matrix) { + *matrix = canvas->getTotalMatrix(); + } +}; + +/////////////////////////////////////////////////////////////////////////////// + +static JNINativeMethod gCanvasMethods[] = { + {"finalizer", "(I)V", (void*) SkCanvasGlue::finalizer}, + {"initRaster","(I)I", (void*) SkCanvasGlue::initRaster}, + {"initGL","()I", (void*) SkCanvasGlue::initGL}, + {"isOpaque","()Z", (void*) SkCanvasGlue::isOpaque}, + {"getWidth","()I", (void*) SkCanvasGlue::getWidth}, + {"getHeight","()I", (void*) SkCanvasGlue::getHeight}, + {"native_setBitmap","(II)V", (void*) SkCanvasGlue::setBitmap}, + {"nativeSetViewport", "(III)V", (void*) SkCanvasGlue::setViewport}, + {"save","()I", (void*) SkCanvasGlue::saveAll}, + {"save","(I)I", (void*) SkCanvasGlue::save}, + {"native_saveLayer","(ILandroid/graphics/RectF;II)I", + (void*) SkCanvasGlue::saveLayer}, + {"native_saveLayer","(IFFFFII)I", (void*) SkCanvasGlue::saveLayer4F}, + {"native_saveLayerAlpha","(ILandroid/graphics/RectF;II)I", + (void*) SkCanvasGlue::saveLayerAlpha}, + {"native_saveLayerAlpha","(IFFFFII)I", + (void*) SkCanvasGlue::saveLayerAlpha4F}, + {"restore","()V", (void*) SkCanvasGlue::restore}, + {"getSaveCount","()I", (void*) SkCanvasGlue::getSaveCount}, + {"restoreToCount","(I)V", (void*) SkCanvasGlue::restoreToCount}, + {"translate","(FF)V", (void*) SkCanvasGlue::translate}, + {"scale","(FF)V", (void*) SkCanvasGlue::scale__FF}, + {"rotate","(F)V", (void*) SkCanvasGlue::rotate__F}, + {"skew","(FF)V", (void*) SkCanvasGlue::skew__FF}, + {"native_concat","(II)V", (void*) SkCanvasGlue::concat}, + {"native_setMatrix","(II)V", (void*) SkCanvasGlue::setMatrix}, + {"clipRect","(FFFF)Z", (void*) SkCanvasGlue::clipRect_FFFF}, + {"clipRect","(IIII)Z", (void*) SkCanvasGlue::clipRect_IIII}, + {"clipRect","(Landroid/graphics/RectF;)Z", + (void*) SkCanvasGlue::clipRect_RectF}, + {"clipRect","(Landroid/graphics/Rect;)Z", + (void*) SkCanvasGlue::clipRect_Rect}, + {"native_clipRect","(IFFFFI)Z", (void*) SkCanvasGlue::clipRect}, + {"native_clipPath","(III)Z", (void*) SkCanvasGlue::clipPath}, + {"native_clipRegion","(III)Z", (void*) SkCanvasGlue::clipRegion}, + {"nativeSetDrawFilter", "(II)V", (void*) SkCanvasGlue::setDrawFilter}, + {"native_getClipBounds","(ILandroid/graphics/Rect;)Z", + (void*) SkCanvasGlue::getClipBounds}, + {"native_getCTM", "(II)V", (void*)SkCanvasGlue::getCTM}, + {"native_quickReject","(ILandroid/graphics/RectF;I)Z", + (void*) SkCanvasGlue::quickReject__RectFI}, + {"native_quickReject","(III)Z", (void*) SkCanvasGlue::quickReject__PathI}, + {"native_quickReject","(IFFFFI)Z", (void*)SkCanvasGlue::quickReject__FFFFI}, + {"native_drawRGB","(IIII)V", (void*) SkCanvasGlue::drawRGB}, + {"native_drawARGB","(IIIII)V", (void*) SkCanvasGlue::drawARGB}, + {"native_drawColor","(II)V", (void*) SkCanvasGlue::drawColor__I}, + {"native_drawColor","(III)V", (void*) SkCanvasGlue::drawColor__II}, + {"native_drawPaint","(II)V", (void*) SkCanvasGlue::drawPaint}, + {"drawPoint", "(FFLandroid/graphics/Paint;)V", + (void*) SkCanvasGlue::drawPoint}, + {"drawPoints", "([FIILandroid/graphics/Paint;)V", + (void*) SkCanvasGlue::drawPoints}, + {"drawLines", "([FIILandroid/graphics/Paint;)V", + (void*) SkCanvasGlue::drawLines}, + {"native_drawLine","(IFFFFI)V", (void*) SkCanvasGlue::drawLine__FFFFPaint}, + {"native_drawRect","(ILandroid/graphics/RectF;I)V", + (void*) SkCanvasGlue::drawRect__RectFPaint}, + {"native_drawRect","(IFFFFI)V", (void*) SkCanvasGlue::drawRect__FFFFPaint}, + {"native_drawOval","(ILandroid/graphics/RectF;I)V", + (void*) SkCanvasGlue::drawOval}, + {"native_drawCircle","(IFFFI)V", (void*) SkCanvasGlue::drawCircle}, + {"native_drawArc","(ILandroid/graphics/RectF;FFZI)V", + (void*) SkCanvasGlue::drawArc}, + {"native_drawRoundRect","(ILandroid/graphics/RectF;FFI)V", + (void*) SkCanvasGlue::drawRoundRect}, + {"native_drawPath","(III)V", (void*) SkCanvasGlue::drawPath}, + {"native_drawBitmap","(IIFFI)V", + (void*) SkCanvasGlue::drawBitmap__BitmapFFPaint}, + {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/RectF;I)V", + (void*) SkCanvasGlue::drawBitmapRF}, + {"native_drawBitmap","(IILandroid/graphics/Rect;Landroid/graphics/Rect;I)V", + (void*) SkCanvasGlue::drawBitmapRR}, + {"native_drawBitmap", "(I[IIIIIIIZI)V", + (void*)SkCanvasGlue::drawBitmapArray}, + + {"nativeDrawBitmapMatrix", "(IIII)V", + (void*)SkCanvasGlue::drawBitmapMatrix}, + {"nativeDrawBitmapMesh", "(IIII[FI[III)V", + (void*)SkCanvasGlue::drawBitmapMesh}, + {"nativeDrawVertices", "(III[FI[FI[II[SIII)V", + (void*)SkCanvasGlue::drawVertices}, + {"native_drawText","(I[CIIFFI)V", + (void*) SkCanvasGlue::drawText___CIIFFPaint}, + {"native_drawText","(ILjava/lang/String;IIFFI)V", + (void*) SkCanvasGlue::drawText__StringIIFFPaint}, + {"drawText","(Ljava/lang/String;FFLandroid/graphics/Paint;)V", + (void*) SkCanvasGlue::drawString}, + {"native_drawPosText","(I[CII[FI)V", + (void*) SkCanvasGlue::drawPosText___CII_FPaint}, + {"native_drawPosText","(ILjava/lang/String;[FI)V", + (void*) SkCanvasGlue::drawPosText__String_FPaint}, + {"native_drawTextOnPath","(I[CIIIFFI)V", + (void*) SkCanvasGlue::drawTextOnPath___CIIPathFFPaint}, + {"native_drawTextOnPath","(ILjava/lang/String;IFFI)V", + (void*) SkCanvasGlue::drawTextOnPath__StringPathFFPaint}, + {"native_drawPicture", "(II)V", (void*) SkCanvasGlue::drawPicture}, + + {"freeGlCaches", "()V", (void*) SkCanvasGlue::freeGlCaches} +}; + +#include <android_runtime/AndroidRuntime.h> + +#define REG(env, name, array) \ + result = android::AndroidRuntime::registerNativeMethods(env, name, array, \ + SK_ARRAY_COUNT(array)); \ + if (result < 0) return result + +int register_android_graphics_Canvas(JNIEnv* env) { + int result; + + REG(env, "android/graphics/Canvas", gCanvasMethods); + + return result; +} + +} diff --git a/core/jni/android/graphics/ColorFilter.cpp b/core/jni/android/graphics/ColorFilter.cpp new file mode 100644 index 0000000..b6ec4a2 --- /dev/null +++ b/core/jni/android/graphics/ColorFilter.cpp @@ -0,0 +1,98 @@ +/* libs/android_runtime/android/graphics/ColorFilter.cpp +** +** Copyright 2006, 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. +*/ + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkColorFilter.h" +#include "SkColorMatrixFilter.h" + +namespace android { + +class SkColorFilterGlue { +public: + + static void finalizer(JNIEnv* env, jobject clazz, SkColorFilter* obj) { + obj->safeUnref(); + } + + static SkColorFilter* CreatePorterDuffFilter(JNIEnv* env, jobject, + jint srcColor, SkPorterDuff::Mode porterDuffMode) { + return SkColorFilter::CreatePorterDuffFilter(srcColor, porterDuffMode); + } + + static SkColorFilter* CreateLightingFilter(JNIEnv* env, jobject, + jint mul, jint add) { + return SkColorFilter::CreateLightingFilter(mul, add); + } + + static SkColorFilter* CreateColorMatrixFilter(JNIEnv* env, jobject, + jfloatArray jarray) { + AutoJavaFloatArray autoArray(env, jarray, 20); + const float* src = autoArray.ptr(); + +#ifdef SK_SCALAR_IS_FIXED + SkFixed array[20]; + for (int i = 0; i < 20; i++) { + array[i] = SkFloatToScalar(src[i]); + } + return new SkColorMatrixFilter(array); +#else + return new SkColorMatrixFilter(src); +#endif + } + +}; + +static JNINativeMethod colorfilter_methods[] = { + {"finalizer", "(I)V", (void*) SkColorFilterGlue::finalizer} +}; + +static JNINativeMethod porterduff_methods[] = { + {"native_CreatePorterDuffFilter","(II)I", + (void*) SkColorFilterGlue::CreatePorterDuffFilter} +}; + +static JNINativeMethod lighting_methods[] = { + {"native_CreateLightingFilter","(II)I", + (void*) SkColorFilterGlue::CreateLightingFilter} +}; + +static JNINativeMethod colormatrix_methods[] = { + {"nativeColorMatrixFilter","([F)I", + (void*) SkColorFilterGlue::CreateColorMatrixFilter} +}; + +#define REG(env, name, array) \ + result = android::AndroidRuntime::registerNativeMethods(env, name, array, \ + SK_ARRAY_COUNT(array)); \ + if (result < 0) return result + + +int register_android_graphics_ColorFilter(JNIEnv* env) { + int result; + + REG(env, "android/graphics/ColorFilter", colorfilter_methods); + REG(env, "android/graphics/PorterDuffColorFilter", porterduff_methods); + REG(env, "android/graphics/LightingColorFilter", lighting_methods); + REG(env, "android/graphics/ColorMatrixColorFilter", colormatrix_methods); + + return 0; +} + +} diff --git a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp new file mode 100644 index 0000000..002fdf9 --- /dev/null +++ b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.cpp @@ -0,0 +1,212 @@ +#include "CreateJavaOutputStreamAdaptor.h" + +#define RETURN_NULL_IF_NULL(value) \ + do { if (!(value)) { SkASSERT(0); return NULL; } } while (false) + +static jclass gInputStream_Clazz; +static jmethodID gInputStream_resetMethodID; +static jmethodID gInputStream_availableMethodID; +static jmethodID gInputStream_readMethodID; +static jmethodID gInputStream_skipMethodID; + +class JavaInputStreamAdaptor : public SkStream { +public: + JavaInputStreamAdaptor(JNIEnv* env, jobject js, jbyteArray ar) + : fEnv(env), fJavaInputStream(js), fJavaByteArray(ar) { + SkASSERT(ar); + fCapacity = env->GetArrayLength(ar); + SkASSERT(fCapacity > 0); + fBytesRead = 0; + } + + virtual bool rewind() { + JNIEnv* env = fEnv; + + fBytesRead = 0; + + env->CallVoidMethod(fJavaInputStream, gInputStream_resetMethodID); + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + env->ExceptionClear(); + printf("------- reset threw an exception\n"); + return false; + } + return true; + } + + virtual size_t read(void* buffer, size_t size) { + JNIEnv* env = fEnv; + + if (buffer == NULL && size == 0) { + jint avail = env->CallIntMethod(fJavaInputStream, + gInputStream_availableMethodID); + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + env->ExceptionClear(); + printf("------- available threw an exception\n"); + avail = 0; + } + return avail; + } + + size_t bytesRead = 0; + + if (buffer == NULL) { // skip + jlong skipped = env->CallLongMethod(fJavaInputStream, + gInputStream_skipMethodID, (jlong)size); + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + env->ExceptionClear(); + printf("------- available threw an exception\n"); + return 0; + } + if (skipped < 0) { + return 0; + } + return (size_t)skipped; + } + + // read the bytes + do { + size_t requested = size; + if (requested > fCapacity) + requested = fCapacity; + + jint n = env->CallIntMethod(fJavaInputStream, + gInputStream_readMethodID, fJavaByteArray, 0, requested); + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + env->ExceptionClear(); + printf("---- read threw an exception\n"); + return 0; + } + + if (n <= 0) { + break; // eof + } + + jbyte* array = env->GetByteArrayElements(fJavaByteArray, NULL); + memcpy(buffer, array, n); + env->ReleaseByteArrayElements(fJavaByteArray, array, 0); + + buffer = (void*)((char*)buffer + n); + bytesRead += n; + size -= n; + fBytesRead += n; + } while (size != 0); + + return bytesRead; + } + +private: + JNIEnv* fEnv; + jobject fJavaInputStream; // the caller owns this object + jbyteArray fJavaByteArray; // the caller owns this object + size_t fCapacity; + size_t fBytesRead; +}; + +SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream, + jbyteArray storage) { + static bool gInited; + + if (!gInited) { + gInputStream_Clazz = env->FindClass("java/io/InputStream"); + RETURN_NULL_IF_NULL(gInputStream_Clazz); + gInputStream_Clazz = (jclass)env->NewGlobalRef(gInputStream_Clazz); + + gInputStream_resetMethodID = env->GetMethodID(gInputStream_Clazz, + "reset", "()V"); + gInputStream_availableMethodID = env->GetMethodID(gInputStream_Clazz, + "available", "()I"); + gInputStream_readMethodID = env->GetMethodID(gInputStream_Clazz, + "read", "([BII)I"); + gInputStream_skipMethodID = env->GetMethodID(gInputStream_Clazz, + "skip", "(J)J"); + + RETURN_NULL_IF_NULL(gInputStream_resetMethodID); + RETURN_NULL_IF_NULL(gInputStream_availableMethodID); + RETURN_NULL_IF_NULL(gInputStream_availableMethodID); + RETURN_NULL_IF_NULL(gInputStream_skipMethodID); + + gInited = true; + } + + return new JavaInputStreamAdaptor(env, stream, storage); +} + +/////////////////////////////////////////////////////////////////////////////// + +static jclass gOutputStream_Clazz; +static jmethodID gOutputStream_writeMethodID; +static jmethodID gOutputStream_flushMethodID; + +class SkJavaOutputStream : public SkWStream { +public: + SkJavaOutputStream(JNIEnv* env, jobject stream, jbyteArray storage) + : fEnv(env), fJavaOutputStream(stream), fJavaByteArray(storage) { + fCapacity = env->GetArrayLength(storage); + } + + virtual bool write(const void* buffer, size_t size) { + JNIEnv* env = fEnv; + jbyteArray storage = fJavaByteArray; + + while (size > 0) { + size_t requested = size; + if (requested > fCapacity) { + requested = fCapacity; + } + + jbyte* array = env->GetByteArrayElements(storage, NULL); + memcpy(array, buffer, requested); + env->ReleaseByteArrayElements(storage, array, 0); + + fEnv->CallVoidMethod(fJavaOutputStream, gOutputStream_writeMethodID, + storage, 0, requested); + if (env->ExceptionCheck()) { + env->ExceptionDescribe(); + env->ExceptionClear(); + printf("------- write threw an exception\n"); + return false; + } + + buffer = (void*)((char*)buffer + requested); + size -= requested; + } + return true; + } + + virtual void flush() { + fEnv->CallVoidMethod(fJavaOutputStream, gOutputStream_flushMethodID); + } + +private: + JNIEnv* fEnv; + jobject fJavaOutputStream; // the caller owns this object + jbyteArray fJavaByteArray; // the caller owns this object + size_t fCapacity; +}; + +SkWStream* CreateJavaOutputStreamAdaptor(JNIEnv* env, jobject stream, + jbyteArray storage) { + static bool gInited; + + if (!gInited) { + gOutputStream_Clazz = env->FindClass("java/io/OutputStream"); + RETURN_NULL_IF_NULL(gOutputStream_Clazz); + gOutputStream_Clazz = (jclass)env->NewGlobalRef(gOutputStream_Clazz); + + gOutputStream_writeMethodID = env->GetMethodID(gOutputStream_Clazz, + "write", "([BII)V"); + RETURN_NULL_IF_NULL(gOutputStream_writeMethodID); + gOutputStream_flushMethodID = env->GetMethodID(gOutputStream_Clazz, + "flush", "()V"); + RETURN_NULL_IF_NULL(gOutputStream_flushMethodID); + + gInited = true; + } + + return new SkJavaOutputStream(env, stream, storage); +} + diff --git a/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h new file mode 100644 index 0000000..cf21dde --- /dev/null +++ b/core/jni/android/graphics/CreateJavaOutputStreamAdaptor.h @@ -0,0 +1,13 @@ +#ifndef CreateJavaOutputStream_DEFINED +#define CreateJavaOutputStream_DEFINED + +//#include <android_runtime/AndroidRuntime.h> +#include "jni.h" +#include "SkStream.h" + +SkStream* CreateJavaInputStreamAdaptor(JNIEnv* env, jobject stream, + jbyteArray storage); +SkWStream* CreateJavaOutputStreamAdaptor(JNIEnv* env, jobject stream, + jbyteArray storage); + +#endif diff --git a/core/jni/android/graphics/DrawFilter.cpp b/core/jni/android/graphics/DrawFilter.cpp new file mode 100644 index 0000000..496e712 --- /dev/null +++ b/core/jni/android/graphics/DrawFilter.cpp @@ -0,0 +1,76 @@ +/* libs/android_runtime/android/graphics/ColorFilter.cpp +** +** Copyright 2006, 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. +*/ + +// This file was generated from the C++ include file: SkColorFilter.h +// Any changes made to this file will be discarded by the build. +// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, +// or one of the auxilary file specifications in device/tools/gluemaker. + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkDrawFilter.h" +#include "SkPaintFlagsDrawFilter.h" +#include "SkPaint.h" + +namespace android { + +class SkDrawFilterGlue { +public: + + static void finalizer(JNIEnv* env, jobject clazz, SkDrawFilter* obj) { + obj->safeUnref(); + } + + static SkDrawFilter* CreatePaintFlagsDF(JNIEnv* env, jobject clazz, + int clearFlags, int setFlags) { + // trim off any out-of-range bits + clearFlags &= SkPaint::kAllFlags; + setFlags &= SkPaint::kAllFlags; + + if (clearFlags | setFlags) { + return new SkPaintFlagsDrawFilter(clearFlags, setFlags); + } else { + return NULL; + } + } +}; + +static JNINativeMethod drawfilter_methods[] = { + {"nativeDestructor", "(I)V", (void*) SkDrawFilterGlue::finalizer} +}; + +static JNINativeMethod paintflags_methods[] = { + {"nativeConstructor","(II)I", (void*) SkDrawFilterGlue::CreatePaintFlagsDF} +}; + +#define REG(env, name, array) \ + result = android::AndroidRuntime::registerNativeMethods(env, name, array, SK_ARRAY_COUNT(array)); \ + if (result < 0) return result + + +int register_android_graphics_DrawFilter(JNIEnv* env) { + int result; + + REG(env, "android/graphics/DrawFilter", drawfilter_methods); + REG(env, "android/graphics/PaintFlagsDrawFilter", paintflags_methods); + + return 0; +} + +} diff --git a/core/jni/android/graphics/Graphics.cpp b/core/jni/android/graphics/Graphics.cpp new file mode 100644 index 0000000..f8ccf72 --- /dev/null +++ b/core/jni/android/graphics/Graphics.cpp @@ -0,0 +1,578 @@ +#include "jni.h" +#include "GraphicsJNI.h" +#include "NIOBuffer.h" +#include "SkPicture.h" +#include "SkRegion.h" +#include <android_runtime/AndroidRuntime.h> + +//#define TRACK_LOCK_COUNT + +void doThrow(JNIEnv* env, const char* exc, const char* msg) { + // don't throw a new exception if we already have one pending + if (env->ExceptionCheck() == JNI_FALSE) { + jclass npeClazz; + + npeClazz = env->FindClass(exc); + LOG_FATAL_IF(npeClazz == NULL, "Unable to find class %s", exc); + + env->ThrowNew(npeClazz, msg); + } +} + +void doThrowNPE(JNIEnv* env) { + doThrow(env, "java/lang/NullPointerException"); +} + +void doThrowAIOOBE(JNIEnv* env) { + doThrow(env, "java/lang/ArrayIndexOutOfBoundsException"); +} + +void doThrowRE(JNIEnv* env, const char* msg) { + doThrow(env, "java/lang/RuntimeException", msg); +} + +void doThrowIAE(JNIEnv* env, const char* msg) { + doThrow(env, "java/lang/IllegalArgumentException", msg); +} + +void doThrowISE(JNIEnv* env, const char* msg) { + doThrow(env, "java/lang/IllegalStateException", msg); +} + +void doThrowOOME(JNIEnv* env, const char* msg) { + doThrow(env, "java/lang/OutOfMemoryError", msg); +} + +bool GraphicsJNI::hasException(JNIEnv *env) { + if (env->ExceptionCheck() != 0) { + LOGE("*** Uncaught exception returned from Java call!\n"); + env->ExceptionDescribe(); + return true; + } + return false; +} + +/////////////////////////////////////////////////////////////////////////////// + +AutoJavaFloatArray::AutoJavaFloatArray(JNIEnv* env, jfloatArray array, + int minLength) +: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { + SkASSERT(env); + if (array) { + fLen = env->GetArrayLength(array); + if (fLen < minLength) { + sk_throw(); + } + fPtr = env->GetFloatArrayElements(array, NULL); + } +} + +AutoJavaFloatArray::~AutoJavaFloatArray() { + if (fPtr) { + fEnv->ReleaseFloatArrayElements(fArray, fPtr, 0); + } +} + +AutoJavaIntArray::AutoJavaIntArray(JNIEnv* env, jintArray array, + int minLength) +: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { + SkASSERT(env); + if (array) { + fLen = env->GetArrayLength(array); + if (fLen < minLength) { + sk_throw(); + } + fPtr = env->GetIntArrayElements(array, NULL); + } +} + +AutoJavaIntArray::~AutoJavaIntArray() { + if (fPtr) { + fEnv->ReleaseIntArrayElements(fArray, fPtr, 0); + } +} + +AutoJavaShortArray::AutoJavaShortArray(JNIEnv* env, jshortArray array, + int minLength) +: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { + SkASSERT(env); + if (array) { + fLen = env->GetArrayLength(array); + if (fLen < minLength) { + sk_throw(); + } + fPtr = env->GetShortArrayElements(array, NULL); + } +} + +AutoJavaShortArray::~AutoJavaShortArray() { + if (fPtr) { + fEnv->ReleaseShortArrayElements(fArray, fPtr, 0); + } +} + +AutoJavaByteArray::AutoJavaByteArray(JNIEnv* env, jbyteArray array, + int minLength) +: fEnv(env), fArray(array), fPtr(NULL), fLen(0) { + SkASSERT(env); + if (array) { + fLen = env->GetArrayLength(array); + if (fLen < minLength) { + sk_throw(); + } + fPtr = env->GetByteArrayElements(array, NULL); + } +} + +AutoJavaByteArray::~AutoJavaByteArray() { + if (fPtr) { + fEnv->ReleaseByteArrayElements(fArray, fPtr, 0); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +static jclass gRect_class; +static jfieldID gRect_leftFieldID; +static jfieldID gRect_topFieldID; +static jfieldID gRect_rightFieldID; +static jfieldID gRect_bottomFieldID; + +static jclass gRectF_class; +static jfieldID gRectF_leftFieldID; +static jfieldID gRectF_topFieldID; +static jfieldID gRectF_rightFieldID; +static jfieldID gRectF_bottomFieldID; + +static jclass gPoint_class; +static jfieldID gPoint_xFieldID; +static jfieldID gPoint_yFieldID; + +static jclass gPointF_class; +static jfieldID gPointF_xFieldID; +static jfieldID gPointF_yFieldID; + +static jclass gBitmap_class; +static jfieldID gBitmap_nativeInstanceID; +static jmethodID gBitmap_constructorMethodID; +static jmethodID gBitmap_allocBufferMethodID; + +static jclass gBitmapConfig_class; +static jfieldID gBitmapConfig_nativeInstanceID; + +static jclass gCanvas_class; +static jfieldID gCanvas_nativeInstanceID; + +static jclass gPaint_class; +static jfieldID gPaint_nativeInstanceID; + +static jclass gPicture_class; +static jfieldID gPicture_nativeInstanceID; + +static jclass gRegion_class; +static jfieldID gRegion_nativeInstanceID; +static jmethodID gRegion_constructorMethodID; + +static jobject gVMRuntime_singleton; +static jmethodID gVMRuntime_trackExternalAllocationMethodID; +static jmethodID gVMRuntime_trackExternalFreeMethodID; + +/////////////////////////////////////////////////////////////////////////////// + +void GraphicsJNI::get_jrect(JNIEnv* env, jobject obj, int* L, int* T, int* R, int* B) +{ + SkASSERT(env->IsInstanceOf(obj, gRect_class)); + + *L = env->GetIntField(obj, gRect_leftFieldID); + *T = env->GetIntField(obj, gRect_topFieldID); + *R = env->GetIntField(obj, gRect_rightFieldID); + *B = env->GetIntField(obj, gRect_bottomFieldID); +} + +void GraphicsJNI::set_jrect(JNIEnv* env, jobject obj, int L, int T, int R, int B) +{ + SkASSERT(env->IsInstanceOf(obj, gRect_class)); + + env->SetIntField(obj, gRect_leftFieldID, L); + env->SetIntField(obj, gRect_topFieldID, T); + env->SetIntField(obj, gRect_rightFieldID, R); + env->SetIntField(obj, gRect_bottomFieldID, B); +} + +SkIRect* GraphicsJNI::jrect_to_irect(JNIEnv* env, jobject obj, SkIRect* ir) +{ + SkASSERT(env->IsInstanceOf(obj, gRect_class)); + + ir->set(env->GetIntField(obj, gRect_leftFieldID), + env->GetIntField(obj, gRect_topFieldID), + env->GetIntField(obj, gRect_rightFieldID), + env->GetIntField(obj, gRect_bottomFieldID)); + return ir; +} + +void GraphicsJNI::irect_to_jrect(const SkIRect& ir, JNIEnv* env, jobject obj) +{ + SkASSERT(env->IsInstanceOf(obj, gRect_class)); + + env->SetIntField(obj, gRect_leftFieldID, ir.fLeft); + env->SetIntField(obj, gRect_topFieldID, ir.fTop); + env->SetIntField(obj, gRect_rightFieldID, ir.fRight); + env->SetIntField(obj, gRect_bottomFieldID, ir.fBottom); +} + +SkRect* GraphicsJNI::jrectf_to_rect(JNIEnv* env, jobject obj, SkRect* r) +{ + SkASSERT(env->IsInstanceOf(obj, gRectF_class)); + + r->set(SkFloatToScalar(env->GetFloatField(obj, gRectF_leftFieldID)), + SkFloatToScalar(env->GetFloatField(obj, gRectF_topFieldID)), + SkFloatToScalar(env->GetFloatField(obj, gRectF_rightFieldID)), + SkFloatToScalar(env->GetFloatField(obj, gRectF_bottomFieldID))); + return r; +} + +SkRect* GraphicsJNI::jrect_to_rect(JNIEnv* env, jobject obj, SkRect* r) +{ + SkASSERT(env->IsInstanceOf(obj, gRect_class)); + + r->set(SkIntToScalar(env->GetIntField(obj, gRect_leftFieldID)), + SkIntToScalar(env->GetIntField(obj, gRect_topFieldID)), + SkIntToScalar(env->GetIntField(obj, gRect_rightFieldID)), + SkIntToScalar(env->GetIntField(obj, gRect_bottomFieldID))); + return r; +} + +void GraphicsJNI::rect_to_jrectf(const SkRect& r, JNIEnv* env, jobject obj) +{ + SkASSERT(env->IsInstanceOf(obj, gRectF_class)); + + env->SetFloatField(obj, gRectF_leftFieldID, SkScalarToFloat(r.fLeft)); + env->SetFloatField(obj, gRectF_topFieldID, SkScalarToFloat(r.fTop)); + env->SetFloatField(obj, gRectF_rightFieldID, SkScalarToFloat(r.fRight)); + env->SetFloatField(obj, gRectF_bottomFieldID, SkScalarToFloat(r.fBottom)); +} + +SkIPoint* GraphicsJNI::jpoint_to_ipoint(JNIEnv* env, jobject obj, SkIPoint* point) +{ + SkASSERT(env->IsInstanceOf(obj, gPoint_class)); + + point->set(env->GetIntField(obj, gPoint_xFieldID), + env->GetIntField(obj, gPoint_yFieldID)); + return point; +} + +void GraphicsJNI::ipoint_to_jpoint(const SkIPoint& ir, JNIEnv* env, jobject obj) +{ + SkASSERT(env->IsInstanceOf(obj, gPoint_class)); + + env->SetIntField(obj, gPointF_xFieldID, ir.fX); + env->SetIntField(obj, gPointF_yFieldID, ir.fY); +} + +SkPoint* GraphicsJNI::jpointf_to_point(JNIEnv* env, jobject obj, SkPoint* point) +{ + SkASSERT(env->IsInstanceOf(obj, gPointF_class)); + + point->set(SkFloatToScalar(env->GetIntField(obj, gPointF_xFieldID)), + SkFloatToScalar(env->GetIntField(obj, gPointF_yFieldID))); + return point; +} + +void GraphicsJNI::point_to_jpointf(const SkPoint& r, JNIEnv* env, jobject obj) +{ + SkASSERT(env->IsInstanceOf(obj, gPointF_class)); + + env->SetFloatField(obj, gPointF_xFieldID, SkScalarToFloat(r.fX)); + env->SetFloatField(obj, gPointF_yFieldID, SkScalarToFloat(r.fY)); +} + +SkBitmap* GraphicsJNI::getNativeBitmap(JNIEnv* env, jobject bitmap) { + SkASSERT(env); + SkASSERT(bitmap); + SkASSERT(env->IsInstanceOf(bitmap, gBitmap_class)); + SkBitmap* b = (SkBitmap*)env->GetIntField(bitmap, gBitmap_nativeInstanceID); + SkASSERT(b); + return b; +} + +SkBitmap::Config GraphicsJNI::getNativeBitmapConfig(JNIEnv* env, + jobject jconfig) { + SkASSERT(env); + if (NULL == jconfig) { + return SkBitmap::kNo_Config; + } + SkASSERT(env->IsInstanceOf(jconfig, gBitmapConfig_class)); + int c = env->GetIntField(jconfig, gBitmapConfig_nativeInstanceID); + if (c < 0 || c >= SkBitmap::kConfigCount) { + c = SkBitmap::kNo_Config; + } + return static_cast<SkBitmap::Config>(c); +} + +SkCanvas* GraphicsJNI::getNativeCanvas(JNIEnv* env, jobject canvas) { + SkASSERT(env); + SkASSERT(canvas); + SkASSERT(env->IsInstanceOf(canvas, gCanvas_class)); + SkCanvas* c = (SkCanvas*)env->GetIntField(canvas, gCanvas_nativeInstanceID); + SkASSERT(c); + return c; +} + +SkPaint* GraphicsJNI::getNativePaint(JNIEnv* env, jobject paint) { + SkASSERT(env); + SkASSERT(paint); + SkASSERT(env->IsInstanceOf(paint, gPaint_class)); + SkPaint* p = (SkPaint*)env->GetIntField(paint, gPaint_nativeInstanceID); + SkASSERT(p); + return p; +} + +SkPicture* GraphicsJNI::getNativePicture(JNIEnv* env, jobject picture) +{ + SkASSERT(env); + SkASSERT(picture); + SkASSERT(env->IsInstanceOf(picture, gPicture_class)); + SkPicture* p = (SkPicture*)env->GetIntField(picture, gPicture_nativeInstanceID); + SkASSERT(p); + return p; +} + +SkRegion* GraphicsJNI::getNativeRegion(JNIEnv* env, jobject region) +{ + SkASSERT(env); + SkASSERT(region); + SkASSERT(env->IsInstanceOf(region, gRegion_class)); + SkRegion* r = (SkRegion*)env->GetIntField(region, gRegion_nativeInstanceID); + SkASSERT(r); + return r; +} + +/////////////////////////////////////////////////////////////////////////////////////////// + +jobject GraphicsJNI::createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable, + jbyteArray ninepatch) +{ + SkASSERT(bitmap != NULL); + SkASSERT(NULL != bitmap->pixelRef()); + + jobject obj = env->AllocObject(gBitmap_class); + if (obj) { + env->CallVoidMethod(obj, gBitmap_constructorMethodID, + (jint)bitmap, isMutable, ninepatch); + if (hasException(env)) { + obj = NULL; + } + } + return obj; +} + +jobject GraphicsJNI::createRegion(JNIEnv* env, SkRegion* region) +{ + SkASSERT(region != NULL); + jobject obj = env->AllocObject(gRegion_class); + if (obj) { + env->CallVoidMethod(obj, gRegion_constructorMethodID, (jint)region, 0); + if (hasException(env)) { + obj = NULL; + } + } + return obj; +} + +#include "SkPixelRef.h" + +static JNIEnv* vm2env(JavaVM* vm) +{ + JNIEnv* env = NULL; + if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK || NULL == env) + { + SkDebugf("------- [%p] vm->GetEnv() failed\n", vm); + sk_throw(); + } + return env; +} + +#ifdef TRACK_LOCK_COUNT + static int gLockCount; +#endif + +/////////////////////////////////////////////////////////////////////////////// + +#include "SkMallocPixelRef.h" + +/* Extend SkMallocPixelRef to inform the VM when we free up the storage +*/ +class AndroidPixelRef : public SkMallocPixelRef { +public: + /** Allocate the specified buffer for pixels. The memory is freed when the + last owner of this pixelref is gone. Our caller has already informed + the VM of our allocation. + */ + AndroidPixelRef(JNIEnv* env, void* storage, size_t size, + SkColorTable* ctable) : SkMallocPixelRef(storage, size, ctable) { + SkASSERT(storage); + SkASSERT(env); + + if (env->GetJavaVM(&fVM) != JNI_OK) { + SkDebugf("------ [%p] env->GetJavaVM failed\n", env); + sk_throw(); + } + } + + virtual ~AndroidPixelRef() { + JNIEnv* env = vm2env(fVM); +// SkDebugf("-------------- inform VM we're releasing %d bytes\n", this->getSize()); + jlong jsize = this->getSize(); // the VM wants longs for the size + env->CallVoidMethod(gVMRuntime_singleton, + gVMRuntime_trackExternalFreeMethodID, + jsize); + if (GraphicsJNI::hasException(env)) { + env->ExceptionClear(); + } + } + +private: + JavaVM* fVM; +}; + +bool GraphicsJNI::setJavaPixelRef(JNIEnv* env, SkBitmap* bitmap, + SkColorTable* ctable) { + Sk64 size64 = bitmap->getSize64(); + if (size64.isNeg() || !size64.is32()) { + doThrow(env, "java/lang/IllegalArgumentException", + "bitmap size exceeds 32bits"); + return false; + } + + size_t size = size64.get32(); + // SkDebugf("-------------- inform VM we've allocated %d bytes\n", size); + jlong jsize = size; // the VM wants longs for the size + bool r = env->CallBooleanMethod(gVMRuntime_singleton, + gVMRuntime_trackExternalAllocationMethodID, + jsize); + if (GraphicsJNI::hasException(env)) { + return false; + } + if (!r) { + LOGE("VM won't let us allocate %zd bytes\n", size); + doThrowOOME(env, "bitmap size exceeds VM budget"); + return false; + } + + // call the version of malloc that returns null on failure + void* addr = sk_malloc_flags(size, 0); + if (NULL == addr) { + // SkDebugf("-------------- inform VM we're releasing %d bytes which we couldn't allocate\n", size); + // we didn't actually allocate it, so inform the VM + env->CallVoidMethod(gVMRuntime_singleton, + gVMRuntime_trackExternalFreeMethodID, + jsize); + if (!GraphicsJNI::hasException(env)) { + doThrowOOME(env, "bitmap size too large for malloc"); + } + return false; + } + + bitmap->setPixelRef(new AndroidPixelRef(env, addr, size, ctable))->unref(); + // since we're already allocated, we lockPixels right away + // HeapAllocator behaves this way too + bitmap->lockPixels(); + return true; +} + +/////////////////////////////////////////////////////////////////////////////// + +JavaPixelAllocator::JavaPixelAllocator(JNIEnv* env) : fEnv(env) +{ +} + +bool JavaPixelAllocator::allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable) { + return GraphicsJNI::setJavaPixelRef(fEnv, bitmap, ctable); +} + +//////////////////////////////////////////////////////////////////////////////// + +static jclass make_globalref(JNIEnv* env, const char classname[]) +{ + jclass c = env->FindClass(classname); + SkASSERT(c); + return (jclass)env->NewGlobalRef(c); +} + +static jfieldID getFieldIDCheck(JNIEnv* env, jclass clazz, + const char fieldname[], const char type[]) +{ + jfieldID id = env->GetFieldID(clazz, fieldname, type); + SkASSERT(id); + return id; +} + +int register_android_graphics_Graphics(JNIEnv* env) +{ + jmethodID m; + jclass c; + + gRect_class = make_globalref(env, "android/graphics/Rect"); + gRect_leftFieldID = getFieldIDCheck(env, gRect_class, "left", "I"); + gRect_topFieldID = getFieldIDCheck(env, gRect_class, "top", "I"); + gRect_rightFieldID = getFieldIDCheck(env, gRect_class, "right", "I"); + gRect_bottomFieldID = getFieldIDCheck(env, gRect_class, "bottom", "I"); + + gRectF_class = make_globalref(env, "android/graphics/RectF"); + gRectF_leftFieldID = getFieldIDCheck(env, gRectF_class, "left", "F"); + gRectF_topFieldID = getFieldIDCheck(env, gRectF_class, "top", "F"); + gRectF_rightFieldID = getFieldIDCheck(env, gRectF_class, "right", "F"); + gRectF_bottomFieldID = getFieldIDCheck(env, gRectF_class, "bottom", "F"); + + gPoint_class = make_globalref(env, "android/graphics/Point"); + gPoint_xFieldID = getFieldIDCheck(env, gPoint_class, "x", "I"); + gPoint_yFieldID = getFieldIDCheck(env, gPoint_class, "y", "I"); + + gPointF_class = make_globalref(env, "android/graphics/PointF"); + gPointF_xFieldID = getFieldIDCheck(env, gPointF_class, "x", "F"); + gPointF_yFieldID = getFieldIDCheck(env, gPointF_class, "y", "F"); + + gBitmap_class = make_globalref(env, "android/graphics/Bitmap"); + gBitmap_nativeInstanceID = getFieldIDCheck(env, gBitmap_class, "mNativeBitmap", "I"); + gBitmap_constructorMethodID = env->GetMethodID(gBitmap_class, "<init>", + "(IZ[B)V"); + + gBitmapConfig_class = make_globalref(env, "android/graphics/Bitmap$Config"); + gBitmapConfig_nativeInstanceID = getFieldIDCheck(env, gBitmapConfig_class, + "nativeInt", "I"); + + gCanvas_class = make_globalref(env, "android/graphics/Canvas"); + gCanvas_nativeInstanceID = getFieldIDCheck(env, gCanvas_class, "mNativeCanvas", "I"); + + gPaint_class = make_globalref(env, "android/graphics/Paint"); + gPaint_nativeInstanceID = getFieldIDCheck(env, gPaint_class, "mNativePaint", "I"); + + gPicture_class = make_globalref(env, "android/graphics/Picture"); + gPicture_nativeInstanceID = getFieldIDCheck(env, gPicture_class, "mNativePicture", "I"); + + gRegion_class = make_globalref(env, "android/graphics/Region"); + gRegion_nativeInstanceID = getFieldIDCheck(env, gRegion_class, "mNativeRegion", "I"); + gRegion_constructorMethodID = env->GetMethodID(gRegion_class, "<init>", + "(II)V"); + + // Get the VMRuntime class. + c = env->FindClass("dalvik/system/VMRuntime"); + SkASSERT(c); + // Look up VMRuntime.getRuntime(). + m = env->GetStaticMethodID(c, "getRuntime", "()Ldalvik/system/VMRuntime;"); + SkASSERT(m); + // Call VMRuntime.getRuntime() and hold onto its result. + gVMRuntime_singleton = env->CallStaticObjectMethod(c, m); + SkASSERT(gVMRuntime_singleton); + gVMRuntime_singleton = (jobject)env->NewGlobalRef(gVMRuntime_singleton); + // Look up the VMRuntime methods we'll be using. + gVMRuntime_trackExternalAllocationMethodID = + env->GetMethodID(c, "trackExternalAllocation", "(J)Z"); + gVMRuntime_trackExternalFreeMethodID = + env->GetMethodID(c, "trackExternalFree", "(J)V"); + + NIOBuffer::RegisterJNI(env); + + return 0; +} + diff --git a/core/jni/android/graphics/GraphicsJNI.h b/core/jni/android/graphics/GraphicsJNI.h new file mode 100644 index 0000000..e67b20b --- /dev/null +++ b/core/jni/android/graphics/GraphicsJNI.h @@ -0,0 +1,156 @@ +#ifndef GraphicsJNI_DEFINED +#define GraphicsJNI_DEFINED + +#include "SkPoint.h" +#include "SkRect.h" +#include "SkBitmap.h" +#include <jni.h> + +class SkCanvas; +class SkPaint; +class SkPicture; + +class GraphicsJNI { +public: + // returns true if an exception is set (and dumps it out to the Log) + static bool hasException(JNIEnv*); + + static void get_jrect(JNIEnv*, jobject jrect, int* L, int* T, int* R, int* B); + static void set_jrect(JNIEnv*, jobject jrect, int L, int T, int R, int B); + + static SkIRect* jrect_to_irect(JNIEnv*, jobject jrect, SkIRect*); + static void irect_to_jrect(const SkIRect&, JNIEnv*, jobject jrect); + + static SkRect* jrectf_to_rect(JNIEnv*, jobject jrectf, SkRect*); + static SkRect* jrect_to_rect(JNIEnv*, jobject jrect, SkRect*); + static void rect_to_jrectf(const SkRect&, JNIEnv*, jobject jrectf); + + static void set_jpoint(JNIEnv*, jobject jrect, int x, int y); + + static SkIPoint* jpoint_to_ipoint(JNIEnv*, jobject jpoint, SkIPoint* point); + static void ipoint_to_jpoint(const SkIPoint& point, JNIEnv*, jobject jpoint); + + static SkPoint* jpointf_to_point(JNIEnv*, jobject jpointf, SkPoint* point); + static void point_to_jpointf(const SkPoint& point, JNIEnv*, jobject jpointf); + + static SkCanvas* getNativeCanvas(JNIEnv*, jobject canvas); + static SkPaint* getNativePaint(JNIEnv*, jobject paint); + static SkBitmap* getNativeBitmap(JNIEnv*, jobject bitmap); + static SkPicture* getNativePicture(JNIEnv*, jobject picture); + static SkRegion* getNativeRegion(JNIEnv*, jobject region); + + /** Return the corresponding native config from the java Config enum, + or kNo_Config if the java object is null. + */ + static SkBitmap::Config getNativeBitmapConfig(JNIEnv*, jobject jconfig); + + /** Create a java Bitmap object given the native bitmap (required) and optional + storage array (may be null). If storage is specified, then it must already be + locked, and its native address set as the bitmap's pixels. If storage is null, + then the bitmap must be an owner of its natively allocated pixels (via allocPixels). + */ + static jobject createBitmap(JNIEnv* env, SkBitmap* bitmap, bool isMutable, + jbyteArray ninePatch); + + static jobject createRegion(JNIEnv* env, SkRegion* region); + + /** Set a pixelref for the bitmap (needs setConfig to already be called) + Returns true on success. If it returns false, then it failed, and the + appropriate exception will have been raised. + */ + static bool setJavaPixelRef(JNIEnv*, SkBitmap*, SkColorTable* ctable); + + /** Copy the colors in colors[] to the bitmap, convert to the correct + format along the way. + */ + static bool SetPixels(JNIEnv* env, jintArray colors, int srcOffset, + int srcStride, int x, int y, int width, int height, + const SkBitmap& dstBitmap); +}; + +class JavaPixelAllocator : public SkBitmap::Allocator { +public: + JavaPixelAllocator(JNIEnv* env); + // overrides + virtual bool allocPixelRef(SkBitmap* bitmap, SkColorTable* ctable); + +private: + JNIEnv* fEnv; +}; + +class AutoJavaFloatArray { +public: + AutoJavaFloatArray(JNIEnv* env, jfloatArray array, int minLength = 0); + ~AutoJavaFloatArray(); + + float* ptr() const { return fPtr; } + int length() const { return fLen; } + +private: + JNIEnv* fEnv; + jfloatArray fArray; + float* fPtr; + int fLen; +}; + +class AutoJavaIntArray { +public: + AutoJavaIntArray(JNIEnv* env, jintArray array, int minLength = 0); + ~AutoJavaIntArray(); + + jint* ptr() const { return fPtr; } + int length() const { return fLen; } + +private: + JNIEnv* fEnv; + jintArray fArray; + jint* fPtr; + int fLen; +}; + +class AutoJavaShortArray { +public: + AutoJavaShortArray(JNIEnv* env, jshortArray array, int minLength = 0); + ~AutoJavaShortArray(); + + jshort* ptr() const { return fPtr; } + int length() const { return fLen; } + +private: + JNIEnv* fEnv; + jshortArray fArray; + jshort* fPtr; + int fLen; +}; + +class AutoJavaByteArray { +public: + AutoJavaByteArray(JNIEnv* env, jbyteArray array, int minLength = 0); + ~AutoJavaByteArray(); + + jbyte* ptr() const { return fPtr; } + int length() const { return fLen; } + +private: + JNIEnv* fEnv; + jbyteArray fArray; + jbyte* fPtr; + int fLen; +}; + +void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL); +void doThrowNPE(JNIEnv* env); +void doThrowAIOOBE(JNIEnv* env); // Array Index Out Of Bounds Exception +void doThrowIAE(JNIEnv* env, const char* msg = NULL); // Illegal Argument +void doThrowRE(JNIEnv* env, const char* msg = NULL); // Runtime +void doThrowISE(JNIEnv* env, const char* msg = NULL); // Illegal State +void doThrowOOME(JNIEnv* env, const char* msg = NULL); // Out of memory + +#define NPE_CHECK_RETURN_ZERO(env, object) \ + do { if (NULL == (object)) { doThrowNPE(env); return 0; } } while (0) + +#define NPE_CHECK_RETURN_VOID(env, object) \ + do { if (NULL == (object)) { doThrowNPE(env); return; } } while (0) + +#endif + diff --git a/core/jni/android/graphics/Interpolator.cpp b/core/jni/android/graphics/Interpolator.cpp new file mode 100644 index 0000000..beec351 --- /dev/null +++ b/core/jni/android/graphics/Interpolator.cpp @@ -0,0 +1,97 @@ +#include "jni.h" +#include <android_runtime/AndroidRuntime.h> + +#include "GraphicsJNI.h" +#include "SkInterpolator.h" +#include "SkTemplates.h" + +static SkInterpolator* Interpolator_constructor(JNIEnv* env, jobject clazz, int valueCount, int frameCount) +{ + return new SkInterpolator(valueCount, frameCount); +} + +static void Interpolator_destructor(JNIEnv* env, jobject clazz, SkInterpolator* interp) +{ + delete interp; +} + +static void Interpolator_reset(JNIEnv* env, jobject clazz, SkInterpolator* interp, int valueCount, int frameCount) +{ + interp->reset(valueCount, frameCount); +} + +static void Interpolator_setKeyFrame(JNIEnv* env, jobject clazz, SkInterpolator* interp, int index, int msec, jfloatArray valueArray, jfloatArray blendArray) +{ + SkScalar blendStorage[4]; + SkScalar* blend = NULL; + + AutoJavaFloatArray autoValues(env, valueArray); + float* values = autoValues.ptr(); + int i, n = autoValues.length(); + + SkAutoSTMalloc<16, SkScalar> storage(n); + SkScalar* scalars = storage.get(); + + for (i = 0; i < n; i++) + scalars[i] = SkFloatToScalar(values[i]); + + if (blendArray != NULL) { + AutoJavaFloatArray autoBlend(env, blendArray, 4); + values = autoBlend.ptr(); + for (i = 0; i < 4; i++) + blendStorage[i] = SkFloatToScalar(values[i]); + blend = blendStorage; + } + + interp->setKeyFrame(index, msec, scalars, blend); +} + +static void Interpolator_setRepeatMirror(JNIEnv* env, jobject clazz, SkInterpolator* interp, float repeatCount, jboolean mirror) +{ + if (repeatCount > 32000) + repeatCount = 32000; + + interp->setRepeatCount(SkFloatToScalar(repeatCount)); + interp->setMirror(mirror != 0); +} + +static int Interpolator_timeToValues(JNIEnv* env, jobject clazz, SkInterpolator* interp, int msec, jfloatArray valueArray) +{ + SkInterpolatorBase::Result result; + + float* values = valueArray ? env->GetFloatArrayElements(valueArray, NULL) : NULL; + result = interp->timeToValues(msec, (SkScalar*)values); + + if (valueArray) { + int n = env->GetArrayLength(valueArray); + for (int i = 0; i < n; i++) { + values[i] = SkScalarToFloat(*(SkScalar*)&values[i]); + } + env->ReleaseFloatArrayElements(valueArray, values, 0); + } + + return result; +} + +// ---------------------------------------------------------------------------- + +/* + * JNI registration. + */ +static JNINativeMethod gInterpolatorMethods[] = { + { "nativeConstructor", "(II)I", (void*)Interpolator_constructor }, + { "nativeDestructor", "(I)V", (void*)Interpolator_destructor }, + { "nativeReset", "(III)V", (void*)Interpolator_reset }, + { "nativeSetKeyFrame", "(III[F[F)V", (void*)Interpolator_setKeyFrame }, + { "nativeSetRepeatMirror", "(IFZ)V", (void*)Interpolator_setRepeatMirror }, + { "nativeTimeToValues", "(II[F)I", (void*)Interpolator_timeToValues } +}; + +int register_android_graphics_Interpolator(JNIEnv* env); +int register_android_graphics_Interpolator(JNIEnv* env) +{ + return android::AndroidRuntime::registerNativeMethods(env, + "android/graphics/Interpolator", + gInterpolatorMethods, + SK_ARRAY_COUNT(gInterpolatorMethods)); +} diff --git a/core/jni/android/graphics/LayerRasterizer.cpp b/core/jni/android/graphics/LayerRasterizer.cpp new file mode 100644 index 0000000..7c45889 --- /dev/null +++ b/core/jni/android/graphics/LayerRasterizer.cpp @@ -0,0 +1,34 @@ +#include "SkLayerRasterizer.h" +#include <jni.h> + +class SkLayerRasterizerGlue { +public: + static SkRasterizer* create(JNIEnv* env, jobject) { + return new SkLayerRasterizer(); + } + + static void addLayer(JNIEnv* env, jobject, SkLayerRasterizer* layer, const SkPaint* paint, float dx, float dy) { + SkASSERT(layer); + SkASSERT(paint); + layer->addLayer(*paint, SkFloatToScalar(dx), SkFloatToScalar(dy)); + } +}; + +///////////////////////////////////////////////////////////////////////////////////////// + +#include <android_runtime/AndroidRuntime.h> + +static JNINativeMethod gLayerRasterizerMethods[] = { + { "nativeConstructor", "()I", (void*)SkLayerRasterizerGlue::create }, + { "nativeAddLayer", "(IIFF)V", (void*)SkLayerRasterizerGlue::addLayer } +}; + +int register_android_graphics_LayerRasterizer(JNIEnv* env); +int register_android_graphics_LayerRasterizer(JNIEnv* env) +{ + return android::AndroidRuntime::registerNativeMethods(env, + "android/graphics/LayerRasterizer", + gLayerRasterizerMethods, + SK_ARRAY_COUNT(gLayerRasterizerMethods)); +} + diff --git a/core/jni/android/graphics/MaskFilter.cpp b/core/jni/android/graphics/MaskFilter.cpp new file mode 100644 index 0000000..e6048cd --- /dev/null +++ b/core/jni/android/graphics/MaskFilter.cpp @@ -0,0 +1,61 @@ +#include "GraphicsJNI.h" +#include "SkMaskFilter.h" +#include "SkBlurMaskFilter.h" + +#include <jni.h> + +class SkMaskFilterGlue { +public: + static void destructor(JNIEnv* env, jobject, SkMaskFilter* filter) { + SkASSERT(filter); + filter->unref(); + } + + static SkMaskFilter* createBlur(JNIEnv* env, jobject, float radius, int blurStyle) { + return SkBlurMaskFilter::Create(SkFloatToScalar(radius), (SkBlurMaskFilter::BlurStyle)blurStyle); + } + + static SkMaskFilter* createEmboss(JNIEnv* env, jobject, jfloatArray dirArray, float ambient, float specular, float radius) { + SkScalar direction[3]; + + AutoJavaFloatArray autoDir(env, dirArray, 3); + float* values = autoDir.ptr(); + for (int i = 0; i < 3; i++) { + direction[i] = SkFloatToScalar(values[i]); + } + + return SkBlurMaskFilter::CreateEmboss(direction, SkFloatToScalar(ambient), + SkFloatToScalar(specular), SkFloatToScalar(radius)); + } +}; + +static JNINativeMethod gMaskFilterMethods[] = { + { "nativeDestructor", "(I)V", (void*)SkMaskFilterGlue::destructor } +}; + +static JNINativeMethod gBlurMaskFilterMethods[] = { + { "nativeConstructor", "(FI)I", (void*)SkMaskFilterGlue::createBlur } +}; + +static JNINativeMethod gEmbossMaskFilterMethods[] = { + { "nativeConstructor", "([FFFF)I", (void*)SkMaskFilterGlue::createEmboss } +}; + +#include <android_runtime/AndroidRuntime.h> + +#define REG(env, name, array) \ + result = android::AndroidRuntime::registerNativeMethods(env, name, array, SK_ARRAY_COUNT(array)); \ + if (result < 0) return result + +int register_android_graphics_MaskFilter(JNIEnv* env); +int register_android_graphics_MaskFilter(JNIEnv* env) +{ + int result; + + REG(env, "android/graphics/MaskFilter", gMaskFilterMethods); + REG(env, "android/graphics/BlurMaskFilter", gBlurMaskFilterMethods); + REG(env, "android/graphics/EmbossMaskFilter", gEmbossMaskFilterMethods); + + return 0; +} + diff --git a/core/jni/android/graphics/Matrix.cpp b/core/jni/android/graphics/Matrix.cpp new file mode 100644 index 0000000..b782766 --- /dev/null +++ b/core/jni/android/graphics/Matrix.cpp @@ -0,0 +1,412 @@ +/* libs/android_runtime/android/graphics/Matrix.cpp +** +** Copyright 2006, 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. +*/ + +// This file was generated from the C++ include file: SkMatrix.h +// Any changes made to this file will be discarded by the build. +// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, +// or one of the auxilary file specifications in device/tools/gluemaker. + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkMatrix.h" +#include "SkTemplates.h" + +namespace android { + +class SkMatrixGlue { +public: + + static void finalizer(JNIEnv* env, jobject clazz, SkMatrix* obj) { + delete obj; + } + + static SkMatrix* create(JNIEnv* env, jobject clazz, const SkMatrix* src) { + SkMatrix* obj = new SkMatrix(); + if (src) + *obj = *src; + else + obj->reset(); + return obj; + } + + static jboolean isIdentity(JNIEnv* env, jobject clazz, SkMatrix* obj) { + return obj->isIdentity(); + } + + static jboolean rectStaysRect(JNIEnv* env, jobject clazz, SkMatrix* obj) { + return obj->rectStaysRect(); + } + + static void reset(JNIEnv* env, jobject clazz, SkMatrix* obj) { + obj->reset(); + } + + static void set(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) { + *obj = *other; + } + + static void setTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + obj->setTranslate(dx_, dy_); + } + + static void setScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { + SkScalar sx_ = SkFloatToScalar(sx); + SkScalar sy_ = SkFloatToScalar(sy); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + obj->setScale(sx_, sy_, px_, py_); + } + + static void setScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { + SkScalar sx_ = SkFloatToScalar(sx); + SkScalar sy_ = SkFloatToScalar(sy); + obj->setScale(sx_, sy_); + } + + static void setRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { + SkScalar degrees_ = SkFloatToScalar(degrees); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + obj->setRotate(degrees_, px_, py_); + } + + static void setRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { + SkScalar degrees_ = SkFloatToScalar(degrees); + obj->setRotate(degrees_); + } + + static void setSinCos__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue, jfloat px, jfloat py) { + SkScalar sinValue_ = SkFloatToScalar(sinValue); + SkScalar cosValue_ = SkFloatToScalar(cosValue); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + obj->setSinCos(sinValue_, cosValue_, px_, py_); + } + + static void setSinCos__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sinValue, jfloat cosValue) { + SkScalar sinValue_ = SkFloatToScalar(sinValue); + SkScalar cosValue_ = SkFloatToScalar(cosValue); + obj->setSinCos(sinValue_, cosValue_); + } + + static void setSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { + SkScalar kx_ = SkFloatToScalar(kx); + SkScalar ky_ = SkFloatToScalar(ky); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + obj->setSkew(kx_, ky_, px_, py_); + } + + static void setSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) { + SkScalar kx_ = SkFloatToScalar(kx); + SkScalar ky_ = SkFloatToScalar(ky); + obj->setSkew(kx_, ky_); + } + + static jboolean setConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* a, SkMatrix* b) { + return obj->setConcat(*a, *b); + } + + static jboolean preTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + return obj->preTranslate(dx_, dy_); + } + + static jboolean preScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { + SkScalar sx_ = SkFloatToScalar(sx); + SkScalar sy_ = SkFloatToScalar(sy); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + return obj->preScale(sx_, sy_, px_, py_); + } + + static jboolean preScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { + SkScalar sx_ = SkFloatToScalar(sx); + SkScalar sy_ = SkFloatToScalar(sy); + return obj->preScale(sx_, sy_); + } + + static jboolean preRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { + SkScalar degrees_ = SkFloatToScalar(degrees); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + return obj->preRotate(degrees_, px_, py_); + } + + static jboolean preRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { + SkScalar degrees_ = SkFloatToScalar(degrees); + return obj->preRotate(degrees_); + } + + static jboolean preSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { + SkScalar kx_ = SkFloatToScalar(kx); + SkScalar ky_ = SkFloatToScalar(ky); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + return obj->preSkew(kx_, ky_, px_, py_); + } + + static jboolean preSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky) { + SkScalar kx_ = SkFloatToScalar(kx); + SkScalar ky_ = SkFloatToScalar(ky); + return obj->preSkew(kx_, ky_); + } + + static jboolean preConcat(JNIEnv* env, jobject clazz, SkMatrix* obj, SkMatrix* other) { + return obj->preConcat(*other); + } + + static jboolean postTranslate(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat dx, jfloat dy) { + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + return obj->postTranslate(dx_, dy_); + } + + static jboolean postScale__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy, jfloat px, jfloat py) { + SkScalar sx_ = SkFloatToScalar(sx); + SkScalar sy_ = SkFloatToScalar(sy); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + return obj->postScale(sx_, sy_, px_, py_); + } + + static jboolean postScale__FF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat sx, jfloat sy) { + SkScalar sx_ = SkFloatToScalar(sx); + SkScalar sy_ = SkFloatToScalar(sy); + return obj->postScale(sx_, sy_); + } + + static jboolean postRotate__FFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees, jfloat px, jfloat py) { + SkScalar degrees_ = SkFloatToScalar(degrees); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + return obj->postRotate(degrees_, px_, py_); + } + + static jboolean postRotate__F(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat degrees) { + SkScalar degrees_ = SkFloatToScalar(degrees); + return obj->postRotate(degrees_); + } + + static jboolean postSkew__FFFF(JNIEnv* env, jobject clazz, SkMatrix* obj, jfloat kx, jfloat ky, jfloat px, jfloat py) { + SkScalar kx_ = SkFloatToScalar(kx); + SkScalar ky_ = SkFloatToScalar(ky); + SkScalar px_ = SkFloatToScalar(px); + SkScalar py_ = SkFloatToScalar(py); + return obj->postSkew(kx_, ky_, px_, py_); + } + + static jboolean postSkew__FF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat kx, jfloat ky) { + SkScalar kx_ = SkFloatToScalar(kx); + SkScalar ky_ = SkFloatToScalar(ky); + return matrix->postSkew(kx_, ky_); + } + + static jboolean postConcat(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* other) { + return matrix->postConcat(*other); + } + + static jboolean setRectToRect(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobject src, jobject dst, SkMatrix::ScaleToFit stf) { + SkRect src_; + GraphicsJNI::jrectf_to_rect(env, src, &src_); + SkRect dst_; + GraphicsJNI::jrectf_to_rect(env, dst, &dst_); + return matrix->setRectToRect(src_, dst_, stf); + } + + static jboolean setPolyToPoly(JNIEnv* env, jobject clazz, SkMatrix* matrix, + jfloatArray jsrc, int srcIndex, + jfloatArray jdst, int dstIndex, int ptCount) { + SkASSERT(srcIndex >= 0); + SkASSERT(dstIndex >= 0); + SkASSERT((unsigned)ptCount <= 4); + + AutoJavaFloatArray autoSrc(env, jsrc, srcIndex + (ptCount << 1)); + AutoJavaFloatArray autoDst(env, jdst, dstIndex + (ptCount << 1)); + float* src = autoSrc.ptr() + srcIndex; + float* dst = autoDst.ptr() + dstIndex; + +#ifdef SK_SCALAR_IS_FIXED + SkPoint srcPt[4], dstPt[4]; + for (int i = 0; i < ptCount; i++) { + int x = i << 1; + int y = x + 1; + srcPt[i].set(SkFloatToScalar(src[x]), SkFloatToScalar(src[y])); + dstPt[i].set(SkFloatToScalar(dst[x]), SkFloatToScalar(dst[y])); + } + return matrix->setPolyToPoly(srcPt, dstPt, ptCount); +#else + return matrix->setPolyToPoly((const SkPoint*)src, (const SkPoint*)dst, + ptCount); +#endif + } + + static jboolean invert(JNIEnv* env, jobject clazz, SkMatrix* matrix, SkMatrix* inverse) { + return matrix->invert(inverse); + } + + static void mapPoints(JNIEnv* env, jobject clazz, SkMatrix* matrix, + jfloatArray dst, int dstIndex, + jfloatArray src, int srcIndex, + int ptCount, bool isPts) { + SkASSERT(ptCount >= 0); + AutoJavaFloatArray autoSrc(env, src, srcIndex + (ptCount << 1)); + AutoJavaFloatArray autoDst(env, dst, dstIndex + (ptCount << 1)); + float* srcArray = autoSrc.ptr() + srcIndex; + float* dstArray = autoDst.ptr() + dstIndex; + +#ifdef SK_SCALAR_IS_FIXED + // we allocate twice the count, 1 set for src, 1 for dst + SkAutoSTMalloc<32, SkPoint> storage(ptCount * 2); + SkPoint* pts = storage.get(); + SkPoint* srcPt = pts; + SkPoint* dstPt = pts + ptCount; + + int i; + for (i = 0; i < ptCount; i++) { + srcPt[i].set(SkFloatToScalar(srcArray[i << 1]), + SkFloatToScalar(srcArray[(i << 1) + 1])); + } + + if (isPts) + matrix->mapPoints(dstPt, srcPt, ptCount); + else + matrix->mapVectors(dstPt, srcPt, ptCount); + + for (i = 0; i < ptCount; i++) { + dstArray[i << 1] = SkScalarToFloat(dstPt[i].fX); + dstArray[(i << 1) + 1] = SkScalarToFloat(dstPt[i].fY); + } +#else + if (isPts) + matrix->mapPoints((SkPoint*)dstArray, (const SkPoint*)srcArray, + ptCount); + else + matrix->mapVectors((SkVector*)dstArray, (const SkVector*)srcArray, + ptCount); +#endif + } + + static jboolean mapRect__RectFRectF(JNIEnv* env, jobject clazz, SkMatrix* matrix, jobjectArray dst, jobject src) { + SkRect dst_, src_; + GraphicsJNI::jrectf_to_rect(env, src, &src_); + jboolean rectStaysRect = matrix->mapRect(&dst_, src_); + GraphicsJNI::rect_to_jrectf(dst_, env, dst); + return rectStaysRect; + } + + static jfloat mapRadius(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloat radius) { + return SkScalarToFloat(matrix->mapRadius(SkFloatToScalar(radius))); + } + + static void getValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) { + AutoJavaFloatArray autoValues(env, values, 9); + float* dst = autoValues.ptr(); + +#ifdef SK_SCALAR_IS_FIXED + for (int i = 0; i < 6; i++) { + dst[i] = SkFixedToFloat(matrix->get(i)); + } + for (int j = 6; j < 9; j++) { + dst[j] = SkFractToFloat(matrix->get(j)); + } +#else + for (int i = 0; i < 9; i++) { + dst[i] = matrix->get(i); + } +#endif + } + + static void setValues(JNIEnv* env, jobject clazz, SkMatrix* matrix, jfloatArray values) { + AutoJavaFloatArray autoValues(env, values, 9); + const float* src = autoValues.ptr(); + +#ifdef SK_SCALAR_IS_FIXED + for (int i = 0; i < 6; i++) { + matrix->set(i, SkFloatToFixed(src[i])); + } + for (int j = 6; j < 9; j++) { + matrix->set(j, SkFloatToFract(src[j])); + } +#else + for (int i = 0; i < 9; i++) { + matrix->set(i, src[i]); + } +#endif + } + + static jboolean equals(JNIEnv* env, jobject clazz, const SkMatrix* a, const SkMatrix* b) { + return *a == *b; + } + }; + +static JNINativeMethod methods[] = { + {"finalizer", "(I)V", (void*) SkMatrixGlue::finalizer}, + {"native_create","(I)I", (void*) SkMatrixGlue::create}, + {"native_isIdentity","(I)Z", (void*) SkMatrixGlue::isIdentity}, + {"native_rectStaysRect","(I)Z", (void*) SkMatrixGlue::rectStaysRect}, + {"native_reset","(I)V", (void*) SkMatrixGlue::reset}, + {"native_set","(II)V", (void*) SkMatrixGlue::set}, + {"native_setTranslate","(IFF)V", (void*) SkMatrixGlue::setTranslate}, + {"native_setScale","(IFFFF)V", (void*) SkMatrixGlue::setScale__FFFF}, + {"native_setScale","(IFF)V", (void*) SkMatrixGlue::setScale__FF}, + {"native_setRotate","(IFFF)V", (void*) SkMatrixGlue::setRotate__FFF}, + {"native_setRotate","(IF)V", (void*) SkMatrixGlue::setRotate__F}, + {"native_setSinCos","(IFFFF)V", (void*) SkMatrixGlue::setSinCos__FFFF}, + {"native_setSinCos","(IFF)V", (void*) SkMatrixGlue::setSinCos__FF}, + {"native_setSkew","(IFFFF)V", (void*) SkMatrixGlue::setSkew__FFFF}, + {"native_setSkew","(IFF)V", (void*) SkMatrixGlue::setSkew__FF}, + {"native_setConcat","(III)Z", (void*) SkMatrixGlue::setConcat}, + {"native_preTranslate","(IFF)Z", (void*) SkMatrixGlue::preTranslate}, + {"native_preScale","(IFFFF)Z", (void*) SkMatrixGlue::preScale__FFFF}, + {"native_preScale","(IFF)Z", (void*) SkMatrixGlue::preScale__FF}, + {"native_preRotate","(IFFF)Z", (void*) SkMatrixGlue::preRotate__FFF}, + {"native_preRotate","(IF)Z", (void*) SkMatrixGlue::preRotate__F}, + {"native_preSkew","(IFFFF)Z", (void*) SkMatrixGlue::preSkew__FFFF}, + {"native_preSkew","(IFF)Z", (void*) SkMatrixGlue::preSkew__FF}, + {"native_preConcat","(II)Z", (void*) SkMatrixGlue::preConcat}, + {"native_postTranslate","(IFF)Z", (void*) SkMatrixGlue::postTranslate}, + {"native_postScale","(IFFFF)Z", (void*) SkMatrixGlue::postScale__FFFF}, + {"native_postScale","(IFF)Z", (void*) SkMatrixGlue::postScale__FF}, + {"native_postRotate","(IFFF)Z", (void*) SkMatrixGlue::postRotate__FFF}, + {"native_postRotate","(IF)Z", (void*) SkMatrixGlue::postRotate__F}, + {"native_postSkew","(IFFFF)Z", (void*) SkMatrixGlue::postSkew__FFFF}, + {"native_postSkew","(IFF)Z", (void*) SkMatrixGlue::postSkew__FF}, + {"native_postConcat","(II)Z", (void*) SkMatrixGlue::postConcat}, + {"native_setRectToRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;I)Z", (void*) SkMatrixGlue::setRectToRect}, + {"native_setPolyToPoly","(I[FI[FII)Z", (void*) SkMatrixGlue::setPolyToPoly}, + {"native_invert","(II)Z", (void*) SkMatrixGlue::invert}, + {"native_mapPoints","(I[FI[FIIZ)V", (void*) SkMatrixGlue::mapPoints}, + {"native_mapRect","(ILandroid/graphics/RectF;Landroid/graphics/RectF;)Z", (void*) SkMatrixGlue::mapRect__RectFRectF}, + {"native_mapRadius","(IF)F", (void*) SkMatrixGlue::mapRadius}, + {"native_getValues","(I[F)V", (void*) SkMatrixGlue::getValues}, + {"native_setValues","(I[F)V", (void*) SkMatrixGlue::setValues}, + {"native_equals", "(II)Z", (void*) SkMatrixGlue::equals} +}; + +int register_android_graphics_Matrix(JNIEnv* env) { + int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Matrix", methods, + sizeof(methods) / sizeof(methods[0])); + return result; +} + +} diff --git a/core/jni/android/graphics/Movie.cpp b/core/jni/android/graphics/Movie.cpp new file mode 100644 index 0000000..5c48077 --- /dev/null +++ b/core/jni/android/graphics/Movie.cpp @@ -0,0 +1,155 @@ +#include "SkMovie.h" +#include "SkStream.h" +#include "GraphicsJNI.h" +#include "SkTemplates.h" +#include "SkUtils.h" +#include "CreateJavaOutputStreamAdaptor.h" + +#include <utils/Asset.h> +#include <utils/ResourceTypes.h> +#include <netinet/in.h> + +#if 0 + #define TRACE_BITMAP(code) code +#else + #define TRACE_BITMAP(code) +#endif + +static jclass gMovie_class; +static jmethodID gMovie_constructorMethodID; +static jfieldID gMovie_nativeInstanceID; + +jobject create_jmovie(JNIEnv* env, SkMovie* moov) { + if (NULL == moov) { + return NULL; + } + jobject obj = env->AllocObject(gMovie_class); + if (obj) { + env->CallVoidMethod(obj, gMovie_constructorMethodID, (jint)moov); + } + return obj; +} + +static SkMovie* J2Movie(JNIEnv* env, jobject movie) { + SkASSERT(env); + SkASSERT(movie); + SkASSERT(env->IsInstanceOf(movie, gMovie_class)); + SkMovie* m = (SkMovie*)env->GetIntField(movie, gMovie_nativeInstanceID); + SkASSERT(m); + return m; +} + +/////////////////////////////////////////////////////////////////////////////// + +static int movie_width(JNIEnv* env, jobject movie) { + NPE_CHECK_RETURN_ZERO(env, movie); + return J2Movie(env, movie)->width(); +} + +static int movie_height(JNIEnv* env, jobject movie) { + NPE_CHECK_RETURN_ZERO(env, movie); + return J2Movie(env, movie)->height(); +} + +static jboolean movie_isOpaque(JNIEnv* env, jobject movie) { + NPE_CHECK_RETURN_ZERO(env, movie); + return J2Movie(env, movie)->isOpaque(); +} + +static int movie_duration(JNIEnv* env, jobject movie) { + NPE_CHECK_RETURN_ZERO(env, movie); + return J2Movie(env, movie)->duration(); +} + +static jboolean movie_setTime(JNIEnv* env, jobject movie, int ms) { + NPE_CHECK_RETURN_ZERO(env, movie); + return J2Movie(env, movie)->setTime(ms); +} + +static void movie_draw(JNIEnv* env, jobject movie, jobject canvas, + jfloat fx, jfloat fy, jobject jpaint) { + NPE_CHECK_RETURN_VOID(env, movie); + NPE_CHECK_RETURN_VOID(env, canvas); + // its OK for paint to be null + + SkMovie* m = J2Movie(env, movie); + SkCanvas* c = GraphicsJNI::getNativeCanvas(env, canvas); + SkScalar sx = SkFloatToScalar(fx); + SkScalar sy = SkFloatToScalar(fy); + const SkBitmap& b = m->bitmap(); + const SkPaint* p = jpaint ? GraphicsJNI::getNativePaint(env, jpaint) : NULL; + + c->drawBitmap(b, sx, sy, p); +} + +static jobject movie_decodeStream(JNIEnv* env, jobject clazz, jobject istream) { + + NPE_CHECK_RETURN_ZERO(env, istream); + + // what is the lifetime of the array? Can the skstream hold onto it? + jbyteArray byteArray = env->NewByteArray(16*1024); + SkStream* strm = CreateJavaInputStreamAdaptor(env, istream, byteArray); + if (NULL == strm) { + return 0; + } + + SkMovie* moov = SkMovie::DecodeStream(strm); + strm->unref(); + return create_jmovie(env, moov); +} + +static jobject movie_decodeByteArray(JNIEnv* env, jobject clazz, + jbyteArray byteArray, + int offset, int length) { + + NPE_CHECK_RETURN_ZERO(env, byteArray); + + int totalLength = env->GetArrayLength(byteArray); + if ((offset | length) < 0 || offset + length > totalLength) { + doThrow(env, "java/lang/ArrayIndexException"); + return 0; + } + + AutoJavaByteArray ar(env, byteArray); + SkMovie* moov = SkMovie::DecodeMemory(ar.ptr() + offset, length); + return create_jmovie(env, moov); +} + +////////////////////////////////////////////////////////////////////////////////////////////// + +#include <android_runtime/AndroidRuntime.h> + +static JNINativeMethod gMethods[] = { + { "width", "()I", (void*)movie_width }, + { "height", "()I", (void*)movie_height }, + { "isOpaque", "()Z", (void*)movie_isOpaque }, + { "duration", "()I", (void*)movie_duration }, + { "setTime", "(I)Z", (void*)movie_setTime }, + { "draw", "(Landroid/graphics/Canvas;FFLandroid/graphics/Paint;)V", + (void*)movie_draw }, + { "decodeStream", "(Ljava/io/InputStream;)Landroid/graphics/Movie;", + (void*)movie_decodeStream }, + { "decodeByteArray", "([BII)Landroid/graphics/Movie;", + (void*)movie_decodeByteArray }, +}; + +#define kClassPathName "android/graphics/Movie" + +#define RETURN_ERR_IF_NULL(value) do { if (!(value)) { assert(0); return -1; } } while (false) + +int register_android_graphics_Movie(JNIEnv* env); +int register_android_graphics_Movie(JNIEnv* env) +{ + gMovie_class = env->FindClass(kClassPathName); + RETURN_ERR_IF_NULL(gMovie_class); + gMovie_class = (jclass)env->NewGlobalRef(gMovie_class); + + gMovie_constructorMethodID = env->GetMethodID(gMovie_class, "<init>", "(I)V"); + RETURN_ERR_IF_NULL(gMovie_constructorMethodID); + + gMovie_nativeInstanceID = env->GetFieldID(gMovie_class, "mNativeMovie", "I"); + RETURN_ERR_IF_NULL(gMovie_nativeInstanceID); + + return android::AndroidRuntime::registerNativeMethods(env, kClassPathName, + gMethods, SK_ARRAY_COUNT(gMethods)); +} diff --git a/core/jni/android/graphics/NIOBuffer.cpp b/core/jni/android/graphics/NIOBuffer.cpp new file mode 100644 index 0000000..cb937a3 --- /dev/null +++ b/core/jni/android/graphics/NIOBuffer.cpp @@ -0,0 +1,143 @@ +#include "NIOBuffer.h" +#include "GraphicsJNI.h" + +// enable this to dump each time we ref/unref a global java object (buffer) +// +//#define TRACE_GLOBAL_REFS + +//#define TRACE_ARRAY_LOCKS + +static jclass gNIOAccess_classID; +static jmethodID gNIOAccess_getBasePointer; +static jmethodID gNIOAccess_getBaseArray; +static jmethodID gNIOAccess_getBaseArrayOffset; +static jmethodID gNIOAccess_getRemainingBytes; + +void NIOBuffer::RegisterJNI(JNIEnv* env) { + if (0 != gNIOAccess_classID) { + return; // already called + } + + jclass c = env->FindClass("java/nio/NIOAccess"); + gNIOAccess_classID = (jclass)env->NewGlobalRef(c); + + gNIOAccess_getBasePointer = env->GetStaticMethodID(gNIOAccess_classID, + "getBasePointer", "(Ljava/nio/Buffer;)J"); + gNIOAccess_getBaseArray = env->GetStaticMethodID(gNIOAccess_classID, + "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;"); + gNIOAccess_getBaseArrayOffset = env->GetStaticMethodID(gNIOAccess_classID, + "getBaseArrayOffset", "(Ljava/nio/Buffer;)I"); + gNIOAccess_getRemainingBytes = env->GetStaticMethodID(gNIOAccess_classID, + "getRemainingBytes", "(Ljava/nio/Buffer;)I"); +} + +/////////////////////////////////////////////////////////////////////////////// + +#ifdef TRACE_GLOBAL_REFS + static int gGlobalRefs; +#endif + +#ifdef TRACE_ARRAY_LOCKS + static int gLockCount; +#endif + +NIOBuffer::NIOBuffer(JNIEnv* env, jobject buffer) { + fBuffer = env->NewGlobalRef(buffer); +#ifdef TRACE_GLOBAL_REFS + SkDebugf("------------ newglobalref bbuffer %X %d\n", buffer, gGlobalRefs++); +#endif + fLockedPtr = NULL; + fLockedArray = NULL; +} + +NIOBuffer::~NIOBuffer() { + // free() needs to have already been called + if (NULL != fBuffer) { + SkDebugf("----- leaked fBuffer in NIOBuffer"); + sk_throw(); + } +} + +void NIOBuffer::free(JNIEnv* env) { + + if (NULL != fLockedPtr) { + SkDebugf("======= free: array still locked %x %p\n", fLockedArray, fLockedPtr); + } + + + if (NULL != fBuffer) { +#ifdef TRACE_GLOBAL_REFS + SkDebugf("----------- deleteglobalref buffer %X %d\n", fBuffer, --gGlobalRefs); +#endif + env->DeleteGlobalRef(fBuffer); + fBuffer = NULL; + } +} + +void* NIOBuffer::lock(JNIEnv* env, int* remaining) { + if (NULL != fLockedPtr) { + SkDebugf("======= lock: array still locked %x %p\n", fLockedArray, fLockedPtr); + } + + fLockedPtr = NULL; + fLockedArray = NULL; + + if (NULL != remaining) { + *remaining = env->CallStaticIntMethod(gNIOAccess_classID, + gNIOAccess_getRemainingBytes, + fBuffer); + if (GraphicsJNI::hasException(env)) { + return NULL; + } + } + + jlong pointer = env->CallStaticLongMethod(gNIOAccess_classID, + gNIOAccess_getBasePointer, + fBuffer); + if (GraphicsJNI::hasException(env)) { + return NULL; + } + if (0 != pointer) { + return reinterpret_cast<void*>(pointer); + } + + fLockedArray = (jbyteArray)env->CallStaticObjectMethod(gNIOAccess_classID, + gNIOAccess_getBaseArray, + fBuffer); + if (GraphicsJNI::hasException(env) || NULL == fLockedArray) { + return NULL; + } + jint offset = env->CallStaticIntMethod(gNIOAccess_classID, + gNIOAccess_getBaseArrayOffset, + fBuffer); + fLockedPtr = env->GetByteArrayElements(fLockedArray, NULL); + if (GraphicsJNI::hasException(env)) { + SkDebugf("------------ failed to lockarray %x\n", fLockedArray); + return NULL; + } +#ifdef TRACE_ARRAY_LOCKS + SkDebugf("------------ lockarray %x %p %d\n", + fLockedArray, fLockedPtr, gLockCount++); +#endif + if (NULL == fLockedPtr) { + offset = 0; + } + return (char*)fLockedPtr + offset; +} + +void NIOBuffer::unlock(JNIEnv* env, bool dataChanged) { + if (NULL != fLockedPtr) { +#ifdef TRACE_ARRAY_LOCKS + SkDebugf("------------ unlockarray %x %p %d\n", + fLockedArray, fLockedPtr, --gLockCount); +#endif + env->ReleaseByteArrayElements(fLockedArray, (jbyte*)fLockedPtr, + dataChanged ? 0 : JNI_ABORT); + + fLockedPtr = NULL; + fLockedArray = NULL; + } else { + SkDebugf("============= unlock called with null ptr %x\n", fLockedArray); + } +} + diff --git a/core/jni/android/graphics/NIOBuffer.h b/core/jni/android/graphics/NIOBuffer.h new file mode 100644 index 0000000..36b5554 --- /dev/null +++ b/core/jni/android/graphics/NIOBuffer.h @@ -0,0 +1,27 @@ +#ifndef NIOBuffer_DEFINED +#define NIOBuffer_DEFINED + +#include <jni.h> +#include "SkBitmap.h" + +class NIOBuffer { +public: + NIOBuffer(JNIEnv* env, jobject buffer); + // this checks to ensure that free() was called + ~NIOBuffer(); + + void* lock(JNIEnv* env, int* remaining); + void unlock(JNIEnv* env, bool dataChanged); + // must be called before destructor + void free(JNIEnv* env); + + // call once on boot, to setup JNI globals + static void RegisterJNI(JNIEnv*); + +private: + jobject fBuffer; + void* fLockedPtr; + jbyteArray fLockedArray; +}; + +#endif diff --git a/core/jni/android/graphics/NinePatch.cpp b/core/jni/android/graphics/NinePatch.cpp new file mode 100644 index 0000000..a098d89 --- /dev/null +++ b/core/jni/android/graphics/NinePatch.cpp @@ -0,0 +1,142 @@ +#include <utils/ResourceTypes.h> + +#include "SkRegion.h" +#include "GraphicsJNI.h" + +#include "JNIHelp.h" + +extern void NinePatch_Draw(SkCanvas* canvas, const SkRect& bounds, + const SkBitmap& bitmap, const android::Res_png_9patch& chunk, + const SkPaint* paint, SkRegion** outRegion); + +using namespace android; + +class SkNinePatchGlue { +public: + static jboolean isNinePatchChunk(JNIEnv* env, jobject, jbyteArray obj) + { + if (NULL == obj) { + return false; + } + if (env->GetArrayLength(obj) < (int)sizeof(Res_png_9patch)) { + return false; + } + jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(obj, 0); + if (array != NULL) + { + Res_png_9patch* chunk = (Res_png_9patch*)array; + int8_t numXDivs = chunk->numXDivs; + env->ReleasePrimitiveArrayCritical(obj, array, 0); + return array[0] != -1; + } + return false; + } + + static void validateNinePatchChunk(JNIEnv* env, jobject, jint, jbyteArray obj) + { + if (env->GetArrayLength(obj) < (int) (sizeof(Res_png_9patch))) { + jniThrowException(env, "java/lang/RuntimeException", + "Array too small for chunk."); + return; + } + + // XXX Also check that dimensions are correct. + } + + static void draw(JNIEnv* env, SkCanvas* canvas, SkRect& bounds, + const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint) + { + jbyte* array = env->GetByteArrayElements(chunkObj, 0); + if (array != NULL) + { + size_t chunkSize = env->GetArrayLength(chunkObj); + void* deserializedArray = alloca(chunkSize); + Res_png_9patch* chunk = (Res_png_9patch*) deserializedArray; + assert(chunkSize == ((Res_png_9patch*) array)->serializedSize()); + memcpy(chunk, array, chunkSize); + Res_png_9patch::deserialize(chunk); + NinePatch_Draw(canvas, bounds, *bitmap, *chunk, paint, NULL); + env->ReleaseByteArrayElements(chunkObj, array, 0); + } + } + + static void drawF(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRectF, + const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint) + { + SkASSERT(canvas); + SkASSERT(boundsRectF); + SkASSERT(bitmap); + SkASSERT(chunkObj); + // paint is optional + + SkRect bounds; + GraphicsJNI::jrectf_to_rect(env, boundsRectF, &bounds); + + draw(env, canvas, bounds, bitmap, chunkObj, paint); + } + + static void drawI(JNIEnv* env, jobject, SkCanvas* canvas, jobject boundsRect, + const SkBitmap* bitmap, jbyteArray chunkObj, const SkPaint* paint) + { + SkASSERT(canvas); + SkASSERT(boundsRect); + SkASSERT(bitmap); + SkASSERT(chunkObj); + // paint is optional + + SkRect bounds; + GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds); + draw(env, canvas, bounds, bitmap, chunkObj, paint); + } + + static jint getTransparentRegion(JNIEnv* env, jobject, + const SkBitmap* bitmap, jbyteArray chunkObj, + jobject boundsRect) + { + SkASSERT(bitmap); + SkASSERT(chunkObj); + SkASSERT(boundsRect); + + SkRect bounds; + GraphicsJNI::jrect_to_rect(env, boundsRect, &bounds); + jbyte* array = (jbyte*)env->GetByteArrayElements(chunkObj, 0); + if (array != NULL) + { + size_t chunkSize = env->GetArrayLength(chunkObj); + void* deserializedArray = alloca(chunkSize); + Res_png_9patch* chunk = (Res_png_9patch*) deserializedArray; + assert(chunkSize == ((Res_png_9patch*) array)->serializedSize()); + memcpy(chunk, array, chunkSize); + Res_png_9patch::deserialize(chunk); + SkRegion* region = NULL; + NinePatch_Draw(NULL, bounds, *bitmap, *chunk, NULL, ®ion); + env->ReleaseByteArrayElements(chunkObj, array, 0); + return (jint)region; + } + + return 0; + } + +}; + +///////////////////////////////////////////////////////////////////////////////////////// + +#include <android_runtime/AndroidRuntime.h> + +static JNINativeMethod gNinePatchMethods[] = { + { "isNinePatchChunk", "([B)Z", (void*)SkNinePatchGlue::isNinePatchChunk }, + { "validateNinePatchChunk", "(I[B)V", (void*)SkNinePatchGlue::validateNinePatchChunk }, + { "nativeDraw", "(ILandroid/graphics/RectF;I[BI)V", (void*)SkNinePatchGlue::drawF }, + { "nativeDraw", "(ILandroid/graphics/Rect;I[BI)V", (void*)SkNinePatchGlue::drawI }, + { "nativeGetTransparentRegion", "(I[BLandroid/graphics/Rect;)I", + (void*)SkNinePatchGlue::getTransparentRegion } +}; + +int register_android_graphics_NinePatch(JNIEnv* env); +int register_android_graphics_NinePatch(JNIEnv* env) +{ + return android::AndroidRuntime::registerNativeMethods(env, + "android/graphics/NinePatch", + gNinePatchMethods, + SK_ARRAY_COUNT(gNinePatchMethods)); +} diff --git a/core/jni/android/graphics/NinePatchImpl.cpp b/core/jni/android/graphics/NinePatchImpl.cpp new file mode 100644 index 0000000..ba63ae4 --- /dev/null +++ b/core/jni/android/graphics/NinePatchImpl.cpp @@ -0,0 +1,320 @@ +/* +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "NinePatch" + +#include <utils/ResourceTypes.h> + +#include "SkBitmap.h" +#include "SkCanvas.h" +#include "SkNinePatch.h" +#include "SkPaint.h" +#include "SkUnPreMultiply.h" + +#define USE_TRACEx + +#ifdef USE_TRACE + static bool gTrace; +#endif + +#include "SkColorPriv.h" + +#include <utils/Log.h> + +static bool getColor(const SkBitmap& bitmap, int x, int y, SkColor* c) { + switch (bitmap.getConfig()) { + case SkBitmap::kARGB_8888_Config: + *c = SkUnPreMultiply::PMColorToColor(*bitmap.getAddr32(x, y)); + break; + case SkBitmap::kRGB_565_Config: + *c = SkPixel16ToPixel32(*bitmap.getAddr16(x, y)); + break; + case SkBitmap::kARGB_4444_Config: + *c = SkUnPreMultiply::PMColorToColor( + SkPixel4444ToPixel32(*bitmap.getAddr16(x, y))); + break; + case SkBitmap::kIndex8_Config: { + SkColorTable* ctable = bitmap.getColorTable(); + *c = SkUnPreMultiply::PMColorToColor( + (*ctable)[*bitmap.getAddr8(x, y)]); + break; + } + default: + return false; + } + return true; +} + +static SkColor modAlpha(SkColor c, int alpha) { + int scale = alpha + (alpha >> 7); + int a = SkColorGetA(c) * scale >> 8; + return SkColorSetA(c, a); +} + +static void drawStretchyPatch(SkCanvas* canvas, SkIRect& src, const SkRect& dst, + const SkBitmap& bitmap, const SkPaint& paint, + SkColor initColor, uint32_t colorHint, + bool hasXfer) { + if (colorHint != android::Res_png_9patch::NO_COLOR) { + ((SkPaint*)&paint)->setColor(modAlpha(colorHint, paint.getAlpha())); + canvas->drawRect(dst, paint); + ((SkPaint*)&paint)->setColor(initColor); + } else if (src.width() == 1 && src.height() == 1) { + SkColor c; + if (!getColor(bitmap, src.fLeft, src.fTop, &c)) { + goto SLOW_CASE; + } + if (0 != c || hasXfer) { + SkColor prev = paint.getColor(); + ((SkPaint*)&paint)->setColor(c); + canvas->drawRect(dst, paint); + ((SkPaint*)&paint)->setColor(prev); + } + } else { + SLOW_CASE: + canvas->drawBitmapRect(bitmap, &src, dst, &paint); + } +} + +SkScalar calculateStretch(SkScalar boundsLimit, SkScalar startingPoint, + int srcSpace, int numStrechyPixelsRemaining, + int numFixedPixelsRemaining) { + SkScalar spaceRemaining = boundsLimit - startingPoint; + SkScalar stretchySpaceRemaining = + spaceRemaining - SkIntToScalar(numFixedPixelsRemaining); + return SkScalarMulDiv(srcSpace, stretchySpaceRemaining, + numStrechyPixelsRemaining); +} + +void NinePatch_Draw(SkCanvas* canvas, const SkRect& bounds, + const SkBitmap& bitmap, const android::Res_png_9patch& chunk, + const SkPaint* paint, SkRegion** outRegion) { + // if our canvas is GL, draw this as a mesh, which will be faster than + // in parts (which is faster for raster) + if (canvas && canvas->getViewport(NULL)) { + SkNinePatch::DrawMesh(canvas, bounds, bitmap, + chunk.xDivs, chunk.numXDivs, + chunk.yDivs, chunk.numYDivs, + paint); + return; + } + +#ifdef USE_TRACE + gTrace = true; +#endif + + SkASSERT(canvas || outRegion); + +#if 0 + if (canvas) { + const SkMatrix& m = canvas->getTotalMatrix(); + SkDebugf("ninepatch [%g %g %g] [%g %g %g]\n", + SkScalarToFloat(m[0]), SkScalarToFloat(m[1]), SkScalarToFloat(m[2]), + SkScalarToFloat(m[3]), SkScalarToFloat(m[4]), SkScalarToFloat(m[5])); + } +#endif + +#ifdef USE_TRACE + if (gTrace) { + SkDEBUGF(("======== ninepatch bounds [%g %g]\n", SkScalarToFloat(bounds.width()), SkScalarToFloat(bounds.height()))); + SkDEBUGF(("======== ninepatch paint bm [%d,%d]\n", bitmap.width(), bitmap.height())); + SkDEBUGF(("======== ninepatch xDivs [%d,%d]\n", chunk.xDivs[0], chunk.xDivs[1])); + SkDEBUGF(("======== ninepatch yDivs [%d,%d]\n", chunk.yDivs[0], chunk.yDivs[1])); + } +#endif + + if (bounds.isEmpty() || + bitmap.width() == 0 || bitmap.height() == 0 || + (paint && paint->getXfermode() == NULL && paint->getAlpha() == 0)) + { +#ifdef USE_TRACE + if (gTrace) SkDEBUGF(("======== abort ninepatch draw\n")); +#endif + return; + } + + // should try a quick-reject test before calling lockPixels + + SkAutoLockPixels alp(bitmap); + // after the lock, it is valid to check getPixels() + if (bitmap.getPixels() == NULL) + return; + + SkPaint defaultPaint; + if (NULL == paint) { + paint = &defaultPaint; + } + + const bool hasXfer = paint->getXfermode() != NULL; + SkRect dst; + SkIRect src; + + const int32_t x0 = chunk.xDivs[0]; + const int32_t y0 = chunk.yDivs[0]; + const SkColor initColor = ((SkPaint*)paint)->getColor(); + const uint8_t numXDivs = chunk.numXDivs; + const uint8_t numYDivs = chunk.numYDivs; + int i; + int j; + int colorIndex = 0; + uint32_t color; + bool xIsStretchable; + const bool initialXIsStretchable = (x0 == 0); + bool yIsStretchable = (y0 == 0); + const int bitmapWidth = bitmap.width(); + const int bitmapHeight = bitmap.height(); + + SkScalar* dstRights = (SkScalar*) alloca((numXDivs + 1) * sizeof(SkScalar)); + bool dstRightsHaveBeenCached = false; + + int numStretchyXPixelsRemaining = 0; + for (i = 0; i < numXDivs; i += 2) { + numStretchyXPixelsRemaining += chunk.xDivs[i + 1] - chunk.xDivs[i]; + } + int numFixedXPixelsRemaining = bitmapWidth - numStretchyXPixelsRemaining; + int numStretchyYPixelsRemaining = 0; + for (i = 0; i < numYDivs; i += 2) { + numStretchyYPixelsRemaining += chunk.yDivs[i + 1] - chunk.yDivs[i]; + } + int numFixedYPixelsRemaining = bitmapHeight - numStretchyYPixelsRemaining; + +#if 0 + SkDebugf("NinePatch [%d %d] bounds [%g %g %g %g] divs [%d %d]\n", + bitmap.width(), bitmap.height(), + SkScalarToFloat(bounds.fLeft), SkScalarToFloat(bounds.fTop), + SkScalarToFloat(bounds.width()), SkScalarToFloat(bounds.height()), + numXDivs, numYDivs); +#endif + + src.fTop = 0; + dst.fTop = bounds.fTop; + // The first row always starts with the top being at y=0 and the bottom + // being either yDivs[1] (if yDivs[0]=0) of yDivs[0]. In the former case + // the first row is stretchable along the Y axis, otherwise it is fixed. + // The last row always ends with the bottom being bitmap.height and the top + // being either yDivs[numYDivs-2] (if yDivs[numYDivs-1]=bitmap.height) or + // yDivs[numYDivs-1]. In the former case the last row is stretchable along + // the Y axis, otherwise it is fixed. + // + // The first and last columns are similarly treated with respect to the X + // axis. + // + // The above is to help explain some of the special casing that goes on the + // code below. + + // The initial yDiv and whether the first row is considered stretchable or + // not depends on whether yDiv[0] was zero or not. + for (j = yIsStretchable ? 1 : 0; + j <= numYDivs && src.fTop < bitmapHeight; + j++, yIsStretchable = !yIsStretchable) { + src.fLeft = 0; + dst.fLeft = bounds.fLeft; + if (j == numYDivs) { + src.fBottom = bitmapHeight; + dst.fBottom = bounds.fBottom; + } else { + src.fBottom = chunk.yDivs[j]; + const int srcYSize = src.fBottom - src.fTop; + if (yIsStretchable) { + dst.fBottom = dst.fTop + calculateStretch(bounds.fBottom, dst.fTop, + srcYSize, + numStretchyYPixelsRemaining, + numFixedYPixelsRemaining); + numStretchyYPixelsRemaining -= srcYSize; + } else { + dst.fBottom = dst.fTop + SkIntToScalar(srcYSize); + numFixedYPixelsRemaining -= srcYSize; + } + } + + xIsStretchable = initialXIsStretchable; + // The initial xDiv and whether the first column is considered + // stretchable or not depends on whether xDiv[0] was zero or not. + for (i = xIsStretchable ? 1 : 0; + i <= numXDivs && src.fLeft < bitmapWidth; + i++, xIsStretchable = !xIsStretchable) { + color = chunk.colors[colorIndex++]; + if (i == numXDivs) { + src.fRight = bitmapWidth; + dst.fRight = bounds.fRight; + } else { + src.fRight = chunk.xDivs[i]; + if (dstRightsHaveBeenCached) { + dst.fRight = dstRights[i]; + } else { + const int srcXSize = src.fRight - src.fLeft; + if (xIsStretchable) { + dst.fRight = dst.fLeft + calculateStretch(bounds.fRight, dst.fLeft, + srcXSize, + numStretchyXPixelsRemaining, + numFixedXPixelsRemaining); + numStretchyXPixelsRemaining -= srcXSize; + } else { + dst.fRight = dst.fLeft + SkIntToScalar(srcXSize); + numFixedXPixelsRemaining -= srcXSize; + } + dstRights[i] = dst.fRight; + } + } + // If this horizontal patch is too small to be displayed, leave + // the destination left edge where it is and go on to the next patch + // in the source. + if (src.fLeft >= src.fRight) { + src.fLeft = src.fRight; + continue; + } + // Make sure that we actually have room to draw any bits + if (dst.fRight <= dst.fLeft || dst.fBottom <= dst.fTop) { + goto nextDiv; + } + // If this patch is transparent, skip and don't draw. + if (color == android::Res_png_9patch::TRANSPARENT_COLOR && !hasXfer) { + if (outRegion) { + if (*outRegion == NULL) { + *outRegion = new SkRegion(); + } + SkIRect idst; + dst.round(&idst); + //LOGI("Adding trans rect: (%d,%d)-(%d,%d)\n", + // idst.fLeft, idst.fTop, idst.fRight, idst.fBottom); + (*outRegion)->op(idst, SkRegion::kUnion_Op); + } + goto nextDiv; + } + if (canvas) { +#if 0 + SkDebugf("-- src [%d %d %d %d] dst [%g %g %g %g]\n", + src.fLeft, src.fTop, src.width(), src.height(), + SkScalarToFloat(dst.fLeft), SkScalarToFloat(dst.fTop), + SkScalarToFloat(dst.width()), SkScalarToFloat(dst.height())); + if (2 == src.width() && SkIntToScalar(5) == dst.width()) { + SkDebugf("--- skip patch\n"); + } +#endif + drawStretchyPatch(canvas, src, dst, bitmap, *paint, initColor, + color, hasXfer); + } + +nextDiv: + src.fLeft = src.fRight; + dst.fLeft = dst.fRight; + } + src.fTop = src.fBottom; + dst.fTop = dst.fBottom; + dstRightsHaveBeenCached = true; + } +} diff --git a/core/jni/android/graphics/Paint.cpp b/core/jni/android/graphics/Paint.cpp new file mode 100644 index 0000000..05830de --- /dev/null +++ b/core/jni/android/graphics/Paint.cpp @@ -0,0 +1,605 @@ +/* libs/android_runtime/android/graphics/Paint.cpp +** +** Copyright 2006, 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. +*/ + +// This file was generated from the C++ include file: SkPaint.h +// Any changes made to this file will be discarded by the build. +// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, +// or one of the auxilary file specifications in device/tools/gluemaker. + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkBlurDrawLooper.h" +#include "SkColorFilter.h" +#include "SkMaskFilter.h" +#include "SkRasterizer.h" +#include "SkShader.h" +#include "SkTypeface.h" +#include "SkXfermode.h" + +namespace android { + +struct JMetricsID { + jfieldID top; + jfieldID ascent; + jfieldID descent; + jfieldID bottom; + jfieldID leading; +}; + +static jclass gFontMetrics_class; +static JMetricsID gFontMetrics_fieldID; + +static jclass gFontMetricsInt_class; +static JMetricsID gFontMetricsInt_fieldID; + +class SkPaintGlue { +public: + + static void finalizer(JNIEnv* env, jobject clazz, SkPaint* obj) { + delete obj; + } + + static SkPaint* init(JNIEnv* env, jobject clazz) { + SkPaint* obj = new SkPaint(); + // utf16 is required for java + obj->setTextEncoding(SkPaint::kUTF16_TextEncoding); + return obj; + } + + static SkPaint* intiWithPaint(JNIEnv* env, jobject clazz, SkPaint* paint) { + SkPaint* obj = new SkPaint(*paint); + return obj; + } + + static void reset(JNIEnv* env, jobject clazz, SkPaint* obj) { + obj->reset(); + } + + static void assign(JNIEnv* env, jobject clazz, SkPaint* dst, const SkPaint* src) { + *dst = *src; + } + + static jint getFlags(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + return GraphicsJNI::getNativePaint(env, paint)->getFlags(); + } + + static void setFlags(JNIEnv* env, jobject paint, jint flags) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setFlags(flags); + } + + static void setAntiAlias(JNIEnv* env, jobject paint, jboolean aa) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setAntiAlias(aa); + } + + static void setLinearText(JNIEnv* env, jobject paint, jboolean linearText) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setLinearText(linearText); + } + + static void setSubpixelText(JNIEnv* env, jobject paint, jboolean subpixelText) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setSubpixelText(subpixelText); + } + + static void setUnderlineText(JNIEnv* env, jobject paint, jboolean underlineText) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setUnderlineText(underlineText); + } + + static void setStrikeThruText(JNIEnv* env, jobject paint, jboolean strikeThruText) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setStrikeThruText(strikeThruText); + } + + static void setFakeBoldText(JNIEnv* env, jobject paint, jboolean fakeBoldText) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setFakeBoldText(fakeBoldText); + } + + static void setFilterBitmap(JNIEnv* env, jobject paint, jboolean filterBitmap) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setFilterBitmap(filterBitmap); + } + + static void setDither(JNIEnv* env, jobject paint, jboolean dither) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setDither(dither); + } + + static jint getStyle(JNIEnv* env, jobject clazz, SkPaint* obj) { + return obj->getStyle(); + } + + static void setStyle(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Style style) { + obj->setStyle(style); + } + + static jint getColor(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + return GraphicsJNI::getNativePaint(env, paint)->getColor(); + } + + static jint getAlpha(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + return GraphicsJNI::getNativePaint(env, paint)->getAlpha(); + } + + static void setColor(JNIEnv* env, jobject paint, jint color) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setColor(color); + } + + static void setAlpha(JNIEnv* env, jobject paint, jint a) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setAlpha(a); + } + + static jfloat getStrokeWidth(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getStrokeWidth()); + } + + static void setStrokeWidth(JNIEnv* env, jobject paint, jfloat width) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setStrokeWidth(SkFloatToScalar(width)); + } + + static jfloat getStrokeMiter(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getStrokeMiter()); + } + + static void setStrokeMiter(JNIEnv* env, jobject paint, jfloat miter) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setStrokeMiter(SkFloatToScalar(miter)); + } + + static jint getStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj) { + return obj->getStrokeCap(); + } + + static void setStrokeCap(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Cap cap) { + obj->setStrokeCap(cap); + } + + static jint getStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj) { + return obj->getStrokeJoin(); + } + + static void setStrokeJoin(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Join join) { + obj->setStrokeJoin(join); + } + + static jboolean getFillPath(JNIEnv* env, jobject clazz, SkPaint* obj, SkPath* src, SkPath* dst) { + return obj->getFillPath(*src, dst); + } + + static SkShader* setShader(JNIEnv* env, jobject clazz, SkPaint* obj, SkShader* shader) { + return obj->setShader(shader); + } + + static SkColorFilter* setColorFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkColorFilter* filter) { + return obj->setColorFilter(filter); + } + + static SkXfermode* setXfermode(JNIEnv* env, jobject clazz, SkPaint* obj, SkXfermode* xfermode) { + return obj->setXfermode(xfermode); + } + + static SkPathEffect* setPathEffect(JNIEnv* env, jobject clazz, SkPaint* obj, SkPathEffect* effect) { + return obj->setPathEffect(effect); + } + + static SkMaskFilter* setMaskFilter(JNIEnv* env, jobject clazz, SkPaint* obj, SkMaskFilter* maskfilter) { + return obj->setMaskFilter(maskfilter); + } + + static SkTypeface* setTypeface(JNIEnv* env, jobject clazz, SkPaint* obj, SkTypeface* typeface) { + return obj->setTypeface(typeface); + } + + static SkRasterizer* setRasterizer(JNIEnv* env, jobject clazz, SkPaint* obj, SkRasterizer* rasterizer) { + return obj->setRasterizer(rasterizer); + } + + static jint getTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj) { + return obj->getTextAlign(); + } + + static void setTextAlign(JNIEnv* env, jobject clazz, SkPaint* obj, SkPaint::Align align) { + obj->setTextAlign(align); + } + + static jfloat getTextSize(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getTextSize()); + } + + static void setTextSize(JNIEnv* env, jobject paint, jfloat textSize) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setTextSize(SkFloatToScalar(textSize)); + } + + static jfloat getTextScaleX(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getTextScaleX()); + } + + static void setTextScaleX(JNIEnv* env, jobject paint, jfloat scaleX) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setTextScaleX(SkFloatToScalar(scaleX)); + } + + static jfloat getTextSkewX(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + return SkScalarToFloat(GraphicsJNI::getNativePaint(env, paint)->getTextSkewX()); + } + + static void setTextSkewX(JNIEnv* env, jobject paint, jfloat skewX) { + NPE_CHECK_RETURN_VOID(env, paint); + GraphicsJNI::getNativePaint(env, paint)->setTextSkewX(SkFloatToScalar(skewX)); + } + + static jfloat ascent(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + SkPaint::FontMetrics metrics; + (void)GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics); + return SkScalarToFloat(metrics.fAscent); + } + + static jfloat descent(JNIEnv* env, jobject paint) { + NPE_CHECK_RETURN_ZERO(env, paint); + SkPaint::FontMetrics metrics; + (void)GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics); + return SkScalarToFloat(metrics.fDescent); + } + + static jfloat getFontMetrics(JNIEnv* env, jobject paint, jobject metricsObj) { + NPE_CHECK_RETURN_ZERO(env, paint); + SkPaint::FontMetrics metrics; + SkScalar spacing = GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics); + + if (metricsObj) { + SkASSERT(env->IsInstanceOf(metricsObj, gFontMetrics_class)); + env->SetFloatField(metricsObj, gFontMetrics_fieldID.top, SkScalarToFloat(metrics.fTop)); + env->SetFloatField(metricsObj, gFontMetrics_fieldID.ascent, SkScalarToFloat(metrics.fAscent)); + env->SetFloatField(metricsObj, gFontMetrics_fieldID.descent, SkScalarToFloat(metrics.fDescent)); + env->SetFloatField(metricsObj, gFontMetrics_fieldID.bottom, SkScalarToFloat(metrics.fBottom)); + env->SetFloatField(metricsObj, gFontMetrics_fieldID.leading, SkScalarToFloat(metrics.fLeading)); + } + return SkScalarToFloat(spacing); + } + + static jint getFontMetricsInt(JNIEnv* env, jobject paint, jobject metricsObj) { + NPE_CHECK_RETURN_ZERO(env, paint); + SkPaint::FontMetrics metrics; + + GraphicsJNI::getNativePaint(env, paint)->getFontMetrics(&metrics); + int ascent = SkScalarRound(metrics.fAscent); + int descent = SkScalarRound(metrics.fDescent); + int leading = SkScalarRound(metrics.fLeading); + + if (metricsObj) { + SkASSERT(env->IsInstanceOf(metricsObj, gFontMetricsInt_class)); + env->SetIntField(metricsObj, gFontMetricsInt_fieldID.top, SkScalarFloor(metrics.fTop)); + env->SetIntField(metricsObj, gFontMetricsInt_fieldID.ascent, ascent); + env->SetIntField(metricsObj, gFontMetricsInt_fieldID.descent, descent); + env->SetIntField(metricsObj, gFontMetricsInt_fieldID.bottom, SkScalarCeil(metrics.fBottom)); + env->SetIntField(metricsObj, gFontMetricsInt_fieldID.leading, leading); + } + return descent - ascent + leading; + } + + static jfloat measureText_CII(JNIEnv* env, jobject jpaint, jcharArray text, int index, int count) { + NPE_CHECK_RETURN_ZERO(env, jpaint); + NPE_CHECK_RETURN_ZERO(env, text); + + SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint); + jchar* textArray = env->GetCharArrayElements(text, NULL); + size_t textLength = env->GetArrayLength(text); + + if ((index | count) < 0 || (size_t)(index + count) > textLength) { + doThrow(env, "ArrayIndexOutOfBoundsException"); + return 0; + } + + jfloat width = SkScalarToFloat(paint->measureText(textArray + index, count << 1)); + env->ReleaseCharArrayElements(text, textArray, 0); + return width; + } + + static jfloat measureText_StringII(JNIEnv* env, jobject jpaint, jstring text, int start, int end) { + NPE_CHECK_RETURN_ZERO(env, jpaint); + NPE_CHECK_RETURN_ZERO(env, text); + + SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint); + const jchar* textArray = env->GetStringChars(text, NULL); + size_t textLength = env->GetStringLength(text); + + int count = end - start; + if ((start | count) < 0 || (size_t)count > textLength) { + doThrow(env, "IndexOutOfBoundsException"); + return 0; + } + + jfloat width = SkScalarToFloat(paint->measureText(textArray + start, count << 1)); + env->ReleaseStringChars(text, textArray); + return width; + } + + static jfloat measureText_String(JNIEnv* env, jobject jpaint, jstring text) { + NPE_CHECK_RETURN_ZERO(env, jpaint); + NPE_CHECK_RETURN_ZERO(env, text); + + SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint); + const jchar* textArray = env->GetStringChars(text, NULL); + size_t textLength = env->GetStringLength(text); + + jfloat width = SkScalarToFloat(paint->measureText(textArray, textLength << 1)); + env->ReleaseStringChars(text, textArray); + return width; + } + + static int dotextwidths(JNIEnv* env, SkPaint* paint, const jchar text[], int count, jfloatArray widths) { + AutoJavaFloatArray autoWidths(env, widths, count); + jfloat* widthsArray = autoWidths.ptr(); + SkScalar* scalarArray = (SkScalar*)widthsArray; + + count = paint->getTextWidths(text, count << 1, scalarArray); + for (int i = 0; i < count; i++) { + widthsArray[i] = SkScalarToFloat(scalarArray[i]); + } + return count; + } + + static int getTextWidths___CII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text, int index, int count, jfloatArray widths) { + jchar* textArray = env->GetCharArrayElements(text, NULL); + count = dotextwidths(env, paint, textArray + index, count, widths); + env->ReleaseCharArrayElements(text, textArray, 0); + return count; + } + + static int getTextWidths__StringII_F(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text, int start, int end, jfloatArray widths) { + const jchar* textArray = env->GetStringChars(text, NULL); + int count = dotextwidths(env, paint, textArray + start, end - start, widths); + env->ReleaseStringChars(text, textArray); + return count; + } + + static void getTextPath___CIIFFPath(JNIEnv* env, jobject clazz, SkPaint* paint, jcharArray text, int index, int count, jfloat x, jfloat y, SkPath* path) { + jchar* textArray = env->GetCharArrayElements(text, NULL); + paint->getTextPath(textArray + index, count << 1, SkFloatToScalar(x), SkFloatToScalar(y), path); + env->ReleaseCharArrayElements(text, textArray, 0); + } + + static void getTextPath__StringIIFFPath(JNIEnv* env, jobject clazz, SkPaint* paint, jstring text, int start, int end, jfloat x, jfloat y, SkPath* path) { + const jchar* textArray = env->GetStringChars(text, NULL); + paint->getTextPath(textArray + start, (end - start) << 1, SkFloatToScalar(x), SkFloatToScalar(y), path); + env->ReleaseStringChars(text, textArray); + } + + static void setShadowLayer(JNIEnv* env, jobject jpaint, jfloat radius, + jfloat dx, jfloat dy, int color) { + NPE_CHECK_RETURN_VOID(env, jpaint); + + SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint); + if (radius <= 0) { + paint->setLooper(NULL); + } + else { + paint->setLooper(new SkBlurDrawLooper(SkFloatToScalar(radius), + SkFloatToScalar(dx), + SkFloatToScalar(dy), + (SkColor)color))->unref(); + } + } + + static int breakText(JNIEnv* env, const SkPaint& paint, const jchar text[], + int count, float maxWidth, jfloatArray jmeasured, + SkPaint::TextBufferDirection tbd) { + SkASSERT(paint.getTextEncoding() == SkPaint::kUTF16_TextEncoding); + + SkScalar measured; + size_t bytes = paint.breakText(text, count << 1, + SkFloatToScalar(maxWidth), &measured, tbd); + SkASSERT((bytes & 1) == 0); + + if (jmeasured && env->GetArrayLength(jmeasured) > 0) { + AutoJavaFloatArray autoMeasured(env, jmeasured, 1); + jfloat* array = autoMeasured.ptr(); + array[0] = SkScalarToFloat(measured); + } + return bytes >> 1; + } + + static int breakTextC(JNIEnv* env, jobject jpaint, jcharArray jtext, + int index, int count, float maxWidth, jfloatArray jmeasuredWidth) { + NPE_CHECK_RETURN_ZERO(env, jpaint); + NPE_CHECK_RETURN_ZERO(env, jtext); + + SkPaint::TextBufferDirection tbd; + if (count < 0) { + tbd = SkPaint::kBackward_TextBufferDirection; + count = -count; + } + else { + tbd = SkPaint::kForward_TextBufferDirection; + } + + if ((index < 0) || (index + count > env->GetArrayLength(jtext))) { + doThrow(env, "java/lang/ArrayIndexOutOfBoundsException"); + return 0; + } + + SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint); + jchar* text = env->GetCharArrayElements(jtext, NULL); + count = breakText(env, *paint, text + index, count, maxWidth, + jmeasuredWidth, tbd); + env->ReleaseCharArrayElements(jtext, text, 0); + return count; + } + + static int breakTextS(JNIEnv* env, jobject jpaint, jstring jtext, + bool forwards, float maxWidth, jfloatArray jmeasuredWidth) { + NPE_CHECK_RETURN_ZERO(env, jpaint); + NPE_CHECK_RETURN_ZERO(env, jtext); + + SkPaint::TextBufferDirection tbd = forwards ? + SkPaint::kForward_TextBufferDirection : + SkPaint::kBackward_TextBufferDirection; + + SkPaint* paint = GraphicsJNI::getNativePaint(env, jpaint); + int count = env->GetStringLength(jtext); + const jchar* text = env->GetStringChars(jtext, NULL); + count = breakText(env, *paint, text, count, maxWidth, + jmeasuredWidth, tbd); + env->ReleaseStringChars(jtext, text); + return count; + } + + static void doTextBounds(JNIEnv* env, const jchar* text, int count, + jobject bounds, const SkPaint& paint) + { + SkRect r; + SkIRect ir; + + paint.measureText(text, count << 1, &r); + r.roundOut(&ir); + GraphicsJNI::irect_to_jrect(ir, env, bounds); + } + + static void getStringBounds(JNIEnv* env, jobject, const SkPaint* paint, + jstring text, int start, int end, jobject bounds) + { + const jchar* textArray = env->GetStringChars(text, NULL); + doTextBounds(env, textArray + start, end - start, bounds, *paint); + env->ReleaseStringChars(text, textArray); + } + + static void getCharArrayBounds(JNIEnv* env, jobject, const SkPaint* paint, + jcharArray text, int index, int count, jobject bounds) + { + jchar* textArray = env->GetCharArrayElements(text, NULL); + doTextBounds(env, textArray + index, count, bounds, *paint); + env->ReleaseCharArrayElements(text, textArray, 0); + } + +}; + +static JNINativeMethod methods[] = { + {"finalizer", "(I)V", (void*) SkPaintGlue::finalizer}, + {"native_init","()I", (void*) SkPaintGlue::init}, + {"native_initWithPaint","(I)I", (void*) SkPaintGlue::intiWithPaint}, + {"native_reset","(I)V", (void*) SkPaintGlue::reset}, + {"native_set","(II)V", (void*) SkPaintGlue::assign}, + {"getFlags","()I", (void*) SkPaintGlue::getFlags}, + {"setFlags","(I)V", (void*) SkPaintGlue::setFlags}, + {"setAntiAlias","(Z)V", (void*) SkPaintGlue::setAntiAlias}, + {"setSubpixelText","(Z)V", (void*) SkPaintGlue::setSubpixelText}, + {"setLinearText","(Z)V", (void*) SkPaintGlue::setLinearText}, + {"setUnderlineText","(Z)V", (void*) SkPaintGlue::setUnderlineText}, + {"setStrikeThruText","(Z)V", (void*) SkPaintGlue::setStrikeThruText}, + {"setFakeBoldText","(Z)V", (void*) SkPaintGlue::setFakeBoldText}, + {"setFilterBitmap","(Z)V", (void*) SkPaintGlue::setFilterBitmap}, + {"setDither","(Z)V", (void*) SkPaintGlue::setDither}, + {"native_getStyle","(I)I", (void*) SkPaintGlue::getStyle}, + {"native_setStyle","(II)V", (void*) SkPaintGlue::setStyle}, + {"getColor","()I", (void*) SkPaintGlue::getColor}, + {"setColor","(I)V", (void*) SkPaintGlue::setColor}, + {"getAlpha","()I", (void*) SkPaintGlue::getAlpha}, + {"setAlpha","(I)V", (void*) SkPaintGlue::setAlpha}, + {"getStrokeWidth","()F", (void*) SkPaintGlue::getStrokeWidth}, + {"setStrokeWidth","(F)V", (void*) SkPaintGlue::setStrokeWidth}, + {"getStrokeMiter","()F", (void*) SkPaintGlue::getStrokeMiter}, + {"setStrokeMiter","(F)V", (void*) SkPaintGlue::setStrokeMiter}, + {"native_getStrokeCap","(I)I", (void*) SkPaintGlue::getStrokeCap}, + {"native_setStrokeCap","(II)V", (void*) SkPaintGlue::setStrokeCap}, + {"native_getStrokeJoin","(I)I", (void*) SkPaintGlue::getStrokeJoin}, + {"native_setStrokeJoin","(II)V", (void*) SkPaintGlue::setStrokeJoin}, + {"native_getFillPath","(III)Z", (void*) SkPaintGlue::getFillPath}, + {"native_setShader","(II)I", (void*) SkPaintGlue::setShader}, + {"native_setColorFilter","(II)I", (void*) SkPaintGlue::setColorFilter}, + {"native_setXfermode","(II)I", (void*) SkPaintGlue::setXfermode}, + {"native_setPathEffect","(II)I", (void*) SkPaintGlue::setPathEffect}, + {"native_setMaskFilter","(II)I", (void*) SkPaintGlue::setMaskFilter}, + {"native_setTypeface","(II)I", (void*) SkPaintGlue::setTypeface}, + {"native_setRasterizer","(II)I", (void*) SkPaintGlue::setRasterizer}, + {"native_getTextAlign","(I)I", (void*) SkPaintGlue::getTextAlign}, + {"native_setTextAlign","(II)V", (void*) SkPaintGlue::setTextAlign}, + {"getTextSize","()F", (void*) SkPaintGlue::getTextSize}, + {"setTextSize","(F)V", (void*) SkPaintGlue::setTextSize}, + {"getTextScaleX","()F", (void*) SkPaintGlue::getTextScaleX}, + {"setTextScaleX","(F)V", (void*) SkPaintGlue::setTextScaleX}, + {"getTextSkewX","()F", (void*) SkPaintGlue::getTextSkewX}, + {"setTextSkewX","(F)V", (void*) SkPaintGlue::setTextSkewX}, + {"ascent","()F", (void*) SkPaintGlue::ascent}, + {"descent","()F", (void*) SkPaintGlue::descent}, + {"getFontMetrics", "(Landroid/graphics/Paint$FontMetrics;)F", (void*)SkPaintGlue::getFontMetrics}, + {"getFontMetricsInt", "(Landroid/graphics/Paint$FontMetricsInt;)I", (void*)SkPaintGlue::getFontMetricsInt}, + {"measureText","([CII)F", (void*) SkPaintGlue::measureText_CII}, + {"measureText","(Ljava/lang/String;)F", (void*) SkPaintGlue::measureText_String}, + {"measureText","(Ljava/lang/String;II)F", (void*) SkPaintGlue::measureText_StringII}, + {"breakText","([CIIF[F)I", (void*) SkPaintGlue::breakTextC}, + {"breakText","(Ljava/lang/String;ZF[F)I", (void*) SkPaintGlue::breakTextS}, + {"native_getTextWidths","(I[CII[F)I", (void*) SkPaintGlue::getTextWidths___CII_F}, + {"native_getTextWidths","(ILjava/lang/String;II[F)I", (void*) SkPaintGlue::getTextWidths__StringII_F}, + {"native_getTextPath","(I[CIIFFI)V", (void*) SkPaintGlue::getTextPath___CIIFFPath}, + {"native_getTextPath","(ILjava/lang/String;IIFFI)V", (void*) SkPaintGlue::getTextPath__StringIIFFPath}, + {"nativeGetStringBounds", "(ILjava/lang/String;IILandroid/graphics/Rect;)V", + (void*) SkPaintGlue::getStringBounds }, + {"nativeGetCharArrayBounds", "(I[CIILandroid/graphics/Rect;)V", + (void*) SkPaintGlue::getCharArrayBounds }, + {"setShadowLayer", "(FFFI)V", (void*)SkPaintGlue::setShadowLayer} +}; + +static jfieldID req_fieldID(jfieldID id) { + SkASSERT(id); + return id; +} + +int register_android_graphics_Paint(JNIEnv* env) { + gFontMetrics_class = env->FindClass("android/graphics/Paint$FontMetrics"); + SkASSERT(gFontMetrics_class); + gFontMetrics_class = (jclass)env->NewGlobalRef(gFontMetrics_class); + + gFontMetrics_fieldID.top = req_fieldID(env->GetFieldID(gFontMetrics_class, "top", "F")); + gFontMetrics_fieldID.ascent = req_fieldID(env->GetFieldID(gFontMetrics_class, "ascent", "F")); + gFontMetrics_fieldID.descent = req_fieldID(env->GetFieldID(gFontMetrics_class, "descent", "F")); + gFontMetrics_fieldID.bottom = req_fieldID(env->GetFieldID(gFontMetrics_class, "bottom", "F")); + gFontMetrics_fieldID.leading = req_fieldID(env->GetFieldID(gFontMetrics_class, "leading", "F")); + + gFontMetricsInt_class = env->FindClass("android/graphics/Paint$FontMetricsInt"); + SkASSERT(gFontMetricsInt_class); + gFontMetricsInt_class = (jclass)env->NewGlobalRef(gFontMetricsInt_class); + + gFontMetricsInt_fieldID.top = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "top", "I")); + gFontMetricsInt_fieldID.ascent = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "ascent", "I")); + gFontMetricsInt_fieldID.descent = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "descent", "I")); + gFontMetricsInt_fieldID.bottom = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "bottom", "I")); + gFontMetricsInt_fieldID.leading = req_fieldID(env->GetFieldID(gFontMetricsInt_class, "leading", "I")); + + int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Paint", methods, + sizeof(methods) / sizeof(methods[0])); + return result; +} + +} diff --git a/core/jni/android/graphics/Path.cpp b/core/jni/android/graphics/Path.cpp new file mode 100644 index 0000000..effb1c8 --- /dev/null +++ b/core/jni/android/graphics/Path.cpp @@ -0,0 +1,306 @@ +/* libs/android_runtime/android/graphics/Path.cpp +** +** Copyright 2006, 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. +*/ + +// This file was generated from the C++ include file: SkPath.h +// Any changes made to this file will be discarded by the build. +// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, +// or one of the auxilary file specifications in device/tools/gluemaker. + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkPath.h" + +namespace android { + +class SkPathGlue { +public: + + static void finalizer(JNIEnv* env, jobject clazz, SkPath* obj) { + delete obj; + } + + static SkPath* init1(JNIEnv* env, jobject clazz) { + return new SkPath(); + } + + static SkPath* init2(JNIEnv* env, jobject clazz, SkPath* val) { + return new SkPath(*val); + } + + static void reset(JNIEnv* env, jobject clazz, SkPath* obj) { + obj->reset(); + } + + static void rewind(JNIEnv* env, jobject clazz, SkPath* obj) { + obj->rewind(); + } + + static void assign(JNIEnv* env, jobject clazz, SkPath* dst, const SkPath* src) { + *dst = *src; + } + + static jint getFillType(JNIEnv* env, jobject clazz, SkPath* obj) { + return obj->getFillType(); + } + + static void setFillType(JNIEnv* env, jobject clazz, SkPath* path, + SkPath::FillType ft) { + path->setFillType(ft); + } + + static jboolean isEmpty(JNIEnv* env, jobject clazz, SkPath* obj) { + return obj->isEmpty(); + } + + static jboolean isRect(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect) { + SkRect rect_; + jboolean result = obj->isRect(&rect_); + GraphicsJNI::rect_to_jrectf(rect_, env, rect); + return result; + } + + static void computeBounds(JNIEnv* env, jobject clazz, SkPath* obj, jobject bounds, SkPath::BoundsType btype) { + SkRect bounds_; + obj->computeBounds(&bounds_, btype); + GraphicsJNI::rect_to_jrectf(bounds_, env, bounds); + } + + static void incReserve(JNIEnv* env, jobject clazz, SkPath* obj, jint extraPtCount) { + obj->incReserve(extraPtCount); + } + + static void moveTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) { + SkScalar x_ = SkFloatToScalar(x); + SkScalar y_ = SkFloatToScalar(y); + obj->moveTo(x_, y_); + } + + static void rMoveTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + obj->rMoveTo(dx_, dy_); + } + + static void lineTo__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y) { + SkScalar x_ = SkFloatToScalar(x); + SkScalar y_ = SkFloatToScalar(y); + obj->lineTo(x_, y_); + } + + static void rLineTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + obj->rLineTo(dx_, dy_); + } + + static void quadTo__FFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2) { + SkScalar x1_ = SkFloatToScalar(x1); + SkScalar y1_ = SkFloatToScalar(y1); + SkScalar x2_ = SkFloatToScalar(x2); + SkScalar y2_ = SkFloatToScalar(y2); + obj->quadTo(x1_, y1_, x2_, y2_); + } + + static void rQuadTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx1, jfloat dy1, jfloat dx2, jfloat dy2) { + SkScalar dx1_ = SkFloatToScalar(dx1); + SkScalar dy1_ = SkFloatToScalar(dy1); + SkScalar dx2_ = SkFloatToScalar(dx2); + SkScalar dy2_ = SkFloatToScalar(dy2); + obj->rQuadTo(dx1_, dy1_, dx2_, dy2_); + } + + static void cubicTo__FFFFFF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + SkScalar x1_ = SkFloatToScalar(x1); + SkScalar y1_ = SkFloatToScalar(y1); + SkScalar x2_ = SkFloatToScalar(x2); + SkScalar y2_ = SkFloatToScalar(y2); + SkScalar x3_ = SkFloatToScalar(x3); + SkScalar y3_ = SkFloatToScalar(y3); + obj->cubicTo(x1_, y1_, x2_, y2_, x3_, y3_); + } + + static void rCubicTo(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x1, jfloat y1, jfloat x2, jfloat y2, jfloat x3, jfloat y3) { + SkScalar x1_ = SkFloatToScalar(x1); + SkScalar y1_ = SkFloatToScalar(y1); + SkScalar x2_ = SkFloatToScalar(x2); + SkScalar y2_ = SkFloatToScalar(y2); + SkScalar x3_ = SkFloatToScalar(x3); + SkScalar y3_ = SkFloatToScalar(y3); + obj->rCubicTo(x1_, y1_, x2_, y2_, x3_, y3_); + } + + static void arcTo(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle, jboolean forceMoveTo) { + SkRect oval_; + GraphicsJNI::jrectf_to_rect(env, oval, &oval_); + SkScalar startAngle_ = SkFloatToScalar(startAngle); + SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle); + obj->arcTo(oval_, startAngle_, sweepAngle_, forceMoveTo); + } + + static void close(JNIEnv* env, jobject clazz, SkPath* obj) { + obj->close(); + } + + static void addRect__RectFI(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, SkPath::Direction dir) { + SkRect rect_; + GraphicsJNI::jrectf_to_rect(env, rect, &rect_); + obj->addRect(rect_, dir); + } + + static void addRect__FFFFI(JNIEnv* env, jobject clazz, SkPath* obj, jfloat left, jfloat top, jfloat right, jfloat bottom, SkPath::Direction dir) { + SkScalar left_ = SkFloatToScalar(left); + SkScalar top_ = SkFloatToScalar(top); + SkScalar right_ = SkFloatToScalar(right); + SkScalar bottom_ = SkFloatToScalar(bottom); + obj->addRect(left_, top_, right_, bottom_, dir); + } + + static void addOval(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, SkPath::Direction dir) { + SkRect oval_; + GraphicsJNI::jrectf_to_rect(env, oval, &oval_); + obj->addOval(oval_, dir); + } + + static void addCircle(JNIEnv* env, jobject clazz, SkPath* obj, jfloat x, jfloat y, jfloat radius, SkPath::Direction dir) { + SkScalar x_ = SkFloatToScalar(x); + SkScalar y_ = SkFloatToScalar(y); + SkScalar radius_ = SkFloatToScalar(radius); + obj->addCircle(x_, y_, radius_, dir); + } + + static void addArc(JNIEnv* env, jobject clazz, SkPath* obj, jobject oval, jfloat startAngle, jfloat sweepAngle) { + SkRect oval_; + GraphicsJNI::jrectf_to_rect(env, oval, &oval_); + SkScalar startAngle_ = SkFloatToScalar(startAngle); + SkScalar sweepAngle_ = SkFloatToScalar(sweepAngle); + obj->addArc(oval_, startAngle_, sweepAngle_); + } + + static void addRoundRectXY(JNIEnv* env, jobject clazz, SkPath* obj, jobject rect, + jfloat rx, jfloat ry, SkPath::Direction dir) { + SkRect rect_; + GraphicsJNI::jrectf_to_rect(env, rect, &rect_); + SkScalar rx_ = SkFloatToScalar(rx); + SkScalar ry_ = SkFloatToScalar(ry); + obj->addRoundRect(rect_, rx_, ry_, dir); + } + + static void addRoundRect8(JNIEnv* env, jobject, SkPath* obj, jobject rect, + jfloatArray array, SkPath::Direction dir) { + SkRect rect_; + GraphicsJNI::jrectf_to_rect(env, rect, &rect_); + AutoJavaFloatArray afa(env, array, 8); + const float* src = afa.ptr(); + SkScalar dst[8]; + + for (int i = 0; i < 8; i++) { + dst[i] = SkFloatToScalar(src[i]); + } + obj->addRoundRect(rect_, dst, dir); + } + + static void addPath__PathFF(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, jfloat dx, jfloat dy) { + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + obj->addPath(*src, dx_, dy_); + } + + static void addPath__Path(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src) { + obj->addPath(*src); + } + + static void addPath__PathMatrix(JNIEnv* env, jobject clazz, SkPath* obj, SkPath* src, SkMatrix* matrix) { + obj->addPath(*src, *matrix); + } + + static void offset__FFPath(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy, SkPath* dst) { + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + obj->offset(dx_, dy_, dst); + } + + static void offset__FF(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + obj->offset(dx_, dy_); + } + + static void setLastPoint(JNIEnv* env, jobject clazz, SkPath* obj, jfloat dx, jfloat dy) { + SkScalar dx_ = SkFloatToScalar(dx); + SkScalar dy_ = SkFloatToScalar(dy); + obj->setLastPt(dx_, dy_); + } + + static void transform__MatrixPath(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix, SkPath* dst) { + obj->transform(*matrix, dst); + } + + static void transform__Matrix(JNIEnv* env, jobject clazz, SkPath* obj, SkMatrix* matrix) { + obj->transform(*matrix); + } + +}; + +static JNINativeMethod methods[] = { + {"finalizer", "(I)V", (void*) SkPathGlue::finalizer}, + {"init1","()I", (void*) SkPathGlue::init1}, + {"init2","(I)I", (void*) SkPathGlue::init2}, + {"native_reset","(I)V", (void*) SkPathGlue::reset}, + {"native_rewind","(I)V", (void*) SkPathGlue::rewind}, + {"native_set","(II)V", (void*) SkPathGlue::assign}, + {"native_getFillType","(I)I", (void*) SkPathGlue::getFillType}, + {"native_setFillType","(II)V", (void*) SkPathGlue::setFillType}, + {"native_isEmpty","(I)Z", (void*) SkPathGlue::isEmpty}, + {"native_isRect","(ILandroid/graphics/RectF;)Z", (void*) SkPathGlue::isRect}, + {"native_computeBounds","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::computeBounds}, + {"native_incReserve","(II)V", (void*) SkPathGlue::incReserve}, + {"native_moveTo","(IFF)V", (void*) SkPathGlue::moveTo__FF}, + {"native_rMoveTo","(IFF)V", (void*) SkPathGlue::rMoveTo}, + {"native_lineTo","(IFF)V", (void*) SkPathGlue::lineTo__FF}, + {"native_rLineTo","(IFF)V", (void*) SkPathGlue::rLineTo}, + {"native_quadTo","(IFFFF)V", (void*) SkPathGlue::quadTo__FFFF}, + {"native_rQuadTo","(IFFFF)V", (void*) SkPathGlue::rQuadTo}, + {"native_cubicTo","(IFFFFFF)V", (void*) SkPathGlue::cubicTo__FFFFFF}, + {"native_rCubicTo","(IFFFFFF)V", (void*) SkPathGlue::rCubicTo}, + {"native_arcTo","(ILandroid/graphics/RectF;FFZ)V", (void*) SkPathGlue::arcTo}, + {"native_close","(I)V", (void*) SkPathGlue::close}, + {"native_addRect","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addRect__RectFI}, + {"native_addRect","(IFFFFI)V", (void*) SkPathGlue::addRect__FFFFI}, + {"native_addOval","(ILandroid/graphics/RectF;I)V", (void*) SkPathGlue::addOval}, + {"native_addCircle","(IFFFI)V", (void*) SkPathGlue::addCircle}, + {"native_addArc","(ILandroid/graphics/RectF;FF)V", (void*) SkPathGlue::addArc}, + {"native_addRoundRect","(ILandroid/graphics/RectF;FFI)V", (void*) SkPathGlue::addRoundRectXY}, + {"native_addRoundRect","(ILandroid/graphics/RectF;[FI)V", (void*) SkPathGlue::addRoundRect8}, + {"native_addPath","(IIFF)V", (void*) SkPathGlue::addPath__PathFF}, + {"native_addPath","(II)V", (void*) SkPathGlue::addPath__Path}, + {"native_addPath","(III)V", (void*) SkPathGlue::addPath__PathMatrix}, + {"native_offset","(IFFI)V", (void*) SkPathGlue::offset__FFPath}, + {"native_offset","(IFF)V", (void*) SkPathGlue::offset__FF}, + {"native_setLastPoint","(IFF)V", (void*) SkPathGlue::setLastPoint}, + {"native_transform","(III)V", (void*) SkPathGlue::transform__MatrixPath}, + {"native_transform","(II)V", (void*) SkPathGlue::transform__Matrix} +}; + +int register_android_graphics_Path(JNIEnv* env) { + int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Path", methods, + sizeof(methods) / sizeof(methods[0])); + return result; +} + +} diff --git a/core/jni/android/graphics/PathEffect.cpp b/core/jni/android/graphics/PathEffect.cpp new file mode 100644 index 0000000..0ecb004 --- /dev/null +++ b/core/jni/android/graphics/PathEffect.cpp @@ -0,0 +1,113 @@ +#include <jni.h> +#include "GraphicsJNI.h" + +#include "SkPathEffect.h" +#include "SkCornerPathEffect.h" +#include "SkDashPathEffect.h" +#include "SkDiscretePathEffect.h" +#include "Sk1DPathEffect.h" +#include "SkTemplates.h" + +class SkPathEffectGlue { +public: + + static void destructor(JNIEnv* env, jobject, SkPathEffect* effect) { + effect->safeUnref(); + } + + static SkPathEffect* Compose_constructor(JNIEnv* env, jobject, + SkPathEffect* outer, SkPathEffect* inner) { + return new SkComposePathEffect(outer, inner); + } + + static SkPathEffect* Sum_constructor(JNIEnv* env, jobject, + SkPathEffect* first, SkPathEffect* second) { + return new SkSumPathEffect(first, second); + } + + static SkPathEffect* Dash_constructor(JNIEnv* env, jobject, + jfloatArray intervalArray, float phase) { + AutoJavaFloatArray autoInterval(env, intervalArray); + int count = autoInterval.length() & ~1; // even number + float* values = autoInterval.ptr(); + + SkAutoSTMalloc<32, SkScalar> storage(count); + SkScalar* intervals = storage.get(); + for (int i = 0; i < count; i++) { + intervals[i] = SkFloatToScalar(values[i]); + } + return new SkDashPathEffect(intervals, count, SkFloatToScalar(phase)); + } + + static SkPathEffect* OneD_constructor(JNIEnv* env, jobject, + const SkPath* shape, float advance, float phase, int style) { + SkASSERT(shape != NULL); + return new SkPath1DPathEffect(*shape, SkFloatToScalar(advance), + SkFloatToScalar(phase), (SkPath1DPathEffect::Style)style); + } + + static SkPathEffect* Corner_constructor(JNIEnv* env, jobject, float radius){ + return new SkCornerPathEffect(SkFloatToScalar(radius)); + } + + static SkPathEffect* Discrete_constructor(JNIEnv* env, jobject, + float length, float deviation) { + return new SkDiscretePathEffect(SkFloatToScalar(length), + SkFloatToScalar(deviation)); + } + +}; + +//////////////////////////////////////////////////////////////////////////////////////////////////////// + +static JNINativeMethod gPathEffectMethods[] = { + { "nativeDestructor", "(I)V", (void*)SkPathEffectGlue::destructor } +}; + +static JNINativeMethod gComposePathEffectMethods[] = { + { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Compose_constructor } +}; + +static JNINativeMethod gSumPathEffectMethods[] = { + { "nativeCreate", "(II)I", (void*)SkPathEffectGlue::Sum_constructor } +}; + +static JNINativeMethod gDashPathEffectMethods[] = { + { "nativeCreate", "([FF)I", (void*)SkPathEffectGlue::Dash_constructor } +}; + +static JNINativeMethod gPathDashPathEffectMethods[] = { + { "nativeCreate", "(IFFI)I", (void*)SkPathEffectGlue::OneD_constructor } +}; + +static JNINativeMethod gCornerPathEffectMethods[] = { + { "nativeCreate", "(F)I", (void*)SkPathEffectGlue::Corner_constructor } +}; + +static JNINativeMethod gDiscretePathEffectMethods[] = { + { "nativeCreate", "(FF)I", (void*)SkPathEffectGlue::Discrete_constructor } +}; + +#include <android_runtime/AndroidRuntime.h> + +#define REG(env, name, array) \ + result = android::AndroidRuntime::registerNativeMethods(env, name, array, \ + SK_ARRAY_COUNT(array)); \ + if (result < 0) return result + +int register_android_graphics_PathEffect(JNIEnv* env); +int register_android_graphics_PathEffect(JNIEnv* env) +{ + int result; + + REG(env, "android/graphics/PathEffect", gPathEffectMethods); + REG(env, "android/graphics/ComposePathEffect", gComposePathEffectMethods); + REG(env, "android/graphics/SumPathEffect", gSumPathEffectMethods); + REG(env, "android/graphics/DashPathEffect", gDashPathEffectMethods); + REG(env, "android/graphics/PathDashPathEffect", gPathDashPathEffectMethods); + REG(env, "android/graphics/CornerPathEffect", gCornerPathEffectMethods); + REG(env, "android/graphics/DiscretePathEffect", gDiscretePathEffectMethods); + + return 0; +} + diff --git a/core/jni/android/graphics/PathMeasure.cpp b/core/jni/android/graphics/PathMeasure.cpp new file mode 100644 index 0000000..51a3f3a --- /dev/null +++ b/core/jni/android/graphics/PathMeasure.cpp @@ -0,0 +1,138 @@ +/* libs/android_runtime/android/graphics/PathMeasure.cpp +** +** Copyright 2007, 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. +*/ + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkPathMeasure.h" + +/* We declare an explicit pair, so that we don't have to rely on the java + client to be sure not to edit the path while we have an active measure + object associated with it. + + This costs us the copy of the path, for the sake of not allowing a bad + java client to randomly crash (since we can't detect the case where the + native path has been modified). + + The C side does have this risk, but it chooses for speed over safety. If it + later changes this, and is internally safe from changes to the path, then + we can remove this explicit copy from our JNI code. + + Note that we do not have a reference on the java side to the java path. + Were we to not need the native copy here, we would want to add a java + reference, so that the java path would not get GD'd while the measure object + was still alive. +*/ +struct PathMeasurePair { + PathMeasurePair() {} + PathMeasurePair(const SkPath& path, bool forceClosed) + : fPath(path), fMeasure(fPath, forceClosed) {} + + SkPath fPath; // copy of the user's path + SkPathMeasure fMeasure; // this guy points to fPath +}; + +namespace android { + +class SkPathMeasureGlue { +public: + + static PathMeasurePair* create(JNIEnv* env, jobject clazz, const SkPath* path, jboolean forceClosed) { + return path ? new PathMeasurePair(*path, forceClosed) : new PathMeasurePair; + } + + static void setPath(JNIEnv* env, jobject clazz, PathMeasurePair* pair, const SkPath* path, jboolean forceClosed) { + if (NULL == path) { + pair->fPath.reset(); + } else { + pair->fPath = *path; + } + pair->fMeasure.setPath(&pair->fPath, forceClosed); + } + + static jfloat getLength(JNIEnv* env, jobject clazz, PathMeasurePair* pair) { + return SkScalarToFloat(pair->fMeasure.getLength()); + } + + static void convertTwoElemFloatArray(JNIEnv* env, jfloatArray array, const SkScalar src[2]) { + AutoJavaFloatArray autoArray(env, array, 2); + jfloat* ptr = autoArray.ptr(); + ptr[0] = SkScalarToFloat(src[0]); + ptr[1] = SkScalarToFloat(src[1]); + } + + static jboolean getPosTan(JNIEnv* env, jobject clazz, PathMeasurePair* pair, jfloat dist, jfloatArray pos, jfloatArray tan) { + SkScalar tmpPos[2], tmpTan[2]; + SkScalar* posPtr = pos ? tmpPos : NULL; + SkScalar* tanPtr = tan ? tmpTan : NULL; + + if (!pair->fMeasure.getPosTan(SkFloatToScalar(dist), (SkPoint*)posPtr, (SkVector*)tanPtr)) { + return false; + } + + if (pos) { + convertTwoElemFloatArray(env, pos, tmpPos); + } + if (tan) { + convertTwoElemFloatArray(env, tan, tmpTan); + } + return true; + } + + static jboolean getMatrix(JNIEnv* env, jobject clazz, PathMeasurePair* pair, jfloat dist, + SkMatrix* matrix, int flags) { + return pair->fMeasure.getMatrix(SkFloatToScalar(dist), matrix, (SkPathMeasure::MatrixFlags)flags); + } + + static jboolean getSegment(JNIEnv* env, jobject clazz, PathMeasurePair* pair, jfloat startF, + jfloat stopF, SkPath* dst, jboolean startWithMoveTo) { + return pair->fMeasure.getSegment(SkFloatToScalar(startF), SkFloatToScalar(stopF), dst, startWithMoveTo); + } + + static jboolean isClosed(JNIEnv* env, jobject clazz, PathMeasurePair* pair) { + return pair->fMeasure.isClosed(); + } + + static jboolean nextContour(JNIEnv* env, jobject clazz, PathMeasurePair* pair) { + return pair->fMeasure.nextContour(); + } + + static void destroy(JNIEnv* env, jobject clazz, PathMeasurePair* pair) { + delete pair; + } +}; + +static JNINativeMethod methods[] = { + {"native_create", "(IZ)I", (void*) SkPathMeasureGlue::create }, + {"native_setPath", "(IIZ)V", (void*) SkPathMeasureGlue::setPath }, + {"native_getLength", "(I)F", (void*) SkPathMeasureGlue::getLength }, + {"native_getPosTan", "(IF[F[F)Z", (void*) SkPathMeasureGlue::getPosTan }, + {"native_getMatrix", "(IFII)Z", (void*) SkPathMeasureGlue::getMatrix }, + {"native_getSegment", "(IFFIZ)Z", (void*) SkPathMeasureGlue::getSegment }, + {"native_isClosed", "(I)Z", (void*) SkPathMeasureGlue::isClosed }, + {"native_nextContour", "(I)Z", (void*) SkPathMeasureGlue::nextContour }, + {"native_destroy", "(I)V", (void*) SkPathMeasureGlue::destroy } +}; + +int register_android_graphics_PathMeasure(JNIEnv* env) { + int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/PathMeasure", methods, + sizeof(methods) / sizeof(methods[0])); + return result; +} + +} diff --git a/core/jni/android/graphics/Picture.cpp b/core/jni/android/graphics/Picture.cpp new file mode 100644 index 0000000..5ab6dd3 --- /dev/null +++ b/core/jni/android/graphics/Picture.cpp @@ -0,0 +1,128 @@ +/* + * 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. + */ + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkCanvas.h" +#include "SkPicture.h" +#include "SkTemplates.h" +#include "CreateJavaOutputStreamAdaptor.h" + +namespace android { + +class SkPictureGlue { +public: + static SkPicture* newPicture(JNIEnv* env, jobject, const SkPicture* src) { + if (src) { + return new SkPicture(*src); + } else { + return new SkPicture; + } + } + + static SkPicture* deserialize(JNIEnv* env, jobject, jobject jstream, + jbyteArray jstorage) { + SkPicture* picture = NULL; + SkStream* strm = CreateJavaInputStreamAdaptor(env, jstream, jstorage); + if (strm) { + picture = new SkPicture(strm); + delete strm; + } + return picture; + } + + static void killPicture(JNIEnv* env, jobject, SkPicture* picture) { + SkASSERT(picture); + delete picture; + } + + static void draw(JNIEnv* env, jobject, SkCanvas* canvas, + SkPicture* picture) { + SkASSERT(canvas); + SkASSERT(picture); + picture->draw(canvas); + } + + static bool serialize(JNIEnv* env, jobject, SkPicture* picture, + jobject jstream, jbyteArray jstorage) { + SkWStream* strm = CreateJavaOutputStreamAdaptor(env, jstream, jstorage); + + if (NULL != strm) { + picture->serialize(strm); + delete strm; + return true; + } + return false; + } + + static int getWidth(JNIEnv* env, jobject jpic) { + NPE_CHECK_RETURN_ZERO(env, jpic); + return GraphicsJNI::getNativePicture(env, jpic)->width(); + } + + static int getHeight(JNIEnv* env, jobject jpic) { + NPE_CHECK_RETURN_ZERO(env, jpic); + return GraphicsJNI::getNativePicture(env, jpic)->height(); + } + + static SkCanvas* beginRecording(JNIEnv* env, jobject, SkPicture* pict, + int w, int h) { + // beginRecording does not ref its return value, it just returns it. + SkCanvas* canvas = pict->beginRecording(w, h); + // the java side will wrap this guy in a Canvas.java, which will call + // unref in its finalizer, so we have to ref it here, so that both that + // Canvas.java and our picture can both be owners + canvas->ref(); + return canvas; + } + + static void endRecording(JNIEnv* env, jobject, SkPicture* pict) { + pict->endRecording(); + } +}; + +static JNINativeMethod gPictureMethods[] = { + {"getWidth", "()I", (void*) SkPictureGlue::getWidth}, + {"getHeight", "()I", (void*) SkPictureGlue::getHeight}, + {"nativeConstructor", "(I)I", (void*) SkPictureGlue::newPicture}, + {"nativeCreateFromStream", "(Ljava/io/InputStream;[B)I", (void*)SkPictureGlue::deserialize}, + {"nativeBeginRecording", "(III)I", (void*) SkPictureGlue::beginRecording}, + {"nativeEndRecording", "(I)V", (void*) SkPictureGlue::endRecording}, + {"nativeDraw", "(II)V", (void*) SkPictureGlue::draw}, + {"nativeWriteToStream", "(ILjava/io/OutputStream;[B)Z", (void*)SkPictureGlue::serialize}, + {"nativeDestructor","(I)V", (void*) SkPictureGlue::killPicture} +}; + +#include <android_runtime/AndroidRuntime.h> + +#define REG(env, name, array) \ + result = android::AndroidRuntime::registerNativeMethods(env, name, array, \ + SK_ARRAY_COUNT(array)); \ + if (result < 0) return result + +int register_android_graphics_Picture(JNIEnv* env) { + int result; + + REG(env, "android/graphics/Picture", gPictureMethods); + + return result; +} + +} + + diff --git a/core/jni/android/graphics/PorterDuff.cpp b/core/jni/android/graphics/PorterDuff.cpp new file mode 100644 index 0000000..47de601 --- /dev/null +++ b/core/jni/android/graphics/PorterDuff.cpp @@ -0,0 +1,52 @@ +/* libs/android_runtime/android/graphics/PorterDuff.cpp +** +** Copyright 2006, 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. +*/ + +// This file was generated from the C++ include file: SkPorterDuff.h +// Any changes made to this file will be discarded by the build. +// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, +// or one of the auxilary file specifications in device/tools/gluemaker. + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkPorterDuff.h" + +namespace android { + +class SkPorterDuffGlue { +public: + + static SkXfermode* CreateXfermode(JNIEnv* env, jobject, + SkPorterDuff::Mode mode) { + return SkPorterDuff::CreateXfermode(mode); + } + +}; + +static JNINativeMethod methods[] = { + {"nativeCreateXfermode","(I)I", (void*) SkPorterDuffGlue::CreateXfermode}, +}; + +int register_android_graphics_PorterDuff(JNIEnv* env) { + int result = AndroidRuntime::registerNativeMethods(env, + "android/graphics/PorterDuffXfermode", methods, + sizeof(methods) / sizeof(methods[0])); + return result; +} + +} diff --git a/core/jni/android/graphics/Rasterizer.cpp b/core/jni/android/graphics/Rasterizer.cpp new file mode 100644 index 0000000..db70b57 --- /dev/null +++ b/core/jni/android/graphics/Rasterizer.cpp @@ -0,0 +1,50 @@ +/* libs/android_runtime/android/graphics/Rasterizer.cpp +** +** Copyright 2006, 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. +*/ + +// This file was generated from the C++ include file: SkRasterizer.h +// Any changes made to this file will be discarded by the build. +// To change this file, either edit the include, or device/tools/gluemaker/main.cpp, +// or one of the auxilary file specifications in device/tools/gluemaker. + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkRasterizer.h" + +namespace android { + +class SkRasterizerGlue { +public: + + static void finalizer(JNIEnv* env, jobject clazz, SkRasterizer* obj) { + obj->safeUnref(); + } + +}; + +static JNINativeMethod methods[] = { + {"finalizer", "(I)V", (void*) SkRasterizerGlue::finalizer} +}; + +int register_android_graphics_Rasterizer(JNIEnv* env) { + int result = AndroidRuntime::registerNativeMethods(env, "android/graphics/Rasterizer", methods, + sizeof(methods) / sizeof(methods[0])); + return result; +} + +} diff --git a/core/jni/android/graphics/Region.cpp b/core/jni/android/graphics/Region.cpp new file mode 100644 index 0000000..00d6cd9 --- /dev/null +++ b/core/jni/android/graphics/Region.cpp @@ -0,0 +1,231 @@ +#include "SkRegion.h" +#include "SkPath.h" +#include "GraphicsJNI.h" + +#include <jni.h> + +static jfieldID gRegion_nativeInstanceFieldID; + +static inline SkRegion* GetSkRegion(JNIEnv* env, jobject regionObject) { + SkRegion* rgn = (SkRegion*)env->GetIntField(regionObject, gRegion_nativeInstanceFieldID); + SkASSERT(rgn != NULL); + return rgn; +} + +static SkRegion* Region_constructor(JNIEnv* env, jobject) { + return new SkRegion; +} + +static void Region_destructor(JNIEnv* env, jobject, SkRegion* region) { + SkASSERT(region); + delete region; +} + +static void Region_setRegion(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* src) { + SkASSERT(dst && src); + *dst = *src; +} + +static jboolean Region_setRect(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom) { + return dst->setRect(left, top, right, bottom); +} + +static jboolean Region_setPath(JNIEnv* env, jobject, SkRegion* dst, + const SkPath* path, const SkRegion* clip) { + SkASSERT(dst && path && clip); + return dst->setPath(*path, *clip); +} + +static jboolean Region_getBounds(JNIEnv* env, jobject, SkRegion* region, jobject rectBounds) { + GraphicsJNI::irect_to_jrect(region->getBounds(), env, rectBounds); + return !region->isEmpty(); +} + +static jboolean Region_getBoundaryPath(JNIEnv* env, jobject, const SkRegion* region, SkPath* path) { + return region->getBoundaryPath(path); +} + +static jboolean Region_op0(JNIEnv* env, jobject, SkRegion* dst, int left, int top, int right, int bottom, int op) { + SkIRect ir; + + ir.set(left, top, right, bottom); + return dst->op(ir, (SkRegion::Op)op); +} + +static jboolean Region_op1(JNIEnv* env, jobject, SkRegion* dst, jobject rectObject, const SkRegion* region, int op) { + SkIRect ir; + GraphicsJNI::jrect_to_irect(env, rectObject, &ir); + return dst->op(ir, *region, (SkRegion::Op)op); +} + +static jboolean Region_op2(JNIEnv* env, jobject, SkRegion* dst, const SkRegion* region1, const SkRegion* region2, int op) { + return dst->op(*region1, *region2, (SkRegion::Op)op); +} + +//////////////////////////////////// These are methods, not static + +static jboolean Region_isEmpty(JNIEnv* env, jobject region) { + return GetSkRegion(env, region)->isEmpty(); +} + +static jboolean Region_isRect(JNIEnv* env, jobject region) { + return GetSkRegion(env, region)->isRect(); +} + +static jboolean Region_isComplex(JNIEnv* env, jobject region) { + return GetSkRegion(env, region)->isComplex(); +} + +static jboolean Region_contains(JNIEnv* env, jobject region, int x, int y) { + return GetSkRegion(env, region)->contains(x, y); +} + +static jboolean Region_quickContains(JNIEnv* env, jobject region, int left, int top, int right, int bottom) { + return GetSkRegion(env, region)->quickContains(left, top, right, bottom); +} + +static jboolean Region_quickRejectIIII(JNIEnv* env, jobject region, int left, int top, int right, int bottom) { + SkIRect ir; + ir.set(left, top, right, bottom); + return GetSkRegion(env, region)->quickReject(ir); +} + +static jboolean Region_quickRejectRgn(JNIEnv* env, jobject region, jobject other) { + return GetSkRegion(env, region)->quickReject(*GetSkRegion(env, other)); +} + +static void Region_translate(JNIEnv* env, jobject region, int x, int y, jobject dst) { + SkRegion* rgn = GetSkRegion(env, region); + if (dst) + rgn->translate(x, y, GetSkRegion(env, dst)); + else + rgn->translate(x, y); +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#include "Parcel.h" +#include "android_util_Binder.h" + +static SkRegion* Region_createFromParcel(JNIEnv* env, jobject clazz, jobject parcel) +{ + if (parcel == NULL) { + return NULL; + } + + android::Parcel* p = android::parcelForJavaObject(env, parcel); + + SkRegion* region = new SkRegion; + size_t size = p->readInt32(); + region->unflatten(p->readInplace(size)); + + return region; +} + +static jboolean Region_writeToParcel(JNIEnv* env, jobject clazz, const SkRegion* region, jobject parcel) +{ + if (parcel == NULL) { + return false; + } + + android::Parcel* p = android::parcelForJavaObject(env, parcel); + + size_t size = region->flatten(NULL); + p->writeInt32(size); + region->flatten(p->writeInplace(size)); + + return true; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +struct RgnIterPair { + SkRegion fRgn; // a copy of the caller's region + SkRegion::Iterator fIter; // an iterator acting upon the copy (fRgn) + + RgnIterPair(const SkRegion& rgn) : fRgn(rgn) { + // have our iterator reference our copy (fRgn), so we know it will be + // unchanged for the lifetime of the iterator + fIter.reset(fRgn); + } +}; + +static RgnIterPair* RegionIter_constructor(JNIEnv* env, jobject, const SkRegion* region) +{ + SkASSERT(region); + return new RgnIterPair(*region); +} + +static void RegionIter_destructor(JNIEnv* env, jobject, RgnIterPair* pair) +{ + SkASSERT(pair); + delete pair; +} + +static jboolean RegionIter_next(JNIEnv* env, jobject, RgnIterPair* pair, jobject rectObject) +{ + // the caller has checked that rectObject is not nul + SkASSERT(pair); + SkASSERT(rectObject); + + if (!pair->fIter.done()) { + GraphicsJNI::irect_to_jrect(pair->fIter.rect(), env, rectObject); + pair->fIter.next(); + return true; + } + return false; +} + +//////////////////////////////////////////////////////////////////////////////////////////////////////////// + +#include <android_runtime/AndroidRuntime.h> + +static JNINativeMethod gRegionIterMethods[] = { + { "nativeConstructor", "(I)I", (void*)RegionIter_constructor }, + { "nativeDestructor", "(I)V", (void*)RegionIter_destructor }, + { "nativeNext", "(ILandroid/graphics/Rect;)Z", (void*)RegionIter_next } +}; + +static JNINativeMethod gRegionMethods[] = { + // these are static methods + { "nativeConstructor", "()I", (void*)Region_constructor }, + { "nativeDestructor", "(I)V", (void*)Region_destructor }, + { "nativeSetRegion", "(II)Z", (void*)Region_setRegion }, + { "nativeSetRect", "(IIIII)Z", (void*)Region_setRect }, + { "nativeSetPath", "(III)Z", (void*)Region_setPath }, + { "nativeGetBounds", "(ILandroid/graphics/Rect;)Z", (void*)Region_getBounds }, + { "nativeGetBoundaryPath", "(II)Z", (void*)Region_getBoundaryPath }, + { "nativeOp", "(IIIIII)Z", (void*)Region_op0 }, + { "nativeOp", "(ILandroid/graphics/Rect;II)Z", (void*)Region_op1 }, + { "nativeOp", "(IIII)Z", (void*)Region_op2 }, + // these are methods that take the java region object + { "isEmpty", "()Z", (void*)Region_isEmpty }, + { "isRect", "()Z", (void*)Region_isRect }, + { "isComplex", "()Z", (void*)Region_isComplex }, + { "contains", "(II)Z", (void*)Region_contains }, + { "quickContains", "(IIII)Z", (void*)Region_quickContains }, + { "quickReject", "(IIII)Z", (void*)Region_quickRejectIIII }, + { "quickReject", "(Landroid/graphics/Region;)Z", (void*)Region_quickRejectRgn }, + { "translate", "(IILandroid/graphics/Region;)V", (void*)Region_translate }, + // parceling methods + { "nativeCreateFromParcel", "(Landroid/os/Parcel;)I", (void*)Region_createFromParcel }, + { "nativeWriteToParcel", "(ILandroid/os/Parcel;)Z", (void*)Region_writeToParcel } +}; + +int register_android_graphics_Region(JNIEnv* env); +int register_android_graphics_Region(JNIEnv* env) +{ + jclass clazz = env->FindClass("android/graphics/Region"); + SkASSERT(clazz); + + gRegion_nativeInstanceFieldID = env->GetFieldID(clazz, "mNativeRegion", "I"); + SkASSERT(gRegion_nativeInstanceFieldID); + + int result = android::AndroidRuntime::registerNativeMethods(env, "android/graphics/Region", + gRegionMethods, SK_ARRAY_COUNT(gRegionMethods)); + if (result < 0) + return result; + + return android::AndroidRuntime::registerNativeMethods(env, "android/graphics/RegionIterator", + gRegionIterMethods, SK_ARRAY_COUNT(gRegionIterMethods)); +} diff --git a/core/jni/android/graphics/Shader.cpp b/core/jni/android/graphics/Shader.cpp new file mode 100644 index 0000000..71dc875 --- /dev/null +++ b/core/jni/android/graphics/Shader.cpp @@ -0,0 +1,273 @@ +#include <jni.h> +#include "GraphicsJNI.h" + +#include "SkShader.h" +#include "SkGradientShader.h" +#include "SkPorterDuff.h" +#include "SkShaderExtras.h" +#include "SkTemplates.h" +#include "SkXfermode.h" + +static void Color_RGBToHSV(JNIEnv* env, jobject, int red, int green, int blue, jfloatArray hsvArray) +{ + SkScalar hsv[3]; + SkRGBToHSV(red, green, blue, hsv); + + AutoJavaFloatArray autoHSV(env, hsvArray, 3); + float* values = autoHSV.ptr(); + for (int i = 0; i < 3; i++) { + values[i] = SkScalarToFloat(hsv[i]); + } +} + +static int Color_HSVToColor(JNIEnv* env, jobject, int alpha, jfloatArray hsvArray) +{ + AutoJavaFloatArray autoHSV(env, hsvArray, 3); + float* values = autoHSV.ptr();; + SkScalar hsv[3]; + + for (int i = 0; i < 3; i++) { + hsv[i] = SkFloatToScalar(values[i]); + } + + return SkHSVToColor(alpha, hsv); +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +static void Shader_destructor(JNIEnv* env, jobject, SkShader* shader) +{ + SkASSERT(shader != NULL); + shader->unref(); +} + +static bool Shader_getLocalMatrix(JNIEnv* env, jobject, const SkShader* shader, SkMatrix* matrix) +{ + SkASSERT(shader != NULL); + return shader->getLocalMatrix(matrix); +} + +static void Shader_setLocalMatrix(JNIEnv* env, jobject, SkShader* shader, const SkMatrix* matrix) +{ + SkASSERT(shader != NULL); + + if (NULL == matrix) { + shader->resetLocalMatrix(); + } + else { + shader->setLocalMatrix(*matrix); + } +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +static SkShader* BitmapShader_constructor(JNIEnv* env, jobject, const SkBitmap* bitmap, + int tileModeX, int tileModeY) +{ + return SkShader::CreateBitmapShader(*bitmap, + (SkShader::TileMode)tileModeX, + (SkShader::TileMode)tileModeY); +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +static SkShader* LinearGradient_create1(JNIEnv* env, jobject, + float x0, float y0, float x1, float y1, + jintArray colorArray, jfloatArray posArray, int tileMode) +{ + SkPoint pts[2]; + pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0)); + pts[1].set(SkFloatToScalar(x1), SkFloatToScalar(y1)); + + size_t count = env->GetArrayLength(colorArray); + int* colorValues = env->GetIntArrayElements(colorArray, NULL); + + SkAutoSTMalloc<8, SkScalar> storage(posArray ? count : 0); + SkScalar* pos = NULL; + + if (posArray) { + AutoJavaFloatArray autoPos(env, posArray, count); + const float* posValues = autoPos.ptr(); + pos = (SkScalar*)storage.get(); + for (size_t i = 0; i < count; i++) + pos[i] = SkFloatToScalar(posValues[i]); + } + + SkShader* shader = SkGradientShader::CreateLinear(pts, (const SkColor*)colorValues, + pos, count, (SkShader::TileMode)tileMode); + env->ReleaseIntArrayElements(colorArray, colorValues, 0); + return shader; +} + +static SkShader* LinearGradient_create2(JNIEnv* env, jobject, + float x0, float y0, float x1, float y1, + int color0, int color1, int tileMode) +{ + SkPoint pts[2]; + pts[0].set(SkFloatToScalar(x0), SkFloatToScalar(y0)); + pts[1].set(SkFloatToScalar(x1), SkFloatToScalar(y1)); + + SkColor colors[2]; + colors[0] = color0; + colors[1] = color1; + + return SkGradientShader::CreateLinear(pts, colors, NULL, 2, (SkShader::TileMode)tileMode); +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +static SkShader* RadialGradient_create1(JNIEnv* env, jobject, + float x, float y, float radius, + jintArray colorArray, jfloatArray posArray, int tileMode) +{ + SkPoint center; + center.set(SkFloatToScalar(x), SkFloatToScalar(y)); + + size_t count = env->GetArrayLength(colorArray); + int* colorValues = env->GetIntArrayElements(colorArray, NULL); + + SkAutoSTMalloc<8, SkScalar> storage(posArray ? count : 0); + SkScalar* pos = NULL; + + if (posArray) { + AutoJavaFloatArray autoPos(env, posArray, count); + const float* posValues = autoPos.ptr(); + pos = (SkScalar*)storage.get(); + for (size_t i = 0; i < count; i++) + pos[i] = SkFloatToScalar(posValues[i]); + } + + SkShader* shader = SkGradientShader::CreateRadial(center, SkFloatToScalar(radius), + (const SkColor*)colorValues, pos, + count, (SkShader::TileMode)tileMode); + env->ReleaseIntArrayElements(colorArray, colorValues, 0); + return shader; +} + +static SkShader* RadialGradient_create2(JNIEnv* env, jobject, + float x, float y, float radius, + int color0, int color1, int tileMode) +{ + SkPoint center; + center.set(SkFloatToScalar(x), SkFloatToScalar(y)); + + SkColor colors[2]; + colors[0] = color0; + colors[1] = color1; + + return SkGradientShader::CreateRadial(center, SkFloatToScalar(radius), colors, NULL, + 2, (SkShader::TileMode)tileMode); +} + +/////////////////////////////////////////////////////////////////////////////// + +static SkShader* SweepGradient_create1(JNIEnv* env, jobject, float x, float y, + jintArray jcolors, jfloatArray jpositions) +{ + size_t count = env->GetArrayLength(jcolors); + int* colors = env->GetIntArrayElements(jcolors, NULL); + + SkAutoSTMalloc<8, SkScalar> storage(jpositions ? count : 0); + SkScalar* pos = NULL; + + if (NULL != jpositions) { + AutoJavaFloatArray autoPos(env, jpositions, count); + const float* posValues = autoPos.ptr(); + pos = (SkScalar*)storage.get(); + for (size_t i = 0; i < count; i++) + pos[i] = SkFloatToScalar(posValues[i]); + } + + SkShader* shader = SkGradientShader::CreateSweep(SkFloatToScalar(x), + SkFloatToScalar(y), + (const SkColor*)colors, + pos, count); + env->ReleaseIntArrayElements(jcolors, colors, 0); + return shader; +} + +static SkShader* SweepGradient_create2(JNIEnv* env, jobject, float x, float y, + int color0, int color1) +{ + SkColor colors[2]; + colors[0] = color0; + colors[1] = color1; + return SkGradientShader::CreateSweep(SkFloatToScalar(x), SkFloatToScalar(y), + colors, NULL, 2); +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +static SkShader* ComposeShader_create1(JNIEnv* env, jobject, + SkShader* shaderA, SkShader* shaderB, SkXfermode* mode) +{ + return new SkComposeShader(shaderA, shaderB, mode); +} + +static SkShader* ComposeShader_create2(JNIEnv* env, jobject, + SkShader* shaderA, SkShader* shaderB, SkPorterDuff::Mode mode) +{ + SkAutoUnref au(SkPorterDuff::CreateXfermode(mode)); + + return new SkComposeShader(shaderA, shaderB, (SkXfermode*)au.get()); +} + +/////////////////////////////////////////////////////////////////////////////////////////////// + +static JNINativeMethod gColorMethods[] = { + { "nativeRGBToHSV", "(III[F)V", (void*)Color_RGBToHSV }, + { "nativeHSVToColor", "(I[F)I", (void*)Color_HSVToColor } +}; + +static JNINativeMethod gShaderMethods[] = { + { "nativeDestructor", "(I)V", (void*)Shader_destructor }, + { "nativeGetLocalMatrix", "(II)Z", (void*)Shader_getLocalMatrix }, + { "nativeSetLocalMatrix", "(II)V", (void*)Shader_setLocalMatrix } +}; + +static JNINativeMethod gBitmapShaderMethods[] = { + { "nativeCreate", "(III)I", (void*)BitmapShader_constructor } +}; + +static JNINativeMethod gLinearGradientMethods[] = { + { "nativeCreate1", "(FFFF[I[FI)I", (void*)LinearGradient_create1 }, + { "nativeCreate2", "(FFFFIII)I", (void*)LinearGradient_create2 } +}; + +static JNINativeMethod gRadialGradientMethods[] = { + {"nativeCreate1", "(FFF[I[FI)I", (void*)RadialGradient_create1 }, + {"nativeCreate2", "(FFFIII)I", (void*)RadialGradient_create2 } +}; + +static JNINativeMethod gSweepGradientMethods[] = { + {"nativeCreate1", "(FF[I[F)I", (void*)SweepGradient_create1 }, + {"nativeCreate2", "(FFII)I", (void*)SweepGradient_create2 } +}; + +static JNINativeMethod gComposeShaderMethods[] = { + {"nativeCreate1", "(III)I", (void*)ComposeShader_create1 }, + {"nativeCreate2", "(III)I", (void*)ComposeShader_create2 } +}; + +#include <android_runtime/AndroidRuntime.h> + +#define REG(env, name, array) \ + result = android::AndroidRuntime::registerNativeMethods(env, name, array, SK_ARRAY_COUNT(array)); \ + if (result < 0) return result + +int register_android_graphics_Shader(JNIEnv* env); +int register_android_graphics_Shader(JNIEnv* env) +{ + int result; + + REG(env, "android/graphics/Color", gColorMethods); + REG(env, "android/graphics/Shader", gShaderMethods); + REG(env, "android/graphics/BitmapShader", gBitmapShaderMethods); + REG(env, "android/graphics/LinearGradient", gLinearGradientMethods); + REG(env, "android/graphics/RadialGradient", gRadialGradientMethods); + REG(env, "android/graphics/SweepGradient", gSweepGradientMethods); + REG(env, "android/graphics/ComposeShader", gComposeShaderMethods); + + return result; +} + diff --git a/core/jni/android/graphics/Typeface.cpp b/core/jni/android/graphics/Typeface.cpp new file mode 100644 index 0000000..32954ce --- /dev/null +++ b/core/jni/android/graphics/Typeface.cpp @@ -0,0 +1,156 @@ +#include "jni.h" +#include <android_runtime/AndroidRuntime.h> + +#include "GraphicsJNI.h" +#include <android_runtime/android_util_AssetManager.h> +#include "SkStream.h" +#include "SkTypeface.h" +#include <utils/AssetManager.h> + +using namespace android; + +class AutoJavaStringToUTF8 { +public: + AutoJavaStringToUTF8(JNIEnv* env, jstring str) : fEnv(env), fJStr(str) + { + fCStr = env->GetStringUTFChars(str, NULL); + } + ~AutoJavaStringToUTF8() + { + fEnv->ReleaseStringUTFChars(fJStr, fCStr); + } + const char* c_str() const { return fCStr; } + +private: + JNIEnv* fEnv; + jstring fJStr; + const char* fCStr; +}; + +static SkTypeface* Typeface_create(JNIEnv* env, jobject, jstring name, + SkTypeface::Style style) { + SkTypeface* face; + + if (NULL == name) { + face = SkTypeface::Create(NULL, (SkTypeface::Style)style); + } + else { + AutoJavaStringToUTF8 str(env, name); + face = SkTypeface::Create(str.c_str(), style); + } + return face; +} + +static SkTypeface* Typeface_createFromTypeface(JNIEnv* env, jobject, SkTypeface* family, int style) { + return SkTypeface::CreateFromTypeface(family, (SkTypeface::Style)style); +} + +static void Typeface_unref(JNIEnv* env, jobject obj, SkTypeface* face) { + face->unref(); +} + +static int Typeface_getStyle(JNIEnv* env, jobject obj, SkTypeface* face) { + return face->getStyle(); +} + +class AssetStream : public SkStream { +public: + AssetStream(Asset* asset, bool hasMemoryBase) : fAsset(asset) + { + fMemoryBase = hasMemoryBase ? fAsset->getBuffer(false) : NULL; + } + + virtual ~AssetStream() + { + delete fAsset; + } + + virtual const void* getMemoryBase() + { + return fMemoryBase; + } + + virtual bool rewind() + { + off_t pos = fAsset->seek(0, SEEK_SET); + return pos != (off_t)-1; + } + + virtual size_t read(void* buffer, size_t size) + { + ssize_t amount; + + if (NULL == buffer) + { + if (0 == size) // caller is asking us for our total length + return fAsset->getLength(); + + // asset->seek returns new total offset + // we want to return amount that was skipped + + off_t oldOffset = fAsset->seek(0, SEEK_CUR); + if (-1 == oldOffset) + return 0; + off_t newOffset = fAsset->seek(size, SEEK_CUR); + if (-1 == newOffset) + return 0; + + amount = newOffset - oldOffset; + } + else + { + amount = fAsset->read(buffer, size); + } + + if (amount < 0) + amount = 0; + return amount; + } + +private: + Asset* fAsset; + const void* fMemoryBase; +}; + +static SkTypeface* Typeface_createFromAsset(JNIEnv* env, jobject, + jobject jassetMgr, + jstring jpath) { + + NPE_CHECK_RETURN_ZERO(env, jassetMgr); + NPE_CHECK_RETURN_ZERO(env, jpath); + + AssetManager* mgr = assetManagerForJavaObject(env, jassetMgr); + if (NULL == mgr) { + return NULL; + } + + AutoJavaStringToUTF8 str(env, jpath); + Asset* asset = mgr->open(str.c_str(), Asset::ACCESS_BUFFER); + if (NULL == asset) { + return NULL; + } + + return SkTypeface::CreateFromStream(new AssetStream(asset, true)); +} + +/////////////////////////////////////////////////////////////////////////////// + +static JNINativeMethod gTypefaceMethods[] = { + { "nativeCreate", "(Ljava/lang/String;I)I", (void*)Typeface_create }, + { "nativeCreateFromTypeface", "(II)I", (void*)Typeface_createFromTypeface }, + { "nativeUnref", "(I)V", (void*)Typeface_unref }, + { "nativeGetStyle", "(I)I", (void*)Typeface_getStyle }, + { "nativeCreateFromAsset", + "(Landroid/content/res/AssetManager;Ljava/lang/String;)I", + (void*)Typeface_createFromAsset } +}; + +int register_android_graphics_Typeface(JNIEnv* env); +int register_android_graphics_Typeface(JNIEnv* env) +{ + return android::AndroidRuntime::registerNativeMethods(env, + "android/graphics/Typeface", + gTypefaceMethods, + SK_ARRAY_COUNT(gTypefaceMethods)); +} + diff --git a/core/jni/android/graphics/Xfermode.cpp b/core/jni/android/graphics/Xfermode.cpp new file mode 100644 index 0000000..2b53d28 --- /dev/null +++ b/core/jni/android/graphics/Xfermode.cpp @@ -0,0 +1,77 @@ +/* + * Copyright (C) 2007 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. + */ + +#include "jni.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkAvoidXfermode.h" +#include "SkPixelXorXfermode.h" + +namespace android { + +class SkXfermodeGlue { +public: + + static void finalizer(JNIEnv* env, jobject, SkXfermode* obj) + { + obj->safeUnref(); + } + + static SkXfermode* avoid_create(JNIEnv* env, jobject, SkColor opColor, + U8CPU tolerance, SkAvoidXfermode::Mode mode) + { + return new SkAvoidXfermode(opColor, tolerance, mode); + } + + static SkXfermode* pixelxor_create(JNIEnv* env, jobject, SkColor opColor) + { + return new SkPixelXorXfermode(opColor); + } +}; + +/////////////////////////////////////////////////////////////////////////////// + +static JNINativeMethod gXfermodeMethods[] = { + {"finalizer", "(I)V", (void*) SkXfermodeGlue::finalizer} +}; + +static JNINativeMethod gAvoidMethods[] = { + {"nativeCreate", "(III)I", (void*) SkXfermodeGlue::avoid_create} +}; + +static JNINativeMethod gPixelXorMethods[] = { + {"nativeCreate", "(I)I", (void*) SkXfermodeGlue::pixelxor_create} +}; + +#include <android_runtime/AndroidRuntime.h> + +#define REG(env, name, array) \ + result = android::AndroidRuntime::registerNativeMethods(env, name, array, \ + SK_ARRAY_COUNT(array)); \ + if (result < 0) return result + +int register_android_graphics_Xfermode(JNIEnv* env) { + int result; + + REG(env, "android/graphics/Xfermode", gXfermodeMethods); + REG(env, "android/graphics/AvoidXfermode", gAvoidMethods); + REG(env, "android/graphics/PixelXorXfermode", gPixelXorMethods); + + return 0; +} + +} diff --git a/core/jni/android/opengl/poly.h b/core/jni/android/opengl/poly.h new file mode 100644 index 0000000..85b44e3 --- /dev/null +++ b/core/jni/android/opengl/poly.h @@ -0,0 +1,51 @@ +/* +** +** Copyright 2007, 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. +*/ + +/* Based on the public domain code: + * Generic Convex Polygon Scan Conversion and Clipping + * by Paul Heckbert + * from "Graphics Gems", Academic Press, 1990 + */ + + +#ifndef POLY_HDR +#define POLY_HDR + +namespace android { + +#define POLY_NMAX 10 /* max #sides to a polygon; change if needed */ +/* note that poly_clip, given an n-gon as input, might output an (n+6)gon */ +/* POLY_NMAX=10 is thus appropriate if input polygons are triangles or quads */ + +typedef struct { /* A POLYGON VERTEX */ + float sx, sy, sz, sw; /* screen space position (sometimes homo.) */ +} Poly_vert; + +typedef struct { /* A POLYGON */ + int n; /* number of sides */ + Poly_vert vert[POLY_NMAX]; /* vertices */ +} Poly; + +#define POLY_CLIP_OUT 0 /* polygon entirely outside box */ +#define POLY_CLIP_PARTIAL 1 /* polygon partially inside */ +#define POLY_CLIP_IN 2 /* polygon entirely inside box */ + +int poly_clip_to_frustum(Poly *p1); + +} // namespace android + +#endif diff --git a/core/jni/android/opengl/poly_clip.cpp b/core/jni/android/opengl/poly_clip.cpp new file mode 100644 index 0000000..04e4b17 --- /dev/null +++ b/core/jni/android/opengl/poly_clip.cpp @@ -0,0 +1,155 @@ +/* +** +** Copyright 2007, 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. +*/ + +/* + * Generic Convex Polygon Scan Conversion and Clipping + * by Paul Heckbert + * from "Graphics Gems", Academic Press, 1990 + */ + +/* Based on the public domain code: + * poly_clip.c: homogeneous 3-D convex polygon clipper + * + * Paul Heckbert 1985, Dec 1989 + */ + +#include "poly.h" +#include "string.h" + +#define LOG_TAG "StreetView" +#include <utils/Log.h> + +namespace android { + +#define SWAP(a, b, temp) {temp = a; a = b; b = temp;} +#define COORD(vert, i) ((float *)(vert))[i] + +#define CLIP_AND_SWAP(elem, sign, k, p, q, r) { \ + poly_clip_to_halfspace(p, q, &v->elem-(float *)v, sign, sign*k); \ + if (q->n==0) {p1->n = 0; return POLY_CLIP_OUT;} \ + SWAP(p, q, r); \ +} + +/* + * poly_clip_to_halfspace: clip convex polygon p against a plane, + * copying the portion satisfying sign*s[index] < k*sw into q, + * where s is a Poly_vert* cast as a float*. + * index is an index into the array of floats at each vertex, such that + * s[index] is sx, sy, or sz (screen space x, y, or z). + * Thus, to clip against xmin, use + * poly_clip_to_halfspace(p, q, XINDEX, -1., -xmin); + * and to clip against xmax, use + * poly_clip_to_halfspace(p, q, XINDEX, 1., xmax); + */ + +void poly_clip_to_halfspace(Poly* p, Poly* q, int index, float sign, float k) +{ + unsigned long m; + float *up, *vp, *wp; + Poly_vert *v; + int i; + Poly_vert *u; + float t, tu, tv; + + q->n = 0; + + /* start with u=vert[n-1], v=vert[0] */ + u = &p->vert[p->n-1]; + tu = sign*COORD(u, index) - u->sw*k; + for (v= &p->vert[0], i=p->n; i>0; i--, u=v, tu=tv, v++) { + /* on old polygon (p), u is previous vertex, v is current vertex */ + /* tv is negative if vertex v is in */ + tv = sign*COORD(v, index) - v->sw*k; + if ((tu <= 0.0f) ^ (tv <= 0.0f)) { + /* edge crosses plane; add intersection point to q */ + t = tu/(tu-tv); + up = (float *)u; + vp = (float *)v; + wp = (float *)&q->vert[q->n].sx; + for(int i = 0; i < 4; i++, wp++, up++, vp++) { + *wp = *up+t*(*vp-*up); + } + q->n++; + } + if (tv<=0.0f) /* vertex v is in, copy it to q */ + q->vert[q->n++] = *v; + } +} + +/* + * poly_clip_to_frustum: Clip the convex polygon p1 to the screen space frustum + * using the homogeneous screen coordinates (sx, sy, sz, sw) of each vertex, + * testing if v->sx/v->sw > box->x0 and v->sx/v->sw < box->x1, + * and similar tests for y and z, for each vertex v of the polygon. + * If polygon is entirely inside box, then POLY_CLIP_IN is returned. + * If polygon is entirely outside box, then POLY_CLIP_OUT is returned. + * Otherwise, if the polygon is cut by the box, p1 is modified and + * POLY_CLIP_PARTIAL is returned. + * + * Given an n-gon as input, clipping against 6 planes could generate an + * (n+6)gon, so POLY_NMAX in poly.h must be big enough to allow that. + */ + +int poly_clip_to_frustum(Poly *p1) +{ + int x0out = 0, x1out = 0, y0out = 0, y1out = 0, z0out = 0, z1out = 0; + int i; + Poly_vert *v; + Poly p2, *p, *q, *r; + + /* count vertices "outside" with respect to each of the six planes */ + for (v=p1->vert, i=p1->n; i>0; i--, v++) { + float sw = v->sw; + if (v->sx < -sw) x0out++; /* out on left */ + if (v->sx > sw) x1out++; /* out on right */ + if (v->sy < -sw) y0out++; /* out on top */ + if (v->sy > sw) y1out++; /* out on bottom */ + if (v->sz < -sw) z0out++; /* out on near */ + if (v->sz > sw) z1out++; /* out on far */ + } + + /* check if all vertices inside */ + if (x0out+x1out+y0out+y1out+z0out+z1out == 0) + return POLY_CLIP_IN; + + /* check if all vertices are "outside" any of the six planes */ + if (x0out==p1->n || x1out==p1->n || y0out==p1->n || + y1out==p1->n || z0out==p1->n || z1out==p1->n) { + p1->n = 0; + return POLY_CLIP_OUT; + } + + /* + * now clip against each of the planes that might cut the polygon, + * at each step toggling between polygons p1 and p2 + */ + p = p1; + q = &p2; + if (x0out) CLIP_AND_SWAP(sx, -1.0f, -1.0f, p, q, r); + if (x1out) CLIP_AND_SWAP(sx, 1.0f, 1.0f, p, q, r); + if (y0out) CLIP_AND_SWAP(sy, -1.0f, -1.0f, p, q, r); + if (y1out) CLIP_AND_SWAP(sy, 1.0f, 1.0f, p, q, r); + if (z0out) CLIP_AND_SWAP(sz, -1.0f, -1.0f, p, q, r); + if (z1out) CLIP_AND_SWAP(sz, 1.0f, 1.0f, p, q, r); + + /* if result ended up in p2 then copy it to p1 */ + if (p==&p2) + memcpy(p1, &p2, sizeof(Poly)-(POLY_NMAX-p2.n)*sizeof(Poly_vert)); + return POLY_CLIP_PARTIAL; +} + +} // namespace android diff --git a/core/jni/android/opengl/util.cpp b/core/jni/android/opengl/util.cpp new file mode 100644 index 0000000..5cd2ceb --- /dev/null +++ b/core/jni/android/opengl/util.cpp @@ -0,0 +1,730 @@ +/** + ** Copyright 2007, 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. + */ + +#include <nativehelper/jni.h> +#include <math.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <assert.h> +#include <dlfcn.h> + +#include <GLES/gl.h> + +#include <graphics/SkBitmap.h> + +#include "android_runtime/AndroidRuntime.h" + +#undef LOG_TAG +#define LOG_TAG "OpenGLUtil" +#include <utils/Log.h> +#include "utils/misc.h" + +#include "poly.h" + +namespace android { + +static jclass gIAEClass; +static jclass gUOEClass; + +static inline +void mx4transform(float x, float y, float z, float w, const float* pM, float* pDest) { + pDest[0] = pM[0 + 4 * 0] * x + pM[0 + 4 * 1] * y + pM[0 + 4 * 2] * z + pM[0 + 4 * 3] * w; + pDest[1] = pM[1 + 4 * 0] * x + pM[1 + 4 * 1] * y + pM[1 + 4 * 2] * z + pM[1 + 4 * 3] * w; + pDest[2] = pM[2 + 4 * 0] * x + pM[2 + 4 * 1] * y + pM[2 + 4 * 2] * z + pM[2 + 4 * 3] * w; + pDest[3] = pM[3 + 4 * 0] * x + pM[3 + 4 * 1] * y + pM[3 + 4 * 2] * z + pM[3 + 4 * 3] * w; +} + +class MallocHelper { +public: + MallocHelper() { + mData = 0; + } + + ~MallocHelper() { + if (mData != 0) { + free(mData); + } + } + + void* alloc(size_t size) { + mData = malloc(size); + return mData; + } + +private: + void* mData; +}; + +#if 0 +static +void +print_poly(const char* label, Poly* pPoly) { + LOGI("%s: %d verts", label, pPoly->n); + for(int i = 0; i < pPoly->n; i++) { + Poly_vert* pV = & pPoly->vert[i]; + LOGI("[%d] %g, %g, %g %g", i, pV->sx, pV->sy, pV->sz, pV->sw); + } +} +#endif + +static +int visibilityTest(float* pWS, float* pPositions, int positionsLength, + unsigned short* pIndices, int indexCount) { + MallocHelper mallocHelper; + int result = POLY_CLIP_OUT; + float* pTransformed = 0; + int transformedIndexCount = 0; + + if ( indexCount < 3 ) { + return POLY_CLIP_OUT; + } + + // Find out how many vertices we need to transform + // We transform every vertex between the min and max indices, inclusive. + // This is OK for the data sets we expect to use with this function, but + // for other loads it might be better to use a more sophisticated vertex + // cache of some sort. + + int minIndex = 65536; + int maxIndex = -1; + for(int i = 0; i < indexCount; i++) { + int index = pIndices[i]; + if ( index < minIndex ) { + minIndex = index; + } + if ( index > maxIndex ) { + maxIndex = index; + } + } + + if ( maxIndex * 3 > positionsLength) { + return -1; + } + + transformedIndexCount = maxIndex - minIndex + 1; + pTransformed = (float*) mallocHelper.alloc(transformedIndexCount * 4 * sizeof(float)); + + if (pTransformed == 0 ) { + return -2; + } + + // Transform the vertices + { + const float* pSrc = pPositions + 3 * minIndex; + float* pDst = pTransformed; + for (int i = 0; i < transformedIndexCount; i++, pSrc += 3, pDst += 4) { + mx4transform(pSrc[0], pSrc[1], pSrc[2], 1.0f, pWS, pDst); + } + } + + // Clip the triangles + + Poly poly; + float* pDest = & poly.vert[0].sx; + for (int i = 0; i < indexCount; i += 3) { + poly.n = 3; + memcpy(pDest , pTransformed + 4 * (pIndices[i ] - minIndex), 4 * sizeof(float)); + memcpy(pDest + 4, pTransformed + 4 * (pIndices[i + 1] - minIndex), 4 * sizeof(float)); + memcpy(pDest + 8, pTransformed + 4 * (pIndices[i + 2] - minIndex), 4 * sizeof(float)); + result = poly_clip_to_frustum(&poly); + if ( result != POLY_CLIP_OUT) { + return result; + } + } + + return result; +} + +template<class JArray, class T> +class ArrayHelper { +public: + ArrayHelper(JNIEnv* env, JArray ref, jint offset, jint minSize) { + mEnv = env; + mRef = ref; + mOffset = offset; + mMinSize = minSize; + mBase = 0; + mReleaseParam = JNI_ABORT; + } + + ~ArrayHelper() { + if (mBase) { + mEnv->ReleasePrimitiveArrayCritical(mRef, mBase, mReleaseParam); + } + } + + // We seperate the bounds check from the initialization because we want to + // be able to bounds-check multiple arrays, and we can't throw an exception + // after we've called GetPrimitiveArrayCritical. + + // Return true if the bounds check succeeded + // Else instruct the runtime to throw an exception + + bool check() { + if ( ! mRef) { + mEnv->ThrowNew(gIAEClass, "array == null"); + return false; + } + if ( mOffset < 0) { + mEnv->ThrowNew(gIAEClass, "offset < 0"); + return false; + } + mLength = mEnv->GetArrayLength(mRef) - mOffset; + if (mLength < mMinSize ) { + mEnv->ThrowNew(gIAEClass, "length - offset < n"); + return false; + } + return true; + } + + // Bind the array. + + void bind() { + mBase = (T*) mEnv->GetPrimitiveArrayCritical(mRef, (jboolean *) 0); + mData = mBase + mOffset; + } + + void commitChanges() { + mReleaseParam = 0; + } + + T* mData; + int mLength; + +private: + T* mBase; + JNIEnv* mEnv; + JArray mRef; + jint mOffset; + jint mMinSize; + int mReleaseParam; +}; + +typedef ArrayHelper<jfloatArray, float> FloatArrayHelper; +typedef ArrayHelper<jcharArray, unsigned short> UnsignedShortArrayHelper; +typedef ArrayHelper<jintArray, int> IntArrayHelper; +typedef ArrayHelper<jbyteArray, unsigned char> ByteArrayHelper; + +inline float distance2(float x, float y, float z) { + return x * x + y * y + z * z; +} + +inline float distance(float x, float y, float z) { + return sqrtf(distance2(x, y, z)); +} + +static +void util_computeBoundingSphere(JNIEnv *env, jclass clazz, + jfloatArray positions_ref, jint positionsOffset, jint positionsCount, + jfloatArray sphere_ref, jint sphereOffset) { + FloatArrayHelper positions(env, positions_ref, positionsOffset, 0); + FloatArrayHelper sphere(env, sphere_ref, sphereOffset, 4); + + bool checkOK = positions.check() && sphere.check(); + if (! checkOK) { + return; + } + + positions.bind(); + sphere.bind(); + + if ( positionsCount < 1 ) { + env->ThrowNew(gIAEClass, "positionsCount < 1"); + return; + } + + const float* pSrc = positions.mData; + + // find bounding box + float x0 = *pSrc++; + float x1 = x0; + float y0 = *pSrc++; + float y1 = y0; + float z0 = *pSrc++; + float z1 = z0; + + for(int i = 1; i < positionsCount; i++) { + { + float x = *pSrc++; + if (x < x0) { + x0 = x; + } + else if (x > x1) { + x1 = x; + } + } + { + float y = *pSrc++; + if (y < y0) { + y0 = y; + } + else if (y > y1) { + y1 = y; + } + } + { + float z = *pSrc++; + if (z < z0) { + z0 = z; + } + else if (z > z1) { + z1 = z; + } + } + } + + // Because we know our input meshes fit pretty well into bounding boxes, + // just take the diagonal of the box as defining our sphere. + float* pSphere = sphere.mData; + float dx = x1 - x0; + float dy = y1 - y0; + float dz = z1 - z0; + *pSphere++ = x0 + dx * 0.5f; + *pSphere++ = y0 + dy * 0.5f; + *pSphere++ = z0 + dz * 0.5f; + *pSphere++ = distance(dx, dy, dz) * 0.5f; + + sphere.commitChanges(); +} + +static void normalizePlane(float* p) { + float rdist = 1.0f / distance(p[0], p[1], p[2]); + for(int i = 0; i < 4; i++) { + p[i] *= rdist; + } +} + +static inline float dot3(float x0, float y0, float z0, float x1, float y1, float z1) { + return x0 * x1 + y0 * y1 + z0 * z1; +} + +static inline float signedDistance(const float* pPlane, float x, float y, float z) { + return dot3(pPlane[0], pPlane[1], pPlane[2], x, y, z) + pPlane[3]; +} + +// Return true if the sphere intersects or is inside the frustum + +static bool sphereHitsFrustum(const float* pFrustum, const float* pSphere) { + float x = pSphere[0]; + float y = pSphere[1]; + float z = pSphere[2]; + float negRadius = -pSphere[3]; + for (int i = 0; i < 6; i++, pFrustum += 4) { + if (signedDistance(pFrustum, x, y, z) <= negRadius) { + return false; + } + } + return true; +} + +static void computeFrustum(const float* m, float* f) { + float m3 = m[3]; + float m7 = m[7]; + float m11 = m[11]; + float m15 = m[15]; + // right + f[0] = m3 - m[0]; + f[1] = m7 - m[4]; + f[2] = m11 - m[8]; + f[3] = m15 - m[12]; + normalizePlane(f); + f+= 4; + + // left + f[0] = m3 + m[0]; + f[1] = m7 + m[4]; + f[2] = m11 + m[8]; + f[3] = m15 + m[12]; + normalizePlane(f); + f+= 4; + + // top + f[0] = m3 - m[1]; + f[1] = m7 - m[5]; + f[2] = m11 - m[9]; + f[3] = m15 - m[13]; + normalizePlane(f); + f+= 4; + + // bottom + f[0] = m3 + m[1]; + f[1] = m7 + m[5]; + f[2] = m11 + m[9]; + f[3] = m15 + m[13]; + normalizePlane(f); + f+= 4; + + // far + f[0] = m3 - m[2]; + f[1] = m7 - m[6]; + f[2] = m11 - m[10]; + f[3] = m15 - m[14]; + normalizePlane(f); + f+= 4; + + // near + f[0] = m3 + m[2]; + f[1] = m7 + m[6]; + f[2] = m11 + m[10]; + f[3] = m15 + m[14]; + normalizePlane(f); +} + +static +int util_frustumCullSpheres(JNIEnv *env, jclass clazz, + jfloatArray mvp_ref, jint mvpOffset, + jfloatArray spheres_ref, jint spheresOffset, jint spheresCount, + jintArray results_ref, jint resultsOffset, jint resultsCapacity) { + float frustum[6*4]; + int outputCount; + int* pResults; + float* pSphere; + FloatArrayHelper mvp(env, mvp_ref, mvpOffset, 16); + FloatArrayHelper spheres(env, spheres_ref, spheresOffset, spheresCount * 4); + IntArrayHelper results(env, results_ref, resultsOffset, resultsCapacity); + + bool initializedOK = mvp.check() && spheres.check() && results.check(); + if (! initializedOK) { + return -1; + } + + mvp.bind(); + spheres.bind(); + results.bind(); + + computeFrustum(mvp.mData, frustum); + + // Cull the spheres + + pSphere = spheres.mData; + pResults = results.mData; + outputCount = 0; + for(int i = 0; i < spheresCount; i++, pSphere += 4) { + if (sphereHitsFrustum(frustum, pSphere)) { + if (outputCount < resultsCapacity) { + *pResults++ = i; + } + outputCount++; + } + } + results.commitChanges(); + return outputCount; +} + +/* + public native int visibilityTest(float[] ws, int wsOffset, + float[] positions, int positionsOffset, + char[] indices, int indicesOffset, int indexCount); + */ + +static +int util_visibilityTest(JNIEnv *env, jclass clazz, + jfloatArray ws_ref, jint wsOffset, + jfloatArray positions_ref, jint positionsOffset, + jcharArray indices_ref, jint indicesOffset, jint indexCount) { + + FloatArrayHelper ws(env, ws_ref, wsOffset, 16); + FloatArrayHelper positions(env, positions_ref, positionsOffset, 0); + UnsignedShortArrayHelper indices(env, indices_ref, indicesOffset, 0); + + bool checkOK = ws.check() && positions.check() && indices.check(); + if (! checkOK) { + // Return value will be ignored, because an exception has been thrown. + return -1; + } + + if (indices.mLength < indexCount) { + env->ThrowNew(gIAEClass, "length < offset + indexCount"); + // Return value will be ignored, because an exception has been thrown. + return -1; + } + + ws.bind(); + positions.bind(); + indices.bind(); + + return visibilityTest(ws.mData, + positions.mData, positions.mLength, + indices.mData, indexCount); +} + +#define I(_i, _j) ((_j)+ 4*(_i)) + +static +void multiplyMM(float* r, const float* lhs, const float* rhs) +{ + for (int i=0 ; i<4 ; i++) { + register const float rhs_i0 = rhs[ I(i,0) ]; + register float ri0 = lhs[ I(0,0) ] * rhs_i0; + register float ri1 = lhs[ I(0,1) ] * rhs_i0; + register float ri2 = lhs[ I(0,2) ] * rhs_i0; + register float ri3 = lhs[ I(0,3) ] * rhs_i0; + for (int j=1 ; j<4 ; j++) { + register const float rhs_ij = rhs[ I(i,j) ]; + ri0 += lhs[ I(j,0) ] * rhs_ij; + ri1 += lhs[ I(j,1) ] * rhs_ij; + ri2 += lhs[ I(j,2) ] * rhs_ij; + ri3 += lhs[ I(j,3) ] * rhs_ij; + } + r[ I(i,0) ] = ri0; + r[ I(i,1) ] = ri1; + r[ I(i,2) ] = ri2; + r[ I(i,3) ] = ri3; + } +} + +static +void util_multiplyMM(JNIEnv *env, jclass clazz, + jfloatArray result_ref, jint resultOffset, + jfloatArray lhs_ref, jint lhsOffset, + jfloatArray rhs_ref, jint rhsOffset) { + + FloatArrayHelper resultMat(env, result_ref, resultOffset, 16); + FloatArrayHelper lhs(env, lhs_ref, lhsOffset, 16); + FloatArrayHelper rhs(env, rhs_ref, rhsOffset, 16); + + bool checkOK = resultMat.check() && lhs.check() && rhs.check(); + + if ( !checkOK ) { + return; + } + + resultMat.bind(); + lhs.bind(); + rhs.bind(); + + multiplyMM(resultMat.mData, lhs.mData, rhs.mData); + + resultMat.commitChanges(); +} + +static +void multiplyMV(float* r, const float* lhs, const float* rhs) +{ + mx4transform(rhs[0], rhs[1], rhs[2], rhs[3], lhs, r); +} + +static +void util_multiplyMV(JNIEnv *env, jclass clazz, + jfloatArray result_ref, jint resultOffset, + jfloatArray lhs_ref, jint lhsOffset, + jfloatArray rhs_ref, jint rhsOffset) { + + FloatArrayHelper resultV(env, result_ref, resultOffset, 4); + FloatArrayHelper lhs(env, lhs_ref, lhsOffset, 16); + FloatArrayHelper rhs(env, rhs_ref, rhsOffset, 4); + + bool checkOK = resultV.check() && lhs.check() && rhs.check(); + + if ( !checkOK ) { + return; + } + + resultV.bind(); + lhs.bind(); + rhs.bind(); + + multiplyMV(resultV.mData, lhs.mData, rhs.mData); + + resultV.commitChanges(); +} + +// --------------------------------------------------------------------------- + +static jfieldID nativeBitmapID = 0; + +void nativeUtilsClassInit(JNIEnv *env, jclass clazz) +{ + jclass bitmapClass = env->FindClass("android/graphics/Bitmap"); + nativeBitmapID = env->GetFieldID(bitmapClass, "mNativeBitmap", "I"); +} + +static int checkFormat(SkBitmap::Config config, int format, int type) +{ + switch(config) { + case SkBitmap::kIndex8_Config: + if (format == GL_PALETTE8_RGBA8_OES) + return 0; + case SkBitmap::kARGB_8888_Config: + case SkBitmap::kA8_Config: + if (type == GL_UNSIGNED_BYTE) + return 0; + case SkBitmap::kARGB_4444_Config: + case SkBitmap::kRGB_565_Config: + switch (type) { + case GL_UNSIGNED_SHORT_4_4_4_4: + case GL_UNSIGNED_SHORT_5_6_5: + case GL_UNSIGNED_SHORT_5_5_5_1: + return 0; + case GL_UNSIGNED_BYTE: + if (format == GL_LUMINANCE_ALPHA) + return 0; + } + break; + default: + break; + } + return -1; +} + +static int getInternalFormat(SkBitmap::Config config) +{ + switch(config) { + case SkBitmap::kA8_Config: + return GL_ALPHA; + case SkBitmap::kARGB_4444_Config: + return GL_RGBA; + case SkBitmap::kARGB_8888_Config: + return GL_RGBA; + case SkBitmap::kIndex8_Config: + return GL_PALETTE8_RGBA8_OES; + case SkBitmap::kRGB_565_Config: + return GL_RGB; + default: + return -1; + } +} + +static jint util_texImage2D(JNIEnv *env, jclass clazz, + jint target, jint level, jint internalformat, + jobject jbitmap, jint type, jint border) +{ + SkBitmap const * nativeBitmap = + (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID); + const SkBitmap& bitmap(*nativeBitmap); + SkBitmap::Config config = bitmap.getConfig(); + if (internalformat < 0) { + internalformat = getInternalFormat(config); + } + int err = checkFormat(config, internalformat, type); + if (err) + return err; + bitmap.lockPixels(); + const int w = bitmap.width(); + const int h = bitmap.height(); + const void* p = bitmap.getPixels(); + if (internalformat == GL_PALETTE8_RGBA8_OES) { + if (sizeof(SkPMColor) != sizeof(uint32_t)) { + err = -1; + goto error; + } + const size_t size = bitmap.getSize(); + const size_t palette_size = 256*sizeof(SkPMColor); + void* const data = malloc(size + palette_size); + if (data) { + void* const pixels = (char*)data + palette_size; + SkColorTable* ctable = bitmap.getColorTable(); + memcpy(data, ctable->lockColors(), ctable->count() * sizeof(SkPMColor)); + memcpy(pixels, p, size); + ctable->unlockColors(false); + glCompressedTexImage2D(target, level, internalformat, w, h, border, 0, data); + free(data); + } else { + err = -1; + } + } else { + glTexImage2D(target, level, internalformat, w, h, border, internalformat, type, p); + } +error: + bitmap.unlockPixels(); + return err; +} + +static jint util_texSubImage2D(JNIEnv *env, jclass clazz, + jint target, jint level, jint xoffset, jint yoffset, + jobject jbitmap, jint format, jint type) +{ + SkBitmap const * nativeBitmap = + (SkBitmap const *)env->GetIntField(jbitmap, nativeBitmapID); + const SkBitmap& bitmap(*nativeBitmap); + SkBitmap::Config config = bitmap.getConfig(); + if (format < 0) { + format = getInternalFormat(config); + if (format == GL_PALETTE8_RGBA8_OES) + return -1; // glCompressedTexSubImage2D() not supported + } + int err = checkFormat(config, format, type); + if (err) + return err; + bitmap.lockPixels(); + const int w = bitmap.width(); + const int h = bitmap.height(); + const void* p = bitmap.getPixels(); + glTexSubImage2D(target, level, xoffset, yoffset, w, h, format, type, p); + bitmap.unlockPixels(); + return 0; +} + +/* + * JNI registration + */ + +static void +lookupClasses(JNIEnv* env) { + gIAEClass = (jclass) env->NewGlobalRef( + env->FindClass("java/lang/IllegalArgumentException")); + gUOEClass = (jclass) env->NewGlobalRef( + env->FindClass("java/lang/UnsupportedOperationException")); +} + +static JNINativeMethod gMatrixMethods[] = { + { "multiplyMM", "([FI[FI[FI)V", (void*)util_multiplyMM }, + { "multiplyMV", "([FI[FI[FI)V", (void*)util_multiplyMV }, +}; + +static JNINativeMethod gVisiblityMethods[] = { + { "computeBoundingSphere", "([FII[FI)V", (void*)util_computeBoundingSphere }, + { "frustumCullSpheres", "([FI[FII[III)I", (void*)util_frustumCullSpheres }, + { "visibilityTest", "([FI[FI[CII)I", (void*)util_visibilityTest }, +}; + +static JNINativeMethod gUtilsMethods[] = { + {"nativeClassInit", "()V", (void*)nativeUtilsClassInit }, + { "native_texImage2D", "(IIILandroid/graphics/Bitmap;II)I", (void*)util_texImage2D }, + { "native_texSubImage2D", "(IIIILandroid/graphics/Bitmap;II)I", (void*)util_texSubImage2D }, +}; + +typedef struct _ClassRegistrationInfo { + const char* classPath; + JNINativeMethod* methods; + size_t methodCount; +} ClassRegistrationInfo; + +static ClassRegistrationInfo gClasses[] = { + {"android/opengl/Matrix", gMatrixMethods, NELEM(gMatrixMethods)}, + {"android/opengl/Visibility", gVisiblityMethods, NELEM(gVisiblityMethods)}, + {"android/opengl/GLUtils", gUtilsMethods, NELEM(gUtilsMethods)}, +}; + +int register_android_opengl_classes(JNIEnv* env) +{ + lookupClasses(env); + int result = 0; + for (int i = 0; i < NELEM(gClasses); i++) { + ClassRegistrationInfo* cri = &gClasses[i]; + result = AndroidRuntime::registerNativeMethods(env, + cri->classPath, cri->methods, cri->methodCount); + if (result < 0) { + LOGE("Failed to register %s: %d", cri->classPath, result); + break; + } + } + return result; +} + +} // namespace android + diff --git a/core/jni/android_bluetooth_BluetoothAudioGateway.cpp b/core/jni/android_bluetooth_BluetoothAudioGateway.cpp new file mode 100755 index 0000000..7f87d80 --- /dev/null +++ b/core/jni/android_bluetooth_BluetoothAudioGateway.cpp @@ -0,0 +1,553 @@ +/* +** Copyright 2006, 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. +*/ + +#define LOG_TAG "BluetoothAudioGateway.cpp" + +#include "android_bluetooth_common.h" +#include "android_runtime/AndroidRuntime.h" +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#define USE_ACCEPT_DIRECTLY (0) +#define USE_SELECT (0) /* 1 for select(), 0 for poll(); used only when + USE_ACCEPT_DIRECTLY == 0 */ + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/socket.h> +#include <sys/time.h> +#include <sys/types.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/uio.h> +#include <ctype.h> + +#if USE_SELECT +#include <sys/select.h> +#else +#include <sys/poll.h> +#endif + +#ifdef HAVE_BLUETOOTH +#include <bluetooth/bluetooth.h> +#include <bluetooth/hci.h> +#include <bluetooth/hci_lib.h> +#include <bluetooth/rfcomm.h> +#include <bluetooth/sco.h> +#endif + +namespace android { + +#ifdef HAVE_BLUETOOTH +static jfieldID field_mNativeData; + /* in */ +static jfieldID field_mHandsfreeAgRfcommChannel; +static jfieldID field_mHeadsetAgRfcommChannel; + /* out */ +static jfieldID field_mTimeoutRemainingMs; /* out */ + +static jfieldID field_mConnectingHeadsetAddress; +static jfieldID field_mConnectingHeadsetRfcommChannel; /* -1 when not connected */ +static jfieldID field_mConnectingHeadsetSocketFd; + +static jfieldID field_mConnectingHandsfreeAddress; +static jfieldID field_mConnectingHandsfreeRfcommChannel; /* -1 when not connected */ +static jfieldID field_mConnectingHandsfreeSocketFd; + + +typedef struct { + int hcidev; + int hf_ag_rfcomm_channel; + int hs_ag_rfcomm_channel; + int hf_ag_rfcomm_sock; + int hs_ag_rfcomm_sock; +} native_data_t; + +static inline native_data_t * get_native_data(JNIEnv *env, jobject object) { + return (native_data_t *)(env->GetIntField(object, + field_mNativeData)); +} + +static int setup_listening_socket(int dev, int channel); +#endif + +static void classInitNative(JNIEnv* env, jclass clazz) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + + /* in */ + field_mNativeData = get_field(env, clazz, "mNativeData", "I"); + field_mHandsfreeAgRfcommChannel = + get_field(env, clazz, "mHandsfreeAgRfcommChannel", "I"); + field_mHeadsetAgRfcommChannel = + get_field(env, clazz, "mHeadsetAgRfcommChannel", "I"); + + /* out */ + field_mConnectingHeadsetAddress = + get_field(env, clazz, + "mConnectingHeadsetAddress", "Ljava/lang/String;"); + field_mConnectingHeadsetRfcommChannel = + get_field(env, clazz, "mConnectingHeadsetRfcommChannel", "I"); + field_mConnectingHeadsetSocketFd = + get_field(env, clazz, "mConnectingHeadsetSocketFd", "I"); + + field_mConnectingHandsfreeAddress = + get_field(env, clazz, + "mConnectingHandsfreeAddress", "Ljava/lang/String;"); + field_mConnectingHandsfreeRfcommChannel = + get_field(env, clazz, "mConnectingHandsfreeRfcommChannel", "I"); + field_mConnectingHandsfreeSocketFd = + get_field(env, clazz, "mConnectingHandsfreeSocketFd", "I"); + + field_mTimeoutRemainingMs = + get_field(env, clazz, "mTimeoutRemainingMs", "I"); +#endif +} + +static void initializeNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = (native_data_t *)calloc(1, sizeof(native_data_t)); + if (NULL == nat) { + LOGE("%s: out of memory!", __FUNCTION__); + return; + } + + nat->hcidev = BLUETOOTH_ADAPTER_HCI_NUM; + + env->SetIntField(object, field_mNativeData, (jint)nat); + nat->hf_ag_rfcomm_channel = + env->GetIntField(object, field_mHandsfreeAgRfcommChannel); + nat->hs_ag_rfcomm_channel = + env->GetIntField(object, field_mHeadsetAgRfcommChannel); + LOGV("HF RFCOMM channel = %d.", nat->hf_ag_rfcomm_channel); + LOGV("HS RFCOMM channel = %d.", nat->hs_ag_rfcomm_channel); + + /* Set the default values of these to -1. */ + env->SetIntField(object, field_mConnectingHeadsetRfcommChannel, -1); + env->SetIntField(object, field_mConnectingHandsfreeRfcommChannel, -1); + + nat->hf_ag_rfcomm_sock = -1; + nat->hs_ag_rfcomm_sock = -1; +#endif +} + +static void cleanupNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + if (nat) { + free(nat); + } +#endif +} + +#ifdef HAVE_BLUETOOTH + +#if USE_ACCEPT_DIRECTLY==0 +static int set_nb(int sk, bool nb) { + int flags = fcntl(sk, F_GETFL); + if (flags < 0) { + LOGE("Can't get socket flags with fcntl(): %s (%d)", + strerror(errno), errno); + close(sk); + return -1; + } + flags &= ~O_NONBLOCK; + if (nb) flags |= O_NONBLOCK; + int status = fcntl(sk, F_SETFL, flags); + if (status < 0) { + LOGE("Can't set socket to nonblocking mode with fcntl(): %s (%d)", + strerror(errno), errno); + close(sk); + return -1; + } + return 0; +} +#endif /*USE_ACCEPT_DIRECTLY==0*/ + +static int do_accept(JNIEnv* env, jobject object, int ag_fd, + jfieldID out_fd, + jfieldID out_address, + jfieldID out_channel) { + +#if USE_ACCEPT_DIRECTLY==0 + if (set_nb(ag_fd, true) < 0) + return -1; +#endif + + struct sockaddr_rc raddr; + int alen = sizeof(raddr); + int nsk = accept(ag_fd, (struct sockaddr *) &raddr, &alen); + if (nsk < 0) { + LOGE("Error on accept from socket fd %d: %s (%d).", + ag_fd, + strerror(errno), + errno); +#if USE_ACCEPT_DIRECTLY==0 + set_nb(ag_fd, false); +#endif + return -1; + } + + env->SetIntField(object, out_fd, nsk); + env->SetIntField(object, out_channel, raddr.rc_channel); + + char addr[BTADDR_SIZE]; + get_bdaddr_as_string(&raddr.rc_bdaddr, addr); + env->SetObjectField(object, out_address, env->NewStringUTF(addr)); + + LOGI("Successful accept() on AG socket %d: new socket %d, address %s, RFCOMM channel %d", + ag_fd, + nsk, + addr, + raddr.rc_channel); +#if USE_ACCEPT_DIRECTLY==0 + set_nb(ag_fd, false); +#endif + return 0; +} + +#if USE_SELECT +static inline int on_accept_set_fields(JNIEnv* env, jobject object, + fd_set *rset, int ag_fd, + jfieldID out_fd, + jfieldID out_address, + jfieldID out_channel) { + + env->SetIntField(object, out_channel, -1); + + if (ag_fd >= 0 && FD_ISSET(ag_fd, &rset)) { + return do_accept(env, object, ag_fd, + out_fd, out_address, out_channel); + } + else { + LOGI("fd = %d, FD_ISSET() = %d", + ag_fd, + FD_ISSET(ag_fd, &rset)); + if (ag_fd >= 0 && !FD_ISSET(ag_fd, &rset)) { + LOGE("WTF???"); + return -1; + } + } + + return 0; +} +#endif +#endif /* HAVE_BLUETOOTH */ + +static jboolean waitForHandsfreeConnectNative(JNIEnv* env, jobject object, + jint timeout_ms) { +// LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + + env->SetIntField(object, field_mTimeoutRemainingMs, timeout_ms); + + int n = 0; + native_data_t *nat = get_native_data(env, object); +#if USE_ACCEPT_DIRECTLY + if (nat->hf_ag_rfcomm_channel > 0) { + LOGI("Setting HF AG server socket to RFCOMM port %d!", + nat->hf_ag_rfcomm_channel); + struct timeval tv; + int len = sizeof(tv); + if (getsockopt(nat->hf_ag_rfcomm_channel, + SOL_SOCKET, SO_RCVTIMEO, &tv, &len) < 0) { + LOGE("getsockopt(%d, SOL_SOCKET, SO_RCVTIMEO): %s (%d)", + nat->hf_ag_rfcomm_channel, + strerror(errno), + errno); + return JNI_FALSE; + } + LOGI("Current HF AG server socket RCVTIMEO is (%d(s), %d(us))!", + (int)tv.tv_sec, (int)tv.tv_usec); + if (timeout_ms >= 0) { + tv.tv_sec = timeout_ms / 1000; + tv.tv_usec = 1000 * (timeout_ms % 1000); + if (setsockopt(nat->hf_ag_rfcomm_channel, + SOL_SOCKET, SO_RCVTIMEO, &tv, sizeof(tv)) < 0) { + LOGE("setsockopt(%d, SOL_SOCKET, SO_RCVTIMEO): %s (%d)", + nat->hf_ag_rfcomm_channel, + strerror(errno), + errno); + return JNI_FALSE; + } + LOGI("Changed HF AG server socket RCVTIMEO to (%d(s), %d(us))!", + (int)tv.tv_sec, (int)tv.tv_usec); + } + + if (!do_accept(env, object, nat->hf_ag_rfcomm_sock, + field_mConnectingHandsfreeSocketFd, + field_mConnectingHandsfreeAddress, + field_mConnectingHandsfreeRfcommChannel)) + { + env->SetIntField(object, field_mTimeoutRemainingMs, 0); + return JNI_TRUE; + } + return JNI_FALSE; + } +#else +#if USE_SELECT + fd_set rset; + FD_ZERO(&rset); + int cnt = 0; + if (nat->hf_ag_rfcomm_channel > 0) { + LOGI("Setting HF AG server socket to RFCOMM port %d!", + nat->hf_ag_rfcomm_channel); + cnt++; + FD_SET(nat->hf_ag_rfcomm_sock, &rset); + } + if (nat->hs_ag_rfcomm_channel > 0) { + LOGI("Setting HS AG server socket to RFCOMM port %d!", + nat->hs_ag_rfcomm_channel); + cnt++; + FD_SET(nat->hs_ag_rfcomm_sock, &rset); + } + if (cnt == 0) { + LOGE("Neither HF nor HS listening sockets are open!"); + return JNI_FALSE; + } + + struct timeval to; + if (timeout_ms >= 0) { + to.tv_sec = timeout_ms / 1000; + to.tv_usec = 1000 * (timeout_ms % 1000); + } + n = select(MAX(nat->hf_ag_rfcomm_sock, + nat->hs_ag_rfcomm_sock) + 1, + &rset, + NULL, + NULL, + (timeout_ms < 0 ? NULL : &to)); + if (timeout_ms > 0) { + jint remaining = to.tv_sec*1000 + to.tv_usec/1000; + LOGI("Remaining time %ldms", (long)remaining); + env->SetIntField(object, field_mTimeoutRemainingMs, + remaining); + } + + LOGI("listening select() returned %d", n); + + if (n <= 0) { + if (n < 0) { + LOGE("listening select() on RFCOMM sockets: %s (%d)", + strerror(errno), + errno); + } + return JNI_FALSE; + } + + n = on_accept_set_fields(env, object, + &rset, nat->hf_ag_rfcomm_sock, + field_mConnectingHandsfreeSocketFd, + field_mConnectingHandsfreeAddress, + field_mConnectingHandsfreeRfcommChannel); + + n += on_accept_set_fields(env, object, + &rset, nat->hs_ag_rfcomm_sock, + field_mConnectingHeadsetSocketFd, + field_mConnectingHeadsetAddress, + field_mConnectingHeadsetRfcommChannel); + + return !n ? JNI_TRUE : JNI_FALSE; +#else + struct pollfd fds[2]; + int cnt = 0; + if (nat->hf_ag_rfcomm_channel > 0) { +// LOGI("Setting HF AG server socket %d to RFCOMM port %d!", +// nat->hf_ag_rfcomm_sock, +// nat->hf_ag_rfcomm_channel); + fds[cnt].fd = nat->hf_ag_rfcomm_sock; + fds[cnt].events = POLLIN | POLLPRI | POLLOUT | POLLERR; + cnt++; + } + if (nat->hs_ag_rfcomm_channel > 0) { +// LOGI("Setting HS AG server socket %d to RFCOMM port %d!", +// nat->hs_ag_rfcomm_sock, +// nat->hs_ag_rfcomm_channel); + fds[cnt].fd = nat->hs_ag_rfcomm_sock; + fds[cnt].events = POLLIN | POLLPRI | POLLOUT | POLLERR; + cnt++; + } + if (cnt == 0) { + LOGE("Neither HF nor HS listening sockets are open!"); + return JNI_FALSE; + } + n = poll(fds, cnt, timeout_ms); + if (n <= 0) { + if (n < 0) { + LOGE("listening poll() on RFCOMM sockets: %s (%d)", + strerror(errno), + errno); + } + else { + env->SetIntField(object, field_mTimeoutRemainingMs, 0); +// LOGI("listening poll() on RFCOMM socket timed out"); + } + return JNI_FALSE; + } + + //LOGI("listening poll() on RFCOMM socket returned %d", n); + int err = 0; + for (cnt = 0; cnt < (int)(sizeof(fds)/sizeof(fds[0])); cnt++) { + //LOGI("Poll on fd %d revent = %d.", fds[cnt].fd, fds[cnt].revents); + if (fds[cnt].fd == nat->hf_ag_rfcomm_sock) { + if (fds[cnt].revents & (POLLIN | POLLPRI | POLLOUT)) { + LOGI("Accepting HF connection.\n"); + err += do_accept(env, object, fds[cnt].fd, + field_mConnectingHandsfreeSocketFd, + field_mConnectingHandsfreeAddress, + field_mConnectingHandsfreeRfcommChannel); + n--; + } + } + else if (fds[cnt].fd == nat->hs_ag_rfcomm_sock) { + if (fds[cnt].revents & (POLLIN | POLLPRI | POLLOUT)) { + LOGI("Accepting HS connection.\n"); + err += do_accept(env, object, fds[cnt].fd, + field_mConnectingHeadsetSocketFd, + field_mConnectingHeadsetAddress, + field_mConnectingHeadsetRfcommChannel); + n--; + } + } + } /* for */ + + if (n != 0) { + LOGI("Bogus poll(): %d fake pollfd entrie(s)!", n); + return JNI_FALSE; + } + + return !err ? JNI_TRUE : JNI_FALSE; +#endif /* USE_SELECT */ +#endif /* USE_ACCEPT_DIRECTLY */ +#else + return JNI_FALSE; +#endif /* HAVE_BLUETOOTH */ +} + +static jboolean setUpListeningSocketsNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + + nat->hf_ag_rfcomm_sock = + setup_listening_socket(nat->hcidev, nat->hf_ag_rfcomm_channel); + if (nat->hf_ag_rfcomm_sock < 0) + return JNI_FALSE; + + nat->hs_ag_rfcomm_sock = + setup_listening_socket(nat->hcidev, nat->hs_ag_rfcomm_channel); + if (nat->hs_ag_rfcomm_sock < 0) { + close(nat->hf_ag_rfcomm_sock); + nat->hf_ag_rfcomm_sock = -1; + return JNI_FALSE; + } + + return JNI_TRUE; +#else + return JNI_FALSE; +#endif /* HAVE_BLUETOOTH */ +} + +#ifdef HAVE_BLUETOOTH +static int setup_listening_socket(int dev, int channel) { + struct sockaddr_rc laddr; + int sk, lm; + + sk = socket(AF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); + if (sk < 0) { + LOGE("Can't create RFCOMM socket"); + return -1; + } + + if (debug_no_encrypt()) { + lm = RFCOMM_LM_AUTH; + } else { + lm = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT; + } + + if (lm && setsockopt(sk, SOL_RFCOMM, RFCOMM_LM, &lm, sizeof(lm)) < 0) { + LOGE("Can't set RFCOMM link mode"); + close(sk); + return -1; + } + + laddr.rc_family = AF_BLUETOOTH; + bacpy(&laddr.rc_bdaddr, BDADDR_ANY); + laddr.rc_channel = channel; + + if (bind(sk, (struct sockaddr *)&laddr, sizeof(laddr)) < 0) { + LOGE("Can't bind RFCOMM socket"); + close(sk); + return -1; + } + + listen(sk, 10); + return sk; +} +#endif /* HAVE_BLUETOOTH */ + +/* + private native void tearDownListeningSocketsNative(); +*/ +static void tearDownListeningSocketsNative(JNIEnv *env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + + if (nat->hf_ag_rfcomm_sock > 0) { + if (close(nat->hf_ag_rfcomm_sock) < 0) { + LOGE("Could not close HF server socket: %s (%d)\n", + strerror(errno), errno); + } + nat->hf_ag_rfcomm_sock = -1; + } + if (nat->hs_ag_rfcomm_sock > 0) { + if (close(nat->hs_ag_rfcomm_sock) < 0) { + LOGE("Could not close HS server socket: %s (%d)\n", + strerror(errno), errno); + } + nat->hs_ag_rfcomm_sock = -1; + } +#endif /* HAVE_BLUETOOTH */ +} + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + + {"classInitNative", "()V", (void*)classInitNative}, + {"initializeNativeDataNative", "()V", (void *)initializeNativeDataNative}, + {"cleanupNativeDataNative", "()V", (void *)cleanupNativeDataNative}, + + {"setUpListeningSocketsNative", "()Z", (void *)setUpListeningSocketsNative}, + {"tearDownListeningSocketsNative", "()V", (void *)tearDownListeningSocketsNative}, + {"waitForHandsfreeConnectNative", "(I)Z", (void *)waitForHandsfreeConnectNative}, +}; + +int register_android_bluetooth_BluetoothAudioGateway(JNIEnv *env) { + return AndroidRuntime::registerNativeMethods(env, + "android/bluetooth/BluetoothAudioGateway", sMethods, + NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/android_bluetooth_Database.cpp b/core/jni/android_bluetooth_Database.cpp new file mode 100644 index 0000000..136c9a3 --- /dev/null +++ b/core/jni/android_bluetooth_Database.cpp @@ -0,0 +1,183 @@ +/* + * Copyright (C) 2007 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. + */ + +#define DBUS_CLASS_NAME BLUEZ_DBUS_BASE_IFC ".Database" +#define LOG_TAG "bluetooth_Database.cpp" + +#include "android_bluetooth_common.h" +#include "android_runtime/AndroidRuntime.h" +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" + +#ifdef HAVE_BLUETOOTH +#include <dbus/dbus.h> +#endif + +namespace android { + +#ifdef HAVE_BLUETOOTH +static DBusConnection* conn = NULL; // Singleton thread-safe connection +#endif + +static void classInitNative(JNIEnv* env, jclass clazz) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + conn = NULL; +#endif +} + +static void initializeNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); + +#ifdef HAVE_BLUETOOTH + if (conn == NULL) { + DBusError err; + dbus_error_init(&err); + dbus_threads_init_default(); + conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + if (dbus_error_is_set(&err)) { + LOGE("Could not get onto the system bus!"); + dbus_error_free(&err); + } + } +#endif +} + +static void cleanupNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +} + +static jint addServiceRecordNative(JNIEnv *env, jobject object, + jbyteArray record) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + if (conn != NULL) { + jbyte* c_record = env->GetByteArrayElements(record, NULL); + DBusMessage *reply = dbus_func_args(env, + conn, + BLUEZ_DBUS_BASE_PATH, + DBUS_CLASS_NAME, + "AddServiceRecord", + DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, + &c_record, + env->GetArrayLength(record), + DBUS_TYPE_INVALID); + env->ReleaseByteArrayElements(record, c_record, JNI_ABORT); + return reply ? dbus_returns_uint32(env, reply) : -1; + } +#endif + return -1; +} + +static jint addServiceRecordFromXmlNative(JNIEnv *env, jobject object, + jstring record) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + if (conn != NULL) { + const char *c_record = env->GetStringUTFChars(record, NULL); + DBusMessage *reply = dbus_func_args(env, + conn, + BLUEZ_DBUS_BASE_PATH, + DBUS_CLASS_NAME, + "AddServiceRecordFromXML", + DBUS_TYPE_STRING, &c_record, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(record, c_record); + return reply ? dbus_returns_uint32(env, reply) : -1; + } +#endif + return -1; +} + +static void updateServiceRecordNative(JNIEnv *env, jobject object, + jint handle, + jbyteArray record) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + if (conn != NULL) { + jbyte* c_record = env->GetByteArrayElements(record, NULL); + DBusMessage *reply = dbus_func_args(env, + conn, + BLUEZ_DBUS_BASE_PATH, + DBUS_CLASS_NAME, + "UpdateServiceRecord", + DBUS_TYPE_UINT32, &handle, + DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, + &c_record, + env->GetArrayLength(record), + DBUS_TYPE_INVALID); + env->ReleaseByteArrayElements(record, c_record, JNI_ABORT); + } +#endif +} + +static void updateServiceRecordFromXmlNative(JNIEnv *env, jobject object, + jint handle, + jstring record) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + if (conn != NULL) { + const char *c_record = env->GetStringUTFChars(record, NULL); + DBusMessage *reply = dbus_func_args(env, + conn, + BLUEZ_DBUS_BASE_PATH, + DBUS_CLASS_NAME, + "UpdateServiceRecordFromXML", + DBUS_TYPE_UINT32, &handle, + DBUS_TYPE_STRING, &c_record, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(record, c_record); + } +#endif +} + +/* private static native void removeServiceRecordNative(int handle); */ +static void removeServiceRecordNative(JNIEnv *env, jobject object, + jint handle) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + if (conn != NULL) { + DBusMessage *reply = dbus_func_args(env, + conn, + BLUEZ_DBUS_BASE_PATH, + DBUS_CLASS_NAME, + "RemoveServiceRecord", + DBUS_TYPE_UINT32, &handle, + DBUS_TYPE_INVALID); + } +#endif +} + + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + {"classInitNative", "()V", (void*)classInitNative}, + {"initializeNativeDataNative", "()V", (void *)initializeNativeDataNative}, + {"cleanupNativeDataNative", "()V", (void *)cleanupNativeDataNative}, + {"addServiceRecordNative", "([B)I", (void*)addServiceRecordNative}, + {"addServiceRecordFromXmlNative", "(Ljava/lang/String;)I", (void*)addServiceRecordFromXmlNative}, + {"updateServiceRecordNative", "(I[B)V", (void*)updateServiceRecordNative}, + {"updateServiceRecordFromXmlNative", "(ILjava/lang/String;)V", (void*)updateServiceRecordFromXmlNative}, + {"removeServiceRecordNative", "(I)V", (void*)removeServiceRecordNative}, +}; + +int register_android_bluetooth_Database(JNIEnv *env) { + return AndroidRuntime::registerNativeMethods(env, + "android/bluetooth/Database", sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/android_bluetooth_HeadsetBase.cpp b/core/jni/android_bluetooth_HeadsetBase.cpp new file mode 100644 index 0000000..bb19e92 --- /dev/null +++ b/core/jni/android_bluetooth_HeadsetBase.cpp @@ -0,0 +1,548 @@ +/* +** Copyright 2006, 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. +*/ + +#define LOG_TAG "BT HSHFP" + +#include "android_bluetooth_common.h" +#include "android_runtime/AndroidRuntime.h" +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/socket.h> +#include <sys/uio.h> +#include <sys/poll.h> + +#ifdef HAVE_BLUETOOTH +#include <bluetooth/bluetooth.h> +#include <bluetooth/rfcomm.h> +#include <bluetooth/sco.h> +#endif + +namespace android { + +#ifdef HAVE_BLUETOOTH +static jfieldID field_mNativeData; +static jfieldID field_mAddress; +static jfieldID field_mRfcommChannel; +static jfieldID field_mTimeoutRemainingMs; + +typedef struct { + jstring address; + const char *c_address; + int rfcomm_channel; + int last_read_err; + int rfcomm_sock; + int rfcomm_connected; // -1 in progress, 0 not connected, 1 connected + int rfcomm_sock_flags; +} native_data_t; + +static inline native_data_t * get_native_data(JNIEnv *env, jobject object) { + return (native_data_t *)(env->GetIntField(object, field_mNativeData)); +} + +static const char CRLF[] = "\xd\xa"; +static const int CRLF_LEN = 2; + +static inline int write_error_check(int fd, const char* line, int len) { + int ret; + errno = 0; + ret = write(fd, line, len); + if (ret < 0) { + LOGE("%s: write() failed: %s (%d)", __FUNCTION__, strerror(errno), + errno); + return -1; + } + if (ret != len) { + LOGE("%s: write() only wrote %d of %d bytes", __FUNCTION__, ret, len); + return -1; + } + return 0; +} + +static int send_line(int fd, const char* line) { + int nw; + int len = strlen(line); + int llen = len + CRLF_LEN * 2 + 1; + char *buffer = (char *)calloc(llen, sizeof(char)); + + snprintf(buffer, llen, "%s%s%s", CRLF, line, CRLF); + + if (write_error_check(fd, buffer, llen - 1)) { + free(buffer); + return -1; + } + free(buffer); + return 0; +} + +static const char* get_line(int fd, char *buf, int len, int timeout_ms, + int *err) { + char *bufit=buf; + int fd_flags = fcntl(fd, F_GETFL, 0); + struct pollfd pfd; + +again: + *bufit = 0; + pfd.fd = fd; + pfd.events = POLLIN; + *err = errno = 0; + int ret = poll(&pfd, 1, timeout_ms); + if (ret < 0) { + LOGE("poll() error\n"); + *err = errno; + return NULL; + } + if (ret == 0) { + return NULL; + } + + if (pfd.revents & (POLLHUP | POLLERR | POLLNVAL)) { + LOGW("RFCOMM poll() returned success (%d), " + "but with an unexpected revents bitmask: %#x\n", ret, pfd.revents); + errno = EIO; + *err = errno; + return NULL; + } + + while ((int)(bufit - buf) < len) + { + errno = 0; + int rc = read(fd, bufit, 1); + + if (!rc) + break; + + if (rc < 0) { + if (errno == EBUSY) { + LOGI("read() error %s (%d): repeating read()...", + strerror(errno), errno); + goto again; + } + *err = errno; + LOGE("read() error %s (%d)", strerror(errno), errno); + return NULL; + } + + + if (*bufit=='\xd') { + break; + } + + if (*bufit=='\xa') + bufit = buf; + else + bufit++; + } + + *bufit = '\x0'; + LOG(LOG_INFO, "Bluetooth AT recv", buf); + + return buf; +} +#endif + +static void classInitNative(JNIEnv* env, jclass clazz) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + field_mNativeData = get_field(env, clazz, "mNativeData", "I"); + field_mAddress = get_field(env, clazz, "mAddress", "Ljava/lang/String;"); + field_mTimeoutRemainingMs = get_field(env, clazz, "mTimeoutRemainingMs", "I"); + field_mRfcommChannel = get_field(env, clazz, "mRfcommChannel", "I"); +#endif +} + +static void initializeNativeDataNative(JNIEnv* env, jobject object, + jint socketFd) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = (native_data_t *)calloc(1, sizeof(native_data_t)); + if (NULL == nat) { + LOGE("%s: out of memory!", __FUNCTION__); + return; + } + + env->SetIntField(object, field_mNativeData, (jint)nat); + nat->address = + (jstring)env->NewGlobalRef(env->GetObjectField(object, + field_mAddress)); + nat->c_address = env->GetStringUTFChars(nat->address, NULL); + nat->rfcomm_channel = env->GetIntField(object, field_mRfcommChannel); + nat->rfcomm_sock = socketFd; + nat->rfcomm_connected = socketFd >= 0; + if (nat->rfcomm_connected) + LOGI("%s: ALREADY CONNECTED!", __FUNCTION__); +#endif +} + +static void cleanupNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = + (native_data_t *)env->GetIntField(object, field_mNativeData); + env->ReleaseStringUTFChars(nat->address, nat->c_address); + env->DeleteGlobalRef(nat->address); + if (nat) + free(nat); +#endif +} + +static jboolean connectNative(JNIEnv *env, jobject obj) +{ + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + int lm; + struct sockaddr_rc addr; + native_data_t *nat = get_native_data(env, obj); + + nat->rfcomm_sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); + + if (nat->rfcomm_sock < 0) { + LOGE("%s: Could not create RFCOMM socket: %s\n", __FUNCTION__, + strerror(errno)); + return JNI_FALSE; + } + + if (debug_no_encrypt()) { + lm = RFCOMM_LM_AUTH; + } else { + lm = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT; + } + + if (lm && setsockopt(nat->rfcomm_sock, SOL_RFCOMM, RFCOMM_LM, &lm, + sizeof(lm)) < 0) { + LOGE("%s: Can't set RFCOMM link mode", __FUNCTION__); + close(nat->rfcomm_sock); + return JNI_FALSE; + } + + memset(&addr, 0, sizeof(struct sockaddr_rc)); + get_bdaddr(nat->c_address, &addr.rc_bdaddr); + addr.rc_channel = nat->rfcomm_channel; + addr.rc_family = AF_BLUETOOTH; + nat->rfcomm_connected = 0; + while (nat->rfcomm_connected == 0) { + if (connect(nat->rfcomm_sock, (struct sockaddr *)&addr, + sizeof(addr)) < 0) { + if (errno == EINTR) continue; + LOGE("%s: connect() failed: %s\n", __FUNCTION__, strerror(errno)); + close(nat->rfcomm_sock); + nat->rfcomm_sock = -1; + return JNI_FALSE; + } else { + nat->rfcomm_connected = 1; + } + } + + return JNI_TRUE; +#else + return JNI_FALSE; +#endif +} + +static jboolean connectAsyncNative(JNIEnv *env, jobject obj) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + struct sockaddr_rc addr; + native_data_t *nat = get_native_data(env, obj); + + if (nat->rfcomm_connected) { + LOGV("RFCOMM socket is already connected or connection is in progress."); + return JNI_TRUE; + } + + if (nat->rfcomm_sock < 0) { + int lm; + + nat->rfcomm_sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); + if (nat->rfcomm_sock < 0) { + LOGE("%s: Could not create RFCOMM socket: %s\n", __FUNCTION__, + strerror(errno)); + return JNI_FALSE; + } + + if (debug_no_encrypt()) { + lm = RFCOMM_LM_AUTH; + } else { + lm = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT; + } + + if (lm && setsockopt(nat->rfcomm_sock, SOL_RFCOMM, RFCOMM_LM, &lm, + sizeof(lm)) < 0) { + LOGE("%s: Can't set RFCOMM link mode", __FUNCTION__); + close(nat->rfcomm_sock); + return JNI_FALSE; + } + LOGI("Created RFCOMM socket fd %d.", nat->rfcomm_sock); + } + + memset(&addr, 0, sizeof(struct sockaddr_rc)); + get_bdaddr(nat->c_address, &addr.rc_bdaddr); + addr.rc_channel = nat->rfcomm_channel; + addr.rc_family = AF_BLUETOOTH; + if (nat->rfcomm_sock_flags >= 0) { + nat->rfcomm_sock_flags = fcntl(nat->rfcomm_sock, F_GETFL, 0); + if (fcntl(nat->rfcomm_sock, + F_SETFL, nat->rfcomm_sock_flags | O_NONBLOCK) >= 0) { + int rc; + nat->rfcomm_connected = 0; + errno = 0; + rc = connect(nat->rfcomm_sock, + (struct sockaddr *)&addr, + sizeof(addr)); + + if (rc >= 0) { + nat->rfcomm_connected = 1; + LOGI("async connect successful"); + return JNI_TRUE; + } + else if (rc < 0) { + if (errno == EINPROGRESS || errno == EAGAIN) + { + LOGI("async connect is in progress (%s)", + strerror(errno)); + nat->rfcomm_connected = -1; + return JNI_TRUE; + } + else + { + LOGE("async connect error: %s (%d)", strerror(errno), errno); + close(nat->rfcomm_sock); + nat->rfcomm_sock = -1; + return JNI_FALSE; + } + } + } // fcntl(nat->rfcomm_sock ...) + } // if (nat->rfcomm_sock_flags >= 0) +#endif + return JNI_FALSE; +} + +static jint waitForAsyncConnectNative(JNIEnv *env, jobject obj, + jint timeout_ms) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + struct sockaddr_rc addr; + native_data_t *nat = get_native_data(env, obj); + + env->SetIntField(obj, field_mTimeoutRemainingMs, timeout_ms); + + if (nat->rfcomm_connected > 0) { + LOGI("RFCOMM is already connected!"); + return 1; + } + + if (nat->rfcomm_sock >= 0 && nat->rfcomm_connected == 0) { + LOGI("Re-opening RFCOMM socket."); + close(nat->rfcomm_sock); + nat->rfcomm_sock = -1; + } + if (JNI_FALSE == connectAsyncNative(env, obj)) { + LOGI("Failed to re-open RFCOMM socket!"); + return -1; + } + + if (nat->rfcomm_sock >= 0) { + /* Do an asynchronous select() */ + int n; + fd_set rset, wset; + struct timeval to; + + FD_ZERO(&rset); + FD_ZERO(&wset); + FD_SET(nat->rfcomm_sock, &rset); + FD_SET(nat->rfcomm_sock, &wset); + if (timeout_ms >= 0) { + to.tv_sec = timeout_ms / 1000; + to.tv_usec = 1000 * (timeout_ms % 1000); + } + n = select(nat->rfcomm_sock + 1, + &rset, + &wset, + NULL, + (timeout_ms < 0 ? NULL : &to)); + + if (timeout_ms > 0) { + jint remaining = to.tv_sec*1000 + to.tv_usec/1000; + LOGV("Remaining time %ldms", (long)remaining); + env->SetIntField(obj, field_mTimeoutRemainingMs, + remaining); + } + + if (n <= 0) { + if (n < 0) { + LOGE("select() on RFCOMM socket: %s (%d)", + strerror(errno), + errno); + return -1; + } + return 0; + } + /* n must be equal to 1 and either rset or wset must have the + file descriptor set. */ + LOGV("select() returned %d.", n); + if (FD_ISSET(nat->rfcomm_sock, &rset) || + FD_ISSET(nat->rfcomm_sock, &wset)) + { + /* A trial async read() will tell us if everything is OK. */ + { + char ch; + errno = 0; + int nr = read(nat->rfcomm_sock, &ch, 1); + /* It should be that nr != 1 because we just opened a socket + and we haven't sent anything over it for the other side to + respond... but one can't be paranoid enough. + */ + if (nr >= 0 || errno != EAGAIN) { + LOGE("RFCOMM async connect() error: %s (%d), nr = %d\n", + strerror(errno), + errno, + nr); + /* Clear the rfcomm_connected flag to cause this function + to re-create the socket and re-attempt the connect() + the next time it is called. + */ + nat->rfcomm_connected = 0; + /* Restore the blocking properties of the socket. */ + fcntl(nat->rfcomm_sock, F_SETFL, nat->rfcomm_sock_flags); + close(nat->rfcomm_sock); + nat->rfcomm_sock = -1; + return -1; + } + } + /* Restore the blocking properties of the socket. */ + fcntl(nat->rfcomm_sock, F_SETFL, nat->rfcomm_sock_flags); + LOGI("Successful RFCOMM socket connect."); + nat->rfcomm_connected = 1; + return 1; + } + } + else LOGE("RFCOMM socket file descriptor %d is bad!", + nat->rfcomm_sock); +#endif + return -1; +} + +static void disconnectNative(JNIEnv *env, jobject obj) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, obj); + if (nat->rfcomm_sock >= 0) { + close(nat->rfcomm_sock); + nat->rfcomm_sock = -1; + nat->rfcomm_connected = 0; + } +#endif +} + +static void pretty_log_urc(const char *urc) { + size_t i; + bool in_line_break = false; + char *buf = (char *)calloc(strlen(urc) + 1, sizeof(char)); + + strcpy(buf, urc); + for (i = 0; i < strlen(buf); i++) { + switch(buf[i]) { + case '\r': + case '\n': + in_line_break = true; + buf[i] = ' '; + break; + default: + if (in_line_break) { + in_line_break = false; + buf[i-1] = '\n'; + } + } + } + LOG(LOG_INFO, "Bluetooth AT sent", buf); + + free(buf); +} + +static jboolean sendURCNative(JNIEnv *env, jobject obj, jstring urc) { +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, obj); + if (nat->rfcomm_connected) { + const char *c_urc = env->GetStringUTFChars(urc, NULL); + jboolean ret = send_line(nat->rfcomm_sock, c_urc) == 0 ? JNI_TRUE : JNI_FALSE; + if (ret == JNI_TRUE) pretty_log_urc(c_urc); + env->ReleaseStringUTFChars(urc, c_urc); + return ret; + } +#endif + return JNI_FALSE; +} + +static jstring readNative(JNIEnv *env, jobject obj, jint timeout_ms) { +#ifdef HAVE_BLUETOOTH + { + native_data_t *nat = get_native_data(env, obj); + if (nat->rfcomm_connected) { + char buf[128]; + const char *ret = get_line(nat->rfcomm_sock, + buf, sizeof(buf), + timeout_ms, + &nat->last_read_err); + return ret ? env->NewStringUTF(ret) : NULL; + } + return NULL; + } +#else + return NULL; +#endif +} + +static jint getLastReadStatusNative(JNIEnv *env, jobject obj) { +#ifdef HAVE_BLUETOOTH + { + native_data_t *nat = get_native_data(env, obj); + if (nat->rfcomm_connected) + return (jint)nat->last_read_err; + return 0; + } +#else + return 0; +#endif +} + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + {"classInitNative", "()V", (void*)classInitNative}, + {"initializeNativeDataNative", "(I)V", (void *)initializeNativeDataNative}, + {"cleanupNativeDataNative", "()V", (void *)cleanupNativeDataNative}, + {"connectNative", "()Z", (void *)connectNative}, + {"connectAsyncNative", "()Z", (void *)connectAsyncNative}, + {"waitForAsyncConnectNative", "(I)I", (void *)waitForAsyncConnectNative}, + {"disconnectNative", "()V", (void *)disconnectNative}, + {"sendURCNative", "(Ljava/lang/String;)Z", (void *)sendURCNative}, + {"readNative", "(I)Ljava/lang/String;", (void *)readNative}, + {"getLastReadStatusNative", "()I", (void *)getLastReadStatusNative}, +}; + +int register_android_bluetooth_HeadsetBase(JNIEnv *env) { + return AndroidRuntime::registerNativeMethods(env, + "android/bluetooth/HeadsetBase", sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/android_bluetooth_RfcommSocket.cpp b/core/jni/android_bluetooth_RfcommSocket.cpp new file mode 100644 index 0000000..3ed35d9 --- /dev/null +++ b/core/jni/android_bluetooth_RfcommSocket.cpp @@ -0,0 +1,621 @@ +/* +** Copyright 2006, 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. +*/ + +#define LOG_TAG "bluetooth_RfcommSocket.cpp" + +#include "android_bluetooth_common.h" +#include "android_runtime/AndroidRuntime.h" +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> +#include <fcntl.h> +#include <sys/socket.h> +#include <sys/uio.h> +#include <sys/poll.h> + +#ifdef HAVE_BLUETOOTH +#include <bluetooth/bluetooth.h> +#include <bluetooth/rfcomm.h> +#include <bluetooth/sco.h> +#endif + +namespace android { + +#ifdef HAVE_BLUETOOTH +static jfieldID field_mNativeData; +static jfieldID field_mTimeoutRemainingMs; +static jfieldID field_mAcceptTimeoutRemainingMs; +static jfieldID field_mAddress; +static jfieldID field_mPort; + +typedef struct { + jstring address; + const char *c_address; + int rfcomm_channel; + int last_read_err; + int rfcomm_sock; + // < 0 -- in progress, + // 0 -- not connected + // > 0 connected + // 1 input is open + // 2 output is open + // 3 both input and output are open + int rfcomm_connected; + int rfcomm_sock_flags; +} native_data_t; + +static inline native_data_t * get_native_data(JNIEnv *env, jobject object) { + return (native_data_t *)(env->GetIntField(object, field_mNativeData)); +} + +static inline void init_socket_info( + JNIEnv *env, jobject object, + native_data_t *nat, + jstring address, + jint rfcomm_channel) { + nat->address = (jstring)env->NewGlobalRef(address); + nat->c_address = env->GetStringUTFChars(nat->address, NULL); + nat->rfcomm_channel = (int)rfcomm_channel; +} + +static inline void cleanup_socket_info(JNIEnv *env, native_data_t *nat) { + if (nat->c_address != NULL) { + env->ReleaseStringUTFChars(nat->address, nat->c_address); + env->DeleteGlobalRef(nat->address); + nat->c_address = NULL; + } +} +#endif + +static void classInitNative(JNIEnv* env, jclass clazz) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + field_mNativeData = get_field(env, clazz, "mNativeData", "I"); + field_mTimeoutRemainingMs = get_field(env, clazz, "mTimeoutRemainingMs", "I"); + field_mAcceptTimeoutRemainingMs = get_field(env, clazz, "mAcceptTimeoutRemainingMs", "I"); + field_mAddress = get_field(env, clazz, "mAddress", "Ljava/lang/String;"); + field_mPort = get_field(env, clazz, "mPort", "I"); +#endif +} + +static void initializeNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + + native_data_t *nat = (native_data_t *)calloc(1, sizeof(native_data_t)); + if (nat == NULL) { + LOGE("%s: out of memory!", __FUNCTION__); + return; + } + + env->SetIntField(object, field_mNativeData, (jint)nat); + nat->rfcomm_sock = -1; + nat->rfcomm_connected = 0; +#endif +} + +static void cleanupNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + if (nat) { + free(nat); + } +#endif +} + +static jobject createNative(JNIEnv *env, jobject obj) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + int lm; + native_data_t *nat = get_native_data(env, obj); + nat->rfcomm_sock = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM); + + if (nat->rfcomm_sock < 0) { + LOGE("%s: Could not create RFCOMM socket: %s\n", __FUNCTION__, + strerror(errno)); + return NULL; + } + + lm = RFCOMM_LM_AUTH | RFCOMM_LM_ENCRYPT; + + if (lm && setsockopt(nat->rfcomm_sock, SOL_RFCOMM, RFCOMM_LM, &lm, + sizeof(lm)) < 0) { + LOGE("%s: Can't set RFCOMM link mode", __FUNCTION__); + close(nat->rfcomm_sock); + return NULL; + } + + return jniCreateFileDescriptor(env, nat->rfcomm_sock); +#else + return NULL; +#endif +} + +static void destroyNative(JNIEnv *env, jobject obj) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, obj); + cleanup_socket_info(env, nat); + if (nat->rfcomm_sock >= 0) { + close(nat->rfcomm_sock); + nat->rfcomm_sock = -1; + } +#endif +} + + +static jboolean connectNative(JNIEnv *env, jobject obj, + jstring address, jint port) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, obj); + + if (nat->rfcomm_sock >= 0) { + if (nat->rfcomm_connected) { + LOGI("RFCOMM socket: %s.", + (nat->rfcomm_connected > 0) ? "already connected" : "connection is in progress"); + return JNI_TRUE; + } + + init_socket_info(env, obj, nat, address, port); + + struct sockaddr_rc addr; + memset(&addr, 0, sizeof(struct sockaddr_rc)); + get_bdaddr(nat->c_address, &addr.rc_bdaddr); + addr.rc_channel = nat->rfcomm_channel; + addr.rc_family = AF_BLUETOOTH; + nat->rfcomm_connected = 0; + + while (nat->rfcomm_connected == 0) { + if (connect(nat->rfcomm_sock, (struct sockaddr *)&addr, + sizeof(addr)) < 0) { + if (errno == EINTR) continue; + LOGE("connect error: %s (%d)\n", strerror(errno), errno); + break; + } else { + nat->rfcomm_connected = 3; // input and output + } + } + } else { + LOGE("%s: socket(RFCOMM) error: socket not created", __FUNCTION__); + } + + if (nat->rfcomm_connected > 0) { + env->SetIntField(obj, field_mPort, port); + return JNI_TRUE; + } +#endif + return JNI_FALSE; +} + +static jboolean connectAsyncNative(JNIEnv *env, jobject obj, + jstring address, jint port) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, obj); + + if (nat->rfcomm_sock < 0) { + LOGE("%s: socket(RFCOMM) error: socket not created", __FUNCTION__); + return JNI_FALSE; + } + + if (nat->rfcomm_connected) { + LOGI("RFCOMM socket: %s.", + (nat->rfcomm_connected > 0) ? + "already connected" : "connection is in progress"); + return JNI_TRUE; + } + + init_socket_info(env, obj, nat, address, port); + + struct sockaddr_rc addr; + memset(&addr, 0, sizeof(struct sockaddr_rc)); + get_bdaddr(nat->c_address, &addr.rc_bdaddr); + addr.rc_channel = nat->rfcomm_channel; + addr.rc_family = AF_BLUETOOTH; + + nat->rfcomm_sock_flags = fcntl(nat->rfcomm_sock, F_GETFL, 0); + if (fcntl(nat->rfcomm_sock, + F_SETFL, nat->rfcomm_sock_flags | O_NONBLOCK) >= 0) { + int rc; + nat->rfcomm_connected = 0; + errno = 0; + rc = connect(nat->rfcomm_sock, + (struct sockaddr *)&addr, + sizeof(addr)); + + if (rc >= 0) { + nat->rfcomm_connected = 3; + LOGI("RFCOMM async connect immediately successful"); + env->SetIntField(obj, field_mPort, port); + return JNI_TRUE; + } + else if (rc < 0) { + if (errno == EINPROGRESS || errno == EAGAIN) + { + LOGI("RFCOMM async connect is in progress (%s)", + strerror(errno)); + nat->rfcomm_connected = -1; + env->SetIntField(obj, field_mPort, port); + return JNI_TRUE; + } + else + { + LOGE("RFCOMM async connect error (%d): %s (%d)", + nat->rfcomm_sock, strerror(errno), errno); + return JNI_FALSE; + } + } + } // fcntl(nat->rfcomm_sock ...) +#endif + return JNI_FALSE; +} + +static jboolean interruptAsyncConnectNative(JNIEnv *env, jobject obj) { + //WRITEME + return JNI_TRUE; +} + +static jint waitForAsyncConnectNative(JNIEnv *env, jobject obj, + jint timeout_ms) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + struct sockaddr_rc addr; + native_data_t *nat = get_native_data(env, obj); + + env->SetIntField(obj, field_mTimeoutRemainingMs, timeout_ms); + + if (nat->rfcomm_sock < 0) { + LOGE("%s: socket(RFCOMM) error: socket not created", __FUNCTION__); + return -1; + } + + if (nat->rfcomm_connected > 0) { + LOGI("%s: RFCOMM is already connected!", __FUNCTION__); + return 1; + } + + /* Do an asynchronous select() */ + int n; + fd_set rset, wset; + struct timeval to; + + FD_ZERO(&rset); + FD_ZERO(&wset); + FD_SET(nat->rfcomm_sock, &rset); + FD_SET(nat->rfcomm_sock, &wset); + if (timeout_ms >= 0) { + to.tv_sec = timeout_ms / 1000; + to.tv_usec = 1000 * (timeout_ms % 1000); + } + n = select(nat->rfcomm_sock + 1, + &rset, + &wset, + NULL, + (timeout_ms < 0 ? NULL : &to)); + + if (timeout_ms > 0) { + jint remaining = to.tv_sec*1000 + to.tv_usec/1000; + LOGI("Remaining time %ldms", (long)remaining); + env->SetIntField(obj, field_mTimeoutRemainingMs, + remaining); + } + + if (n <= 0) { + if (n < 0) { + LOGE("select() on RFCOMM socket: %s (%d)", + strerror(errno), + errno); + return -1; + } + return 0; + } + /* n must be equal to 1 and either rset or wset must have the + file descriptor set. */ + LOGI("select() returned %d.", n); + if (FD_ISSET(nat->rfcomm_sock, &rset) || + FD_ISSET(nat->rfcomm_sock, &wset)) { + /* A trial async read() will tell us if everything is OK. */ + char ch; + errno = 0; + int nr = read(nat->rfcomm_sock, &ch, 1); + /* It should be that nr != 1 because we just opened a socket + and we haven't sent anything over it for the other side to + respond... but one can't be paranoid enough. + */ + if (nr >= 0 || errno != EAGAIN) { + LOGE("RFCOMM async connect() error: %s (%d), nr = %d\n", + strerror(errno), + errno, + nr); + /* Clear the rfcomm_connected flag to cause this function + to re-create the socket and re-attempt the connect() + the next time it is called. + */ + nat->rfcomm_connected = 0; + /* Restore the blocking properties of the socket. */ + fcntl(nat->rfcomm_sock, F_SETFL, nat->rfcomm_sock_flags); + return -1; + } + /* Restore the blocking properties of the socket. */ + fcntl(nat->rfcomm_sock, F_SETFL, nat->rfcomm_sock_flags); + LOGI("Successful RFCOMM socket connect."); + nat->rfcomm_connected = 3; // input and output + return 1; + } +#endif + return -1; +} + +static jboolean shutdownNative(JNIEnv *env, jobject obj, + jboolean shutdownInput) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + /* NOTE: If you change the bcode to modify nat, make sure you + add synchronize(this) to the method calling this native + method. + */ + native_data_t *nat = get_native_data(env, obj); + if (nat->rfcomm_sock < 0) { + LOGE("socket(RFCOMM) error: socket not created"); + return JNI_FALSE; + } + int rc = shutdown(nat->rfcomm_sock, + shutdownInput ? SHUT_RD : SHUT_WR); + if (!rc) { + nat->rfcomm_connected &= + shutdownInput ? ~1 : ~2; + return JNI_TRUE; + } +#endif + return JNI_FALSE; +} + +static jint isConnectedNative(JNIEnv *env, jobject obj) { + LOGI(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + const native_data_t *nat = get_native_data(env, obj); + return nat->rfcomm_connected; +#endif + return 0; +} + +//@@@@@@@@@ bind to device??? +static jboolean bindNative(JNIEnv *env, jobject obj, jstring device, + jint port) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + + /* NOTE: If you change the code to modify nat, make sure you + add synchronize(this) to the method calling this native + method. + */ + const native_data_t *nat = get_native_data(env, obj); + if (nat->rfcomm_sock < 0) { + LOGE("socket(RFCOMM) error: socket not created"); + return JNI_FALSE; + } + + struct sockaddr_rc laddr; + int lm; + + lm = 0; +/* + lm |= RFCOMM_LM_MASTER; + lm |= RFCOMM_LM_AUTH; + lm |= RFCOMM_LM_ENCRYPT; + lm |= RFCOMM_LM_SECURE; +*/ + + if (lm && setsockopt(nat->rfcomm_sock, SOL_RFCOMM, RFCOMM_LM, &lm, sizeof(lm)) < 0) { + LOGE("Can't set RFCOMM link mode"); + return JNI_FALSE; + } + + laddr.rc_family = AF_BLUETOOTH; + bacpy(&laddr.rc_bdaddr, BDADDR_ANY); + laddr.rc_channel = port; + + if (bind(nat->rfcomm_sock, (struct sockaddr *)&laddr, sizeof(laddr)) < 0) { + LOGE("Can't bind RFCOMM socket"); + return JNI_FALSE; + } + + env->SetIntField(obj, field_mPort, port); + + return JNI_TRUE; +#endif + return JNI_FALSE; +} + +static jboolean listenNative(JNIEnv *env, jobject obj, jint backlog) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + /* NOTE: If you change the code to modify nat, make sure you + add synchronize(this) to the method calling this native + method. + */ + const native_data_t *nat = get_native_data(env, obj); + if (nat->rfcomm_sock < 0) { + LOGE("socket(RFCOMM) error: socket not created"); + return JNI_FALSE; + } + return listen(nat->rfcomm_sock, backlog) < 0 ? JNI_FALSE : JNI_TRUE; +#else + return JNI_FALSE; +#endif +} + +static int set_nb(int sk, bool nb) { + int flags = fcntl(sk, F_GETFL); + if (flags < 0) { + LOGE("Can't get socket flags with fcntl(): %s (%d)", + strerror(errno), errno); + close(sk); + return -1; + } + flags &= ~O_NONBLOCK; + if (nb) flags |= O_NONBLOCK; + int status = fcntl(sk, F_SETFL, flags); + if (status < 0) { + LOGE("Can't set socket to nonblocking mode with fcntl(): %s (%d)", + strerror(errno), errno); + close(sk); + return -1; + } + return 0; +} + +// Note: the code should check at a higher level to see whether +// listen() has been called. +#ifdef HAVE_BLUETOOTH +static int do_accept(JNIEnv* env, jobject object, int sock, + jobject newsock, + jfieldID out_address, + bool must_succeed) { + + if (must_succeed && set_nb(sock, true) < 0) + return -1; + + struct sockaddr_rc raddr; + int alen = sizeof(raddr); + int nsk = accept(sock, (struct sockaddr *) &raddr, &alen); + if (nsk < 0) { + LOGE("Error on accept from socket fd %d: %s (%d).", + sock, + strerror(errno), + errno); + if (must_succeed) set_nb(sock, false); + return -1; + } + + char addr[BTADDR_SIZE]; + get_bdaddr_as_string(&raddr.rc_bdaddr, addr); + env->SetObjectField(newsock, out_address, env->NewStringUTF(addr)); + + LOGI("Successful accept() on AG socket %d: new socket %d, address %s, RFCOMM channel %d", + sock, + nsk, + addr, + raddr.rc_channel); + if (must_succeed) set_nb(sock, false); + return nsk; +} +#endif /*HAVE_BLUETOOTH*/ + +static jobject acceptNative(JNIEnv *env, jobject obj, + jobject newsock, jint timeoutMs) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, obj); + if (nat->rfcomm_sock < 0) { + LOGE("socket(RFCOMM) error: socket not created"); + return JNI_FALSE; + } + + if (newsock == NULL) { + LOGE("%s: newsock = NULL\n", __FUNCTION__); + return JNI_FALSE; + } + + int nsk = -1; + if (timeoutMs < 0) { + /* block until accept() succeeds */ + nsk = do_accept(env, obj, nat->rfcomm_sock, + newsock, field_mAddress, false); + if (nsk < 0) { + return NULL; + } + } + else { + /* wait with a timeout */ + + struct pollfd fds; + fds.fd = nat->rfcomm_sock; + fds.events = POLLIN | POLLPRI | POLLOUT | POLLERR; + + env->SetIntField(obj, field_mAcceptTimeoutRemainingMs, 0); + int n = poll(&fds, 1, timeoutMs); + if (n <= 0) { + if (n < 0) { + LOGE("listening poll() on RFCOMM socket: %s (%d)", + strerror(errno), + errno); + env->SetIntField(obj, field_mAcceptTimeoutRemainingMs, timeoutMs); + } + else { + LOGI("listening poll() on RFCOMM socket timed out"); + } + return NULL; + } + + LOGI("listening poll() on RFCOMM socket returned %d", n); + if (fds.fd == nat->rfcomm_sock) { + if (fds.revents & (POLLIN | POLLPRI | POLLOUT)) { + LOGI("Accepting connection.\n"); + nsk = do_accept(env, obj, nat->rfcomm_sock, + newsock, field_mAddress, true); + if (nsk < 0) { + return NULL; + } + } + } + } + + LOGI("Connection accepted, new socket fd = %d.", nsk); + native_data_t *newnat = get_native_data(env, newsock); + newnat->rfcomm_sock = nsk; + newnat->rfcomm_connected = 3; + return jniCreateFileDescriptor(env, nsk); +#else + return NULL; +#endif +} + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + {"classInitNative", "()V", (void*)classInitNative}, + {"initializeNativeDataNative", "()V", (void *)initializeNativeDataNative}, + {"cleanupNativeDataNative", "()V", (void *)cleanupNativeDataNative}, + + {"createNative", "()Ljava/io/FileDescriptor;", (void *)createNative}, + {"destroyNative", "()V", (void *)destroyNative}, + {"connectNative", "(Ljava/lang/String;I)Z", (void *)connectNative}, + {"connectAsyncNative", "(Ljava/lang/String;I)Z", (void *)connectAsyncNative}, + {"interruptAsyncConnectNative", "()Z", (void *)interruptAsyncConnectNative}, + {"waitForAsyncConnectNative", "(I)I", (void *)waitForAsyncConnectNative}, + {"shutdownNative", "(Z)Z", (void *)shutdownNative}, + {"isConnectedNative", "()I", (void *)isConnectedNative}, + + {"bindNative", "(Ljava/lang/String;I)Z", (void*)bindNative}, + {"listenNative", "(I)Z", (void*)listenNative}, + {"acceptNative", "(Landroid/bluetooth/RfcommSocket;I)Ljava/io/FileDescriptor;", (void*)acceptNative}, +}; + +int register_android_bluetooth_RfcommSocket(JNIEnv *env) { + return AndroidRuntime::registerNativeMethods(env, + "android/bluetooth/RfcommSocket", sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/android_bluetooth_ScoSocket.cpp b/core/jni/android_bluetooth_ScoSocket.cpp new file mode 100644 index 0000000..3afe5f5 --- /dev/null +++ b/core/jni/android_bluetooth_ScoSocket.cpp @@ -0,0 +1,506 @@ +/* +** Copyright 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. +*/ + +#define LOG_TAG "bluetooth_ScoSocket.cpp" + +#include "android_bluetooth_common.h" +#include "android_runtime/AndroidRuntime.h" +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> +#include <pthread.h> +#include <sys/socket.h> +#include <sys/types.h> +#include <sys/uio.h> +#include <sys/poll.h> + +#ifdef HAVE_BLUETOOTH +#include <bluetooth/bluetooth.h> +#include <bluetooth/sco.h> +#endif + +/* Ideally, blocking I/O on a SCO socket would return when another thread + * calls close(). However it does not right now, in fact close() on a SCO + * socket has strange behavior (returns a bogus value) when other threads + * are performing blocking I/O on that socket. So, to workaround, we always + * call close() from the same thread that does blocking I/O. This requires the + * use of a socketpair to signal the blocking I/O to abort. + * + * Unfortunately I don't know a way to abort connect() yet, but at least this + * times out after the BT page timeout (10 seconds currently), so the thread + * will die eventually. The fact that the thread can outlive + * the Java object forces us to use a mutex in destoryNative(). + * + * The JNI API is entirely async. + * + * Also note this class deals only with SCO connections, not with data + * transmission. + */ +namespace android { +#ifdef HAVE_BLUETOOTH + +static JavaVM *jvm; +static jfieldID field_mNativeData; +static jmethodID method_onAccepted; +static jmethodID method_onConnected; +static jmethodID method_onClosed; + +struct thread_data_t; +static void *work_thread(void *arg); +static int connect_work(const char *address); +static int accept_work(int signal_sk); +static void wait_for_close(int sk, int signal_sk); +static void closeNative(JNIEnv *env, jobject object); + +/* shared native data - protected by mutex */ +typedef struct { + pthread_mutex_t mutex; + int signal_sk; // socket to signal blocked I/O to unblock + jobject object; // JNI global ref to the Java object + thread_data_t *thread_data; // pointer to thread local data + // max 1 thread per sco socket +} native_data_t; + +/* thread local data */ +struct thread_data_t { + native_data_t *nat; + bool is_accept; // accept (listening) or connect (outgoing) thread + int signal_sk; // socket for thread to listen for unblock signal + char address[BTADDR_SIZE]; // BT addres as string +}; + +static inline native_data_t * get_native_data(JNIEnv *env, jobject object) { + return (native_data_t *)(env->GetIntField(object, field_mNativeData)); +} +#endif + +static void classInitNative(JNIEnv* env, jclass clazz) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + if (env->GetJavaVM(&jvm) < 0) { + LOGE("Could not get handle to the VM"); + } + field_mNativeData = get_field(env, clazz, "mNativeData", "I"); + method_onAccepted = env->GetMethodID(clazz, "onAccepted", "(I)V"); + method_onConnected = env->GetMethodID(clazz, "onConnected", "(I)V"); + method_onClosed = env->GetMethodID(clazz, "onClosed", "()V"); +#endif +} + +/* Returns false if a serious error occured */ +static jboolean initNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + + native_data_t *nat = (native_data_t *) calloc(1, sizeof(native_data_t)); + if (nat == NULL) { + LOGE("%s: out of memory!", __FUNCTION__); + return JNI_FALSE; + } + + pthread_mutex_init(&nat->mutex, NULL); + env->SetIntField(object, field_mNativeData, (jint)nat); + nat->signal_sk = -1; + nat->object = NULL; + nat->thread_data = NULL; + +#endif + return JNI_TRUE; +} + +static void destroyNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + + closeNative(env, object); + + pthread_mutex_lock(&nat->mutex); + if (nat->thread_data != NULL) { + nat->thread_data->nat = NULL; + } + pthread_mutex_unlock(&nat->mutex); + pthread_mutex_destroy(&nat->mutex); + + free(nat); +#endif +} + +static jboolean acceptNative(JNIEnv *env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + int signal_sks[2]; + pthread_t thread; + struct thread_data_t *data = NULL; + + pthread_mutex_lock(&nat->mutex); + if (nat->signal_sk != -1) { + pthread_mutex_unlock(&nat->mutex); + return JNI_FALSE; + } + + // setup socketpair to pass messages between threads + if (socketpair(AF_UNIX, SOCK_STREAM, 0, signal_sks) < 0) { + LOGE("%s: socketpair() failed: %s", __FUNCTION__, strerror(errno)); + pthread_mutex_unlock(&nat->mutex); + return JNI_FALSE; + } + nat->signal_sk = signal_sks[0]; + nat->object = env->NewGlobalRef(object); + + data = (thread_data_t *)calloc(1, sizeof(thread_data_t)); + if (data == NULL) { + LOGE("%s: out of memory", __FUNCTION__); + pthread_mutex_unlock(&nat->mutex); + return JNI_FALSE; + } + nat->thread_data = data; + pthread_mutex_unlock(&nat->mutex); + + data->signal_sk = signal_sks[1]; + data->nat = nat; + data->is_accept = true; + + if (pthread_create(&thread, NULL, &work_thread, (void *)data) < 0) { + LOGE("%s: pthread_create() failed: %s", __FUNCTION__, strerror(errno)); + return JNI_FALSE; + } + return JNI_TRUE; + +#endif + return JNI_FALSE; +} + +static jboolean connectNative(JNIEnv *env, jobject object, jstring address) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + int signal_sks[2]; + pthread_t thread; + struct thread_data_t *data; + const char *c_address; + + pthread_mutex_lock(&nat->mutex); + if (nat->signal_sk != -1) { + pthread_mutex_unlock(&nat->mutex); + return JNI_FALSE; + } + + // setup socketpair to pass messages between threads + if (socketpair(AF_UNIX, SOCK_STREAM, 0, signal_sks) < 0) { + LOGE("%s: socketpair() failed: %s\n", __FUNCTION__, strerror(errno)); + pthread_mutex_unlock(&nat->mutex); + return JNI_FALSE; + } + nat->signal_sk = signal_sks[0]; + nat->object = env->NewGlobalRef(object); + + data = (thread_data_t *)calloc(1, sizeof(thread_data_t)); + if (data == NULL) { + LOGE("%s: out of memory", __FUNCTION__); + pthread_mutex_unlock(&nat->mutex); + return JNI_FALSE; + } + pthread_mutex_unlock(&nat->mutex); + + data->signal_sk = signal_sks[1]; + data->nat = nat; + c_address = env->GetStringUTFChars(address, NULL); + strlcpy(data->address, c_address, BTADDR_SIZE); + env->ReleaseStringUTFChars(address, c_address); + data->is_accept = false; + + if (pthread_create(&thread, NULL, &work_thread, (void *)data) < 0) { + LOGE("%s: pthread_create() failed: %s", __FUNCTION__, strerror(errno)); + return JNI_FALSE; + } + return JNI_TRUE; + +#endif + return JNI_FALSE; +} + +static void closeNative(JNIEnv *env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + int signal_sk; + + pthread_mutex_lock(&nat->mutex); + signal_sk = nat->signal_sk; + nat->signal_sk = -1; + env->DeleteGlobalRef(nat->object); + nat->object = NULL; + pthread_mutex_unlock(&nat->mutex); + + if (signal_sk >= 0) { + LOGV("%s: signal_sk = %d", __FUNCTION__, signal_sk); + unsigned char dummy; + write(signal_sk, &dummy, sizeof(dummy)); + close(signal_sk); + } +#endif +} + +#ifdef HAVE_BLUETOOTH +/* thread entry point */ +static void *work_thread(void *arg) { + JNIEnv* env; + thread_data_t *data = (thread_data_t *)arg; + int sk; + + LOGV(__FUNCTION__); + if (jvm->AttachCurrentThread(&env, NULL) != JNI_OK) { + LOGE("%s: AttachCurrentThread() failed", __FUNCTION__); + return NULL; + } + + /* connect the SCO socket */ + if (data->is_accept) { + LOGV("SCO OBJECT %p ACCEPT #####", data->nat->object); + sk = accept_work(data->signal_sk); + LOGV("SCO OBJECT %p END ACCEPT *****", data->nat->object); + } else { + sk = connect_work(data->address); + } + + /* callback with connection result */ + if (data->nat == NULL) { + LOGV("%s: object destroyed!", __FUNCTION__); + goto done; + } + pthread_mutex_lock(&data->nat->mutex); + if (data->nat->object == NULL) { + pthread_mutex_unlock(&data->nat->mutex); + LOGV("%s: callback cancelled", __FUNCTION__); + goto done; + } + if (data->is_accept) { + env->CallVoidMethod(data->nat->object, method_onAccepted, sk); + } else { + env->CallVoidMethod(data->nat->object, method_onConnected, sk); + } + pthread_mutex_unlock(&data->nat->mutex); + + if (sk < 0) { + goto done; + } + + LOGV("SCO OBJECT %p %d CONNECTED +++ (%s)", data->nat->object, sk, + data->is_accept ? "in" : "out"); + + /* wait for the socket to close */ + LOGV("wait_for_close()..."); + wait_for_close(sk, data->signal_sk); + LOGV("wait_for_close() returned"); + + /* callback with close result */ + if (data->nat == NULL) { + LOGV("%s: object destroyed!", __FUNCTION__); + goto done; + } + pthread_mutex_lock(&data->nat->mutex); + if (data->nat->object == NULL) { + LOGV("%s: callback cancelled", __FUNCTION__); + } else { + env->CallVoidMethod(data->nat->object, method_onClosed); + } + pthread_mutex_unlock(&data->nat->mutex); + +done: + if (sk >= 0) { + close(sk); + LOGV("SCO OBJECT %p %d CLOSED --- (%s)", data->nat->object, sk, data->is_accept ? "in" : "out"); + } + if (data->signal_sk >= 0) { + close(data->signal_sk); + } + LOGV("SCO socket closed"); + + if (data->nat != NULL) { + pthread_mutex_lock(&data->nat->mutex); + env->DeleteGlobalRef(data->nat->object); + data->nat->object = NULL; + data->nat->thread_data = NULL; + pthread_mutex_unlock(&data->nat->mutex); + } + + free(data); + if (jvm->DetachCurrentThread() != JNI_OK) { + LOGE("%s: DetachCurrentThread() failed", __FUNCTION__); + } + + LOGV("work_thread() done"); + return NULL; +} + +static int accept_work(int signal_sk) { + LOGV(__FUNCTION__); + int sk; + int nsk; + int addr_sz; + int max_fd; + fd_set fds; + struct sockaddr_sco addr; + + sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO); + if (sk < 0) { + LOGE("%s socket() failed: %s", __FUNCTION__, strerror(errno)); + return -1; + } + + memset(&addr, 0, sizeof(addr)); + addr.sco_family = AF_BLUETOOTH; + memcpy(&addr.sco_bdaddr, BDADDR_ANY, sizeof(bdaddr_t)); + if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + LOGE("%s bind() failed: %s", __FUNCTION__, strerror(errno)); + goto error; + } + + if (listen(sk, 1)) { + LOGE("%s: listen() failed: %s", __FUNCTION__, strerror(errno)); + goto error; + } + + memset(&addr, 0, sizeof(addr)); + addr_sz = sizeof(addr); + + FD_ZERO(&fds); + FD_SET(sk, &fds); + FD_SET(signal_sk, &fds); + + max_fd = (sk > signal_sk) ? sk : signal_sk; + LOGI("Listening SCO socket..."); + while (select(max_fd + 1, &fds, NULL, NULL, NULL) < 0) { + if (errno != EINTR) { + LOGE("%s: select() failed: %s", __FUNCTION__, strerror(errno)); + goto error; + } + LOGV("%s: select() EINTR, retrying", __FUNCTION__); + } + LOGV("select() returned"); + if (FD_ISSET(signal_sk, &fds)) { + // signal to cancel listening + LOGV("cancelled listening socket, closing"); + goto error; + } + if (!FD_ISSET(sk, &fds)) { + LOGE("error: select() returned >= 0 with no fds set"); + goto error; + } + + nsk = accept(sk, (struct sockaddr *)&addr, &addr_sz); + if (nsk < 0) { + LOGE("%s: accept() failed: %s", __FUNCTION__, strerror(errno)); + goto error; + } + LOGI("Connected SCO socket (incoming)"); + close(sk); // The listening socket + + return nsk; + +error: + close(sk); + + return -1; +} + +static int connect_work(const char *address) { + LOGV(__FUNCTION__); + struct sockaddr_sco addr; + int sk = -1; + + sk = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO); + if (sk < 0) { + LOGE("%s: socket() failed: %s", __FUNCTION__, strerror(errno)); + return -1; + } + + /* Bind to local address */ + memset(&addr, 0, sizeof(addr)); + addr.sco_family = AF_BLUETOOTH; + memcpy(&addr.sco_bdaddr, BDADDR_ANY, sizeof(bdaddr_t)); + if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) { + LOGE("%s: bind() failed: %s", __FUNCTION__, strerror(errno)); + goto error; + } + + memset(&addr, 0, sizeof(addr)); + addr.sco_family = AF_BLUETOOTH; + get_bdaddr(address, &addr.sco_bdaddr); + LOGI("Connecting to socket"); + while (connect(sk, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + if (errno != EINTR) { + LOGE("%s: connect() failed: %s", __FUNCTION__, strerror(errno)); + goto error; + } + LOGV("%s: connect() EINTR, retrying", __FUNCTION__); + } + LOGI("SCO socket connected (outgoing)"); + + return sk; + +error: + if (sk >= 0) close(sk); + return -1; +} + +static void wait_for_close(int sk, int signal_sk) { + LOGV(__FUNCTION__); + pollfd p[2]; + + memset(p, 0, 2 * sizeof(pollfd)); + p[0].fd = sk; + p[1].fd = signal_sk; + p[1].events = POLLIN | POLLPRI; + + LOGV("poll..."); + + while (poll(p, 2, -1) < 0) { // blocks + if (errno != EINTR) { + LOGE("%s: poll() failed: %s", __FUNCTION__, strerror(errno)); + break; + } + LOGV("%s: poll() EINTR, retrying", __FUNCTION__); + } + + LOGV("poll() returned"); +} +#endif + +static JNINativeMethod sMethods[] = { + {"classInitNative", "()V", (void*)classInitNative}, + {"initNative", "()V", (void *)initNative}, + {"destroyNative", "()V", (void *)destroyNative}, + {"connectNative", "(Ljava/lang/String;)Z", (void *)connectNative}, + {"acceptNative", "()Z", (void *)acceptNative}, + {"closeNative", "()V", (void *)closeNative}, +}; + +int register_android_bluetooth_ScoSocket(JNIEnv *env) { + return AndroidRuntime::registerNativeMethods(env, + "android/bluetooth/ScoSocket", sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/android_bluetooth_common.cpp b/core/jni/android_bluetooth_common.cpp new file mode 100644 index 0000000..c81af1ce --- /dev/null +++ b/core/jni/android_bluetooth_common.cpp @@ -0,0 +1,423 @@ +/* +** Copyright 2006, 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. +*/ + +#define LOG_TAG "bluetooth_common.cpp" + +#include "android_bluetooth_common.h" +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> +#include <cutils/properties.h> + +#ifdef HAVE_BLUETOOTH +#include <dbus/dbus.h> +#endif + +namespace android { + +#ifdef HAVE_BLUETOOTH +jfieldID get_field(JNIEnv *env, jclass clazz, const char *member, + const char *mtype) { + jfieldID field = env->GetFieldID(clazz, member, mtype); + if (field == NULL) { + LOGE("Can't find member %s", member); + } + return field; +} + +typedef struct { + void (*user_cb)(DBusMessage *, void *); + void *user; + JNIEnv *env; +} dbus_async_call_t; + +void dbus_func_args_async_callback(DBusPendingCall *call, void *data) { + + dbus_async_call_t *req = (dbus_async_call_t *)data; + DBusMessage *msg; + + /* This is guaranteed to be non-NULL, because this function is called only + when once the remote method invokation returns. */ + msg = dbus_pending_call_steal_reply(call); + + if (msg) { + if (req->user_cb) { + // The user may not deref the message object. + req->user_cb(msg, req->user); + } + dbus_message_unref(msg); + } + + //dbus_message_unref(req->method); + dbus_pending_call_cancel(call); + dbus_pending_call_unref(call); + free(req); +} + +dbus_bool_t dbus_func_args_async_valist(JNIEnv *env, + DBusConnection *conn, + int timeout_ms, + void (*user_cb)(DBusMessage *, void *), + void *user, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + va_list args) { + DBusMessage *msg = NULL; + const char *name; + dbus_async_call_t *pending; + dbus_bool_t reply = FALSE; + + /* Compose the command */ + msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC, path, ifc, func); + + if (msg == NULL) { + LOGE("Could not allocate D-Bus message object!"); + goto done; + } + + /* append arguments */ + if (!dbus_message_append_args_valist(msg, first_arg_type, args)) { + LOGE("Could not append argument to method call!"); + goto done; + } + + /* Make the call. */ + pending = (dbus_async_call_t *)malloc(sizeof(dbus_async_call_t)); + if (pending) { + DBusPendingCall *call; + + pending->env = env; + pending->user_cb = user_cb; + pending->user = user; + //pending->method = msg; + + reply = dbus_connection_send_with_reply(conn, msg, + &call, + timeout_ms); + if (reply == TRUE) { + dbus_pending_call_set_notify(call, + dbus_func_args_async_callback, + pending, + NULL); + } + } + +done: + if (msg) dbus_message_unref(msg); + return reply; +} + +dbus_bool_t dbus_func_args_async(JNIEnv *env, + DBusConnection *conn, + int timeout_ms, + void (*reply)(DBusMessage *, void *), + void *user, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + ...) { + dbus_bool_t ret; + va_list lst; + va_start(lst, first_arg_type); + ret = dbus_func_args_async_valist(env, conn, + timeout_ms, + reply, user, + path, ifc, func, + first_arg_type, lst); + va_end(lst); + return ret; +} + +// If err is NULL, then any errors will be LOGE'd, and free'd and the reply +// will be NULL. +// If err is not NULL, then it is assumed that dbus_error_init was already +// called, and error's will be returned to the caller without logging. The +// return value is NULL iff an error was set. The client must free the error if +// set. +DBusMessage * dbus_func_args_timeout_valist(JNIEnv *env, + DBusConnection *conn, + int timeout_ms, + DBusError *err, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + va_list args) { + + DBusMessage *msg = NULL, *reply = NULL; + const char *name; + bool return_error = (err != NULL); + + if (!return_error) { + err = (DBusError*)malloc(sizeof(DBusError)); + dbus_error_init(err); + } + + /* Compose the command */ + msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC, path, ifc, func); + + if (msg == NULL) { + LOGE("Could not allocate D-Bus message object!"); + goto done; + } + + /* append arguments */ + if (!dbus_message_append_args_valist(msg, first_arg_type, args)) { + LOGE("Could not append argument to method call!"); + goto done; + } + + /* Make the call. */ + reply = dbus_connection_send_with_reply_and_block(conn, msg, timeout_ms, err); + if (!return_error && dbus_error_is_set(err)) { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(err, msg); + } + +done: + if (!return_error) { + free(err); + } + if (msg) dbus_message_unref(msg); + return reply; +} + +DBusMessage * dbus_func_args_timeout(JNIEnv *env, + DBusConnection *conn, + int timeout_ms, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + ...) { + DBusMessage *ret; + va_list lst; + va_start(lst, first_arg_type); + ret = dbus_func_args_timeout_valist(env, conn, timeout_ms, NULL, + path, ifc, func, + first_arg_type, lst); + va_end(lst); + return ret; +} + +DBusMessage * dbus_func_args(JNIEnv *env, + DBusConnection *conn, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + ...) { + DBusMessage *ret; + va_list lst; + va_start(lst, first_arg_type); + ret = dbus_func_args_timeout_valist(env, conn, -1, NULL, + path, ifc, func, + first_arg_type, lst); + va_end(lst); + return ret; +} + +DBusMessage * dbus_func_args_error(JNIEnv *env, + DBusConnection *conn, + DBusError *err, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + ...) { + DBusMessage *ret; + va_list lst; + va_start(lst, first_arg_type); + ret = dbus_func_args_timeout_valist(env, conn, -1, err, + path, ifc, func, + first_arg_type, lst); + va_end(lst); + return ret; +} + +jint dbus_returns_int32(JNIEnv *env, DBusMessage *reply) { + + DBusError err; + jint ret = -1; + + dbus_error_init(&err); + if (!dbus_message_get_args(reply, &err, + DBUS_TYPE_INT32, &ret, + DBUS_TYPE_INVALID)) { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply); + } + dbus_message_unref(reply); + return ret; +} + +jint dbus_returns_uint32(JNIEnv *env, DBusMessage *reply) { + + DBusError err; + jint ret = -1; + + dbus_error_init(&err); + if (!dbus_message_get_args(reply, &err, + DBUS_TYPE_UINT32, &ret, + DBUS_TYPE_INVALID)) { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply); + } + dbus_message_unref(reply); + return ret; +} + +jstring dbus_returns_string(JNIEnv *env, DBusMessage *reply) { + + DBusError err; + jstring ret = NULL; + const char *name; + + dbus_error_init(&err); + if (dbus_message_get_args(reply, &err, + DBUS_TYPE_STRING, &name, + DBUS_TYPE_INVALID)) { + ret = env->NewStringUTF(name); + } else { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply); + } + dbus_message_unref(reply); + + return ret; +} + +jboolean dbus_returns_boolean(JNIEnv *env, DBusMessage *reply) { + DBusError err; + jboolean ret = JNI_FALSE; + dbus_bool_t val = FALSE; + + dbus_error_init(&err); + + /* Check the return value. */ + if (dbus_message_get_args(reply, &err, + DBUS_TYPE_BOOLEAN, &val, + DBUS_TYPE_INVALID)) { + ret = val == TRUE ? JNI_TRUE : JNI_FALSE; + } else { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply); + } + + dbus_message_unref(reply); + return ret; +} + +jobjectArray dbus_returns_array_of_strings(JNIEnv *env, DBusMessage *reply) { + + DBusError err; + char **list; + int i, len; + jobjectArray strArray = NULL; + + dbus_error_init(&err); + if (dbus_message_get_args (reply, + &err, + DBUS_TYPE_ARRAY, DBUS_TYPE_STRING, + &list, &len, + DBUS_TYPE_INVALID)) { + jclass stringClass; + jstring classNameStr; + + //LOGV("%s: there are %d elements in string array!", __FUNCTION__, len); + + stringClass = env->FindClass("java/lang/String"); + strArray = env->NewObjectArray(len, stringClass, NULL); + + for (i = 0; i < len; i++) { + //LOGV("%s: array[%d] = [%s]", __FUNCTION__, i, list[i]); + env->SetObjectArrayElement(strArray, i, + env->NewStringUTF(list[i])); + } + } else { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply); + } + + dbus_message_unref(reply); + return strArray; +} + +jbyteArray dbus_returns_array_of_bytes(JNIEnv *env, DBusMessage *reply) { + + DBusError err; + int i, len; + jbyte *list; + jbyteArray byteArray = NULL; + + dbus_error_init(&err); + if (dbus_message_get_args(reply, &err, + DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &list, &len, + DBUS_TYPE_INVALID)) { + //LOGV("%s: there are %d elements in byte array!", __FUNCTION__, len); + byteArray = env->NewByteArray(len); + if (byteArray) + env->SetByteArrayRegion(byteArray, 0, len, list); + + } else { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply); + } + + dbus_message_unref(reply); + return byteArray; +} + +void get_bdaddr(const char *str, bdaddr_t *ba) { + char *d = ((char *)ba) + 5, *endp; + int i; + for(i = 0; i < 6; i++) { + *d-- = strtol(str, &endp, 16); + if (*endp != ':' && i != 5) { + memset(ba, 0, sizeof(bdaddr_t)); + return; + } + str = endp + 1; + } +} + +void get_bdaddr_as_string(const bdaddr_t *ba, char *str) { + const uint8_t *b = (const uint8_t *)ba; + sprintf(str, "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X", + b[5], b[4], b[3], b[2], b[1], b[0]); +} + +bool debug_no_encrypt() { + return false; +#if 0 + char value[PROPERTY_VALUE_MAX] = ""; + + property_get("debug.bt.no_encrypt", value, ""); + if (!strncmp("true", value, PROPERTY_VALUE_MAX) || + !strncmp("1", value, PROPERTY_VALUE_MAX)) { + LOGD("mandatory bluetooth encryption disabled"); + return true; + } else { + return false; + } +#endif +} +#endif + +} /* namespace android */ diff --git a/core/jni/android_bluetooth_common.h b/core/jni/android_bluetooth_common.h new file mode 100644 index 0000000..e77cd30 --- /dev/null +++ b/core/jni/android_bluetooth_common.h @@ -0,0 +1,137 @@ +/* +** Copyright 2006, 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_BLUETOOTH_COMMON_H +#define ANDROID_BLUETOOTH_COMMON_H + +// Set to 0 to enable verbose bluetooth logging +#define LOG_NDEBUG 1 + +#include "jni.h" +#include "utils/Log.h" + +#include <errno.h> +#include <stdint.h> + +#ifdef HAVE_BLUETOOTH +#include <dbus/dbus.h> +#include <bluetooth/bluetooth.h> +#endif + +namespace android { + +#ifdef HAVE_BLUETOOTH +#define BLUEZ_DBUS_BASE_PATH "/org/bluez" +#define BLUEZ_DBUS_BASE_IFC "org.bluez" + +// It would be nicer to retrieve this from bluez using GetDefaultAdapter, +// but this is only possible when the adapter is up (and hcid is running). +// It is much easier just to hardcode bluetooth adapter to hci0 +#define BLUETOOTH_ADAPTER_HCI_NUM 0 +#define BLUEZ_ADAPTER_OBJECT_NAME BLUEZ_DBUS_BASE_PATH "/hci0" + +#define BTADDR_SIZE 18 // size of BT address character array (including null) + +jfieldID get_field(JNIEnv *env, + jclass clazz, + const char *member, + const char *mtype); + +// LOGE and free a D-Bus error +// Using #define so that __FUNCTION__ resolves usefully +#define LOG_AND_FREE_DBUS_ERROR_WITH_MSG(err, msg) \ + { LOGE("%s: D-Bus error in %s: %s (%s)", __FUNCTION__, \ + dbus_message_get_member((msg)), (err)->name, (err)->message); \ + dbus_error_free((err)); } +#define LOG_AND_FREE_DBUS_ERROR(err) \ + { LOGE("%s: D-Bus error: %s (%s)", __FUNCTION__, \ + (err)->name, (err)->message); \ + dbus_error_free((err)); } + +dbus_bool_t dbus_func_args_async_valist(JNIEnv *env, + DBusConnection *conn, + int timeout_ms, + void (*reply)(DBusMessage *, void *), + void *user, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + va_list args); + +dbus_bool_t dbus_func_args_async(JNIEnv *env, + DBusConnection *conn, + int timeout_ms, + void (*reply)(DBusMessage *, void *), + void *user, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + ...); + +DBusMessage * dbus_func_args(JNIEnv *env, + DBusConnection *conn, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + ...); + +DBusMessage * dbus_func_args_error(JNIEnv *env, + DBusConnection *conn, + DBusError *err, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + ...); + +DBusMessage * dbus_func_args_timeout(JNIEnv *env, + DBusConnection *conn, + int timeout_ms, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + ...); + +DBusMessage * dbus_func_args_timeout_valist(JNIEnv *env, + DBusConnection *conn, + int timeout_ms, + DBusError *err, + const char *path, + const char *ifc, + const char *func, + int first_arg_type, + va_list args); + +jint dbus_returns_int32(JNIEnv *env, DBusMessage *reply); +jint dbus_returns_uint32(JNIEnv *env, DBusMessage *reply); +jstring dbus_returns_string(JNIEnv *env, DBusMessage *reply); +jboolean dbus_returns_boolean(JNIEnv *env, DBusMessage *reply); +jobjectArray dbus_returns_array_of_strings(JNIEnv *env, DBusMessage *reply); +jbyteArray dbus_returns_array_of_bytes(JNIEnv *env, DBusMessage *reply); + +void get_bdaddr(const char *str, bdaddr_t *ba); +void get_bdaddr_as_string(const bdaddr_t *ba, char *str); + +bool debug_no_encrypt(); + +#endif +} /* namespace android */ + +#endif/*ANDROID_BLUETOOTH_COMMON_H*/ diff --git a/core/jni/android_database_CursorWindow.cpp b/core/jni/android_database_CursorWindow.cpp new file mode 100644 index 0000000..f19fbbf --- /dev/null +++ b/core/jni/android_database_CursorWindow.cpp @@ -0,0 +1,674 @@ +/* + * Copyright (C) 2007 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. + */ + +#undef LOG_TAG +#define LOG_TAG "CursorWindow" + +#include <jni.h> +#include <JNIHelp.h> +#include <android_runtime/AndroidRuntime.h> + +#include <utils/Log.h> +#include <utils/String8.h> +#include <utils/String16.h> + +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +#include "CursorWindow.h" +#include "sqlite3_exception.h" +#include "android_util_Binder.h" + + +namespace android { + +static jfieldID gWindowField; +static jfieldID gBufferField; +static jfieldID gSizeCopiedField; + +#define GET_WINDOW(env, object) ((CursorWindow *)env->GetIntField(object, gWindowField)) +#define SET_WINDOW(env, object, window) (env->SetIntField(object, gWindowField, (int)window)) +#define SET_BUFFER(env, object, buf) (env->SetObjectField(object, gBufferField, buf)) +#define SET_SIZE_COPIED(env, object, size) (env->SetIntField(object, gSizeCopiedField, size)) + +CursorWindow * get_window_from_object(JNIEnv * env, jobject javaWindow) +{ + return GET_WINDOW(env, javaWindow); +} + +static void native_init_empty(JNIEnv * env, jobject object, jboolean localOnly) +{ + uint8_t * data; + size_t size; + CursorWindow * window; + + window = new CursorWindow(MAX_WINDOW_SIZE); + if (!window) { + jniThrowException(env, "java/lang/RuntimeException", "No memory for native window object"); + return; + } + + if (!window->initBuffer(localOnly)) { + jniThrowException(env, "java/lang/IllegalStateException", "Couldn't init cursor window"); + delete window; + return; + } + +LOG_WINDOW("native_init_empty: window = %p", window); + SET_WINDOW(env, object, window); +} + +static void native_init_memory(JNIEnv * env, jobject object, jobject memObj) +{ + sp<IMemory> memory = interface_cast<IMemory>(ibinderForJavaObject(env, memObj)); + if (memory == NULL) { + jniThrowException(env, "java/lang/IllegalStateException", "Couldn't get native binder"); + return; + } + + CursorWindow * window = new CursorWindow(); + if (!window) { + jniThrowException(env, "java/lang/RuntimeException", "No memory for native window object"); + return; + } + if (!window->setMemory(memory)) { + jniThrowException(env, "java/lang/RuntimeException", "No memory in memObj"); + delete window; + return; + } + +LOG_WINDOW("native_init_memory: numRows = %d, numColumns = %d, window = %p", window->getNumRows(), window->getNumColumns(), window); + SET_WINDOW(env, object, window); +} + +static jobject native_getBinder(JNIEnv * env, jobject object) +{ + CursorWindow * window = GET_WINDOW(env, object); + if (window) { + sp<IMemory> memory = window->getMemory(); + if (memory != NULL) { + sp<IBinder> binder = memory->asBinder(); + return javaObjectForIBinder(env, binder); + } + } + return NULL; +} + +static void native_clear(JNIEnv * env, jobject object) +{ + CursorWindow * window = GET_WINDOW(env, object); +LOG_WINDOW("Clearing window %p", window); + if (window == NULL) { + jniThrowException(env, "java/lang/IllegalStateException", "clear() called after close()"); + return; + } + window->clear(); +} + +static void native_close(JNIEnv * env, jobject object) +{ + CursorWindow * window = GET_WINDOW(env, object); + if (window) { +LOG_WINDOW("Closing window %p", window); + delete window; + SET_WINDOW(env, object, 0); + } +} + +static void throwExceptionWithRowCol(JNIEnv * env, jint row, jint column) +{ + char buf[100]; + snprintf(buf, sizeof(buf), "get field slot from row %d col %d failed", row, column); + jniThrowException(env, "java/lang/IllegalStateException", buf); +} + +static void throwUnknowTypeException(JNIEnv * env, jint type) +{ + char buf[80]; + snprintf(buf, sizeof(buf), "UNKNOWN type %d", type); + jniThrowException(env, "java/lang/IllegalStateException", buf); +} + +static jlong getLong_native(JNIEnv * env, jobject object, jint row, jint column) +{ + int32_t err; + CursorWindow * window = GET_WINDOW(env, object); +LOG_WINDOW("Getting long for %d,%d from %p", row, column, window); + + field_slot_t field; + err = window->read_field_slot(row, column, &field); + if (err != 0) { + throwExceptionWithRowCol(env, row, column); + return 0; + } + + uint8_t type = field.type; + if (type == FIELD_TYPE_INTEGER) { + int64_t value; + if (window->getLong(row, column, &value)) { + return value; + } + return 0; + } else if (type == FIELD_TYPE_STRING) { + uint32_t size = field.data.buffer.size; + if (size > 0) { +#if WINDOW_STORAGE_UTF8 + return strtoll((char const *)window->offsetToPtr(field.data.buffer.offset), NULL, 0); +#else + String8 ascii((char16_t *) window->offsetToPtr(field.data.buffer.offset), size / 2); + char const * str = ascii.string(); + return strtoll(str, NULL, 0); +#endif + } else { + return 0; + } + } else if (type == FIELD_TYPE_FLOAT) { + double value; + if (window->getDouble(row, column, &value)) { + return value; + } + return 0; + } else if (type == FIELD_TYPE_NULL) { + return 0; + } else if (type == FIELD_TYPE_BLOB) { + throw_sqlite3_exception(env, "Unable to convert BLOB to long"); + return 0; + } else { + throwUnknowTypeException(env, type); + return 0; + } +} + +static jbyteArray getBlob_native(JNIEnv* env, jobject object, jint row, jint column) +{ + int32_t err; + CursorWindow * window = GET_WINDOW(env, object); +LOG_WINDOW("Getting blob for %d,%d from %p", row, column, window); + + field_slot_t field; + err = window->read_field_slot(row, column, &field); + if (err != 0) { + throwExceptionWithRowCol(env, row, column); + return NULL; + } + + uint8_t type = field.type; + if (type == FIELD_TYPE_BLOB || type == FIELD_TYPE_STRING) { + jbyteArray byteArray = env->NewByteArray(field.data.buffer.size); + LOG_ASSERT(byteArray, "Native could not create new byte[]"); + env->SetByteArrayRegion(byteArray, 0, field.data.buffer.size, + (const jbyte*)window->offsetToPtr(field.data.buffer.offset)); + return byteArray; + } else if (type == FIELD_TYPE_INTEGER) { + throw_sqlite3_exception(env, "INTEGER data in getBlob_native "); + } else if (type == FIELD_TYPE_FLOAT) { + throw_sqlite3_exception(env, "FLOAT data in getBlob_native "); + } else if (type == FIELD_TYPE_NULL) { + // do nothing + } else { + throwUnknowTypeException(env, type); + } + return NULL; +} + +static jboolean isBlob_native(JNIEnv* env, jobject object, jint row, jint column) +{ + int32_t err; + CursorWindow * window = GET_WINDOW(env, object); +LOG_WINDOW("Checking if column is a blob for %d,%d from %p", row, column, window); + + field_slot_t field; + err = window->read_field_slot(row, column, &field); + if (err != 0) { + throwExceptionWithRowCol(env, row, column); + return NULL; + } + + return field.type == FIELD_TYPE_BLOB || field.type == FIELD_TYPE_NULL; +} + +static jstring getString_native(JNIEnv* env, jobject object, jint row, jint column) +{ + int32_t err; + CursorWindow * window = GET_WINDOW(env, object); +LOG_WINDOW("Getting string for %d,%d from %p", row, column, window); + + field_slot_t field; + err = window->read_field_slot(row, column, &field); + if (err != 0) { + throwExceptionWithRowCol(env, row, column); + return NULL; + } + + uint8_t type = field.type; + if (type == FIELD_TYPE_STRING) { + uint32_t size = field.data.buffer.size; + if (size > 0) { +#if WINDOW_STORAGE_UTF8 + // Pass size - 1 since the UTF8 is null terminated and we don't want a null terminator on the UTF16 string + String16 utf16((char const *)window->offsetToPtr(field.data.buffer.offset), size - 1); + return env->NewString((jchar const *)utf16.string(), utf16.size()); +#else + return env->NewString((jchar const *)window->offsetToPtr(field.data.buffer.offset), size / 2); +#endif + } else { + return env->NewStringUTF(""); + } + } else if (type == FIELD_TYPE_INTEGER) { + int64_t value; + if (window->getLong(row, column, &value)) { + char buf[32]; + snprintf(buf, sizeof(buf), "%lld", value); + return env->NewStringUTF(buf); + } + return NULL; + } else if (type == FIELD_TYPE_FLOAT) { + double value; + if (window->getDouble(row, column, &value)) { + char buf[32]; + snprintf(buf, sizeof(buf), "%g", value); + return env->NewStringUTF(buf); + } + return NULL; + } else if (type == FIELD_TYPE_NULL) { + return NULL; + } else if (type == FIELD_TYPE_BLOB) { + throw_sqlite3_exception(env, "Unable to convert BLOB to string"); + return NULL; + } else { + throwUnknowTypeException(env, type); + return NULL; + } +} + +/** + * Use this only to convert characters that are known to be within the + * 0-127 range for direct conversion to UTF-16 + */ +static jint charToJchar(const char* src, jchar* dst, jint bufferSize) +{ + int32_t len = strlen(src); + + if (bufferSize < len) { + len = bufferSize; + } + + for (int i = 0; i < len; i++) { + *dst++ = (*src++ & 0x7F); + } + return len; +} + +static jcharArray copyStringToBuffer_native(JNIEnv* env, jobject object, jint row, + jint column, jint bufferSize, jobject buf) +{ + int32_t err; + CursorWindow * window = GET_WINDOW(env, object); +LOG_WINDOW("Copying string for %d,%d from %p", row, column, window); + + field_slot_t field; + err = window->read_field_slot(row, column, &field); + if (err != 0) { + jniThrowException(env, "java/lang/IllegalStateException", "Unable to get field slot"); + return NULL; + } + + jcharArray buffer = (jcharArray)env->GetObjectField(buf, gBufferField); + if (buffer == NULL) { + jniThrowException(env, "java/lang/IllegalStateException", "buf should not be null"); + return NULL; + } + jchar* dst = env->GetCharArrayElements(buffer, NULL); + uint8_t type = field.type; + uint32_t sizeCopied = 0; + jcharArray newArray = NULL; + if (type == FIELD_TYPE_STRING) { + uint32_t size = field.data.buffer.size; + if (size > 0) { +#if WINDOW_STORAGE_UTF8 + // Pass size - 1 since the UTF8 is null terminated and we don't want a null terminator on the UTF16 string + String16 utf16((char const *)window->offsetToPtr(field.data.buffer.offset), size - 1); + int32_t strSize = utf16.size(); + if (strSize > bufferSize || dst == NULL) { + newArray = env->NewCharArray(strSize); + env->SetCharArrayRegion(newArray, 0, strSize, (jchar const *)utf16.string()); + } else { + memcpy(dst, (jchar const *)utf16.string(), strSize * 2); + } + sizeCopied = strSize; +#else + sizeCopied = size/2 + size % 2; + if (size > bufferSize * 2 || dst == NULL) { + newArray = env->NewCharArray(sizeCopied); + memcpy(newArray, (jchar const *)window->offsetToPtr(field.data.buffer.offset), size); + } else { + memcpy(dst, (jchar const *)window->offsetToPtr(field.data.buffer.offset), size); + } +#endif + } + } else if (type == FIELD_TYPE_INTEGER) { + int64_t value; + if (window->getLong(row, column, &value)) { + char buf[32]; + int len; + snprintf(buf, sizeof(buf), "%lld", value); + jchar* dst = env->GetCharArrayElements(buffer, NULL); + sizeCopied = charToJchar(buf, dst, bufferSize); + } + } else if (type == FIELD_TYPE_FLOAT) { + double value; + if (window->getDouble(row, column, &value)) { + char tempbuf[32]; + snprintf(tempbuf, sizeof(tempbuf), "%g", value); + jchar* dst = env->GetCharArrayElements(buffer, NULL); + sizeCopied = charToJchar(tempbuf, dst, bufferSize); + } + } else if (type == FIELD_TYPE_NULL) { + } else if (type == FIELD_TYPE_BLOB) { + throw_sqlite3_exception(env, "Unable to convert BLOB to string"); + } else { + LOGE("Unknown field type %d", type); + throw_sqlite3_exception(env, "UNKNOWN type in copyStringToBuffer_native()"); + } + SET_SIZE_COPIED(env, buf, sizeCopied); + env->ReleaseCharArrayElements(buffer, dst, JNI_OK); + return newArray; +} + +static jdouble getDouble_native(JNIEnv* env, jobject object, jint row, jint column) +{ + int32_t err; + CursorWindow * window = GET_WINDOW(env, object); +LOG_WINDOW("Getting double for %d,%d from %p", row, column, window); + + field_slot_t field; + err = window->read_field_slot(row, column, &field); + if (err != 0) { + throwExceptionWithRowCol(env, row, column); + return 0.0; + } + + uint8_t type = field.type; + if (type == FIELD_TYPE_FLOAT) { + double value; + if (window->getDouble(row, column, &value)) { + return value; + } + return 0.0; + } else if (type == FIELD_TYPE_STRING) { + uint32_t size = field.data.buffer.size; + if (size > 0) { +#if WINDOW_STORAGE_UTF8 + return strtod((char const *)window->offsetToPtr(field.data.buffer.offset), NULL); +#else + String8 ascii((char16_t *) window->offsetToPtr(field.data.buffer.offset), size / 2); + char const * str = ascii.string(); + return strtod(str, NULL); +#endif + } else { + return 0.0; + } + } else if (type == FIELD_TYPE_INTEGER) { + int64_t value; + if (window->getLong(row, column, &value)) { + return (double) value; + } + return 0.0; + } else if (type == FIELD_TYPE_NULL) { + return 0.0; + } else if (type == FIELD_TYPE_BLOB) { + throw_sqlite3_exception(env, "Unable to convert BLOB to double"); + return 0.0; + } else { + throwUnknowTypeException(env, type); + return 0.0; + } +} + +static jboolean isNull_native(JNIEnv* env, jobject object, jint row, jint column) +{ + CursorWindow * window = GET_WINDOW(env, object); +LOG_WINDOW("Checking for NULL at %d,%d from %p", row, column, window); + + bool isNull; + if (window->getNull(row, column, &isNull)) { + return isNull; + } + + //TODO throw execption? + return true; +} + +static jint getNumRows(JNIEnv * env, jobject object) +{ + CursorWindow * window = GET_WINDOW(env, object); + return window->getNumRows(); +} + +static jboolean setNumColumns(JNIEnv * env, jobject object, jint columnNum) +{ + CursorWindow * window = GET_WINDOW(env, object); + return window->setNumColumns(columnNum); +} + +static jboolean allocRow(JNIEnv * env, jobject object) +{ + CursorWindow * window = GET_WINDOW(env, object); + return window->allocRow() != NULL; +} + +static jboolean putBlob_native(JNIEnv * env, jobject object, jbyteArray value, jint row, jint col) +{ + CursorWindow * window = GET_WINDOW(env, object); + if (!value) { + LOG_WINDOW("How did a null value send to here"); + return false; + } + field_slot_t * fieldSlot = window->getFieldSlotWithCheck(row, col); + if (fieldSlot == NULL) { + LOG_WINDOW(" getFieldSlotWithCheck error "); + return false; + } + + jint len = env->GetArrayLength(value); + int offset = window->alloc(len); + if (!offset) { + LOG_WINDOW("Failed allocating %u bytes", len); + return false; + } + jbyte * bytes = env->GetByteArrayElements(value, NULL); + window->copyIn(offset, (uint8_t const *)bytes, len); + + // This must be updated after the call to alloc(), since that + // may move the field around in the window + fieldSlot->type = FIELD_TYPE_BLOB; + fieldSlot->data.buffer.offset = offset; + fieldSlot->data.buffer.size = len; + env->ReleaseByteArrayElements(value, bytes, JNI_ABORT); + LOG_WINDOW("%d,%d is BLOB with %u bytes @ %d", row, col, len, offset); + return true; +} + +static jboolean putString_native(JNIEnv * env, jobject object, jstring value, jint row, jint col) +{ + CursorWindow * window = GET_WINDOW(env, object); + if (!value) { + LOG_WINDOW("How did a null value send to here"); + return false; + } + field_slot_t * fieldSlot = window->getFieldSlotWithCheck(row, col); + if (fieldSlot == NULL) { + LOG_WINDOW(" getFieldSlotWithCheck error "); + return false; + } + +#if WINDOW_STORAGE_UTF8 + int len = env->GetStringUTFLength(value) + 1; + char const * valStr = env->GetStringUTFChars(value, NULL); +#else + int len = env->GetStringLength(value); + // GetStringLength return number of chars and one char takes 2 bytes + len *= 2; + const jchar* valStr = env->GetStringChars(value, NULL); +#endif + if (!valStr) { + LOG_WINDOW("value can't be transfer to UTFChars"); + return false; + } + + int offset = window->alloc(len); + if (!offset) { + LOG_WINDOW("Failed allocating %u bytes", len); +#if WINDOW_STORAGE_UTF8 + env->ReleaseStringUTFChars(value, valStr); +#else + env->ReleaseStringChars(value, valStr); +#endif + return false; + } + + window->copyIn(offset, (uint8_t const *)valStr, len); + + // This must be updated after the call to alloc(), since that + // may move the field around in the window + fieldSlot->type = FIELD_TYPE_STRING; + fieldSlot->data.buffer.offset = offset; + fieldSlot->data.buffer.size = len; + + LOG_WINDOW("%d,%d is TEXT with %u bytes @ %d", row, col, len, offset); +#if WINDOW_STORAGE_UTF8 + env->ReleaseStringUTFChars(value, valStr); +#else + env->ReleaseStringChars(value, valStr); +#endif + + return true; +} + +static jboolean putLong_native(JNIEnv * env, jobject object, jlong value, jint row, jint col) +{ + CursorWindow * window = GET_WINDOW(env, object); + if (!window->putLong(row, col, value)) { + LOG_WINDOW(" getFieldSlotWithCheck error "); + return false; + } + + LOG_WINDOW("%d,%d is INTEGER 0x%016llx", row, col, value); + + return true; +} + +static jboolean putDouble_native(JNIEnv * env, jobject object, jdouble value, jint row, jint col) +{ + CursorWindow * window = GET_WINDOW(env, object); + if (!window->putDouble(row, col, value)) { + LOG_WINDOW(" getFieldSlotWithCheck error "); + return false; + } + + LOG_WINDOW("%d,%d is FLOAT %lf", row, col, value); + + return true; +} + +static jboolean putNull_native(JNIEnv * env, jobject object, jint row, jint col) +{ + CursorWindow * window = GET_WINDOW(env, object); + if (!window->putNull(row, col)) { + LOG_WINDOW(" getFieldSlotWithCheck error "); + return false; + } + + LOG_WINDOW("%d,%d is NULL", row, col); + + return true; +} + +// free the last row +static void freeLastRow(JNIEnv * env, jobject object) { + CursorWindow * window = GET_WINDOW(env, object); + window->freeLastRow(); +} + +static JNINativeMethod sMethods[] = +{ + /* name, signature, funcPtr */ + {"native_init", "(Z)V", (void *)native_init_empty}, + {"native_init", "(Landroid/os/IBinder;)V", (void *)native_init_memory}, + {"native_getBinder", "()Landroid/os/IBinder;", (void *)native_getBinder}, + {"native_clear", "()V", (void *)native_clear}, + {"close_native", "()V", (void *)native_close}, + {"getLong_native", "(II)J", (void *)getLong_native}, + {"getBlob_native", "(II)[B", (void *)getBlob_native}, + {"isBlob_native", "(II)Z", (void *)isBlob_native}, + {"getString_native", "(II)Ljava/lang/String;", (void *)getString_native}, + {"copyStringToBuffer_native", "(IIILandroid/database/CharArrayBuffer;)[C", (void *)copyStringToBuffer_native}, + {"getDouble_native", "(II)D", (void *)getDouble_native}, + {"isNull_native", "(II)Z", (void *)isNull_native}, + {"getNumRows_native", "()I", (void *)getNumRows}, + {"setNumColumns_native", "(I)Z", (void *)setNumColumns}, + {"allocRow_native", "()Z", (void *)allocRow}, + {"putBlob_native", "([BII)Z", (void *)putBlob_native}, + {"putString_native", "(Ljava/lang/String;II)Z", (void *)putString_native}, + {"putLong_native", "(JII)Z", (void *)putLong_native}, + {"putDouble_native", "(DII)Z", (void *)putDouble_native}, + {"freeLastRow_native", "()V", (void *)freeLastRow}, + {"putNull_native", "(II)Z", (void *)putNull_native}, +}; + +int register_android_database_CursorWindow(JNIEnv * env) +{ + jclass clazz; + + clazz = env->FindClass("android/database/CursorWindow"); + if (clazz == NULL) { + LOGE("Can't find android/database/CursorWindow"); + return -1; + } + + gWindowField = env->GetFieldID(clazz, "nWindow", "I"); + + if (gWindowField == NULL) { + LOGE("Error locating fields"); + return -1; + } + + clazz = env->FindClass("android/database/CharArrayBuffer"); + if (clazz == NULL) { + LOGE("Can't find android/database/CharArrayBuffer"); + return -1; + } + + gBufferField = env->GetFieldID(clazz, "data", "[C"); + + if (gBufferField == NULL) { + LOGE("Error locating fields data in CharArrayBuffer"); + return -1; + } + + gSizeCopiedField = env->GetFieldID(clazz, "sizeCopied", "I"); + + if (gSizeCopiedField == NULL) { + LOGE("Error locating fields sizeCopied in CharArrayBuffer"); + return -1; + } + + return AndroidRuntime::registerNativeMethods(env, "android/database/CursorWindow", + sMethods, NELEM(sMethods)); +} + +} // namespace android diff --git a/core/jni/android_database_SQLiteDatabase.cpp b/core/jni/android_database_SQLiteDatabase.cpp new file mode 100644 index 0000000..66f0118 --- /dev/null +++ b/core/jni/android_database_SQLiteDatabase.cpp @@ -0,0 +1,464 @@ +/* + * Copyright (C) 2006-2007 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. + */ + +#undef LOG_TAG +#define LOG_TAG "Database" + +#include <utils/Log.h> +#include <utils/String8.h> +#include <utils/String16.h> + +#include <jni.h> +#include <JNIHelp.h> +#include <android_runtime/AndroidRuntime.h> + +#include <sqlite3.h> +#include <sqlite3_android.h> +#include <string.h> +#include <utils.h> +#include <ctype.h> + +#include <stdio.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <string.h> +#include <netdb.h> +#include <sys/ioctl.h> + +#include "sqlite3_exception.h" + +#define UTF16_STORAGE 0 +#define INVALID_VERSION -1 +#define SQLITE_SOFT_HEAP_LIMIT (4 * 1024 * 1024) +#define ANDROID_TABLE "android_metadata" + +namespace android { + +enum { + OPEN_READWRITE = 0x00000000, + OPEN_READONLY = 0x00000001, + OPEN_READ_MASK = 0x00000001, + NO_LOCALIZED_COLLATORS = 0x00000010, + CREATE_IF_NECESSARY = 0x10000000 +}; + +static jfieldID offset_db_handle; + +/* public native void dbopen(String path, int flags, String locale); */ +static void dbopen(JNIEnv* env, jobject object, jstring pathString, jint flags) +{ + int err; + sqlite3 * handle = NULL; + sqlite3_stmt * statement = NULL; + char const * path8 = env->GetStringUTFChars(pathString, NULL); + int sqliteFlags; + + // convert our flags into the sqlite flags + if (flags & CREATE_IF_NECESSARY) { + sqliteFlags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE; + } else if (flags & OPEN_READONLY) { + sqliteFlags = SQLITE_OPEN_READONLY; + } else { + sqliteFlags = SQLITE_OPEN_READWRITE; + } + + err = sqlite3_open_v2(path8, &handle, sqliteFlags, NULL); + if (err != SQLITE_OK) { + LOGE("sqlite3_open_v2(\"%s\", &handle, %d, NULL) failed\n", path8, sqliteFlags); + throw_sqlite3_exception(env, handle); + goto done; + } + + // The soft heap limit prevents the page cache allocations from growing + // beyond the given limit, no matter what the max page cache sizes are + // set to. The limit does not, as of 3.5.0, affect any other allocations. + sqlite3_soft_heap_limit(SQLITE_SOFT_HEAP_LIMIT); + + // Set the default busy handler to retry for 1000ms and then return SQLITE_BUSY + err = sqlite3_busy_timeout(handle, 1000 /* ms */); + if (err != SQLITE_OK) { + LOGE("sqlite3_busy_timeout(handle, 1000) failed for \"%s\"\n", path8); + throw_sqlite3_exception(env, handle); + goto done; + } + +#ifdef DB_INTEGRITY_CHECK + static const char* integritySql = "pragma integrity_check(1);"; + err = sqlite3_prepare_v2(handle, integritySql, -1, &statement, NULL); + if (err != SQLITE_OK) { + LOGE("sqlite_prepare_v2(handle, \"%s\") failed for \"%s\"\n", integritySql, path8); + throw_sqlite3_exception(env, handle); + goto done; + } + + // first is OK or error message + err = sqlite3_step(statement); + if (err != SQLITE_ROW) { + LOGE("integrity check failed for \"%s\"\n", integritySql, path8); + throw_sqlite3_exception(env, handle); + goto done; + } else { + const char *text = (const char*)sqlite3_column_text(statement, 0); + if (strcmp(text, "ok") != 0) { + LOGE("integrity check failed for \"%s\": %s\n", integritySql, path8, text); + jniThrowException(env, "android/database/sqlite/SQLiteDatabaseCorruptException", text); + goto done; + } + } +#endif + + err = register_android_functions(handle, UTF16_STORAGE); + if (err) { + throw_sqlite3_exception(env, handle); + goto done; + } + + LOGV("Opened '%s' - %p\n", path8, handle); + env->SetIntField(object, offset_db_handle, (int) handle); + handle = NULL; // The caller owns the handle now. + +done: + // Release allocated resources + if (path8 != NULL) env->ReleaseStringUTFChars(pathString, path8); + if (statement != NULL) sqlite3_finalize(statement); + if (handle != NULL) sqlite3_close(handle); +} + +/* public native void close(); */ +static void dbclose(JNIEnv* env, jobject object) +{ + sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle); + + if (handle != NULL) { + LOGV("Closing database: handle=%p\n", handle); + int result = sqlite3_close(handle); + if (result == SQLITE_OK) { + LOGV("Closed %p\n", handle); + env->SetIntField(object, offset_db_handle, 0); + } else { + // This can happen if sub-objects aren't closed first. Make sure the caller knows. + throw_sqlite3_exception(env, handle); + LOGE("sqlite3_close(%p) failed: %d\n", handle, result); + } + } +} + +/* public native void native_execSQL(String sql); */ +static void native_execSQL(JNIEnv* env, jobject object, jstring sqlString) +{ + int err; + int stepErr; + sqlite3_stmt * statement = NULL; + sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle); + jchar const * sql = env->GetStringChars(sqlString, NULL); + jsize sqlLen = env->GetStringLength(sqlString); + + if (sql == NULL || sqlLen == 0) { + jniThrowException(env, "java/lang/IllegalArgumentException", "You must supply an SQL string"); + return; + } + + err = sqlite3_prepare16_v2(handle, sql, sqlLen * 2, &statement, NULL); + + env->ReleaseStringChars(sqlString, sql); + + if (err != SQLITE_OK) { + char const * sql8 = env->GetStringUTFChars(sqlString, NULL); + LOGE("Failure %d (%s) on %p when preparing '%s'.\n", err, sqlite3_errmsg(handle), handle, sql8); + throw_sqlite3_exception(env, handle, sql8); + env->ReleaseStringUTFChars(sqlString, sql8); + return; + } + + stepErr = sqlite3_step(statement); + err = sqlite3_finalize(statement); + + if (stepErr != SQLITE_DONE) { + if (stepErr == SQLITE_ROW) { + throw_sqlite3_exception(env, "Queries cannot be performed using execSQL(), use query() instead."); + } else { + char const * sql8 = env->GetStringUTFChars(sqlString, NULL); + LOGE("Failure %d (%s) on %p when executing '%s'\n", err, sqlite3_errmsg(handle), handle, sql8); + throw_sqlite3_exception(env, handle, sql8); + env->ReleaseStringUTFChars(sqlString, sql8); + + } + } else IF_LOGV() { + char const * sql8 = env->GetStringUTFChars(sqlString, NULL); + LOGV("Success on %p when executing '%s'\n", handle, sql8); + env->ReleaseStringUTFChars(sqlString, sql8); + } +} + +/* native long lastInsertRow(); */ +static jlong lastInsertRow(JNIEnv* env, jobject object) +{ + sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle); + + return sqlite3_last_insert_rowid(handle); +} + +/* native int lastChangeCount(); */ +static jint lastChangeCount(JNIEnv* env, jobject object) +{ + sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle); + + return sqlite3_changes(handle); +} + +/* set locale in the android_metadata table, install localized collators, and rebuild indexes */ +static void native_setLocale(JNIEnv* env, jobject object, jstring localeString, jint flags) +{ + if ((flags & NO_LOCALIZED_COLLATORS)) return; + + int err; + char const* locale8 = env->GetStringUTFChars(localeString, NULL); + sqlite3 * handle = (sqlite3 *)env->GetIntField(object, offset_db_handle); + sqlite3_stmt* stmt = NULL; + char** meta = NULL; + int rowCount, colCount; + char* dbLocale = NULL; + + // create the table, if necessary and possible + if (!(flags & OPEN_READONLY)) { + static const char *createSql ="CREATE TABLE IF NOT EXISTS " ANDROID_TABLE " (locale TEXT)"; + err = sqlite3_exec(handle, createSql, NULL, NULL, NULL); + if (err != SQLITE_OK) { + LOGE("CREATE TABLE " ANDROID_TABLE " failed\n"); + throw_sqlite3_exception(env, handle); + goto done; + } + } + + // try to read from the table + static const char *selectSql = "SELECT locale FROM " ANDROID_TABLE " LIMIT 1"; + err = sqlite3_get_table(handle, selectSql, &meta, &rowCount, &colCount, NULL); + if (err != SQLITE_OK) { + LOGE("SELECT locale FROM " ANDROID_TABLE " failed\n"); + throw_sqlite3_exception(env, handle); + goto done; + } + + dbLocale = (rowCount >= 1) ? meta[1 * colCount + 0] : NULL; + + if (dbLocale != NULL && !strcmp(dbLocale, locale8)) { + // database locale is the same as the desired locale; set up the collators and go + err = register_localized_collators(handle, locale8, UTF16_STORAGE); + if (err != SQLITE_OK) throw_sqlite3_exception(env, handle); + goto done; // no database changes needed + } + + if ((flags & OPEN_READONLY)) { + // read-only database, so we're going to have to put up with whatever we got + err = register_localized_collators(handle, dbLocale ? dbLocale : locale8, UTF16_STORAGE); + if (err != SQLITE_OK) throw_sqlite3_exception(env, handle); + goto done; + } + + // need to update android_metadata and indexes atomically, so use a transaction... + err = sqlite3_exec(handle, "BEGIN TRANSACTION", NULL, NULL, NULL); + if (err != SQLITE_OK) { + LOGE("BEGIN TRANSACTION failed setting locale\n"); + throw_sqlite3_exception(env, handle); + goto done; + } + + err = register_localized_collators(handle, dbLocale ? dbLocale : locale8, UTF16_STORAGE); + if (err != SQLITE_OK) { + LOGE("register_localized_collators() failed setting locale\n"); + throw_sqlite3_exception(env, handle); + goto done; + } + + err = sqlite3_exec(handle, "DELETE FROM " ANDROID_TABLE, NULL, NULL, NULL); + if (err != SQLITE_OK) { + LOGE("DELETE failed setting locale\n"); + throw_sqlite3_exception(env, handle); + goto rollback; + } + + static const char *sql = "INSERT INTO " ANDROID_TABLE " (locale) VALUES(?);"; + err = sqlite3_prepare_v2(handle, sql, -1, &stmt, NULL); + if (err != SQLITE_OK) { + LOGE("sqlite3_prepare_v2(\"%s\") failed\n", sql); + throw_sqlite3_exception(env, handle); + goto rollback; + } + + err = sqlite3_bind_text(stmt, 1, locale8, -1, SQLITE_TRANSIENT); + if (err != SQLITE_OK) { + LOGE("sqlite3_bind_text() failed setting locale\n"); + throw_sqlite3_exception(env, handle); + goto rollback; + } + + err = sqlite3_step(stmt); + if (err != SQLITE_OK && err != SQLITE_DONE) { + LOGE("sqlite3_step(\"%s\") failed setting locale\n", sql); + throw_sqlite3_exception(env, handle); + goto rollback; + } + + err = sqlite3_exec(handle, "REINDEX LOCALIZED", NULL, NULL, NULL); + if (err != SQLITE_OK) { + LOGE("REINDEX LOCALIZED failed\n"); + throw_sqlite3_exception(env, handle); + goto rollback; + } + + // all done, yay! + err = sqlite3_exec(handle, "COMMIT TRANSACTION", NULL, NULL, NULL); + if (err != SQLITE_OK) { + LOGE("COMMIT TRANSACTION failed setting locale\n"); + throw_sqlite3_exception(env, handle); + goto done; + } + +rollback: + sqlite3_exec(handle, "ROLLBACK TRANSACTION", NULL, NULL, NULL); + +done: + if (locale8 != NULL) env->ReleaseStringUTFChars(localeString, locale8); + if (stmt != NULL) sqlite3_finalize(stmt); + if (meta != NULL) sqlite3_free_table(meta); +} + +static jint native_releaseMemory(JNIEnv *env, jobject clazz) +{ + // Attempt to release as much memory from the + return sqlite3_release_memory(SQLITE_SOFT_HEAP_LIMIT); +} + +static JNINativeMethod sMethods[] = +{ + /* name, signature, funcPtr */ + {"dbopen", "(Ljava/lang/String;I)V", (void *)dbopen}, + {"dbclose", "()V", (void *)dbclose}, + {"native_execSQL", "(Ljava/lang/String;)V", (void *)native_execSQL}, + {"lastInsertRow", "()J", (void *)lastInsertRow}, + {"lastChangeCount", "()I", (void *)lastChangeCount}, + {"native_setLocale", "(Ljava/lang/String;I)V", (void *)native_setLocale}, + {"releaseMemory", "()I", (void *)native_releaseMemory}, +}; + +int register_android_database_SQLiteDatabase(JNIEnv *env) +{ + jclass clazz; + + clazz = env->FindClass("android/database/sqlite/SQLiteDatabase"); + if (clazz == NULL) { + LOGE("Can't find android/database/sqlite/SQLiteDatabase\n"); + return -1; + } + + offset_db_handle = env->GetFieldID(clazz, "mNativeHandle", "I"); + if (offset_db_handle == NULL) { + LOGE("Can't find SQLiteDatabase.mNativeHandle\n"); + return -1; + } + + return AndroidRuntime::registerNativeMethods(env, "android/database/sqlite/SQLiteDatabase", sMethods, NELEM(sMethods)); +} + +/* throw a SQLiteException with a message appropriate for the error in handle */ +void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle) { + throw_sqlite3_exception(env, handle, NULL); +} + +/* throw a SQLiteException with the given message */ +void throw_sqlite3_exception(JNIEnv* env, const char* message) { + throw_sqlite3_exception(env, NULL, message); +} + +/* throw a SQLiteException with a message appropriate for the error in handle + concatenated with the given message + */ +void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle, const char* message) { + if (handle) { + throw_sqlite3_exception(env, sqlite3_errcode(handle), + sqlite3_errmsg(handle), message); + } else { + // we use SQLITE_OK so that a generic SQLiteException is thrown; + // any code not specified in the switch statement below would do. + throw_sqlite3_exception(env, SQLITE_OK, "unknown error", message); + } +} + +/* throw a SQLiteException for a given error code */ +void throw_sqlite3_exception_errcode(JNIEnv* env, int errcode, const char* message) { + if (errcode == SQLITE_DONE) { + throw_sqlite3_exception(env, errcode, NULL, message); + } else { + char temp[20]; + sprintf(temp, "error code %d", errcode); + throw_sqlite3_exception(env, errcode, temp, message); + } +} + +/* throw a SQLiteException for a given error code, sqlite3message, and + user message + */ +void throw_sqlite3_exception(JNIEnv* env, int errcode, + const char* sqlite3Message, const char* message) { + const char* exceptionClass; + switch (errcode) { + case SQLITE_IOERR: + exceptionClass = "android/database/sqlite/SQLiteDiskIOException"; + break; + case SQLITE_CORRUPT: + exceptionClass = "android/database/sqlite/SQLiteDatabaseCorruptException"; + break; + case SQLITE_CONSTRAINT: + exceptionClass = "android/database/sqlite/SQLiteConstraintException"; + break; + case SQLITE_ABORT: + exceptionClass = "android/database/sqlite/SQLiteAbortException"; + break; + case SQLITE_DONE: + exceptionClass = "android/database/sqlite/SQLiteDoneException"; + break; + case SQLITE_FULL: + exceptionClass = "android/database/sqlite/SQLiteFullException"; + break; + case SQLITE_MISUSE: + exceptionClass = "android/database/sqlite/SQLiteMisuseException"; + break; + default: + exceptionClass = "android/database/sqlite/SQLiteException"; + break; + } + + if (sqlite3Message != NULL && message != NULL) { + char* fullMessage = (char *)malloc(strlen(sqlite3Message) + strlen(message) + 3); + if (fullMessage != NULL) { + strcpy(fullMessage, sqlite3Message); + strcat(fullMessage, ": "); + strcat(fullMessage, message); + jniThrowException(env, exceptionClass, fullMessage); + free(fullMessage); + } else { + jniThrowException(env, exceptionClass, sqlite3Message); + } + } else if (sqlite3Message != NULL) { + jniThrowException(env, exceptionClass, sqlite3Message); + } else { + jniThrowException(env, exceptionClass, message); + } +} + + +} // namespace android diff --git a/core/jni/android_database_SQLiteDebug.cpp b/core/jni/android_database_SQLiteDebug.cpp new file mode 100644 index 0000000..916df35 --- /dev/null +++ b/core/jni/android_database_SQLiteDebug.cpp @@ -0,0 +1,244 @@ +/* + * Copyright (C) 2007 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. + */ + +#include <JNIHelp.h> +#include <jni.h> +#include <utils/misc.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <cutils/mspace.h> +#include <utils/Log.h> + +#include <sqlite3.h> + +// From mem_mspace.c in libsqlite +extern "C" mspace sqlite3_get_mspace(); + +// From sqlite.c, hacked in for Android +extern "C" void sqlite3_get_pager_stats(sqlite3_int64 * totalBytesOut, + sqlite3_int64 * referencedBytesOut, + sqlite3_int64 * dbBytesOut, + int * numPagersOut); + +namespace android { + +static jfieldID gTotalBytesField; +static jfieldID gReferencedBytesField; +static jfieldID gDbBytesField; +static jfieldID gNumPagersField; + + +#define USE_MSPACE 0 + +static void getPagerStats(JNIEnv *env, jobject clazz, jobject statsObj) +{ + sqlite3_int64 totalBytes; + sqlite3_int64 referencedBytes; + sqlite3_int64 dbBytes; + int numPagers; + + sqlite3_get_pager_stats(&totalBytes, &referencedBytes, &dbBytes, + &numPagers); + + env->SetLongField(statsObj, gTotalBytesField, totalBytes); + env->SetLongField(statsObj, gReferencedBytesField, referencedBytes); + env->SetLongField(statsObj, gDbBytesField, dbBytes); + env->SetIntField(statsObj, gNumPagersField, numPagers); +} + +static jlong getHeapSize(JNIEnv *env, jobject clazz) +{ +#if !NO_MALLINFO + struct mallinfo info = mspace_mallinfo(sqlite3_get_mspace()); + struct mallinfo info = dlmallinfo(); + return (jlong) info.usmblks; +#elif USE_MSPACE + mspace space = sqlite3_get_mspace(); + if (space != 0) { + return mspace_footprint(space); + } else { + return 0; + } +#else + return 0; +#endif +} + +static jlong getHeapAllocatedSize(JNIEnv *env, jobject clazz) +{ +#if !NO_MALLINFO + struct mallinfo info = mspace_mallinfo(sqlite3_get_mspace()); + return (jlong) info.uordblks; +#else + return sqlite3_memory_used(); +#endif +} + +static jlong getHeapFreeSize(JNIEnv *env, jobject clazz) +{ +#if !NO_MALLINFO + struct mallinfo info = mspace_mallinfo(sqlite3_get_mspace()); + return (jlong) info.fordblks; +#else + return getHeapSize(env, clazz) - sqlite3_memory_used(); +#endif +} + +static int read_mapinfo(FILE *fp, + int *sharedPages, int *privatePages) +{ + char line[1024]; + int len; + int skip; + + unsigned start = 0, size = 0, resident = 0; + unsigned shared_clean = 0, shared_dirty = 0; + unsigned private_clean = 0, private_dirty = 0; + unsigned referenced = 0; + + int isAnon = 0; + int isHeap = 0; + +again: + skip = 0; + + if(fgets(line, 1024, fp) == 0) return 0; + + len = strlen(line); + if (len < 1) return 0; + line[--len] = 0; + + /* ignore guard pages */ + if (line[18] == '-') skip = 1; + + start = strtoul(line, 0, 16); + + if (len > 50 && !strncmp(line + 49, "/tmp/sqlite-heap", strlen("/tmp/sqlite-heap"))) { + isHeap = 1; + } + + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Size: %d kB", &size) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Rss: %d kB", &resident) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Shared_Clean: %d kB", &shared_clean) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Shared_Dirty: %d kB", &shared_dirty) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Private_Clean: %d kB", &private_clean) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Private_Dirty: %d kB", &private_dirty) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Referenced: %d kB", &referenced) != 1) return 0; + + if (skip) { + goto again; + } + + if (isHeap) { + *sharedPages += shared_dirty; + *privatePages += private_dirty; + } + return 1; +} + +static void load_maps(int pid, int *sharedPages, int *privatePages) +{ + char tmp[128]; + FILE *fp; + + sprintf(tmp, "/proc/%d/smaps", pid); + fp = fopen(tmp, "r"); + if (fp == 0) return; + + while (read_mapinfo(fp, sharedPages, privatePages) != 0) { + // Do nothing + } + fclose(fp); +} + +static void getHeapDirtyPages(JNIEnv *env, jobject clazz, jintArray pages) +{ + int _pages[2]; + + _pages[0] = 0; + _pages[1] = 0; + + load_maps(getpid(), &_pages[0], &_pages[1]); + + // Convert from kbytes to 4K pages + _pages[0] /= 4; + _pages[1] /= 4; + + env->SetIntArrayRegion(pages, 0, 2, _pages); +} + +/* + * JNI registration. + */ + +static JNINativeMethod gMethods[] = +{ + { "getPagerStats", "(Landroid/database/sqlite/SQLiteDebug$PagerStats;)V", + (void*) getPagerStats }, + { "getHeapSize", "()J", (void*) getHeapSize }, + { "getHeapAllocatedSize", "()J", (void*) getHeapAllocatedSize }, + { "getHeapFreeSize", "()J", (void*) getHeapFreeSize }, + { "getHeapDirtyPages", "([I)V", (void*) getHeapDirtyPages }, +}; + +int register_android_database_SQLiteDebug(JNIEnv *env) +{ + jclass clazz; + + clazz = env->FindClass("android/database/sqlite/SQLiteDebug$PagerStats"); + if (clazz == NULL) { + LOGE("Can't find android/database/sqlite/SQLiteDebug$PagerStats"); + return -1; + } + + gTotalBytesField = env->GetFieldID(clazz, "totalBytes", "J"); + if (gTotalBytesField == NULL) { + LOGE("Can't find totalBytes"); + return -1; + } + + gReferencedBytesField = env->GetFieldID(clazz, "referencedBytes", "J"); + if (gReferencedBytesField == NULL) { + LOGE("Can't find referencedBytes"); + return -1; + } + + gDbBytesField = env->GetFieldID(clazz, "databaseBytes", "J"); + if (gDbBytesField == NULL) { + LOGE("Can't find databaseBytes"); + return -1; + } + + gNumPagersField = env->GetFieldID(clazz, "numPagers", "I"); + if (gNumPagersField == NULL) { + LOGE("Can't find numPagers"); + return -1; + } + + return jniRegisterNativeMethods(env, "android/database/sqlite/SQLiteDebug", + gMethods, NELEM(gMethods)); +} + +} // namespace android diff --git a/core/jni/android_database_SQLiteProgram.cpp b/core/jni/android_database_SQLiteProgram.cpp new file mode 100644 index 0000000..54e7de2 --- /dev/null +++ b/core/jni/android_database_SQLiteProgram.cpp @@ -0,0 +1,240 @@ +/* + * Copyright (C) 2006-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. + */ + +#undef LOG_TAG +#define LOG_TAG "Cursor" + +#include <jni.h> +#include <JNIHelp.h> +#include <android_runtime/AndroidRuntime.h> + +#include <sqlite3.h> + +#include <utils/Log.h> + +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +#include "sqlite3_exception.h" + + +namespace android { + +static jfieldID gHandleField; +static jfieldID gStatementField; + + +#define GET_STATEMENT(env, object) \ + (sqlite3_stmt *)env->GetIntField(object, gStatementField) +#define GET_HANDLE(env, object) \ + (sqlite3 *)env->GetIntField(object, gHandleField) + + +sqlite3_stmt * compile(JNIEnv* env, jobject object, + sqlite3 * handle, jstring sqlString) +{ + int err; + jchar const * sql; + jsize sqlLen; + sqlite3_stmt * statement = GET_STATEMENT(env, object); + + // Make sure not to leak the statement if it already exists + if (statement != NULL) { + sqlite3_finalize(statement); + env->SetIntField(object, gStatementField, 0); + } + + // Compile the SQL + sql = env->GetStringChars(sqlString, NULL); + sqlLen = env->GetStringLength(sqlString); + err = sqlite3_prepare16_v2(handle, sql, sqlLen * 2, &statement, NULL); + env->ReleaseStringChars(sqlString, sql); + + if (err == SQLITE_OK) { + // Store the statement in the Java object for future calls + LOGV("Prepared statement %p on %p", statement, handle); + env->SetIntField(object, gStatementField, (int)statement); + return statement; + } else { + // Error messages like 'near ")": syntax error' are not + // always helpful enough, so construct an error string that + // includes the query itself. + const char *query = env->GetStringUTFChars(sqlString, NULL); + char *message = (char*) malloc(strlen(query) + 50); + if (message) { + strcpy(message, ", while compiling: "); // less than 50 chars + strcat(message, query); + } + env->ReleaseStringUTFChars(sqlString, query); + throw_sqlite3_exception(env, handle, message); + free(message); + return NULL; + } +} + +static void native_compile(JNIEnv* env, jobject object, jstring sqlString) +{ + compile(env, object, GET_HANDLE(env, object), sqlString); +} + +static void native_bind_null(JNIEnv* env, jobject object, + jint index) +{ + int err; + sqlite3_stmt * statement = GET_STATEMENT(env, object); + + err = sqlite3_bind_null(statement, index); + if (err != SQLITE_OK) { + char buf[32]; + sprintf(buf, "handle %p", statement); + throw_sqlite3_exception(env, GET_HANDLE(env, object), buf); + return; + } +} + +static void native_bind_long(JNIEnv* env, jobject object, + jint index, jlong value) +{ + int err; + sqlite3_stmt * statement = GET_STATEMENT(env, object); + + err = sqlite3_bind_int64(statement, index, value); + if (err != SQLITE_OK) { + char buf[32]; + sprintf(buf, "handle %p", statement); + throw_sqlite3_exception(env, GET_HANDLE(env, object), buf); + return; + } +} + +static void native_bind_double(JNIEnv* env, jobject object, + jint index, jdouble value) +{ + int err; + sqlite3_stmt * statement = GET_STATEMENT(env, object); + + err = sqlite3_bind_double(statement, index, value); + if (err != SQLITE_OK) { + char buf[32]; + sprintf(buf, "handle %p", statement); + throw_sqlite3_exception(env, GET_HANDLE(env, object), buf); + return; + } +} + +static void native_bind_string(JNIEnv* env, jobject object, + jint index, jstring sqlString) +{ + int err; + jchar const * sql; + jsize sqlLen; + sqlite3_stmt * statement= GET_STATEMENT(env, object); + + sql = env->GetStringChars(sqlString, NULL); + sqlLen = env->GetStringLength(sqlString); + err = sqlite3_bind_text16(statement, index, sql, sqlLen * 2, SQLITE_TRANSIENT); + env->ReleaseStringChars(sqlString, sql); + if (err != SQLITE_OK) { + char buf[32]; + sprintf(buf, "handle %p", statement); + throw_sqlite3_exception(env, GET_HANDLE(env, object), buf); + return; + } +} + +static void native_bind_blob(JNIEnv* env, jobject object, + jint index, jbyteArray value) +{ + int err; + jchar const * sql; + jsize sqlLen; + sqlite3_stmt * statement= GET_STATEMENT(env, object); + + jint len = env->GetArrayLength(value); + jbyte * bytes = env->GetByteArrayElements(value, NULL); + + err = sqlite3_bind_blob(statement, index, bytes, len, SQLITE_TRANSIENT); + env->ReleaseByteArrayElements(value, bytes, JNI_ABORT); + + if (err != SQLITE_OK) { + char buf[32]; + sprintf(buf, "handle %p", statement); + throw_sqlite3_exception(env, GET_HANDLE(env, object), buf); + return; + } +} + +static void native_clear_bindings(JNIEnv* env, jobject object) +{ + int err; + sqlite3_stmt * statement = GET_STATEMENT(env, object); + + err = sqlite3_clear_bindings(statement); + if (err != SQLITE_OK) { + throw_sqlite3_exception(env, GET_HANDLE(env, object)); + return; + } +} + +static void native_finalize(JNIEnv* env, jobject object) +{ + int err; + sqlite3_stmt * statement = GET_STATEMENT(env, object); + + if (statement != NULL) { + sqlite3_finalize(statement); + env->SetIntField(object, gStatementField, 0); + } +} + + +static JNINativeMethod sMethods[] = +{ + /* name, signature, funcPtr */ + {"native_compile", "(Ljava/lang/String;)V", (void *)native_compile}, + {"native_bind_null", "(I)V", (void *)native_bind_null}, + {"native_bind_long", "(IJ)V", (void *)native_bind_long}, + {"native_bind_double", "(ID)V", (void *)native_bind_double}, + {"native_bind_string", "(ILjava/lang/String;)V", (void *)native_bind_string}, + {"native_bind_blob", "(I[B)V", (void *)native_bind_blob}, + {"native_clear_bindings", "()V", (void *)native_clear_bindings}, + {"native_finalize", "()V", (void *)native_finalize}, +}; + +int register_android_database_SQLiteProgram(JNIEnv * env) +{ + jclass clazz; + + clazz = env->FindClass("android/database/sqlite/SQLiteProgram"); + if (clazz == NULL) { + LOGE("Can't find android/database/sqlite/SQLiteProgram"); + return -1; + } + + gHandleField = env->GetFieldID(clazz, "nHandle", "I"); + gStatementField = env->GetFieldID(clazz, "nStatement", "I"); + + if (gHandleField == NULL || gStatementField == NULL) { + LOGE("Error locating fields"); + return -1; + } + + return AndroidRuntime::registerNativeMethods(env, + "android/database/sqlite/SQLiteProgram", sMethods, NELEM(sMethods)); +} + +} // namespace android diff --git a/core/jni/android_database_SQLiteQuery.cpp b/core/jni/android_database_SQLiteQuery.cpp new file mode 100644 index 0000000..9458433 --- /dev/null +++ b/core/jni/android_database_SQLiteQuery.cpp @@ -0,0 +1,360 @@ +/* + * Copyright (C) 2006 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. + */ + +#undef LOG_TAG +#define LOG_TAG "Cursor" + +#include <jni.h> +#include <JNIHelp.h> +#include <android_runtime/AndroidRuntime.h> + +#include <sqlite3.h> + +#include <utils/Log.h> + +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +#include "CursorWindow.h" +#include "sqlite3_exception.h" + + +namespace android { + +sqlite3_stmt * compile(JNIEnv* env, jobject object, + sqlite3 * handle, jstring sqlString); + +// From android_database_CursorWindow.cpp +CursorWindow * get_window_from_object(JNIEnv * env, jobject javaWindow); + +static jfieldID gHandleField; +static jfieldID gStatementField; + + +#define GET_STATEMENT(env, object) \ + (sqlite3_stmt *)env->GetIntField(object, gStatementField) +#define GET_HANDLE(env, object) \ + (sqlite3 *)env->GetIntField(object, gHandleField) + +static int skip_rows(sqlite3_stmt *statement, int maxRows) { + int retryCount = 0; + for (int i = 0; i < maxRows; i++) { + int err = sqlite3_step(statement); + if (err == SQLITE_ROW){ + // do nothing + } else if (err == SQLITE_DONE) { + return i; + } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) { + // The table is locked, retry + LOG_WINDOW("Database locked, retrying"); + if (retryCount > 50) { + LOGE("Bailing on database busy rety"); + break; + } + // Sleep to give the thread holding the lock a chance to finish + usleep(1000); + retryCount++; + continue; + } else { + return -1; + } + } + LOGD("skip_rows row %d", maxRows); + return maxRows; +} + +static int finish_program_and_get_row_count(sqlite3_stmt *statement) { + int numRows = 0; + int retryCount = 0; + while (true) { + int err = sqlite3_step(statement); + if (err == SQLITE_ROW){ + numRows++; + } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) { + // The table is locked, retry + LOG_WINDOW("Database locked, retrying"); + if (retryCount > 50) { + LOGE("Bailing on database busy rety"); + break; + } + // Sleep to give the thread holding the lock a chance to finish + usleep(1000); + retryCount++; + continue; + } else { + // no need to throw exception + break; + } + } + sqlite3_reset(statement); + LOGD("finish_program_and_get_row_count row %d", numRows); + return numRows; +} + +static jint native_fill_window(JNIEnv* env, jobject object, jobject javaWindow, + jint startPos, jint offsetParam) +{ + int err; + sqlite3_stmt * statement = GET_STATEMENT(env, object); + int numRows = 0; + int numColumns; + int retryCount; + int boundParams; + CursorWindow * window; + + if (statement == NULL) { + LOGE("Invalid statement in fillWindow()"); + jniThrowException(env, "java/lang/IllegalStateException", + "Attempting to access a deactivated, closed, or empty cursor"); + return 0; + } + + // Only do the binding if there is a valid offsetParam. If no binding needs to be done + // offsetParam will be set to 0, an invliad value. + if(offsetParam > 0) { + // Bind the offset parameter, telling the program which row to start with + err = sqlite3_bind_int(statement, offsetParam, startPos); + if (err != SQLITE_OK) { + LOGE("Unable to bind offset position, offsetParam = %d", offsetParam); + jniThrowException(env, "java/lang/IllegalArgumentException", + sqlite3_errmsg(GET_HANDLE(env, object))); + return 0; + } + LOG_WINDOW("Bound to startPos %d", startPos); + } else { + LOG_WINDOW("Not binding to startPos %d", startPos); + } + + // Get the native window + window = get_window_from_object(env, javaWindow); + if (!window) { + LOGE("Invalid CursorWindow"); + jniThrowException(env, "java/lang/IllegalArgumentException", + "Bad CursorWindow"); + return 0; + } + LOG_WINDOW("Window: numRows = %d, size = %d, freeSpace = %d", window->getNumRows(), window->size(), window->freeSpace()); + + numColumns = sqlite3_column_count(statement); + if (!window->setNumColumns(numColumns)) { + LOGE("Failed to change column count from %d to %d", window->getNumColumns(), numColumns); + jniThrowException(env, "java/lang/IllegalStateException", "numColumns mismatch"); + return 0; + } + + retryCount = 0; + if (startPos > 0) { + int num = skip_rows(statement, startPos); + if (num < 0) { + throw_sqlite3_exception(env, GET_HANDLE(env, object)); + return 0; + } else if (num < startPos) { + LOGE("startPos %d > actual rows %d", startPos, num); + return num; + } + } + + while(true) { + err = sqlite3_step(statement); + if (err == SQLITE_ROW) { + LOG_WINDOW("\nStepped statement %p to row %d", statement, startPos + numRows); + retryCount = 0; + + // Allocate a new field directory for the row. This pointer is not reused + // since it mey be possible for it to be relocated on a call to alloc() when + // the field data is being allocated. + { + field_slot_t * fieldDir = window->allocRow(); + if (!fieldDir) { + LOGE("Failed allocating fieldDir at startPos %d row %d", startPos, numRows); + return startPos + numRows + finish_program_and_get_row_count(statement) + 1; + } + } + + // Pack the row into the window + int i; + for (i = 0; i < numColumns; i++) { + int type = sqlite3_column_type(statement, i); + if (type == SQLITE_TEXT) { + // TEXT data +#if WINDOW_STORAGE_UTF8 + uint8_t const * text = (uint8_t const *)sqlite3_column_text(statement, i); + // SQLite does not include the NULL terminator in size, but does + // ensure all strings are NULL terminated, so increase size by + // one to make sure we store the terminator. + size_t size = sqlite3_column_bytes(statement, i) + 1; +#else + uint8_t const * text = (uint8_t const *)sqlite3_column_text16(statement, i); + size_t size = sqlite3_column_bytes16(statement, i); +#endif + int offset = window->alloc(size); + if (!offset) { + window->freeLastRow(); + LOGE("Failed allocating %u bytes for text/blob at %d,%d", size, + startPos + numRows, i); + return startPos + numRows + finish_program_and_get_row_count(statement) + 1; + } + + window->copyIn(offset, text, size); + + // This must be updated after the call to alloc(), since that + // may move the field around in the window + field_slot_t * fieldSlot = window->getFieldSlot(numRows, i); + fieldSlot->type = FIELD_TYPE_STRING; + fieldSlot->data.buffer.offset = offset; + fieldSlot->data.buffer.size = size; + + LOG_WINDOW("%d,%d is TEXT with %u bytes", startPos + numRows, i, size); + } else if (type == SQLITE_INTEGER) { + // INTEGER data + int64_t value = sqlite3_column_int64(statement, i); + if (!window->putLong(numRows, i, value)) { + window->freeLastRow(); + LOGE("Failed allocating space for a long in column %d", i); + return startPos + numRows + finish_program_and_get_row_count(statement) + 1; + } + LOG_WINDOW("%d,%d is INTEGER 0x%016llx", startPos + numRows, i, value); + } else if (type == SQLITE_FLOAT) { + // FLOAT data + double value = sqlite3_column_double(statement, i); + if (!window->putDouble(numRows, i, value)) { + window->freeLastRow(); + LOGE("Failed allocating space for a double in column %d", i); + return startPos + numRows + finish_program_and_get_row_count(statement) + 1; + } + LOG_WINDOW("%d,%d is FLOAT %lf", startPos + numRows, i, value); + } else if (type == SQLITE_BLOB) { + // BLOB data + uint8_t const * blob = (uint8_t const *)sqlite3_column_blob(statement, i); + size_t size = sqlite3_column_bytes16(statement, i); + int offset = window->alloc(size); + if (!offset) { + window->freeLastRow(); + LOGE("Failed allocating %u bytes for blob at %d,%d", size, + startPos + numRows, i); + return startPos + numRows + finish_program_and_get_row_count(statement) + 1; + } + + window->copyIn(offset, blob, size); + + // This must be updated after the call to alloc(), since that + // may move the field around in the window + field_slot_t * fieldSlot = window->getFieldSlot(numRows, i); + fieldSlot->type = FIELD_TYPE_BLOB; + fieldSlot->data.buffer.offset = offset; + fieldSlot->data.buffer.size = size; + + LOG_WINDOW("%d,%d is Blob with %u bytes @ %d", startPos + numRows, i, size, offset); + } else if (type == SQLITE_NULL) { + // NULL field + window->putNull(numRows, i); + + LOG_WINDOW("%d,%d is NULL", startPos + numRows, i); + } else { + // Unknown data + LOGE("Unknown column type when filling database window"); + throw_sqlite3_exception(env, "Unknown column type when filling window"); + break; + } + } + + if (i < numColumns) { + // Not all the fields fit in the window + break; + } + + // Mark the row as complete in the window + numRows++; + } else if (err == SQLITE_DONE) { + // All rows processed, bail + LOG_WINDOW("Processed all rows"); + break; + } else if (err == SQLITE_LOCKED || err == SQLITE_BUSY) { + // The table is locked, retry + LOG_WINDOW("Database locked, retrying"); + if (retryCount > 50) { + LOGE("Bailing on database busy rety"); + break; + } + + // Sleep to give the thread holding the lock a chance to finish + usleep(1000); + + retryCount++; + continue; + } else { + throw_sqlite3_exception(env, GET_HANDLE(env, object)); + break; + } + } + + LOG_WINDOW("Resetting statement %p after fetching %d rows in %d bytes\n\n\n\n", statement, + numRows, window->size() - window->freeSpace()); +// LOGI("Filled window with %d rows in %d bytes", numRows, window->size() - window->freeSpace()); + sqlite3_reset(statement); + return startPos + numRows; +} + +static jint native_column_count(JNIEnv* env, jobject object) +{ + sqlite3_stmt * statement = GET_STATEMENT(env, object); + + return sqlite3_column_count(statement); +} + +static jstring native_column_name(JNIEnv* env, jobject object, jint columnIndex) +{ + sqlite3_stmt * statement = GET_STATEMENT(env, object); + char const * name; + + name = sqlite3_column_name(statement, columnIndex); + + return env->NewStringUTF(name); +} + + +static JNINativeMethod sMethods[] = +{ + /* name, signature, funcPtr */ + {"native_fill_window", "(Landroid/database/CursorWindow;II)I", (void *)native_fill_window}, + {"native_column_count", "()I", (void*)native_column_count}, + {"native_column_name", "(I)Ljava/lang/String;", (void *)native_column_name}, +}; + +int register_android_database_SQLiteQuery(JNIEnv * env) +{ + jclass clazz; + + clazz = env->FindClass("android/database/sqlite/SQLiteQuery"); + if (clazz == NULL) { + LOGE("Can't find android/database/sqlite/SQLiteQuery"); + return -1; + } + + gHandleField = env->GetFieldID(clazz, "nHandle", "I"); + gStatementField = env->GetFieldID(clazz, "nStatement", "I"); + + if (gHandleField == NULL || gStatementField == NULL) { + LOGE("Error locating fields"); + return -1; + } + + return AndroidRuntime::registerNativeMethods(env, + "android/database/sqlite/SQLiteQuery", sMethods, NELEM(sMethods)); +} + +} // namespace android diff --git a/core/jni/android_database_SQLiteStatement.cpp b/core/jni/android_database_SQLiteStatement.cpp new file mode 100644 index 0000000..b615895 --- /dev/null +++ b/core/jni/android_database_SQLiteStatement.cpp @@ -0,0 +1,149 @@ +/* //device/libs/android_runtime/android_database_SQLiteCursor.cpp +** +** Copyright 2006, 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. +*/ + +#undef LOG_TAG +#define LOG_TAG "Cursor" + +#include <jni.h> +#include <JNIHelp.h> +#include <android_runtime/AndroidRuntime.h> + +#include <sqlite3.h> + +#include <utils/Log.h> + +#include <stdio.h> +#include <string.h> +#include <unistd.h> + +#include "sqlite3_exception.h" + +namespace android { + + +sqlite3_stmt * compile(JNIEnv* env, jobject object, + sqlite3 * handle, jstring sqlString); + +static jfieldID gHandleField; +static jfieldID gStatementField; + + +#define GET_STATEMENT(env, object) \ + (sqlite3_stmt *)env->GetIntField(object, gStatementField) +#define GET_HANDLE(env, object) \ + (sqlite3 *)env->GetIntField(object, gHandleField) + + +static void native_execute(JNIEnv* env, jobject object) +{ + int err; + sqlite3 * handle = GET_HANDLE(env, object); + sqlite3_stmt * statement = GET_STATEMENT(env, object); + + // Execute the statement + err = sqlite3_step(statement); + + // Throw an exception if an error occured + if (err != SQLITE_DONE) { + throw_sqlite3_exception_errcode(env, err, NULL); + } + + // Reset the statment so it's ready to use again + sqlite3_reset(statement); +} + +static jlong native_1x1_long(JNIEnv* env, jobject object) +{ + int err; + sqlite3 * handle = GET_HANDLE(env, object); + sqlite3_stmt * statement = GET_STATEMENT(env, object); + jlong value = -1; + + // Execute the statement + err = sqlite3_step(statement); + + // Handle the result + if (err == SQLITE_ROW) { + // No errors, read the data and return it + value = sqlite3_column_int64(statement, 0); + } else { + throw_sqlite3_exception_errcode(env, err, NULL); + } + + // Reset the statment so it's ready to use again + sqlite3_reset(statement); + + return value; +} + +static jstring native_1x1_string(JNIEnv* env, jobject object) +{ + int err; + sqlite3 * handle = GET_HANDLE(env, object); + sqlite3_stmt * statement = GET_STATEMENT(env, object); + jstring value = NULL; + + // Execute the statement + err = sqlite3_step(statement); + + // Handle the result + if (err == SQLITE_ROW) { + // No errors, read the data and return it + char const * text = (char const *)sqlite3_column_text(statement, 0); + value = env->NewStringUTF(text); + } else { + throw_sqlite3_exception_errcode(env, err, NULL); + } + + // Reset the statment so it's ready to use again + sqlite3_reset(statement); + + return value; +} + + +static JNINativeMethod sMethods[] = +{ + /* name, signature, funcPtr */ + {"native_execute", "()V", (void *)native_execute}, + {"native_1x1_long", "()J", (void *)native_1x1_long}, + {"native_1x1_string", "()Ljava/lang/String;", (void *)native_1x1_string}, +}; + +int register_android_database_SQLiteStatement(JNIEnv * env) +{ + jclass clazz; + + clazz = env->FindClass("android/database/sqlite/SQLiteStatement"); + if (clazz == NULL) { + LOGE("Can't find android/database/sqlite/SQLiteStatement"); + return -1; + } + + gHandleField = env->GetFieldID(clazz, "nHandle", "I"); + gStatementField = env->GetFieldID(clazz, "nStatement", "I"); + + if (gHandleField == NULL || gStatementField == NULL) { + LOGE("Error locating fields"); + return -1; + } + + return AndroidRuntime::registerNativeMethods(env, + "android/database/sqlite/SQLiteStatement", sMethods, NELEM(sMethods)); +} + +} // namespace android diff --git a/core/jni/android_ddm_DdmHandleNativeHeap.cpp b/core/jni/android_ddm_DdmHandleNativeHeap.cpp new file mode 100644 index 0000000..c3b4e3c --- /dev/null +++ b/core/jni/android_ddm_DdmHandleNativeHeap.cpp @@ -0,0 +1,144 @@ +/* //device/libs/android_runtime/android_ddm_DdmHandleNativeHeap.cpp +** +** Copyright 2006, 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. +*/ + +#undef LOG_TAG +#define LOG_TAG "DdmHandleNativeHeap" + +#include <JNIHelp.h> +#include <jni.h> +#include <android_runtime/AndroidRuntime.h> + +#include <utils/Log.h> + +#include <fcntl.h> +#include <errno.h> +#include <sys/types.h> +#include <sys/stat.h> + +#if defined(__arm__) +extern "C" void get_malloc_leak_info(uint8_t** info, size_t* overallSize, + size_t* infoSize, size_t* totalMemory, size_t* backtraceSize); + +extern "C" void free_malloc_leak_info(uint8_t* info); +#endif + +#define MAPS_FILE_SIZE 65 * 1024 + +struct Header { + size_t mapSize; + size_t allocSize; + size_t allocInfoSize; + size_t totalMemory; + size_t backtraceSize; +}; + +namespace android { + +/* + * Retrieve the native heap information and the info from /proc/<self>/maps, + * copy them into a byte[] with a "struct Header" that holds data offsets, + * and return the array. + */ +static jbyteArray getLeakInfo(JNIEnv *env, jobject clazz) +{ +#if defined(__arm__) + // get the info in /proc/[pid]/map + Header header; + memset(&header, 0, sizeof(header)); + + pid_t pid = getpid(); + + char path[FILENAME_MAX]; + sprintf(path, "/proc/%d/maps", pid); + + struct stat sb; + int ret = stat(path, &sb); + + uint8_t* mapsFile = NULL; + if (ret == 0) { + mapsFile = (uint8_t*)malloc(MAPS_FILE_SIZE); + int fd = open(path, O_RDONLY); + + if (mapsFile != NULL && fd != -1) { + int amount = 0; + do { + uint8_t* ptr = mapsFile + header.mapSize; + amount = read(fd, ptr, MAPS_FILE_SIZE); + if (amount <= 0) { + if (errno != EINTR) + break; + else + continue; + } + header.mapSize += amount; + } while (header.mapSize < MAPS_FILE_SIZE); + + LOGD("**** read %d bytes from '%s'", (int) header.mapSize, path); + } + } + + uint8_t* allocBytes; + get_malloc_leak_info(&allocBytes, &header.allocSize, &header.allocInfoSize, + &header.totalMemory, &header.backtraceSize); + + jbyte* bytes = NULL; + jbyte* ptr = NULL; + jbyteArray array = env->NewByteArray(sizeof(Header) + header.mapSize + header.allocSize); + if (array == NULL) { + goto done; + } + + bytes = env->GetByteArrayElements(array, NULL); + ptr = bytes; + +// LOGD("*** mapSize: %d allocSize: %d allocInfoSize: %d totalMemory: %d", +// header.mapSize, header.allocSize, header.allocInfoSize, header.totalMemory); + + memcpy(ptr, &header, sizeof(header)); + ptr += sizeof(header); + + if (header.mapSize > 0 && mapsFile != NULL) { + memcpy(ptr, mapsFile, header.mapSize); + ptr += header.mapSize; + } + + memcpy(ptr, allocBytes, header.allocSize); + env->ReleaseByteArrayElements(array, bytes, 0); + +done: + if (mapsFile != NULL) { + free(mapsFile); + } + // free the info up! + free_malloc_leak_info(allocBytes); + + return array; +#else + return NULL; +#endif +} + +static JNINativeMethod method_table[] = { + { "getLeakInfo", "()[B", (void*)getLeakInfo }, +}; + +int register_android_ddm_DdmHandleNativeHeap(JNIEnv *env) +{ + return AndroidRuntime::registerNativeMethods(env, "android/ddm/DdmHandleNativeHeap", method_table, NELEM(method_table)); +} + +}; diff --git a/core/jni/android_debug_JNITest.cpp b/core/jni/android_debug_JNITest.cpp new file mode 100644 index 0000000..f14201e --- /dev/null +++ b/core/jni/android_debug_JNITest.cpp @@ -0,0 +1,119 @@ +/* //device/libs/android_runtime/android_debug_JNITest.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "DebugJNI" + +#include "jni.h" +#include "nativehelper/JNIHelp.h" +#include "utils/Log.h" +#include "utils/misc.h" +//#include "android_runtime/AndroidRuntime.h" + +namespace android { + +/* + * Implements: + * native int part1(int intArg, double doubleArg, String stringArg, + * int[] arrayArg) + */ +static jint android_debug_JNITest_part1(JNIEnv* env, jobject object, + jint intArg, jdouble doubleArg, jstring stringArg, jobjectArray arrayArg) +{ + jclass clazz; + jmethodID part2id; + jsize arrayLen; + jint arrayVal; + int result = -2; + + LOGI("JNI test: in part1, intArg=%d, doubleArg=%.3f\n", intArg, doubleArg); + + /* find "int part2(double doubleArg, int fromArray, String stringArg)" */ + clazz = env->GetObjectClass(object); + part2id = env->GetMethodID(clazz, + "part2", "(DILjava/lang/String;)I"); + if (part2id == NULL) { + LOGE("JNI test: unable to find part2\n"); + return -1; + } + + /* get the length of the array */ + arrayLen = env->GetArrayLength(arrayArg); + LOGI(" array size is %d\n", arrayLen); + + /* + * Get the last element in the array. + * Use the Get<type>ArrayElements functions instead if you need access + * to multiple elements. + */ + arrayVal = (int) env->GetObjectArrayElement(arrayArg, arrayLen-1); + LOGI(" array val is %d\n", arrayVal); + + /* call this->part2 */ + result = env->CallIntMethod(object, part2id, + doubleArg, arrayVal, stringArg); + + return result; +} + +/* + * Implements: + * private static native int part3(String stringArg); + */ +static jint android_debug_JNITest_part3(JNIEnv* env, jclass clazz, + jstring stringArg) +{ + const char* utfChars; + jboolean isCopy; + + LOGI("JNI test: in part3\n"); + + utfChars = env->GetStringUTFChars(stringArg, &isCopy); + + LOGI(" String is '%s', isCopy=%d\n", (const char*) utfChars, isCopy); + + env->ReleaseStringUTFChars(stringArg, utfChars); + + return 2000; +} + +/* + * JNI registration. + */ +static JNINativeMethod gMethods[] = { + /* name, signature, funcPtr */ + { "part1", "(IDLjava/lang/String;[I)I", + (void*) android_debug_JNITest_part1 }, + { "part3", "(Ljava/lang/String;)I", + (void*) android_debug_JNITest_part3 }, +}; +int register_android_debug_JNITest(JNIEnv* env) +{ + return jniRegisterNativeMethods(env, "android/debug/JNITest", + gMethods, NELEM(gMethods)); +} + +#if 0 +/* trampoline into C++ */ +extern "C" +int register_android_debug_JNITest_C(JNIEnv* env) +{ + return android::register_android_debug_JNITest(env); +} +#endif + +}; // namespace android + diff --git a/core/jni/android_graphics_PixelFormat.cpp b/core/jni/android_graphics_PixelFormat.cpp new file mode 100644 index 0000000..0643622 --- /dev/null +++ b/core/jni/android_graphics_PixelFormat.cpp @@ -0,0 +1,85 @@ +/* + * Copyright (C) 2007 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. + */ + +#include <stdio.h> +#include <assert.h> + +#include <ui/PixelFormat.h> + +#include "jni.h" +#include <android_runtime/AndroidRuntime.h> +#include <utils/misc.h> + +// ---------------------------------------------------------------------------- + +namespace android { + +// ---------------------------------------------------------------------------- + +struct offsets_t { + jfieldID bytesPerPixel; + jfieldID bitsPerPixel; +}; + +static offsets_t offsets; + +static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL) +{ + jclass npeClazz = env->FindClass(exc); + env->ThrowNew(npeClazz, msg); +} + +// ---------------------------------------------------------------------------- + +static void android_graphics_getPixelFormatInfo( + JNIEnv* env, jobject clazz, jint format, jobject pixelFormatObject) +{ + PixelFormatInfo info; + status_t err = getPixelFormatInfo(format, &info); + if (err < 0) { + doThrow(env, "java/lang/IllegalArgumentException"); + return; + } + env->SetIntField(pixelFormatObject, offsets.bytesPerPixel, info.bytesPerPixel); + env->SetIntField(pixelFormatObject, offsets.bitsPerPixel, info.bitsPerPixel); +} +// ---------------------------------------------------------------------------- + +const char* const kClassPathName = "android/graphics/PixelFormat"; + +static void nativeClassInit(JNIEnv* env, jclass clazz); + +static JNINativeMethod gMethods[] = { + { "nativeClassInit", "()V", + (void*)nativeClassInit }, + { "getPixelFormatInfo", "(ILandroid/graphics/PixelFormat;)V", + (void*)android_graphics_getPixelFormatInfo + } +}; + +void nativeClassInit(JNIEnv* env, jclass clazz) +{ + offsets.bytesPerPixel = env->GetFieldID(clazz, "bytesPerPixel", "I"); + offsets.bitsPerPixel = env->GetFieldID(clazz, "bitsPerPixel", "I"); +} + +int register_android_graphics_PixelFormat(JNIEnv* env) +{ + return AndroidRuntime::registerNativeMethods(env, + kClassPathName, gMethods, NELEM(gMethods)); +} + +}; diff --git a/core/jni/android_hardware_Camera.cpp b/core/jni/android_hardware_Camera.cpp new file mode 100644 index 0000000..a29c27b --- /dev/null +++ b/core/jni/android_hardware_Camera.cpp @@ -0,0 +1,451 @@ +/* +** +** Copyright 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. +*/ + +#define LOG_TAG "Camera-JNI" + +#include "jni.h" +#include "JNIHelp.h" +#include "android_runtime/AndroidRuntime.h" + +#include <ui/Surface.h> +#include <ui/Camera.h> +#include <utils/IMemory.h> + +using namespace android; + +enum CallbackMessageID { + kShutterCallback = 0, + kRawCallback = 1, + kJpegCallback = 2, + kPreviewCallback = 3, + kAutoFocusCallback = 4, + kErrorCallback = 5 +}; + +enum CameraError { + kCameraErrorUnknown = 1, + kCameraErrorMediaServer = 100 +}; + + +struct fields_t { + jfieldID context; + jfieldID surface; + jfieldID listener_context; + jmethodID post_event; +}; + +static fields_t fields; + +struct callback_cookie { + jclass camera_class; + jobject camera_ref; +}; + +static Camera *get_native_camera(JNIEnv *env, jobject thiz) +{ + Camera *c = reinterpret_cast<Camera*>(env->GetIntField(thiz, fields.context)); + if (c == 0) + jniThrowException(env, "java/lang/RuntimeException", "Method called after release()"); + + return c; +} + +static void err_callback(status_t err, void *cookie) +{ + JNIEnv *env = AndroidRuntime::getJNIEnv(); + callback_cookie *c = (callback_cookie *)cookie; + int error; + + switch (err) { + case DEAD_OBJECT: + error = kCameraErrorMediaServer; + break; + default: + error = kCameraErrorUnknown; + break; + } + LOGV("err_callback: camera_ref=%x, cookie=%x", (int)c->camera_ref, (int)cookie); + + env->CallStaticVoidMethod(c->camera_class, fields.post_event, + c->camera_ref, kErrorCallback, error, 0, NULL); +} + +// connect to camera service +static void android_hardware_Camera_native_setup(JNIEnv *env, jobject thiz, jobject weak_this) +{ + sp<Camera> c = Camera::connect(); + + if (c == NULL) { + jniThrowException(env, "java/lang/RuntimeException", "Out of memory"); + return; + } + + // make sure camera hardware is alive + if (c->getStatus() != NO_ERROR) { + jniThrowException(env, "java/io/IOException", "Camera initialization failed"); + return; + } + + callback_cookie *cookie = new callback_cookie; + jclass clazz = env->GetObjectClass(thiz); + if (clazz == NULL) { + LOGE("Can't find android/hardware/Camera"); + // XXX no idea what to throw here, can this even happen? + jniThrowException(env, "java/lang/Exception", NULL); + return; + } + cookie->camera_class = (jclass)env->NewGlobalRef(clazz); + + // We use a weak reference so the Camera object can be garbage collected. + // The reference is only used as a proxy for callbacks. + cookie->camera_ref = env->NewGlobalRef(weak_this); + env->SetIntField(thiz, fields.listener_context, (int)cookie); + + LOGV("native_setup: camera_ref=%x, camera_obj=%x, cookie=%x", (int)cookie->camera_ref, (int)thiz, (int)cookie); + + // save camera object in opaque field + env->SetIntField(thiz, fields.context, reinterpret_cast<int>(c.get())); + + c->setErrorCallback(err_callback, cookie); + + // hold a strong reference so this doesn't go away while the app is still running + c->incStrong(thiz); +} + +// disconnect from camera service +static void android_hardware_Camera_release(JNIEnv *env, jobject thiz) +{ + sp<Camera> c = reinterpret_cast<Camera*>(env->GetIntField(thiz, fields.context)); + // It's okay to call this when the native camera context is already null. + // This handles the case where the user has called release() and the + // finalizer is invoked later. + if (c != 0) { + c->disconnect(); + + // remove our strong reference created in native setup + c->decStrong(thiz); + env->SetIntField(thiz, fields.context, 0); + + callback_cookie *cookie = (callback_cookie *)env->GetIntField(thiz, fields.listener_context); + + LOGV("release: camera_ref=%x, camera_obj=%x, cookie=%x", (int)cookie->camera_ref, (int)thiz, (int)cookie); + + if (cookie) { + env->DeleteGlobalRef(cookie->camera_ref); + env->DeleteGlobalRef(cookie->camera_class); + delete cookie; + env->SetIntField(thiz, fields.listener_context, 0); + } + } +} + +static void android_hardware_Camera_setPreviewDisplay(JNIEnv *env, jobject thiz, jobject surface) +{ + Camera *c = get_native_camera(env, thiz); + if (c == 0) + return; + + sp<Surface> s = (Surface *)env->GetIntField(surface, fields.surface); + if (c->setPreviewDisplay(s) != NO_ERROR) { + jniThrowException(env, "java/io/IOException", "setPreviewDisplay failed"); + return; + } +} + +static void preview_callback(const sp<IMemory>& mem, void *cookie) +{ + JNIEnv *env = AndroidRuntime::getJNIEnv(); + callback_cookie *c = (callback_cookie *)cookie; + int arg1 = 0, arg2 = 0; + jobject obj = NULL; + + ssize_t offset; + size_t size; + sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); + + uint8_t *data = ((uint8_t *)heap->base()) + offset; + + jbyteArray array = env->NewByteArray(size); + if (array == NULL) { + LOGE("Couldn't allocate byte array for YUV data"); + return; + } + + jbyte *bytes = env->GetByteArrayElements(array, NULL); + memcpy(bytes, data, size); + env->ReleaseByteArrayElements(array, bytes, 0); + + obj = array; + + env->CallStaticVoidMethod(c->camera_class, fields.post_event, + c->camera_ref, kPreviewCallback, arg1, arg2, obj); + env->DeleteLocalRef(array); +} + +static void android_hardware_Camera_startPreview(JNIEnv *env, jobject thiz) +{ + Camera *c = get_native_camera(env, thiz); + if (c == 0) + return; + + if (c->startPreview() != NO_ERROR) { + jniThrowException(env, "java/io/IOException", "startPreview failed"); + return; + } +} + +static void android_hardware_Camera_stopPreview(JNIEnv *env, jobject thiz) +{ + Camera *c = get_native_camera(env, thiz); + if (c == 0) + return; + + c->stopPreview(); +} + +static void android_hardware_Camera_setHasPreviewCallback(JNIEnv *env, jobject thiz, jboolean installed) +{ + Camera *c = get_native_camera(env, thiz); + if (c == 0) + return; + + // Important: Only install preview_callback if the Java code has called + // setPreviewCallback() with a non-null value, otherwise we'd pay to memcpy + // each preview frame for nothing. + callback_cookie *cookie = (callback_cookie *)env->GetIntField(thiz, fields.listener_context); + c->setFrameCallback(installed ? preview_callback : NULL, cookie); +} + +static void autofocus_callback_impl(bool success, void *cookie) +{ + JNIEnv *env = AndroidRuntime::getJNIEnv(); + callback_cookie *c = (callback_cookie *)cookie; + env->CallStaticVoidMethod(c->camera_class, fields.post_event, + c->camera_ref, kAutoFocusCallback, + success, 0, NULL); +} + + + +static void android_hardware_Camera_autoFocus(JNIEnv *env, jobject thiz) +{ + Camera *c = get_native_camera(env, thiz); + if (c == 0) + return; + callback_cookie *cookie = (callback_cookie *)env->GetIntField(thiz, fields.listener_context); + c->setAutoFocusCallback(autofocus_callback_impl, cookie); + if (c->autoFocus() != NO_ERROR) { + jniThrowException(env, "java/io/IOException", "autoFocus failed"); + } +} + +static void jpeg_callback(const sp<IMemory>& mem, void *cookie) +{ + JNIEnv *env = AndroidRuntime::getJNIEnv(); + callback_cookie *c = (callback_cookie *)cookie; + int arg1 = 0, arg2 = 0; + jobject obj = NULL; + + if (mem == NULL) { + env->CallStaticVoidMethod(c->camera_class, fields.post_event, + c->camera_ref, kJpegCallback, arg1, arg2, NULL); + return; + } + ssize_t offset; + size_t size; + sp<IMemoryHeap> heap = mem->getMemory(&offset, &size); + LOGV("jpeg_callback: mem off=%d, size=%d", offset, size); + + uint8_t *heap_base = (uint8_t *)heap->base(); + if (heap_base == NULL) { + LOGE("YUV heap is NULL"); + return; + } + + uint8_t *data = heap_base + offset; + + jbyteArray array = env->NewByteArray(size); + if (array == NULL) { + LOGE("Couldn't allocate byte array for JPEG data"); + return; + } + + jbyte *bytes = env->GetByteArrayElements(array, NULL); + memcpy(bytes, data, size); + env->ReleaseByteArrayElements(array, bytes, 0); + + obj = array; + + env->CallStaticVoidMethod(c->camera_class, fields.post_event, + c->camera_ref, kJpegCallback, arg1, arg2, obj); + env->DeleteLocalRef(array); +} + +static void shutter_callback_impl(void *cookie) +{ + JNIEnv *env = AndroidRuntime::getJNIEnv(); + callback_cookie *c = (callback_cookie *)cookie; + env->CallStaticVoidMethod(c->camera_class, fields.post_event, + c->camera_ref, kShutterCallback, 0, 0, NULL); +} + +static void raw_callback(const sp<IMemory>& mem __attribute__((unused)), + void *cookie) +{ + JNIEnv *env = AndroidRuntime::getJNIEnv(); + callback_cookie *c = (callback_cookie *)cookie; + env->CallStaticVoidMethod(c->camera_class, fields.post_event, + c->camera_ref, kRawCallback, 0, 0, NULL); +} + +static void android_hardware_Camera_takePicture(JNIEnv *env, jobject thiz) +{ + Camera *c = get_native_camera(env, thiz); + if (c == 0) + return; + + callback_cookie *cookie = + (callback_cookie *)env->GetIntField(thiz, fields.listener_context); + c->setShutterCallback(shutter_callback_impl, cookie); + c->setRawCallback(raw_callback, cookie); + c->setJpegCallback(jpeg_callback, cookie); + if (c->takePicture() != NO_ERROR) { + jniThrowException(env, "java/io/IOException", "takePicture failed"); + return; + } + + return; +} + +static void android_hardware_Camera_setParameters(JNIEnv *env, jobject thiz, jstring params) +{ + Camera *c = get_native_camera(env, thiz); + if (c == 0) + return; + + const jchar* str = env->GetStringCritical(params, 0); + String8 params8; + if (params) { + params8 = String8(str, env->GetStringLength(params)); + env->ReleaseStringCritical(params, str); + } + if (c->setParameters(params8) != NO_ERROR) { + jniThrowException(env, "java/io/IllegalArgumentException", "setParameters failed"); + return; + } +} + +static jstring android_hardware_Camera_getParameters(JNIEnv *env, jobject thiz) +{ + Camera *c = get_native_camera(env, thiz); + if (c == 0) + return 0; + + return env->NewStringUTF(c->getParameters().string()); +} + +//------------------------------------------------- + +static JNINativeMethod camMethods[] = { + { "native_setup", + "(Ljava/lang/Object;)V", + (void*)android_hardware_Camera_native_setup }, + { "native_release", + "()V", + (void*)android_hardware_Camera_release }, + { "setPreviewDisplay", + "(Landroid/view/Surface;)V", + (void *)android_hardware_Camera_setPreviewDisplay }, + { "startPreview", + "()V", + (void *)android_hardware_Camera_startPreview }, + { "stopPreview", + "()V", + (void *)android_hardware_Camera_stopPreview }, + { "setHasPreviewCallback", + "(Z)V", + (void *)android_hardware_Camera_setHasPreviewCallback }, + { "native_autoFocus", + "()V", + (void *)android_hardware_Camera_autoFocus }, + { "native_takePicture", + "()V", + (void *)android_hardware_Camera_takePicture }, + { "native_setParameters", + "(Ljava/lang/String;)V", + (void *)android_hardware_Camera_setParameters }, + { "native_getParameters", + "()Ljava/lang/String;", + (void *)android_hardware_Camera_getParameters } +}; + +struct field { + const char *class_name; + const char *field_name; + const char *field_type; + jfieldID *jfield; +}; + +static int find_fields(JNIEnv *env, field *fields, int count) +{ + for (int i = 0; i < count; i++) { + field *f = &fields[i]; + jclass clazz = env->FindClass(f->class_name); + if (clazz == NULL) { + LOGE("Can't find %s", f->class_name); + return -1; + } + + jfieldID field = env->GetFieldID(clazz, f->field_name, f->field_type); + if (field == NULL) { + LOGE("Can't find %s.%s", f->class_name, f->field_name); + return -1; + } + + *(f->jfield) = field; + } + + return 0; +} + +// Get all the required offsets in java class and register native functions +int register_android_hardware_Camera(JNIEnv *env) +{ + field fields_to_find[] = { + { "android/hardware/Camera", "mNativeContext", "I", &fields.context }, + { "android/hardware/Camera", "mListenerContext", "I", &fields.listener_context }, + { "android/view/Surface", "mSurface", "I", &fields.surface } + }; + + if (find_fields(env, fields_to_find, NELEM(fields_to_find)) < 0) + return -1; + + jclass clazz = env->FindClass("android/hardware/Camera"); + fields.post_event = env->GetStaticMethodID(clazz, "postEventFromNative", + "(Ljava/lang/Object;IIILjava/lang/Object;)V"); + if (fields.post_event == NULL) { + LOGE("Can't find android/hardware/Camera.postEventFromNative"); + return -1; + } + + + // Register native functions + return AndroidRuntime::registerNativeMethods(env, "android/hardware/Camera", + camMethods, NELEM(camMethods)); +} + diff --git a/core/jni/android_hardware_SensorManager.cpp b/core/jni/android_hardware_SensorManager.cpp new file mode 100644 index 0000000..e8dcd71 --- /dev/null +++ b/core/jni/android_hardware_SensorManager.cpp @@ -0,0 +1,82 @@ +/* + * Copyright 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. + */ + +#define LOG_TAG "Sensors" + +#include <hardware/sensors.h> + +#include "jni.h" +#include "JNIHelp.h" + + +namespace android { + +/* + * The method below are not thread-safe and not intended to be + */ + +static jint +android_data_open(JNIEnv *env, jclass clazz, jobject fdo) +{ + jclass FileDescriptor = env->FindClass("java/io/FileDescriptor"); + jfieldID offset = env->GetFieldID(FileDescriptor, "descriptor", "I"); + int fd = env->GetIntField(fdo, offset); + return sensors_data_open(fd); // doesn't take ownership of fd +} + +static jint +android_data_close(JNIEnv *env, jclass clazz) +{ + return sensors_data_close(); +} + +static jint +android_data_poll(JNIEnv *env, jclass clazz, jfloatArray values, jint sensors) +{ + sensors_data_t data; + int res = sensors_data_poll(&data, sensors); + if (res) { + env->SetFloatArrayRegion(values, 0, 3, data.vector.v); + // return the sensor's number + res = 31 - __builtin_clz(res); + // and its status in the top 4 bits + res |= data.vector.status << 28; + } + return res; +} + +static jint +android_data_get_sensors(JNIEnv *env, jclass clazz) +{ + return sensors_data_get_sensors(); +} + +static JNINativeMethod gMethods[] = { + {"_sensors_data_open", "(Ljava/io/FileDescriptor;)I", (void*) android_data_open }, + {"_sensors_data_close", "()I", (void*) android_data_close }, + {"_sensors_data_poll", "([FI)I", (void*) android_data_poll }, + {"_sensors_data_get_sensors","()I", (void*) android_data_get_sensors }, +}; + +}; // namespace android + +using namespace android; + +int register_android_hardware_SensorManager(JNIEnv *env) +{ + return jniRegisterNativeMethods(env, "android/hardware/SensorManager", + gMethods, NELEM(gMethods)); +} diff --git a/core/jni/android_location_GpsLocationProvider.cpp b/core/jni/android_location_GpsLocationProvider.cpp new file mode 100644 index 0000000..264cc51 --- /dev/null +++ b/core/jni/android_location_GpsLocationProvider.cpp @@ -0,0 +1,293 @@ +/* + * 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. + */ + +#define LOG_TAG "GpsLocationProvider" + +#include "JNIHelp.h" +#include "jni.h" +#include "hardware/gps.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <string.h> +#include <pthread.h> + + +static pthread_mutex_t sEventMutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_cond_t sEventCond = PTHREAD_COND_INITIALIZER; +static jmethodID method_reportLocation; +static jmethodID method_reportStatus; +static jmethodID method_reportSvStatus; +static jmethodID method_xtraDownloadRequest; + +static const GpsInterface* sGpsInterface = NULL; +static const GpsXtraInterface* sGpsXtraInterface = NULL; + +// data written to by GPS callbacks +static GpsLocation sGpsLocation; +static GpsStatus sGpsStatus; +static GpsSvStatus sGpsSvStatus; + +// a copy of the data shared by android_location_GpsLocationProvider_wait_for_event +// and android_location_GpsLocationProvider_read_status +static GpsLocation sGpsLocationCopy; +static GpsStatus sGpsStatusCopy; +static GpsSvStatus sGpsSvStatusCopy; + +enum CallbackType { + kLocation = 1, + kStatus = 2, + kSvStatus = 4, + kXtraDownloadRequest = 8, + kDisableRequest = 16, +}; +static int sPendingCallbacks; + +namespace android { + +static void location_callback(GpsLocation* location) +{ + pthread_mutex_lock(&sEventMutex); + + sPendingCallbacks |= kLocation; + memcpy(&sGpsLocation, location, sizeof(sGpsLocation)); + + pthread_cond_signal(&sEventCond); + pthread_mutex_unlock(&sEventMutex); +} + +static void status_callback(GpsStatus* status) +{ + pthread_mutex_lock(&sEventMutex); + + sPendingCallbacks |= kStatus; + memcpy(&sGpsStatus, status, sizeof(sGpsStatus)); + + pthread_cond_signal(&sEventCond); + pthread_mutex_unlock(&sEventMutex); +} + +static void sv_status_callback(GpsSvStatus* sv_status) +{ + pthread_mutex_lock(&sEventMutex); + + sPendingCallbacks |= kSvStatus; + memcpy(&sGpsSvStatus, sv_status, sizeof(GpsSvStatus)); + + pthread_cond_signal(&sEventCond); + pthread_mutex_unlock(&sEventMutex); +} + +GpsCallbacks sGpsCallbacks = { + location_callback, + status_callback, + sv_status_callback, +}; + +static void +download_request_callback() +{ + pthread_mutex_lock(&sEventMutex); + sPendingCallbacks |= kXtraDownloadRequest; + pthread_cond_signal(&sEventCond); + pthread_mutex_unlock(&sEventMutex); +} + +GpsXtraCallbacks sGpsXtraCallbacks = { + download_request_callback, +}; + + +static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env, jclass clazz) { + method_reportLocation = env->GetMethodID(clazz, "reportLocation", "(IDDDFFFJ)V"); + method_reportStatus = env->GetMethodID(clazz, "reportStatus", "(I)V"); + method_reportSvStatus = env->GetMethodID(clazz, "reportSvStatus", "()V"); + method_xtraDownloadRequest = env->GetMethodID(clazz, "xtraDownloadRequest", "()V"); +} + +static jboolean android_location_GpsLocationProvider_is_supported(JNIEnv* env, jclass clazz) { + if (!sGpsInterface) + sGpsInterface = gps_get_interface(); + return (sGpsInterface != NULL); +} + +static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj) +{ + if (!sGpsInterface) + sGpsInterface = gps_get_interface(); + return (sGpsInterface && sGpsInterface->init(&sGpsCallbacks) == 0); +} + +static void android_location_GpsLocationProvider_disable(JNIEnv* env, jobject obj) +{ + pthread_mutex_lock(&sEventMutex); + sPendingCallbacks |= kDisableRequest; + pthread_cond_signal(&sEventCond); + pthread_mutex_unlock(&sEventMutex); +} + +static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject obj) +{ + sGpsInterface->cleanup(); +} + +static jboolean android_location_GpsLocationProvider_start(JNIEnv* env, jobject obj, jboolean singleFix, jint fixFrequency) +{ + int result = sGpsInterface->set_position_mode(GPS_POSITION_MODE_STANDALONE, (singleFix ? 0 : fixFrequency)); + if (result) { + return result; + } + + return (sGpsInterface->start() == 0); +} + +static jboolean android_location_GpsLocationProvider_stop(JNIEnv* env, jobject obj) +{ + return (sGpsInterface->stop() == 0); +} + +static void android_location_GpsLocationProvider_set_fix_frequency(JNIEnv* env, jobject obj, jint fixFrequency) +{ + if (sGpsInterface->set_fix_frequency) + sGpsInterface->set_fix_frequency(fixFrequency); +} + +static void android_location_GpsLocationProvider_delete_aiding_data(JNIEnv* env, jobject obj, jint flags) +{ + sGpsInterface->delete_aiding_data(flags); +} + +static void android_location_GpsLocationProvider_wait_for_event(JNIEnv* env, jobject obj) +{ + pthread_mutex_lock(&sEventMutex); + pthread_cond_wait(&sEventCond, &sEventMutex); + + // copy and clear the callback flags + int pendingCallbacks = sPendingCallbacks; + sPendingCallbacks = 0; + + // copy everything and unlock the mutex before calling into Java code to avoid the possibility + // of timeouts in the GPS engine. + memcpy(&sGpsLocationCopy, &sGpsLocation, sizeof(sGpsLocationCopy)); + memcpy(&sGpsStatusCopy, &sGpsStatus, sizeof(sGpsStatusCopy)); + memcpy(&sGpsSvStatusCopy, &sGpsSvStatus, sizeof(sGpsSvStatusCopy)); + pthread_mutex_unlock(&sEventMutex); + + if (pendingCallbacks & kLocation) { + env->CallVoidMethod(obj, method_reportLocation, sGpsLocationCopy.flags, + (jdouble)sGpsLocationCopy.latitude, (jdouble)sGpsLocationCopy.longitude, + (jdouble)sGpsLocationCopy.altitude, + (jfloat)sGpsLocationCopy.speed, (jfloat)sGpsLocationCopy.bearing, + (jfloat)sGpsLocationCopy.accuracy, (jlong)sGpsLocationCopy.timestamp); + } + if (pendingCallbacks & kStatus) { + env->CallVoidMethod(obj, method_reportStatus, sGpsStatusCopy.status); + } + if (pendingCallbacks & kSvStatus) { + env->CallVoidMethod(obj, method_reportSvStatus); + } + if (pendingCallbacks & kXtraDownloadRequest) { + env->CallVoidMethod(obj, method_xtraDownloadRequest); + } + if (pendingCallbacks & kDisableRequest) { + // don't need to do anything - we are just poking so wait_for_event will return. + } +} + +static jint android_location_GpsLocationProvider_read_sv_status(JNIEnv* env, jobject obj, + jintArray prnArray, jfloatArray snrArray, jfloatArray elevArray, jfloatArray azumArray, + jintArray maskArray) +{ + // this should only be called from within a call to reportStatus, so we don't need to lock here + + jint* prns = env->GetIntArrayElements(prnArray, 0); + jfloat* snrs = env->GetFloatArrayElements(snrArray, 0); + jfloat* elev = env->GetFloatArrayElements(elevArray, 0); + jfloat* azim = env->GetFloatArrayElements(azumArray, 0); + jint* mask = env->GetIntArrayElements(maskArray, 0); + + int num_svs = sGpsSvStatusCopy.num_svs; + for (int i = 0; i < num_svs; i++) { + prns[i] = sGpsSvStatusCopy.sv_list[i].prn; + snrs[i] = sGpsSvStatusCopy.sv_list[i].snr; + elev[i] = sGpsSvStatusCopy.sv_list[i].elevation; + azim[i] = sGpsSvStatusCopy.sv_list[i].azimuth; + } + mask[0] = sGpsSvStatusCopy.ephemeris_mask; + mask[1] = sGpsSvStatusCopy.almanac_mask; + mask[2] = sGpsSvStatusCopy.used_in_fix_mask; + + env->ReleaseIntArrayElements(prnArray, prns, 0); + env->ReleaseFloatArrayElements(snrArray, snrs, 0); + env->ReleaseFloatArrayElements(elevArray, elev, 0); + env->ReleaseFloatArrayElements(azumArray, azim, 0); + env->ReleaseIntArrayElements(maskArray, mask, 0); + return num_svs; +} + +static void android_location_GpsLocationProvider_inject_time(JNIEnv* env, jobject obj, jlong time, + jlong timeReference, jint uncertainty) +{ + sGpsInterface->inject_time(time, timeReference, uncertainty); +} + +static jboolean android_location_GpsLocationProvider_supports_xtra(JNIEnv* env, jobject obj) +{ + if (!sGpsXtraInterface) { + sGpsXtraInterface = (const GpsXtraInterface*)sGpsInterface->get_extension(GPS_XTRA_INTERFACE); + if (sGpsXtraInterface) { + int result = sGpsXtraInterface->init(&sGpsXtraCallbacks); + if (result) { + sGpsXtraInterface = NULL; + } + } + } + + return (sGpsXtraInterface != NULL); +} + +static void android_location_GpsLocationProvider_inject_xtra_data(JNIEnv* env, jobject obj, + jbyteArray data, jint length) +{ + jbyte* bytes = env->GetByteArrayElements(data, 0); + sGpsXtraInterface->inject_xtra_data((char *)bytes, length); + env->ReleaseByteArrayElements(data, bytes, 0); +} + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + {"class_init_native", "()V", (void *)android_location_GpsLocationProvider_class_init_native}, + {"native_is_supported", "()Z", (void*)android_location_GpsLocationProvider_is_supported}, + {"native_init", "()Z", (void*)android_location_GpsLocationProvider_init}, + {"native_disable", "()V", (void*)android_location_GpsLocationProvider_disable}, + {"native_cleanup", "()V", (void*)android_location_GpsLocationProvider_cleanup}, + {"native_start", "(ZI)Z", (void*)android_location_GpsLocationProvider_start}, + {"native_stop", "()Z", (void*)android_location_GpsLocationProvider_stop}, + {"native_set_fix_frequency", "(I)V", (void*)android_location_GpsLocationProvider_set_fix_frequency}, + {"native_delete_aiding_data", "(I)V", (void*)android_location_GpsLocationProvider_delete_aiding_data}, + {"native_wait_for_event", "()V", (void*)android_location_GpsLocationProvider_wait_for_event}, + {"native_read_sv_status", "([I[F[F[F[I)I", (void*)android_location_GpsLocationProvider_read_sv_status}, + {"native_inject_time", "(JJI)V", (void*)android_location_GpsLocationProvider_inject_time}, + {"native_supports_xtra", "()Z", (void*)android_location_GpsLocationProvider_supports_xtra}, + {"native_inject_xtra_data", "([BI)V", (void*)android_location_GpsLocationProvider_inject_xtra_data}, +}; + +int register_android_location_GpsLocationProvider(JNIEnv* env) +{ + return jniRegisterNativeMethods(env, "com/android/internal/location/GpsLocationProvider", sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/android_media_AudioSystem.cpp b/core/jni/android_media_AudioSystem.cpp new file mode 100644 index 0000000..99785a2 --- /dev/null +++ b/core/jni/android_media_AudioSystem.cpp @@ -0,0 +1,186 @@ +/* //device/libs/android_runtime/android_media_AudioSystem.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "AudioSystem" +#include "utils/Log.h" + +#include <stdio.h> +#include <unistd.h> +#include <fcntl.h> +#include <math.h> + +#include "jni.h" +#include "JNIHelp.h" +#include "android_runtime/AndroidRuntime.h" + +#include <media/AudioSystem.h> +#include <media/AudioTrack.h> + +// ---------------------------------------------------------------------------- + +using namespace android; + +enum AudioError { + kAudioStatusOk = 0, + kAudioStatusError = 1, + kAudioStatusMediaServerDied = 100 +}; + +static int check_AudioSystem_Command(status_t status) +{ + if (status == NO_ERROR) { + return kAudioStatusOk; + } else { + return kAudioStatusError; + } +} + +static int +android_media_AudioSystem_setVolume(JNIEnv *env, jobject clazz, jint type, jint volume) +{ + LOGV("setVolume(%d)", int(volume)); + if (int(type) == AudioTrack::VOICE_CALL) { + return check_AudioSystem_Command(AudioSystem::setStreamVolume(type, float(volume) / 100.0)); + } else { + return check_AudioSystem_Command(AudioSystem::setStreamVolume(type, AudioSystem::linearToLog(volume))); + } +} + +static int +android_media_AudioSystem_getVolume(JNIEnv *env, jobject clazz, jint type) +{ + float v; + int v_int = -1; + if (AudioSystem::getStreamVolume(int(type), &v) == NO_ERROR) { + // voice call volume is converted to log scale in the hardware + if (int(type) == AudioTrack::VOICE_CALL) { + v_int = lrint(v * 100.0); + } else { + v_int = AudioSystem::logToLinear(v); + } + } + return v_int; +} + +static int +android_media_AudioSystem_muteMicrophone(JNIEnv *env, jobject thiz, jboolean on) +{ + return check_AudioSystem_Command(AudioSystem::muteMicrophone(on)); +} + +static jboolean +android_media_AudioSystem_isMicrophoneMuted(JNIEnv *env, jobject thiz) +{ + bool state = false; + AudioSystem::isMicrophoneMuted(&state); + return state; +} + +static int +android_media_AudioSystem_setRouting(JNIEnv *env, jobject clazz, jint mode, jint routes, jint mask) +{ + return check_AudioSystem_Command(AudioSystem::setRouting(mode, uint32_t(routes), uint32_t(mask))); +} + +static jint +android_media_AudioSystem_getRouting(JNIEnv *env, jobject clazz, jint mode) +{ + uint32_t routes = -1; + AudioSystem::getRouting(mode, &routes); + return jint(routes); +} + +static int +android_media_AudioSystem_setMode(JNIEnv *env, jobject clazz, jint mode) +{ + return check_AudioSystem_Command(AudioSystem::setMode(mode)); +} + +static jint +android_media_AudioSystem_getMode(JNIEnv *env, jobject clazz) +{ + int mode = AudioSystem::MODE_INVALID; + AudioSystem::getMode(&mode); + return jint(mode); +} + +static jboolean +android_media_AudioSystem_isMusicActive(JNIEnv *env, jobject thiz) +{ + bool state = false; + AudioSystem::isMusicActive(&state); + return state; +} + +// Temporary interface, do not use +// TODO: Replace with a more generic key:value get/set mechanism +static void +android_media_AudioSystem_setParameter(JNIEnv *env, jobject thiz, jstring key, jstring value) +{ + const char *c_key = env->GetStringUTFChars(key, NULL); + const char *c_value = env->GetStringUTFChars(value, NULL); + AudioSystem::setParameter(c_key, c_value); + env->ReleaseStringUTFChars(key, c_key); + env->ReleaseStringUTFChars(value, c_value); +} + +void android_media_AudioSystem_error_callback(status_t err) +{ + JNIEnv *env = AndroidRuntime::getJNIEnv(); + jclass clazz = env->FindClass("android/media/AudioSystem"); + + int error; + + switch (err) { + case DEAD_OBJECT: + error = kAudioStatusMediaServerDied; + break; + case NO_ERROR: + error = kAudioStatusOk; + break; + default: + error = kAudioStatusError; + break; + } + + env->CallStaticVoidMethod(clazz, env->GetStaticMethodID(clazz, "errorCallbackFromNative","(I)V"), error); +} + +// ---------------------------------------------------------------------------- + +static JNINativeMethod gMethods[] = { + {"setVolume", "(II)I", (void *)android_media_AudioSystem_setVolume}, + {"getVolume", "(I)I", (void *)android_media_AudioSystem_getVolume}, + {"setParameter", "(Ljava/lang/String;Ljava/lang/String;)V", (void *)android_media_AudioSystem_setParameter}, + {"muteMicrophone", "(Z)I", (void *)android_media_AudioSystem_muteMicrophone}, + {"isMicrophoneMuted", "()Z", (void *)android_media_AudioSystem_isMicrophoneMuted}, + {"setRouting", "(III)I", (void *)android_media_AudioSystem_setRouting}, + {"getRouting", "(I)I", (void *)android_media_AudioSystem_getRouting}, + {"setMode", "(I)I", (void *)android_media_AudioSystem_setMode}, + {"getMode", "()I", (void *)android_media_AudioSystem_getMode}, + {"isMusicActive", "()Z", (void *)android_media_AudioSystem_isMusicActive}, +}; + +const char* const kClassPathName = "android/media/AudioSystem"; + +int register_android_media_AudioSystem(JNIEnv *env) +{ + AudioSystem::setErrorCallback(android_media_AudioSystem_error_callback); + + return AndroidRuntime::registerNativeMethods(env, + "android/media/AudioSystem", gMethods, NELEM(gMethods)); +} diff --git a/core/jni/android_media_ToneGenerator.cpp b/core/jni/android_media_ToneGenerator.cpp new file mode 100644 index 0000000..73c1283 --- /dev/null +++ b/core/jni/android_media_ToneGenerator.cpp @@ -0,0 +1,149 @@ +/* //device/libs/android_runtime/android_media_AudioSystem.cpp + ** + ** Copyright 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. + */ + +#define LOG_TAG "ToneGenerator" + +#include <stdio.h> +#include <unistd.h> +#include <fcntl.h> + +#include "jni.h" +#include "JNIHelp.h" +#include "android_runtime/AndroidRuntime.h" + +#include "utils/Log.h" +#include "media/AudioSystem.h" +#include "media/ToneGenerator.h" + +// ---------------------------------------------------------------------------- + +using namespace android; + +struct fields_t { + jfieldID context; +}; +static fields_t fields; + +static jboolean android_media_ToneGenerator_startTone(JNIEnv *env, jobject thiz, jint toneType) { + LOGV("android_media_ToneGenerator_startTone: %x\n", (int)thiz); + + ToneGenerator *lpToneGen = (ToneGenerator *)env->GetIntField(thiz, + fields.context); + if (lpToneGen == NULL) { + jniThrowException(env, "java/lang/RuntimeException", "Method called after release()"); + return false; + } + + return lpToneGen->startTone(toneType); +} + +static void android_media_ToneGenerator_stopTone(JNIEnv *env, jobject thiz) { + LOGV("android_media_ToneGenerator_stopTone: %x\n", (int)thiz); + + ToneGenerator *lpToneGen = (ToneGenerator *)env->GetIntField(thiz, + fields.context); + + LOGV("ToneGenerator lpToneGen: %x\n", (unsigned int)lpToneGen); + if (lpToneGen == NULL) { + jniThrowException(env, "java/lang/RuntimeException", "Method called after release()"); + return; + } + lpToneGen->stopTone(); +} + +static void android_media_ToneGenerator_release(JNIEnv *env, jobject thiz) { + ToneGenerator *lpToneGen = (ToneGenerator *)env->GetIntField(thiz, + fields.context); + LOGV("android_media_ToneGenerator_release lpToneGen: %x\n", (int)lpToneGen); + + env->SetIntField(thiz, fields.context, 0); + + if (lpToneGen) { + delete lpToneGen; + } +} + +static void android_media_ToneGenerator_native_setup(JNIEnv *env, jobject thiz, + jint streamType, jint volume) { + ToneGenerator *lpToneGen = new ToneGenerator(streamType, AudioSystem::linearToLog(volume)); + + env->SetIntField(thiz, fields.context, 0); + + LOGV("android_media_ToneGenerator_native_setup jobject: %x\n", (int)thiz); + + if (lpToneGen == NULL) { + LOGE("ToneGenerator creation failed \n"); + jniThrowException(env, "java/lang/OutOfMemoryException", NULL); + return; + } + LOGV("ToneGenerator lpToneGen: %x\n", (unsigned int)lpToneGen); + + if (!lpToneGen->isInited()) { + LOGE("ToneGenerator init failed \n"); + jniThrowException(env, "java/lang/RuntimeException", "Init failed"); + return; + } + + // Stow our new C++ ToneGenerator in an opaque field in the Java object. + env->SetIntField(thiz, fields.context, (int)lpToneGen); + + LOGV("ToneGenerator fields.context: %x\n", env->GetIntField(thiz, fields.context)); +} + +static void android_media_ToneGenerator_native_finalize(JNIEnv *env, + jobject thiz) { + LOGV("android_media_ToneGenerator_native_finalize jobject: %x\n", (int)thiz); + + ToneGenerator *lpToneGen = (ToneGenerator *)env->GetIntField(thiz, + fields.context); + + if (lpToneGen) { + LOGV("delete lpToneGen: %x\n", (int)lpToneGen); + delete lpToneGen; + } +} + +// ---------------------------------------------------------------------------- + +static JNINativeMethod gMethods[] = { + { "startTone", "(I)Z", (void *)android_media_ToneGenerator_startTone }, + { "stopTone", "()V", (void *)android_media_ToneGenerator_stopTone }, + { "release", "()V", (void *)android_media_ToneGenerator_release }, + { "native_setup", "(II)V", (void *)android_media_ToneGenerator_native_setup }, + { "native_finalize", "()V", (void *)android_media_ToneGenerator_native_finalize } +}; + + +int register_android_media_ToneGenerator(JNIEnv *env) { + jclass clazz; + + clazz = env->FindClass("android/media/ToneGenerator"); + if (clazz == NULL) { + LOGE("Can't find %s", "android/media/ToneGenerator"); + return -1; + } + + fields.context = env->GetFieldID(clazz, "mNativeContext", "I"); + if (fields.context == NULL) { + LOGE("Can't find ToneGenerator.mNativeContext"); + return -1; + } + LOGV("register_android_media_ToneGenerator ToneGenerator fields.context: %x", (unsigned int)fields.context); + + return AndroidRuntime::registerNativeMethods(env, + "android/media/ToneGenerator", gMethods, NELEM(gMethods)); +} diff --git a/core/jni/android_message_digest_sha1.cpp b/core/jni/android_message_digest_sha1.cpp new file mode 100644 index 0000000..480bbf8 --- /dev/null +++ b/core/jni/android_message_digest_sha1.cpp @@ -0,0 +1,146 @@ +/* //device/libs/android_runtime/android_message_digest_sha1.cpp +** +** Copyright 2006, 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. +*/ + +#include "jni.h" +#include <JNIHelp.h> +#include "android_runtime/AndroidRuntime.h" + +#include <openssl/sha.h> + +//#define _DEBUG 1 + +// ---------------------------------------------------------------------------- + +using namespace android; + +// ---------------------------------------------------------------------------- + +struct fields_t { + jfieldID context; +}; +static fields_t fields; + +static void native_init(JNIEnv *env, jobject clazz) +{ + SHA_CTX* context; + +#ifdef _DEBUG + printf("sha1.native_init\n"); +#endif + + context = (SHA_CTX *)malloc(sizeof(SHA_CTX)); + SHA1_Init(context); + + env->SetIntField(clazz, fields.context, (int)context); +} + +static void native_reset(JNIEnv *env, jobject clazz) +{ + SHA_CTX *context = (SHA_CTX *)env->GetIntField(clazz, fields.context); + if (context != NULL) { +#ifdef _DEBUG + printf("sha1.native_reset: free context\n"); +#endif + free(context); + env->SetIntField(clazz, fields.context, 0 ); + } +} + + +static void native_update(JNIEnv *env, jobject clazz, jbyteArray dataArray) +{ +#ifdef _DEBUG + printf("sha1.native_update\n"); +#endif + jbyte * data; + jsize dataSize; + SHA_CTX *context = (SHA_CTX *)env->GetIntField(clazz, fields.context); + + if (context == NULL) { +#ifdef _DEBUG + printf("sha1.native_update: context is NULL, call init...\n"); +#endif + native_init(env, clazz); + context = (SHA_CTX *)env->GetIntField(clazz, fields.context); + } + + data = env->GetByteArrayElements(dataArray, NULL); + if (data == NULL) { + LOGE("Unable to get byte array elements"); + jniThrowException(env, "java/lang/IllegalArgumentException", + "Invalid data array when calling MessageDigest.update()"); + return; + } + dataSize = env->GetArrayLength(dataArray); + + SHA1_Update(context, data, dataSize); + + env->ReleaseByteArrayElements(dataArray, data, 0); +} + +static jbyteArray native_digest(JNIEnv *env, jobject clazz) +{ +#ifdef _DEBUG + printf("sha1.native_digest\n"); +#endif + jbyteArray array; + jbyte md[SHA_DIGEST_LENGTH]; + SHA_CTX *context = (SHA_CTX *)env->GetIntField(clazz, fields.context); + + SHA1_Final((uint8_t*)md, context); + + array = env->NewByteArray(SHA_DIGEST_LENGTH); + LOG_ASSERT(array, "Native could not create new byte[]"); + + env->SetByteArrayRegion(array, 0, SHA_DIGEST_LENGTH, md); + + native_reset(env, clazz); + + return array; +} + + +static JNINativeMethod method_table[] = +{ + /* name, signature, funcPtr */ + {"init", "()V", (void *)native_init}, + {"update", "([B)V", (void *)native_update}, + {"digest", "()[B", (void *)native_digest}, + {"reset", "()V", (void *)native_reset}, +}; + +int register_android_message_digest_sha1(JNIEnv *env) +{ + jclass clazz; + + clazz = env->FindClass("android/security/Sha1MessageDigest"); + if (clazz == NULL) { + LOGE("Can't find android/security/Sha1MessageDigest"); + return -1; + } + + fields.context = env->GetFieldID(clazz, "mNativeSha1Context", "I"); + if (fields.context == NULL) { + LOGE("Can't find Sha1MessageDigest.mNativeSha1Context"); + return -1; + } + + return AndroidRuntime::registerNativeMethods( + env, "android/security/Sha1MessageDigest", + method_table, NELEM(method_table)); +} + diff --git a/core/jni/android_net_LocalSocketImpl.cpp b/core/jni/android_net_LocalSocketImpl.cpp new file mode 100644 index 0000000..abd0961 --- /dev/null +++ b/core/jni/android_net_LocalSocketImpl.cpp @@ -0,0 +1,966 @@ +/* + * Copyright (C) 2006 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. + */ + +#define LOG_TAG "LocalSocketImpl" + +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <sys/un.h> +#include <arpa/inet.h> +#include <netinet/in.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> +#include <sys/ioctl.h> + +#include <cutils/sockets.h> +#include <netinet/tcp.h> +#include <cutils/properties.h> +#include <cutils/adb_networking.h> + +namespace android { + +static jfieldID field_inboundFileDescriptors; +static jfieldID field_outboundFileDescriptors; +static jclass class_Credentials; +static jclass class_FileDescriptor; +static jmethodID method_CredentialsInit; + +/* + * private native FileDescriptor + * create_native(boolean stream) + * throws IOException; + */ +static jobject +socket_create (JNIEnv *env, jobject object, jboolean stream) +{ + int ret; + + ret = socket(PF_LOCAL, stream ? SOCK_STREAM : SOCK_DGRAM, 0); + + if (ret < 0) { + jniThrowIOException(env, errno); + return NULL; + } + + return jniCreateFileDescriptor(env,ret); +} + +/* private native void connectLocal(FileDescriptor fd, + * String name, int namespace) throws IOException + */ +static void +socket_connect_local(JNIEnv *env, jobject object, + jobject fileDescriptor, jstring name, jint namespaceId) +{ + int ret; + const char *nameUtf8; + int fd; + + nameUtf8 = env->GetStringUTFChars(name, NULL); + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + ret = socket_local_client_connect( + fd, + nameUtf8, + namespaceId, + SOCK_STREAM); + + env->ReleaseStringUTFChars(name, nameUtf8); + + if (ret < 0) { + jniThrowIOException(env, errno); + return; + } +} + +#define DEFAULT_BACKLOG 4 + +/* private native void bindLocal(FileDescriptor fd, String name, namespace) + * throws IOException; + */ + +static void +socket_bind_local (JNIEnv *env, jobject object, jobject fileDescriptor, + jstring name, jint namespaceId) +{ + int ret; + int fd; + const char *nameUtf8; + + + if (name == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + nameUtf8 = env->GetStringUTFChars(name, NULL); + + ret = socket_local_server_bind(fd, nameUtf8, namespaceId); + + env->ReleaseStringUTFChars(name, nameUtf8); + + if (ret < 0) { + jniThrowIOException(env, errno); + return; + } +} + +/* private native void listen_native(int fd, int backlog) throws IOException; */ +static void +socket_listen (JNIEnv *env, jobject object, jobject fileDescriptor, int backlog) +{ + int ret; + int fd; + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + ret = listen(fd, backlog); + + if (ret < 0) { + jniThrowIOException(env, errno); + return; + } +} + +/* private native FileDescriptor +** accept (FileDescriptor fd, LocalSocketImpl s) +** throws IOException; +*/ +static jobject +socket_accept (JNIEnv *env, jobject object, jobject fileDescriptor, jobject s) +{ + union { + struct sockaddr address; + struct sockaddr_un un_address; + } sa; + + int ret; + int retFD; + int fd; + socklen_t addrlen; + + if (s == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return NULL; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return NULL; + } + + do { + addrlen = sizeof(sa); + ret = accept(fd, &(sa.address), &addrlen); + } while (ret < 0 && errno == EINTR); + + if (ret < 0) { + jniThrowIOException(env, errno); + return NULL; + } + + retFD = ret; + + return jniCreateFileDescriptor(env, retFD); +} + +/* private native void shutdown(FileDescriptor fd, boolean shutdownInput) */ + +static void +socket_shutdown (JNIEnv *env, jobject object, jobject fileDescriptor, + jboolean shutdownInput) +{ + int ret; + int fd; + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + ret = shutdown(fd, shutdownInput ? SHUT_RD : SHUT_WR); + + if (ret < 0) { + jniThrowIOException(env, errno); + return; + } +} + +static bool +java_opt_to_real(int optID, int* opt, int* level) +{ + switch (optID) + { + case 4098: + *opt = SO_RCVBUF; + *level = SOL_SOCKET; + return true; + case 4097: + *opt = SO_SNDBUF; + *level = SOL_SOCKET; + return true; + case 4102: + *opt = SO_SNDTIMEO; + *level = SOL_SOCKET; + return true; + case 128: + *opt = SO_LINGER; + *level = SOL_SOCKET; + return true; + case 1: + *opt = TCP_NODELAY; + *level = IPPROTO_TCP; + return true; + case 4: + *opt = SO_REUSEADDR; + *level = SOL_SOCKET; + return true; + + } + return false; +} + +static jint +socket_getOption(JNIEnv *env, jobject object, jobject fileDescriptor, int optID) +{ + int ret, value; + int opt, level; + int fd; + + socklen_t size = sizeof(int); + + if (!java_opt_to_real(optID, &opt, &level)) { + jniThrowIOException(env, -1); + return 0; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return 0; + } + + switch (opt) + { + case SO_LINGER: + { + struct linger lingr; + size = sizeof(lingr); + ret = getsockopt(fd, level, opt, &lingr, &size); + if (!lingr.l_onoff) { + value = -1; + } else { + value = lingr.l_linger; + } + break; + } + default: + ret = getsockopt(fd, level, opt, &value, &size); + break; + } + + + if (ret != 0) { + jniThrowIOException(env, errno); + return 0; + } + + return value; +} + +static void socket_setOption( + JNIEnv *env, jobject object, jobject fileDescriptor, int optID, + jint boolValue, jint intValue) { + int ret; + int optname; + int level; + int fd; + + if (!java_opt_to_real(optID, &optname, &level)) { + jniThrowIOException(env, -1); + return; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + switch (optname) { + case SO_LINGER: { + /* + * SO_LINGER is special because it needs to use a special + * "linger" struct as well as use the incoming boolean + * argument specially. + */ + struct linger lingr; + lingr.l_onoff = boolValue ? 1 : 0; // Force it to be 0 or 1. + lingr.l_linger = intValue; + ret = setsockopt(fd, level, optname, &lingr, sizeof(lingr)); + break; + } + case SO_SNDTIMEO: { + /* + * SO_TIMEOUT from the core library gets converted to + * SO_SNDTIMEO, but the option is supposed to set both + * send and receive timeouts. Note: The incoming timeout + * value is in milliseconds. + */ + struct timeval timeout; + timeout.tv_sec = intValue / 1000; + timeout.tv_usec = (intValue % 1000) * 1000; + + ret = setsockopt(fd, SOL_SOCKET, SO_RCVTIMEO, + (void *)&timeout, sizeof(timeout)); + + if (ret == 0) { + ret = setsockopt(fd, SOL_SOCKET, SO_SNDTIMEO, + (void *)&timeout, sizeof(timeout)); + } + + break; + } + default: { + /* + * In all other cases, the translated option level and + * optname may be used directly for a call to setsockopt(). + */ + ret = setsockopt(fd, level, optname, &intValue, sizeof(intValue)); + break; + } + } + + if (ret != 0) { + jniThrowIOException(env, errno); + return; + } +} + +static jint socket_available (JNIEnv *env, jobject object, + jobject fileDescriptor) +{ + int fd; + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return (jint)-1; + } + +#if 1 + int avail; + int ret = ioctl(fd, FIONREAD, &avail); + + // If this were a non-socket fd, there would be other cases to worry + // about... + + if (ret < 0) { + jniThrowIOException(env, errno); + return (jint) 0; + } + + return (jint)avail; +#else +// there appears to be a bionic bug that prevents this version from working. + + ssize_t ret; + struct msghdr msg; + + memset(&msg, 0, sizeof(msg)); + + do { + ret = recvmsg(fd, &msg, MSG_PEEK | MSG_DONTWAIT | MSG_NOSIGNAL); + } while (ret < 0 && errno == EINTR); + + + // MSG_PEEK returns 0 on EOF and EWOULDBLOCK on none available + if (ret < 0 && errno == EWOULDBLOCK) { + return 0; + } if (ret < 0) { + jniThrowIOException(env, errno); + return -1; + } + + return (jint)ret; +#endif +} + +static void socket_close (JNIEnv *env, jobject object, jobject fileDescriptor) +{ + int fd; + int err; + + if (fileDescriptor == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + do { + err = close(fd); + } while (err < 0 && errno == EINTR); + + if (err < 0) { + jniThrowIOException(env, errno); + return; + } +} + +/** + * Processes ancillary data, handling only + * SCM_RIGHTS. Creates appropriate objects and sets appropriate + * fields in the LocalSocketImpl object. Returns 0 on success + * or -1 if an exception was thrown. + */ +static int socket_process_cmsg(JNIEnv *env, jobject thisJ, struct msghdr * pMsg) +{ + struct cmsghdr *cmsgptr; + + for (cmsgptr = CMSG_FIRSTHDR(pMsg); + cmsgptr != NULL; cmsgptr = CMSG_NXTHDR(pMsg, cmsgptr)) { + + if (cmsgptr->cmsg_level != SOL_SOCKET) { + continue; + } + + if (cmsgptr->cmsg_type == SCM_RIGHTS) { + int *pDescriptors = (int *)CMSG_DATA(cmsgptr); + jobjectArray fdArray; + int count + = ((cmsgptr->cmsg_len - CMSG_LEN(0)) / sizeof(int)); + + if (count < 0) { + jniThrowException(env, "java/io/IOException", + "invalid cmsg length"); + } + + fdArray = env->NewObjectArray(count, class_FileDescriptor, NULL); + + if (fdArray == NULL) { + return -1; + } + + for (int i = 0; i < count; i++) { + jobject fdObject + = jniCreateFileDescriptor(env, pDescriptors[i]); + + if (env->ExceptionOccurred() != NULL) { + return -1; + } + + env->SetObjectArrayElement(fdArray, i, fdObject); + + if (env->ExceptionOccurred() != NULL) { + return -1; + } + } + + env->SetObjectField(thisJ, field_inboundFileDescriptors, fdArray); + + if (env->ExceptionOccurred() != NULL) { + return -1; + } + } + } + + return 0; +} + +/** + * Reads data from a socket into buf, processing any ancillary data + * and adding it to thisJ. + * + * Returns the length of normal data read, or -1 if an exception has + * been thrown in this function. + */ +static ssize_t socket_read_all(JNIEnv *env, jobject thisJ, int fd, + void *buffer, size_t len) +{ + ssize_t ret; + ssize_t bytesread = 0; + struct msghdr msg; + struct iovec iv; + unsigned char *buf = (unsigned char *)buffer; + // Enough buffer for a pile of fd's. We throw an exception if + // this buffer is too small. + struct cmsghdr cmsgbuf[2*sizeof(cmsghdr) + 0x100]; + + memset(&msg, 0, sizeof(msg)); + memset(&iv, 0, sizeof(iv)); + + iv.iov_base = buf; + iv.iov_len = len; + + msg.msg_iov = &iv; + msg.msg_iovlen = 1; + msg.msg_control = cmsgbuf; + msg.msg_controllen = sizeof(cmsgbuf); + + do { + ret = recvmsg(fd, &msg, MSG_NOSIGNAL); + } while (ret < 0 && errno == EINTR); + + if (ret < 0 && errno == EPIPE) { + // Treat this as an end of stream + return 0; + } + + if (ret < 0) { + jniThrowIOException(env, errno); + return -1; + } + + if ((msg.msg_flags & (MSG_CTRUNC | MSG_OOB | MSG_ERRQUEUE)) != 0) { + // To us, any of the above flags are a fatal error + + jniThrowException(env, "java/io/IOException", + "Unexpected error or truncation during recvmsg()"); + + return -1; + } + + if (ret >= 0) { + socket_process_cmsg(env, thisJ, &msg); + } + + return ret; +} + +/** + * Writes all the data in the specified buffer to the specified socket. + * + * Returns 0 on success or -1 if an exception was thrown. + */ +static int socket_write_all(JNIEnv *env, jobject object, int fd, + void *buf, size_t len) +{ + ssize_t ret; + struct msghdr msg; + unsigned char *buffer = (unsigned char *)buf; + memset(&msg, 0, sizeof(msg)); + + jobjectArray outboundFds + = (jobjectArray)env->GetObjectField( + object, field_outboundFileDescriptors); + + if (env->ExceptionOccurred() != NULL) { + return -1; + } + + struct cmsghdr *cmsg; + int countFds = outboundFds == NULL ? 0 : env->GetArrayLength(outboundFds); + int fds[countFds]; + char msgbuf[CMSG_SPACE(countFds)]; + + // Add any pending outbound file descriptors to the message + if (outboundFds != NULL) { + + if (env->ExceptionOccurred() != NULL) { + return -1; + } + + for (int i = 0; i < countFds; i++) { + jobject fdObject = env->GetObjectArrayElement(outboundFds, i); + if (env->ExceptionOccurred() != NULL) { + return -1; + } + + fds[i] = jniGetFDFromFileDescriptor(env, fdObject); + if (env->ExceptionOccurred() != NULL) { + return -1; + } + } + + // See "man cmsg" really + msg.msg_control = msgbuf; + msg.msg_controllen = sizeof msgbuf; + cmsg = CMSG_FIRSTHDR(&msg); + cmsg->cmsg_level = SOL_SOCKET; + cmsg->cmsg_type = SCM_RIGHTS; + cmsg->cmsg_len = CMSG_LEN(sizeof fds); + memcpy(CMSG_DATA(cmsg), fds, sizeof fds); + } + + // We only write our msg_control during the first write + while (len > 0) { + struct iovec iv; + memset(&iv, 0, sizeof(iv)); + + iv.iov_base = buffer; + iv.iov_len = len; + + msg.msg_iov = &iv; + msg.msg_iovlen = 1; + + do { + ret = sendmsg(fd, &msg, MSG_NOSIGNAL); + } while (ret < 0 && errno == EINTR); + + if (ret < 0) { + jniThrowIOException(env, errno); + return -1; + } + + buffer += ret; + len -= ret; + + // Wipes out any msg_control too + memset(&msg, 0, sizeof(msg)); + } + + return 0; +} + +static jint socket_read (JNIEnv *env, jobject object, jobject fileDescriptor) +{ + int fd; + int err; + + if (fileDescriptor == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return (jint)-1; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return (jint)0; + } + + unsigned char buf; + + err = socket_read_all(env, object, fd, &buf, 1); + + if (err < 0) { + jniThrowIOException(env, errno); + return (jint)0; + } + + if (err == 0) { + // end of file + return (jint)-1; + } + + return (jint)buf; +} + +static jint socket_readba (JNIEnv *env, jobject object, + jbyteArray buffer, jint off, jint len, jobject fileDescriptor) +{ + int fd; + jbyte* byteBuffer; + int ret; + + if (fileDescriptor == NULL || buffer == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return (jint)-1; + } + + if (off < 0 || len < 0 || (off + len) > env->GetArrayLength(buffer)) { + jniThrowException(env, "java/lang/ArrayIndexOutOfBounds", NULL); + return (jint)-1; + } + + if (len == 0) { + // because socket_read_all returns 0 on EOF + return 0; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return (jint)-1; + } + + byteBuffer = env->GetByteArrayElements(buffer, NULL); + + if (NULL == byteBuffer) { + // an exception will have been thrown + return (jint)-1; + } + + ret = socket_read_all(env, object, + fd, byteBuffer + off, len); + + // A return of -1 above means an exception is pending + + env->ReleaseByteArrayElements(buffer, byteBuffer, 0); + + return (jint) ((ret == 0) ? -1 : ret); +} + +static void socket_write (JNIEnv *env, jobject object, + jint b, jobject fileDescriptor) +{ + int fd; + int err; + + if (fileDescriptor == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + err = socket_write_all(env, object, fd, &b, 1); + + // A return of -1 above means an exception is pending +} + +static void socket_writeba (JNIEnv *env, jobject object, + jbyteArray buffer, jint off, jint len, jobject fileDescriptor) +{ + int fd; + int err; + jbyte* byteBuffer; + + if (fileDescriptor == NULL || buffer == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return; + } + + if (off < 0 || len < 0 || (off + len) > env->GetArrayLength(buffer)) { + jniThrowException(env, "java/lang/ArrayIndexOutOfBounds", NULL); + return; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + byteBuffer = env->GetByteArrayElements(buffer,NULL); + + if (NULL == byteBuffer) { + // an exception will have been thrown + return; + } + + err = socket_write_all(env, object, fd, + byteBuffer + off, len); + + // A return of -1 above means an exception is pending + + env->ReleaseByteArrayElements(buffer, byteBuffer, JNI_ABORT); +} + +static jobject socket_get_peer_credentials(JNIEnv *env, + jobject object, jobject fileDescriptor) +{ + int err; + int fd; + + if (fileDescriptor == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return NULL; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return NULL; + } + + struct ucred creds; + + memset(&creds, 0, sizeof(creds)); + socklen_t szCreds = sizeof(creds); + + err = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &creds, &szCreds); + + if (err < 0) { + jniThrowIOException(env, errno); + return NULL; + } + + if (szCreds == 0) { + return NULL; + } + + return env->NewObject(class_Credentials, method_CredentialsInit, + creds.pid, creds.uid, creds.gid); +} + +#if 0 +//TODO change this to return an instance of LocalSocketAddress +static jobject socket_getSockName(JNIEnv *env, + jobject object, jobject fileDescriptor) +{ + int err; + int fd; + + if (fileDescriptor == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return NULL; + } + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return NULL; + } + + union { + struct sockaddr address; + struct sockaddr_un un_address; + } sa; + + memset(&sa, 0, sizeof(sa)); + + socklen_t namelen = sizeof(sa); + err = getsockname(fd, &(sa.address), &namelen); + + if (err < 0) { + jniThrowIOException(env, errno); + return NULL; + } + + if (sa.address.sa_family != AF_UNIX) { + // We think we're an impl only for AF_UNIX, so this should never happen. + + jniThrowIOException(env, EINVAL); + return NULL; + } + + if (sa.un_address.sun_path[0] == '\0') { + } else { + } + + + + +} +#endif + +/* + * JNI registration. + */ +static JNINativeMethod gMethods[] = { + /* name, signature, funcPtr */ + {"getOption_native", "(Ljava/io/FileDescriptor;I)I", (void*)socket_getOption}, + {"setOption_native", "(Ljava/io/FileDescriptor;III)V", (void*)socket_setOption}, + {"create_native", "(Z)Ljava/io/FileDescriptor;", (void*)socket_create}, + {"connectLocal", "(Ljava/io/FileDescriptor;Ljava/lang/String;I)V", + (void*)socket_connect_local}, + {"bindLocal", "(Ljava/io/FileDescriptor;Ljava/lang/String;I)V", (void*)socket_bind_local}, + {"listen_native", "(Ljava/io/FileDescriptor;I)V", (void*)socket_listen}, + {"accept", "(Ljava/io/FileDescriptor;Landroid/net/LocalSocketImpl;)Ljava/io/FileDescriptor;", (void*)socket_accept}, + {"shutdown", "(Ljava/io/FileDescriptor;Z)V", (void*)socket_shutdown}, + {"available_native", "(Ljava/io/FileDescriptor;)I", (void*) socket_available}, + {"close_native", "(Ljava/io/FileDescriptor;)V", (void*) socket_close}, + {"read_native", "(Ljava/io/FileDescriptor;)I", (void*) socket_read}, + {"readba_native", "([BIILjava/io/FileDescriptor;)I", (void*) socket_readba}, + {"writeba_native", "([BIILjava/io/FileDescriptor;)V", (void*) socket_writeba}, + {"write_native", "(ILjava/io/FileDescriptor;)V", (void*) socket_write}, + {"getPeerCredentials_native", + "(Ljava/io/FileDescriptor;)Landroid/net/Credentials;", + (void*) socket_get_peer_credentials} + //,{"getSockName_native", "(Ljava/io/FileDescriptor;)Ljava/lang/String;", + // (void *) socket_getSockName} + +}; + +int register_android_net_LocalSocketImpl(JNIEnv *env) +{ + jclass clazz; + + clazz = env->FindClass("android/net/LocalSocketImpl"); + + if (clazz == NULL) { + goto error; + } + + field_inboundFileDescriptors = env->GetFieldID(clazz, + "inboundFileDescriptors", "[Ljava/io/FileDescriptor;"); + + if (field_inboundFileDescriptors == NULL) { + goto error; + } + + field_outboundFileDescriptors = env->GetFieldID(clazz, + "outboundFileDescriptors", "[Ljava/io/FileDescriptor;"); + + if (field_outboundFileDescriptors == NULL) { + goto error; + } + + class_Credentials = env->FindClass("android/net/Credentials"); + + if (class_Credentials == NULL) { + goto error; + } + + class_Credentials = (jclass)env->NewGlobalRef(class_Credentials); + + class_FileDescriptor = env->FindClass("java/io/FileDescriptor"); + + if (class_FileDescriptor == NULL) { + goto error; + } + + class_FileDescriptor = (jclass)env->NewGlobalRef(class_FileDescriptor); + + method_CredentialsInit + = env->GetMethodID(class_Credentials, "<init>", "(III)V"); + + if (method_CredentialsInit == NULL) { + goto error; + } + + return jniRegisterNativeMethods(env, + "android/net/LocalSocketImpl", gMethods, NELEM(gMethods)); + +error: + LOGE("Error registering android.net.LocalSocketImpl"); + return -1; +} + +}; diff --git a/core/jni/android_net_NetUtils.cpp b/core/jni/android_net_NetUtils.cpp new file mode 100644 index 0000000..417ce54 --- /dev/null +++ b/core/jni/android_net_NetUtils.cpp @@ -0,0 +1,235 @@ +/* + * Copyright 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. + */ + +#define LOG_TAG "NetUtils" + +#include "jni.h" +#include <utils/misc.h> +#include <android_runtime/AndroidRuntime.h> +#include <utils/Log.h> +#include <arpa/inet.h> + +extern "C" { +int ifc_disable(const char *ifname); +int ifc_add_host_route(const char *ifname, uint32_t addr); +int ifc_remove_host_routes(const char *ifname); +int ifc_set_default_route(const char *ifname, uint32_t gateway); +int ifc_get_default_route(const char *ifname); +int ifc_remove_default_route(const char *ifname); +int ifc_reset_connections(const char *ifname); +int ifc_configure(const char *ifname, in_addr_t ipaddr, in_addr_t netmask, in_addr_t gateway, in_addr_t dns1, in_addr_t dns2); + +int dhcp_do_request(const char *ifname, + in_addr_t *ipaddr, + in_addr_t *gateway, + in_addr_t *mask, + in_addr_t *dns1, + in_addr_t *dns2, + in_addr_t *server, + uint32_t *lease); +int dhcp_stop(const char *ifname); +char *dhcp_get_errmsg(); +} + +#define NETUTILS_PKG_NAME "android/net/NetworkUtils" + +namespace android { + +/* + * The following remembers the jfieldID's of the fields + * of the DhcpInfo Java object, so that we don't have + * to look them up every time. + */ +static struct fieldIds { + jclass dhcpInfoClass; + jmethodID constructorId; + jfieldID ipaddress; + jfieldID gateway; + jfieldID netmask; + jfieldID dns1; + jfieldID dns2; + jfieldID serverAddress; + jfieldID leaseDuration; +} dhcpInfoFieldIds; + +static jint android_net_utils_disableInterface(JNIEnv* env, jobject clazz, jstring ifname) +{ + int result; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::ifc_disable(nameStr); + env->ReleaseStringUTFChars(ifname, nameStr); + return (jint)result; +} + +static jint android_net_utils_addHostRoute(JNIEnv* env, jobject clazz, jstring ifname, jint addr) +{ + int result; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::ifc_add_host_route(nameStr, addr); + env->ReleaseStringUTFChars(ifname, nameStr); + return (jint)result; +} + +static jint android_net_utils_removeHostRoutes(JNIEnv* env, jobject clazz, jstring ifname) +{ + int result; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::ifc_remove_host_routes(nameStr); + env->ReleaseStringUTFChars(ifname, nameStr); + return (jint)result; +} + +static jint android_net_utils_setDefaultRoute(JNIEnv* env, jobject clazz, jstring ifname, jint gateway) +{ + int result; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::ifc_set_default_route(nameStr, gateway); + env->ReleaseStringUTFChars(ifname, nameStr); + return (jint)result; +} + +static jint android_net_utils_getDefaultRoute(JNIEnv* env, jobject clazz, jstring ifname) +{ + int result; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::ifc_get_default_route(nameStr); + env->ReleaseStringUTFChars(ifname, nameStr); + return (jint)result; +} + +static jint android_net_utils_removeDefaultRoute(JNIEnv* env, jobject clazz, jstring ifname) +{ + int result; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::ifc_remove_default_route(nameStr); + env->ReleaseStringUTFChars(ifname, nameStr); + return (jint)result; +} + +static jint android_net_utils_resetConnections(JNIEnv* env, jobject clazz, jstring ifname) +{ + int result; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::ifc_reset_connections(nameStr); + env->ReleaseStringUTFChars(ifname, nameStr); + return (jint)result; +} + +static jboolean android_net_utils_runDhcp(JNIEnv* env, jobject clazz, jstring ifname, jobject info) +{ + int result; + in_addr_t ipaddr, gateway, mask, dns1, dns2, server; + uint32_t lease; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::dhcp_do_request(nameStr, &ipaddr, &gateway, &mask, + &dns1, &dns2, &server, &lease); + env->ReleaseStringUTFChars(ifname, nameStr); + if (result == 0 && dhcpInfoFieldIds.dhcpInfoClass != NULL) { + env->SetIntField(info, dhcpInfoFieldIds.ipaddress, ipaddr); + env->SetIntField(info, dhcpInfoFieldIds.gateway, gateway); + env->SetIntField(info, dhcpInfoFieldIds.netmask, mask); + env->SetIntField(info, dhcpInfoFieldIds.dns1, dns1); + env->SetIntField(info, dhcpInfoFieldIds.dns2, dns2); + env->SetIntField(info, dhcpInfoFieldIds.serverAddress, server); + env->SetIntField(info, dhcpInfoFieldIds.leaseDuration, lease); + } + return (jboolean)(result == 0); +} + +static jboolean android_net_utils_stopDhcp(JNIEnv* env, jobject clazz, jstring ifname, jobject info) +{ + int result; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::dhcp_stop(nameStr); + env->ReleaseStringUTFChars(ifname, nameStr); + return (jboolean)(result == 0); +} + +static jstring android_net_utils_getDhcpError(JNIEnv* env, jobject clazz) +{ + return env->NewStringUTF(::dhcp_get_errmsg()); +} + +static jboolean android_net_utils_configureInterface(JNIEnv* env, + jobject clazz, + jstring ifname, + jint ipaddr, + jint mask, + jint gateway, + jint dns1, + jint dns2) +{ + int result; + uint32_t lease; + + const char *nameStr = env->GetStringUTFChars(ifname, NULL); + result = ::ifc_configure(nameStr, ipaddr, mask, gateway, dns1, dns2); + env->ReleaseStringUTFChars(ifname, nameStr); + return (jboolean)(result == 0); +} + +// ---------------------------------------------------------------------------- + +/* + * JNI registration. + */ +static JNINativeMethod gNetworkUtilMethods[] = { + /* name, signature, funcPtr */ + + { "disableInterface", "(Ljava/lang/String;)I", (void *)android_net_utils_disableInterface }, + { "addHostRoute", "(Ljava/lang/String;I)I", (void *)android_net_utils_addHostRoute }, + { "removeHostRoutes", "(Ljava/lang/String;)I", (void *)android_net_utils_removeHostRoutes }, + { "setDefaultRoute", "(Ljava/lang/String;I)I", (void *)android_net_utils_setDefaultRoute }, + { "getDefaultRoute", "(Ljava/lang/String;)I", (void *)android_net_utils_getDefaultRoute }, + { "removeDefaultRoute", "(Ljava/lang/String;)I", (void *)android_net_utils_removeDefaultRoute }, + { "resetConnections", "(Ljava/lang/String;)I", (void *)android_net_utils_resetConnections }, + { "runDhcp", "(Ljava/lang/String;Landroid/net/DhcpInfo;)Z", (void *)android_net_utils_runDhcp }, + { "stopDhcp", "(Ljava/lang/String;)Z", (void *)android_net_utils_stopDhcp }, + { "configureNative", "(Ljava/lang/String;IIIII)Z", (void *)android_net_utils_configureInterface }, + { "getDhcpError", "()Ljava/lang/String;", (void*) android_net_utils_getDhcpError }, +}; + +int register_android_net_NetworkUtils(JNIEnv* env) +{ + jclass netutils = env->FindClass(NETUTILS_PKG_NAME); + LOG_FATAL_IF(netutils == NULL, "Unable to find class " NETUTILS_PKG_NAME); + + dhcpInfoFieldIds.dhcpInfoClass = env->FindClass("android/net/DhcpInfo"); + if (dhcpInfoFieldIds.dhcpInfoClass != NULL) { + dhcpInfoFieldIds.constructorId = env->GetMethodID(dhcpInfoFieldIds.dhcpInfoClass, "<init>", "()V"); + dhcpInfoFieldIds.ipaddress = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "ipAddress", "I"); + dhcpInfoFieldIds.gateway = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "gateway", "I"); + dhcpInfoFieldIds.netmask = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "netmask", "I"); + dhcpInfoFieldIds.dns1 = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "dns1", "I"); + dhcpInfoFieldIds.dns2 = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "dns2", "I"); + dhcpInfoFieldIds.serverAddress = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "serverAddress", "I"); + dhcpInfoFieldIds.leaseDuration = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "leaseDuration", "I"); + } + + return AndroidRuntime::registerNativeMethods(env, + NETUTILS_PKG_NAME, gNetworkUtilMethods, NELEM(gNetworkUtilMethods)); +} + +}; // namespace android diff --git a/core/jni/android_net_wifi_Wifi.cpp b/core/jni/android_net_wifi_Wifi.cpp new file mode 100644 index 0000000..48af99e --- /dev/null +++ b/core/jni/android_net_wifi_Wifi.cpp @@ -0,0 +1,492 @@ +/* + * Copyright 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. + */ + +#define LOG_TAG "wifi" + +#include "jni.h" +#include <utils/misc.h> +#include <android_runtime/AndroidRuntime.h> +#include <utils/Log.h> + +#include "wifi.h" + +#define WIFI_PKG_NAME "android/net/wifi/WifiNative" + +namespace android { + +/* + * The following remembers the jfieldID's of the fields + * of the DhcpInfo Java object, so that we don't have + * to look them up every time. + */ +static struct fieldIds { + jclass dhcpInfoClass; + jmethodID constructorId; + jfieldID ipaddress; + jfieldID gateway; + jfieldID netmask; + jfieldID dns1; + jfieldID dns2; + jfieldID serverAddress; + jfieldID leaseDuration; +} dhcpInfoFieldIds; + +static int doCommand(const char *cmd, char *replybuf, int replybuflen) +{ + size_t reply_len = replybuflen - 1; + + if (::wifi_command(cmd, replybuf, &reply_len) != 0) + return -1; + else { + // Strip off trailing newline + if (reply_len > 0 && replybuf[reply_len-1] == '\n') + replybuf[reply_len-1] = '\0'; + else + replybuf[reply_len] = '\0'; + return 0; + } +} + +static jint doIntCommand(const char *cmd) +{ + char reply[256]; + + if (doCommand(cmd, reply, sizeof(reply)) != 0) { + return (jint)-1; + } else { + return (jint)atoi(reply); + } +} + +static jboolean doBooleanCommand(const char *cmd, const char *expect) +{ + char reply[256]; + + if (doCommand(cmd, reply, sizeof(reply)) != 0) { + return (jboolean)JNI_FALSE; + } else { + return (jboolean)(strcmp(reply, expect) == 0); + } +} + +// Send a command to the supplicant, and return the reply as a String +static jstring doStringCommand(JNIEnv *env, const char *cmd) +{ + char reply[4096]; + + if (doCommand(cmd, reply, sizeof(reply)) != 0) { + return env->NewStringUTF(NULL); + } else { + return env->NewStringUTF(reply); + } +} + +static jboolean android_net_wifi_loadDriver(JNIEnv* env, jobject clazz) +{ + return (jboolean)(::wifi_load_driver() == 0); +} + +static jboolean android_net_wifi_unloadDriver(JNIEnv* env, jobject clazz) +{ + return (jboolean)(::wifi_unload_driver() == 0); +} + +static jboolean android_net_wifi_startSupplicant(JNIEnv* env, jobject clazz) +{ + return (jboolean)(::wifi_start_supplicant() == 0); +} + +static jboolean android_net_wifi_stopSupplicant(JNIEnv* env, jobject clazz) +{ + return (jboolean)(::wifi_stop_supplicant() == 0); +} + +static jboolean android_net_wifi_connectToSupplicant(JNIEnv* env, jobject clazz) +{ + return (jboolean)(::wifi_connect_to_supplicant() == 0); +} + +static void android_net_wifi_closeSupplicantConnection(JNIEnv* env, jobject clazz) +{ + ::wifi_close_supplicant_connection(); +} + +static jstring android_net_wifi_waitForEvent(JNIEnv* env, jobject clazz) +{ + char buf[256]; + + int nread = ::wifi_wait_for_event(buf, sizeof buf); + if (nread > 0) { + return env->NewStringUTF(buf); + } else { + return env->NewStringUTF(NULL); + } +} + +static jstring android_net_wifi_listNetworksCommand(JNIEnv* env, jobject clazz) +{ + return doStringCommand(env, "LIST_NETWORKS"); +} + +static jint android_net_wifi_addNetworkCommand(JNIEnv* env, jobject clazz) +{ + return doIntCommand("ADD_NETWORK"); +} + +static jboolean android_net_wifi_setNetworkVariableCommand(JNIEnv* env, + jobject clazz, + jint netId, + jstring name, + jstring value) +{ + char cmdstr[256]; + jboolean isCopy; + + const char *nameStr = env->GetStringUTFChars(name, &isCopy); + const char *valueStr = env->GetStringUTFChars(value, &isCopy); + + if (nameStr == NULL || valueStr == NULL) + return JNI_FALSE; + + int cmdTooLong = snprintf(cmdstr, sizeof(cmdstr), "SET_NETWORK %d %s %s", + netId, nameStr, valueStr) >= (int)sizeof(cmdstr); + + env->ReleaseStringUTFChars(name, nameStr); + env->ReleaseStringUTFChars(value, valueStr); + + return (jboolean)!cmdTooLong && doBooleanCommand(cmdstr, "OK"); +} + +static jstring android_net_wifi_getNetworkVariableCommand(JNIEnv* env, + jobject clazz, + jint netId, + jstring name) +{ + char cmdstr[256]; + jboolean isCopy; + + const char *nameStr = env->GetStringUTFChars(name, &isCopy); + + if (nameStr == NULL) + return env->NewStringUTF(NULL); + + int cmdTooLong = snprintf(cmdstr, sizeof(cmdstr), "GET_NETWORK %d %s", + netId, nameStr) >= (int)sizeof(cmdstr); + + env->ReleaseStringUTFChars(name, nameStr); + + return cmdTooLong ? env->NewStringUTF(NULL) : doStringCommand(env, cmdstr); +} + +static jboolean android_net_wifi_removeNetworkCommand(JNIEnv* env, jobject clazz, jint netId) +{ + char cmdstr[256]; + + int numWritten = snprintf(cmdstr, sizeof(cmdstr), "REMOVE_NETWORK %d", netId); + int cmdTooLong = numWritten >= (int)sizeof(cmdstr); + + return (jboolean)!cmdTooLong && doBooleanCommand(cmdstr, "OK"); +} + +static jboolean android_net_wifi_enableNetworkCommand(JNIEnv* env, + jobject clazz, + jint netId, + jboolean disableOthers) +{ + char cmdstr[256]; + const char *cmd = disableOthers ? "SELECT_NETWORK" : "ENABLE_NETWORK"; + + int numWritten = snprintf(cmdstr, sizeof(cmdstr), "%s %d", cmd, netId); + int cmdTooLong = numWritten >= (int)sizeof(cmdstr); + + return (jboolean)!cmdTooLong && doBooleanCommand(cmdstr, "OK"); +} + +static jboolean android_net_wifi_disableNetworkCommand(JNIEnv* env, jobject clazz, jint netId) +{ + char cmdstr[256]; + + int numWritten = snprintf(cmdstr, sizeof(cmdstr), "DISABLE_NETWORK %d", netId); + int cmdTooLong = numWritten >= (int)sizeof(cmdstr); + + return (jboolean)!cmdTooLong && doBooleanCommand(cmdstr, "OK"); +} + +static jstring android_net_wifi_statusCommand(JNIEnv* env, jobject clazz) +{ + return doStringCommand(env, "STATUS"); +} + +static jboolean android_net_wifi_pingCommand(JNIEnv* env, jobject clazz) +{ + return doBooleanCommand("PING", "PONG"); +} + +static jstring android_net_wifi_scanResultsCommand(JNIEnv* env, jobject clazz) +{ + return doStringCommand(env, "SCAN_RESULTS"); +} + +static jboolean android_net_wifi_disconnectCommand(JNIEnv* env, jobject clazz) +{ + return doBooleanCommand("DISCONNECT", "OK"); +} + +static jboolean android_net_wifi_reconnectCommand(JNIEnv* env, jobject clazz) +{ + return doBooleanCommand("RECONNECT", "OK"); +} +static jboolean android_net_wifi_reassociateCommand(JNIEnv* env, jobject clazz) +{ + return doBooleanCommand("REASSOCIATE", "OK"); +} + +static jboolean android_net_wifi_scanCommand(JNIEnv* env, jobject clazz) +{ + jboolean result; + // Ignore any error from setting the scan mode. + // The scan will still work. + (void)doBooleanCommand("DRIVER SCAN-ACTIVE", "OK"); + result = doBooleanCommand("SCAN", "OK"); + (void)doBooleanCommand("DRIVER SCAN-PASSIVE", "OK"); + return result; +} + +static jboolean android_net_wifi_setScanModeCommand(JNIEnv* env, jobject clazz, jboolean setActive) +{ + jboolean result; + // Ignore any error from setting the scan mode. + // The scan will still work. + if (setActive) { + return doBooleanCommand("DRIVER SCAN-ACTIVE", "OK"); + } else { + return doBooleanCommand("DRIVER SCAN-PASSIVE", "OK"); + } +} + +static jboolean android_net_wifi_startDriverCommand(JNIEnv* env, jobject clazz) +{ + return doBooleanCommand("DRIVER START", "OK"); +} + +static jboolean android_net_wifi_stopDriverCommand(JNIEnv* env, jobject clazz) +{ + return doBooleanCommand("DRIVER STOP", "OK"); +} + +static jint android_net_wifi_getRssiCommand(JNIEnv* env, jobject clazz) +{ + char reply[256]; + int rssi = -200; + + if (doCommand("DRIVER RSSI", reply, sizeof(reply)) != 0) { + return (jint)-1; + } + // reply comes back in the form "<SSID> rssi XX" where XX is the + // number we're interested in. if we're associating, it returns "OK". + if (strcmp(reply, "OK") != 0) { + sscanf(reply, "%*s %*s %d", &rssi); + } + return (jint)rssi; +} + +static jint android_net_wifi_getLinkSpeedCommand(JNIEnv* env, jobject clazz) +{ + char reply[256]; + int linkspeed; + + if (doCommand("DRIVER LINKSPEED", reply, sizeof(reply)) != 0) { + return (jint)-1; + } + // reply comes back in the form "LinkSpeed XX" where XX is the + // number we're interested in. + sscanf(reply, "%*s %u", &linkspeed); + return (jint)linkspeed; +} + +static jstring android_net_wifi_getMacAddressCommand(JNIEnv* env, jobject clazz) +{ + char reply[256]; + char buf[256]; + + if (doCommand("DRIVER MACADDR", reply, sizeof(reply)) != 0) { + return env->NewStringUTF(NULL); + } + // reply comes back in the form "Macaddr = XX.XX.XX.XX.XX.XX" where XX + // is the part of the string we're interested in. + if (sscanf(reply, "%*s = %255s", buf) == 1) + return env->NewStringUTF(buf); + else + return env->NewStringUTF(NULL); +} + +static jboolean android_net_wifi_setPowerModeCommand(JNIEnv* env, jobject clazz, jint mode) +{ + char cmdstr[256]; + + int numWritten = snprintf(cmdstr, sizeof(cmdstr), "DRIVER POWERMODE %d", mode); + int cmdTooLong = numWritten >= (int)sizeof(cmdstr); + + return (jboolean)!cmdTooLong && doBooleanCommand(cmdstr, "OK"); +} + +static jboolean android_net_wifi_setBluetoothCoexistenceModeCommand(JNIEnv* env, jobject clazz, jint mode) +{ + char cmdstr[256]; + + int numWritten = snprintf(cmdstr, sizeof(cmdstr), "DRIVER BTCOEXMODE %d", mode); + int cmdTooLong = numWritten >= (int)sizeof(cmdstr); + + return (jboolean)!cmdTooLong && doBooleanCommand(cmdstr, "OK"); +} + +static jboolean android_net_wifi_saveConfigCommand(JNIEnv* env, jobject clazz) +{ + // Make sure we never write out a value for AP_SCAN other than 1 + (void)doBooleanCommand("AP_SCAN 1", "OK"); + return doBooleanCommand("SAVE_CONFIG", "OK"); +} + +static jboolean android_net_wifi_reloadConfigCommand(JNIEnv* env, jobject clazz) +{ + return doBooleanCommand("RECONFIGURE", "OK"); +} + +static jboolean android_net_wifi_setScanResultHandlingCommand(JNIEnv* env, jobject clazz, jint mode) +{ + char cmdstr[256]; + + int numWritten = snprintf(cmdstr, sizeof(cmdstr), "AP_SCAN %d", mode); + int cmdTooLong = numWritten >= (int)sizeof(cmdstr); + + return (jboolean)!cmdTooLong && doBooleanCommand(cmdstr, "OK"); +} + +static jboolean android_net_wifi_addToBlacklistCommand(JNIEnv* env, jobject clazz, jstring bssid) +{ + char cmdstr[256]; + jboolean isCopy; + + const char *bssidStr = env->GetStringUTFChars(bssid, &isCopy); + + int cmdTooLong = snprintf(cmdstr, sizeof(cmdstr), "BLACKLIST %s", bssidStr) >= sizeof(cmdstr); + + env->ReleaseStringUTFChars(bssid, bssidStr); + + return (jboolean)!cmdTooLong && doBooleanCommand(cmdstr, "OK"); +} + +static jboolean android_net_wifi_clearBlacklistCommand(JNIEnv* env, jobject clazz) +{ + return doBooleanCommand("BLACKLIST clear", "OK"); +} + +static jboolean android_net_wifi_doDhcpRequest(JNIEnv* env, jobject clazz, jobject info) +{ + jint ipaddr, gateway, mask, dns1, dns2, server, lease; + jboolean succeeded = ((jboolean)::do_dhcp_request(&ipaddr, &gateway, &mask, + &dns1, &dns2, &server, &lease) == 0); + if (succeeded && dhcpInfoFieldIds.dhcpInfoClass != NULL) { + env->SetIntField(info, dhcpInfoFieldIds.ipaddress, ipaddr); + env->SetIntField(info, dhcpInfoFieldIds.gateway, gateway); + env->SetIntField(info, dhcpInfoFieldIds.netmask, mask); + env->SetIntField(info, dhcpInfoFieldIds.dns1, dns1); + env->SetIntField(info, dhcpInfoFieldIds.dns2, dns2); + env->SetIntField(info, dhcpInfoFieldIds.serverAddress, server); + env->SetIntField(info, dhcpInfoFieldIds.leaseDuration, lease); + } + return succeeded; +} + +static jstring android_net_wifi_getDhcpError(JNIEnv* env, jobject clazz) +{ + return env->NewStringUTF(::get_dhcp_error_string()); +} + +// ---------------------------------------------------------------------------- + +/* + * JNI registration. + */ +static JNINativeMethod gWifiMethods[] = { + /* name, signature, funcPtr */ + + { "loadDriver", "()Z", (void *)android_net_wifi_loadDriver }, + { "unloadDriver", "()Z", (void *)android_net_wifi_unloadDriver }, + { "startSupplicant", "()Z", (void *)android_net_wifi_startSupplicant }, + { "stopSupplicant", "()Z", (void *)android_net_wifi_stopSupplicant }, + { "connectToSupplicant", "()Z", (void *)android_net_wifi_connectToSupplicant }, + { "closeSupplicantConnection", "()V", (void *)android_net_wifi_closeSupplicantConnection }, + + { "listNetworksCommand", "()Ljava/lang/String;", + (void*) android_net_wifi_listNetworksCommand }, + { "addNetworkCommand", "()I", (void*) android_net_wifi_addNetworkCommand }, + { "setNetworkVariableCommand", "(ILjava/lang/String;Ljava/lang/String;)Z", + (void*) android_net_wifi_setNetworkVariableCommand }, + { "getNetworkVariableCommand", "(ILjava/lang/String;)Ljava/lang/String;", + (void*) android_net_wifi_getNetworkVariableCommand }, + { "removeNetworkCommand", "(I)Z", (void*) android_net_wifi_removeNetworkCommand }, + { "enableNetworkCommand", "(IZ)Z", (void*) android_net_wifi_enableNetworkCommand }, + { "disableNetworkCommand", "(I)Z", (void*) android_net_wifi_disableNetworkCommand }, + { "waitForEvent", "()Ljava/lang/String;", (void*) android_net_wifi_waitForEvent }, + { "statusCommand", "()Ljava/lang/String;", (void*) android_net_wifi_statusCommand }, + { "scanResultsCommand", "()Ljava/lang/String;", (void*) android_net_wifi_scanResultsCommand }, + { "pingCommand", "()Z", (void *)android_net_wifi_pingCommand }, + { "disconnectCommand", "()Z", (void *)android_net_wifi_disconnectCommand }, + { "reconnectCommand", "()Z", (void *)android_net_wifi_reconnectCommand }, + { "reassociateCommand", "()Z", (void *)android_net_wifi_reassociateCommand }, + { "scanCommand", "()Z", (void*) android_net_wifi_scanCommand }, + { "setScanModeCommand", "(Z)Z", (void*) android_net_wifi_setScanModeCommand }, + { "startDriverCommand", "()Z", (void*) android_net_wifi_startDriverCommand }, + { "stopDriverCommand", "()Z", (void*) android_net_wifi_stopDriverCommand }, + { "setPowerModeCommand", "(I)Z", (void*) android_net_wifi_setPowerModeCommand }, + { "setBluetoothCoexistenceModeCommand", "(I)Z", + (void*) android_net_wifi_setBluetoothCoexistenceModeCommand }, + { "getRssiCommand", "()I", (void*) android_net_wifi_getRssiCommand }, + { "getLinkSpeedCommand", "()I", (void*) android_net_wifi_getLinkSpeedCommand }, + { "getMacAddressCommand", "()Ljava/lang/String;", (void*) android_net_wifi_getMacAddressCommand }, + { "saveConfigCommand", "()Z", (void*) android_net_wifi_saveConfigCommand }, + { "reloadConfigCommand", "()Z", (void*) android_net_wifi_reloadConfigCommand }, + { "setScanResultHandlingCommand", "(I)Z", (void*) android_net_wifi_setScanResultHandlingCommand }, + { "addToBlacklistCommand", "(Ljava/lang/String;)Z", (void*) android_net_wifi_addToBlacklistCommand }, + { "clearBlacklistCommand", "()Z", (void*) android_net_wifi_clearBlacklistCommand }, + + { "doDhcpRequest", "(Landroid/net/DhcpInfo;)Z", (void*) android_net_wifi_doDhcpRequest }, + { "getDhcpError", "()Ljava/lang/String;", (void*) android_net_wifi_getDhcpError }, +}; + +int register_android_net_wifi_WifiManager(JNIEnv* env) +{ + jclass wifi = env->FindClass(WIFI_PKG_NAME); + LOG_FATAL_IF(wifi == NULL, "Unable to find class " WIFI_PKG_NAME); + + dhcpInfoFieldIds.dhcpInfoClass = env->FindClass("android/net/DhcpInfo"); + if (dhcpInfoFieldIds.dhcpInfoClass != NULL) { + dhcpInfoFieldIds.constructorId = env->GetMethodID(dhcpInfoFieldIds.dhcpInfoClass, "<init>", "()V"); + dhcpInfoFieldIds.ipaddress = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "ipAddress", "I"); + dhcpInfoFieldIds.gateway = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "gateway", "I"); + dhcpInfoFieldIds.netmask = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "netmask", "I"); + dhcpInfoFieldIds.dns1 = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "dns1", "I"); + dhcpInfoFieldIds.dns2 = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "dns2", "I"); + dhcpInfoFieldIds.serverAddress = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "serverAddress", "I"); + dhcpInfoFieldIds.leaseDuration = env->GetFieldID(dhcpInfoFieldIds.dhcpInfoClass, "leaseDuration", "I"); + } + + return AndroidRuntime::registerNativeMethods(env, + WIFI_PKG_NAME, gWifiMethods, NELEM(gWifiMethods)); +} + +}; // namespace android diff --git a/core/jni/android_nio_utils.cpp b/core/jni/android_nio_utils.cpp new file mode 100644 index 0000000..584e7a4 --- /dev/null +++ b/core/jni/android_nio_utils.cpp @@ -0,0 +1,114 @@ +/* + * 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. + */ + +#include "android_nio_utils.h" + +struct NioJNIData { + jclass nioAccessClass; + + jmethodID getBasePointerID; + jmethodID getBaseArrayID; + jmethodID getBaseArrayOffsetID; +}; + +static NioJNIData gNioJNI; + +void* android::nio_getPointer(JNIEnv *_env, jobject buffer, jarray *array) { + assert(array); + + jlong pointer; + jint offset; + void *data; + + pointer = _env->CallStaticLongMethod(gNioJNI.nioAccessClass, + gNioJNI.getBasePointerID, buffer); + if (pointer != 0L) { + *array = NULL; + return (void *) (jint) pointer; + } + + *array = (jarray) _env->CallStaticObjectMethod(gNioJNI.nioAccessClass, + gNioJNI.getBaseArrayID, buffer); + offset = _env->CallStaticIntMethod(gNioJNI.nioAccessClass, + gNioJNI.getBaseArrayOffsetID, buffer); + data = _env->GetPrimitiveArrayCritical(*array, (jboolean *) 0); + + return (void *) ((char *) data + offset); +} + + +void android::nio_releasePointer(JNIEnv *_env, jarray array, void *data, + jboolean commit) { + _env->ReleasePrimitiveArrayCritical(array, data, + commit ? 0 : JNI_ABORT); +} + +/////////////////////////////////////////////////////////////////////////////// + +android::AutoBufferPointer::AutoBufferPointer(JNIEnv* env, jobject nioBuffer, + jboolean commit) { + fEnv = env; + fCommit = commit; + fPointer = android::nio_getPointer(env, nioBuffer, &fArray); +} + +android::AutoBufferPointer::~AutoBufferPointer() { + if (NULL != fArray) { + android::nio_releasePointer(fEnv, fArray, fPointer, fCommit); + } +} + +/////////////////////////////////////////////////////////////////////////////// + +static jclass findClass(JNIEnv* env, const char name[]) { + jclass c = env->FindClass(name); + LOG_FATAL_IF(!c, "Unable to find class %s", name); + return c; +} + +static jmethodID findStaticMethod(JNIEnv* env, jclass c, const char method[], + const char params[]) { + jmethodID m = env->GetStaticMethodID(c, method, params); + LOG_FATAL_IF(!m, "Unable to find method %s", method); + return m; +} + +static jfieldID getFieldID(JNIEnv* env, jclass c, const char name[], + const char type[]) { + jfieldID f = env->GetFieldID(c, name, type); + LOG_FATAL_IF(!f, "Unable to find field %s", name); + return f; +} + +namespace android { + +int register_android_nio_utils(JNIEnv* env); +int register_android_nio_utils(JNIEnv* env) { + jclass localClass = findClass(env, "java/nio/NIOAccess"); + gNioJNI.getBasePointerID = findStaticMethod(env, localClass, + "getBasePointer", "(Ljava/nio/Buffer;)J"); + gNioJNI.getBaseArrayID = findStaticMethod(env, localClass, + "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;"); + gNioJNI.getBaseArrayOffsetID = findStaticMethod(env, localClass, + "getBaseArrayOffset", "(Ljava/nio/Buffer;)I"); + + // now record a permanent version of the class ID + gNioJNI.nioAccessClass = (jclass) env->NewGlobalRef(localClass); + + return 0; +} + +} diff --git a/core/jni/android_nio_utils.h b/core/jni/android_nio_utils.h new file mode 100644 index 0000000..69c360c --- /dev/null +++ b/core/jni/android_nio_utils.h @@ -0,0 +1,74 @@ +/* + * 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_nio_utils_DEFINED +#define android_nio_utils_DEFINED + +#include <android_runtime/AndroidRuntime.h> + +namespace android { + +/** + * Given an nio.Buffer, return a pointer to it, beginning at its current + * position. The returned pointer is only valid for the current JNI stack-frame. + * For performance, it does not create any global references, so the getPointer + * (and releasePointer if array is returned non-null) must be done in the + * same JNI stack-frame. + * + * @param env The current JNI env + * @param buffer The nio.Buffer object + * @param array REQUIRED. Output. If on return it is set to non-null, then + * nio_releasePointer must be called with the array + * and the returned pointer when the caller is through with it. + * If on return it is set to null, do not call + * nio_releasePointer. + * @return The pointer to the memory in the buffer object + */ +void* nio_getPointer(JNIEnv *env, jobject buffer, jarray *array); + +/** + * Call this if android_nio_getPointer returned non-null in its array parameter. + * Pass that array and the returned pointer when you are done accessing the + * pointer. If called (i.e. array is non-null), it must be called in the same + * JNI stack-frame as getPointer + * + * @param env The current JNI env + * @param buffer The array returned from android_nio_getPointer (!= null) + * @param pointer The pointer returned by android_nio_getPointer + * @param commit JNI_FALSE if the pointer was just read, and JNI_TRUE if + * the pointer was written to. + */ +void nio_releasePointer(JNIEnv *env, jarray array, void *pointer, + jboolean commit); + +class AutoBufferPointer { +public: + AutoBufferPointer(JNIEnv* env, jobject nioBuffer, jboolean commit); + ~AutoBufferPointer(); + + void* pointer() const { return fPointer; } + +private: + JNIEnv* fEnv; + void* fPointer; + jarray fArray; + jint fRemaining; + jboolean fCommit; +}; + +} /* namespace android */ + +#endif diff --git a/core/jni/android_os_Debug.cpp b/core/jni/android_os_Debug.cpp new file mode 100644 index 0000000..6ba949c --- /dev/null +++ b/core/jni/android_os_Debug.cpp @@ -0,0 +1,307 @@ +/* + * Copyright (C) 2007 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. + */ + +#include "JNIHelp.h" +#include "jni.h" +#include "utils/misc.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <time.h> +#include <sys/time.h> + +#ifdef HAVE_MALLOC_H +#include <malloc.h> +#endif + +namespace android +{ + +static jfieldID dalvikPss_field; +static jfieldID dalvikPrivateDirty_field; +static jfieldID dalvikSharedDirty_field; +static jfieldID nativePss_field; +static jfieldID nativePrivateDirty_field; +static jfieldID nativeSharedDirty_field; +static jfieldID otherPss_field; +static jfieldID otherPrivateDirty_field; +static jfieldID otherSharedDirty_field; + +struct stats_t { + int dalvikPss; + int dalvikPrivateDirty; + int dalvikSharedDirty; + + int nativePss; + int nativePrivateDirty; + int nativeSharedDirty; + + int otherPss; + int otherPrivateDirty; + int otherSharedDirty; +}; + +#define BINDER_STATS "/proc/binder/stats" + +static jlong android_os_Debug_getNativeHeapSize(JNIEnv *env, jobject clazz) +{ +#ifdef HAVE_MALLOC_H + struct mallinfo info = mallinfo(); + return (jlong) info.usmblks; +#else + return -1; +#endif +} + +static jlong android_os_Debug_getNativeHeapAllocatedSize(JNIEnv *env, jobject clazz) +{ +#ifdef HAVE_MALLOC_H + struct mallinfo info = mallinfo(); + return (jlong) info.uordblks; +#else + return -1; +#endif +} + +static jlong android_os_Debug_getNativeHeapFreeSize(JNIEnv *env, jobject clazz) +{ +#ifdef HAVE_MALLOC_H + struct mallinfo info = mallinfo(); + return (jlong) info.fordblks; +#else + return -1; +#endif +} + +static int read_mapinfo(FILE *fp, stats_t* stats) +{ + char line[1024]; + int len; + int skip; + + unsigned start = 0, size = 0, resident = 0, pss = 0; + unsigned shared_clean = 0, shared_dirty = 0; + unsigned private_clean = 0, private_dirty = 0; + unsigned referenced = 0; + + int isNativeHeap; + int isDalvikHeap; + int isSqliteHeap; + +again: + isNativeHeap = 0; + isDalvikHeap = 0; + isSqliteHeap = 0; + skip = 0; + + if(fgets(line, 1024, fp) == 0) return 0; + + len = strlen(line); + if (len < 1) return 0; + line[--len] = 0; + + /* ignore guard pages */ + if (line[18] == '-') skip = 1; + + start = strtoul(line, 0, 16); + + if (len >= 50) { + if (!strcmp(line + 49, "[heap]")) { + isNativeHeap = 1; + } else if (!strncmp(line + 49, "/dalvik-LinearAlloc", strlen("/dalvik-LinearAlloc"))) { + isDalvikHeap = 1; + } else if (!strncmp(line + 49, "/mspace/dalvik-heap", strlen("/mspace/dalvik-heap"))) { + isDalvikHeap = 1; + } else if (!strncmp(line + 49, "/dalvik-heap-bitmap/", strlen("/dalvik-heap-bitmap/"))) { + isDalvikHeap = 1; + } else if (!strncmp(line + 49, "/tmp/sqlite-heap", strlen("/tmp/sqlite-heap"))) { + isSqliteHeap = 1; + } + } + + // TODO: This needs to be fixed to be less fragile. If the order of this file changes or a new + // line is add, this method will return without filling out any of the information. + + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Size: %d kB", &size) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Rss: %d kB", &resident) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Pss: %d kB", &pss) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Shared_Clean: %d kB", &shared_clean) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Shared_Dirty: %d kB", &shared_dirty) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Private_Clean: %d kB", &private_clean) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Private_Dirty: %d kB", &private_dirty) != 1) return 0; + if (fgets(line, 1024, fp) == 0) return 0; + if (sscanf(line, "Referenced: %d kB", &referenced) != 1) return 0; + + if (skip) { + goto again; + } + + if (isNativeHeap) { + stats->nativePss += pss; + stats->nativePrivateDirty += private_dirty; + stats->nativeSharedDirty += shared_dirty; + } else if (isDalvikHeap) { + stats->dalvikPss += pss; + stats->dalvikPrivateDirty += private_dirty; + stats->dalvikSharedDirty += shared_dirty; + } else if (isSqliteHeap) { + // ignore + } else { + stats->otherPss += pss; + stats->otherPrivateDirty += shared_dirty; + stats->otherSharedDirty += private_dirty; + } + + return 1; +} + +static void load_maps(int pid, stats_t* stats) +{ + char tmp[128]; + FILE *fp; + + sprintf(tmp, "/proc/%d/smaps", pid); + fp = fopen(tmp, "r"); + if (fp == 0) return; + + while (read_mapinfo(fp, stats) != 0) { + // Do nothing + } + fclose(fp); +} + +static void android_os_Debug_getDirtyPages(JNIEnv *env, jobject clazz, jobject object) +{ + stats_t stats; + memset(&stats, 0, sizeof(stats_t)); + + load_maps(getpid(), &stats); + + env->SetIntField(object, dalvikPss_field, stats.dalvikPss); + env->SetIntField(object, dalvikPrivateDirty_field, stats.dalvikPrivateDirty); + env->SetIntField(object, dalvikSharedDirty_field, stats.dalvikSharedDirty); + + env->SetIntField(object, nativePss_field, stats.nativePss); + env->SetIntField(object, nativePrivateDirty_field, stats.nativePrivateDirty); + env->SetIntField(object, nativeSharedDirty_field, stats.nativeSharedDirty); + + env->SetIntField(object, otherPss_field, stats.otherPss); + env->SetIntField(object, otherPrivateDirty_field, stats.otherPrivateDirty); + env->SetIntField(object, otherSharedDirty_field, stats.otherSharedDirty); +} + +static jint read_binder_stat(const char* stat) +{ + FILE* fp = fopen(BINDER_STATS, "r"); + if (fp == NULL) { + return -1; + } + + char line[1024]; + + char compare[128]; + int len = snprintf(compare, 128, "proc %d", getpid()); + + // loop until we have the block that represents this process + do { + if (fgets(line, 1024, fp) == 0) { + return -1; + } + } while (strncmp(compare, line, len)); + + // now that we have this process, read until we find the stat that we are looking for + len = snprintf(compare, 128, " %s: ", stat); + + do { + if (fgets(line, 1024, fp) == 0) { + return -1; + } + } while (strncmp(compare, line, len)); + + // we have the line, now increment the line ptr to the value + char* ptr = line + len; + return atoi(ptr); +} + +static jint android_os_Debug_getBinderSentTransactions(JNIEnv *env, jobject clazz) +{ + return read_binder_stat("bcTRANSACTION"); +} + +static jint android_os_getBinderReceivedTransactions(JNIEnv *env, jobject clazz) +{ + return read_binder_stat("brTRANSACTION"); +} + +// these are implemented in android_util_Binder.cpp +jint android_os_Debug_getLocalObjectCount(JNIEnv* env, jobject clazz); +jint android_os_Debug_getProxyObjectCount(JNIEnv* env, jobject clazz); +jint android_os_Debug_getDeathObjectCount(JNIEnv* env, jobject clazz); + +/* + * JNI registration. + */ + +static JNINativeMethod gMethods[] = { + { "getNativeHeapSize", "()J", + (void*) android_os_Debug_getNativeHeapSize }, + { "getNativeHeapAllocatedSize", "()J", + (void*) android_os_Debug_getNativeHeapAllocatedSize }, + { "getNativeHeapFreeSize", "()J", + (void*) android_os_Debug_getNativeHeapFreeSize }, + { "getMemoryInfo", "(Landroid/os/Debug$MemoryInfo;)V", + (void*) android_os_Debug_getDirtyPages }, + { "getBinderSentTransactions", "()I", + (void*) android_os_Debug_getBinderSentTransactions }, + { "getBinderReceivedTransactions", "()I", + (void*) android_os_getBinderReceivedTransactions }, + { "getBinderLocalObjectCount", "()I", + (void*)android_os_Debug_getLocalObjectCount }, + { "getBinderProxyObjectCount", "()I", + (void*)android_os_Debug_getProxyObjectCount }, + { "getBinderDeathObjectCount", "()I", + (void*)android_os_Debug_getDeathObjectCount }, +}; + +int register_android_os_Debug(JNIEnv *env) +{ + jclass clazz = env->FindClass("android/os/Debug$MemoryInfo"); + + dalvikPss_field = env->GetFieldID(clazz, "dalvikPss", "I"); + dalvikPrivateDirty_field = env->GetFieldID(clazz, "dalvikPrivateDirty", "I"); + dalvikSharedDirty_field = env->GetFieldID(clazz, "dalvikSharedDirty", "I"); + + nativePss_field = env->GetFieldID(clazz, "nativePss", "I"); + nativePrivateDirty_field = env->GetFieldID(clazz, "nativePrivateDirty", "I"); + nativeSharedDirty_field = env->GetFieldID(clazz, "nativeSharedDirty", "I"); + + otherPss_field = env->GetFieldID(clazz, "otherPss", "I"); + otherPrivateDirty_field = env->GetFieldID(clazz, "otherPrivateDirty", "I"); + otherSharedDirty_field = env->GetFieldID(clazz, "otherSharedDirty", "I"); + + return jniRegisterNativeMethods(env, "android/os/Debug", gMethods, NELEM(gMethods)); +} + +}; diff --git a/core/jni/android_os_Exec.cpp b/core/jni/android_os_Exec.cpp new file mode 100644 index 0000000..ca5e695 --- /dev/null +++ b/core/jni/android_os_Exec.cpp @@ -0,0 +1,215 @@ +/* + * Copyright (C) 2007 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. + */ + +#define LOG_TAG "Exec" + +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" +#include "android_runtime/AndroidRuntime.h" + +#include <sys/types.h> +#include <sys/ioctl.h> +#include <sys/wait.h> +#include <errno.h> +#include <fcntl.h> +#include <stdlib.h> +#include <unistd.h> +#include <termios.h> + +namespace android +{ + +static jclass class_fileDescriptor; +static jfieldID field_fileDescriptor_descriptor; +static jmethodID method_fileDescriptor_init; + + +static int create_subprocess(const char *cmd, const char *arg0, const char *arg1, + int* pProcessId) +{ + char *devname; + int ptm; + pid_t pid; + + ptm = open("/dev/ptmx", O_RDWR); // | O_NOCTTY); + if(ptm < 0){ + LOGE("[ cannot open /dev/ptmx - %s ]\n",strerror(errno)); + return -1; + } + fcntl(ptm, F_SETFD, FD_CLOEXEC); + + if(grantpt(ptm) || unlockpt(ptm) || + ((devname = (char*) ptsname(ptm)) == 0)){ + LOGE("[ trouble with /dev/ptmx - %s ]\n", strerror(errno)); + return -1; + } + + pid = fork(); + if(pid < 0) { + LOGE("- fork failed: %s -\n", strerror(errno)); + return -1; + } + + if(pid == 0){ + int pts; + + setsid(); + + pts = open(devname, O_RDWR); + if(pts < 0) exit(-1); + + dup2(pts, 0); + dup2(pts, 1); + dup2(pts, 2); + + close(ptm); + + execl(cmd, cmd, arg0, arg1, NULL); + exit(-1); + } else { + *pProcessId = (int) pid; + return ptm; + } +} + + +static jobject android_os_Exec_createSubProcess(JNIEnv *env, jobject clazz, + jstring cmd, jstring arg0, jstring arg1, jintArray processIdArray) +{ + const jchar* str = cmd ? env->GetStringCritical(cmd, 0) : 0; + String8 cmd_8; + if (str) { + cmd_8 = String8(str, env->GetStringLength(cmd)); + env->ReleaseStringCritical(cmd, str); + } + + str = arg0 ? env->GetStringCritical(arg0, 0) : 0; + const char* arg0Str = 0; + String8 arg0_8; + if (str) { + arg0_8 = String8(str, env->GetStringLength(arg0)); + env->ReleaseStringCritical(arg0, str); + arg0Str = arg0_8.string(); + } + + str = arg1 ? env->GetStringCritical(arg1, 0) : 0; + const char* arg1Str = 0; + String8 arg1_8; + if (str) { + arg1_8 = String8(str, env->GetStringLength(arg1)); + env->ReleaseStringCritical(arg1, str); + arg1Str = arg1_8.string(); + } + + int procId; + int ptm = create_subprocess(cmd_8.string(), arg0Str, arg1Str, &procId); + + if (processIdArray) { + int procIdLen = env->GetArrayLength(processIdArray); + if (procIdLen > 0) { + jboolean isCopy; + + int* pProcId = (int*) env->GetPrimitiveArrayCritical(processIdArray, &isCopy); + if (pProcId) { + *pProcId = procId; + env->ReleasePrimitiveArrayCritical(processIdArray, pProcId, 0); + } + } + } + + jobject result = env->NewObject(class_fileDescriptor, method_fileDescriptor_init); + + if (!result) { + LOGE("Couldn't create a FileDescriptor."); + } + else { + env->SetIntField(result, field_fileDescriptor_descriptor, ptm); + } + + return result; +} + + +static void android_os_Exec_setPtyWindowSize(JNIEnv *env, jobject clazz, + jobject fileDescriptor, jint row, jint col, jint xpixel, jint ypixel) +{ + int fd; + struct winsize sz; + + fd = jniGetFDFromFileDescriptor(env, fileDescriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + sz.ws_row = row; + sz.ws_col = col; + sz.ws_xpixel = xpixel; + sz.ws_ypixel = ypixel; + + ioctl(fd, TIOCSWINSZ, &sz); +} + +static int android_os_Exec_waitFor(JNIEnv *env, jobject clazz, + jint procId) { + int status; + waitpid(procId, &status, 0); + int result = 0; + if (WIFEXITED(status)) { + result = WEXITSTATUS(status); + } + return result; +} + +static JNINativeMethod method_table[] = { + { "createSubprocess", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;[I)Ljava/io/FileDescriptor;", + (void*) android_os_Exec_createSubProcess }, + { "setPtyWindowSize", "(Ljava/io/FileDescriptor;IIII)V", + (void*) android_os_Exec_setPtyWindowSize}, + { "waitFor", "(I)I", + (void*) android_os_Exec_waitFor} +}; + +int register_android_os_Exec(JNIEnv *env) +{ + class_fileDescriptor = env->FindClass("java/io/FileDescriptor"); + + if (class_fileDescriptor == NULL) { + LOGE("Can't find java/io/FileDescriptor"); + return -1; + } + + field_fileDescriptor_descriptor = env->GetFieldID(class_fileDescriptor, "descriptor", "I"); + + if (field_fileDescriptor_descriptor == NULL) { + LOGE("Can't find FileDescriptor.descriptor"); + return -1; + } + + method_fileDescriptor_init = env->GetMethodID(class_fileDescriptor, "<init>", "()V"); + if (method_fileDescriptor_init == NULL) { + LOGE("Can't find FileDescriptor.init"); + return -1; + } + + return AndroidRuntime::registerNativeMethods( + env, "android/os/Exec", + method_table, NELEM(method_table)); +} + +}; diff --git a/core/jni/android_os_FileUtils.cpp b/core/jni/android_os_FileUtils.cpp new file mode 100644 index 0000000..21cb919 --- /dev/null +++ b/core/jni/android_os_FileUtils.cpp @@ -0,0 +1,208 @@ +/* //device/libs/android_runtime/android_util_Process.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "FileUtils" + +#include <utils/Log.h> + +#include <android_runtime/AndroidRuntime.h> + +#include "JNIHelp.h" + +#include <sys/errno.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <fcntl.h> +#include <signal.h> + +#if HAVE_ANDROID_OS +#include <sys/ioctl.h> +#include <linux/msdos_fs.h> +#endif + +namespace android { + +static jclass gFileStatusClass; +static jfieldID gFileStatusDevFieldID; +static jfieldID gFileStatusInoFieldID; +static jfieldID gFileStatusModeFieldID; +static jfieldID gFileStatusNlinkFieldID; +static jfieldID gFileStatusUidFieldID; +static jfieldID gFileStatusGidFieldID; +static jfieldID gFileStatusSizeFieldID; +static jfieldID gFileStatusBlksizeFieldID; +static jfieldID gFileStatusBlocksFieldID; +static jfieldID gFileStatusAtimeFieldID; +static jfieldID gFileStatusMtimeFieldID; +static jfieldID gFileStatusCtimeFieldID; + +jint android_os_FileUtils_setPermissions(JNIEnv* env, jobject clazz, + jstring file, jint mode, + jint uid, jint gid) +{ + #if HAVE_ANDROID_OS + const jchar* str = env->GetStringCritical(file, 0); + String8 file8; + if (str) { + file8 = String8(str, env->GetStringLength(file)); + env->ReleaseStringCritical(file, str); + } + if (file8.size() <= 0) { + return ENOENT; + } + if (uid >= 0 || gid >= 0) { + int res = chown(file8.string(), uid, gid); + if (res != 0) { + return errno; + } + } + return chmod(file8.string(), mode) == 0 ? 0 : errno; + #else + return ENOSYS; + #endif +} + +jint android_os_FileUtils_getPermissions(JNIEnv* env, jobject clazz, + jstring file, jintArray outArray) +{ + #if HAVE_ANDROID_OS + const jchar* str = env->GetStringCritical(file, 0); + String8 file8; + if (str) { + file8 = String8(str, env->GetStringLength(file)); + env->ReleaseStringCritical(file, str); + } + if (file8.size() <= 0) { + return ENOENT; + } + struct stat st; + if (stat(file8.string(), &st) != 0) { + return errno; + } + jint* array = (jint*)env->GetPrimitiveArrayCritical(outArray, 0); + if (array) { + int len = env->GetArrayLength(outArray); + if (len >= 1) { + array[0] = st.st_mode; + } + if (len >= 2) { + array[1] = st.st_uid; + } + if (len >= 3) { + array[2] = st.st_gid; + } + } + env->ReleasePrimitiveArrayCritical(outArray, array, 0); + return 0; + #else + return ENOSYS; + #endif +} + +jint android_os_FileUtils_getFatVolumeId(JNIEnv* env, jobject clazz, jstring path) +{ + #if HAVE_ANDROID_OS + if (path == NULL) { + jniThrowException(env, "java/lang/IllegalArgumentException", NULL); + return -1; + } + const char *pathStr = env->GetStringUTFChars(path, NULL); + int result = -1; + // only if our system supports this ioctl + #ifdef VFAT_IOCTL_GET_VOLUME_ID + int fd = open(pathStr, O_RDONLY); + if (fd >= 0) { + result = ioctl(fd, VFAT_IOCTL_GET_VOLUME_ID); + close(fd); + } + #endif + + env->ReleaseStringUTFChars(path, pathStr); + return result; + #else + return -1; + #endif +} + +jboolean android_os_FileUtils_getFileStatus(JNIEnv* env, jobject clazz, jstring path, jobject fileStatus) { + const char* pathStr = env->GetStringUTFChars(path, NULL); + jboolean ret = false; + + struct stat s; + int res = stat(pathStr, &s); + if (res == 0) { + ret = true; + if (fileStatus != NULL) { + env->SetIntField(fileStatus, gFileStatusDevFieldID, s.st_dev); + env->SetIntField(fileStatus, gFileStatusInoFieldID, s.st_ino); + env->SetIntField(fileStatus, gFileStatusModeFieldID, s.st_mode); + env->SetIntField(fileStatus, gFileStatusNlinkFieldID, s.st_nlink); + env->SetIntField(fileStatus, gFileStatusUidFieldID, s.st_uid); + env->SetIntField(fileStatus, gFileStatusGidFieldID, s.st_gid); + env->SetLongField(fileStatus, gFileStatusSizeFieldID, s.st_size); + env->SetIntField(fileStatus, gFileStatusBlksizeFieldID, s.st_blksize); + env->SetLongField(fileStatus, gFileStatusBlocksFieldID, s.st_blocks); + env->SetLongField(fileStatus, gFileStatusAtimeFieldID, s.st_atime); + env->SetLongField(fileStatus, gFileStatusMtimeFieldID, s.st_mtime); + env->SetLongField(fileStatus, gFileStatusCtimeFieldID, s.st_ctime); + } + } + + env->ReleaseStringUTFChars(path, pathStr); + + return ret; +} + +static const JNINativeMethod methods[] = { + {"setPermissions", "(Ljava/lang/String;III)I", (void*)android_os_FileUtils_setPermissions}, + {"getPermissions", "(Ljava/lang/String;[I)I", (void*)android_os_FileUtils_getPermissions}, + {"getFatVolumeId", "(Ljava/lang/String;)I", (void*)android_os_FileUtils_getFatVolumeId}, + {"getFileStatus", "(Ljava/lang/String;Landroid/os/FileUtils$FileStatus;)Z", (void*)android_os_FileUtils_getFileStatus}, +}; + +static const char* const kFileUtilsPathName = "android/os/FileUtils"; + +int register_android_os_FileUtils(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass(kFileUtilsPathName); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.FileUtils"); + + gFileStatusClass = env->FindClass("android/os/FileUtils$FileStatus"); + LOG_FATAL_IF(gFileStatusClass == NULL, "Unable to find class android.os.FileUtils$FileStatus"); + + gFileStatusDevFieldID = env->GetFieldID(gFileStatusClass, "dev", "I"); + gFileStatusInoFieldID = env->GetFieldID(gFileStatusClass, "ino", "I"); + gFileStatusModeFieldID = env->GetFieldID(gFileStatusClass, "mode", "I"); + gFileStatusNlinkFieldID = env->GetFieldID(gFileStatusClass, "nlink", "I"); + gFileStatusUidFieldID = env->GetFieldID(gFileStatusClass, "uid", "I"); + gFileStatusGidFieldID = env->GetFieldID(gFileStatusClass, "gid", "I"); + gFileStatusSizeFieldID = env->GetFieldID(gFileStatusClass, "size", "J"); + gFileStatusBlksizeFieldID = env->GetFieldID(gFileStatusClass, "blksize", "I"); + gFileStatusBlocksFieldID = env->GetFieldID(gFileStatusClass, "blocks", "J"); + gFileStatusAtimeFieldID = env->GetFieldID(gFileStatusClass, "atime", "J"); + gFileStatusMtimeFieldID = env->GetFieldID(gFileStatusClass, "mtime", "J"); + gFileStatusCtimeFieldID = env->GetFieldID(gFileStatusClass, "ctime", "J"); + + return AndroidRuntime::registerNativeMethods( + env, kFileUtilsPathName, + methods, NELEM(methods)); +} + +} + diff --git a/core/jni/android_os_Hardware.cpp b/core/jni/android_os_Hardware.cpp new file mode 100644 index 0000000..a302498 --- /dev/null +++ b/core/jni/android_os_Hardware.cpp @@ -0,0 +1,91 @@ +/* + * Copyright 2006, 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. +*/ + +#include <hardware/flashlight.h> +#include <hardware/led.h> +#include <hardware/power.h> + +#include <nativehelper/jni.h> +#include <android_runtime/AndroidRuntime.h> +#include <nativehelper/JNIHelp.h> + +namespace android { + +static jboolean +setLedState(JNIEnv *env, jobject clazz, jint colorARGB, jint onMS, jint offMS) +{ + return set_led_state(colorARGB, onMS, offMS); +} + +static jint +getFlashlightEnabled(JNIEnv *env, jobject clazz) +{ + return get_flashlight_enabled(); +} + +static void +setFlashlightEnabled(JNIEnv *env, jobject clazz, jboolean on) +{ + set_flashlight_enabled(on); +} + +static void +enableCameraFlash(JNIEnv *env, jobject clazz, jint milliseconds) +{ + enable_camera_flash(milliseconds); +} + +static void +setScreenBacklight(JNIEnv *env, jobject clazz, jint brightness) +{ + set_light_brightness(SCREEN_LIGHT, brightness); +} + +static void +setKeyboardBacklight(JNIEnv *env, jobject clazz, jboolean on) +{ + set_light_brightness(KEYBOARD_LIGHT, (on ? 255 : 0)); +} + +static void +setButtonBacklight(JNIEnv *env, jobject clazz, jboolean on) +{ + set_light_brightness(BUTTON_LIGHT, (on ? 255 : 0)); +} + +// ============================================================================ +/* + * JNI registration. + */ + +static JNINativeMethod g_methods[] = { + /* name, signature, funcPtr */ + { "setLedState", "(III)I", (void*)setLedState }, + { "getFlashlightEnabled", "()Z", (void*)getFlashlightEnabled }, + { "setFlashlightEnabled", "(Z)V", (void*)setFlashlightEnabled }, + { "enableCameraFlash", "(I)V", (void*)enableCameraFlash }, + { "setScreenBacklight", "(I)V", (void*)setScreenBacklight }, + { "setKeyboardBacklight", "(Z)V", (void*)setKeyboardBacklight }, + { "setButtonBacklight", "(Z)V", (void*)setButtonBacklight }, +}; + +int register_android_os_Hardware(JNIEnv* env) +{ + return AndroidRuntime::registerNativeMethods(env, + "android/os/Hardware", g_methods, NELEM(g_methods)); +} + +}; // namespace android diff --git a/core/jni/android_os_MemoryFile.cpp b/core/jni/android_os_MemoryFile.cpp new file mode 100644 index 0000000..edf7dc4 --- /dev/null +++ b/core/jni/android_os_MemoryFile.cpp @@ -0,0 +1,129 @@ +/* + * 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. + */ + +#define LOG_TAG "MemoryFile" +#include <utils/Log.h> + +#include <cutils/ashmem.h> +#include <android_runtime/AndroidRuntime.h> +#include "JNIHelp.h" +#include <unistd.h> +#include <sys/mman.h> + + +namespace android { + +static jint android_os_MemoryFile_open(JNIEnv* env, jobject clazz, jstring name, jint length) +{ + const char* namestr = (name ? env->GetStringUTFChars(name, NULL) : NULL); + + // round up length to page boundary + length = (((length - 1) / getpagesize()) + 1) * getpagesize(); + int result = ashmem_create_region(namestr, length); + + if (name) + env->ReleaseStringUTFChars(name, namestr); + + if (result < 0) + jniThrowException(env, "java/io/IOException", "ashmem_create_region failed"); + return result; +} + +static jint android_os_MemoryFile_mmap(JNIEnv* env, jobject clazz, jint fd, jint length) +{ + jint result = (jint)mmap(NULL, length, PROT_READ | PROT_WRITE, MAP_PRIVATE, fd, 0); + if (!result) + jniThrowException(env, "java/io/IOException", "mmap failed"); + return result; +} + +static void android_os_MemoryFile_close(JNIEnv* env, jobject clazz, jint fd) +{ + close(fd); +} + +static jint android_os_MemoryFile_read(JNIEnv* env, jobject clazz, + jint fd, jint address, jbyteArray buffer, jint srcOffset, jint destOffset, + jint count, jboolean unpinned) +{ + if (unpinned && ashmem_pin_region(fd, 0, 0) == ASHMEM_WAS_PURGED) { + ashmem_unpin_region(fd, 0, 0); + jniThrowException(env, "java/io/IOException", "ashmem region was purged"); + return -1; + } + + jbyte* bytes = env->GetByteArrayElements(buffer, 0); + memcpy(bytes + destOffset, (const char *)address + srcOffset, count); + env->ReleaseByteArrayElements(buffer, bytes, 0); + + if (unpinned) { + ashmem_unpin_region(fd, 0, 0); + } + return count; +} + +static jint android_os_MemoryFile_write(JNIEnv* env, jobject clazz, + jint fd, jint address, jbyteArray buffer, jint srcOffset, jint destOffset, + jint count, jboolean unpinned) +{ + if (unpinned && ashmem_pin_region(fd, 0, 0) == ASHMEM_WAS_PURGED) { + ashmem_unpin_region(fd, 0, 0); + jniThrowException(env, "java/io/IOException", "ashmem region was purged"); + return -1; + } + + jbyte* bytes = env->GetByteArrayElements(buffer, 0); + memcpy((char *)address + destOffset, bytes + srcOffset, count); + env->ReleaseByteArrayElements(buffer, bytes, 0); + + if (unpinned) { + ashmem_unpin_region(fd, 0, 0); + } + return count; +} + +static void android_os_MemoryFile_pin(JNIEnv* env, jobject clazz, jint fd, jboolean pin) +{ + int result = (pin ? ashmem_pin_region(fd, 0, 0) : ashmem_unpin_region(fd, 0, 0)); + if (result < 0) { + jniThrowException(env, "java/io/IOException", NULL); + } +} + +static const JNINativeMethod methods[] = { + {"native_open", "(Ljava/lang/String;I)I", (void*)android_os_MemoryFile_open}, + {"native_mmap", "(II)I", (void*)android_os_MemoryFile_mmap}, + {"native_close", "(I)V", (void*)android_os_MemoryFile_close}, + {"native_read", "(II[BIIIZ)I", (void*)android_os_MemoryFile_read}, + {"native_write", "(II[BIIIZ)V", (void*)android_os_MemoryFile_write}, + {"native_pin", "(IZ)V", (void*)android_os_MemoryFile_pin}, +}; + +static const char* const kClassPathName = "android/os/MemoryFile"; + +int register_android_os_MemoryFile(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass(kClassPathName); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.FileUtils"); + + return AndroidRuntime::registerNativeMethods( + env, kClassPathName, + methods, NELEM(methods)); +} + +} diff --git a/core/jni/android_os_NetStat.cpp b/core/jni/android_os_NetStat.cpp new file mode 100644 index 0000000..983f719 --- /dev/null +++ b/core/jni/android_os_NetStat.cpp @@ -0,0 +1,158 @@ +/* //device/libs/android_runtime/android_os_Wifi.cpp +** +** Copyright 2007, 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. +*/ + +#define LOG_TAG "NetStat" + +#include "jni.h" +#include <utils/misc.h> +#include <android_runtime/AndroidRuntime.h> +#include <utils/Log.h> + +#include <stdio.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include <unistd.h> +#include <stdlib.h> +#if HAVE_ANDROID_OS +#include <utils/Atomic.h> +#endif + +namespace android { + +static jint android_os_netStatGetTxPkts(JNIEnv* env, jobject clazz) +{ + int ret = 0; + int fd = -1; + char input[50]; + + fd = open("/sys/class/net/rmnet0/statistics/tx_packets", O_RDONLY); + if (fd <= 0) { + fd = open("/sys/class/net/ppp0/statistics/tx_packets", O_RDONLY); + } + + if (fd > 0) { + int size = read(fd, input, 50); + if (size > 0) { + ret = atoi(input); + } + close(fd); + } + + return (jint)ret; +} + +static jint android_os_netStatGetRxPkts(JNIEnv* env, jobject clazz) +{ + int ret = 0; + int fd = -1; + char input[50]; + + fd = open("/sys/class/net/rmnet0/statistics/rx_packets", O_RDONLY); + if (fd <= 0) { + fd = open("/sys/class/net/ppp0/statistics/rx_packets", O_RDONLY); + } + + if (fd > 0) { + int size = read(fd, input, 50); + if (size > 0) { + ret = atoi(input); + } + close(fd); + } + + return (jint)ret; +} + +static jint android_os_netStatGetRxBytes(JNIEnv* env, jobject clazz) +{ + int ret = 0; + int fd = -1; + char input[50]; + + fd = open("/sys/class/net/rmnet0/statistics/rx_bytes", O_RDONLY); + if (fd <= 0) { + fd = open("/sys/class/net/ppp0/statistics/rx_bytes", O_RDONLY); + } + + if (fd > 0) { + int size = read(fd, input, 50); + if (size > 0) { + ret = atoi(input); + } + close(fd); + } + + return (jint)ret; +} + + +static jint android_os_netStatGetTxBytes(JNIEnv* env, jobject clazz) +{ + int ret = 0; + int fd = -1; + char input[50]; + + fd = open("/sys/class/net/rmnet0/statistics/tx_bytes", O_RDONLY); + if (fd <= 0) { + fd = open("/sys/class/net/ppp0/statistics/tx_bytes", O_RDONLY); + } + + if (fd > 0) { + int size = read(fd, input, 50); + if (size > 0) { + ret = atoi(input); + } + close(fd); + } + + return (jint)ret; +} + +// ---------------------------------------------------------------------------- + +/* + * JNI registration. + */ +static JNINativeMethod gMethods[] = { + /* name, signature, funcPtr */ + + { "netStatGetTxPkts", "()I", + (void*) android_os_netStatGetTxPkts }, + + { "netStatGetRxPkts", "()I", + (void*) android_os_netStatGetRxPkts }, + + { "netStatGetTxBytes", "()I", + (void*) android_os_netStatGetTxBytes }, + + { "netStatGetRxBytes", "()I", + (void*) android_os_netStatGetRxBytes }, + +}; + +int register_android_os_NetStat(JNIEnv* env) +{ + jclass netStat = env->FindClass("android/os/NetStat"); + LOG_FATAL_IF(netStat == NULL, "Unable to find class android/os/NetStat"); + + return AndroidRuntime::registerNativeMethods(env, + "android/os/NetStat", gMethods, NELEM(gMethods)); +} + +}; // namespace android + diff --git a/core/jni/android_os_ParcelFileDescriptor.cpp b/core/jni/android_os_ParcelFileDescriptor.cpp new file mode 100644 index 0000000..465e233 --- /dev/null +++ b/core/jni/android_os_ParcelFileDescriptor.cpp @@ -0,0 +1,102 @@ +/* //device/libs/android_runtime/android_os_ParcelFileDescriptor.cpp +** +** Copyright 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. +*/ + +#include "JNIHelp.h" + +#include <fcntl.h> +#include <sys/stat.h> +#include <stdio.h> + +#include <utils/Log.h> + +#include <android_runtime/AndroidRuntime.h> + +namespace android +{ + +static struct file_descriptor_offsets_t +{ + jclass mClass; + jmethodID mConstructor; + jfieldID mDescriptor; +} gFileDescriptorOffsets; + +static struct socket_offsets_t +{ + jfieldID mSocketImpl; +} gSocketOffsets; + +static struct socket_impl_offsets_t +{ + jfieldID mFileDescriptor; +} gSocketImplOffsets; + + +static jobject android_os_ParcelFileDescriptor_getFileDescriptorFromSocket(JNIEnv* env, + jobject clazz, jobject object) +{ + jobject socketImpl = env->GetObjectField(object, gSocketOffsets.mSocketImpl); + jobject fileDescriptor = env->GetObjectField(socketImpl, gSocketImplOffsets.mFileDescriptor); + jint fd = env->GetIntField(fileDescriptor, gFileDescriptorOffsets.mDescriptor); + jobject fileDescriptorClone = env->NewObject(gFileDescriptorOffsets.mClass, + gFileDescriptorOffsets.mConstructor); + if (fileDescriptorClone != NULL) { + env->SetIntField(fileDescriptorClone, gFileDescriptorOffsets.mDescriptor, dup(fd)); + } + return fileDescriptorClone; +} + +static const JNINativeMethod gParcelFileDescriptorMethods[] = { + {"getFileDescriptorFromSocket", "(Ljava/net/Socket;)Ljava/io/FileDescriptor;", + (void*)android_os_ParcelFileDescriptor_getFileDescriptorFromSocket} +}; + +const char* const kParcelFileDescriptorPathName = "android/os/ParcelFileDescriptor"; + +int register_android_os_ParcelFileDescriptor(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass("java/net/Socket"); + LOG_FATAL_IF(clazz == NULL, "Unable to find class java.net.Socket"); + gSocketOffsets.mSocketImpl = env->GetFieldID(clazz, "impl", "Ljava/net/SocketImpl;"); + LOG_FATAL_IF(gSocketOffsets.mSocketImpl == NULL, + "Unable to find impl field in java.net.Socket"); + + clazz = env->FindClass("java/net/SocketImpl"); + LOG_FATAL_IF(clazz == NULL, "Unable to find class java.net.SocketImpl"); + gSocketImplOffsets.mFileDescriptor = env->GetFieldID(clazz, "fd", "Ljava/io/FileDescriptor;"); + LOG_FATAL_IF(gSocketImplOffsets.mFileDescriptor == NULL, + "Unable to find fd field in java.net.SocketImpl"); + + clazz = env->FindClass("java/io/FileDescriptor"); + LOG_FATAL_IF(clazz == NULL, "Unable to find class java.io.FileDescriptor"); + gFileDescriptorOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + gFileDescriptorOffsets.mConstructor = env->GetMethodID(clazz, "<init>", "()V"); + gFileDescriptorOffsets.mDescriptor = env->GetFieldID(clazz, "descriptor", "I"); + LOG_FATAL_IF(gFileDescriptorOffsets.mDescriptor == NULL, + "Unable to find descriptor field in java.io.FileDescriptor"); + + clazz = env->FindClass(kParcelFileDescriptorPathName); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.ParcelFileDescriptor"); + + return AndroidRuntime::registerNativeMethods( + env, kParcelFileDescriptorPathName, + gParcelFileDescriptorMethods, NELEM(gParcelFileDescriptorMethods)); +} + +} diff --git a/core/jni/android_os_Power.cpp b/core/jni/android_os_Power.cpp new file mode 100644 index 0000000..02a4083 --- /dev/null +++ b/core/jni/android_os_Power.cpp @@ -0,0 +1,123 @@ +/* //device/libs/android_runtime/android_os_Power.cpp +** +** Copyright 2006, 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. +*/ + +#include "jni.h" +#include "android_runtime/AndroidRuntime.h" +#include <utils/misc.h> +#include <hardware/power.h> +#include <sys/reboot.h> + +namespace android +{ + +static void throw_NullPointerException(JNIEnv *env, const char* msg) +{ + jclass clazz; + clazz = env->FindClass("java/lang/NullPointerException"); + env->ThrowNew(clazz, msg); +} + +static void +acquireWakeLock(JNIEnv *env, jobject clazz, jint lock, jstring idObj) +{ + if (idObj == NULL) { + throw_NullPointerException(env, "id is null"); + return ; + } + + const char *id = env->GetStringUTFChars(idObj, NULL); + + acquire_wake_lock(lock, id); + + env->ReleaseStringUTFChars(idObj, id); +} + +static void +releaseWakeLock(JNIEnv *env, jobject clazz, jstring idObj) +{ + if (idObj == NULL) { + throw_NullPointerException(env, "id is null"); + return ; + } + + const char *id = env->GetStringUTFChars(idObj, NULL); + + release_wake_lock(id); + + env->ReleaseStringUTFChars(idObj, id); + +} + +static int +setLastUserActivityTimeout(JNIEnv *env, jobject clazz, jlong timeMS) +{ + return set_last_user_activity_timeout(timeMS/1000); +} + +static int +setLightBrightness(JNIEnv *env, jobject clazz, jint mask, jint brightness) +{ + return set_light_brightness(mask, brightness); +} + +static int +setScreenState(JNIEnv *env, jobject clazz, jboolean on) +{ + return set_screen_state(on); +} + +static void android_os_Power_shutdown(JNIEnv *env, jobject clazz) +{ + sync(); +#ifdef HAVE_ANDROID_OS + reboot(RB_POWER_OFF); +#endif +} + +static void android_os_Power_reboot(JNIEnv *env, jobject clazz, jstring reason) +{ + sync(); +#ifdef HAVE_ANDROID_OS + if (reason == NULL) { + reboot(RB_AUTOBOOT); + } else { + const char *chars = env->GetStringUTFChars(reason, NULL); + __reboot(LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, + LINUX_REBOOT_CMD_RESTART2, (char*) chars); + env->ReleaseStringUTFChars(reason, chars); // In case it fails. + } +#endif +} + +static JNINativeMethod method_table[] = { + { "acquireWakeLock", "(ILjava/lang/String;)V", (void*)acquireWakeLock }, + { "releaseWakeLock", "(Ljava/lang/String;)V", (void*)releaseWakeLock }, + { "setLastUserActivityTimeout", "(J)I", (void*)setLastUserActivityTimeout }, + { "setLightBrightness", "(II)I", (void*)setLightBrightness }, + { "setScreenState", "(Z)I", (void*)setScreenState }, + { "shutdown", "()V", (void*)android_os_Power_shutdown }, + { "reboot", "(Ljava/lang/String;)V", (void*)android_os_Power_reboot }, +}; + +int register_android_os_Power(JNIEnv *env) +{ + return AndroidRuntime::registerNativeMethods( + env, "android/os/Power", + method_table, NELEM(method_table)); +} + +}; diff --git a/core/jni/android_os_StatFs.cpp b/core/jni/android_os_StatFs.cpp new file mode 100644 index 0000000..c658aa5 --- /dev/null +++ b/core/jni/android_os_StatFs.cpp @@ -0,0 +1,163 @@ +/* + * Copyright 2007, 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. + */ + +#if INCLUDE_SYS_MOUNT_FOR_STATFS +#include <sys/mount.h> +#else +#include <sys/statfs.h> +#endif + +#include <errno.h> + +#include "jni.h" +#include "JNIHelp.h" +#include "android_runtime/AndroidRuntime.h" + + +namespace android +{ + +// ---------------------------------------------------------------------------- + +struct fields_t { + jfieldID context; +}; +static fields_t fields; + +// ---------------------------------------------------------------------------- + +static jint +android_os_StatFs_getBlockSize(JNIEnv *env, jobject thiz) +{ + struct statfs *stat = (struct statfs *)env->GetIntField(thiz, fields.context); + return stat->f_bsize; +} + +static jint +android_os_StatFs_getBlockCount(JNIEnv *env, jobject thiz) +{ + struct statfs *stat = (struct statfs *)env->GetIntField(thiz, fields.context); + return stat->f_blocks; +} + +static jint +android_os_StatFs_getFreeBlocks(JNIEnv *env, jobject thiz) +{ + struct statfs *stat = (struct statfs *)env->GetIntField(thiz, fields.context); + return stat->f_bfree; +} + +static jint +android_os_StatFs_getAvailableBlocks(JNIEnv *env, jobject thiz) +{ + struct statfs *stat = (struct statfs *)env->GetIntField(thiz, fields.context); + return stat->f_bavail; +} + +static void +android_os_StatFs_native_restat(JNIEnv *env, jobject thiz, jstring path) +{ + if (path == NULL) { + jniThrowException(env, "java/lang/IllegalArgumentException", NULL); + return; + } + + // get the object handle + struct statfs *stat = (struct statfs *)env->GetIntField(thiz, fields.context); + if (stat == NULL) { + jniThrowException(env, "java/lang/NoSuchFieldException", NULL); + return; + } + + const char* pathstr = env->GetStringUTFChars(path, NULL); + if (pathstr == NULL) { + jniThrowException(env, "java/lang/RuntimeException", "Out of memory"); + return; + } + + // note that stat will contain the new file data corresponding to + // pathstr + if (statfs(pathstr, stat) != 0) { + LOGE("statfs %s failed, errno: %d", pathstr, errno); + delete stat; + env->SetIntField(thiz, fields.context, 0); + jniThrowException(env, "java/lang/IllegalArgumentException", NULL); + } + // Release pathstr + env->ReleaseStringUTFChars(path, pathstr); +} + +static void +android_os_StatFs_native_setup(JNIEnv *env, jobject thiz, jstring path) +{ + if (path == NULL) { + jniThrowException(env, "java/lang/IllegalArgumentException", NULL); + return; + } + + struct statfs* stat = new struct statfs; + if (stat == NULL) { + jniThrowException(env, "java/lang/RuntimeException", "Out of memory"); + return; + } + env->SetIntField(thiz, fields.context, (int)stat); + android_os_StatFs_native_restat(env, thiz, path); +} + +static void +android_os_StatFs_native_finalize(JNIEnv *env, jobject thiz) +{ + struct statfs *stat = (struct statfs *)env->GetIntField(thiz, fields.context); + if (stat != NULL) { + delete stat; + env->SetIntField(thiz, fields.context, 0); + } +} + +// ---------------------------------------------------------------------------- + +static JNINativeMethod gMethods[] = { + {"getBlockSize", "()I", (void *)android_os_StatFs_getBlockSize}, + {"getBlockCount", "()I", (void *)android_os_StatFs_getBlockCount}, + {"getFreeBlocks", "()I", (void *)android_os_StatFs_getFreeBlocks}, + {"getAvailableBlocks", "()I", (void *)android_os_StatFs_getAvailableBlocks}, + {"native_setup", "(Ljava/lang/String;)V", (void *)android_os_StatFs_native_setup}, + {"native_finalize", "()V", (void *)android_os_StatFs_native_finalize}, + {"native_restat", "(Ljava/lang/String;)V", (void *)android_os_StatFs_native_restat}, +}; + + +int register_android_os_StatFs(JNIEnv *env) +{ + jclass clazz; + + clazz = env->FindClass("android/os/StatFs"); + if (clazz == NULL) { + LOGE("Can't find android/os/StatFs"); + return -1; + } + + fields.context = env->GetFieldID(clazz, "mNativeContext", "I"); + if (fields.context == NULL) { + LOGE("Can't find StatFs.mNativeContext"); + return -1; + } + + return AndroidRuntime::registerNativeMethods(env, + "android/os/StatFs", gMethods, NELEM(gMethods)); +} + +} // namespace android diff --git a/core/jni/android_os_SystemClock.cpp b/core/jni/android_os_SystemClock.cpp new file mode 100644 index 0000000..ffd0c1e --- /dev/null +++ b/core/jni/android_os_SystemClock.cpp @@ -0,0 +1,103 @@ +/* + * 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. + */ + + +/* + * System clock functions. + */ + +#include "JNIHelp.h" +#include "jni.h" +#include "android_runtime/AndroidRuntime.h" + +#include "utils/SystemClock.h" + +#include <sys/time.h> +#include <time.h> + +namespace android { + +/* + * native public static void setCurrentTimeMillis(long millis) + * + * Set the current time. This only works when running as root. + */ +static jboolean android_os_SystemClock_setCurrentTimeMillis(JNIEnv* env, + jobject clazz, jlong millis) +{ + return (setCurrentTimeMillis(millis) == 0); +} + +/* + * native public static long uptimeMillis(); + */ +static jlong android_os_SystemClock_uptimeMillis(JNIEnv* env, + jobject clazz) +{ + return (jlong)uptimeMillis(); +} + +/* + * native public static long elapsedRealtime(); + */ +static jlong android_os_SystemClock_elapsedRealtime(JNIEnv* env, + jobject clazz) +{ + return (jlong)elapsedRealtime(); +} + +/* + * native public static long currentThreadTimeMillis(); + */ +static jlong android_os_SystemClock_currentThreadTimeMillis(JNIEnv* env, + jobject clazz) +{ +#if defined(HAVE_POSIX_CLOCKS) + struct timespec tm; + + clock_gettime(CLOCK_THREAD_CPUTIME_ID, &tm); + + return tm.tv_sec * 1000LL + tm.tv_nsec / 1000000; +#else + struct timeval tv; + + gettimeofday(&tv, NULL); + return tv.tv_sec * 1000LL + tv.tv_usec / 1000; +#endif +} + +/* + * JNI registration. + */ +static JNINativeMethod gMethods[] = { + /* name, signature, funcPtr */ + { "setCurrentTimeMillis", "(J)Z", + (void*) android_os_SystemClock_setCurrentTimeMillis }, + { "uptimeMillis", "()J", + (void*) android_os_SystemClock_uptimeMillis }, + { "elapsedRealtime", "()J", + (void*) android_os_SystemClock_elapsedRealtime }, + { "currentThreadTimeMillis", "()J", + (void*) android_os_SystemClock_currentThreadTimeMillis }, +}; +int register_android_os_SystemClock(JNIEnv* env) +{ + return AndroidRuntime::registerNativeMethods(env, + "android/os/SystemClock", gMethods, NELEM(gMethods)); +} + +}; // namespace android + diff --git a/core/jni/android_os_SystemProperties.cpp b/core/jni/android_os_SystemProperties.cpp new file mode 100644 index 0000000..ca4fa11 --- /dev/null +++ b/core/jni/android_os_SystemProperties.cpp @@ -0,0 +1,108 @@ +/* //device/libs/android_runtime/android_os_SystemProperties.cpp +** +** Copyright 2006, 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. +*/ + +#include "cutils/properties.h" +#include "jni.h" +#include "android_runtime/AndroidRuntime.h" +#include <nativehelper/JNIHelp.h> + +namespace android +{ + +static jstring SystemProperties_getSS(JNIEnv *env, jobject clazz, + jstring keyJ, jstring defJ) +{ + int len; + const char* key; + char buf[PROPERTY_VALUE_MAX]; + jstring rvJ = NULL; + + if (keyJ == NULL) { + jniThrowException(env, "java/lang/NullPointerException", + "key must not be null."); + goto error; + } + + key = env->GetStringUTFChars(keyJ, NULL); + + len = property_get(key, buf, ""); + if ((len <= 0) && (defJ != NULL)) { + rvJ = defJ; + } else if (len >= 0) { + rvJ = env->NewStringUTF(buf); + } else { + rvJ = env->NewStringUTF(""); + } + + env->ReleaseStringUTFChars(keyJ, key); + +error: + return rvJ; +} + +static jstring SystemProperties_getS(JNIEnv *env, jobject clazz, + jstring keyJ) +{ + return SystemProperties_getSS(env, clazz, keyJ, NULL); +} + +static void SystemProperties_set(JNIEnv *env, jobject clazz, + jstring keyJ, jstring valJ) +{ + int err; + const char* key; + const char* val; + + if (keyJ == NULL) { + jniThrowException(env, "java/lang/NullPointerException", + "key must not be null."); + return ; + } + key = env->GetStringUTFChars(keyJ, NULL); + + if (valJ == NULL) { + val = ""; /* NULL pointer not allowed here */ + } else { + val = env->GetStringUTFChars(valJ, NULL); + } + + err = property_set(key, val); + + env->ReleaseStringUTFChars(keyJ, key); + + if (valJ != NULL) { + env->ReleaseStringUTFChars(valJ, val); + } +} + +static JNINativeMethod method_table[] = { + { "native_get", "(Ljava/lang/String;)Ljava/lang/String;", + (void*) SystemProperties_getS }, + { "native_get", "(Ljava/lang/String;Ljava/lang/String;)Ljava/lang/String;", + (void*) SystemProperties_getSS }, + { "native_set", "(Ljava/lang/String;Ljava/lang/String;)V", + (void*) SystemProperties_set }, +}; + +int register_android_os_SystemProperties(JNIEnv *env) +{ + return AndroidRuntime::registerNativeMethods( + env, "android/os/SystemProperties", + method_table, NELEM(method_table)); +} + +}; diff --git a/core/jni/android_os_UEventObserver.cpp b/core/jni/android_os_UEventObserver.cpp new file mode 100644 index 0000000..cac4372 --- /dev/null +++ b/core/jni/android_os_UEventObserver.cpp @@ -0,0 +1,70 @@ +/* + * 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. + */ + +#define LOG_TAG "UEventObserver" +#include "utils/Log.h" + +#include "hardware/uevent.h" +#include "jni.h" +#include "JNIHelp.h" +#include "android_runtime/AndroidRuntime.h" + +namespace android +{ + +static void +android_os_UEventObserver_native_setup(JNIEnv *env, jclass clazz) +{ + if (!uevent_init()) { + jniThrowException(env, "java/lang/RuntimeException", + "Unable to open socket for UEventObserver"); + } +} + +static int +android_os_UEventObserver_next_event(JNIEnv *env, jclass clazz, jbyteArray jbuffer) +{ + int buf_sz = env->GetArrayLength(jbuffer); + char *buffer = (char*)env->GetByteArrayElements(jbuffer, NULL); + + int length = uevent_next_event(buffer, buf_sz - 1); + + env->ReleaseByteArrayElements(jbuffer, (jbyte*)buffer, 0); + + return length; +} + +static JNINativeMethod gMethods[] = { + {"native_setup", "()V", (void *)android_os_UEventObserver_native_setup}, + {"next_event", "([B)I", (void *)android_os_UEventObserver_next_event}, +}; + + +int register_android_os_UEventObserver(JNIEnv *env) +{ + jclass clazz; + + clazz = env->FindClass("android/os/UEventObserver"); + if (clazz == NULL) { + LOGE("Can't find android/os/UEventObserver"); + return -1; + } + + return AndroidRuntime::registerNativeMethods(env, + "android/os/UEventObserver", gMethods, NELEM(gMethods)); +} + +} // namespace android diff --git a/core/jni/android_pim_EventRecurrence.cpp b/core/jni/android_pim_EventRecurrence.cpp new file mode 100644 index 0000000..cbe99bc --- /dev/null +++ b/core/jni/android_pim_EventRecurrence.cpp @@ -0,0 +1,199 @@ +/* //device/libs/android_runtime/android_pim_EventRecurrence.cpp
+**
+** Copyright 2006, 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.
+*/
+
+#include <pim/EventRecurrence.h>
+#include "jni.h"
+#include "nativehelper/JNIHelp.h"
+#include <utils/String8.h>
+
+namespace android {
+
+struct cached_array_fields_t
+{
+ jfieldID array;
+ jfieldID count;
+};
+
+static jclass clazz;
+static jfieldID freq_field;
+static jfieldID until_field;
+static jfieldID count_field;
+static jfieldID interval_field;
+static jfieldID wkst_field;
+static cached_array_fields_t bysecond_fields;
+static cached_array_fields_t byminute_fields;
+static cached_array_fields_t byhour_fields;
+static cached_array_fields_t byday_fields;
+static cached_array_fields_t bydayNum_fields;
+static cached_array_fields_t bymonthday_fields;
+static cached_array_fields_t byyearday_fields;
+static cached_array_fields_t byweekno_fields;
+static cached_array_fields_t bymonth_fields;
+static cached_array_fields_t bysetpos_fields;
+
+static status_t
+set_array(JNIEnv* env, int inCount, int* inArray,
+ jobject This, const cached_array_fields_t& fields)
+{
+ if (inCount > 0) {
+ jintArray array = (jintArray) env->GetObjectField(This, fields.array);
+ if (array == NULL || env->GetArrayLength(array) < inCount) {
+ // +4 because it's cheap to allocate a little extra here, and
+ // that reduces the chance that we'll come back here again
+ array = env->NewIntArray(inCount+4);
+ env->SetObjectField(This, fields.array, array);
+ }
+ if (array == NULL) {
+ return NO_MEMORY;
+ }
+ env->SetIntArrayRegion(array, 0, inCount, inArray);
+
+ }
+ env->SetIntField(This, fields.count, inCount);
+ return NO_ERROR;
+}
+
+/*
+ * In class android.pim.EventRecurrence
+ * public native int parse(String str);
+ */
+#define SET_ARRAY_AND_CHECK(name) \
+ /*printf("setting " #name " to %d elements\n", er.name##Count);*/ \
+ if (set_array(env, er.name##Count, er.name, This, name##_fields) \
+ != NO_ERROR) { \
+ jniThrowException(env, "java/lang/RuntimeException", \
+ "EventRecurrence.parse error setting field " #name " or " \
+ #name "Count."); \
+ return ; \
+ }
+static void
+EventRecurrence_parse(JNIEnv* env, jobject This, jstring jstr)
+{
+ if (jstr == NULL) {
+ jniThrowException(env, "java/lang/NullPointerException",
+ "EventRecurrence.parse str parameter null");
+ return ;
+ }
+ jboolean isCopy;
+ const jchar* jchars = env->GetStringChars(jstr, &isCopy);
+ jsize len = env->GetStringLength(jstr);
+ String16 str(jchars, len);
+ env->ReleaseStringChars(jstr, jchars);
+
+ //printf("the string was '%s'\n", String8(str).string());
+
+ EventRecurrence er;
+ if (NO_ERROR != er.parse(str)) {
+ String8 msg("Error parsing recurrence: '");
+ msg.append(String8(str));
+ msg.append("'");
+
+ jniThrowException(env,
+ "android/pim/EventRecurrence$InvalidFormatException",
+ msg.string());
+ return ;
+ }
+
+ jstring untilStr;
+ if (er.until.size() > 0) {
+ untilStr = env->NewString(er.until.string(), er.until.size());
+ if (untilStr == NULL) {
+ jniThrowException(env, "java/lang/RuntimeException",
+ "EventRecurrence.parse error setting field 'until'");
+ return ;
+ }
+ } else {
+ untilStr = NULL;
+ }
+ env->SetObjectField(This, until_field, untilStr);
+
+ env->SetIntField(This, freq_field, er.freq);
+ env->SetIntField(This, count_field, er.count);
+ env->SetIntField(This, interval_field, er.interval);
+ env->SetIntField(This, wkst_field, er.wkst);
+
+ SET_ARRAY_AND_CHECK(bysecond)
+ SET_ARRAY_AND_CHECK(byminute)
+ SET_ARRAY_AND_CHECK(byhour)
+ SET_ARRAY_AND_CHECK(byday)
+ // we'll just set the bydayCount field twice, it'll be less code total
+ if (set_array(env, er.bydayCount, er.bydayNum, This, bydayNum_fields)
+ != NO_ERROR) {
+ jniThrowException(env, "java/lang/RuntimeException",
+ "EventRecurrence.parse error setting field bydayNum or "
+ "bydayCount.");
+ return ;
+ }
+ SET_ARRAY_AND_CHECK(bymonthday)
+ SET_ARRAY_AND_CHECK(byyearday)
+ SET_ARRAY_AND_CHECK(byweekno)
+ SET_ARRAY_AND_CHECK(bymonth)
+ SET_ARRAY_AND_CHECK(bysetpos)
+}
+
+/*
+ * JNI registration.
+ */
+static JNINativeMethod METHODS[] = {
+ /* name, signature, funcPtr */
+ { "parse", "(Ljava/lang/String;)V", (void*)EventRecurrence_parse }
+};
+
+static const char*const CLASS_NAME = "android/pim/EventRecurrence";
+
+int register_android_pim_EventRecurrence(JNIEnv* env)
+{
+ clazz = env->FindClass(CLASS_NAME);
+ if (clazz == NULL) {
+ LOGE("Field lookup unable to find class '%s'\n", CLASS_NAME);
+ return -1;
+ }
+
+ freq_field = env->GetFieldID(clazz, "freq", "I");
+ count_field = env->GetFieldID(clazz, "count", "I");
+ interval_field = env->GetFieldID(clazz, "interval", "I");
+ wkst_field = env->GetFieldID(clazz, "wkst", "I");
+
+ until_field = env->GetFieldID(clazz, "until", "Ljava/lang/String;");
+
+ bysecond_fields.array = env->GetFieldID(clazz, "bysecond", "[I");
+ bysecond_fields.count = env->GetFieldID(clazz, "bysecondCount", "I");
+ byminute_fields.array = env->GetFieldID(clazz, "byminute", "[I");
+ byminute_fields.count = env->GetFieldID(clazz, "byminuteCount", "I");
+ byhour_fields.array = env->GetFieldID(clazz, "byhour", "[I");
+ byhour_fields.count = env->GetFieldID(clazz, "byhourCount", "I");
+ byday_fields.array = env->GetFieldID(clazz, "byday", "[I");
+ byday_fields.count = env->GetFieldID(clazz, "bydayCount", "I");
+ bydayNum_fields.array = env->GetFieldID(clazz, "bydayNum", "[I");
+ bydayNum_fields.count = byday_fields.count;
+ bymonthday_fields.array = env->GetFieldID(clazz, "bymonthday", "[I");
+ bymonthday_fields.count = env->GetFieldID(clazz, "bymonthdayCount", "I");
+ byyearday_fields.array = env->GetFieldID(clazz, "byyearday", "[I");
+ byyearday_fields.count = env->GetFieldID(clazz, "byyeardayCount", "I");
+ byweekno_fields.array = env->GetFieldID(clazz, "byweekno", "[I");
+ byweekno_fields.count = env->GetFieldID(clazz, "byweeknoCount", "I");
+ bymonth_fields.array = env->GetFieldID(clazz, "bymonth", "[I");
+ bymonth_fields.count = env->GetFieldID(clazz, "bymonthCount", "I");
+ bysetpos_fields.array = env->GetFieldID(clazz, "bysetpos", "[I");
+ bysetpos_fields.count = env->GetFieldID(clazz, "bysetposCount", "I");
+
+ return jniRegisterNativeMethods(env, CLASS_NAME,
+ METHODS, sizeof(METHODS)/sizeof(METHODS[0]));
+}
+
+}; // namespace android
+
diff --git a/core/jni/android_pim_Time.cpp b/core/jni/android_pim_Time.cpp new file mode 100644 index 0000000..c1dd499 --- /dev/null +++ b/core/jni/android_pim_Time.cpp @@ -0,0 +1,594 @@ +/* +** Copyright 2006, 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. +*/ + +#define LOG_TAG "Log_println" + +#include <utils/Log.h> +#include <utils/String8.h> +#include <assert.h> + +#include "jni.h" +#include "utils/misc.h" +#include "android_runtime/AndroidRuntime.h" +#include <utils/TimeUtils.h> +#include <nativehelper/JNIHelp.h> + +namespace android { + +static jfieldID g_allDayField = 0; +static jfieldID g_secField = 0; +static jfieldID g_minField = 0; +static jfieldID g_hourField = 0; +static jfieldID g_mdayField = 0; +static jfieldID g_monField = 0; +static jfieldID g_yearField = 0; +static jfieldID g_wdayField = 0; +static jfieldID g_ydayField = 0; +static jfieldID g_isdstField = 0; +static jfieldID g_gmtoffField = 0; +static jfieldID g_timezoneField = 0; + +static inline bool java2time(JNIEnv* env, Time* t, jobject o) +{ + t->t.tm_sec = env->GetIntField(o, g_secField); + t->t.tm_min = env->GetIntField(o, g_minField); + t->t.tm_hour = env->GetIntField(o, g_hourField); + t->t.tm_mday = env->GetIntField(o, g_mdayField); + t->t.tm_mon = env->GetIntField(o, g_monField); + t->t.tm_year = (env->GetIntField(o, g_yearField))-1900; + t->t.tm_wday = env->GetIntField(o, g_wdayField); + t->t.tm_yday = env->GetIntField(o, g_ydayField); + t->t.tm_isdst = env->GetIntField(o, g_isdstField); + t->t.tm_gmtoff = env->GetLongField(o, g_gmtoffField); + bool allDay = env->GetIntField(o, g_allDayField); + if (allDay && + ((t->t.tm_sec !=0) || (t->t.tm_min != 0) || (t->t.tm_hour != 0))) { + char msg[100]; + sprintf(msg, "allDay is true but sec, min, hour are not 0."); + jniThrowException(env, "java/lang/IllegalArgumentException", msg); + return false; + } + return true; +} + +static inline void time2java(JNIEnv* env, jobject o, const Time &t) +{ + env->SetIntField(o, g_secField, t.t.tm_sec); + env->SetIntField(o, g_minField, t.t.tm_min); + env->SetIntField(o, g_hourField, t.t.tm_hour); + env->SetIntField(o, g_mdayField, t.t.tm_mday); + env->SetIntField(o, g_monField, t.t.tm_mon); + env->SetIntField(o, g_yearField, t.t.tm_year+1900); + env->SetIntField(o, g_wdayField, t.t.tm_wday); + env->SetIntField(o, g_ydayField, t.t.tm_yday); + env->SetIntField(o, g_isdstField, t.t.tm_isdst); + env->SetLongField(o, g_gmtoffField, t.t.tm_gmtoff); +} + +#define ACQUIRE_TIMEZONE(This, t) \ + jstring timezoneString_##This \ + = (jstring) env->GetObjectField(This, g_timezoneField); \ + t.timezone = env->GetStringUTFChars(timezoneString_##This, NULL); + +#define RELEASE_TIMEZONE(This, t) \ + env->ReleaseStringUTFChars(timezoneString_##This, t.timezone); + + +// ============================================================================ + +static jlong android_pim_Time_normalize(JNIEnv* env, jobject This, + jboolean ignoreDst) +{ + Time t; + if (!java2time(env, &t, This)) return 0L; + ACQUIRE_TIMEZONE(This, t) + + int64_t result = t.toMillis(ignoreDst != 0); + + time2java(env, This, t); + RELEASE_TIMEZONE(This, t) + + return result; +} + +static void android_pim_Time_switchTimezone(JNIEnv* env, jobject This, + jstring timezoneObject) +{ + Time t; + if (!java2time(env, &t, This)) return; + ACQUIRE_TIMEZONE(This, t) + + const char* timezone = env->GetStringUTFChars(timezoneObject, NULL); + + t.switchTimezone(timezone); + + time2java(env, This, t); + env->ReleaseStringUTFChars(timezoneObject, timezone); + RELEASE_TIMEZONE(This, t) + + // we do this here because there's no point in reallocating the string + env->SetObjectField(This, g_timezoneField, timezoneObject); +} + +static jint android_pim_Time_compare(JNIEnv* env, jobject clazz, + jobject aObject, jobject bObject) +{ + Time a, b; + + if (!java2time(env, &a, aObject)) return 0; + ACQUIRE_TIMEZONE(aObject, a) + + if (!java2time(env, &b, bObject)) return 0; + ACQUIRE_TIMEZONE(bObject, b) + + int result = Time::compare(a, b); + + RELEASE_TIMEZONE(aObject, a) + RELEASE_TIMEZONE(bObject, b) + + return result; +} + +static jstring android_pim_Time_format2445(JNIEnv* env, jobject This) +{ + Time t; + if (!java2time(env, &t, This)) return env->NewStringUTF(""); + bool allDay = env->GetIntField(This, g_allDayField); + + if (!allDay) { + ACQUIRE_TIMEZONE(This, t) + bool inUtc = strcmp("UTC", t.timezone) == 0; + short buf[16]; + t.format2445(buf, true); + RELEASE_TIMEZONE(This, t) + if (inUtc) { + // The letter 'Z' is appended to the end so allow for one + // more character in the buffer. + return env->NewString((jchar*)buf, 16); + } else { + return env->NewString((jchar*)buf, 15); + } + } else { + short buf[8]; + t.format2445(buf, false); + return env->NewString((jchar*)buf, 8); + } +} + +static jstring android_pim_Time_format(JNIEnv* env, jobject This, + jstring formatObject) +{ + Time t; + if (!java2time(env, &t, This)) return env->NewStringUTF(""); + ACQUIRE_TIMEZONE(This, t) + + const char* format = env->GetStringUTFChars(formatObject, NULL); + + String8 r = t.format(format); + + env->ReleaseStringUTFChars(formatObject, format); + RELEASE_TIMEZONE(This, t) + + return env->NewStringUTF(r.string()); +} + + +static jstring android_pim_Time_toString(JNIEnv* env, jobject This) +{ + Time t; + if (!java2time(env, &t, This)) return env->NewStringUTF("");; + ACQUIRE_TIMEZONE(This, t) + + String8 r = t.toString(); + + RELEASE_TIMEZONE(This, t) + + return env->NewStringUTF(r.string()); +} + +static void android_pim_Time_setToNow(JNIEnv* env, jobject This) +{ + env->SetBooleanField(This, g_allDayField, JNI_FALSE); + Time t; + ACQUIRE_TIMEZONE(This, t) + + t.setToNow(); + + time2java(env, This, t); + RELEASE_TIMEZONE(This, t) +} + +static jlong android_pim_Time_toMillis(JNIEnv* env, jobject This, + jboolean ignoreDst) +{ + Time t; + if (!java2time(env, &t, This)) return 0L; + ACQUIRE_TIMEZONE(This, t) + + int64_t result = t.toMillis(ignoreDst != 0); + + RELEASE_TIMEZONE(This, t) + + return result; +} + +static void android_pim_Time_set(JNIEnv* env, jobject This, jlong millis) +{ + env->SetBooleanField(This, g_allDayField, JNI_FALSE); + Time t; + if (!java2time(env, &t, This)) return; + ACQUIRE_TIMEZONE(This, t) + + t.set(millis); + + time2java(env, This, t); + RELEASE_TIMEZONE(This, t) +} + + +// ============================================================================ +// Just do this here because it's not worth recreating the strings + +static int get_char(JNIEnv* env, const jchar *s, int spos, int mul, + bool *thrown) +{ + jchar c = s[spos]; + if (c >= '0' && c <= '9') { + return (c - '0') * mul; + } else { + char msg[100]; + sprintf(msg, "Parse error at pos=%d", spos); + jniThrowException(env, "android/util/TimeFormatException", msg); + *thrown = true; + return 0; + } +} + +static bool check_char(JNIEnv* env, const jchar *s, int spos, jchar expected) +{ + jchar c = s[spos]; + if (c != expected) { + char msg[100]; + sprintf(msg, "Unexpected %c at pos=%d. Expected %c.", c, spos, + expected); + jniThrowException(env, "android/util/TimeFormatException", msg); + return false; + } + return true; +} + + +static void android_pim_Time_parse(JNIEnv* env, jobject This, jstring strObj) +{ + jsize len = env->GetStringLength(strObj); + const jchar *s = env->GetStringChars(strObj, NULL); + + bool thrown = false; + int n; + + n = get_char(env, s, 0, 1000, &thrown); + n += get_char(env, s, 1, 100, &thrown); + n += get_char(env, s, 2, 10, &thrown); + n += get_char(env, s, 3, 1, &thrown); + if (thrown) return; + env->SetIntField(This, g_yearField, n); + + n = get_char(env, s, 4, 10, &thrown); + n += get_char(env, s, 5, 1, &thrown); + n--; + if (thrown) return; + env->SetIntField(This, g_monField, n); + + n = get_char(env, s, 6, 10, &thrown); + n += get_char(env, s, 7, 1, &thrown); + if (thrown) return; + env->SetIntField(This, g_mdayField, n); + + if (len >= 15) { + env->SetBooleanField(This, g_allDayField, JNI_FALSE); + n = get_char(env, s, 9, 10, &thrown); + n += get_char(env, s, 10, 1, &thrown); + if (thrown) return; + env->SetIntField(This, g_hourField, n); + + n = get_char(env, s, 11, 10, &thrown); + n += get_char(env, s, 12, 1, &thrown); + if (thrown) return; + env->SetIntField(This, g_minField, n); + + n = get_char(env, s, 13, 10, &thrown); + n += get_char(env, s, 14, 1, &thrown); + if (thrown) return; + env->SetIntField(This, g_secField, n); + } else { + env->SetBooleanField(This, g_allDayField, JNI_TRUE); + env->SetIntField(This, g_hourField, 0); + env->SetIntField(This, g_minField, 0); + env->SetIntField(This, g_secField, 0); + } + + env->SetIntField(This, g_wdayField, 0); + env->SetIntField(This, g_ydayField, 0); + env->SetIntField(This, g_isdstField, -1); + env->SetLongField(This, g_gmtoffField, 0); + + env->ReleaseStringChars(strObj, s); +} + +static jboolean android_pim_Time_parse2445(JNIEnv* env, jobject This, + jstring strObj) +{ + jsize len = env->GetStringLength(strObj); + const jchar *s = env->GetStringChars(strObj, NULL); + + bool thrown = false; + int n; + jboolean inUtc = false; + + if (len < 8) { + char msg[100]; + sprintf(msg, "String too short -- expected at least 8 characters."); + jniThrowException(env, "android/util/TimeFormatException", msg); + return false; + } + + // year + n = get_char(env, s, 0, 1000, &thrown); + n += get_char(env, s, 1, 100, &thrown); + n += get_char(env, s, 2, 10, &thrown); + n += get_char(env, s, 3, 1, &thrown); + if (thrown) return false; + env->SetIntField(This, g_yearField, n); + + // month + n = get_char(env, s, 4, 10, &thrown); + n += get_char(env, s, 5, 1, &thrown); + n--; + if (thrown) return false; + env->SetIntField(This, g_monField, n); + + // day of month + n = get_char(env, s, 6, 10, &thrown); + n += get_char(env, s, 7, 1, &thrown); + if (thrown) return false; + env->SetIntField(This, g_mdayField, n); + + if (len > 8) { + // T + if (!check_char(env, s, 8, 'T')) return false; + env->SetBooleanField(This, g_allDayField, JNI_FALSE); + + // hour + n = get_char(env, s, 9, 10, &thrown); + n += get_char(env, s, 10, 1, &thrown); + if (thrown) return false; + env->SetIntField(This, g_hourField, n); + + // min + n = get_char(env, s, 11, 10, &thrown); + n += get_char(env, s, 12, 1, &thrown); + if (thrown) return false; + env->SetIntField(This, g_minField, n); + + // sec + n = get_char(env, s, 13, 10, &thrown); + n += get_char(env, s, 14, 1, &thrown); + if (thrown) return false; + env->SetIntField(This, g_secField, n); + + if (len > 15) { + // Z + if (!check_char(env, s, 15, 'Z')) return false; + inUtc = true; + } + } else { + // all day + env->SetBooleanField(This, g_allDayField, JNI_TRUE); + env->SetIntField(This, g_hourField, 0); + env->SetIntField(This, g_minField, 0); + env->SetIntField(This, g_secField, 0); + } + + env->SetIntField(This, g_wdayField, 0); + env->SetIntField(This, g_ydayField, 0); + env->SetIntField(This, g_isdstField, -1); + env->SetLongField(This, g_gmtoffField, 0); + + env->ReleaseStringChars(strObj, s); + return inUtc; +} + +static jboolean android_pim_Time_parse3339(JNIEnv* env, + jobject This, + jstring strObj) +{ + jsize len = env->GetStringLength(strObj); + const jchar *s = env->GetStringChars(strObj, NULL); + + bool thrown = false; + int n; + jboolean inUtc = false; + + // year + n = get_char(env, s, 0, 1000, &thrown); + n += get_char(env, s, 1, 100, &thrown); + n += get_char(env, s, 2, 10, &thrown); + n += get_char(env, s, 3, 1, &thrown); + if (thrown) return false; + env->SetIntField(This, g_yearField, n); + + // - + if (!check_char(env, s, 4, '-')) return false; + + // month + n = get_char(env, s, 5, 10, &thrown); + n += get_char(env, s, 6, 1, &thrown); + --n; + if (thrown) return false; + env->SetIntField(This, g_monField, n); + + // - + if (!check_char(env, s, 7, '-')) return false; + + // day + n = get_char(env, s, 8, 10, &thrown); + n += get_char(env, s, 9, 1, &thrown); + if (thrown) return false; + env->SetIntField(This, g_mdayField, n); + + if (len >= 17) { + // T + if (!check_char(env, s, 10, 'T')) return false; + + env->SetBooleanField(This, g_allDayField, JNI_FALSE); + // hour + n = get_char(env, s, 11, 10, &thrown); + n += get_char(env, s, 12, 1, &thrown); + if (thrown) return false; + int hour = n; + // env->SetIntField(This, g_hourField, n); + + // : + if (!check_char(env, s, 13, ':')) return false; + + // minute + n = get_char(env, s, 14, 10, &thrown); + n += get_char(env, s, 15, 1, &thrown); + if (thrown) return false; + int minute = n; + // env->SetIntField(This, g_minField, n); + + // : + if (!check_char(env, s, 16, ':')) return false; + + // second + n = get_char(env, s, 17, 10, &thrown); + n += get_char(env, s, 18, 1, &thrown); + if (thrown) return false; + env->SetIntField(This, g_secField, n); + + // skip the '.XYZ' -- we don't care about subsecond precision. + int offset = 0; + if (len >= 23) { + char c = s[23]; + + // NOTE: the offset is meant to be subtracted to get from local time + // to UTC. we therefore use 1 for '-' and -1 for '+'. + switch (c) { + case 'Z': + // Zulu time -- UTC + offset = 0; + break; + case '-': + offset = 1; + break; + case '+': + offset = -1; + break; + default: + char msg[100]; + sprintf(msg, "Unexpected %c at position 19. Expected + or -", + c); + jniThrowException(env, "android/util/TimeFormatException", msg); + return false; + } + inUtc = true; + + if (offset != 0) { + // hour + n = get_char(env, s, 24, 10, &thrown); + n += get_char(env, s, 25, 1, &thrown); + if (thrown) return false; + n *= offset; + hour += n; + + // : + if (!check_char(env, s, 26, ':')) return false; + + // minute + n = get_char(env, s, 27, 10, &thrown); + n += get_char(env, s, 28, 1, &thrown); + if (thrown) return false; + n *= offset; + minute += n; + } + } + env->SetIntField(This, g_hourField, hour); + env->SetIntField(This, g_minField, minute); + + if (offset != 0) { + // we need to normalize after applying the hour and minute offsets + android_pim_Time_normalize(env, This, false /* use isdst */); + // The timezone is set to UTC in the calling Java code. + } + } else { + env->SetBooleanField(This, g_allDayField, JNI_TRUE); + env->SetIntField(This, g_hourField, 0); + env->SetIntField(This, g_minField, 0); + env->SetIntField(This, g_secField, 0); + } + + env->SetIntField(This, g_wdayField, 0); + env->SetIntField(This, g_ydayField, 0); + env->SetIntField(This, g_isdstField, -1); + env->SetLongField(This, g_gmtoffField, 0); + + env->ReleaseStringChars(strObj, s); + return inUtc; +} + +// ============================================================================ +/* + * JNI registration. + */ +static JNINativeMethod gMethods[] = { + /* name, signature, funcPtr */ + { "normalize", "(Z)J", (void*)android_pim_Time_normalize }, + { "switchTimezone", "(Ljava/lang/String;)V", (void*)android_pim_Time_switchTimezone }, + { "compare", "(Landroid/pim/Time;Landroid/pim/Time;)I", (void*)android_pim_Time_compare }, + { "format", "(Ljava/lang/String;)Ljava/lang/String;", (void*)android_pim_Time_format }, + { "format2445", "()Ljava/lang/String;", (void*)android_pim_Time_format2445 }, + { "toString", "()Ljava/lang/String;", (void*)android_pim_Time_toString }, + { "parse", "(Ljava/lang/String;)V", (void*)android_pim_Time_parse }, + { "nativeParse2445", "(Ljava/lang/String;)Z", (void*)android_pim_Time_parse2445 }, + { "nativeParse3339", "(Ljava/lang/String;)Z", (void*)android_pim_Time_parse3339 }, + { "setToNow", "()V", (void*)android_pim_Time_setToNow }, + { "toMillis", "(Z)J", (void*)android_pim_Time_toMillis }, + { "set", "(J)V", (void*)android_pim_Time_set } +}; + +int register_android_pim_Time(JNIEnv* env) +{ + jclass timeClass = env->FindClass("android/pim/Time"); + + g_allDayField = env->GetFieldID(timeClass, "allDay", "Z"); + g_secField = env->GetFieldID(timeClass, "second", "I"); + g_minField = env->GetFieldID(timeClass, "minute", "I"); + g_hourField = env->GetFieldID(timeClass, "hour", "I"); + g_mdayField = env->GetFieldID(timeClass, "monthDay", "I"); + g_monField = env->GetFieldID(timeClass, "month", "I"); + g_yearField = env->GetFieldID(timeClass, "year", "I"); + g_wdayField = env->GetFieldID(timeClass, "weekDay", "I"); + g_ydayField = env->GetFieldID(timeClass, "yearDay", "I"); + g_isdstField = env->GetFieldID(timeClass, "isDst", "I"); + g_gmtoffField = env->GetFieldID(timeClass, "gmtoff", "J"); + g_timezoneField = env->GetFieldID(timeClass, "timezone", "Ljava/lang/String;"); + + return AndroidRuntime::registerNativeMethods(env, "android/pim/Time", gMethods, NELEM(gMethods)); +} + +}; // namespace android + diff --git a/core/jni/android_security_Md5MessageDigest.cpp b/core/jni/android_security_Md5MessageDigest.cpp new file mode 100644 index 0000000..3533559 --- /dev/null +++ b/core/jni/android_security_Md5MessageDigest.cpp @@ -0,0 +1,126 @@ +/* + * Copyright (C) 2006 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. + */ + +#include "jni.h" +#include <JNIHelp.h> +#include <stdlib.h> +#include <stdint.h> + +#include <openssl/md5.h> + +namespace android +{ + +struct fields_t { + jfieldID context; +}; +static fields_t fields; + +static void native_init(JNIEnv *env, jobject clazz) +{ + MD5_CTX* context = (MD5_CTX *)malloc(sizeof(MD5_CTX)); + MD5_Init(context); + + env->SetIntField(clazz, fields.context, (int)context); +} + +static void native_reset(JNIEnv *env, jobject clazz) +{ + MD5_CTX *context = (MD5_CTX *)env->GetIntField(clazz, fields.context); + if (context != NULL) { + free(context); + env->SetIntField(clazz, fields.context, 0 ); + } +} + +static void native_update(JNIEnv *env, jobject clazz, jbyteArray dataArray) +{ + jbyte * data; + jsize dataSize; + MD5_CTX *context = (MD5_CTX *)env->GetIntField(clazz, fields.context); + + if (context == NULL) { + native_init(env, clazz); + context = (MD5_CTX *)env->GetIntField(clazz, fields.context); + } + + data = env->GetByteArrayElements(dataArray, NULL); + if (data == NULL) { + LOGE("Unable to get byte array elements"); + jniThrowException(env, "java/lang/IllegalArgumentException", + "Invalid data array when calling MessageDigest.update()"); + return; + } + dataSize = env->GetArrayLength(dataArray); + + MD5_Update(context, data, dataSize); + + env->ReleaseByteArrayElements(dataArray, data, 0); +} + +static jbyteArray native_digest(JNIEnv *env, jobject clazz) +{ + jbyteArray array; + jbyte md[MD5_DIGEST_LENGTH]; + MD5_CTX *context = (MD5_CTX *)env->GetIntField(clazz, fields.context); + + MD5_Final((uint8_t*)md, context); + + array = env->NewByteArray(MD5_DIGEST_LENGTH); + LOG_ASSERT(array, "Native could not create new byte[]"); + + env->SetByteArrayRegion(array, 0, MD5_DIGEST_LENGTH, md); + + native_reset(env, clazz); + + return array; +} + + +/* + * JNI registration. + */ + +static JNINativeMethod gMethods[] = +{ + /* name, signature, funcPtr */ + {"init", "()V", (void *)native_init}, + {"update", "([B)V", (void *)native_update}, + {"digest", "()[B", (void *)native_digest}, + {"reset", "()V", (void *)native_reset}, +}; + +int register_android_security_Md5MessageDigest(JNIEnv *env) +{ + jclass clazz; + + clazz = env->FindClass("android/security/Md5MessageDigest"); + if (clazz == NULL) { + LOGE("Can't find android/security/Md5MessageDigest"); + return -1; + } + + fields.context = env->GetFieldID(clazz, "mNativeMd5Context", "I"); + if (fields.context == NULL) { + LOGE("Can't find Md5MessageDigest.mNativeMd5Context"); + return -1; + } + + return jniRegisterNativeMethods(env, "android/security/Md5MessageDigest", + gMethods, NELEM(gMethods)); +} + +}; diff --git a/core/jni/android_server_BluetoothDeviceService.cpp b/core/jni/android_server_BluetoothDeviceService.cpp new file mode 100644 index 0000000..3ff6af1 --- /dev/null +++ b/core/jni/android_server_BluetoothDeviceService.cpp @@ -0,0 +1,1144 @@ +/* +** Copyright 2006, 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. +*/ + +#define DBUS_CLASS_NAME BLUEZ_DBUS_BASE_IFC ".Adapter" +#define LOG_TAG "BluetoothDeviceService.cpp" + +#include "android_bluetooth_common.h" +#include "android_runtime/AndroidRuntime.h" +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <ctype.h> +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> + +#include <sys/socket.h> +#include <sys/ioctl.h> +#include <fcntl.h> + +#ifdef HAVE_BLUETOOTH +#include <dbus/dbus.h> +#include <bluedroid/bluetooth.h> +#endif + +#include <cutils/properties.h> + +namespace android { + +#ifdef HAVE_BLUETOOTH +// We initialize these variables when we load class +// android.server.BluetoothDeviceService +static jfieldID field_mNativeData; + +typedef struct { + JNIEnv *env; + DBusConnection *conn; + const char *adapter; // dbus object name of the local adapter +} native_data_t; + +void onCreateBondingResult(DBusMessage *msg, void *user); +void onGetRemoteServiceChannelResult(DBusMessage *msg, void *user); + +/** Get native data stored in the opaque (Java code maintained) pointer mNativeData + * Perform quick sanity check, if there are any problems return NULL + */ +static inline native_data_t * get_native_data(JNIEnv *env, jobject object) { + native_data_t *nat = + (native_data_t *)(env->GetIntField(object, field_mNativeData)); + if (nat == NULL || nat->conn == NULL) { + LOGE("Uninitialized native data\n"); + return NULL; + } + return nat; +} +#endif + +static void classInitNative(JNIEnv* env, jclass clazz) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + field_mNativeData = get_field(env, clazz, "mNativeData", "I"); +#endif +} + +/* Returns true on success (even if adapter is present but disabled). + * Return false if dbus is down, or another serious error (out of memory) +*/ +static bool initializeNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = (native_data_t *)calloc(1, sizeof(native_data_t)); + if (NULL == nat) { + LOGE("%s: out of memory!", __FUNCTION__); + return false; + } + nat->env = env; + + env->SetIntField(object, field_mNativeData, (jint)nat); + DBusError err; + dbus_error_init(&err); + dbus_threads_init_default(); + nat->conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + if (dbus_error_is_set(&err)) { + LOGE("Could not get onto the system bus: %s", err.message); + dbus_error_free(&err); + return false; + } + + nat->adapter = BLUEZ_ADAPTER_OBJECT_NAME; +#endif /*HAVE_BLUETOOTH*/ + return true; +} + +static void cleanupNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = + (native_data_t *)env->GetIntField(object, field_mNativeData); + if (nat) { + free(nat); + nat = NULL; + } +#endif +} + +static jstring getNameNative(JNIEnv *env, jobject object){ + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "GetName", + DBUS_TYPE_INVALID); + return reply ? dbus_returns_string(env, reply) : NULL; + } +#endif + return NULL; +} + +static jstring getAdapterPathNative(JNIEnv *env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + if (nat) { + return (env->NewStringUTF(nat->adapter)); + } +#endif + return NULL; +} + + +static jboolean startDiscoveryNative(JNIEnv *env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + DBusMessage *msg = NULL; + DBusMessage *reply = NULL; + DBusError err; + const char *name; + jboolean ret = JNI_FALSE; + + native_data_t *nat = get_native_data(env, object); + if (nat == NULL) { + goto done; + } + + dbus_error_init(&err); + + /* Compose the command */ + msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC, nat->adapter, + DBUS_CLASS_NAME, "DiscoverDevices"); + + if (msg == NULL) { + LOGE("%s: Could not allocate D-Bus message object!", __FUNCTION__); + goto done; + } + + /* Send the command. */ + reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err); + if (dbus_error_is_set(&err)) { + /* We treat the in-progress error code as success. */ + if(strcmp(err.message, BLUEZ_DBUS_BASE_IFC ".Error.InProgress") == 0) { + LOGW("%s: D-Bus error: %s, treating as startDiscoveryNative success\n", + __FUNCTION__, err.message); + ret = JNI_TRUE; + goto done; + } else { + LOGE("%s: D-Bus error: %s (%s)\n", __FUNCTION__, err.name, err.message); + ret = JNI_FALSE; + goto done; + } + } + + ret = JNI_TRUE; +done: + if (reply) dbus_message_unref(reply); + if (msg) dbus_message_unref(msg); + return ret; +#else + return JNI_FALSE; +#endif +} + +static void cancelDiscoveryNative(JNIEnv *env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + DBusMessage *msg = NULL; + DBusMessage *reply = NULL; + DBusError err; + const char *name; + jstring ret; + native_data_t *nat; + + dbus_error_init(&err); + + nat = get_native_data(env, object); + if (nat == NULL) { + goto done; + } + + /* Compose the command */ + msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC, nat->adapter, + DBUS_CLASS_NAME, "CancelDiscovery"); + + if (msg == NULL) { + LOGE("%s: Could not allocate D-Bus message object!", __FUNCTION__); + goto done; + } + + /* Send the command. */ + reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err); + if (dbus_error_is_set(&err)) { + if(strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.NotAuthorized") == 0) { + // hcid sends this if there is no active discovery to cancel + LOGV("%s: There was no active discovery to cancel", __FUNCTION__); + dbus_error_free(&err); + } else { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + } + } + +done: + if (msg) dbus_message_unref(msg); + if (reply) dbus_message_unref(reply); +#endif +} + +static jboolean startPeriodicDiscoveryNative(JNIEnv *env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + DBusMessage *msg = NULL; + DBusMessage *reply = NULL; + DBusError err; + jboolean ret = JNI_FALSE; + + native_data_t *nat = get_native_data(env, object); + if (nat == NULL) { + goto done; + } + + dbus_error_init(&err); + msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC, nat->adapter, + DBUS_CLASS_NAME, "StartPeriodicDiscovery"); + if (msg == NULL) { + LOGE("%s: Could not allocate DBUS message object\n", __FUNCTION__); + goto done; + } + + /* Send the command. */ + reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err); + if (dbus_error_is_set(&err)) { + /* We treat the in-progress error code as success. */ + if(strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.InProgress") == 0) { + LOGW("%s: D-Bus error: %s (%s), treating as " + "startPeriodicDiscoveryNative success\n", + __FUNCTION__, err.name, err.message); + } else { + LOGE("%s: D-Bus error: %s (%s)\n", __FUNCTION__, err.name, err.message); + ret = JNI_FALSE; + goto done; + } + } + + ret = JNI_TRUE; +done: + if (reply) dbus_message_unref(reply); + if (msg) dbus_message_unref(msg); + return ret; +#else + return JNI_FALSE; +#endif +} + +static jboolean stopPeriodicDiscoveryNative(JNIEnv *env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + DBusMessage *msg = NULL; + DBusMessage *reply = NULL; + DBusError err; + const char *name; + jboolean ret = JNI_FALSE; + + native_data_t *nat = get_native_data(env, object); + if (nat == NULL) { + goto done; + } + + dbus_error_init(&err); + msg = dbus_message_new_method_call(BLUEZ_DBUS_BASE_IFC, nat->adapter, + DBUS_CLASS_NAME, "StopPeriodicDiscovery"); + if (msg == NULL) { + LOGE("%s: Could not allocate DBUS message object\n", __FUNCTION__); + goto done; + } + + /* Send the command. */ + reply = dbus_connection_send_with_reply_and_block(nat->conn, msg, -1, &err); + if (dbus_error_is_set(&err)) { + /* We treat the in-progress error code as success. */ + if(strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.InProgress") == 0) { + LOGW("%s: D-Bus error: %s (%s), treating as " + "stopPeriodicDiscoveryNative success\n", + __FUNCTION__, err.name, err.message); + } else { + LOGE("%s: D-Bus error: %s (%s)\n", __FUNCTION__, err.name, err.message); + ret = JNI_FALSE; + goto done; + } + } + + ret = JNI_TRUE; +done: + if (reply) dbus_message_unref(reply); + if (msg) dbus_message_unref(msg); + return ret; +#else + return JNI_FALSE; +#endif +} + +static jboolean isPeriodicDiscoveryNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "IsPeriodicDiscovery", + DBUS_TYPE_INVALID); + return reply ? dbus_returns_boolean(env, reply) : JNI_FALSE; + } +#endif + return JNI_FALSE; +} + +static jboolean setDiscoverableTimeoutNative(JNIEnv *env, jobject object, jint timeout_s) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + + if (timeout_s < 0) { + return JNI_FALSE; + } + + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "SetDiscoverableTimeout", + DBUS_TYPE_UINT32, &timeout_s, + DBUS_TYPE_INVALID); + if (reply != NULL) { + dbus_message_unref(reply); + return JNI_TRUE; + } + } +#endif + return JNI_FALSE; +} + +static jint getDiscoverableTimeoutNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "GetDiscoverableTimeout", + DBUS_TYPE_INVALID); + return reply ? dbus_returns_uint32(env, reply) : -1; + } +#endif + return -1; +} + +static jboolean isConnectedNative(JNIEnv *env, jobject object, jstring address) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "IsConnected", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + return reply ? dbus_returns_boolean(env, reply) : JNI_FALSE; + } +#endif + return JNI_FALSE; +} + +static void disconnectRemoteDeviceNative(JNIEnv *env, jobject object, jstring address) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + // Set a timeout of 5 seconds. Specifying the default timeout is + // not long enough, as a remote-device disconnect results in + // signal RemoteDisconnectRequested being sent, followed by a + // delay of 2 seconds, after which the actual disconnect takes + // place. + DBusMessage *reply = + dbus_func_args_timeout(env, nat->conn, 60000, nat->adapter, + DBUS_CLASS_NAME, "DisconnectRemoteDevice", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + if (reply) dbus_message_unref(reply); + } +#endif +} + +static jboolean isConnectableNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "IsConnectable", + DBUS_TYPE_INVALID); + return reply ? dbus_returns_boolean(env, reply) : JNI_FALSE; + } +#endif + return JNI_FALSE; +} + +static jboolean isDiscoverableNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "IsDiscoverable", + DBUS_TYPE_INVALID); + return reply ? dbus_returns_boolean(env, reply) : JNI_FALSE; + } +#endif + return JNI_FALSE; +} + +static jstring getModeNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "GetMode", + DBUS_TYPE_INVALID); + return reply ? dbus_returns_string(env, reply) : NULL; + } +#endif + return NULL; +} + +static jboolean setModeNative(JNIEnv *env, jobject object, jstring mode) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_mode = env->GetStringUTFChars(mode, NULL); + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "SetMode", + DBUS_TYPE_STRING, &c_mode, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(mode, c_mode); + if (reply) { + dbus_message_unref(reply); + return JNI_TRUE; + } + return JNI_FALSE; + } +#endif + return JNI_FALSE; +} + +static void common_Bonding(JNIEnv *env, jobject object, int timeout_ms, + const char *func, jstring address) { +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + LOGV("... address = %s", c_address); + DBusMessage *reply = + dbus_func_args_timeout(env, nat->conn, timeout_ms, nat->adapter, + DBUS_CLASS_NAME, func, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + if (reply) { + dbus_message_unref(reply); + } + } +#endif +} + +static jboolean createBondingNative(JNIEnv *env, jobject object, + jstring address, jint timeout_ms) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + LOGV("... address = %s", c_address); + char *context_address = (char *)calloc(BTADDR_SIZE, sizeof(char)); + strlcpy(context_address, c_address, BTADDR_SIZE); // for callback + bool ret = dbus_func_args_async(env, nat->conn, (int)timeout_ms, + onCreateBondingResult, // callback + context_address, // user data + nat->adapter, + DBUS_CLASS_NAME, "CreateBonding", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + return ret ? JNI_TRUE : JNI_FALSE; + + } +#endif + return JNI_FALSE; +} + +static void cancelBondingProcessNative(JNIEnv *env, jobject object, + jstring address) { + LOGV(__FUNCTION__); + common_Bonding(env, object, -1, "CancelBondingProcess", address); +} + +static void removeBondingNative(JNIEnv *env, jobject object, jstring address) { + LOGV(__FUNCTION__); + common_Bonding(env, object, -1, "RemoveBonding", address); +} + +static jboolean hasBondingNative(JNIEnv *env, jobject object, jstring address) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + LOGV("... address = %s", c_address); + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "HasBonding", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + return reply ? dbus_returns_boolean(env, reply) : JNI_FALSE; + } +#endif + return JNI_FALSE; +} + +static jobjectArray listBondingsNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "ListBondings", + DBUS_TYPE_INVALID); + // return String[] + return reply ? dbus_returns_array_of_strings(env, reply) : NULL; + } +#endif + return NULL; +} + +static jobjectArray listConnectionsNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "ListConnections", + DBUS_TYPE_INVALID); + // return String[] + return reply ? dbus_returns_array_of_strings(env, reply) : NULL; + } +#endif + return NULL; +} + +static jobjectArray listRemoteDevicesNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "ListRemoteDevices", + DBUS_TYPE_INVALID); + return reply ? dbus_returns_array_of_strings(env, reply) : NULL; + } +#endif + return NULL; +} + +static jstring common_Get(JNIEnv *env, jobject object, const char *func) { + LOGV("%s:%s", __FUNCTION__, func); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusError err; + dbus_error_init(&err); + DBusMessage *reply = + dbus_func_args_error(env, nat->conn, &err, nat->adapter, + DBUS_CLASS_NAME, func, + DBUS_TYPE_INVALID); + if (reply) { + return dbus_returns_string(env, reply); + } else { + LOG_AND_FREE_DBUS_ERROR(&err); + return NULL; + } + } +#endif + return NULL; +} + +static jstring getAddressNative(JNIEnv *env, jobject obj) { + return common_Get(env, obj, "GetAddress"); +} + +static jstring getVersionNative(JNIEnv *env, jobject obj) { + return common_Get(env, obj, "GetVersion"); +} + +static jstring getRevisionNative(JNIEnv *env, jobject obj) { + return common_Get(env, obj, "GetRevision"); +} + +static jstring getManufacturerNative(JNIEnv *env, jobject obj) { + return common_Get(env, obj, "GetManufacturer"); +} + +static jstring getCompanyNative(JNIEnv *env, jobject obj) { + return common_Get(env, obj, "GetCompany"); +} + +static jboolean setNameNative(JNIEnv *env, jobject obj, jstring name) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, obj); + if (nat) { + const char *c_name = env->GetStringUTFChars(name, NULL); + DBusMessage *reply = dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "SetName", + DBUS_TYPE_STRING, &c_name, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(name, c_name); + if (reply) { + dbus_message_unref(reply); + return JNI_TRUE; + } + } +#endif + return JNI_FALSE; +} + +static jstring getMajorClassNative(JNIEnv *env, jobject obj) { + return common_Get(env, obj, "GetMajorClass"); +} + +static jstring getMinorClassNative(JNIEnv *env, jobject obj) { + return common_Get(env, obj, "GetMinorClass"); +} + +static jstring common_getRemote(JNIEnv *env, jobject object, const char *func, + jstring address) { + LOGV("%s:%s", __FUNCTION__, func); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + DBusError err; + dbus_error_init(&err); + + LOGV("... address = %s", c_address); + + DBusMessage *reply = + dbus_func_args_error(env, nat->conn, &err, nat->adapter, + DBUS_CLASS_NAME, func, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + if (reply) { + return dbus_returns_string(env, reply); + } else if (!strcmp(func, "GetRemoteName") && + dbus_error_has_name(&err, "org.bluez.Error.RequestDeferred")) { + // This error occurs if we request name during device discovery, + // its fine + LOGV("... %s: %s", func, err.message); + dbus_error_free(&err); + return NULL; + } else { + LOG_AND_FREE_DBUS_ERROR(&err); + return NULL; + } + } +#endif + return NULL; +} + +static jstring getRemoteAliasNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "GetRemoteAlias", address); +} + +static jboolean setRemoteAliasNative(JNIEnv *env, jobject obj, + jstring address, jstring alias) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, obj); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + const char *c_alias = env->GetStringUTFChars(alias, NULL); + + LOGV("... address = %s alias = %s", c_address, c_alias); + + DBusMessage *reply = dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "SetRemoteAlias", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_STRING, &c_alias, + DBUS_TYPE_INVALID); + + env->ReleaseStringUTFChars(address, c_address); + env->ReleaseStringUTFChars(alias, c_alias); + if (reply) + { + dbus_message_unref(reply); + return JNI_TRUE; + } + return JNI_FALSE; + } +#endif + return JNI_FALSE; +} + +static jboolean clearRemoteAliasNative(JNIEnv *env, jobject obj, jstring address) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, obj); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + + LOGV("... address = %s", c_address); + + DBusMessage *reply = dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "ClearRemoteAlias", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + + env->ReleaseStringUTFChars(address, c_address); + if (reply) + { + dbus_message_unref(reply); + return JNI_TRUE; + } + return JNI_FALSE; + } +#endif + return JNI_FALSE; +} + +static jstring getRemoteVersionNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "GetRemoteVersion", address); +} + +static jstring getRemoteRevisionNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "GetRemoteRevision", address); +} + +static jstring getRemoteManufacturerNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "GetRemoteManufacturer", address); +} + +static jstring getRemoteCompanyNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "GetRemoteCompany", address); +} + +static jstring getRemoteMajorClassNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "GetRemoteMajorClass", address); +} + +static jstring getRemoteMinorClassNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "GetRemoteMinorClass", address); +} + +static jstring getRemoteNameNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "GetRemoteName", address); +} + +static jstring lastSeenNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "LastSeen", address); +} + +static jstring lastUsedNative(JNIEnv *env, jobject obj, jstring address) { + return common_getRemote(env, obj, "LastUsed", address); +} + +static jobjectArray getRemoteServiceClassesNative(JNIEnv *env, jobject object, + jstring address) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + + LOGV("... address = %s", c_address); + + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "GetRemoteServiceClasses", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + return reply ? dbus_returns_array_of_strings(env, reply) : NULL; + } +#endif + return NULL; +} + +static jint getRemoteClassNative(JNIEnv *env, jobject object, jstring address) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + jint ret = 0; + const char *c_address = env->GetStringUTFChars(address, NULL); + + LOGV("... address = %s", c_address); + + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "GetRemoteClass", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + if (reply) + { + DBusError err; + dbus_error_init(&err); + if (!dbus_message_get_args(reply, &err, + DBUS_TYPE_UINT32, &ret, + DBUS_TYPE_INVALID)) { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply); + } + dbus_message_unref(reply); + } + + return ret; + } +#endif + return 0; +} + +static jbyteArray getRemoteFeaturesNative(JNIEnv *env, jobject object, + jstring address) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + + LOGV("... address = %s", c_address); + + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "GetRemoteFeatures", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + /* array of DBUS_TYPE_BYTE_AS_STRING */ + return reply ? dbus_returns_array_of_bytes(env, reply) : NULL; + } +#endif + return NULL; +} + +static jintArray getRemoteServiceHandlesNative(JNIEnv *env, jobject object, + jstring address, jstring match) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + jintArray intArray = NULL; + const char *c_address = env->GetStringUTFChars(address, NULL); + const char *c_match = env->GetStringUTFChars(match, NULL); + + LOGV("... address = %s match = %s", c_address, c_match); + + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "GetRemoteServiceHandles", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_STRING, &c_match, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + env->ReleaseStringUTFChars(match, c_match); + if (reply) + { + DBusError err; + jint *list; + int i, len; + + dbus_error_init(&err); + if (dbus_message_get_args (reply, &err, + DBUS_TYPE_ARRAY, DBUS_TYPE_UINT32, + &list, &len, + DBUS_TYPE_INVALID)) { + if (len) { + intArray = env->NewIntArray(len); + if (intArray) + env->SetIntArrayRegion(intArray, 0, len, list); + } + } else { + LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, reply); + } + + dbus_message_unref(reply); + } + return intArray; + } +#endif + return NULL; +} + +static jbyteArray getRemoteServiceRecordNative(JNIEnv *env, jobject object, + jstring address, jint handle) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + + LOGV("... address = %s", c_address); + + DBusMessage *reply = + dbus_func_args(env, nat->conn, nat->adapter, + DBUS_CLASS_NAME, "GetRemoteServiceRecord", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_UINT32, &handle, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + return reply ? dbus_returns_array_of_bytes(env, reply) : NULL; + } +#endif + return NULL; +} + +static jboolean getRemoteServiceChannelNative(JNIEnv *env, jobject object, + jstring address, jshort uuid16) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + const char *c_address = env->GetStringUTFChars(address, NULL); + char *context_address = (char *)calloc(BTADDR_SIZE, sizeof(char)); + strlcpy(context_address, c_address, BTADDR_SIZE); + + LOGV("... address = %s", c_address); + LOGV("... uuid16 = %#X", uuid16); + + bool ret = dbus_func_args_async(env, nat->conn, 20000, // ms + onGetRemoteServiceChannelResult, context_address, + nat->adapter, + DBUS_CLASS_NAME, "GetRemoteServiceChannel", + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_UINT16, &uuid16, + DBUS_TYPE_INVALID); + env->ReleaseStringUTFChars(address, c_address); + return ret ? JNI_TRUE : JNI_FALSE; + } +#endif + return JNI_FALSE; +} + +static jint enableNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + return bt_enable(); +#endif + return -1; +} + +static jint disableNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + return bt_disable(); +#endif + return -1; +} + +static jint isEnabledNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + return bt_is_enabled(); +#endif + return -1; +} + +static jboolean setPinNative(JNIEnv *env, jobject object, jstring address, + jstring pin, int nativeData) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *msg = (DBusMessage *)nativeData; + DBusMessage *reply = dbus_message_new_method_return(msg); + if (!reply) { + LOGE("%s: Cannot create message reply to return PIN code to " + "D-Bus\n", __FUNCTION__); + dbus_message_unref(msg); + return JNI_FALSE; + } + + const char *c_pin = env->GetStringUTFChars(pin, NULL); + + dbus_message_append_args(reply, DBUS_TYPE_STRING, &c_pin, + DBUS_TYPE_INVALID); + + dbus_connection_send(nat->conn, reply, NULL); + dbus_message_unref(msg); + dbus_message_unref(reply); + env->ReleaseStringUTFChars(pin, c_pin); + return JNI_TRUE; + } +#endif + return JNI_FALSE; +} + +static jboolean cancelPinNative(JNIEnv *env, jobject object, jstring address, + int nativeData) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + native_data_t *nat = get_native_data(env, object); + if (nat) { + DBusMessage *msg = (DBusMessage *)nativeData; + DBusMessage *reply = dbus_message_new_error(msg, + "org.bluez.Error.Canceled", "PIN Entry was canceled"); + if (!reply) { + LOGE("%s: Cannot create message reply to return PIN cancel to " + "D-BUS\n", __FUNCTION__); + dbus_message_unref(msg); + return JNI_FALSE; + } + + dbus_connection_send(nat->conn, reply, NULL); + dbus_message_unref(msg); + dbus_message_unref(reply); + return JNI_TRUE; + } +#endif + return JNI_FALSE; +} + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + {"classInitNative", "()V", (void*)classInitNative}, + {"initializeNativeDataNative", "()V", (void *)initializeNativeDataNative}, + {"cleanupNativeDataNative", "()V", (void *)cleanupNativeDataNative}, + {"getAdapterPathNative", "()Ljava/lang/String;", (void*)getAdapterPathNative}, + + {"isEnabledNative", "()I", (void *)isEnabledNative}, + {"enableNative", "()I", (void *)enableNative}, + {"disableNative", "()I", (void *)disableNative}, + + {"getAddressNative", "()Ljava/lang/String;", (void *)getAddressNative}, + {"getNameNative", "()Ljava/lang/String;", (void*)getNameNative}, + {"setNameNative", "(Ljava/lang/String;)Z", (void *)setNameNative}, + {"getMajorClassNative", "()Ljava/lang/String;", (void *)getMajorClassNative}, + {"getMinorClassNative", "()Ljava/lang/String;", (void *)getMinorClassNative}, + {"getVersionNative", "()Ljava/lang/String;", (void *)getVersionNative}, + {"getRevisionNative", "()Ljava/lang/String;", (void *)getRevisionNative}, + {"getManufacturerNative", "()Ljava/lang/String;", (void *)getManufacturerNative}, + {"getCompanyNative", "()Ljava/lang/String;", (void *)getCompanyNative}, + + {"getModeNative", "()Ljava/lang/String;", (void *)getModeNative}, + {"setModeNative", "(Ljava/lang/String;)Z", (void *)setModeNative}, + + {"getDiscoverableTimeoutNative", "()I", (void *)getDiscoverableTimeoutNative}, + {"setDiscoverableTimeoutNative", "(I)Z", (void *)setDiscoverableTimeoutNative}, + + {"startDiscoveryNative", "(Z)Z", (void*)startDiscoveryNative}, + {"cancelDiscoveryNative", "()Z", (void *)cancelDiscoveryNative}, + {"startPeriodicDiscoveryNative", "()Z", (void *)startPeriodicDiscoveryNative}, + {"stopPeriodicDiscoveryNative", "()Z", (void *)stopPeriodicDiscoveryNative}, + {"isPeriodicDiscoveryNative", "()Z", (void *)isPeriodicDiscoveryNative}, + {"listRemoteDevicesNative", "()[Ljava/lang/String;", (void *)listRemoteDevicesNative}, + + {"listConnectionsNative", "()[Ljava/lang/String;", (void *)listConnectionsNative}, + {"isConnectedNative", "(Ljava/lang/String;)Z", (void *)isConnectedNative}, + {"disconnectRemoteDeviceNative", "(Ljava/lang/String;)Z", (void *)disconnectRemoteDeviceNative}, + + {"createBondingNative", "(Ljava/lang/String;I)Z", (void *)createBondingNative}, + {"cancelBondingProcessNative", "(Ljava/lang/String;)Z", (void *)cancelBondingProcessNative}, + {"listBondingsNative", "()[Ljava/lang/String;", (void *)listBondingsNative}, + {"hasBondingNative", "(Ljava/lang/String;)Z", (void *)hasBondingNative}, + {"removeBondingNative", "(Ljava/lang/String;)Z", (void *)removeBondingNative}, + + {"getRemoteNameNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)getRemoteNameNative}, + {"getRemoteAliasNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)getRemoteAliasNative}, + {"setRemoteAliasNative", "(Ljava/lang/String;Ljava/lang/String;)Z", (void *)setRemoteAliasNative}, + {"clearRemoteAliasNative", "(Ljava/lang/String;)Z", (void *)clearRemoteAliasNative}, + {"getRemoteVersionNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)getRemoteVersionNative}, + {"getRemoteRevisionNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)getRemoteRevisionNative}, + {"getRemoteClassNative", "(Ljava/lang/String;)I", (void *)getRemoteClassNative}, + {"getRemoteManufacturerNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)getRemoteManufacturerNative}, + {"getRemoteCompanyNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)getRemoteCompanyNative}, + {"getRemoteMajorClassNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)getRemoteMajorClassNative}, + {"getRemoteMinorClassNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)getRemoteMinorClassNative}, + {"getRemoteServiceClassesNative", "(Ljava/lang/String;)[Ljava/lang/String;", (void *)getRemoteServiceClassesNative}, + {"getRemoteServiceChannelNative", "(Ljava/lang/String;S)Z", (void *)getRemoteServiceChannelNative}, + {"getRemoteFeaturesNative", "(Ljava/lang/String;)[B", (void *)getRemoteFeaturesNative}, + {"lastSeenNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)lastSeenNative}, + {"lastUsedNative", "(Ljava/lang/String;)Ljava/lang/String;", (void *)lastUsedNative}, + {"setPinNative", "(Ljava/lang/String;Ljava/lang/String;I)Z", (void *)setPinNative}, + {"cancelPinNative", "(Ljava/lang/String;I)Z", (void *)cancelPinNative}, +}; + +int register_android_server_BluetoothDeviceService(JNIEnv *env) { + return AndroidRuntime::registerNativeMethods(env, + "android/server/BluetoothDeviceService", sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/android_server_BluetoothEventLoop.cpp b/core/jni/android_server_BluetoothEventLoop.cpp new file mode 100644 index 0000000..395a45c --- /dev/null +++ b/core/jni/android_server_BluetoothEventLoop.cpp @@ -0,0 +1,642 @@ +/* +** Copyright 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. +*/ + +#define LOG_TAG "BluetoothEventLoop.cpp" + +#include "android_bluetooth_common.h" +#include "android_runtime/AndroidRuntime.h" +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <stdio.h> +#include <string.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> + +#ifdef HAVE_BLUETOOTH +#include <dbus/dbus.h> +#endif + +namespace android { + +#ifdef HAVE_BLUETOOTH +static jfieldID field_mNativeData; + +static jmethodID method_onModeChanged; +static jmethodID method_onDiscoveryStarted; +static jmethodID method_onDiscoveryCompleted; +static jmethodID method_onRemoteDeviceFound; +static jmethodID method_onRemoteDeviceDisappeared; +static jmethodID method_onRemoteClassUpdated; +static jmethodID method_onRemoteNameUpdated; +static jmethodID method_onRemoteNameFailed; +static jmethodID method_onRemoteAliasChanged; +static jmethodID method_onRemoteAliasCleared; +static jmethodID method_onRemoteDeviceConnected; +static jmethodID method_onRemoteDeviceDisconnectRequested; +static jmethodID method_onRemoteDeviceDisconnected; +static jmethodID method_onBondingCreated; +static jmethodID method_onBondingRemoved; + +static jmethodID method_onCreateBondingResult; +static jmethodID method_onGetRemoteServiceChannelResult; + +static jmethodID method_onPasskeyAgentRequest; +static jmethodID method_onPasskeyAgentCancel; + +struct native_data_t { + DBusConnection *conn; + /* These variables are set in waitForAndDispatchEventNative() and are + valid only within the scope of this function. At any other time, they + are NULL. */ + jobject me; + JNIEnv *env; +}; + +// Only valid during waitForAndDispatchEventNative() +static native_data_t *event_loop_nat; + +static inline native_data_t * get_native_data(JNIEnv *env, jobject object) { + return (native_data_t *)(env->GetIntField(object, + field_mNativeData)); +} + +#endif +static void classInitNative(JNIEnv* env, jclass clazz) { + LOGV(__FUNCTION__); + +#ifdef HAVE_BLUETOOTH + method_onModeChanged = env->GetMethodID(clazz, "onModeChanged", "(Ljava/lang/String;)V"); + method_onDiscoveryStarted = env->GetMethodID(clazz, "onDiscoveryStarted", "()V"); + method_onDiscoveryCompleted = env->GetMethodID(clazz, "onDiscoveryCompleted", "()V"); + method_onRemoteDeviceFound = env->GetMethodID(clazz, "onRemoteDeviceFound", "(Ljava/lang/String;IS)V"); + method_onRemoteDeviceDisappeared = env->GetMethodID(clazz, "onRemoteDeviceDisappeared", "(Ljava/lang/String;)V"); + method_onRemoteClassUpdated = env->GetMethodID(clazz, "onRemoteClassUpdated", "(Ljava/lang/String;I)V"); + method_onRemoteNameUpdated = env->GetMethodID(clazz, "onRemoteNameUpdated", "(Ljava/lang/String;Ljava/lang/String;)V"); + method_onRemoteNameFailed = env->GetMethodID(clazz, "onRemoteNameFailed", "(Ljava/lang/String;)V"); + method_onRemoteAliasChanged = env->GetMethodID(clazz, "onRemoteAliasChanged", "(Ljava/lang/String;Ljava/lang/String;)V"); + method_onRemoteDeviceConnected = env->GetMethodID(clazz, "onRemoteDeviceConnected", "(Ljava/lang/String;)V"); + method_onRemoteDeviceDisconnectRequested = env->GetMethodID(clazz, "onRemoteDeviceDisconnectRequested", "(Ljava/lang/String;)V"); + method_onRemoteDeviceDisconnected = env->GetMethodID(clazz, "onRemoteDeviceDisconnected", "(Ljava/lang/String;)V"); + method_onBondingCreated = env->GetMethodID(clazz, "onBondingCreated", "(Ljava/lang/String;)V"); + method_onBondingRemoved = env->GetMethodID(clazz, "onBondingRemoved", "(Ljava/lang/String;)V"); + + method_onCreateBondingResult = env->GetMethodID(clazz, "onCreateBondingResult", "(Ljava/lang/String;Z)V"); + + method_onPasskeyAgentRequest = env->GetMethodID(clazz, "onPasskeyAgentRequest", "(Ljava/lang/String;I)V"); + method_onPasskeyAgentCancel = env->GetMethodID(clazz, "onPasskeyAgentCancel", "(Ljava/lang/String;)V"); + method_onGetRemoteServiceChannelResult = env->GetMethodID(clazz, "onGetRemoteServiceChannelResult", "(Ljava/lang/String;I)V"); + + field_mNativeData = env->GetFieldID(clazz, "mNativeData", "I"); +#endif +} + +static void initializeNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = (native_data_t *)calloc(1, sizeof(native_data_t)); + if (NULL == nat) { + LOGE("%s: out of memory!", __FUNCTION__); + return; + } + env->SetIntField(object, field_mNativeData, (jint)nat); + + { + DBusError err; + dbus_error_init(&err); + dbus_threads_init_default(); + nat->conn = dbus_bus_get(DBUS_BUS_SYSTEM, &err); + if (dbus_error_is_set(&err)) { + LOGE("%s: Could not get onto the system bus!", __FUNCTION__); + dbus_error_free(&err); + } + } +#endif +} + +static void cleanupNativeDataNative(JNIEnv* env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = + (native_data_t *)env->GetIntField(object, field_mNativeData); + if (nat) { + free(nat); + } +#endif +} + +#ifdef HAVE_BLUETOOTH +static jboolean add_adapter_event_match(JNIEnv *env, native_data_t *nat); +static void remove_adapter_event_match(JNIEnv *env, native_data_t *nat); +static DBusHandlerResult event_filter(DBusConnection *conn, DBusMessage *msg, + void *data); +static DBusHandlerResult passkey_agent_event_filter(DBusConnection *conn, + DBusMessage *msg, + void *data); + +static const DBusObjectPathVTable passkey_agent_vtable = { + NULL, passkey_agent_event_filter, NULL, NULL, NULL, NULL +}; +#endif + +static jboolean setUpEventLoopNative(JNIEnv *env, jobject object) { +#ifdef HAVE_BLUETOOTH + LOGV(__FUNCTION__); + dbus_threads_init_default(); + native_data_t *nat = get_native_data(env, object); + if (nat != NULL && nat->conn != NULL) { + if (!dbus_connection_add_filter(nat->conn, event_filter, nat, NULL)){ + return JNI_FALSE; + } + + if (add_adapter_event_match(env, nat) != JNI_TRUE) { + return JNI_FALSE; + } + + const char *path = "/android/bluetooth/PasskeyAgent"; + if (!dbus_connection_register_object_path(nat->conn, path, + &passkey_agent_vtable, NULL)) { + LOGE("%s: Can't register object path %s for agent!", + __FUNCTION__, path); + return JNI_FALSE; + } + + DBusError err; + dbus_error_init(&err); + + // RegisterDefaultPasskeyAgent() will fail until hcid is up, so keep + // trying for 10 seconds. + int attempt; + for (attempt = 1000; attempt > 0; attempt--) { + DBusMessage *reply = dbus_func_args_error(env, nat->conn, &err, + BLUEZ_DBUS_BASE_PATH, + "org.bluez.Security", "RegisterDefaultPasskeyAgent", + DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); + if (reply) { + // Success + dbus_message_unref(reply); + return JNI_TRUE; + } else if (dbus_error_has_name(&err, + "org.freedesktop.DBus.Error.ServiceUnknown")) { + // hcid is still down, retry + dbus_error_free(&err); + usleep(10000); // 10 ms + } else { + // Some other error we weren't expecting + LOG_AND_FREE_DBUS_ERROR(&err); + return JNI_FALSE; + } + } + LOGE("Time-out trying to call RegisterDefaultPasskeyAgent(), " + "is hcid running?"); + return JNI_FALSE; + } + +#endif + return JNI_FALSE; +} + +static void tearDownEventLoopNative(JNIEnv *env, jobject object) { + LOGV(__FUNCTION__); +#ifdef HAVE_BLUETOOTH + native_data_t *nat = get_native_data(env, object); + if (nat != NULL && nat->conn != NULL) { + + const char *path = "/android/bluetooth/PasskeyAgent"; + DBusMessage *reply = + dbus_func_args(env, nat->conn, BLUEZ_DBUS_BASE_PATH, + "org.bluez.Security", "UnregisterDefaultPasskeyAgent", + DBUS_TYPE_STRING, &path, + DBUS_TYPE_INVALID); + if (reply) dbus_message_unref(reply); + + DBusError err; + dbus_error_init(&err); + (void)dbus_connection_remove_filter(nat->conn, + event_filter, + nat); + + dbus_connection_unregister_object_path(nat->conn, path); + + remove_adapter_event_match(env, nat); + } +#endif +} + +#ifdef HAVE_BLUETOOTH +static const char *const adapter_event_match = + "type='signal',interface='"BLUEZ_DBUS_BASE_IFC".Adapter'"; + +static jboolean add_adapter_event_match(JNIEnv *env, native_data_t *nat) { + if (nat == NULL || nat->conn == NULL) { + LOGE("%s: Not connected to d-bus!", __FUNCTION__); + return JNI_FALSE; + } + DBusError err; + dbus_error_init(&err); + dbus_bus_add_match(nat->conn, adapter_event_match, &err); + if (dbus_error_is_set(&err)) { + LOG_AND_FREE_DBUS_ERROR(&err); + return JNI_FALSE; + } + return JNI_TRUE; +} + +static void remove_adapter_event_match(JNIEnv *env, native_data_t *nat) { + if (nat->conn == NULL) { + LOGE("%s: Not connected to d-bus!", __FUNCTION__); + return; + } + DBusError err; + dbus_error_init(&err); + dbus_bus_remove_match(nat->conn, adapter_event_match, &err); + if (dbus_error_is_set(&err)) { + LOG_AND_FREE_DBUS_ERROR(&err); + } +} + +// Called by dbus during WaitForAndDispatchEventNative() +static DBusHandlerResult event_filter(DBusConnection *conn, DBusMessage *msg, + void *data) { + native_data_t *nat; + JNIEnv *env; + DBusError err; + + dbus_error_init(&err); + + nat = (native_data_t *)data; + env = nat->env; + if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_SIGNAL) { + LOGV("%s: not interested (not a signal).", __FUNCTION__); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + LOGV("%s: Received signal %s:%s", __FUNCTION__, + dbus_message_get_interface(msg), dbus_message_get_member(msg)); + + if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteDeviceFound")) { + char *c_address; + int n_class; + short n_rssi; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_UINT32, &n_class, + DBUS_TYPE_INT16, &n_rssi, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s class = %#X rssi = %hd", c_address, n_class, + n_rssi); + env->CallVoidMethod(nat->me, + method_onRemoteDeviceFound, + env->NewStringUTF(c_address), + (jint)n_class, + (jshort)n_rssi); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "DiscoveryStarted")) { + LOGI("DiscoveryStarted signal received"); + env->CallVoidMethod(nat->me, method_onDiscoveryStarted); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "DiscoveryCompleted")) { + LOGI("DiscoveryCompleted signal received"); + env->CallVoidMethod(nat->me, method_onDiscoveryCompleted); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteDeviceDisappeared")) { + char *c_address; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s", c_address); + env->CallVoidMethod(nat->me, method_onRemoteDeviceDisappeared, + env->NewStringUTF(c_address)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteClassUpdated")) { + char *c_address; + int n_class; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_UINT32, &n_class, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s", c_address); + env->CallVoidMethod(nat->me, method_onRemoteClassUpdated, + env->NewStringUTF(c_address), (jint)n_class); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteNameUpdated")) { + char *c_address; + char *c_name; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_STRING, &c_name, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s, name = %s", c_address, c_name); + env->CallVoidMethod(nat->me, + method_onRemoteNameUpdated, + env->NewStringUTF(c_address), + env->NewStringUTF(c_name)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteNameFailed")) { + char *c_address; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s", c_address); + env->CallVoidMethod(nat->me, + method_onRemoteNameFailed, + env->NewStringUTF(c_address)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteAliasChanged")) { + char *c_address, *c_alias; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_STRING, &c_alias, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s, alias = %s", c_address, c_alias); + env->CallVoidMethod(nat->me, + method_onRemoteAliasChanged, + env->NewStringUTF(c_address), + env->NewStringUTF(c_alias)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteAliasCleared")) { + char *c_address; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s", c_address); + env->CallVoidMethod(nat->me, + method_onRemoteAliasCleared, + env->NewStringUTF(c_address)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteDeviceConnected")) { + char *c_address; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s", c_address); + env->CallVoidMethod(nat->me, + method_onRemoteDeviceConnected, + env->NewStringUTF(c_address)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteDeviceDisconnectRequested")) { + char *c_address; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s", c_address); + env->CallVoidMethod(nat->me, + method_onRemoteDeviceDisconnectRequested, + env->NewStringUTF(c_address)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "RemoteDeviceDisconnected")) { + char *c_address; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s", c_address); + env->CallVoidMethod(nat->me, + method_onRemoteDeviceDisconnected, + env->NewStringUTF(c_address)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "BondingCreated")) { + char *c_address; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s", c_address); + env->CallVoidMethod(nat->me, + method_onBondingCreated, + env->NewStringUTF(c_address)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else if (dbus_message_is_signal(msg, + "org.bluez.Adapter", + "BondingRemoved")) { + char *c_address; + if (dbus_message_get_args(msg, &err, + DBUS_TYPE_STRING, &c_address, + DBUS_TYPE_INVALID)) { + LOGV("... address = %s", c_address); + env->CallVoidMethod(nat->me, + method_onBondingRemoved, + env->NewStringUTF(c_address)); + } else LOG_AND_FREE_DBUS_ERROR_WITH_MSG(&err, msg); + return DBUS_HANDLER_RESULT_HANDLED; + } else { + LOGV("... ignored"); + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} + +// Called by dbus during WaitForAndDispatchEventNative() +static DBusHandlerResult passkey_agent_event_filter(DBusConnection *conn, + DBusMessage *msg, + void *data) { + native_data_t *nat = event_loop_nat; + JNIEnv *env; + + + env = nat->env; + if (dbus_message_get_type(msg) != DBUS_MESSAGE_TYPE_METHOD_CALL) { + LOGV("%s: not interested (not a method call).", __FUNCTION__); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + LOGV("%s: Received method %s:%s", __FUNCTION__, + dbus_message_get_interface(msg), dbus_message_get_member(msg)); + + if (dbus_message_is_method_call(msg, + "org.bluez.PasskeyAgent", "Request")) { + + const char *adapter; + const char *address; + if (!dbus_message_get_args(msg, NULL, + DBUS_TYPE_STRING, &adapter, + DBUS_TYPE_STRING, &address, + DBUS_TYPE_INVALID)) { + LOGE("%s: Invalid arguments for Request() method", __FUNCTION__); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + LOGV("... address = %s", address); + + dbus_message_ref(msg); // increment refcount because we pass to java + + env->CallVoidMethod(nat->me, method_onPasskeyAgentRequest, + env->NewStringUTF(address), (int)msg); + + return DBUS_HANDLER_RESULT_HANDLED; + + } else if (dbus_message_is_method_call(msg, + "org.bluez.PasskeyAgent", "Cancel")) { + + const char *adapter; + const char *address; + if (!dbus_message_get_args(msg, NULL, + DBUS_TYPE_STRING, &adapter, + DBUS_TYPE_STRING, &address, + DBUS_TYPE_INVALID)) { + LOGE("%s: Invalid arguments for Cancel() method", __FUNCTION__); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + + LOGV("... address = %s", address); + + env->CallVoidMethod(nat->me, method_onPasskeyAgentCancel, + env->NewStringUTF(address)); + + return DBUS_HANDLER_RESULT_HANDLED; + + } else if (dbus_message_is_method_call(msg, + "org.bluez.PasskeyAgent", "Release")) { + LOGE("We are no longer the passkey agent!"); + } else { + LOGV("... ignored"); + } + + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; +} +#endif + +static jboolean waitForAndDispatchEventNative(JNIEnv *env, jobject object, + jint timeout_ms) { +#ifdef HAVE_BLUETOOTH + //LOGV("%s: %8d (pid %d tid %d)",__FUNCTION__, time(NULL), getpid(), gettid()); // too chatty + native_data_t *nat = get_native_data(env, object); + if (nat != NULL && nat->conn != NULL) { + jboolean ret; + nat->me = object; + nat->env = env; + event_loop_nat = nat; + ret = dbus_connection_read_write_dispatch(nat->conn, + timeout_ms) == TRUE ? + JNI_TRUE : JNI_FALSE; + event_loop_nat = NULL; + nat->me = NULL; + nat->env = NULL; + return ret; + } +#endif + return JNI_FALSE; +} + +#ifdef HAVE_BLUETOOTH +void onCreateBondingResult(DBusMessage *msg, void *user) { + LOGV(__FUNCTION__); + + const char *address = (const char *)user; + DBusError err; + dbus_error_init(&err); + JNIEnv *env = event_loop_nat->env; + + LOGV("... address = %s", address); + + jboolean result = JNI_TRUE; + if (dbus_set_error_from_message(&err, msg)) { + /* if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.AuthenticationFailed")) */ + LOGE("%s: D-Bus error: %s (%s)\n", __FUNCTION__, err.name, err.message); + result = JNI_FALSE; + dbus_error_free(&err); + } + + env->CallVoidMethod(event_loop_nat->me, + method_onCreateBondingResult, + env->NewStringUTF(address), + result); + free(user); +} + +void onGetRemoteServiceChannelResult(DBusMessage *msg, void *user) { + LOGV(__FUNCTION__); + + const char *address = (const char *) user; + DBusError err; + dbus_error_init(&err); + JNIEnv *env = event_loop_nat->env; + jint channel = -2; + + LOGV("... address = %s", context->address); + + if (dbus_set_error_from_message(&err, msg) || + !dbus_message_get_args(msg, &err, + DBUS_TYPE_INT32, &channel, + DBUS_TYPE_INVALID)) { + /* if (!strcmp(err.name, BLUEZ_DBUS_BASE_IFC ".Error.AuthenticationFailed")) */ + LOGE("%s: D-Bus error: %s (%s)\n", __FUNCTION__, err.name, err.message); + dbus_error_free(&err); + } + +done: + env->CallVoidMethod(event_loop_nat->me, + method_onGetRemoteServiceChannelResult, + env->NewStringUTF(address), + channel); + free(user); +} +#endif + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + {"classInitNative", "()V", (void *)classInitNative}, + {"initializeNativeDataNative", "()V", (void *)initializeNativeDataNative}, + {"cleanupNativeDataNative", "()V", (void *)cleanupNativeDataNative}, + {"setUpEventLoopNative", "()Z", (void *)setUpEventLoopNative}, + {"tearDownEventLoopNative", "()V", (void *)tearDownEventLoopNative}, + {"waitForAndDispatchEventNative", "(I)Z", (void *)waitForAndDispatchEventNative} +}; + +int register_android_server_BluetoothEventLoop(JNIEnv *env) { + return AndroidRuntime::registerNativeMethods(env, + "android/server/BluetoothEventLoop", sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/android_text_AndroidCharacter.cpp b/core/jni/android_text_AndroidCharacter.cpp new file mode 100644 index 0000000..97daed3 --- /dev/null +++ b/core/jni/android_text_AndroidCharacter.cpp @@ -0,0 +1,128 @@ +/* //device/libs/android_runtime/android_text_AndroidCharacter.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "AndroidUnicode" + +#include <jni.h> +#include <android_runtime/AndroidRuntime.h> +#include "utils/misc.h" +#include "utils/AndroidUnicode.h" +#include "utils/Log.h" + +namespace android { + +static void jniThrowException(JNIEnv* env, const char* exc, const char* msg = NULL) +{ + jclass excClazz = env->FindClass(exc); + LOG_ASSERT(excClazz, "Unable to find class %s", exc); + + env->ThrowNew(excClazz, msg); +} + +static void getDirectionalities(JNIEnv* env, jobject obj, jcharArray srcArray, jbyteArray destArray, int count) +{ + jchar* src = env->GetCharArrayElements(srcArray, NULL); + jbyte* dest = env->GetByteArrayElements(destArray, NULL); + if (src == NULL || dest == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + goto DIRECTION_END; + } + + if (env->GetArrayLength(srcArray) < count || env->GetArrayLength(destArray) < count) { + jniThrowException(env, "java/lang/ArrayIndexException", NULL); + goto DIRECTION_END; + } + + for (int i = 0; i < count; i++) { + if (src[i] >= 0xD800 && src[i] <= 0xDBFF && + i + 1 < count && + src[i + 1] >= 0xDC00 && src[i + 1] <= 0xDFFF) { + int c = 0x00010000 + ((src[i] - 0xD800) << 10) + + (src[i + 1] & 0x3FF); + int dir = android::Unicode::getDirectionality(c); + + dest[i++] = dir; + dest[i] = dir; + } else { + int c = src[i]; + int dir = android::Unicode::getDirectionality(c); + + dest[i] = dir; + } + } + +DIRECTION_END: + env->ReleaseCharArrayElements(srcArray, src, JNI_ABORT); + env->ReleaseByteArrayElements(destArray, dest, JNI_ABORT); +} + +static jboolean mirror(JNIEnv* env, jobject obj, jcharArray charArray, int start, int count) +{ + jchar* data = env->GetCharArrayElements(charArray, NULL); + bool ret = false; + + if (data == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + goto MIRROR_END; + } + + if (start > start + count || env->GetArrayLength(charArray) < count) { + jniThrowException(env, "java/lang/ArrayIndexException", NULL); + goto MIRROR_END; + } + + for (int i = start; i < start + count; i++) { + // XXX this thinks it knows that surrogates are never mirrored + + int c1 = data[i]; + int c2 = android::Unicode::toMirror(c1); + + if (c1 != c2) { + data[i] = c2; + ret = true; + } + } + +MIRROR_END: + env->ReleaseCharArrayElements(charArray, data, JNI_ABORT); + return ret; +} + +static jchar getMirror(JNIEnv* env, jobject obj, jchar c) +{ + return android::Unicode::toMirror(c); +} + +static JNINativeMethod gMethods[] = { + { "getDirectionalities", "([C[BI)V", + (void*) getDirectionalities }, + { "mirror", "([CII)Z", + (void*) mirror }, + { "getMirror", "(C)C", + (void*) getMirror } +}; + +int register_android_text_AndroidCharacter(JNIEnv* env) +{ + jclass clazz = env->FindClass("android/text/AndroidCharacter"); + LOG_ASSERT(clazz, "Cannot find android/text/AndroidCharacter"); + + return AndroidRuntime::registerNativeMethods(env, "android/text/AndroidCharacter", + gMethods, NELEM(gMethods)); +} + +} diff --git a/core/jni/android_text_KeyCharacterMap.cpp b/core/jni/android_text_KeyCharacterMap.cpp new file mode 100644 index 0000000..2a23a71 --- /dev/null +++ b/core/jni/android_text_KeyCharacterMap.cpp @@ -0,0 +1,173 @@ +/* + * Copyright 2006, 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. +*/ + +#include <ui/KeyCharacterMap.h> + +#include <nativehelper/jni.h> +#include <android_runtime/AndroidRuntime.h> +#include <nativehelper/JNIHelp.h> + +namespace android { + +static jint +ctor(JNIEnv *env, jobject clazz, jint id) +{ + return reinterpret_cast<int>(KeyCharacterMap::load(id)); +} + +static void +dtor(JNIEnv *env, jobject clazz, jint ptr) +{ + delete reinterpret_cast<KeyCharacterMap*>(ptr); +} + +static jchar +get(JNIEnv *env, jobject clazz, jint ptr, jint keycode, jint meta) +{ + return reinterpret_cast<KeyCharacterMap*>(ptr)->get(keycode, meta); +} + +static jchar +getNumber(JNIEnv *env, jobject clazz, jint ptr, jint keycode) +{ + return reinterpret_cast<KeyCharacterMap*>(ptr)->getNumber(keycode); +} + +static jchar +getMatch(JNIEnv *env, jobject clazz, jint ptr, jint keycode, jcharArray chars, jint modifiers) +{ + jchar rv; + jchar* ch = env->GetCharArrayElements(chars, NULL); + jsize chsize = env->GetArrayLength(chars); + + rv = reinterpret_cast<KeyCharacterMap*>(ptr)->getMatch(keycode, ch, chsize, modifiers); + + env->ReleaseCharArrayElements(chars, ch, JNI_ABORT); + return rv; +} + +static jchar +getDisplayLabel(JNIEnv *env, jobject clazz, jint ptr, jint keycode) +{ + return reinterpret_cast<KeyCharacterMap*>(ptr)->getDisplayLabel(keycode); +} + +static jfieldID gKeyDataMetaField; +static jfieldID gKeyDataNumberField; +static jfieldID gKeyDataDisplayLabelField; + +static jboolean +getKeyData(JNIEnv *env, jobject clazz, jint ptr, jint keycode, jobject keydata) +{ + jboolean rv; + + unsigned short displayLabel = env->GetCharField(keydata, gKeyDataDisplayLabelField); + unsigned short number = env->GetCharField(keydata, gKeyDataNumberField); + + jcharArray chars = (jcharArray) env->GetObjectField(keydata, gKeyDataMetaField); + jchar* ch = env->GetCharArrayElements(chars, NULL); + + KeyCharacterMap* kmap = reinterpret_cast<KeyCharacterMap*>(ptr); + rv = kmap->getKeyData(keycode, &displayLabel, &number, ch); + + env->SetCharField(keydata, gKeyDataDisplayLabelField, displayLabel); + env->SetCharField(keydata, gKeyDataNumberField, number); + + env->ReleaseCharArrayElements(chars, ch, 0); + return rv; +} + +static jint +getKeyboardType(JNIEnv *env, jobject clazz, jint ptr) +{ + return reinterpret_cast<KeyCharacterMap*>(ptr)->getKeyboardType(); +} + +static jlongArray +getEvents(JNIEnv *env, jobject clazz, jint ptr, jcharArray jchars) +{ + KeyCharacterMap* kmap = reinterpret_cast<KeyCharacterMap*>(ptr); + + uint16_t* chars = env->GetCharArrayElements(jchars, NULL); + size_t len = env->GetArrayLength(jchars); + + Vector<int32_t> keys; + Vector<uint32_t> modifiers; + bool success = kmap->getEvents(chars, len, &keys, &modifiers); + + env->ReleaseCharArrayElements(jchars, chars, JNI_ABORT); + + if (success) { + size_t N = keys.size(); + + jlongArray rv = env->NewLongArray(N); + uint64_t* results = (uint64_t*)env->GetLongArrayElements(rv, NULL); + + for (size_t i=0; i<N; i++) { + uint64_t v = modifiers[i]; + v <<= 32; + v |= keys[i]; + results[i] = v; + } + + env->ReleaseLongArrayElements(rv, (jlong*)results, 0); + return rv; + } else { + return NULL; + } +} + +// ============================================================================ +/* + * JNI registration. + */ + +static JNINativeMethod g_methods[] = { + /* name, signature, funcPtr */ + { "ctor_native", "(I)I", (void*)ctor }, + { "dtor_native", "(I)V", (void*)dtor }, + { "get_native", "(III)C", (void*)get }, + { "getNumber_native", "(II)C", (void*)getNumber }, + { "getMatch_native", "(II[CI)C", (void*)getMatch }, + { "getDisplayLabel_native", "(II)C", (void*)getDisplayLabel }, + { "getKeyData_native", "(IILandroid/view/KeyCharacterMap$KeyData;)Z", + (void*)getKeyData }, + { "getKeyboardType_native", "(I)I", (void*)getKeyboardType }, + { "getEvents_native", "(I[C)[J", (void*)getEvents } +}; + +int register_android_text_KeyCharacterMap(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass("android/view/KeyCharacterMap$KeyData"); + if (clazz == NULL) { + LOGE("Can't find android/view/KeyCharacterMap$KeyData"); + return -1; + } + + gKeyDataMetaField = env->GetFieldID(clazz, "meta", "[C"); + gKeyDataNumberField = env->GetFieldID(clazz, "number", "C"); + gKeyDataDisplayLabelField = env->GetFieldID(clazz, "displayLabel", "C"); + + return AndroidRuntime::registerNativeMethods(env, + "android/view/KeyCharacterMap", g_methods, NELEM(g_methods)); +} + +}; // namespace android + + + diff --git a/core/jni/android_util_AssetManager.cpp b/core/jni/android_util_AssetManager.cpp new file mode 100644 index 0000000..8a62159 --- /dev/null +++ b/core/jni/android_util_AssetManager.cpp @@ -0,0 +1,1673 @@ +/* //device/libs/android_runtime/android_util_AssetManager.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "asset" + +#include <android_runtime/android_util_AssetManager.h> + +#include "jni.h" +#include "JNIHelp.h" +#include "android_util_Binder.h" +#include <utils/misc.h> +#include <android_runtime/AndroidRuntime.h> +#include <utils/Log.h> + +#include <utils/Asset.h> +#include <utils/AssetManager.h> +#include <utils/ResourceTypes.h> + +#include <stdio.h> + +namespace android { + +// ---------------------------------------------------------------------------- + +static struct typedvalue_offsets_t +{ + jfieldID mType; + jfieldID mData; + jfieldID mString; + jfieldID mAssetCookie; + jfieldID mResourceId; + jfieldID mChangingConfigurations; +} gTypedValueOffsets; + +static struct assetfiledescriptor_offsets_t +{ + jfieldID mFd; + jfieldID mStartOffset; + jfieldID mLength; +} gAssetFileDescriptorOffsets; + +static struct assetmanager_offsets_t +{ + jfieldID mObject; +} gAssetManagerOffsets; + +jclass g_stringClass = NULL; + +// ---------------------------------------------------------------------------- + +static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL) +{ + jclass npeClazz; + + npeClazz = env->FindClass(exc); + LOG_FATAL_IF(npeClazz == NULL, "Unable to find class %s", exc); + + env->ThrowNew(npeClazz, msg); +} + +enum { + STYLE_NUM_ENTRIES = 5, + STYLE_TYPE = 0, + STYLE_DATA = 1, + STYLE_ASSET_COOKIE = 2, + STYLE_RESOURCE_ID = 3, + STYLE_CHANGING_CONFIGURATIONS = 4 +}; + +static jint copyValue(JNIEnv* env, jobject outValue, const ResTable* table, + const Res_value& value, uint32_t ref, ssize_t block, + uint32_t typeSpecFlags) +{ + env->SetIntField(outValue, gTypedValueOffsets.mType, value.dataType); + env->SetIntField(outValue, gTypedValueOffsets.mAssetCookie, + (jint)table->getTableCookie(block)); + env->SetIntField(outValue, gTypedValueOffsets.mData, value.data); + env->SetObjectField(outValue, gTypedValueOffsets.mString, NULL); + env->SetIntField(outValue, gTypedValueOffsets.mResourceId, ref); + env->SetIntField(outValue, gTypedValueOffsets.mChangingConfigurations, + typeSpecFlags); + return block; +} + +// ---------------------------------------------------------------------------- + +// this guy is exported to other jni routines +AssetManager* assetManagerForJavaObject(JNIEnv* env, jobject obj) +{ + AssetManager* am = (AssetManager*)env->GetIntField(obj, gAssetManagerOffsets.mObject); + if (am != NULL) { + return am; + } + jniThrowException(env, "java/lang/IllegalStateException", "AssetManager has been finalized!"); + return NULL; +} + +static jint android_content_AssetManager_openAsset(JNIEnv* env, jobject clazz, + jstring fileName, jint mode) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return 0; + } + + LOGV("openAsset in %p (Java object %p)\n", am, clazz); + + if (fileName == NULL || am == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return -1; + } + + if (mode != Asset::ACCESS_UNKNOWN && mode != Asset::ACCESS_RANDOM + && mode != Asset::ACCESS_STREAMING && mode != Asset::ACCESS_BUFFER) { + doThrow(env, "java/lang/IllegalArgumentException"); + return -1; + } + + const char* fileName8 = env->GetStringUTFChars(fileName, NULL); + Asset* a = am->open(fileName8, (Asset::AccessMode)mode); + + if (a == NULL) { + doThrow(env, "java/io/FileNotFoundException", fileName8); + env->ReleaseStringUTFChars(fileName, fileName8); + return -1; + } + env->ReleaseStringUTFChars(fileName, fileName8); + + //printf("Created Asset Stream: %p\n", a); + + return (jint)a; +} + +static jobject returnParcelFileDescriptor(JNIEnv* env, Asset* a, jlongArray outOffsets) +{ + off_t startOffset, length; + int fd = a->openFileDescriptor(&startOffset, &length); + delete a; + + if (fd < 0) { + doThrow(env, "java/io/FileNotFoundException", + "This file can not be opened as a file descriptor; it is probably compressed"); + return NULL; + } + + jlong* offsets = (jlong*)env->GetPrimitiveArrayCritical(outOffsets, 0); + if (offsets == NULL) { + close(fd); + return NULL; + } + + offsets[0] = startOffset; + offsets[1] = length; + + env->ReleasePrimitiveArrayCritical(outOffsets, offsets, 0); + + jobject fileDesc = newFileDescriptor(env, fd); + if (fileDesc == NULL) { + close(fd); + return NULL; + } + + return newParcelFileDescriptor(env, fileDesc); +} + +static jobject android_content_AssetManager_openAssetFd(JNIEnv* env, jobject clazz, + jstring fileName, jlongArray outOffsets) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + + LOGV("openAssetFd in %p (Java object %p)\n", am, clazz); + + if (fileName == NULL || am == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return NULL; + } + + const char* fileName8 = env->GetStringUTFChars(fileName, NULL); + Asset* a = am->open(fileName8, Asset::ACCESS_RANDOM); + + if (a == NULL) { + doThrow(env, "java/io/FileNotFoundException", fileName8); + env->ReleaseStringUTFChars(fileName, fileName8); + return NULL; + } + env->ReleaseStringUTFChars(fileName, fileName8); + + //printf("Created Asset Stream: %p\n", a); + + return returnParcelFileDescriptor(env, a, outOffsets); +} + +static jint android_content_AssetManager_openNonAssetNative(JNIEnv* env, jobject clazz, + jint cookie, + jstring fileName, + jint mode) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return 0; + } + + LOGV("openNonAssetNative in %p (Java object %p)\n", am, clazz); + + if (fileName == NULL || am == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return -1; + } + + if (mode != Asset::ACCESS_UNKNOWN && mode != Asset::ACCESS_RANDOM + && mode != Asset::ACCESS_STREAMING && mode != Asset::ACCESS_BUFFER) { + doThrow(env, "java/lang/IllegalArgumentException"); + return -1; + } + + const char* fileName8 = env->GetStringUTFChars(fileName, NULL); + Asset* a = cookie + ? am->openNonAsset((void*)cookie, fileName8, (Asset::AccessMode)mode) + : am->openNonAsset(fileName8, (Asset::AccessMode)mode); + + if (a == NULL) { + doThrow(env, "java/io/FileNotFoundException", fileName8); + env->ReleaseStringUTFChars(fileName, fileName8); + return -1; + } + env->ReleaseStringUTFChars(fileName, fileName8); + + //printf("Created Asset Stream: %p\n", a); + + return (jint)a; +} + +static jobject android_content_AssetManager_openNonAssetFdNative(JNIEnv* env, jobject clazz, + jint cookie, + jstring fileName, + jlongArray outOffsets) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + + LOGV("openNonAssetFd in %p (Java object %p)\n", am, clazz); + + if (fileName == NULL || am == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return NULL; + } + + const char* fileName8 = env->GetStringUTFChars(fileName, NULL); + Asset* a = cookie + ? am->openNonAsset((void*)cookie, fileName8, Asset::ACCESS_RANDOM) + : am->openNonAsset(fileName8, Asset::ACCESS_RANDOM); + + if (a == NULL) { + doThrow(env, "java/io/FileNotFoundException", fileName8); + env->ReleaseStringUTFChars(fileName, fileName8); + return NULL; + } + env->ReleaseStringUTFChars(fileName, fileName8); + + //printf("Created Asset Stream: %p\n", a); + + return returnParcelFileDescriptor(env, a, outOffsets); +} + +static jobjectArray android_content_AssetManager_list(JNIEnv* env, jobject clazz, + jstring fileName) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + + if (fileName == NULL || am == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return NULL; + } + + const char* fileName8 = env->GetStringUTFChars(fileName, NULL); + + AssetDir* dir = am->openDir(fileName8); + + env->ReleaseStringUTFChars(fileName, fileName8); + + if (dir == NULL) { + doThrow(env, "java/io/FileNotFoundException", fileName8); + return NULL; + } + + jclass cls = env->FindClass("java/lang/String"); + LOG_FATAL_IF(cls == NULL, "No string class?!?"); + if (cls == NULL) { + delete dir; + return NULL; + } + + size_t N = dir->getFileCount(); + + jobjectArray array = env->NewObjectArray(dir->getFileCount(), + cls, NULL); + if (array == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + delete dir; + return NULL; + } + + for (size_t i=0; i<N; i++) { + const String8& name = dir->getFileName(i); + jstring str = env->NewStringUTF(name.string()); + if (str == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + delete dir; + return NULL; + } + env->SetObjectArrayElement(array, i, str); + } + + delete dir; + + return array; +} + +static void android_content_AssetManager_destroyAsset(JNIEnv* env, jobject clazz, + jint asset) +{ + Asset* a = (Asset*)asset; + + //printf("Destroying Asset Stream: %p\n", a); + + if (a == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return; + } + + delete a; +} + +static jint android_content_AssetManager_readAssetChar(JNIEnv* env, jobject clazz, + jint asset) +{ + Asset* a = (Asset*)asset; + + if (a == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return -1; + } + + uint8_t b; + ssize_t res = a->read(&b, 1); + return res == 1 ? b : -1; +} + +static jint android_content_AssetManager_readAsset(JNIEnv* env, jobject clazz, + jint asset, jbyteArray bArray, + jint off, jint len) +{ + Asset* a = (Asset*)asset; + + if (a == NULL || bArray == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return -1; + } + + if (len == 0) { + return 0; + } + + jsize bLen = env->GetArrayLength(bArray); + if (off < 0 || off >= bLen || len < 0 || len > bLen || (off+len) > bLen) { + doThrow(env, "java/lang/IndexOutOfBoundsException"); + return -1; + } + + jbyte* b = env->GetByteArrayElements(bArray, NULL); + ssize_t res = a->read(b+off, len); + env->ReleaseByteArrayElements(bArray, b, 0); + + if (res > 0) return res; + + if (res < 0) { + doThrow(env, "java/io/IOException"); + } + return -1; +} + +static jlong android_content_AssetManager_seekAsset(JNIEnv* env, jobject clazz, + jint asset, + jlong offset, jint whence) +{ + Asset* a = (Asset*)asset; + + if (a == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return -1; + } + + return a->seek( + offset, (whence > 0) ? SEEK_END : (whence < 0 ? SEEK_SET : SEEK_CUR)); +} + +static jlong android_content_AssetManager_getAssetLength(JNIEnv* env, jobject clazz, + jint asset) +{ + Asset* a = (Asset*)asset; + + if (a == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return -1; + } + + return a->getLength(); +} + +static jlong android_content_AssetManager_getAssetRemainingLength(JNIEnv* env, jobject clazz, + jint asset) +{ + Asset* a = (Asset*)asset; + + if (a == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return -1; + } + + return a->getRemainingLength(); +} + +static jint android_content_AssetManager_addAssetPath(JNIEnv* env, jobject clazz, + jstring path) +{ + if (path == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return JNI_FALSE; + } + + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return JNI_FALSE; + } + + const char* path8 = env->GetStringUTFChars(path, NULL); + + void* cookie; + bool res = am->addAssetPath(String8(path8), &cookie); + + env->ReleaseStringUTFChars(path, path8); + + return (res) ? (jint)cookie : 0; +} + +static jboolean android_content_AssetManager_isUpToDate(JNIEnv* env, jobject clazz) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return JNI_TRUE; + } + return am->isUpToDate() ? JNI_TRUE : JNI_FALSE; +} + +static void android_content_AssetManager_setLocale(JNIEnv* env, jobject clazz, + jstring locale) +{ + if (locale == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return; + } + + const char* locale8 = env->GetStringUTFChars(locale, NULL); + + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return; + } + + am->setLocale(locale8); + + env->ReleaseStringUTFChars(locale, locale8); +} + +static jobjectArray android_content_AssetManager_getLocales(JNIEnv* env, jobject clazz) +{ + Vector<String8> locales; + + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + + am->getLocales(&locales); + + const int N = locales.size(); + + jobjectArray result = env->NewObjectArray(N, g_stringClass, NULL); + if (result == NULL) { + return NULL; + } + + for (int i=0; i<N; i++) { + LOGD("locale %2d: '%s'", i, locales[i].string()); + env->SetObjectArrayElement(result, i, env->NewStringUTF(locales[i].string())); + } + + return result; +} + +static void android_content_AssetManager_setConfiguration(JNIEnv* env, jobject clazz, + jint mcc, jint mnc, + jstring locale, jint orientation, + jint touchscreen, jint density, + jint keyboard, jint keyboardHidden, + jint navigation, + jint screenWidth, jint screenHeight, + jint sdkVersion) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return; + } + + ResTable_config config; + memset(&config, 0, sizeof(config)); + + const char* locale8 = locale != NULL ? env->GetStringUTFChars(locale, NULL) : NULL; + + config.mcc = (uint16_t)mcc; + config.mnc = (uint16_t)mnc; + config.orientation = (uint8_t)orientation; + config.touchscreen = (uint8_t)touchscreen; + config.density = (uint16_t)density; + config.keyboard = (uint8_t)keyboard; + config.inputFlags = (uint8_t)keyboardHidden<<ResTable_config::SHIFT_KEYSHIDDEN; + config.navigation = (uint8_t)navigation; + config.screenWidth = (uint16_t)screenWidth; + config.screenHeight = (uint16_t)screenHeight; + config.sdkVersion = (uint16_t)sdkVersion; + config.minorVersion = 0; + am->setConfiguration(config, locale8); + + if (locale != NULL) env->ReleaseStringUTFChars(locale, locale8); +} + +static jint android_content_AssetManager_getResourceIdentifier(JNIEnv* env, jobject clazz, + jstring name, + jstring defType, + jstring defPackage) +{ + if (name == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return 0; + } + + const char16_t* name16 = env->GetStringChars(name, NULL); + jsize nameLen = env->GetStringLength(name); + const char16_t* defType16 = defType + ? env->GetStringChars(defType, NULL) : NULL; + jsize defTypeLen = defType + ? env->GetStringLength(defType) : 0; + const char16_t* defPackage16 = defPackage + ? env->GetStringChars(defPackage, NULL) : NULL; + jsize defPackageLen = defPackage + ? env->GetStringLength(defPackage) : 0; + + jint ident = am->getResources().identifierForName( + name16, nameLen, defType16, defTypeLen, defPackage16, defPackageLen); + + if (defPackage16) { + env->ReleaseStringChars(defPackage, defPackage16); + } + if (defType16) { + env->ReleaseStringChars(defType, defType16); + } + env->ReleaseStringChars(name, name16); + + return ident; +} + +static jstring android_content_AssetManager_getResourceName(JNIEnv* env, jobject clazz, + jint resid) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + + ResTable::resource_name name; + if (!am->getResources().getResourceName(resid, &name)) { + return NULL; + } + + String16 str; + if (name.package != NULL) { + str.setTo(name.package, name.packageLen); + } + if (name.type != NULL) { + if (str.size() > 0) { + char16_t div = ':'; + str.append(&div, 1); + } + str.append(name.type, name.typeLen); + } + if (name.name != NULL) { + if (str.size() > 0) { + char16_t div = '/'; + str.append(&div, 1); + } + str.append(name.name, name.nameLen); + } + + return env->NewString((const jchar*)str.string(), str.size()); +} + +static jstring android_content_AssetManager_getResourcePackageName(JNIEnv* env, jobject clazz, + jint resid) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + + ResTable::resource_name name; + if (!am->getResources().getResourceName(resid, &name)) { + return NULL; + } + + if (name.package != NULL) { + return env->NewString((const jchar*)name.package, name.packageLen); + } + + return NULL; +} + +static jstring android_content_AssetManager_getResourceTypeName(JNIEnv* env, jobject clazz, + jint resid) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + + ResTable::resource_name name; + if (!am->getResources().getResourceName(resid, &name)) { + return NULL; + } + + if (name.type != NULL) { + return env->NewString((const jchar*)name.type, name.typeLen); + } + + return NULL; +} + +static jstring android_content_AssetManager_getResourceEntryName(JNIEnv* env, jobject clazz, + jint resid) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + + ResTable::resource_name name; + if (!am->getResources().getResourceName(resid, &name)) { + return NULL; + } + + if (name.name != NULL) { + return env->NewString((const jchar*)name.name, name.nameLen); + } + + return NULL; +} + +static jint android_content_AssetManager_loadResourceValue(JNIEnv* env, jobject clazz, + jint ident, + jobject outValue, + jboolean resolve) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return 0; + } + const ResTable& res(am->getResources()); + + Res_value value; + uint32_t typeSpecFlags; + ssize_t block = res.getResource(ident, &value, false, &typeSpecFlags); + uint32_t ref = ident; + if (resolve) { + block = res.resolveReference(&value, block, &ref); + } + return block >= 0 ? copyValue(env, outValue, &res, value, ref, block, typeSpecFlags) : block; +} + +static jint android_content_AssetManager_loadResourceBagValue(JNIEnv* env, jobject clazz, + jint ident, jint bagEntryId, + jobject outValue, jboolean resolve) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return 0; + } + const ResTable& res(am->getResources()); + + // Now lock down the resource object and start pulling stuff from it. + res.lock(); + + ssize_t block = -1; + Res_value value; + + const ResTable::bag_entry* entry = NULL; + uint32_t typeSpecFlags; + ssize_t entryCount = res.getBagLocked(ident, &entry, &typeSpecFlags); + + for (ssize_t i=0; i<entryCount; i++) { + if (((uint32_t)bagEntryId) == entry->map.name.ident) { + block = entry->stringBlock; + value = entry->map.value; + } + entry++; + } + + res.unlock(); + + if (block < 0) { + return block; + } + + uint32_t ref = ident; + if (resolve) { + block = res.resolveReference(&value, block, &ref, &typeSpecFlags); + } + return block >= 0 ? copyValue(env, outValue, &res, value, ref, block, typeSpecFlags) : block; +} + +static jint android_content_AssetManager_getStringBlockCount(JNIEnv* env, jobject clazz) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return 0; + } + return am->getResources().getTableCount(); +} + +static jint android_content_AssetManager_getNativeStringBlock(JNIEnv* env, jobject clazz, + jint block) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return 0; + } + return (jint)am->getResources().getTableStringBlock(block); +} + +static jstring android_content_AssetManager_getCookieName(JNIEnv* env, jobject clazz, + jint cookie) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + String8 name(am->getAssetPath((void*)cookie)); + if (name.length() == 0) { + doThrow(env, "java/lang/IndexOutOfBoundsException"); + return NULL; + } + jstring str = env->NewStringUTF(name.string()); + if (str == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + return NULL; + } + return str; +} + +static jint android_content_AssetManager_newTheme(JNIEnv* env, jobject clazz) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return 0; + } + return (jint)(new ResTable::Theme(am->getResources())); +} + +static void android_content_AssetManager_deleteTheme(JNIEnv* env, jobject clazz, + jint themeInt) +{ + ResTable::Theme* theme = (ResTable::Theme*)themeInt; + delete theme; +} + +static void android_content_AssetManager_applyThemeStyle(JNIEnv* env, jobject clazz, + jint themeInt, + jint styleRes, + jboolean force) +{ + ResTable::Theme* theme = (ResTable::Theme*)themeInt; + theme->applyStyle(styleRes, force ? true : false); +} + +static void android_content_AssetManager_copyTheme(JNIEnv* env, jobject clazz, + jint destInt, jint srcInt) +{ + ResTable::Theme* dest = (ResTable::Theme*)destInt; + ResTable::Theme* src = (ResTable::Theme*)srcInt; + dest->setTo(*src); +} + +static jint android_content_AssetManager_loadThemeAttributeValue( + JNIEnv* env, jobject clazz, jint themeInt, jint ident, jobject outValue, jboolean resolve) +{ + ResTable::Theme* theme = (ResTable::Theme*)themeInt; + const ResTable& res(theme->getResTable()); + + Res_value value; + // XXX value could be different in different configs! + uint32_t typeSpecFlags = 0; + ssize_t block = theme->getAttribute(ident, &value, &typeSpecFlags); + uint32_t ref = 0; + if (resolve) { + block = res.resolveReference(&value, block, &ref, &typeSpecFlags); + } + return block >= 0 ? copyValue(env, outValue, &res, value, ref, block, typeSpecFlags) : block; +} + +static void android_content_AssetManager_dumpTheme(JNIEnv* env, jobject clazz, + jint themeInt, jint pri, + jstring tag, jstring prefix) +{ + ResTable::Theme* theme = (ResTable::Theme*)themeInt; + const ResTable& res(theme->getResTable()); + + if (tag == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return; + } + + const char* tag8 = env->GetStringUTFChars(tag, NULL); + const char* prefix8 = NULL; + if (prefix != NULL) { + prefix8 = env->GetStringUTFChars(prefix, NULL); + } + + // XXX Need to use params. + theme->dumpToLog(); + + if (prefix8 != NULL) { + env->ReleaseStringUTFChars(prefix, prefix8); + } + env->ReleaseStringUTFChars(tag, tag8); +} + +static jboolean android_content_AssetManager_applyStyle(JNIEnv* env, jobject clazz, + jint themeToken, + jint defStyleAttr, + jint defStyleRes, + jint xmlParserToken, + jintArray attrs, + jintArray outValues, + jintArray outIndices) +{ + if (themeToken == 0 || attrs == NULL || outValues == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return JNI_FALSE; + } + + ResTable::Theme* theme = (ResTable::Theme*)themeToken; + const ResTable& res = theme->getResTable(); + ResXMLParser* xmlParser = (ResXMLParser*)xmlParserToken; + Res_value value; + + const jsize NI = env->GetArrayLength(attrs); + const jsize NV = env->GetArrayLength(outValues); + if (NV < (NI*STYLE_NUM_ENTRIES)) { + doThrow(env, "java/lang/IndexOutOfBoundsException"); + return JNI_FALSE; + } + + jint* src = (jint*)env->GetPrimitiveArrayCritical(attrs, 0); + if (src == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + return JNI_FALSE; + } + + jint* dest = (jint*)env->GetPrimitiveArrayCritical(outValues, 0); + if (dest == NULL) { + env->ReleasePrimitiveArrayCritical(attrs, src, 0); + doThrow(env, "java/lang/OutOfMemoryError"); + return JNI_FALSE; + } + + jint* indices = NULL; + int indicesIdx = 0; + if (outIndices != NULL) { + if (env->GetArrayLength(outIndices) > NI) { + indices = (jint*)env->GetPrimitiveArrayCritical(outIndices, 0); + } + } + + // Load default style from attribute, if specified... + uint32_t defStyleBagTypeSetFlags = 0; + if (defStyleAttr != 0) { + Res_value value; + if (theme->getAttribute(defStyleAttr, &value, &defStyleBagTypeSetFlags) >= 0) { + if (value.dataType == Res_value::TYPE_REFERENCE) { + defStyleRes = value.data; + } + } + } + + // Retrieve the style class associated with the current XML tag. + int style = 0; + uint32_t styleBagTypeSetFlags = 0; + if (xmlParser != NULL) { + ssize_t idx = xmlParser->indexOfStyle(); + if (idx >= 0 && xmlParser->getAttributeValue(idx, &value) >= 0) { + if (value.dataType == value.TYPE_ATTRIBUTE) { + if (theme->getAttribute(value.data, &value, &styleBagTypeSetFlags) < 0) { + value.dataType = Res_value::TYPE_NULL; + } + } + if (value.dataType == value.TYPE_REFERENCE) { + style = value.data; + } + } + } + + // Now lock down the resource object and start pulling stuff from it. + res.lock(); + + // Retrieve the default style bag, if requested. + const ResTable::bag_entry* defStyleEnt = NULL; + uint32_t defStyleTypeSetFlags = 0; + ssize_t bagOff = defStyleRes != 0 + ? res.getBagLocked(defStyleRes, &defStyleEnt, &defStyleTypeSetFlags) : -1; + defStyleTypeSetFlags |= defStyleBagTypeSetFlags; + const ResTable::bag_entry* endDefStyleEnt = defStyleEnt + + (bagOff >= 0 ? bagOff : 0); + + // Retrieve the style class bag, if requested. + const ResTable::bag_entry* styleEnt = NULL; + uint32_t styleTypeSetFlags = 0; + bagOff = style != 0 ? res.getBagLocked(style, &styleEnt, &styleTypeSetFlags) : -1; + styleTypeSetFlags |= styleBagTypeSetFlags; + const ResTable::bag_entry* endStyleEnt = styleEnt + + (bagOff >= 0 ? bagOff : 0); + + // Retrieve the XML attributes, if requested. + const jsize NX = xmlParser ? xmlParser->getAttributeCount() : 0; + jsize ix=0; + uint32_t curXmlAttr = xmlParser ? xmlParser->getAttributeNameResID(ix) : 0; + + static const ssize_t kXmlBlock = 0x10000000; + + // Now iterate through all of the attributes that the client has requested, + // filling in each with whatever data we can find. + ssize_t block = 0; + uint32_t typeSetFlags; + for (jsize ii=0; ii<NI; ii++) { + const uint32_t curIdent = (uint32_t)src[ii]; + + // Try to find a value for this attribute... we prioritize values + // coming from, first XML attributes, then XML style, then default + // style, and finally the theme. + value.dataType = Res_value::TYPE_NULL; + value.data = 0; + typeSetFlags = 0; + + // Skip through XML attributes until the end or the next possible match. + while (ix < NX && curIdent > curXmlAttr) { + ix++; + curXmlAttr = xmlParser->getAttributeNameResID(ix); + } + // Retrieve the current XML attribute if it matches, and step to next. + if (ix < NX && curIdent == curXmlAttr) { + block = kXmlBlock; + xmlParser->getAttributeValue(ix, &value); + ix++; + curXmlAttr = xmlParser->getAttributeNameResID(ix); + } + + // Skip through the style values until the end or the next possible match. + while (styleEnt < endStyleEnt && curIdent > styleEnt->map.name.ident) { + styleEnt++; + } + // Retrieve the current style attribute if it matches, and step to next. + if (styleEnt < endStyleEnt && curIdent == styleEnt->map.name.ident) { + if (value.dataType == Res_value::TYPE_NULL) { + block = styleEnt->stringBlock; + typeSetFlags = styleTypeSetFlags; + value = styleEnt->map.value; + } + styleEnt++; + } + + // Skip through the default style values until the end or the next possible match. + while (defStyleEnt < endDefStyleEnt && curIdent > defStyleEnt->map.name.ident) { + defStyleEnt++; + } + // Retrieve the current default style attribute if it matches, and step to next. + if (defStyleEnt < endDefStyleEnt && curIdent == defStyleEnt->map.name.ident) { + if (value.dataType == Res_value::TYPE_NULL) { + block = defStyleEnt->stringBlock; + typeSetFlags = defStyleTypeSetFlags; + value = defStyleEnt->map.value; + } + defStyleEnt++; + } + + //printf("Attribute 0x%08x: type=0x%x, data=0x%08x\n", curIdent, value.dataType, value.data); + uint32_t resid = 0; + if (value.dataType != Res_value::TYPE_NULL) { + // Take care of resolving the found resource to its final value. + //printf("Resolving attribute reference\n"); + ssize_t newBlock = theme->resolveAttributeReference(&value, block, &resid, &typeSetFlags); + if (newBlock >= 0) block = newBlock; + } else { + // If we still don't have a value for this attribute, try to find + // it in the theme! + //printf("Looking up in theme\n"); + ssize_t newBlock = theme->getAttribute(curIdent, &value, &typeSetFlags); + if (newBlock >= 0) { + //printf("Resolving resource reference\n"); + newBlock = res.resolveReference(&value, block, &resid, &typeSetFlags); + if (newBlock >= 0) block = newBlock; + } + } + + // Deal with the special @null value -- it turns back to TYPE_NULL. + if (value.dataType == Res_value::TYPE_REFERENCE && value.data == 0) { + value.dataType = Res_value::TYPE_NULL; + } + + //printf("Attribute 0x%08x: final type=0x%x, data=0x%08x\n", curIdent, value.dataType, value.data); + + // Write the final value back to Java. + dest[STYLE_TYPE] = value.dataType; + dest[STYLE_DATA] = value.data; + dest[STYLE_ASSET_COOKIE] = + block != kXmlBlock ? (jint)res.getTableCookie(block) : (jint)-1; + dest[STYLE_RESOURCE_ID] = resid; + dest[STYLE_CHANGING_CONFIGURATIONS] = typeSetFlags; + + if (indices != NULL && value.dataType != Res_value::TYPE_NULL) { + indicesIdx++; + indices[indicesIdx] = ii; + } + + dest += STYLE_NUM_ENTRIES; + } + + res.unlock(); + + if (indices != NULL) { + indices[0] = indicesIdx; + env->ReleasePrimitiveArrayCritical(outIndices, indices, 0); + } + env->ReleasePrimitiveArrayCritical(outValues, dest, 0); + env->ReleasePrimitiveArrayCritical(attrs, src, 0); + + return JNI_TRUE; +} + +static jboolean android_content_AssetManager_retrieveAttributes(JNIEnv* env, jobject clazz, + jint xmlParserToken, + jintArray attrs, + jintArray outValues, + jintArray outIndices) +{ + if (xmlParserToken == 0 || attrs == NULL || outValues == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return JNI_FALSE; + } + + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return JNI_FALSE; + } + const ResTable& res(am->getResources()); + ResXMLParser* xmlParser = (ResXMLParser*)xmlParserToken; + Res_value value; + + const jsize NI = env->GetArrayLength(attrs); + const jsize NV = env->GetArrayLength(outValues); + if (NV < (NI*STYLE_NUM_ENTRIES)) { + doThrow(env, "java/lang/IndexOutOfBoundsException"); + return JNI_FALSE; + } + + jint* src = (jint*)env->GetPrimitiveArrayCritical(attrs, 0); + if (src == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + return JNI_FALSE; + } + + jint* dest = (jint*)env->GetPrimitiveArrayCritical(outValues, 0); + if (dest == NULL) { + env->ReleasePrimitiveArrayCritical(attrs, src, 0); + doThrow(env, "java/lang/OutOfMemoryError"); + return JNI_FALSE; + } + + jint* indices = NULL; + int indicesIdx = 0; + if (outIndices != NULL) { + if (env->GetArrayLength(outIndices) > NI) { + indices = (jint*)env->GetPrimitiveArrayCritical(outIndices, 0); + } + } + + // Now lock down the resource object and start pulling stuff from it. + res.lock(); + + // Retrieve the XML attributes, if requested. + const jsize NX = xmlParser->getAttributeCount(); + jsize ix=0; + uint32_t curXmlAttr = xmlParser->getAttributeNameResID(ix); + + static const ssize_t kXmlBlock = 0x10000000; + + // Now iterate through all of the attributes that the client has requested, + // filling in each with whatever data we can find. + ssize_t block = 0; + uint32_t typeSetFlags; + for (jsize ii=0; ii<NI; ii++) { + const uint32_t curIdent = (uint32_t)src[ii]; + + // Try to find a value for this attribute... + value.dataType = Res_value::TYPE_NULL; + value.data = 0; + typeSetFlags = 0; + + // Skip through XML attributes until the end or the next possible match. + while (ix < NX && curIdent > curXmlAttr) { + ix++; + curXmlAttr = xmlParser->getAttributeNameResID(ix); + } + // Retrieve the current XML attribute if it matches, and step to next. + if (ix < NX && curIdent == curXmlAttr) { + block = kXmlBlock; + xmlParser->getAttributeValue(ix, &value); + ix++; + curXmlAttr = xmlParser->getAttributeNameResID(ix); + } + + //printf("Attribute 0x%08x: type=0x%x, data=0x%08x\n", curIdent, value.dataType, value.data); + uint32_t resid = 0; + if (value.dataType != Res_value::TYPE_NULL) { + // Take care of resolving the found resource to its final value. + //printf("Resolving attribute reference\n"); + ssize_t newBlock = res.resolveReference(&value, block, &resid, &typeSetFlags); + if (newBlock >= 0) block = newBlock; + } + + // Deal with the special @null value -- it turns back to TYPE_NULL. + if (value.dataType == Res_value::TYPE_REFERENCE && value.data == 0) { + value.dataType = Res_value::TYPE_NULL; + } + + //printf("Attribute 0x%08x: final type=0x%x, data=0x%08x\n", curIdent, value.dataType, value.data); + + // Write the final value back to Java. + dest[STYLE_TYPE] = value.dataType; + dest[STYLE_DATA] = value.data; + dest[STYLE_ASSET_COOKIE] = + block != kXmlBlock ? (jint)res.getTableCookie(block) : (jint)-1; + dest[STYLE_RESOURCE_ID] = resid; + dest[STYLE_CHANGING_CONFIGURATIONS] = typeSetFlags; + + if (indices != NULL && value.dataType != Res_value::TYPE_NULL) { + indicesIdx++; + indices[indicesIdx] = ii; + } + + dest += STYLE_NUM_ENTRIES; + } + + res.unlock(); + + if (indices != NULL) { + indices[0] = indicesIdx; + env->ReleasePrimitiveArrayCritical(outIndices, indices, 0); + } + + env->ReleasePrimitiveArrayCritical(outValues, dest, 0); + env->ReleasePrimitiveArrayCritical(attrs, src, 0); + + return JNI_TRUE; +} + +static jint android_content_AssetManager_getArraySize(JNIEnv* env, jobject clazz, + jint id) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + const ResTable& res(am->getResources()); + + res.lock(); + const ResTable::bag_entry* defStyleEnt = NULL; + ssize_t bagOff = res.getBagLocked(id, &defStyleEnt); + res.unlock(); + + return bagOff; +} + +static jint android_content_AssetManager_retrieveArray(JNIEnv* env, jobject clazz, + jint id, + jintArray outValues) +{ + if (outValues == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return JNI_FALSE; + } + + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return JNI_FALSE; + } + const ResTable& res(am->getResources()); + Res_value value; + ssize_t block; + + const jsize NV = env->GetArrayLength(outValues); + + jint* dest = (jint*)env->GetPrimitiveArrayCritical(outValues, 0); + if (dest == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + return JNI_FALSE; + } + + // Now lock down the resource object and start pulling stuff from it. + res.lock(); + + const ResTable::bag_entry* arrayEnt = NULL; + uint32_t arrayTypeSetFlags = 0; + ssize_t bagOff = res.getBagLocked(id, &arrayEnt, &arrayTypeSetFlags); + const ResTable::bag_entry* endArrayEnt = arrayEnt + + (bagOff >= 0 ? bagOff : 0); + + int i = 0; + uint32_t typeSetFlags; + while (i < NV && arrayEnt < endArrayEnt) { + block = arrayEnt->stringBlock; + typeSetFlags = arrayTypeSetFlags; + value = arrayEnt->map.value; + + uint32_t resid = 0; + if (value.dataType != Res_value::TYPE_NULL) { + // Take care of resolving the found resource to its final value. + //printf("Resolving attribute reference\n"); + ssize_t newBlock = res.resolveReference(&value, block, &resid, &typeSetFlags); + if (newBlock >= 0) block = newBlock; + } + + // Deal with the special @null value -- it turns back to TYPE_NULL. + if (value.dataType == Res_value::TYPE_REFERENCE && value.data == 0) { + value.dataType = Res_value::TYPE_NULL; + } + + //printf("Attribute 0x%08x: final type=0x%x, data=0x%08x\n", curIdent, value.dataType, value.data); + + // Write the final value back to Java. + dest[STYLE_TYPE] = value.dataType; + dest[STYLE_DATA] = value.data; + dest[STYLE_ASSET_COOKIE] = (jint)res.getTableCookie(block); + dest[STYLE_RESOURCE_ID] = resid; + dest[STYLE_CHANGING_CONFIGURATIONS] = typeSetFlags; + dest += STYLE_NUM_ENTRIES; + i+= STYLE_NUM_ENTRIES; + arrayEnt++; + } + + i /= STYLE_NUM_ENTRIES; + + res.unlock(); + + env->ReleasePrimitiveArrayCritical(outValues, dest, 0); + + return i; +} + +static jint android_content_AssetManager_openXmlAssetNative(JNIEnv* env, jobject clazz, + jint cookie, + jstring fileName) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return 0; + } + + LOGV("openXmlAsset in %p (Java object %p)\n", am, clazz); + + if (fileName == NULL || am == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + const char* fileName8 = env->GetStringUTFChars(fileName, NULL); + Asset* a = cookie + ? am->openNonAsset((void*)cookie, fileName8, Asset::ACCESS_BUFFER) + : am->openNonAsset(fileName8, Asset::ACCESS_BUFFER); + + if (a == NULL) { + doThrow(env, "java/io/FileNotFoundException", fileName8); + env->ReleaseStringUTFChars(fileName, fileName8); + return 0; + } + env->ReleaseStringUTFChars(fileName, fileName8); + + ResXMLTree* block = new ResXMLTree(); + status_t err = block->setTo(a->getBuffer(true), a->getLength(), true); + a->close(); + delete a; + + if (err != NO_ERROR) { + doThrow(env, "java/io/FileNotFoundException", "Corrupt XML binary file"); + return 0; + } + + return (jint)block; +} + +static jintArray android_content_AssetManager_getArrayStringInfo(JNIEnv* env, jobject clazz, + jint arrayResId) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + const ResTable& res(am->getResources()); + + const ResTable::bag_entry* startOfBag; + const ssize_t N = res.lockBag(arrayResId, &startOfBag); + if (N < 0) { + return NULL; + } + + jintArray array = env->NewIntArray(N * 2); + if (array == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + res.unlockBag(startOfBag); + return NULL; + } + + Res_value value; + const ResTable::bag_entry* bag = startOfBag; + for (size_t i = 0, j = 0; ((ssize_t)i)<N; i++, bag++) { + jint stringIndex = -1; + jint stringBlock = 0; + value = bag->map.value; + + // Take care of resolving the found resource to its final value. + stringBlock = res.resolveReference(&value, bag->stringBlock, NULL); + if (value.dataType == Res_value::TYPE_STRING) { + stringIndex = value.data; + } + + //todo: It might be faster to allocate a C array to contain + // the blocknums and indices, put them in there and then + // do just one SetIntArrayRegion() + env->SetIntArrayRegion(array, j, 1, &stringBlock); + env->SetIntArrayRegion(array, j + 1, 1, &stringIndex); + j = j + 2; + } + res.unlockBag(startOfBag); + return array; +} + +static jobjectArray android_content_AssetManager_getArrayStringResource(JNIEnv* env, jobject clazz, + jint arrayResId) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + const ResTable& res(am->getResources()); + + jclass cls = env->FindClass("java/lang/String"); + LOG_FATAL_IF(cls == NULL, "No string class?!?"); + if (cls == NULL) { + return NULL; + } + + const ResTable::bag_entry* startOfBag; + const ssize_t N = res.lockBag(arrayResId, &startOfBag); + if (N < 0) { + return NULL; + } + + jobjectArray array = env->NewObjectArray(N, cls, NULL); + if (array == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + res.unlockBag(startOfBag); + return NULL; + } + + Res_value value; + const ResTable::bag_entry* bag = startOfBag; + size_t strLen = 0; + for (size_t i=0; ((ssize_t)i)<N; i++, bag++) { + value = bag->map.value; + jstring str = NULL; + + // Take care of resolving the found resource to its final value. + ssize_t block = res.resolveReference(&value, bag->stringBlock, NULL); + if (value.dataType == Res_value::TYPE_STRING) { + const char16_t* str16 = res.getTableStringBlock(block)->stringAt(value.data, &strLen); + str = env->NewString(str16, strLen); + if (str == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + res.unlockBag(startOfBag); + return NULL; + } + } + + env->SetObjectArrayElement(array, i, str); + } + res.unlockBag(startOfBag); + return array; +} + +static jintArray android_content_AssetManager_getArrayIntResource(JNIEnv* env, jobject clazz, + jint arrayResId) +{ + AssetManager* am = assetManagerForJavaObject(env, clazz); + if (am == NULL) { + return NULL; + } + const ResTable& res(am->getResources()); + + const ResTable::bag_entry* startOfBag; + const ssize_t N = res.lockBag(arrayResId, &startOfBag); + if (N < 0) { + return NULL; + } + + jintArray array = env->NewIntArray(N); + if (array == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + res.unlockBag(startOfBag); + return NULL; + } + + Res_value value; + const ResTable::bag_entry* bag = startOfBag; + for (size_t i=0; ((ssize_t)i)<N; i++, bag++) { + value = bag->map.value; + + // Take care of resolving the found resource to its final value. + ssize_t block = res.resolveReference(&value, bag->stringBlock, NULL); + if (value.dataType >= Res_value::TYPE_FIRST_INT + && value.dataType <= Res_value::TYPE_LAST_INT) { + int intVal = value.data; + env->SetIntArrayRegion(array, i, 1, &intVal); + } + } + res.unlockBag(startOfBag); + return array; +} + +static void android_content_AssetManager_init(JNIEnv* env, jobject clazz) +{ + AssetManager* am = new AssetManager(); + if (am == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + return; + } + + am->addDefaultAssets(); + + LOGV("Created AssetManager %p for Java object %p\n", am, clazz); + env->SetIntField(clazz, gAssetManagerOffsets.mObject, (jint)am); +} + +static void android_content_AssetManager_destroy(JNIEnv* env, jobject clazz) +{ + AssetManager* am = (AssetManager*) + (env->GetIntField(clazz, gAssetManagerOffsets.mObject)); + LOGV("Destroying AssetManager %p for Java object %p\n", am, clazz); + if (am != NULL) { + delete am; + env->SetIntField(clazz, gAssetManagerOffsets.mObject, 0); + } +} + +static jint android_content_AssetManager_getGlobalAssetCount(JNIEnv* env, jobject clazz) +{ + return Asset::getGlobalCount(); +} + +static jint android_content_AssetManager_getGlobalAssetManagerCount(JNIEnv* env, jobject clazz) +{ + return AssetManager::getGlobalCount(); +} + +// ---------------------------------------------------------------------------- + +/* + * JNI registration. + */ +static JNINativeMethod gAssetManagerMethods[] = { + /* name, signature, funcPtr */ + + // Basic asset stuff. + { "openAsset", "(Ljava/lang/String;I)I", + (void*) android_content_AssetManager_openAsset }, + { "openAssetFd", "(Ljava/lang/String;[J)Landroid/os/ParcelFileDescriptor;", + (void*) android_content_AssetManager_openAssetFd }, + { "openNonAssetNative", "(ILjava/lang/String;I)I", + (void*) android_content_AssetManager_openNonAssetNative }, + { "openNonAssetFdNative", "(ILjava/lang/String;[J)Landroid/os/ParcelFileDescriptor;", + (void*) android_content_AssetManager_openNonAssetFdNative }, + { "list", "(Ljava/lang/String;)[Ljava/lang/String;", + (void*) android_content_AssetManager_list }, + { "destroyAsset", "(I)V", + (void*) android_content_AssetManager_destroyAsset }, + { "readAssetChar", "(I)I", + (void*) android_content_AssetManager_readAssetChar }, + { "readAsset", "(I[BII)I", + (void*) android_content_AssetManager_readAsset }, + { "seekAsset", "(IJI)J", + (void*) android_content_AssetManager_seekAsset }, + { "getAssetLength", "(I)J", + (void*) android_content_AssetManager_getAssetLength }, + { "getAssetRemainingLength", "(I)J", + (void*) android_content_AssetManager_getAssetRemainingLength }, + { "addAssetPath", "(Ljava/lang/String;)I", + (void*) android_content_AssetManager_addAssetPath }, + { "isUpToDate", "()Z", + (void*) android_content_AssetManager_isUpToDate }, + + // Resources. + { "setLocale", "(Ljava/lang/String;)V", + (void*) android_content_AssetManager_setLocale }, + { "getLocales", "()[Ljava/lang/String;", + (void*) android_content_AssetManager_getLocales }, + { "setConfiguration", "(IILjava/lang/String;IIIIIIIII)V", + (void*) android_content_AssetManager_setConfiguration }, + { "getResourceIdentifier","(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I", + (void*) android_content_AssetManager_getResourceIdentifier }, + { "getResourceName","(I)Ljava/lang/String;", + (void*) android_content_AssetManager_getResourceName }, + { "getResourcePackageName","(I)Ljava/lang/String;", + (void*) android_content_AssetManager_getResourcePackageName }, + { "getResourceTypeName","(I)Ljava/lang/String;", + (void*) android_content_AssetManager_getResourceTypeName }, + { "getResourceEntryName","(I)Ljava/lang/String;", + (void*) android_content_AssetManager_getResourceEntryName }, + { "loadResourceValue","(ILandroid/util/TypedValue;Z)I", + (void*) android_content_AssetManager_loadResourceValue }, + { "loadResourceBagValue","(IILandroid/util/TypedValue;Z)I", + (void*) android_content_AssetManager_loadResourceBagValue }, + { "getStringBlockCount","()I", + (void*) android_content_AssetManager_getStringBlockCount }, + { "getNativeStringBlock","(I)I", + (void*) android_content_AssetManager_getNativeStringBlock }, + { "getCookieName","(I)Ljava/lang/String;", + (void*) android_content_AssetManager_getCookieName }, + + // Themes. + { "newTheme", "()I", + (void*) android_content_AssetManager_newTheme }, + { "deleteTheme", "(I)V", + (void*) android_content_AssetManager_deleteTheme }, + { "applyThemeStyle", "(IIZ)V", + (void*) android_content_AssetManager_applyThemeStyle }, + { "copyTheme", "(II)V", + (void*) android_content_AssetManager_copyTheme }, + { "loadThemeAttributeValue", "(IILandroid/util/TypedValue;Z)I", + (void*) android_content_AssetManager_loadThemeAttributeValue }, + { "dumpTheme", "(IILjava/lang/String;Ljava/lang/String;)V", + (void*) android_content_AssetManager_dumpTheme }, + { "applyStyle","(IIII[I[I[I)Z", + (void*) android_content_AssetManager_applyStyle }, + { "retrieveAttributes","(I[I[I[I)Z", + (void*) android_content_AssetManager_retrieveAttributes }, + { "getArraySize","(I)I", + (void*) android_content_AssetManager_getArraySize }, + { "retrieveArray","(I[I)I", + (void*) android_content_AssetManager_retrieveArray }, + + // XML files. + { "openXmlAssetNative", "(ILjava/lang/String;)I", + (void*) android_content_AssetManager_openXmlAssetNative }, + + // Arrays. + { "getArrayStringResource","(I)[Ljava/lang/String;", + (void*) android_content_AssetManager_getArrayStringResource }, + { "getArrayStringInfo","(I)[I", + (void*) android_content_AssetManager_getArrayStringInfo }, + { "getArrayIntResource","(I)[I", + (void*) android_content_AssetManager_getArrayIntResource }, + + // Bookkeeping. + { "init", "()V", + (void*) android_content_AssetManager_init }, + { "destroy", "()V", + (void*) android_content_AssetManager_destroy }, + { "getGlobalAssetCount", "()I", + (void*) android_content_AssetManager_getGlobalAssetCount }, + { "getGlobalAssetManagerCount", "()I", + (void*) android_content_AssetManager_getGlobalAssetCount }, +}; + +int register_android_content_AssetManager(JNIEnv* env) +{ + jclass typedValue = env->FindClass("android/util/TypedValue"); + LOG_FATAL_IF(typedValue == NULL, "Unable to find class android/util/TypedValue"); + gTypedValueOffsets.mType + = env->GetFieldID(typedValue, "type", "I"); + LOG_FATAL_IF(gTypedValueOffsets.mType == NULL, "Unable to find TypedValue.type"); + gTypedValueOffsets.mData + = env->GetFieldID(typedValue, "data", "I"); + LOG_FATAL_IF(gTypedValueOffsets.mData == NULL, "Unable to find TypedValue.data"); + gTypedValueOffsets.mString + = env->GetFieldID(typedValue, "string", "Ljava/lang/CharSequence;"); + LOG_FATAL_IF(gTypedValueOffsets.mString == NULL, "Unable to find TypedValue.string"); + gTypedValueOffsets.mAssetCookie + = env->GetFieldID(typedValue, "assetCookie", "I"); + LOG_FATAL_IF(gTypedValueOffsets.mAssetCookie == NULL, "Unable to find TypedValue.assetCookie"); + gTypedValueOffsets.mResourceId + = env->GetFieldID(typedValue, "resourceId", "I"); + LOG_FATAL_IF(gTypedValueOffsets.mResourceId == NULL, "Unable to find TypedValue.resourceId"); + gTypedValueOffsets.mChangingConfigurations + = env->GetFieldID(typedValue, "changingConfigurations", "I"); + LOG_FATAL_IF(gTypedValueOffsets.mChangingConfigurations == NULL, "Unable to find TypedValue.changingConfigurations"); + + jclass assetFd = env->FindClass("android/content/res/AssetFileDescriptor"); + LOG_FATAL_IF(assetFd == NULL, "Unable to find class android/content/res/AssetFileDescriptor"); + gAssetFileDescriptorOffsets.mFd + = env->GetFieldID(assetFd, "mFd", "Landroid/os/ParcelFileDescriptor;"); + LOG_FATAL_IF(gAssetFileDescriptorOffsets.mFd == NULL, "Unable to find AssetFileDescriptor.mFd"); + gAssetFileDescriptorOffsets.mStartOffset + = env->GetFieldID(assetFd, "mStartOffset", "J"); + LOG_FATAL_IF(gAssetFileDescriptorOffsets.mStartOffset == NULL, "Unable to find AssetFileDescriptor.mStartOffset"); + gAssetFileDescriptorOffsets.mLength + = env->GetFieldID(assetFd, "mLength", "J"); + LOG_FATAL_IF(gAssetFileDescriptorOffsets.mLength == NULL, "Unable to find AssetFileDescriptor.mLength"); + + jclass assetManager = env->FindClass("android/content/res/AssetManager"); + LOG_FATAL_IF(assetManager == NULL, "Unable to find class android/content/res/AssetManager"); + gAssetManagerOffsets.mObject + = env->GetFieldID(assetManager, "mObject", "I"); + LOG_FATAL_IF(gAssetManagerOffsets.mObject == NULL, "Unable to find AssetManager.mObject"); + + g_stringClass = env->FindClass("java/lang/String"); + + return AndroidRuntime::registerNativeMethods(env, + "android/content/res/AssetManager", gAssetManagerMethods, NELEM(gAssetManagerMethods)); +} + +}; // namespace android diff --git a/core/jni/android_util_Base64.cpp b/core/jni/android_util_Base64.cpp new file mode 100644 index 0000000..bc69747 --- /dev/null +++ b/core/jni/android_util_Base64.cpp @@ -0,0 +1,160 @@ +/* //device/libs/android_runtime/android_util_Base64.cpp +** +** Copyright 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. +*/ + +/********************************************************* +* +* This code was copied from +* system/extra/ssh/dropbear-0.49/libtomcrypt/src/misc/base64/base64_decode.c +* +*********************************************************/ + +#define LOG_TAG "Base64" + +#include <utils/Log.h> + +#include <android_runtime/AndroidRuntime.h> + +#include "JNIHelp.h" + +#include <sys/errno.h> +#include <sys/stat.h> +#include <sys/types.h> +#include <fcntl.h> +#include <signal.h> + +namespace android { + +static const unsigned char map[256] = { +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 62, 255, 255, 255, 63, + 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 255, 255, +255, 254, 255, 255, 255, 0, 1, 2, 3, 4, 5, 6, + 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, + 19, 20, 21, 22, 23, 24, 25, 255, 255, 255, 255, 255, +255, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, + 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, + 49, 50, 51, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, +255, 255, 255, 255 }; + +/** + base64 decode a block of memory + @param in The base64 data to decode + @param inlen The length of the base64 data + @param out [out] The destination of the binary decoded data + @param outlen [in/out] The max size and resulting size of the decoded data + @return 0 if successful +*/ +int base64_decode(const unsigned char *in, unsigned long inlen, + unsigned char *out, unsigned long *outlen) +{ + unsigned long t, x, y, z; + unsigned char c; + int g; + + g = 3; + for (x = y = z = t = 0; x < inlen; x++) { + c = map[in[x]&0xFF]; + if (c == 255) continue; + /* the final = symbols are read and used to trim the remaining bytes */ + if (c == 254) { + c = 0; + /* prevent g < 0 which would potentially allow an overflow later */ + if (--g < 0) { + return -3; + } + } else if (g != 3) { + /* we only allow = to be at the end */ + return -4; + } + + t = (t<<6)|c; + + if (++y == 4) { + if (z + g > *outlen) { + return -2; + } + out[z++] = (unsigned char)((t>>16)&255); + if (g > 1) out[z++] = (unsigned char)((t>>8)&255); + if (g > 2) out[z++] = (unsigned char)(t&255); + y = t = 0; + } + } + if (y != 0) { + return -5; + } + *outlen = z; + return 0; +} + +static jbyteArray decodeBase64(JNIEnv *env, jobject jobj, jstring jdata) +{ + const char * rawData = env->GetStringUTFChars(jdata, NULL); + int stringLength = env->GetStringUTFLength(jdata); + + int resultLength = stringLength / 4 * 3; + if (rawData[stringLength-1] == '=') { + resultLength -= 1; + if (rawData[stringLength-2] == '=') { + resultLength -= 1; + } + } + + jbyteArray byteArray = env->NewByteArray(resultLength); + jbyte* byteArrayData = env->GetByteArrayElements(byteArray, NULL); + + unsigned long outlen = resultLength; + int result = base64_decode((const unsigned char*)rawData, stringLength, (unsigned char *)byteArrayData, &outlen); + if (result != 0) + memset((unsigned char *)byteArrayData, -result, resultLength); + + env->ReleaseStringUTFChars(jdata, rawData); + env->ReleaseByteArrayElements(byteArray, byteArrayData, 0); + + return byteArray; +} + +static const JNINativeMethod methods[] = { + {"decodeBase64Native", "(Ljava/lang/String;)[B", (void*)decodeBase64 } +}; + +static const char* const kBase64PathName = "android/os/Base64Utils"; + +int register_android_util_Base64(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass(kBase64PathName); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.Base64Utils"); + + return AndroidRuntime::registerNativeMethods( + env, kBase64PathName, + methods, NELEM(methods)); +} + +} diff --git a/core/jni/android_util_Binder.cpp b/core/jni/android_util_Binder.cpp new file mode 100644 index 0000000..24404a8 --- /dev/null +++ b/core/jni/android_util_Binder.cpp @@ -0,0 +1,1510 @@ +/* + * Copyright (C) 2006 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. + */ + +#define LOG_TAG "JavaBinder" +//#define LOG_NDEBUG 0 + +#include "android_util_Binder.h" +#include "JNIHelp.h" + +#include <fcntl.h> +#include <sys/stat.h> +#include <stdio.h> + +#include <utils/Atomic.h> +#include <utils/IInterface.h> +#include <utils/IPCThreadState.h> +#include <utils/Log.h> +#include <utils/Parcel.h> +#include <utils/ProcessState.h> +#include <utils/IServiceManager.h> + +#include <android_runtime/AndroidRuntime.h> + +//#undef LOGV +//#define LOGV(...) fprintf(stderr, __VA_ARGS__) + +using namespace android; + +// ---------------------------------------------------------------------------- + +static struct bindernative_offsets_t +{ + // Class state. + jclass mClass; + jmethodID mExecTransact; + + // Object state. + jfieldID mObject; + +} gBinderOffsets; + +// ---------------------------------------------------------------------------- + +static struct binderinternal_offsets_t +{ + // Class state. + jclass mClass; + jmethodID mForceGc; + +} gBinderInternalOffsets; + +// ---------------------------------------------------------------------------- + +static struct debug_offsets_t +{ + // Class state. + jclass mClass; + +} gDebugOffsets; + +// ---------------------------------------------------------------------------- + +static struct weakreference_offsets_t +{ + // Class state. + jclass mClass; + jmethodID mGet; + +} gWeakReferenceOffsets; + +static struct error_offsets_t +{ + jclass mClass; +} gErrorOffsets; + +// ---------------------------------------------------------------------------- + +static struct binderproxy_offsets_t +{ + // Class state. + jclass mClass; + jmethodID mConstructor; + jmethodID mSendDeathNotice; + + // Object state. + jfieldID mObject; + jfieldID mSelf; + +} gBinderProxyOffsets; + +// ---------------------------------------------------------------------------- + +static struct parcel_offsets_t +{ + jfieldID mObject; + jfieldID mOwnObject; +} gParcelOffsets; + +static struct log_offsets_t +{ + // Class state. + jclass mClass; + jmethodID mLogE; +} gLogOffsets; + +static struct file_descriptor_offsets_t +{ + jclass mClass; + jmethodID mConstructor; + jfieldID mDescriptor; +} gFileDescriptorOffsets; + +static struct parcel_file_descriptor_offsets_t +{ + jclass mClass; + jmethodID mConstructor; +} gParcelFileDescriptorOffsets; + +// **************************************************************************** +// **************************************************************************** +// **************************************************************************** + +static volatile int32_t gNumRefsCreated = 0; +static volatile int32_t gNumProxyRefs = 0; +static volatile int32_t gNumLocalRefs = 0; +static volatile int32_t gNumDeathRefs = 0; + +static void incRefsCreated(JNIEnv* env) +{ + int old = android_atomic_inc(&gNumRefsCreated); + if (old == 200) { + android_atomic_and(0, &gNumRefsCreated); + env->CallStaticVoidMethod(gBinderInternalOffsets.mClass, + gBinderInternalOffsets.mForceGc); + } else { + LOGV("Now have %d binder ops", old); + } +} + +static JavaVM* jnienv_to_javavm(JNIEnv* env) +{ + JavaVM* vm; + return env->GetJavaVM(&vm) >= 0 ? vm : NULL; +} + +static JNIEnv* javavm_to_jnienv(JavaVM* vm) +{ + JNIEnv* env; + return vm->GetEnv((void **)&env, JNI_VERSION_1_4) >= 0 ? env : NULL; +} + +static void report_exception(JNIEnv* env, jthrowable excep, const char* msg) +{ + env->ExceptionClear(); + + jstring tagstr = env->NewStringUTF(LOG_TAG); + jstring msgstr = env->NewStringUTF(msg); + + if ((tagstr == NULL) || (msgstr == NULL)) { + env->ExceptionClear(); /* assume exception (OOM?) was thrown */ + LOGE("Unable to call Log.e()\n"); + LOGE("%s", msg); + goto bail; + } + + env->CallStaticIntMethod( + gLogOffsets.mClass, gLogOffsets.mLogE, tagstr, msgstr, excep); + if (env->ExceptionCheck()) { + /* attempting to log the failure has failed */ + LOGW("Failed trying to log exception, msg='%s'\n", msg); + env->ExceptionClear(); + } + + if (env->IsInstanceOf(excep, gErrorOffsets.mClass)) { + /* + * It's an Error: Reraise the exception, detach this thread, and + * wait for the fireworks. Die even more blatantly after a minute + * if the gentler attempt doesn't do the trick. + * + * The GetJavaVM function isn't on the "approved" list of JNI calls + * that can be made while an exception is pending, so we want to + * get the VM ptr, throw the exception, and then detach the thread. + */ + JavaVM* vm = jnienv_to_javavm(env); + env->Throw(excep); + vm->DetachCurrentThread(); + sleep(60); + LOGE("Forcefully exiting"); + exit(1); + *((int *) 1) = 1; + } + +bail: + /* discard local refs created for us by VM */ + env->DeleteLocalRef(tagstr); + env->DeleteLocalRef(msgstr); +} + +class JavaBBinderHolder; + +class JavaBBinder : public BBinder +{ +public: + JavaBBinder(JNIEnv* env, jobject object) + : mVM(jnienv_to_javavm(env)), mObject(env->NewGlobalRef(object)) + { + LOGV("Creating JavaBBinder %p\n", this); + android_atomic_inc(&gNumLocalRefs); + incRefsCreated(env); + } + + bool checkSubclass(const void* subclassID) const + { + return subclassID == &gBinderOffsets; + } + + jobject object() const + { + return mObject; + } + +protected: + virtual ~JavaBBinder() + { + LOGV("Destroying JavaBBinder %p\n", this); + android_atomic_dec(&gNumLocalRefs); + JNIEnv* env = javavm_to_jnienv(mVM); + env->DeleteGlobalRef(mObject); + } + + virtual status_t onTransact( + uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags = 0) + { + JNIEnv* env = javavm_to_jnienv(mVM); + + LOGV("onTransact() on %p calling object %p in env %p vm %p\n", this, mObject, env, mVM); + + //printf("Transact from %p to Java code sending: ", this); + //data.print(); + //printf("\n"); + jboolean res = env->CallBooleanMethod(mObject, gBinderOffsets.mExecTransact, + code, (int32_t)&data, (int32_t)reply, flags); + jthrowable excep = env->ExceptionOccurred(); + if (excep) { + report_exception(env, excep, + "*** Uncaught remote exception! " + "(Exceptions are not yet supported across processes.)"); + res = JNI_FALSE; + + /* clean up JNI local ref -- we don't return to Java code */ + env->DeleteLocalRef(excep); + } + + //aout << "onTransact to Java code; result=" << res << endl + // << "Transact from " << this << " to Java code returning " + // << reply << ": " << *reply << endl; + return res != JNI_FALSE ? NO_ERROR : UNKNOWN_TRANSACTION; + } + + virtual status_t dump(int fd, const Vector<String16>& args) + { + return 0; + } + +private: + JavaVM* const mVM; + jobject const mObject; +}; + +// ---------------------------------------------------------------------------- + +class JavaBBinderHolder : public RefBase +{ +public: + JavaBBinderHolder(JNIEnv* env, jobject object) + : mObject(object) + { + LOGV("Creating JavaBBinderHolder for Object %p\n", object); + } + ~JavaBBinderHolder() + { + LOGV("Destroying JavaBBinderHolder for Object %p\n", mObject); + } + + sp<JavaBBinder> get(JNIEnv* env) + { + AutoMutex _l(mLock); + sp<JavaBBinder> b = mBinder.promote(); + if (b == NULL) { + b = new JavaBBinder(env, mObject); + mBinder = b; + LOGV("Creating JavaBinder %p (refs %p) for Object %p, weakCount=%d\n", + b.get(), b->getWeakRefs(), mObject, b->getWeakRefs()->getWeakCount()); + } + + return b; + } + + sp<JavaBBinder> getExisting() + { + AutoMutex _l(mLock); + return mBinder.promote(); + } + +private: + Mutex mLock; + jobject mObject; + wp<JavaBBinder> mBinder; +}; + +// ---------------------------------------------------------------------------- + +class JavaDeathRecipient : public IBinder::DeathRecipient +{ +public: + JavaDeathRecipient(JNIEnv* env, jobject object) + : mVM(jnienv_to_javavm(env)), mObject(env->NewGlobalRef(object)), + mHoldsRef(true) + { + incStrong(this); + android_atomic_inc(&gNumDeathRefs); + incRefsCreated(env); + } + + void binderDied(const wp<IBinder>& who) + { + JNIEnv* env = javavm_to_jnienv(mVM); + + LOGV("Receiving binderDied() on JavaDeathRecipient %p\n", this); + + env->CallStaticVoidMethod(gBinderProxyOffsets.mClass, + gBinderProxyOffsets.mSendDeathNotice, mObject); + jthrowable excep = env->ExceptionOccurred(); + if (excep) { + report_exception(env, excep, + "*** Uncaught exception returned from death notification!"); + } + + clearReference(); + } + + void clearReference() + { + bool release = false; + mLock.lock(); + if (mHoldsRef) { + mHoldsRef = false; + release = true; + } + mLock.unlock(); + if (release) { + decStrong(this); + } + } + +protected: + virtual ~JavaDeathRecipient() + { + //LOGI("Removing death ref: recipient=%p\n", mObject); + android_atomic_dec(&gNumDeathRefs); + JNIEnv* env = javavm_to_jnienv(mVM); + env->DeleteGlobalRef(mObject); + } + +private: + JavaVM* const mVM; + jobject const mObject; + Mutex mLock; + bool mHoldsRef; +}; + +// ---------------------------------------------------------------------------- + +namespace android { + +static void proxy_cleanup(const void* id, void* obj, void* cleanupCookie) +{ + android_atomic_dec(&gNumProxyRefs); + JNIEnv* env = javavm_to_jnienv((JavaVM*)cleanupCookie); + env->DeleteGlobalRef((jobject)obj); +} + +static Mutex mProxyLock; + +jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val) +{ + if (val == NULL) return NULL; + + if (val->checkSubclass(&gBinderOffsets)) { + // One of our own! + jobject object = static_cast<JavaBBinder*>(val.get())->object(); + //printf("objectForBinder %p: it's our own %p!\n", val.get(), object); + return object; + } + + // For the rest of the function we will hold this lock, to serialize + // looking/creation of Java proxies for native Binder proxies. + AutoMutex _l(mProxyLock); + + // Someone else's... do we know about it? + jobject object = (jobject)val->findObject(&gBinderProxyOffsets); + if (object != NULL) { + jobject res = env->CallObjectMethod(object, gWeakReferenceOffsets.mGet); + if (res != NULL) { + LOGV("objectForBinder %p: found existing %p!\n", val.get(), res); + return res; + } + LOGV("Proxy object %p of IBinder %p no longer in working set!!!", object, val.get()); + android_atomic_dec(&gNumProxyRefs); + val->detachObject(&gBinderProxyOffsets); + env->DeleteGlobalRef(object); + } + + object = env->NewObject(gBinderProxyOffsets.mClass, gBinderProxyOffsets.mConstructor); + if (object != NULL) { + LOGV("objectForBinder %p: created new %p!\n", val.get(), object); + // The proxy holds a reference to the native object. + env->SetIntField(object, gBinderProxyOffsets.mObject, (int)val.get()); + val->incStrong(object); + + // The native object needs to hold a weak reference back to the + // proxy, so we can retrieve the same proxy if it is still active. + jobject refObject = env->NewGlobalRef( + env->GetObjectField(object, gBinderProxyOffsets.mSelf)); + val->attachObject(&gBinderProxyOffsets, refObject, + jnienv_to_javavm(env), proxy_cleanup); + + // Note that a new object reference has been created. + android_atomic_inc(&gNumProxyRefs); + incRefsCreated(env); + } + + return object; +} + +sp<IBinder> ibinderForJavaObject(JNIEnv* env, jobject obj) +{ + if (obj == NULL) return NULL; + + if (env->IsInstanceOf(obj, gBinderOffsets.mClass)) { + JavaBBinderHolder* jbh = (JavaBBinderHolder*) + env->GetIntField(obj, gBinderOffsets.mObject); + return jbh != NULL ? jbh->get(env) : NULL; + } + + if (env->IsInstanceOf(obj, gBinderProxyOffsets.mClass)) { + return (IBinder*) + env->GetIntField(obj, gBinderProxyOffsets.mObject); + } + + LOGW("ibinderForJavaObject: %p is not a Binder object", obj); + return NULL; +} + +Parcel* parcelForJavaObject(JNIEnv* env, jobject obj) +{ + if (obj) { + Parcel* p = (Parcel*)env->GetIntField(obj, gParcelOffsets.mObject); + if (p != NULL) { + return p; + } + jniThrowException(env, "java/lang/IllegalStateException", "Parcel has been finalized!"); + } + return NULL; +} + +jobject newFileDescriptor(JNIEnv* env, int fd) +{ + jobject object = env->NewObject( + gFileDescriptorOffsets.mClass, gFileDescriptorOffsets.mConstructor); + if (object != NULL) { + //LOGI("Created new FileDescriptor %p with fd %d\n", object, fd); + env->SetIntField(object, gFileDescriptorOffsets.mDescriptor, fd); + } + return object; +} + +jobject newParcelFileDescriptor(JNIEnv* env, jobject fileDesc) +{ + return env->NewObject( + gParcelFileDescriptorOffsets.mClass, gParcelFileDescriptorOffsets.mConstructor, fileDesc); +} + +void signalExceptionForError(JNIEnv* env, jobject obj, status_t err) +{ + switch (err) { + case UNKNOWN_ERROR: + jniThrowException(env, "java/lang/RuntimeException", "Unknown error"); + break; + case NO_MEMORY: + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + break; + case INVALID_OPERATION: + jniThrowException(env, "java/lang/UnsupportedOperationException", NULL); + break; + case BAD_VALUE: + jniThrowException(env, "java/lang/IllegalArgumentException", NULL); + break; + case BAD_INDEX: + jniThrowException(env, "java/lang/IndexOutOfBoundsException", NULL); + break; + case BAD_TYPE: + jniThrowException(env, "java/lang/IllegalArgumentException", NULL); + break; + case NAME_NOT_FOUND: + jniThrowException(env, "java/util/NoSuchElementException", NULL); + break; + case PERMISSION_DENIED: + jniThrowException(env, "java/lang/SecurityException", NULL); + break; + case NOT_ENOUGH_DATA: + jniThrowException(env, "android/os/ParcelFormatException", "Not enough data"); + break; + case NO_INIT: + jniThrowException(env, "java/lang/RuntimeException", "Not initialized"); + break; + case ALREADY_EXISTS: + jniThrowException(env, "java/lang/RuntimeException", "Item already exists"); + break; + case DEAD_OBJECT: + jniThrowException(env, "android/os/DeadObjectException", NULL); + break; + case UNKNOWN_TRANSACTION: + jniThrowException(env, "java/lang/RuntimeException", "Unknown transaction code"); + break; + case FAILED_TRANSACTION: + LOGE("!!! FAILED BINDER TRANSACTION !!!"); + //jniThrowException(env, "java/lang/OutOfMemoryError", "Binder transaction too large"); + break; + default: + LOGE("Unknown binder error code. 0x%x", err); + } +} + +} + +// ---------------------------------------------------------------------------- + +static jint android_os_Binder_getCallingPid(JNIEnv* env, jobject clazz) +{ + return IPCThreadState::self()->getCallingPid(); +} + +static jint android_os_Binder_getCallingUid(JNIEnv* env, jobject clazz) +{ + return IPCThreadState::self()->getCallingUid(); +} + +static jlong android_os_Binder_clearCallingIdentity(JNIEnv* env, jobject clazz) +{ + return IPCThreadState::self()->clearCallingIdentity(); +} + +static void android_os_Binder_restoreCallingIdentity(JNIEnv* env, jobject clazz, jlong token) +{ + IPCThreadState::self()->restoreCallingIdentity(token); +} + +static void android_os_Binder_flushPendingCommands(JNIEnv* env, jobject clazz) +{ + IPCThreadState::self()->flushCommands(); +} + +static void android_os_Binder_init(JNIEnv* env, jobject clazz) +{ + JavaBBinderHolder* jbh = new JavaBBinderHolder(env, clazz); + if (jbh == NULL) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + return; + } + LOGV("Java Binder %p: acquiring first ref on holder %p", clazz, jbh); + jbh->incStrong(clazz); + env->SetIntField(clazz, gBinderOffsets.mObject, (int)jbh); +} + +static void android_os_Binder_destroy(JNIEnv* env, jobject clazz) +{ + JavaBBinderHolder* jbh = (JavaBBinderHolder*) + env->GetIntField(clazz, gBinderOffsets.mObject); + env->SetIntField(clazz, gBinderOffsets.mObject, 0); + LOGV("Java Binder %p: removing ref on holder %p", clazz, jbh); + jbh->decStrong(clazz); +} + +// ---------------------------------------------------------------------------- + +static const JNINativeMethod gBinderMethods[] = { + /* name, signature, funcPtr */ + { "getCallingPid", "()I", (void*)android_os_Binder_getCallingPid }, + { "getCallingUid", "()I", (void*)android_os_Binder_getCallingUid }, + { "clearCallingIdentity", "()J", (void*)android_os_Binder_clearCallingIdentity }, + { "restoreCallingIdentity", "(J)V", (void*)android_os_Binder_restoreCallingIdentity }, + { "flushPendingCommands", "()V", (void*)android_os_Binder_flushPendingCommands }, + { "init", "()V", (void*)android_os_Binder_init }, + { "destroy", "()V", (void*)android_os_Binder_destroy } +}; + +const char* const kBinderPathName = "android/os/Binder"; + +static int int_register_android_os_Binder(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass(kBinderPathName); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.Binder"); + + gBinderOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + gBinderOffsets.mExecTransact + = env->GetMethodID(clazz, "execTransact", "(IIII)Z"); + assert(gBinderOffsets.mExecTransact); + + gBinderOffsets.mObject + = env->GetFieldID(clazz, "mObject", "I"); + assert(gBinderOffsets.mObject); + + return AndroidRuntime::registerNativeMethods( + env, kBinderPathName, + gBinderMethods, NELEM(gBinderMethods)); +} + +// **************************************************************************** +// **************************************************************************** +// **************************************************************************** + +namespace android { + +jint android_os_Debug_getLocalObjectCount(JNIEnv* env, jobject clazz) +{ + return gNumLocalRefs; +} + +jint android_os_Debug_getProxyObjectCount(JNIEnv* env, jobject clazz) +{ + return gNumProxyRefs; +} + +jint android_os_Debug_getDeathObjectCount(JNIEnv* env, jobject clazz) +{ + return gNumDeathRefs; +} + +} + +// **************************************************************************** +// **************************************************************************** +// **************************************************************************** + +static jobject android_os_BinderInternal_getContextObject(JNIEnv* env, jobject clazz) +{ + sp<IBinder> b = ProcessState::self()->getContextObject(NULL); + return javaObjectForIBinder(env, b); +} + +static void android_os_BinderInternal_joinThreadPool(JNIEnv* env, jobject clazz) +{ + sp<IBinder> b = ProcessState::self()->getContextObject(NULL); + android::IPCThreadState::self()->joinThreadPool(); +} + +static void android_os_BinderInternal_handleGc(JNIEnv* env, jobject clazz) +{ + LOGV("Gc has executed, clearing binder ops"); + android_atomic_and(0, &gNumRefsCreated); +} + +// ---------------------------------------------------------------------------- + +static const JNINativeMethod gBinderInternalMethods[] = { + /* name, signature, funcPtr */ + { "getContextObject", "()Landroid/os/IBinder;", (void*)android_os_BinderInternal_getContextObject }, + { "joinThreadPool", "()V", (void*)android_os_BinderInternal_joinThreadPool }, + { "handleGc", "()V", (void*)android_os_BinderInternal_handleGc } +}; + +const char* const kBinderInternalPathName = "com/android/internal/os/BinderInternal"; + +static int int_register_android_os_BinderInternal(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass(kBinderInternalPathName); + LOG_FATAL_IF(clazz == NULL, "Unable to find class com.android.internal.os.BinderInternal"); + + gBinderInternalOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + gBinderInternalOffsets.mForceGc + = env->GetStaticMethodID(clazz, "forceBinderGc", "()V"); + assert(gBinderInternalOffsets.mForceGc); + + return AndroidRuntime::registerNativeMethods( + env, kBinderInternalPathName, + gBinderInternalMethods, NELEM(gBinderInternalMethods)); +} + +// **************************************************************************** +// **************************************************************************** +// **************************************************************************** + +static jboolean android_os_BinderProxy_pingBinder(JNIEnv* env, jobject obj) +{ + IBinder* target = (IBinder*) + env->GetIntField(obj, gBinderProxyOffsets.mObject); + if (target == NULL) { + return JNI_FALSE; + } + status_t err = target->pingBinder(); + return err == NO_ERROR ? JNI_TRUE : JNI_FALSE; +} + +static jstring android_os_BinderProxy_getInterfaceDescriptor(JNIEnv* env, jobject obj) +{ + IBinder* target = (IBinder*) env->GetIntField(obj, gBinderProxyOffsets.mObject); + if (target != NULL) { + String16 desc = target->getInterfaceDescriptor(); + return env->NewString(desc.string(), desc.size()); + } + jniThrowException(env, "java/lang/RuntimeException", + "No binder found for object"); + return NULL; +} + +static jboolean android_os_BinderProxy_isBinderAlive(JNIEnv* env, jobject obj) +{ + IBinder* target = (IBinder*) + env->GetIntField(obj, gBinderProxyOffsets.mObject); + if (target == NULL) { + return JNI_FALSE; + } + bool alive = target->isBinderAlive(); + return alive ? JNI_TRUE : JNI_FALSE; +} + +static jboolean android_os_BinderProxy_transact(JNIEnv* env, jobject obj, + jint code, jobject dataObj, + jobject replyObj, jint flags) +{ + if (dataObj == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return JNI_FALSE; + } + + Parcel* data = parcelForJavaObject(env, dataObj); + if (data == NULL) { + return JNI_FALSE; + } + Parcel* reply = parcelForJavaObject(env, replyObj); + if (reply == NULL && replyObj != NULL) { + return JNI_FALSE; + } + + IBinder* target = (IBinder*) + env->GetIntField(obj, gBinderProxyOffsets.mObject); + if (target == NULL) { + jniThrowException(env, "java/lang/IllegalStateException", "Binder has been finalized!"); + return JNI_FALSE; + } + + LOGV("Java code calling transact on %p in Java object %p with code %d\n", + target, obj, code); + //printf("Transact from Java code to %p sending: ", target); data->print(); + status_t err = target->transact(code, *data, reply, flags); + //if (reply) printf("Transact from Java code to %p received: ", target); reply->print(); + if (err == NO_ERROR) { + return JNI_TRUE; + } else if (err == UNKNOWN_TRANSACTION) { + return JNI_FALSE; + } + + signalExceptionForError(env, obj, err); + return JNI_FALSE; +} + +static void android_os_BinderProxy_linkToDeath(JNIEnv* env, jobject obj, + jobject recipient, jint flags) +{ + if (recipient == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return; + } + + IBinder* target = (IBinder*) + env->GetIntField(obj, gBinderProxyOffsets.mObject); + if (target == NULL) { + LOGW("Binder has been finalized when calling linkToDeath() with recip=%p)\n", recipient); + assert(false); + } + + LOGV("linkToDeath: binder=%p recipient=%p\n", target, recipient); + + if (!target->localBinder()) { + sp<JavaDeathRecipient> jdr = new JavaDeathRecipient(env, recipient); + status_t err = target->linkToDeath(jdr, recipient, flags); + if (err != NO_ERROR) { + // Failure adding the death recipient, so clear its reference + // now. + jdr->clearReference(); + signalExceptionForError(env, obj, err); + } + } +} + +static jboolean android_os_BinderProxy_unlinkToDeath(JNIEnv* env, jobject obj, + jobject recipient, jint flags) +{ + jboolean res = JNI_FALSE; + if (recipient == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return res; + } + + IBinder* target = (IBinder*) + env->GetIntField(obj, gBinderProxyOffsets.mObject); + if (target == NULL) { + LOGW("Binder has been finalized when calling linkToDeath() with recip=%p)\n", recipient); + return JNI_FALSE; + } + + LOGV("unlinkToDeath: binder=%p recipient=%p\n", target, recipient); + + if (!target->localBinder()) { + wp<IBinder::DeathRecipient> dr; + status_t err = target->unlinkToDeath(NULL, recipient, flags, &dr); + if (err == NO_ERROR && dr != NULL) { + sp<IBinder::DeathRecipient> sdr = dr.promote(); + JavaDeathRecipient* jdr = static_cast<JavaDeathRecipient*>(sdr.get()); + if (jdr != NULL) { + jdr->clearReference(); + } + } + if (err == NO_ERROR || err == DEAD_OBJECT) { + res = JNI_TRUE; + } else { + jniThrowException(env, "java/util/NoSuchElementException", + "Death link does not exist"); + } + } + + return res; +} + +static void android_os_BinderProxy_destroy(JNIEnv* env, jobject obj) +{ + IBinder* b = (IBinder*) + env->GetIntField(obj, gBinderProxyOffsets.mObject); + LOGV("Destroying BinderProxy %p: binder=%p\n", obj, b); + env->SetIntField(obj, gBinderProxyOffsets.mObject, 0); + b->decStrong(obj); + IPCThreadState::self()->flushCommands(); +} + +// ---------------------------------------------------------------------------- + +static const JNINativeMethod gBinderProxyMethods[] = { + /* name, signature, funcPtr */ + {"pingBinder", "()Z", (void*)android_os_BinderProxy_pingBinder}, + {"isBinderAlive", "()Z", (void*)android_os_BinderProxy_isBinderAlive}, + {"getInterfaceDescriptor", "()Ljava/lang/String;", (void*)android_os_BinderProxy_getInterfaceDescriptor}, + {"transact", "(ILandroid/os/Parcel;Landroid/os/Parcel;I)Z", (void*)android_os_BinderProxy_transact}, + {"linkToDeath", "(Landroid/os/IBinder$DeathRecipient;I)V", (void*)android_os_BinderProxy_linkToDeath}, + {"unlinkToDeath", "(Landroid/os/IBinder$DeathRecipient;I)Z", (void*)android_os_BinderProxy_unlinkToDeath}, + {"destroy", "()V", (void*)android_os_BinderProxy_destroy}, +}; + +const char* const kBinderProxyPathName = "android/os/BinderProxy"; + +static int int_register_android_os_BinderProxy(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass("java/lang/ref/WeakReference"); + LOG_FATAL_IF(clazz == NULL, "Unable to find class java.lang.ref.WeakReference"); + gWeakReferenceOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + gWeakReferenceOffsets.mGet + = env->GetMethodID(clazz, "get", "()Ljava/lang/Object;"); + assert(gWeakReferenceOffsets.mGet); + + clazz = env->FindClass("java/lang/Error"); + LOG_FATAL_IF(clazz == NULL, "Unable to find class java.lang.Error"); + gErrorOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + + clazz = env->FindClass(kBinderProxyPathName); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.BinderProxy"); + + gBinderProxyOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + gBinderProxyOffsets.mConstructor + = env->GetMethodID(clazz, "<init>", "()V"); + assert(gBinderProxyOffsets.mConstructor); + gBinderProxyOffsets.mSendDeathNotice + = env->GetStaticMethodID(clazz, "sendDeathNotice", "(Landroid/os/IBinder$DeathRecipient;)V"); + assert(gBinderProxyOffsets.mSendDeathNotice); + + gBinderProxyOffsets.mObject + = env->GetFieldID(clazz, "mObject", "I"); + assert(gBinderProxyOffsets.mObject); + gBinderProxyOffsets.mSelf + = env->GetFieldID(clazz, "mSelf", "Ljava/lang/ref/WeakReference;"); + assert(gBinderProxyOffsets.mSelf); + + return AndroidRuntime::registerNativeMethods( + env, kBinderProxyPathName, + gBinderProxyMethods, NELEM(gBinderProxyMethods)); +} + +// **************************************************************************** +// **************************************************************************** +// **************************************************************************** + +static jint android_os_Parcel_dataSize(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + return parcel ? parcel->dataSize() : 0; +} + +static jint android_os_Parcel_dataAvail(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + return parcel ? parcel->dataAvail() : 0; +} + +static jint android_os_Parcel_dataPosition(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + return parcel ? parcel->dataPosition() : 0; +} + +static jint android_os_Parcel_dataCapacity(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + return parcel ? parcel->dataCapacity() : 0; +} + +static void android_os_Parcel_setDataSize(JNIEnv* env, jobject clazz, jint size) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + const status_t err = parcel->setDataSize(size); + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + } +} + +static void android_os_Parcel_setDataPosition(JNIEnv* env, jobject clazz, jint pos) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + parcel->setDataPosition(pos); + } +} + +static void android_os_Parcel_setDataCapacity(JNIEnv* env, jobject clazz, jint size) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + const status_t err = parcel->setDataCapacity(size); + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + } +} + +static void android_os_Parcel_writeNative(JNIEnv* env, jobject clazz, + jobject data, jint offset, + jint length) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel == NULL) { + return; + } + void *dest; + + const status_t err = parcel->writeInt32(length); + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + + dest = parcel->writeInplace(length); + + if (dest == NULL) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + return; + } + + jbyte* ar = (jbyte*)env->GetPrimitiveArrayCritical((jarray)data, 0); + if (ar) { + memcpy(dest, ar, length); + env->ReleasePrimitiveArrayCritical((jarray)data, ar, 0); + } +} + + +static void android_os_Parcel_writeInt(JNIEnv* env, jobject clazz, jint val) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + const status_t err = parcel->writeInt32(val); + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + } +} + +static void android_os_Parcel_writeLong(JNIEnv* env, jobject clazz, jlong val) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + const status_t err = parcel->writeInt64(val); + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + } +} + +static void android_os_Parcel_writeFloat(JNIEnv* env, jobject clazz, jfloat val) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + const status_t err = parcel->writeFloat(val); + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + } +} + +static void android_os_Parcel_writeDouble(JNIEnv* env, jobject clazz, jdouble val) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + const status_t err = parcel->writeDouble(val); + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + } +} + +static void android_os_Parcel_writeString(JNIEnv* env, jobject clazz, jstring val) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + status_t err = NO_MEMORY; + if (val) { + const jchar* str = env->GetStringCritical(val, 0); + if (str) { + err = parcel->writeString16(str, env->GetStringLength(val)); + env->ReleaseStringCritical(val, str); + } + } else { + err = parcel->writeString16(NULL, 0); + } + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + } +} + +static void android_os_Parcel_writeStrongBinder(JNIEnv* env, jobject clazz, jobject object) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + const status_t err = parcel->writeStrongBinder(ibinderForJavaObject(env, object)); + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + } +} + +static void android_os_Parcel_writeFileDescriptor(JNIEnv* env, jobject clazz, jobject object) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + const status_t err = parcel->writeDupFileDescriptor( + env->GetIntField(object, gFileDescriptorOffsets.mDescriptor)); + if (err != NO_ERROR) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + } + } +} + +static jbyteArray android_os_Parcel_createByteArray(JNIEnv* env, jobject clazz) +{ + jbyteArray ret = NULL; + + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + int32_t len = parcel->readInt32(); + + // sanity check the stored length against the true data size + if (len >= 0 && len <= (int32_t)parcel->dataAvail()) { + ret = env->NewByteArray(len); + + if (ret != NULL) { + jbyte* a2 = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0); + if (a2) { + const void* data = parcel->readInplace(len); + memcpy(a2, data, len); + env->ReleasePrimitiveArrayCritical(ret, a2, 0); + } + } + } + } + + return ret; +} + +static jint android_os_Parcel_readInt(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + return parcel->readInt32(); + } + return 0; +} + +static jlong android_os_Parcel_readLong(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + return parcel->readInt64(); + } + return 0; +} + +static jfloat android_os_Parcel_readFloat(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + return parcel->readFloat(); + } + return 0; +} + +static jdouble android_os_Parcel_readDouble(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + return parcel->readDouble(); + } + return 0; +} + +static jstring android_os_Parcel_readString(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + size_t len; + const char16_t* str = parcel->readString16Inplace(&len); + if (str) { + return env->NewString(str, len); + } + return NULL; + } + return NULL; +} + +static jobject android_os_Parcel_readStrongBinder(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + return javaObjectForIBinder(env, parcel->readStrongBinder()); + } + return NULL; +} + +static jobject android_os_Parcel_readFileDescriptor(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + int fd = parcel->readFileDescriptor(); + if (fd < 0) return NULL; + fd = dup(fd); + if (fd < 0) return NULL; + jobject object = env->NewObject( + gFileDescriptorOffsets.mClass, gFileDescriptorOffsets.mConstructor); + if (object != NULL) { + //LOGI("Created new FileDescriptor %p with fd %d\n", object, fd); + env->SetIntField(object, gFileDescriptorOffsets.mDescriptor, fd); + } + return object; + } + return NULL; +} + +static jobject android_os_Parcel_openFileDescriptor(JNIEnv* env, jobject clazz, + jstring name, jint mode) +{ + if (name == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return NULL; + } + const jchar* str = env->GetStringCritical(name, 0); + if (str == NULL) { + // Whatever, whatever. + jniThrowException(env, "java/lang/IllegalStateException", NULL); + return NULL; + } + String8 name8(str, env->GetStringLength(name)); + env->ReleaseStringCritical(name, str); + int flags=0; + switch (mode&0x30000000) { + case 0: + case 0x10000000: + flags = O_RDONLY; + break; + case 0x20000000: + flags = O_WRONLY; + break; + case 0x30000000: + flags = O_RDWR; + break; + } + + if (mode&0x08000000) flags |= O_CREAT; + if (mode&0x04000000) flags |= O_TRUNC; + + int realMode = S_IRWXU|S_IRWXG; + if (mode&0x00000001) realMode |= S_IROTH; + if (mode&0x00000002) realMode |= S_IWOTH; + + int fd = open(name8.string(), flags, realMode); + if (fd < 0) { + jniThrowException(env, "java/io/FileNotFoundException", NULL); + return NULL; + } + jobject object = newFileDescriptor(env, fd); + if (object == NULL) { + close(fd); + } + return object; +} + +static void android_os_Parcel_closeFileDescriptor(JNIEnv* env, jobject clazz, jobject object) +{ + int fd = env->GetIntField(object, gFileDescriptorOffsets.mDescriptor); + if (fd >= 0) { + env->SetIntField(object, gFileDescriptorOffsets.mDescriptor, -1); + //LOGI("Closing ParcelFileDescriptor %d\n", fd); + close(fd); + } +} + +static void android_os_Parcel_freeBuffer(JNIEnv* env, jobject clazz) +{ + int32_t own = env->GetIntField(clazz, gParcelOffsets.mOwnObject); + if (own) { + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + //LOGI("Parcel.freeBuffer() called for C++ Parcel %p\n", parcel); + parcel->freeData(); + } + } +} + +static void android_os_Parcel_init(JNIEnv* env, jobject clazz, jint parcelInt) +{ + Parcel* parcel = (Parcel*)parcelInt; + int own = 0; + if (!parcel) { + //LOGI("Initializing obj %p: creating new Parcel\n", clazz); + own = 1; + parcel = new Parcel; + } else { + //LOGI("Initializing obj %p: given existing Parcel %p\n", clazz, parcel); + } + if (parcel == NULL) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + return; + } + //LOGI("Initializing obj %p from C++ Parcel %p, own=%d\n", clazz, parcel, own); + env->SetIntField(clazz, gParcelOffsets.mOwnObject, own); + env->SetIntField(clazz, gParcelOffsets.mObject, (int)parcel); +} + +static void android_os_Parcel_destroy(JNIEnv* env, jobject clazz) +{ + int32_t own = env->GetIntField(clazz, gParcelOffsets.mOwnObject); + if (own) { + Parcel* parcel = parcelForJavaObject(env, clazz); + env->SetIntField(clazz, gParcelOffsets.mObject, 0); + //LOGI("Destroying obj %p: deleting C++ Parcel %p\n", clazz, parcel); + delete parcel; + } else { + env->SetIntField(clazz, gParcelOffsets.mObject, 0); + //LOGI("Destroying obj %p: leaving C++ Parcel %p\n", clazz); + } +} + +static jbyteArray android_os_Parcel_marshall(JNIEnv* env, jobject clazz) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel == NULL) { + return NULL; + } + + // do not marshall if there are binder objects in the parcel + if (parcel->objectsCount()) + { + jniThrowException(env, "java/lang/RuntimeException", "Tried to marshall a Parcel that contained Binder objects."); + return NULL; + } + + jbyteArray ret = env->NewByteArray(parcel->dataSize()); + + if (ret != NULL) + { + jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(ret, 0); + if (array != NULL) + { + memcpy(array, parcel->data(), parcel->dataSize()); + env->ReleasePrimitiveArrayCritical(ret, array, 0); + } + } + + return ret; +} + +static void android_os_Parcel_unmarshall(JNIEnv* env, jobject clazz, jbyteArray data, jint offset, jint length) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel == NULL || length < 0) { + return; + } + + jbyte* array = (jbyte*)env->GetPrimitiveArrayCritical(data, 0); + if (array) + { + parcel->setDataSize(length); + parcel->setDataPosition(0); + + void* raw = parcel->writeInplace(length); + memcpy(raw, (array + offset), length); + + env->ReleasePrimitiveArrayCritical(data, array, 0); + } +} + +static void android_os_Parcel_appendFrom(JNIEnv* env, jobject clazz, jobject parcel, jint offset, jint length) +{ + Parcel* thisParcel = parcelForJavaObject(env, clazz); + if (thisParcel == NULL) { + return; + } + Parcel* otherParcel = parcelForJavaObject(env, parcel); + if (otherParcel == NULL) { + return; + } + + (void) thisParcel->appendFrom(otherParcel, offset, length); +} + +static jboolean android_os_Parcel_hasFileDescriptors(JNIEnv* env, jobject clazz) +{ + jboolean ret = JNI_FALSE; + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + if (parcel->hasFileDescriptors()) { + ret = JNI_TRUE; + } + } + return ret; +} + +static void android_os_Parcel_writeInterfaceToken(JNIEnv* env, jobject clazz, jstring name) +{ + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + // In the current implementation, the token is just the serialized interface name that + // the caller expects to be invoking + const jchar* str = env->GetStringCritical(name, 0); + if (str != NULL) { + parcel->writeInterfaceToken(String16(str, env->GetStringLength(name))); + env->ReleaseStringCritical(name, str); + } + } +} + +static void android_os_Parcel_enforceInterface(JNIEnv* env, jobject clazz, jstring name) +{ + jboolean ret = JNI_FALSE; + + Parcel* parcel = parcelForJavaObject(env, clazz); + if (parcel != NULL) { + const jchar* str = env->GetStringCritical(name, 0); + if (str) { + bool isValid = parcel->enforceInterface(String16(str, env->GetStringLength(name))); + env->ReleaseStringCritical(name, str); + if (isValid) { + return; // everything was correct -> return silently + } + } + } + + // all error conditions wind up here + jniThrowException(env, "java/lang/SecurityException", + "Binder invocation to an incorrect interface"); +} + +// ---------------------------------------------------------------------------- + +static const JNINativeMethod gParcelMethods[] = { + {"dataSize", "()I", (void*)android_os_Parcel_dataSize}, + {"dataAvail", "()I", (void*)android_os_Parcel_dataAvail}, + {"dataPosition", "()I", (void*)android_os_Parcel_dataPosition}, + {"dataCapacity", "()I", (void*)android_os_Parcel_dataCapacity}, + {"setDataSize", "(I)V", (void*)android_os_Parcel_setDataSize}, + {"setDataPosition", "(I)V", (void*)android_os_Parcel_setDataPosition}, + {"setDataCapacity", "(I)V", (void*)android_os_Parcel_setDataCapacity}, + {"writeNative", "([BII)V", (void*)android_os_Parcel_writeNative}, + {"writeInt", "(I)V", (void*)android_os_Parcel_writeInt}, + {"writeLong", "(J)V", (void*)android_os_Parcel_writeLong}, + {"writeFloat", "(F)V", (void*)android_os_Parcel_writeFloat}, + {"writeDouble", "(D)V", (void*)android_os_Parcel_writeDouble}, + {"writeString", "(Ljava/lang/String;)V", (void*)android_os_Parcel_writeString}, + {"writeStrongBinder", "(Landroid/os/IBinder;)V", (void*)android_os_Parcel_writeStrongBinder}, + {"writeFileDescriptor", "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_writeFileDescriptor}, + {"createByteArray", "()[B", (void*)android_os_Parcel_createByteArray}, + {"readInt", "()I", (void*)android_os_Parcel_readInt}, + {"readLong", "()J", (void*)android_os_Parcel_readLong}, + {"readFloat", "()F", (void*)android_os_Parcel_readFloat}, + {"readDouble", "()D", (void*)android_os_Parcel_readDouble}, + {"readString", "()Ljava/lang/String;", (void*)android_os_Parcel_readString}, + {"readStrongBinder", "()Landroid/os/IBinder;", (void*)android_os_Parcel_readStrongBinder}, + {"internalReadFileDescriptor", "()Ljava/io/FileDescriptor;", (void*)android_os_Parcel_readFileDescriptor}, + {"openFileDescriptor", "(Ljava/lang/String;I)Ljava/io/FileDescriptor;", (void*)android_os_Parcel_openFileDescriptor}, + {"closeFileDescriptor", "(Ljava/io/FileDescriptor;)V", (void*)android_os_Parcel_closeFileDescriptor}, + {"freeBuffer", "()V", (void*)android_os_Parcel_freeBuffer}, + {"init", "(I)V", (void*)android_os_Parcel_init}, + {"destroy", "()V", (void*)android_os_Parcel_destroy}, + {"marshall", "()[B", (void*)android_os_Parcel_marshall}, + {"unmarshall", "([BII)V", (void*)android_os_Parcel_unmarshall}, + {"appendFrom", "(Landroid/os/Parcel;II)V", (void*)android_os_Parcel_appendFrom}, + {"hasFileDescriptors", "()Z", (void*)android_os_Parcel_hasFileDescriptors}, + {"writeInterfaceToken", "(Ljava/lang/String;)V", (void*)android_os_Parcel_writeInterfaceToken}, + {"enforceInterface", "(Ljava/lang/String;)V", (void*)android_os_Parcel_enforceInterface}, +}; + +const char* const kParcelPathName = "android/os/Parcel"; + +static int int_register_android_os_Parcel(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass("android/util/Log"); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.util.Log"); + gLogOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + gLogOffsets.mLogE = env->GetStaticMethodID( + clazz, "e", "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/Throwable;)I"); + assert(gLogOffsets.mLogE); + + clazz = env->FindClass("java/io/FileDescriptor"); + LOG_FATAL_IF(clazz == NULL, "Unable to find class java.io.FileDescriptor"); + gFileDescriptorOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + gFileDescriptorOffsets.mConstructor + = env->GetMethodID(clazz, "<init>", "()V"); + gFileDescriptorOffsets.mDescriptor = env->GetFieldID(clazz, "descriptor", "I"); + LOG_FATAL_IF(gFileDescriptorOffsets.mDescriptor == NULL, + "Unable to find descriptor field in java.io.FileDescriptor"); + + clazz = env->FindClass("android/os/ParcelFileDescriptor"); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.ParcelFileDescriptor"); + gParcelFileDescriptorOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + gParcelFileDescriptorOffsets.mConstructor + = env->GetMethodID(clazz, "<init>", "(Ljava/io/FileDescriptor;)V"); + + clazz = env->FindClass(kParcelPathName); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.Parcel"); + + gParcelOffsets.mObject + = env->GetFieldID(clazz, "mObject", "I"); + gParcelOffsets.mOwnObject + = env->GetFieldID(clazz, "mOwnObject", "I"); + + return AndroidRuntime::registerNativeMethods( + env, kParcelPathName, + gParcelMethods, NELEM(gParcelMethods)); +} + +int register_android_os_Binder(JNIEnv* env) +{ + if (int_register_android_os_Binder(env) < 0) + return -1; + if (int_register_android_os_BinderInternal(env) < 0) + return -1; + if (int_register_android_os_BinderProxy(env) < 0) + return -1; + if (int_register_android_os_Parcel(env) < 0) + return -1; + return 0; +} + +namespace android { + +// Returns the Unix file descriptor for a ParcelFileDescriptor object +int getParcelFileDescriptorFD(JNIEnv* env, jobject object) +{ + return env->GetIntField(object, gFileDescriptorOffsets.mDescriptor); +} + +} diff --git a/core/jni/android_util_Binder.h b/core/jni/android_util_Binder.h new file mode 100644 index 0000000..16d993d --- /dev/null +++ b/core/jni/android_util_Binder.h @@ -0,0 +1,35 @@ +/* //device/libs/android_runtime/android_util_Binder.h +** +** Copyright 2006, 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. +*/ + +#include <utils/IBinder.h> + +#include "jni.h" + +namespace android { + +// Converstion to/from Java IBinder Object and C++ IBinder instance. +extern jobject javaObjectForIBinder(JNIEnv* env, const sp<IBinder>& val); +extern sp<IBinder> ibinderForJavaObject(JNIEnv* env, jobject obj); + +// Conversion from Java Parcel Object to C++ Parcel instance. +// Note: does not type checking; must guarantee jobject is a Java Parcel +extern Parcel* parcelForJavaObject(JNIEnv* env, jobject obj); + +extern jobject newFileDescriptor(JNIEnv* env, int fd); +extern jobject newParcelFileDescriptor(JNIEnv* env, jobject fileDesc); + +} diff --git a/core/jni/android_util_EventLog.cpp b/core/jni/android_util_EventLog.cpp new file mode 100644 index 0000000..d0cac18 --- /dev/null +++ b/core/jni/android_util_EventLog.cpp @@ -0,0 +1,353 @@ +/* + * Copyright (C) 2007 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. + */ + +#include <fcntl.h> + +#include "JNIHelp.h" +#include "android_runtime/AndroidRuntime.h" +#include "jni.h" +#include "utils/logger.h" + +#define END_DELIMITER '\n' +#define INT_BUFFER_SIZE (sizeof(jbyte)+sizeof(jint)+sizeof(END_DELIMITER)) +#define LONG_BUFFER_SIZE (sizeof(jbyte)+sizeof(jlong)+sizeof(END_DELIMITER)) +#define INITAL_BUFFER_CAPACITY 256 + +#define MAX(a,b) ((a>b)?a:b) + +namespace android { + +static jclass gCollectionClass; +static jmethodID gCollectionAddID; + +static jclass gEventClass; +static jmethodID gEventInitID; + +static jclass gIntegerClass; +static jfieldID gIntegerValueID; + +static jclass gListClass; +static jfieldID gListItemsID; + +static jclass gLongClass; +static jfieldID gLongValueID; + +static jclass gStringClass; + +struct ByteBuf { + size_t len; + size_t capacity; + uint8_t* buf; + + ByteBuf(size_t initSize) { + buf = (uint8_t*)malloc(initSize); + len = 0; + capacity = initSize; + } + + ~ByteBuf() { + free(buf); + } + + bool ensureExtraCapacity(size_t extra) { + size_t spaceNeeded = len + extra; + if (spaceNeeded > capacity) { + size_t newCapacity = MAX(spaceNeeded, 2 * capacity); + void* newBuf = realloc(buf, newCapacity); + if (newBuf == NULL) { + return false; + } + capacity = newCapacity; + buf = (uint8_t*)newBuf; + return true; + } else { + return true; + } + } + + void putIntEvent(jint value) { + bool succeeded = ensureExtraCapacity(INT_BUFFER_SIZE); + buf[len++] = EVENT_TYPE_INT; + memcpy(buf+len, &value, sizeof(jint)); + len += sizeof(jint); + } + + void putByte(uint8_t value) { + bool succeeded = ensureExtraCapacity(sizeof(uint8_t)); + buf[len++] = value; + } + + void putLongEvent(jlong value) { + bool succeeded = ensureExtraCapacity(LONG_BUFFER_SIZE); + buf[len++] = EVENT_TYPE_LONG; + memcpy(buf+len, &value, sizeof(jlong)); + len += sizeof(jlong); + } + + + void putStringEvent(JNIEnv* env, jstring value) { + const char* strValue = env->GetStringUTFChars(value, NULL); + uint32_t strLen = strlen(strValue); //env->GetStringUTFLength(value); + bool succeeded = ensureExtraCapacity(1 + sizeof(uint32_t) + strLen); + buf[len++] = EVENT_TYPE_STRING; + memcpy(buf+len, &strLen, sizeof(uint32_t)); + len += sizeof(uint32_t); + memcpy(buf+len, strValue, strLen); + env->ReleaseStringUTFChars(value, strValue); + len += strLen; + } + + void putList(JNIEnv* env, jobject list) { + jobjectArray items = (jobjectArray) env->GetObjectField(list, gListItemsID); + if (items == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return; + } + + jsize numItems = env->GetArrayLength(items); + putByte(EVENT_TYPE_LIST); + putByte(numItems); + // We'd like to call GetPrimitveArrayCritical() but that might + // not be safe since we're going to be doing some I/O + for (int i = 0; i < numItems; i++) { + jobject item = env->GetObjectArrayElement(items, i); + if (env->IsInstanceOf(item, gIntegerClass)) { + jint intVal = env->GetIntField(item, gIntegerValueID); + putIntEvent(intVal); + } else if (env->IsInstanceOf(item, gLongClass)) { + jlong longVal = env->GetLongField(item, gLongValueID); + putLongEvent(longVal); + } else if (env->IsInstanceOf(item, gStringClass)) { + putStringEvent(env, (jstring)item); + } else if (env->IsInstanceOf(item, gListClass)) { + putList(env, item); + } else { + jniThrowException( + env, + "java/lang/IllegalArgumentException", + "Attempt to log an illegal item type."); + return; + } + env->DeleteLocalRef(item); + } + + env->DeleteLocalRef(items); + } +}; + +/* + * In class android.util.EventLog: + * static native int writeEvent(int tag, int value) + */ +static jint android_util_EventLog_writeEvent_Integer(JNIEnv* env, jobject clazz, + jint tag, jint value) +{ + return android_btWriteLog(tag, EVENT_TYPE_INT, &value, sizeof(value)); +} + +/* + * In class android.util.EventLog: + * static native int writeEvent(long tag, long value) + */ +static jint android_util_EventLog_writeEvent_Long(JNIEnv* env, jobject clazz, + jint tag, jlong value) +{ + return android_btWriteLog(tag, EVENT_TYPE_LONG, &value, sizeof(value)); +} + +/* + * In class android.util.EventLog: + * static native int writeEvent(long tag, List value) + */ +static jint android_util_EventLog_writeEvent_List(JNIEnv* env, jobject clazz, + jint tag, jobject value) { + if (value == NULL) { + jclass clazz = env->FindClass("java/lang/IllegalArgumentException"); + env->ThrowNew(clazz, "writeEvent needs a value."); + return -1; + } + ByteBuf byteBuf(INITAL_BUFFER_CAPACITY); + byteBuf.putList(env, value); + byteBuf.putByte((uint8_t)END_DELIMITER); + int numBytesPut = byteBuf.len; + int bytesWritten = android_bWriteLog(tag, byteBuf.buf, numBytesPut); + return bytesWritten; +} + +/* + * In class android.util.EventLog: + * static native int writeEvent(int tag, String value) + */ +static jint android_util_EventLog_writeEvent_String(JNIEnv* env, jobject clazz, + jint tag, jstring value) { + if (value == NULL) { + jclass clazz = env->FindClass("java/lang/IllegalArgumentException"); + env->ThrowNew(clazz, "logEvent needs a value."); + return -1; + } + + ByteBuf byteBuf(INITAL_BUFFER_CAPACITY); + byteBuf.putStringEvent(env, value); + byteBuf.putByte((uint8_t)END_DELIMITER); + int numBytesPut = byteBuf.len; + int bytesWritten = android_bWriteLog(tag, byteBuf.buf, numBytesPut); + return bytesWritten; +} + +/* + * In class android.util.EventLog: + * static native void readEvents(int[] tags, Collection<Event> output) + */ +static void android_util_EventLog_readEvents(JNIEnv* env, jobject clazz, + jintArray tags, + jobject out) { + if (tags == NULL || out == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return; + } + + int fd = open("/dev/" LOGGER_LOG_EVENTS, O_RDONLY | O_NONBLOCK); + if (fd < 0) { + jniThrowIOException(env, errno); + return; + } + + jsize tagLength = env->GetArrayLength(tags); + jint *tagValues = env->GetIntArrayElements(tags, NULL); + + uint8_t buf[LOGGER_ENTRY_MAX_LEN]; + for (;;) { + int len = read(fd, buf, sizeof(buf)); + if (len == 0 || (len < 0 && errno == EAGAIN)) { + break; + } else if (len < 0) { + // This calls env->ThrowNew(), which doesn't throw an exception + // now, but sets a flag to trigger an exception after we return. + jniThrowIOException(env, errno); + break; + } else if ((size_t) len < sizeof(logger_entry) + sizeof(int32_t)) { + jniThrowException(env, "java/io/IOException", "Event too short"); + break; + } + + logger_entry* entry = (logger_entry*) buf; + int32_t tag = * (int32_t*) (buf + sizeof(*entry)); + + int found = 0; + for (int i = 0; !found && i < tagLength; ++i) { + found = (tag == tagValues[i]); + } + + if (found) { + jsize len = sizeof(*entry) + entry->len; + jbyteArray array = env->NewByteArray(len); + if (array == NULL) break; + + jbyte *bytes = env->GetByteArrayElements(array, NULL); + memcpy(bytes, buf, len); + env->ReleaseByteArrayElements(array, bytes, 0); + + jobject event = env->NewObject(gEventClass, gEventInitID, array); + if (event == NULL) break; + + env->CallBooleanMethod(out, gCollectionAddID, event); + env->DeleteLocalRef(event); + env->DeleteLocalRef(array); + } + } + + close(fd); + env->ReleaseIntArrayElements(tags, tagValues, 0); +} + + +/* + * JNI registration. + */ +static JNINativeMethod gRegisterMethods[] = { + /* name, signature, funcPtr */ + { "writeEvent", "(II)I", (void*) android_util_EventLog_writeEvent_Integer }, + { "writeEvent", "(IJ)I", (void*) android_util_EventLog_writeEvent_Long }, + { "writeEvent", + "(ILjava/lang/String;)I", + (void*) android_util_EventLog_writeEvent_String + }, + { "writeEvent", + "(ILandroid/util/EventLog$List;)I", + (void*) android_util_EventLog_writeEvent_List + }, + { "readEvents", + "([ILjava/util/Collection;)V", + (void*) android_util_EventLog_readEvents + } +}; + +static struct { const char *name; jclass *clazz; } gClasses[] = { + { "android/util/EventLog$Event", &gEventClass }, + { "android/util/EventLog$List", &gListClass }, + { "java/lang/Integer", &gIntegerClass }, + { "java/lang/Long", &gLongClass }, + { "java/lang/String", &gStringClass }, + { "java/util/Collection", &gCollectionClass }, +}; + +static struct { jclass *c; const char *name, *ft; jfieldID *id; } gFields[] = { + { &gIntegerClass, "value", "I", &gIntegerValueID }, + { &gListClass, "mItems", "[Ljava/lang/Object;", &gListItemsID }, + { &gLongClass, "value", "J", &gLongValueID }, +}; + +static struct { jclass *c; const char *name, *mt; jmethodID *id; } gMethods[] = { + { &gEventClass, "<init>", "([B)V", &gEventInitID }, + { &gCollectionClass, "add", "(Ljava/lang/Object;)Z", &gCollectionAddID }, +}; + +int register_android_util_EventLog(JNIEnv* env) { + for (int i = 0; i < NELEM(gClasses); ++i) { + jclass clazz = env->FindClass(gClasses[i].name); + if (clazz == NULL) { + LOGE("Can't find class: %s\n", gClasses[i].name); + return -1; + } + *gClasses[i].clazz = (jclass) env->NewGlobalRef(clazz); + } + + for (int i = 0; i < NELEM(gFields); ++i) { + *gFields[i].id = env->GetFieldID( + *gFields[i].c, gFields[i].name, gFields[i].ft); + if (*gFields[i].id == NULL) { + LOGE("Can't find field: %s\n", gFields[i].name); + return -1; + } + } + + for (int i = 0; i < NELEM(gMethods); ++i) { + *gMethods[i].id = env->GetMethodID( + *gMethods[i].c, gMethods[i].name, gMethods[i].mt); + if (*gMethods[i].id == NULL) { + LOGE("Can't find method: %s\n", gMethods[i].name); + return -1; + } + } + + return AndroidRuntime::registerNativeMethods( + env, + "android/util/EventLog", + gRegisterMethods, NELEM(gRegisterMethods)); +} + +}; // namespace android + diff --git a/core/jni/android_util_FileObserver.cpp b/core/jni/android_util_FileObserver.cpp new file mode 100644 index 0000000..794478a --- /dev/null +++ b/core/jni/android_util_FileObserver.cpp @@ -0,0 +1,157 @@ +/* //device/libs/android_runtime/android_util_FileObserver.cpp +** +** Copyright 2006, 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. +*/ + +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" +#include "android_runtime/AndroidRuntime.h" + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <stdint.h> +#include <fcntl.h> +#include <sys/ioctl.h> +#include <errno.h> + +#ifdef HAVE_INOTIFY +#include <sys/inotify.h> +#endif + +namespace android { + +static jmethodID method_onEvent; + +static jint android_os_fileobserver_init(JNIEnv* env, jobject object) +{ +#ifdef HAVE_INOTIFY + + return (jint)inotify_init(); + +#else // HAVE_INOTIFY + + return -1; + +#endif // HAVE_INOTIFY +} + +static void android_os_fileobserver_observe(JNIEnv* env, jobject object, jint fd) +{ +#ifdef HAVE_INOTIFY + + char event_buf[512]; + struct inotify_event* event; + + while (1) + { + int event_pos = 0; + int num_bytes = read(fd, event_buf, sizeof(event_buf)); + + if (num_bytes < (int)sizeof(*event)) + { + if (errno == EINTR) + continue; + + LOGE("***** ERROR! android_os_fileobserver_observe() got a short event!"); + return; + } + + while (num_bytes >= (int)sizeof(*event)) + { + int event_size; + event = (struct inotify_event *)(event_buf + event_pos); + + jstring path = NULL; + + if (event->len > 0) + { + path = env->NewStringUTF(event->name); + } + + env->CallVoidMethod(object, method_onEvent, event->wd, event->mask, path); + + event_size = sizeof(*event) + event->len; + num_bytes -= event_size; + event_pos += event_size; + } + } + +#endif // HAVE_INOTIFY +} + +static jint android_os_fileobserver_startWatching(JNIEnv* env, jobject object, jint fd, jstring pathString, jint mask) +{ + int res = -1; + +#ifdef HAVE_INOTIFY + + if (fd >= 0) + { + const char* path = env->GetStringUTFChars(pathString, NULL); + + res = inotify_add_watch(fd, path, mask); + + env->ReleaseStringUTFChars(pathString, path); + } + +#endif // HAVE_INOTIFY + + return res; +} + +static void android_os_fileobserver_stopWatching(JNIEnv* env, jobject object, jint fd, jint wfd) +{ +#ifdef HAVE_INOTIFY + + inotify_rm_watch((int)fd, (uint32_t)wfd); + +#endif // HAVE_INOTIFY +} + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + { "init", "()I", (void*)android_os_fileobserver_init }, + { "observe", "(I)V", (void*)android_os_fileobserver_observe }, + { "startWatching", "(ILjava/lang/String;I)I", (void*)android_os_fileobserver_startWatching }, + { "stopWatching", "(II)V", (void*)android_os_fileobserver_stopWatching } + +}; + +int register_android_os_FileObserver(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass("android/os/FileObserver$ObserverThread"); + + if (clazz == NULL) + { + LOGE("Can't find android/os/FileObserver$ObserverThread"); + return -1; + } + + method_onEvent = env->GetMethodID(clazz, "onEvent", "(IILjava/lang/String;)V"); + if (method_onEvent == NULL) + { + LOGE("Can't find FileObserver.onEvent(int, int, String)"); + return -1; + } + + return AndroidRuntime::registerNativeMethods(env, "android/os/FileObserver$ObserverThread", sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/android_util_FloatMath.cpp b/core/jni/android_util_FloatMath.cpp new file mode 100644 index 0000000..f38faa9 --- /dev/null +++ b/core/jni/android_util_FloatMath.cpp @@ -0,0 +1,46 @@ +#include "jni.h" +#include <android_runtime/AndroidRuntime.h> +#include <math.h> +#include <float.h> +#include "SkTypes.h" + +class MathUtilsGlue { +public: + static float FloorF(JNIEnv* env, jobject clazz, float x) { + return floorf(x); + } + + static float CeilF(JNIEnv* env, jobject clazz, float x) { + return ceilf(x); + } + + static float SinF(JNIEnv* env, jobject clazz, float x) { + return sinf(x); + } + + static float CosF(JNIEnv* env, jobject clazz, float x) { + return cosf(x); + } + + static float SqrtF(JNIEnv* env, jobject clazz, float x) { + return sqrtf(x); + } +}; + +static JNINativeMethod gMathUtilsMethods[] = { + {"floor", "(F)F", (void*) MathUtilsGlue::FloorF}, + {"ceil", "(F)F", (void*) MathUtilsGlue::CeilF}, + {"sin", "(F)F", (void*) MathUtilsGlue::SinF}, + {"cos", "(F)F", (void*) MathUtilsGlue::CosF}, + {"sqrt", "(F)F", (void*) MathUtilsGlue::SqrtF} +}; + +int register_android_util_FloatMath(JNIEnv* env) +{ + int result = android::AndroidRuntime::registerNativeMethods(env, + "android/util/FloatMath", + gMathUtilsMethods, + SK_ARRAY_COUNT(gMathUtilsMethods)); + return result; +} + diff --git a/core/jni/android_util_Log.cpp b/core/jni/android_util_Log.cpp new file mode 100644 index 0000000..8316b03 --- /dev/null +++ b/core/jni/android_util_Log.cpp @@ -0,0 +1,161 @@ +/* //device/libs/android_runtime/android_util_Log.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_NAMESPACE "log.tag." +#define LOG_TAG "Log_println" + +#include <assert.h> +#include <cutils/properties.h> +#include <utils/Log.h> +#include <utils/String8.h> + +#include "jni.h" +#include "utils/misc.h" +#include "android_runtime/AndroidRuntime.h" + +#define MIN(a,b) ((a<b)?a:b) + +namespace android { + +struct levels_t { + jint verbose; + jint debug; + jint info; + jint warn; + jint error; + jint assert; +}; +static levels_t levels; + +static int toLevel(const char* value) +{ + switch (value[0]) { + case 'V': return levels.verbose; + case 'D': return levels.debug; + case 'I': return levels.info; + case 'W': return levels.warn; + case 'E': return levels.error; + case 'A': return levels.assert; + case 'S': return -1; // SUPPRESS + } + return levels.info; +} + +static jboolean android_util_Log_isLoggable(JNIEnv* env, jobject clazz, jstring tag, jint level) +{ +#ifndef HAVE_ANDROID_OS + return false; +#else /* HAVE_ANDROID_OS */ + int len; + char key[PROPERTY_KEY_MAX]; + char buf[PROPERTY_VALUE_MAX]; + + if (tag == NULL) { + return false; + } + + jboolean result = false; + + const char* chars = env->GetStringUTFChars(tag, NULL); + + if ((strlen(chars)+sizeof(LOG_NAMESPACE)) > PROPERTY_KEY_MAX) { + jclass clazz = env->FindClass("java/lang/IllegalArgumentException"); + char buf2[200]; + snprintf(buf2, sizeof(buf2), "Log tag \"%s\" exceeds limit of %d characters\n", + chars, PROPERTY_KEY_MAX - sizeof(LOG_NAMESPACE)); + + // release the chars! + env->ReleaseStringUTFChars(tag, chars); + + env->ThrowNew(clazz, buf2); + return false; + } else { + strncpy(key, LOG_NAMESPACE, sizeof(LOG_NAMESPACE)-1); + strcpy(key + sizeof(LOG_NAMESPACE) - 1, chars); + } + + env->ReleaseStringUTFChars(tag, chars); + + len = property_get(key, buf, ""); + int logLevel = toLevel(buf); + return (logLevel >= 0 && level >= logLevel) ? true : false; +#endif /* HAVE_ANDROID_OS */ +} + +/* + * In class android.util.Log: + * public static native int println(int priority, String tag, String msg) + */ +static jint android_util_Log_println(JNIEnv* env, jobject clazz, + jint priority, jstring tagObj, jstring msgObj) +{ + const char* tag = NULL; + const char* msg = NULL; + + if (msgObj == NULL) { + jclass npeClazz; + + npeClazz = env->FindClass("java/lang/NullPointerException"); + assert(npeClazz != NULL); + + env->ThrowNew(npeClazz, "println needs a message"); + return -1; + } + + if (tagObj != NULL) + tag = env->GetStringUTFChars(tagObj, NULL); + msg = env->GetStringUTFChars(msgObj, NULL); + + int res = android_writeLog((android_LogPriority) priority, tag, msg); + + if (tag != NULL) + env->ReleaseStringUTFChars(tagObj, tag); + env->ReleaseStringUTFChars(msgObj, msg); + + return res; +} + +/* + * JNI registration. + */ +static JNINativeMethod gMethods[] = { + /* name, signature, funcPtr */ + { "isLoggable", "(Ljava/lang/String;I)Z", (void*) android_util_Log_isLoggable }, + { "println", "(ILjava/lang/String;Ljava/lang/String;)I", (void*) android_util_Log_println }, +}; + +int register_android_util_Log(JNIEnv* env) +{ + jclass clazz = env->FindClass("android/util/Log"); + + if (clazz == NULL) { + LOGE("Can't find android/util/Log"); + return -1; + } + + levels.verbose = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "VERBOSE", "I")); + levels.debug = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "DEBUG", "I")); + levels.info = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "INFO", "I")); + levels.warn = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "WARN", "I")); + levels.error = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "ERROR", "I")); + levels.assert = env->GetStaticIntField(clazz, env->GetStaticFieldID(clazz, "ASSERT", "I")); + + return AndroidRuntime::registerNativeMethods(env, "android/util/Log", gMethods, NELEM(gMethods)); +} + +}; // namespace android + diff --git a/core/jni/android_util_Process.cpp b/core/jni/android_util_Process.cpp new file mode 100644 index 0000000..08c4f1c --- /dev/null +++ b/core/jni/android_util_Process.cpp @@ -0,0 +1,743 @@ +/* //device/libs/android_runtime/android_util_Process.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "Process" + +#include <utils/Log.h> +#include <utils/IPCThreadState.h> +#include <utils/ProcessState.h> +#include <utils/IServiceManager.h> +#include <utils/String8.h> +#include <utils/Vector.h> + +#include <android_runtime/AndroidRuntime.h> + +#include "android_util_Binder.h" +#include "JNIHelp.h" + +#include <sys/errno.h> +#include <sys/resource.h> +#include <sys/types.h> +#include <dirent.h> +#include <fcntl.h> +#include <grp.h> +#include <pwd.h> +#include <signal.h> + +/* desktop Linux needs a little help with gettid() */ +#if defined(HAVE_GETTID) && !defined(HAVE_ANDROID_OS) +#define __KERNEL__ +# include <linux/unistd.h> +#ifdef _syscall0 +_syscall0(pid_t,gettid) +#else +pid_t gettid() { return syscall(__NR_gettid);} +#endif +#undef __KERNEL__ +#endif + +using namespace android; + +static void signalExceptionForPriorityError(JNIEnv* env, jobject obj, int err) +{ + switch (err) { + case EINVAL: + jniThrowException(env, "java/lang/IllegalArgumentException", NULL); + break; + case ESRCH: + jniThrowException(env, "java/lang/IllegalArgumentException", "Given thread does not exist"); + break; + case EPERM: + jniThrowException(env, "java/lang/SecurityException", "No permission to modify given thread"); + break; + case EACCES: + jniThrowException(env, "java/lang/SecurityException", "No permission to set to given priority"); + break; + default: + jniThrowException(env, "java/lang/RuntimeException", "Unknown error"); + break; + } +} + +static void fakeProcessEntry(void* arg) +{ + String8* cls = (String8*)arg; + + AndroidRuntime* jr = AndroidRuntime::getRuntime(); + jr->callMain(cls->string(), 0, NULL); + + delete cls; +} + +jint android_os_Process_myPid(JNIEnv* env, jobject clazz) +{ + return getpid(); +} + +jint android_os_Process_myTid(JNIEnv* env, jobject clazz) +{ +#ifdef HAVE_GETTID + return gettid(); +#else + return getpid(); +#endif +} + +jint android_os_Process_getUidForName(JNIEnv* env, jobject clazz, jstring name) +{ + if (name == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return -1; + } + + const jchar* str16 = env->GetStringCritical(name, 0); + String8 name8; + if (str16) { + name8 = String8(str16, env->GetStringLength(name)); + env->ReleaseStringCritical(name, str16); + } + + const size_t N = name8.size(); + if (N > 0) { + const char* str = name8.string(); + for (size_t i=0; i<N; i++) { + if (str[i] < '0' || str[i] > '9') { + struct passwd* pwd = getpwnam(str); + if (pwd == NULL) { + return -1; + } + return pwd->pw_uid; + } + } + return atoi(str); + } + return -1; +} + +jint android_os_Process_getGidForName(JNIEnv* env, jobject clazz, jstring name) +{ + if (name == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return -1; + } + + const jchar* str16 = env->GetStringCritical(name, 0); + String8 name8; + if (str16) { + name8 = String8(str16, env->GetStringLength(name)); + env->ReleaseStringCritical(name, str16); + } + + const size_t N = name8.size(); + if (N > 0) { + const char* str = name8.string(); + for (size_t i=0; i<N; i++) { + if (str[i] < '0' || str[i] > '9') { + struct group* grp = getgrnam(str); + if (grp == NULL) { + return -1; + } + return grp->gr_gid; + } + } + return atoi(str); + } + return -1; +} + +void android_os_Process_setThreadPriority(JNIEnv* env, jobject clazz, + jint pid, jint pri) +{ + if (setpriority(PRIO_PROCESS, pid, pri) < 0) { + signalExceptionForPriorityError(env, clazz, errno); + } + //LOGI("Setting priority of %d: %d, getpriority returns %d\n", + // pid, pri, getpriority(PRIO_PROCESS, pid)); +} + +void android_os_Process_setCallingThreadPriority(JNIEnv* env, jobject clazz, + jint pri) +{ + jint tid = android_os_Process_myTid(env, clazz); + android_os_Process_setThreadPriority(env, clazz, tid, pri); +} + +jint android_os_Process_getThreadPriority(JNIEnv* env, jobject clazz, + jint pid) +{ + errno = 0; + jint pri = getpriority(PRIO_PROCESS, pid); + if (errno != 0) { + signalExceptionForPriorityError(env, clazz, errno); + } + //LOGI("Returning priority of %d: %d\n", pid, pri); + return pri; +} + +jboolean android_os_Process_setOomAdj(JNIEnv* env, jobject clazz, + jint pid, jint adj) +{ +#ifdef HAVE_OOM_ADJ + if (ProcessState::self()->supportsProcesses()) { + char text[64]; + sprintf(text, "/proc/%d/oom_adj", pid); + int fd = open(text, O_WRONLY); + if (fd >= 0) { + sprintf(text, "%d", adj); + write(fd, text, strlen(text)); + close(fd); + return true; + } + } +#endif + return false; +} + +void android_os_Process_setArgV0(JNIEnv* env, jobject clazz, jstring name) +{ + if (name == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return; + } + + const jchar* str = env->GetStringCritical(name, 0); + String8 name8; + if (str) { + name8 = String8(str, env->GetStringLength(name)); + env->ReleaseStringCritical(name, str); + } + + if (name8.size() > 0) { + ProcessState::self()->setArgV0(name8.string()); + } +} + +jint android_os_Process_setUid(JNIEnv* env, jobject clazz, jint uid) +{ + #if HAVE_ANDROID_OS + return setuid(uid) == 0 ? 0 : errno; + #else + return ENOSYS; + #endif +} + +jint android_os_Process_setGid(JNIEnv* env, jobject clazz, jint uid) +{ + #if HAVE_ANDROID_OS + return setgid(uid) == 0 ? 0 : errno; + #else + return ENOSYS; + #endif +} + +jboolean android_os_Process_supportsProcesses(JNIEnv* env, jobject clazz) +{ + return ProcessState::self()->supportsProcesses(); +} + +static int pid_compare(const void* v1, const void* v2) +{ + //LOGI("Compare %d vs %d\n", *((const jint*)v1), *((const jint*)v2)); + return *((const jint*)v1) - *((const jint*)v2); +} + +jint android_os_Process_getFreeMemory(JNIEnv* env, jobject clazz) +{ + int fd = open("/proc/meminfo", O_RDONLY); + + if (fd < 0) { + LOGW("Unable to open /proc/meminfo"); + return -1; + } + + char buffer[256]; + const int len = read(fd, buffer, sizeof(buffer)-1); + close(fd); + + if (len < 0) { + LOGW("Unable to read /proc/meminfo"); + return -1; + } + buffer[len] = 0; + + int numFound = 0; + int mem = 0; + + static const char* const sums[] = { "MemFree:", "Cached:", NULL }; + static const int sumsLen[] = { strlen("MemFree:"), strlen("Cached:"), NULL }; + + char* p = buffer; + while (*p && numFound < 2) { + int i = 0; + while (sums[i]) { + if (strncmp(p, sums[i], sumsLen[i]) == 0) { + p += sumsLen[i]; + while (*p == ' ') p++; + char* num = p; + while (*p >= '0' && *p <= '9') p++; + if (*p != 0) { + *p = 0; + p++; + if (*p == 0) p--; + } + mem += atoi(num) * 1024; + numFound++; + break; + } + i++; + } + p++; + } + + return numFound > 0 ? mem : -1; +} + +void android_os_Process_readProcLines(JNIEnv* env, jobject clazz, jstring fileStr, + jobjectArray reqFields, jlongArray outFields) +{ + //LOGI("getMemInfo: %p %p", reqFields, outFields); + + if (fileStr == NULL || reqFields == NULL || outFields == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return; + } + + const char* file8 = env->GetStringUTFChars(fileStr, NULL); + if (file8 == NULL) { + return; + } + String8 file(file8); + env->ReleaseStringUTFChars(fileStr, file8); + + jsize count = env->GetArrayLength(reqFields); + if (count > env->GetArrayLength(outFields)) { + jniThrowException(env, "java/lang/IllegalArgumentException", "Array lengths differ"); + return; + } + + Vector<String8> fields; + int i; + + for (i=0; i<count; i++) { + jobject obj = env->GetObjectArrayElement(reqFields, i); + if (obj != NULL) { + const char* str8 = env->GetStringUTFChars((jstring)obj, NULL); + //LOGI("String at %d: %p = %s", i, obj, str8); + if (str8 == NULL) { + jniThrowException(env, "java/lang/NullPointerException", "Element in reqFields"); + return; + } + fields.add(String8(str8)); + env->ReleaseStringUTFChars((jstring)obj, str8); + } else { + jniThrowException(env, "java/lang/NullPointerException", "Element in reqFields"); + return; + } + } + + jlong* sizesArray = env->GetLongArrayElements(outFields, 0); + if (sizesArray == NULL) { + return; + } + + //LOGI("Clearing %d sizes", count); + for (i=0; i<count; i++) { + sizesArray[i] = 0; + } + + int fd = open(file.string(), O_RDONLY); + + if (fd >= 0) { + const size_t BUFFER_SIZE = 2048; + char* buffer = (char*)malloc(BUFFER_SIZE); + int len = read(fd, buffer, BUFFER_SIZE-1); + close(fd); + + if (len < 0) { + LOGW("Unable to read %s", file.string()); + len = 0; + } + buffer[len] = 0; + + int foundCount = 0; + + char* p = buffer; + while (*p && foundCount < count) { + bool skipToEol = true; + //LOGI("Parsing at: %s", p); + for (i=0; i<count; i++) { + const String8& field = fields[i]; + if (strncmp(p, field.string(), field.length()) == 0) { + p += field.length(); + while (*p == ' ') p++; + char* num = p; + while (*p >= '0' && *p <= '9') p++; + skipToEol = *p != '\n'; + if (*p != 0) { + *p = 0; + p++; + } + char* end; + sizesArray[i] = strtoll(num, &end, 10); + //LOGI("Field %s = %d", field.string(), sizesArray[i]); + foundCount++; + break; + } + } + if (skipToEol) { + while (*p && *p != '\n') { + p++; + } + if (*p == '\n') { + p++; + } + } + } + + free(buffer); + } else { + LOGW("Unable to open %s", file.string()); + } + + //LOGI("Done!"); + env->ReleaseLongArrayElements(outFields, sizesArray, 0); +} + +jintArray android_os_Process_getPids(JNIEnv* env, jobject clazz, + jstring file, jintArray lastArray) +{ + if (file == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return NULL; + } + + const char* file8 = env->GetStringUTFChars(file, NULL); + if (file8 == NULL) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + return NULL; + } + + DIR* dirp = opendir(file8); + + env->ReleaseStringUTFChars(file, file8); + + if(dirp == NULL) { + return NULL; + } + + jsize curCount = 0; + jint* curData = NULL; + if (lastArray != NULL) { + curCount = env->GetArrayLength(lastArray); + curData = env->GetIntArrayElements(lastArray, 0); + } + + jint curPos = 0; + + struct dirent* entry; + while ((entry=readdir(dirp)) != NULL) { + const char* p = entry->d_name; + while (*p) { + if (*p < '0' || *p > '9') break; + p++; + } + if (*p != 0) continue; + + char* end; + int pid = strtol(entry->d_name, &end, 10); + //LOGI("File %s pid=%d\n", entry->d_name, pid); + if (curPos >= curCount) { + jsize newCount = (curCount == 0) ? 10 : (curCount*2); + jintArray newArray = env->NewIntArray(newCount); + if (newArray == NULL) { + closedir(dirp); + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + return NULL; + } + jint* newData = env->GetIntArrayElements(newArray, 0); + if (curData != NULL) { + memcpy(newData, curData, sizeof(jint)*curCount); + env->ReleaseIntArrayElements(lastArray, curData, 0); + } + lastArray = newArray; + curCount = newCount; + curData = newData; + } + + curData[curPos] = pid; + curPos++; + } + + closedir(dirp); + + if (curData != NULL && curPos > 0) { + qsort(curData, curPos, sizeof(jint), pid_compare); + } + + while (curPos < curCount) { + curData[curPos] = -1; + curPos++; + } + + if (curData != NULL) { + env->ReleaseIntArrayElements(lastArray, curData, 0); + } + + return lastArray; +} + +enum { + PROC_TERM_MASK = 0xff, + PROC_ZERO_TERM = 0, + PROC_SPACE_TERM = ' ', + PROC_COMBINE = 0x100, + PROC_PARENS = 0x200, + PROC_OUT_STRING = 0x1000, + PROC_OUT_LONG = 0x2000, + PROC_OUT_FLOAT = 0x4000, +}; + +jboolean android_os_Process_readProcFile(JNIEnv* env, jobject clazz, + jstring file, jintArray format, jobjectArray outStrings, + jlongArray outLongs, jfloatArray outFloats) +{ + if (file == NULL || format == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return JNI_FALSE; + } + + const char* file8 = env->GetStringUTFChars(file, NULL); + if (file8 == NULL) { + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + return JNI_FALSE; + } + int fd = open(file8, O_RDONLY); + env->ReleaseStringUTFChars(file, file8); + + if (fd < 0) { + //LOGW("Unable to open process file: %s\n", file8); + return JNI_FALSE; + } + + char buffer[256]; + const int len = read(fd, buffer, sizeof(buffer)-1); + close(fd); + + if (len < 0) { + //LOGW("Unable to open process file: %s fd=%d\n", file8, fd); + return JNI_FALSE; + } + buffer[len] = 0; + + //LOGI("Process file %s: %s\n", file8, buffer); + + const jsize NF = env->GetArrayLength(format); + const jsize NS = outStrings ? env->GetArrayLength(outStrings) : 0; + const jsize NL = outLongs ? env->GetArrayLength(outLongs) : 0; + const jsize NR = outFloats ? env->GetArrayLength(outFloats) : 0; + + jint* formatData = env->GetIntArrayElements(format, 0); + jlong* longsData = outLongs ? + env->GetLongArrayElements(outLongs, 0) : NULL; + jfloat* floatsData = outFloats ? + env->GetFloatArrayElements(outFloats, 0) : NULL; + if (formatData == NULL || (NL > 0 && longsData == NULL) + || (NR > 0 && floatsData == NULL)) { + if (formatData != NULL) { + env->ReleaseIntArrayElements(format, formatData, 0); + } + if (longsData != NULL) { + env->ReleaseLongArrayElements(outLongs, longsData, 0); + } + if (floatsData != NULL) { + env->ReleaseFloatArrayElements(outFloats, floatsData, 0); + } + jniThrowException(env, "java/lang/OutOfMemoryError", NULL); + return JNI_FALSE; + } + + jsize i = 0; + jsize di = 0; + + jboolean res = JNI_TRUE; + + for (jsize fi=0; fi<NF; fi++) { + const jint mode = formatData[fi]; + if ((mode&PROC_PARENS) != 0) { + i++; + } + const char term = (char)(mode&PROC_TERM_MASK); + const jsize start = i; + if (i >= len) { + res = JNI_FALSE; + break; + } + + jsize end = -1; + if ((mode&PROC_PARENS) != 0) { + while (buffer[i] != ')' && i < len) { + i++; + } + end = i; + i++; + } + while (buffer[i] != term && i < len) { + i++; + } + if (end < 0) { + end = i; + } + + if (i < len) { + i++; + if ((mode&PROC_COMBINE) != 0) { + while (buffer[i] == term && i < len) { + i++; + } + } + } + + //LOGI("Field %d: %d-%d dest=%d mode=0x%x\n", i, start, end, di, mode); + + if ((mode&(PROC_OUT_FLOAT|PROC_OUT_LONG|PROC_OUT_STRING)) != 0) { + char c = buffer[end]; + buffer[end] = 0; + if ((mode&PROC_OUT_FLOAT) != 0 && di < NR) { + char* end; + floatsData[di] = strtof(buffer+start, &end); + } + if ((mode&PROC_OUT_LONG) != 0 && di < NL) { + char* end; + longsData[di] = strtoll(buffer+start, &end, 10); + } + if ((mode&PROC_OUT_STRING) != 0 && di < NS) { + jstring str = env->NewStringUTF(buffer+start); + env->SetObjectArrayElement(outStrings, di, str); + } + buffer[end] = c; + di++; + } + } + + env->ReleaseIntArrayElements(format, formatData, 0); + if (longsData != NULL) { + env->ReleaseLongArrayElements(outLongs, longsData, 0); + } + if (floatsData != NULL) { + env->ReleaseFloatArrayElements(outFloats, floatsData, 0); + } + + return res; +} + +void android_os_Process_setApplicationObject(JNIEnv* env, jobject clazz, + jobject binderObject) +{ + if (binderObject == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return; + } + + sp<IBinder> binder = ibinderForJavaObject(env, binderObject); +} + +void android_os_Process_sendSignal(JNIEnv* env, jobject clazz, jint pid, jint sig) +{ + if (pid > 0) { + LOGI("Sending signal. PID: %d SIG: %d", pid, sig); + kill(pid, sig); + } +} + +static jlong android_os_Process_getElapsedCpuTime(JNIEnv* env, jobject clazz) +{ + struct timespec ts; + + int res = clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &ts); + + if (res != 0) { + return (jlong) 0; + } + + nsecs_t when = seconds_to_nanoseconds(ts.tv_sec) + ts.tv_nsec; + return (jlong) nanoseconds_to_milliseconds(when); +} + +static jlong android_os_Process_getPss(JNIEnv* env, jobject clazz, jint pid) +{ + char filename[64]; + + snprintf(filename, sizeof(filename), "/proc/%d/smaps", pid); + + FILE * file = fopen(filename, "r"); + if (!file) { + return (jlong) -1; + } + + // Tally up all of the Pss from the various maps + char line[256]; + jlong pss = 0; + while (fgets(line, sizeof(line), file)) { + jlong v; + if (sscanf(line, "Pss: %lld kB", &v) == 1) { + pss += v; + } + } + + fclose(file); + + // Return the Pss value in bytes, not kilobytes + return pss * 1024; +} + +static const JNINativeMethod methods[] = { + {"myPid", "()I", (void*)android_os_Process_myPid}, + {"myTid", "()I", (void*)android_os_Process_myTid}, + {"getUidForName", "(Ljava/lang/String;)I", (void*)android_os_Process_getUidForName}, + {"getGidForName", "(Ljava/lang/String;)I", (void*)android_os_Process_getGidForName}, + {"setThreadPriority", "(II)V", (void*)android_os_Process_setThreadPriority}, + {"setThreadPriority", "(I)V", (void*)android_os_Process_setCallingThreadPriority}, + {"getThreadPriority", "(I)I", (void*)android_os_Process_getThreadPriority}, + {"setOomAdj", "(II)Z", (void*)android_os_Process_setOomAdj}, + {"setArgV0", "(Ljava/lang/String;)V", (void*)android_os_Process_setArgV0}, + {"setUid", "(I)I", (void*)android_os_Process_setUid}, + {"setGid", "(I)I", (void*)android_os_Process_setGid}, + {"sendSignal", "(II)V", (void*)android_os_Process_sendSignal}, + {"supportsProcesses", "()Z", (void*)android_os_Process_supportsProcesses}, + {"getFreeMemory", "()I", (void*)android_os_Process_getFreeMemory}, + {"readProcLines", "(Ljava/lang/String;[Ljava/lang/String;[J)V", (void*)android_os_Process_readProcLines}, + {"getPids", "(Ljava/lang/String;[I)[I", (void*)android_os_Process_getPids}, + {"readProcFile", "(Ljava/lang/String;[I[Ljava/lang/String;[J[F)Z", (void*)android_os_Process_readProcFile}, + {"getElapsedCpuTime", "()J", (void*)android_os_Process_getElapsedCpuTime}, + {"getPss", "(I)J", (void*)android_os_Process_getPss}, + //{"setApplicationObject", "(Landroid/os/IBinder;)V", (void*)android_os_Process_setApplicationObject}, +}; + +const char* const kProcessPathName = "android/os/Process"; + +int register_android_os_Process(JNIEnv* env) +{ + jclass clazz; + + clazz = env->FindClass(kProcessPathName); + LOG_FATAL_IF(clazz == NULL, "Unable to find class android.os.Process"); + + return AndroidRuntime::registerNativeMethods( + env, kProcessPathName, + methods, NELEM(methods)); +} + diff --git a/core/jni/android_util_StringBlock.cpp b/core/jni/android_util_StringBlock.cpp new file mode 100644 index 0000000..ffb271c --- /dev/null +++ b/core/jni/android_util_StringBlock.cpp @@ -0,0 +1,204 @@ +/* //device/libs/android_runtime/android_util_StringBlock.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "StringBlock" + +#include "jni.h" +#include <utils/misc.h> +#include <android_runtime/AndroidRuntime.h> +#include <utils/Log.h> + +#include <utils/ResourceTypes.h> + +#include <stdio.h> + +namespace android { + +// ---------------------------------------------------------------------------- + +static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL) +{ + jclass npeClazz; + + npeClazz = env->FindClass(exc); + LOG_FATAL_IF(npeClazz == NULL, "Unable to find class %s", exc); + + env->ThrowNew(npeClazz, msg); +} + +static jint android_content_StringBlock_nativeCreate(JNIEnv* env, jobject clazz, + jbyteArray bArray, + jint off, jint len) +{ + if (bArray == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + jsize bLen = env->GetArrayLength(bArray); + if (off < 0 || off >= bLen || len < 0 || len > bLen || (off+len) > bLen) { + doThrow(env, "java/lang/IndexOutOfBoundsException"); + return 0; + } + + jbyte* b = env->GetByteArrayElements(bArray, NULL); + ResStringPool* osb = new ResStringPool(b+off, len, true); + env->ReleaseByteArrayElements(bArray, b, 0); + + if (osb == NULL || osb->getError() != NO_ERROR) { + doThrow(env, "java/lang/IllegalArgumentException"); + return 0; + } + + return (jint)osb; +} + +static jint android_content_StringBlock_nativeGetSize(JNIEnv* env, jobject clazz, + jint token) +{ + ResStringPool* osb = (ResStringPool*)token; + if (osb == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return osb->size(); +} + +static jstring android_content_StringBlock_nativeGetString(JNIEnv* env, jobject clazz, + jint token, jint idx) +{ + ResStringPool* osb = (ResStringPool*)token; + if (osb == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + size_t len; + const char16_t* str = osb->stringAt(idx, &len); + if (str == NULL) { + doThrow(env, "java/lang/IndexOutOfBoundsException"); + return 0; + } + + return env->NewString((const jchar*)str, len); +} + +static jintArray android_content_StringBlock_nativeGetStyle(JNIEnv* env, jobject clazz, + jint token, jint idx) +{ + ResStringPool* osb = (ResStringPool*)token; + if (osb == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return NULL; + } + + const ResStringPool_span* spans = osb->styleAt(idx); + if (spans == NULL) { + return NULL; + } + + const ResStringPool_span* pos = spans; + int num = 0; + while (pos->name.index != ResStringPool_span::END) { + num++; + pos++; + } + + if (num == 0) { + return NULL; + } + + jintArray array = env->NewIntArray((num*sizeof(ResStringPool_span))/sizeof(jint)); + if (array == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + return NULL; + } + + num = 0; + static const int numInts = sizeof(ResStringPool_span)/sizeof(jint); + while (spans->name.index != ResStringPool_span::END) { + env->SetIntArrayRegion(array, + num*numInts, numInts, + (jint*)spans); + spans++; + num++; + } + + return array; +} + +static jint android_content_StringBlock_nativeIndexOfString(JNIEnv* env, jobject clazz, + jint token, jstring str) +{ + ResStringPool* osb = (ResStringPool*)token; + if (osb == NULL || str == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + const char16_t* str16 = env->GetStringChars(str, NULL); + jsize strLen = env->GetStringLength(str); + + ssize_t idx = osb->indexOfString(str16, strLen); + + env->ReleaseStringChars(str, str16); + + return idx; +} + +static void android_content_StringBlock_nativeDestroy(JNIEnv* env, jobject clazz, + jint token) +{ + ResStringPool* osb = (ResStringPool*)token; + if (osb == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return; + } + + delete osb; +} + +// ---------------------------------------------------------------------------- + +/* + * JNI registration. + */ +static JNINativeMethod gStringBlockMethods[] = { + /* name, signature, funcPtr */ + { "nativeCreate", "([BII)I", + (void*) android_content_StringBlock_nativeCreate }, + { "nativeGetSize", "(I)I", + (void*) android_content_StringBlock_nativeGetSize }, + { "nativeGetString", "(II)Ljava/lang/String;", + (void*) android_content_StringBlock_nativeGetString }, + { "nativeGetStyle", "(II)[I", + (void*) android_content_StringBlock_nativeGetStyle }, + { "nativeIndexOfString","(ILjava/lang/String;)I", + (void*) android_content_StringBlock_nativeIndexOfString }, + { "nativeDestroy", "(I)V", + (void*) android_content_StringBlock_nativeDestroy }, +}; + +int register_android_content_StringBlock(JNIEnv* env) +{ + return AndroidRuntime::registerNativeMethods(env, + "android/content/res/StringBlock", gStringBlockMethods, NELEM(gStringBlockMethods)); +} + +}; // namespace android + diff --git a/core/jni/android_util_XmlBlock.cpp b/core/jni/android_util_XmlBlock.cpp new file mode 100644 index 0000000..8887fdc --- /dev/null +++ b/core/jni/android_util_XmlBlock.cpp @@ -0,0 +1,426 @@ +/* //device/libs/android_runtime/android_util_XmlBlock.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "XmlBlock" + +#include "jni.h" +#include <utils/misc.h> +#include <android_runtime/AndroidRuntime.h> +#include <utils/AssetManager.h> +#include <utils/Log.h> + +#include <utils/ResourceTypes.h> + +#include <stdio.h> + +namespace android { + +// ---------------------------------------------------------------------------- + +static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL) +{ + jclass npeClazz; + + npeClazz = env->FindClass(exc); + LOG_FATAL_IF(npeClazz == NULL, "Unable to find class %s", exc); + + env->ThrowNew(npeClazz, msg); +} + +static jint android_content_XmlBlock_nativeCreate(JNIEnv* env, jobject clazz, + jbyteArray bArray, + jint off, jint len) +{ + if (bArray == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + jsize bLen = env->GetArrayLength(bArray); + if (off < 0 || off >= bLen || len < 0 || len > bLen || (off+len) > bLen) { + doThrow(env, "java/lang/IndexOutOfBoundsException"); + return 0; + } + + jbyte* b = env->GetByteArrayElements(bArray, NULL); + ResXMLTree* osb = new ResXMLTree(b+off, len, true); + env->ReleaseByteArrayElements(bArray, b, 0); + + if (osb == NULL || osb->getError() != NO_ERROR) { + doThrow(env, "java/lang/IllegalArgumentException"); + return 0; + } + + return (jint)osb; +} + +static jint android_content_XmlBlock_nativeGetStringBlock(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLTree* osb = (ResXMLTree*)token; + if (osb == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return (jint)&osb->getStrings(); +} + +static jint android_content_XmlBlock_nativeCreateParseState(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLTree* osb = (ResXMLTree*)token; + if (osb == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + ResXMLParser* st = new ResXMLParser(*osb); + if (st == NULL) { + doThrow(env, "java/lang/OutOfMemoryError"); + return 0; + } + + st->restart(); + + return (jint)st; +} + +static jint android_content_XmlBlock_nativeNext(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + return ResXMLParser::END_DOCUMENT; + } + + do { + jint code = (jint)st->next(); + switch (code) { + case ResXMLParser::START_TAG: + return 2; + case ResXMLParser::END_TAG: + return 3; + case ResXMLParser::TEXT: + return 4; + case ResXMLParser::START_DOCUMENT: + return 0; + case ResXMLParser::END_DOCUMENT: + return 1; + case ResXMLParser::BAD_DOCUMENT: + goto bad; + } + } while (true); + +bad: + doThrow(env, "org/xmlpull/v1/XmlPullParserException", + "Corrupt XML binary file"); + return ResXMLParser::BAD_DOCUMENT; +} + +static jint android_content_XmlBlock_nativeGetNamespace(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + return -1; + } + + return (jint)st->getElementNamespaceID(); +} + +static jint android_content_XmlBlock_nativeGetName(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + return -1; + } + + return (jint)st->getElementNameID(); +} + +static jint android_content_XmlBlock_nativeGetText(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + return -1; + } + + return (jint)st->getTextID(); +} + +static jint android_content_XmlBlock_nativeGetLineNumber(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return (jint)st->getLineNumber(); +} + +static jint android_content_XmlBlock_nativeGetAttributeCount(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return (jint)st->getAttributeCount(); +} + +static jint android_content_XmlBlock_nativeGetAttributeNamespace(JNIEnv* env, jobject clazz, + jint token, jint idx) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return (jint)st->getAttributeNamespaceID(idx); +} + +static jint android_content_XmlBlock_nativeGetAttributeName(JNIEnv* env, jobject clazz, + jint token, jint idx) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return (jint)st->getAttributeNameID(idx); +} + +static jint android_content_XmlBlock_nativeGetAttributeResource(JNIEnv* env, jobject clazz, + jint token, jint idx) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return (jint)st->getAttributeNameResID(idx); +} + +static jint android_content_XmlBlock_nativeGetAttributeDataType(JNIEnv* env, jobject clazz, + jint token, jint idx) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return (jint)st->getAttributeDataType(idx); +} + +static jint android_content_XmlBlock_nativeGetAttributeData(JNIEnv* env, jobject clazz, + jint token, jint idx) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return (jint)st->getAttributeData(idx); +} + +static jint android_content_XmlBlock_nativeGetAttributeStringValue(JNIEnv* env, jobject clazz, + jint token, jint idx) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + return (jint)st->getAttributeValueStringID(idx); +} + +static jint android_content_XmlBlock_nativeGetAttributeIndex(JNIEnv* env, jobject clazz, + jint token, + jstring ns, jstring name) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL || name == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + const char16_t* ns16 = NULL; + jsize nsLen = 0; + if (ns) { + ns16 = env->GetStringChars(ns, NULL); + nsLen = env->GetStringLength(ns); + } + + const char16_t* name16 = env->GetStringChars(name, NULL); + jsize nameLen = env->GetStringLength(name); + + jint idx = (jint)st->indexOfAttribute(ns16, nsLen, name16, nameLen); + + if (ns) { + env->ReleaseStringChars(ns, ns16); + } + env->ReleaseStringChars(name, name16); + + return idx; +} + +static jint android_content_XmlBlock_nativeGetIdAttribute(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + ssize_t idx = st->indexOfID(); + return idx >= 0 ? (jint)st->getAttributeValueStringID(idx) : -1; +} + +static jint android_content_XmlBlock_nativeGetClassAttribute(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + ssize_t idx = st->indexOfClass(); + return idx >= 0 ? (jint)st->getAttributeValueStringID(idx) : -1; +} + +static jint android_content_XmlBlock_nativeGetStyleAttribute(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return 0; + } + + ssize_t idx = st->indexOfStyle(); + if (idx < 0) { + return 0; + } + + Res_value value; + if (st->getAttributeValue(idx, &value) < 0) { + return 0; + } + + return value.dataType == value.TYPE_REFERENCE + || value.dataType == value.TYPE_ATTRIBUTE + ? value.data : 0; +} + +static void android_content_XmlBlock_nativeDestroyParseState(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLParser* st = (ResXMLParser*)token; + if (st == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return; + } + + delete st; +} + +static void android_content_XmlBlock_nativeDestroy(JNIEnv* env, jobject clazz, + jint token) +{ + ResXMLTree* osb = (ResXMLTree*)token; + if (osb == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return; + } + + delete osb; +} + +// ---------------------------------------------------------------------------- + +/* + * JNI registration. + */ +static JNINativeMethod gXmlBlockMethods[] = { + /* name, signature, funcPtr */ + { "nativeCreate", "([BII)I", + (void*) android_content_XmlBlock_nativeCreate }, + { "nativeGetStringBlock", "(I)I", + (void*) android_content_XmlBlock_nativeGetStringBlock }, + { "nativeCreateParseState", "(I)I", + (void*) android_content_XmlBlock_nativeCreateParseState }, + { "nativeNext", "(I)I", + (void*) android_content_XmlBlock_nativeNext }, + { "nativeGetNamespace", "(I)I", + (void*) android_content_XmlBlock_nativeGetNamespace }, + { "nativeGetName", "(I)I", + (void*) android_content_XmlBlock_nativeGetName }, + { "nativeGetText", "(I)I", + (void*) android_content_XmlBlock_nativeGetText }, + { "nativeGetLineNumber", "(I)I", + (void*) android_content_XmlBlock_nativeGetLineNumber }, + { "nativeGetAttributeCount", "(I)I", + (void*) android_content_XmlBlock_nativeGetAttributeCount }, + { "nativeGetAttributeNamespace","(II)I", + (void*) android_content_XmlBlock_nativeGetAttributeNamespace }, + { "nativeGetAttributeName", "(II)I", + (void*) android_content_XmlBlock_nativeGetAttributeName }, + { "nativeGetAttributeResource", "(II)I", + (void*) android_content_XmlBlock_nativeGetAttributeResource }, + { "nativeGetAttributeDataType", "(II)I", + (void*) android_content_XmlBlock_nativeGetAttributeDataType }, + { "nativeGetAttributeData", "(II)I", + (void*) android_content_XmlBlock_nativeGetAttributeData }, + { "nativeGetAttributeStringValue", "(II)I", + (void*) android_content_XmlBlock_nativeGetAttributeStringValue }, + { "nativeGetAttributeIndex", "(ILjava/lang/String;Ljava/lang/String;)I", + (void*) android_content_XmlBlock_nativeGetAttributeIndex }, + { "nativeGetIdAttribute", "(I)I", + (void*) android_content_XmlBlock_nativeGetIdAttribute }, + { "nativeGetClassAttribute", "(I)I", + (void*) android_content_XmlBlock_nativeGetClassAttribute }, + { "nativeGetStyleAttribute", "(I)I", + (void*) android_content_XmlBlock_nativeGetStyleAttribute }, + { "nativeDestroyParseState", "(I)V", + (void*) android_content_XmlBlock_nativeDestroyParseState }, + { "nativeDestroy", "(I)V", + (void*) android_content_XmlBlock_nativeDestroy }, +}; + +int register_android_content_XmlBlock(JNIEnv* env) +{ + return AndroidRuntime::registerNativeMethods(env, + "android/content/res/XmlBlock", gXmlBlockMethods, NELEM(gXmlBlockMethods)); +} + +}; // namespace android + diff --git a/core/jni/android_view_Display.cpp b/core/jni/android_view_Display.cpp new file mode 100644 index 0000000..bb7b5ef --- /dev/null +++ b/core/jni/android_view_Display.cpp @@ -0,0 +1,133 @@ +/* + * Copyright (C) 2007 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. + */ + +#include <stdio.h> +#include <assert.h> + +#include <ui/SurfaceComposerClient.h> +#include <ui/PixelFormat.h> +#include <ui/DisplayInfo.h> + +#include "jni.h" +#include <android_runtime/AndroidRuntime.h> +#include <utils/misc.h> + +// ---------------------------------------------------------------------------- + +namespace android { + +// ---------------------------------------------------------------------------- + +struct offsets_t { + jfieldID display; + jfieldID pixelFormat; + jfieldID fps; + jfieldID density; + jfieldID xdpi; + jfieldID ydpi; +}; +static offsets_t offsets; + +static void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL) +{ + jclass npeClazz = env->FindClass(exc); + env->ThrowNew(npeClazz, msg); +} + +// ---------------------------------------------------------------------------- + +static void android_view_Display_init( + JNIEnv* env, jobject clazz, jint dpy) +{ + DisplayInfo info; + status_t err = SurfaceComposerClient::getDisplayInfo(DisplayID(dpy), &info); + if (err < 0) { + doThrow(env, "java/lang/IllegalArgumentException"); + return; + } + env->SetIntField(clazz, offsets.pixelFormat,info.pixelFormatInfo.format); + env->SetFloatField(clazz, offsets.fps, info.fps); + env->SetFloatField(clazz, offsets.density, info.density); + env->SetFloatField(clazz, offsets.xdpi, info.xdpi); + env->SetFloatField(clazz, offsets.ydpi, info.ydpi); +} + +static jint android_view_Display_getWidth( + JNIEnv* env, jobject clazz) +{ + DisplayID dpy = env->GetIntField(clazz, offsets.display); + return SurfaceComposerClient::getDisplayWidth(dpy); +} + +static jint android_view_Display_getHeight( + JNIEnv* env, jobject clazz) +{ + DisplayID dpy = env->GetIntField(clazz, offsets.display); + return SurfaceComposerClient::getDisplayHeight(dpy); +} + +static jint android_view_Display_getOrientation( + JNIEnv* env, jobject clazz) +{ + DisplayID dpy = env->GetIntField(clazz, offsets.display); + return SurfaceComposerClient::getDisplayOrientation(dpy); +} + +static jint android_view_Display_getDisplayCount( + JNIEnv* env, jclass clazz) +{ + return SurfaceComposerClient::getNumberOfDisplays(); +} + +// ---------------------------------------------------------------------------- + +const char* const kClassPathName = "android/view/Display"; + +static void nativeClassInit(JNIEnv* env, jclass clazz); + +static JNINativeMethod gMethods[] = { + { "nativeClassInit", "()V", + (void*)nativeClassInit }, + { "getDisplayCount", "()I", + (void*)android_view_Display_getDisplayCount }, + { "init", "(I)V", + (void*)android_view_Display_init }, + { "getWidth", "()I", + (void*)android_view_Display_getWidth }, + { "getHeight", "()I", + (void*)android_view_Display_getHeight }, + { "getOrientation", "()I", + (void*)android_view_Display_getOrientation } +}; + +void nativeClassInit(JNIEnv* env, jclass clazz) +{ + offsets.display = env->GetFieldID(clazz, "mDisplay", "I"); + offsets.pixelFormat = env->GetFieldID(clazz, "mPixelFormat", "I"); + offsets.fps = env->GetFieldID(clazz, "mRefreshRate", "F"); + offsets.density = env->GetFieldID(clazz, "mDensity", "F"); + offsets.xdpi = env->GetFieldID(clazz, "mDpiX", "F"); + offsets.ydpi = env->GetFieldID(clazz, "mDpiY", "F"); +} + +int register_android_view_Display(JNIEnv* env) +{ + return AndroidRuntime::registerNativeMethods(env, + kClassPathName, gMethods, NELEM(gMethods)); +} + +}; + diff --git a/core/jni/android_view_Surface.cpp b/core/jni/android_view_Surface.cpp new file mode 100644 index 0000000..f09bd4c --- /dev/null +++ b/core/jni/android_view_Surface.cpp @@ -0,0 +1,619 @@ +/* + * Copyright (C) 2007 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. + */ + +#include <stdio.h> + +#include "android_util_Binder.h" + +#include <ui/SurfaceComposerClient.h> +#include <ui/Region.h> +#include <ui/Rect.h> + +#include <SkCanvas.h> +#include <SkBitmap.h> + +#include "jni.h" +#include <android_runtime/AndroidRuntime.h> +#include <utils/misc.h> + + +// ---------------------------------------------------------------------------- + +namespace android { + +// ---------------------------------------------------------------------------- + +static const char* const OutOfResourcesException = + "android/view/Surface$OutOfResourcesException"; + +struct sso_t { + jfieldID client; +}; +static sso_t sso; + +struct so_t { + jfieldID surface; + jfieldID saveCount; + jfieldID canvas; +}; +static so_t so; + +struct ro_t { + jfieldID l; + jfieldID t; + jfieldID r; + jfieldID b; +}; +static ro_t ro; + +struct po_t { + jfieldID x; + jfieldID y; +}; +static po_t po; + +struct co_t { + jfieldID surfaceFormat; +}; +static co_t co; + +struct no_t { + jfieldID native_canvas; + jfieldID native_region; + jfieldID native_parcel; +}; +static no_t no; + + +static __attribute__((noinline)) +void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL) +{ + if (!env->ExceptionOccurred()) { + jclass npeClazz = env->FindClass(exc); + env->ThrowNew(npeClazz, msg); + } +} + +// ---------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- + +static void SurfaceSession_init(JNIEnv* env, jobject clazz) +{ + sp<SurfaceComposerClient> client = new SurfaceComposerClient; + client->incStrong(clazz); + env->SetIntField(clazz, sso.client, (int)client.get()); +} + +static void SurfaceSession_destroy(JNIEnv* env, jobject clazz) +{ + SurfaceComposerClient* client = + (SurfaceComposerClient*)env->GetIntField(clazz, sso.client); + if (client != 0) { + client->decStrong(clazz); + env->SetIntField(clazz, sso.client, 0); + } +} + +static void SurfaceSession_kill(JNIEnv* env, jobject clazz) +{ + SurfaceComposerClient* client = + (SurfaceComposerClient*)env->GetIntField(clazz, sso.client); + if (client != 0) { + client->dispose(); + client->decStrong(clazz); + env->SetIntField(clazz, sso.client, 0); + } +} + +// ---------------------------------------------------------------------------- + +static sp<Surface> getSurface(JNIEnv* env, jobject clazz) +{ + Surface* const p = (Surface*)env->GetIntField(clazz, so.surface); + return sp<Surface>(p); +} + +static void setSurface(JNIEnv* env, jobject clazz, const sp<Surface>& surface) +{ + Surface* const p = (Surface*)env->GetIntField(clazz, so.surface); + if (surface.get()) { + surface->incStrong(clazz); + } + if (p) { + p->decStrong(clazz); + } + env->SetIntField(clazz, so.surface, (int)surface.get()); +} + +// ---------------------------------------------------------------------------- + +static void Surface_init( + JNIEnv* env, jobject clazz, + jobject session, jint pid, jint dpy, jint w, jint h, jint format, jint flags) +{ + if (session == NULL) { + doThrow(env, "java/lang/NullPointerException"); + return; + } + + SurfaceComposerClient* client = + (SurfaceComposerClient*)env->GetIntField(session, sso.client); + + sp<Surface> surface(client->createSurface(pid, dpy, w, h, format, flags)); + if (surface == 0) { + doThrow(env, OutOfResourcesException); + return; + } + setSurface(env, clazz, surface); +} + +static void Surface_initParcel(JNIEnv* env, jobject clazz, jobject argParcel) +{ + Parcel* parcel = (Parcel*)env->GetIntField(argParcel, no.native_parcel); + if (parcel == NULL) { + doThrow(env, "java/lang/NullPointerException", NULL); + return; + } + const sp<Surface>& rhs = Surface::readFromParcel(parcel); + setSurface(env, clazz, rhs); +} + +static void Surface_clear(JNIEnv* env, jobject clazz, uintptr_t *ostack) +{ + setSurface(env, clazz, 0); +} + +static jboolean Surface_isValid(JNIEnv* env, jobject clazz) +{ + const sp<Surface>& surface = getSurface(env, clazz); + return surface->isValid() ? JNI_TRUE : JNI_FALSE; +} + +static inline SkBitmap::Config convertPixelFormat(PixelFormat format) +{ + /* note: if PIXEL_FORMAT_XRGB_8888 means that all alpha bytes are 0xFF, then + we can map to SkBitmap::kARGB_8888_Config, and optionally call + bitmap.setIsOpaque(true) on the resulting SkBitmap (as an accelerator) + */ + switch (format) { + case PIXEL_FORMAT_RGBA_8888: return SkBitmap::kARGB_8888_Config; + case PIXEL_FORMAT_RGBA_4444: return SkBitmap::kARGB_4444_Config; + case PIXEL_FORMAT_RGB_565: return SkBitmap::kRGB_565_Config; + case PIXEL_FORMAT_A_8: return SkBitmap::kA8_Config; + default: return SkBitmap::kNo_Config; + } +} + +static jobject Surface_lockCanvas(JNIEnv* env, jobject clazz, jobject dirtyRect) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (!surface->isValid()) + return 0; + + // get dirty region + Region dirtyRegion; + if (dirtyRect) { + Rect dirty; + dirty.left = env->GetIntField(dirtyRect, ro.l); + dirty.top = env->GetIntField(dirtyRect, ro.t); + dirty.right = env->GetIntField(dirtyRect, ro.r); + dirty.bottom= env->GetIntField(dirtyRect, ro.b); + dirtyRegion.set(dirty); + } else { + dirtyRegion.set(Rect(0x3FFF,0x3FFF)); + } + + Surface::SurfaceInfo info; + status_t err = surface->lock(&info, &dirtyRegion); + if (err < 0) { + const char* const exception = (err == NO_MEMORY) ? + OutOfResourcesException : + "java/lang/IllegalArgumentException"; + doThrow(env, exception, NULL); + return 0; + } + + // Associate a SkCanvas object to this surface + jobject canvas = env->GetObjectField(clazz, so.canvas); + env->SetIntField(canvas, co.surfaceFormat, info.format); + + SkCanvas* nativeCanvas = (SkCanvas*)env->GetIntField(canvas, no.native_canvas); + SkBitmap bitmap; + bitmap.setConfig(convertPixelFormat(info.format), info.w, info.h, info.bpr); + if (info.w > 0 && info.h > 0) { + bitmap.setPixels(info.bits); + } else { + // be safe with an empty bitmap. + bitmap.setPixels(NULL); + } + nativeCanvas->setBitmapDevice(bitmap); + nativeCanvas->clipRegion(dirtyRegion.toSkRegion()); + + int saveCount = nativeCanvas->save(); + env->SetIntField(clazz, so.saveCount, saveCount); + + return canvas; +} + +static void Surface_unlockCanvasAndPost( + JNIEnv* env, jobject clazz, jobject argCanvas) +{ + jobject canvas = env->GetObjectField(clazz, so.canvas); + if (canvas != argCanvas) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + return; + } + + const sp<Surface>& surface = getSurface(env, clazz); + if (!surface->isValid()) + return; + + // detach the canvas from the surface + SkCanvas* nativeCanvas = (SkCanvas*)env->GetIntField(canvas, no.native_canvas); + int saveCount = env->GetIntField(clazz, so.saveCount); + nativeCanvas->restoreToCount(saveCount); + nativeCanvas->setBitmapDevice(SkBitmap()); + env->SetIntField(clazz, so.saveCount, 0); + + // unlock surface + status_t err = surface->unlockAndPost(); + if (err < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } +} + +static void Surface_unlockCanvas( + JNIEnv* env, jobject clazz, jobject argCanvas) +{ + jobject canvas = env->GetObjectField(clazz, so.canvas); + if (canvas != argCanvas) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + return; + } + + const sp<Surface>& surface = getSurface(env, clazz); + if (!surface->isValid()) + return; + + status_t err = surface->unlock(); + if (err < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + return; + } + SkCanvas* nativeCanvas = (SkCanvas*)env->GetIntField(canvas, no.native_canvas); + int saveCount = env->GetIntField(clazz, so.saveCount); + nativeCanvas->restoreToCount(saveCount); + nativeCanvas->setBitmapDevice(SkBitmap()); + env->SetIntField(clazz, so.saveCount, 0); +} + +static void Surface_openTransaction( + JNIEnv* env, jobject clazz) +{ + SurfaceComposerClient::openGlobalTransaction(); +} + +static void Surface_closeTransaction( + JNIEnv* env, jobject clazz) +{ + SurfaceComposerClient::closeGlobalTransaction(); +} + +static void Surface_setOrientation( + JNIEnv* env, jobject clazz, jint display, jint orientation) +{ + int err = SurfaceComposerClient::setOrientation(display, orientation); + if (err < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } +} + +static void Surface_freezeDisplay( + JNIEnv* env, jobject clazz, jint display) +{ + int err = SurfaceComposerClient::freezeDisplay(display, 0); + if (err < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } +} + +static void Surface_unfreezeDisplay( + JNIEnv* env, jobject clazz, jint display) +{ + int err = SurfaceComposerClient::unfreezeDisplay(display, 0); + if (err < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } +} + +static void Surface_setLayer( + JNIEnv* env, jobject clazz, jint zorder) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->setLayer(zorder) < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_setPosition( + JNIEnv* env, jobject clazz, jint x, jint y) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->setPosition(x, y) < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_setSize( + JNIEnv* env, jobject clazz, jint w, jint h) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->setSize(w, h) < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_hide( + JNIEnv* env, jobject clazz) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->hide() < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_show( + JNIEnv* env, jobject clazz) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->show() < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_freeze( + JNIEnv* env, jobject clazz) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->freeze() < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_unfreeze( + JNIEnv* env, jobject clazz) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->unfreeze() < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_setFlags( + JNIEnv* env, jobject clazz, jint flags, jint mask) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->setFlags(flags, mask) < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_setTransparentRegion( + JNIEnv* env, jobject clazz, jobject argRegion) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + SkRegion* nativeRegion = (SkRegion*)env->GetIntField(argRegion, no.native_region); + if (surface->setTransparentRegionHint(Region(*nativeRegion)) < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_setAlpha( + JNIEnv* env, jobject clazz, jfloat alpha) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->setAlpha(alpha) < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_setMatrix( + JNIEnv* env, jobject clazz, + jfloat dsdx, jfloat dtdx, jfloat dsdy, jfloat dtdy) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->setMatrix(dsdx, dtdx, dsdy, dtdy) < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_setFreezeTint( + JNIEnv* env, jobject clazz, + jint tint) +{ + const sp<Surface>& surface = getSurface(env, clazz); + if (surface->isValid()) { + if (surface->setFreezeTint(tint) < 0) { + doThrow(env, "java/lang/IllegalArgumentException", NULL); + } + } +} + +static void Surface_copyFrom( + JNIEnv* env, jobject clazz, jobject other) +{ + if (clazz == other) + return; + + if (other == NULL) { + doThrow(env, "java/lang/NullPointerException", NULL); + return; + } + + const sp<Surface>& surface = getSurface(env, clazz); + const sp<Surface>& rhs = getSurface(env, other); + if (!Surface::isSameSurface(surface, rhs)) { + // we reassign the surface only if it's a different one + // otherwise we would loose our client-side state. + setSurface(env, clazz, rhs->dup()); + } +} + + +static void Surface_readFromParcel( + JNIEnv* env, jobject clazz, jobject argParcel) +{ + Parcel* parcel = (Parcel*)env->GetIntField( argParcel, no.native_parcel); + if (parcel == NULL) { + doThrow(env, "java/lang/NullPointerException", NULL); + return; + } + + const sp<Surface>& surface = getSurface(env, clazz); + const sp<Surface>& rhs = Surface::readFromParcel(parcel); + if (!Surface::isSameSurface(surface, rhs)) { + // we reassign the surface only if it's a different one + // otherwise we would loose our client-side state. + setSurface(env, clazz, rhs); + } +} + +static void Surface_writeToParcel( + JNIEnv* env, jobject clazz, jobject argParcel, jint flags) +{ + Parcel* parcel = (Parcel*)env->GetIntField( + argParcel, no.native_parcel); + + if (parcel == NULL) { + doThrow(env, "java/lang/NullPointerException", NULL); + return; + } + + const sp<Surface>& surface = getSurface(env, clazz); + Surface::writeToParcel(surface, parcel); +} + +// ---------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- +// ---------------------------------------------------------------------------- + +const char* const kSurfaceSessionClassPathName = "android/view/SurfaceSession"; +const char* const kSurfaceClassPathName = "android/view/Surface"; +static void nativeClassInit(JNIEnv* env, jclass clazz); + +static JNINativeMethod gSurfaceSessionMethods[] = { + {"init", "()V", (void*)SurfaceSession_init }, + {"destroy", "()V", (void*)SurfaceSession_destroy }, + {"kill", "()V", (void*)SurfaceSession_kill }, +}; + +static JNINativeMethod gSurfaceMethods[] = { + {"nativeClassInit", "()V", (void*)nativeClassInit }, + {"init", "(Landroid/view/SurfaceSession;IIIIII)V", (void*)Surface_init }, + {"init", "(Landroid/os/Parcel;)V", (void*)Surface_initParcel }, + {"clear", "()V", (void*)Surface_clear }, + {"copyFrom", "(Landroid/view/Surface;)V", (void*)Surface_copyFrom }, + {"isValid", "()Z", (void*)Surface_isValid }, + {"lockCanvasNative", "(Landroid/graphics/Rect;)Landroid/graphics/Canvas;", (void*)Surface_lockCanvas }, + {"unlockCanvasAndPost", "(Landroid/graphics/Canvas;)V", (void*)Surface_unlockCanvasAndPost }, + {"unlockCanvas", "(Landroid/graphics/Canvas;)V", (void*)Surface_unlockCanvas }, + {"openTransaction", "()V", (void*)Surface_openTransaction }, + {"closeTransaction", "()V", (void*)Surface_closeTransaction }, + {"setOrientation", "(II)V", (void*)Surface_setOrientation }, + {"freezeDisplay", "(I)V", (void*)Surface_freezeDisplay }, + {"unfreezeDisplay", "(I)V", (void*)Surface_unfreezeDisplay }, + {"setLayer", "(I)V", (void*)Surface_setLayer }, + {"setPosition", "(II)V",(void*)Surface_setPosition }, + {"setSize", "(II)V",(void*)Surface_setSize }, + {"hide", "()V", (void*)Surface_hide }, + {"show", "()V", (void*)Surface_show }, + {"freeze", "()V", (void*)Surface_freeze }, + {"unfreeze", "()V", (void*)Surface_unfreeze }, + {"setFlags", "(II)V",(void*)Surface_setFlags }, + {"setTransparentRegionHint","(Landroid/graphics/Region;)V", (void*)Surface_setTransparentRegion }, + {"setAlpha", "(F)V", (void*)Surface_setAlpha }, + {"setMatrix", "(FFFF)V", (void*)Surface_setMatrix }, + {"setFreezeTint", "(I)V", (void*)Surface_setFreezeTint }, + {"readFromParcel", "(Landroid/os/Parcel;)V", (void*)Surface_readFromParcel }, + {"writeToParcel", "(Landroid/os/Parcel;I)V", (void*)Surface_writeToParcel }, +}; + +void nativeClassInit(JNIEnv* env, jclass clazz) +{ + so.surface = env->GetFieldID(clazz, "mSurface", "I"); + so.saveCount = env->GetFieldID(clazz, "mSaveCount", "I"); + so.canvas = env->GetFieldID(clazz, "mCanvas", "Landroid/graphics/Canvas;"); + + jclass surfaceSession = env->FindClass("android/view/SurfaceSession"); + sso.client = env->GetFieldID(surfaceSession, "mClient", "I"); + + jclass canvas = env->FindClass("android/graphics/Canvas"); + no.native_canvas = env->GetFieldID(canvas, "mNativeCanvas", "I"); + co.surfaceFormat = env->GetFieldID(canvas, "mSurfaceFormat", "I"); + + jclass region = env->FindClass("android/graphics/Region"); + no.native_region = env->GetFieldID(region, "mNativeRegion", "I"); + + jclass parcel = env->FindClass("android/os/Parcel"); + no.native_parcel = env->GetFieldID(parcel, "mObject", "I"); + + jclass rect = env->FindClass("android/graphics/Rect"); + ro.l = env->GetFieldID(rect, "left", "I"); + ro.t = env->GetFieldID(rect, "top", "I"); + ro.r = env->GetFieldID(rect, "right", "I"); + ro.b = env->GetFieldID(rect, "bottom", "I"); + + jclass point = env->FindClass("android/graphics/Point"); + po.x = env->GetFieldID(point, "x", "I"); + po.y = env->GetFieldID(point, "y", "I"); +} + +int register_android_view_Surface(JNIEnv* env) +{ + int err; + err = AndroidRuntime::registerNativeMethods(env, kSurfaceSessionClassPathName, + gSurfaceSessionMethods, NELEM(gSurfaceSessionMethods)); + + err |= AndroidRuntime::registerNativeMethods(env, kSurfaceClassPathName, + gSurfaceMethods, NELEM(gSurfaceMethods)); + return err; +} + +}; + diff --git a/core/jni/android_view_ViewRoot.cpp b/core/jni/android_view_ViewRoot.cpp new file mode 100644 index 0000000..843d293 --- /dev/null +++ b/core/jni/android_view_ViewRoot.cpp @@ -0,0 +1,98 @@ +/* + * 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. + */ + +#include <stdio.h> +#include <assert.h> + +#include <graphics/SkCanvas.h> +#include <graphics/SkDevice.h> +#include <graphics/SkGLCanvas.h> +#include <graphics/SkPaint.h> +#include "GraphicsJNI.h" + +#include "jni.h" +#include <android_runtime/AndroidRuntime.h> +#include <utils/misc.h> + +// ---------------------------------------------------------------------------- + +namespace android { + +static int gPrevDur; + +static void android_view_ViewRoot_showFPS(JNIEnv* env, jobject, jobject jcanvas, + jint dur) { + NPE_CHECK_RETURN_VOID(env, jcanvas); + SkCanvas* canvas = GraphicsJNI::getNativeCanvas(env, jcanvas); + const SkBitmap& bm = canvas->getDevice()->accessBitmap(false); + int height = bm.height(); + SkScalar bot = SkIntToScalar(height); + + if (height < 200) { + return; + } + + SkMatrix m; + SkRect r; + SkPaint p; + char str[4]; + + dur = (gPrevDur + dur) >> 1; + gPrevDur = dur; + + dur = 1000 / dur; + str[3] = (char)('0' + dur % 10); dur /= 10; + str[2] = (char)('0' + dur % 10); dur /= 10; + str[1] = (char)('0' + dur % 10); dur /= 10; + str[0] = (char)('0' + dur % 10); + + m.reset(); + r.set(0, bot-SkIntToScalar(10), SkIntToScalar(26), bot); + p.setAntiAlias(true); + p.setTextSize(SkIntToScalar(10)); + + canvas->save(); + canvas->setMatrix(m); + canvas->clipRect(r, SkRegion::kReplace_Op); + p.setColor(SK_ColorWHITE); + canvas->drawPaint(p); + p.setColor(SK_ColorBLACK); + canvas->drawText(str, 4, SkIntToScalar(1), bot - SK_Scalar1, p); + canvas->restore(); +} + +static void android_view_ViewRoot_abandonGlCaches(JNIEnv* env, jobject) { + SkGLCanvas::AbandonAllTextures(); +} + +// ---------------------------------------------------------------------------- + +const char* const kClassPathName = "android/view/ViewRoot"; + +static JNINativeMethod gMethods[] = { + { "nativeShowFPS", "(Landroid/graphics/Canvas;I)V", + (void*)android_view_ViewRoot_showFPS }, + { "nativeAbandonGlCaches", "()V", + (void*)android_view_ViewRoot_abandonGlCaches } +}; + +int register_android_view_ViewRoot(JNIEnv* env) { + return AndroidRuntime::registerNativeMethods(env, + kClassPathName, gMethods, NELEM(gMethods)); +} + +}; + diff --git a/core/jni/com_android_internal_graphics_NativeUtils.cpp b/core/jni/com_android_internal_graphics_NativeUtils.cpp new file mode 100644 index 0000000..0829532 --- /dev/null +++ b/core/jni/com_android_internal_graphics_NativeUtils.cpp @@ -0,0 +1,65 @@ +/* + * Copyright (C) 2007 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. + */ + +#define LOG_TAG "AWT" + +#include "jni.h" +#include "JNIHelp.h" +#include "GraphicsJNI.h" +#include <android_runtime/AndroidRuntime.h> + +#include "SkCanvas.h" +#include "SkDevice.h" +#include "SkPicture.h" +#include "SkTemplates.h" + +namespace android +{ + +static jclass class_fileDescriptor; +static jfieldID field_fileDescriptor_descriptor; +static jmethodID method_fileDescriptor_init; + + +static jboolean scrollRect(JNIEnv* env, jobject graphics2D, jobject canvas, jobject rect, int dx, int dy) { + if (canvas == NULL) { + jniThrowException(env, "java/lang/NullPointerException", NULL); + return false; + } + + SkIRect src, *srcPtr = NULL; + if (NULL != rect) { + GraphicsJNI::jrect_to_irect(env, rect, &src); + srcPtr = &src; + } + SkCanvas* c = GraphicsJNI::getNativeCanvas(env, canvas); + const SkBitmap& bitmap = c->getDevice()->accessBitmap(true); + return bitmap.scrollRect(srcPtr, dx, dy, NULL); +} + +static JNINativeMethod method_table[] = { + { "nativeScrollRect", + "(Landroid/graphics/Canvas;Landroid/graphics/Rect;II)Z", + (void*)scrollRect} +}; + +int register_com_android_internal_graphics_NativeUtils(JNIEnv *env) { + return AndroidRuntime::registerNativeMethods( + env, "com/android/internal/graphics/NativeUtils", + method_table, NELEM(method_table)); +} + +} diff --git a/core/jni/com_android_internal_os_ZygoteInit.cpp b/core/jni/com_android_internal_os_ZygoteInit.cpp new file mode 100644 index 0000000..ada4dd3 --- /dev/null +++ b/core/jni/com_android_internal_os_ZygoteInit.cpp @@ -0,0 +1,367 @@ +/* + * Copyright (C) 2007 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. + */ + +#define LOG_TAG "Zygote" + +#include <sys/types.h> +#include <unistd.h> +#include <fcntl.h> +#include <utils/misc.h> +#include <errno.h> +#include <sys/select.h> + +#include "jni.h" +#include <JNIHelp.h> +#include "android_runtime/AndroidRuntime.h" + +#ifdef HAVE_ANDROID_OS +#include <linux/capability.h> +#include <linux/prctl.h> +#include <sys/prctl.h> +extern "C" int capget(cap_user_header_t hdrp, cap_user_data_t datap); +extern "C" int capset(cap_user_header_t hdrp, const cap_user_data_t datap); +#endif + + +namespace android { + +/* + * In class com.android.internal.os.ZygoteInit: + * private static native boolean setreuid(int ruid, int euid) + */ +static jint com_android_internal_os_ZygoteInit_setreuid( + JNIEnv* env, jobject clazz, jint ruid, jint euid) +{ + int err; + + errno = 0; + err = setreuid(ruid, euid); + + //LOGI("setreuid(%d,%d) err %d errno %d", ruid, euid, err, errno); + + return errno; +} + +/* + * In class com.android.internal.os.ZygoteInit: + * private static native int setregid(int rgid, int egid) + */ +static jint com_android_internal_os_ZygoteInit_setregid( + JNIEnv* env, jobject clazz, jint rgid, jint egid) +{ + int err; + + errno = 0; + err = setregid(rgid, egid); + + //LOGI("setregid(%d,%d) err %d errno %d", rgid, egid, err, errno); + + return errno; +} + +/* + * In class com.android.internal.os.ZygoteInit: + * private static native int setpgid(int rgid, int egid) + */ +static jint com_android_internal_os_ZygoteInit_setpgid( + JNIEnv* env, jobject clazz, jint pid, jint pgid) +{ + int err; + + errno = 0; + + err = setpgid(pid, pgid); + + return errno; +} + +/* + * In class com.android.internal.os.ZygoteInit: + * private static native int getpgid(int pid) + */ +static jint com_android_internal_os_ZygoteInit_getpgid( + JNIEnv* env, jobject clazz, jint pid) +{ + pid_t ret; + ret = getpgid(pid); + + if (ret < 0) { + jniThrowIOException(env, errno); + } + + return ret; +} + +static void com_android_internal_os_ZygoteInit_reopenStdio(JNIEnv* env, + jobject clazz, jobject in, jobject out, jobject errfd) +{ + int fd; + int err; + + fd = jniGetFDFromFileDescriptor(env, in); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + do { + err = dup2(fd, STDIN_FILENO); + } while (err < 0 && errno == EINTR); + + fd = jniGetFDFromFileDescriptor(env, out); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + do { + err = dup2(fd, STDOUT_FILENO); + } while (err < 0 && errno == EINTR); + + fd = jniGetFDFromFileDescriptor(env, errfd); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + do { + err = dup2(fd, STDERR_FILENO); + } while (err < 0 && errno == EINTR); +} + +static void com_android_internal_os_ZygoteInit_closeDescriptor(JNIEnv* env, + jobject clazz, jobject descriptor) +{ + int fd; + int err; + + fd = jniGetFDFromFileDescriptor(env, descriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + do { + err = close(fd); + } while (err < 0 && errno == EINTR); + + if (err < 0) { + jniThrowIOException(env, errno); + return; + } +} + +static void com_android_internal_os_ZygoteInit_setCloseOnExec (JNIEnv *env, + jobject clazz, jobject descriptor, jboolean flag) +{ + int fd; + int err; + int fdFlags; + + fd = jniGetFDFromFileDescriptor(env, descriptor); + + if (env->ExceptionOccurred() != NULL) { + return; + } + + fdFlags = fcntl(fd, F_GETFD); + + if (fdFlags < 0) { + jniThrowIOException(env, errno); + return; + } + + if (flag) { + fdFlags |= FD_CLOEXEC; + } else { + fdFlags &= ~FD_CLOEXEC; + } + + err = fcntl(fd, F_SETFD, fdFlags); + + if (err < 0) { + jniThrowIOException(env, errno); + return; + } +} + +static void com_android_internal_os_ZygoteInit_setCapabilities (JNIEnv *env, + jobject clazz, jlong permitted, jlong effective) +{ +#ifdef HAVE_ANDROID_OS + struct __user_cap_header_struct capheader; + struct __user_cap_data_struct capdata; + int err; + + memset (&capheader, 0, sizeof(capheader)); + memset (&capdata, 0, sizeof(capdata)); + + capheader.version = _LINUX_CAPABILITY_VERSION; + capheader.pid = 0; + + // As of this writing, capdata is __u32, but that's expected + // to change... + capdata.effective = effective; + capdata.permitted = permitted; + + err = capset (&capheader, &capdata); + + if (err < 0) { + jniThrowIOException(env, errno); + return; + } +#endif /* HAVE_ANDROID_OS */ +} + +static jlong com_android_internal_os_ZygoteInit_capgetPermitted (JNIEnv *env, + jobject clazz, jint pid) +{ +#ifndef HAVE_ANDROID_OS + return (jlong)0; +#else + struct __user_cap_header_struct capheader; + struct __user_cap_data_struct capdata; + int err; + + memset (&capheader, 0, sizeof(capheader)); + memset (&capdata, 0, sizeof(capdata)); + + capheader.version = _LINUX_CAPABILITY_VERSION; + capheader.pid = pid; + + err = capget (&capheader, &capdata); + + if (err < 0) { + jniThrowIOException(env, errno); + return 0; + } + + return (jlong) capdata.permitted; +#endif /* HAVE_ANDROID_OS */ +} + +static jint com_android_internal_os_ZygoteInit_selectReadable ( + JNIEnv *env, jobject clazz, jobjectArray fds) +{ + if (fds == NULL) { + jniThrowException(env, "java/lang/NullPointerException", + "fds == null"); + return -1; + } + + jsize length = env->GetArrayLength(fds); + fd_set fdset; + + if (env->ExceptionOccurred() != NULL) { + return -1; + } + + FD_ZERO(&fdset); + + int nfds = 0; + for (jsize i = 0; i < length; i++) { + jobject fdObj = env->GetObjectArrayElement(fds, i); + if (env->ExceptionOccurred() != NULL) { + return -1; + } + if (fdObj == NULL) { + continue; + } + int fd = jniGetFDFromFileDescriptor(env, fdObj); + if (env->ExceptionOccurred() != NULL) { + return -1; + } + + FD_SET(fd, &fdset); + + if (fd >= nfds) { + nfds = fd + 1; + } + } + + int err; + do { + err = select (nfds, &fdset, NULL, NULL, NULL); + } while (err < 0 && errno == EINTR); + + if (err < 0) { + jniThrowIOException(env, errno); + return -1; + } + + for (jsize i = 0; i < length; i++) { + jobject fdObj = env->GetObjectArrayElement(fds, i); + if (env->ExceptionOccurred() != NULL) { + return -1; + } + if (fdObj == NULL) { + continue; + } + int fd = jniGetFDFromFileDescriptor(env, fdObj); + if (env->ExceptionOccurred() != NULL) { + return -1; + } + if (FD_ISSET(fd, &fdset)) { + return (jint)i; + } + } + return -1; +} + +static jobject com_android_internal_os_ZygoteInit_createFileDescriptor ( + JNIEnv *env, jobject clazz, jint fd) +{ + return jniCreateFileDescriptor(env, fd); +} + +/* + * JNI registration. + */ +static JNINativeMethod gMethods[] = { + /* name, signature, funcPtr */ + { "setreuid", "(II)I", + (void*) com_android_internal_os_ZygoteInit_setreuid }, + { "setregid", "(II)I", + (void*) com_android_internal_os_ZygoteInit_setregid }, + { "setpgid", "(II)I", + (void *) com_android_internal_os_ZygoteInit_setpgid }, + { "getpgid", "(I)I", + (void *) com_android_internal_os_ZygoteInit_getpgid }, + { "reopenStdio", + "(Ljava/io/FileDescriptor;Ljava/io/FileDescriptor;" + "Ljava/io/FileDescriptor;)V", + (void *) com_android_internal_os_ZygoteInit_reopenStdio}, + { "closeDescriptor", "(Ljava/io/FileDescriptor;)V", + (void *) com_android_internal_os_ZygoteInit_closeDescriptor}, + { "setCloseOnExec", "(Ljava/io/FileDescriptor;Z)V", + (void *) com_android_internal_os_ZygoteInit_setCloseOnExec}, + { "setCapabilities", "(JJ)V", + (void *) com_android_internal_os_ZygoteInit_setCapabilities }, + { "capgetPermitted", "(I)J", + (void *) com_android_internal_os_ZygoteInit_capgetPermitted }, + { "selectReadable", "([Ljava/io/FileDescriptor;)I", + (void *) com_android_internal_os_ZygoteInit_selectReadable }, + { "createFileDescriptor", "(I)Ljava/io/FileDescriptor;", + (void *) com_android_internal_os_ZygoteInit_createFileDescriptor } +}; +int register_com_android_internal_os_ZygoteInit(JNIEnv* env) +{ + return AndroidRuntime::registerNativeMethods(env, + "com/android/internal/os/ZygoteInit", gMethods, NELEM(gMethods)); +} + +}; // namespace android + diff --git a/core/jni/com_google_android_gles_jni_EGLImpl.cpp b/core/jni/com_google_android_gles_jni_EGLImpl.cpp new file mode 100644 index 0000000..af03016 --- /dev/null +++ b/core/jni/com_google_android_gles_jni_EGLImpl.cpp @@ -0,0 +1,475 @@ +/* +** +** Copyright 2006, 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. +*/ + +#include <android_runtime/AndroidRuntime.h> +#include <utils/misc.h> + +#include <GLES/egl.h> +#include <GLES/gl.h> + +#include <ui/EGLNativeWindowSurface.h> +#include <ui/Surface.h> +#include <graphics/SkBitmap.h> +#include <graphics/SkPixelRef.h> + +namespace android { + +static jclass gDisplay_class; +static jclass gContext_class; +static jclass gSurface_class; +static jclass gConfig_class; + +static jmethodID gConfig_ctorID; + +static jfieldID gDisplay_EGLDisplayFieldID; +static jfieldID gContext_EGLContextFieldID; +static jfieldID gSurface_EGLSurfaceFieldID; +static jfieldID gSurface_NativePixelRefFieldID; +static jfieldID gConfig_EGLConfigFieldID; +static jfieldID gSurface_SurfaceFieldID; +static jfieldID gBitmap_NativeBitmapFieldID; + +static __attribute__((noinline)) +void doThrow(JNIEnv* env, const char* exc, const char* msg = NULL) +{ + jclass npeClazz = env->FindClass(exc); + env->ThrowNew(npeClazz, msg); +} + +static __attribute__((noinline)) +bool hasException(JNIEnv *env) { + if (env->ExceptionCheck() != 0) { + env->ExceptionDescribe(); + return true; + } + return false; +} + +static __attribute__((noinline)) +jclass make_globalref(JNIEnv* env, const char classname[]) { + jclass c = env->FindClass(classname); + return (jclass)env->NewGlobalRef(c); +} + +static inline EGLDisplay getDisplay(JNIEnv* env, jobject o) { + if (!o) return EGL_NO_DISPLAY; + return (EGLDisplay)env->GetIntField(o, gDisplay_EGLDisplayFieldID); +} +static inline EGLSurface getSurface(JNIEnv* env, jobject o) { + if (!o) return EGL_NO_SURFACE; + return (EGLSurface)env->GetIntField(o, gSurface_EGLSurfaceFieldID); +} +static inline EGLContext getContext(JNIEnv* env, jobject o) { + if (!o) return EGL_NO_CONTEXT; + return (EGLContext)env->GetIntField(o, gContext_EGLContextFieldID); +} +static inline EGLConfig getConfig(JNIEnv* env, jobject o) { + if (!o) return 0; + return (EGLConfig)env->GetIntField(o, gConfig_EGLConfigFieldID); +} +static void nativeClassInit(JNIEnv *_env, jclass eglImplClass) +{ + gDisplay_class = make_globalref(_env, "com/google/android/gles_jni/EGLDisplayImpl"); + gContext_class = make_globalref(_env, "com/google/android/gles_jni/EGLContextImpl"); + gSurface_class = make_globalref(_env, "com/google/android/gles_jni/EGLSurfaceImpl"); + gConfig_class = make_globalref(_env, "com/google/android/gles_jni/EGLConfigImpl"); + + gConfig_ctorID = _env->GetMethodID(gConfig_class, "<init>", "(I)V"); + + gDisplay_EGLDisplayFieldID = _env->GetFieldID(gDisplay_class, "mEGLDisplay", "I"); + gContext_EGLContextFieldID = _env->GetFieldID(gContext_class, "mEGLContext", "I"); + gSurface_EGLSurfaceFieldID = _env->GetFieldID(gSurface_class, "mEGLSurface", "I"); + gSurface_NativePixelRefFieldID = _env->GetFieldID(gSurface_class, "mNativePixelRef", "I"); + gConfig_EGLConfigFieldID = _env->GetFieldID(gConfig_class, "mEGLConfig", "I"); + + jclass surface_class = _env->FindClass("android/view/Surface"); + gSurface_SurfaceFieldID = _env->GetFieldID(surface_class, "mSurface", "I"); + + jclass bitmap_class = _env->FindClass("android/graphics/Bitmap"); + gBitmap_NativeBitmapFieldID = _env->GetFieldID(bitmap_class, "mNativeBitmap", "I"); +} + +jboolean jni_eglInitialize(JNIEnv *_env, jobject _this, jobject display, + jintArray major_minor) { + + EGLDisplay dpy = getDisplay(_env, display); + jboolean success = eglInitialize(dpy, NULL, NULL); + if (success && major_minor) { + int len = _env->GetArrayLength(major_minor); + if (len) { + // we're exposing only EGL 1.0 + jint* base = (jint *)_env->GetPrimitiveArrayCritical(major_minor, (jboolean *)0); + if (len >= 1) base[0] = 1; + if (len >= 2) base[1] = 0; + _env->ReleasePrimitiveArrayCritical(major_minor, base, JNI_ABORT); + } + } + return success; +} + +jboolean jni_eglQueryContext(JNIEnv *_env, jobject _this, jobject display, + jobject context, jint attribute, jintArray value) { + EGLDisplay dpy = getDisplay(_env, display); + EGLContext ctx = getContext(_env, context); + if (value == NULL) { + doThrow(_env, "java/lang/NullPointerException"); + return JNI_FALSE; + } + jboolean success = JNI_FALSE; + int len = _env->GetArrayLength(value); + if (len) { + jint* base = (jint *)_env->GetPrimitiveArrayCritical(value, (jboolean *)0); + success = eglQueryContext(dpy, ctx, attribute, base); + _env->ReleasePrimitiveArrayCritical(value, base, JNI_ABORT); + } + return success; +} + +jboolean jni_eglQuerySurface(JNIEnv *_env, jobject _this, jobject display, + jobject surface, jint attribute, jintArray value) { + EGLDisplay dpy = getDisplay(_env, display); + EGLContext sur = getSurface(_env, surface); + if (value == NULL) { + doThrow(_env, "java/lang/NullPointerException"); + return JNI_FALSE; + } + jboolean success = JNI_FALSE; + int len = _env->GetArrayLength(value); + if (len) { + jint* base = (jint *)_env->GetPrimitiveArrayCritical(value, (jboolean *)0); + success = eglQuerySurface(dpy, sur, attribute, base); + _env->ReleasePrimitiveArrayCritical(value, base, JNI_ABORT); + } + return success; +} + +jboolean jni_eglChooseConfig(JNIEnv *_env, jobject _this, jobject display, + jintArray attrib_list, jobjectArray configs, jint config_size, jintArray num_config) { + EGLDisplay dpy = getDisplay(_env, display); + if (attrib_list==NULL || configs==NULL || num_config==NULL) { + doThrow(_env, "java/lang/NullPointerException"); + return JNI_FALSE; + } + jboolean success = JNI_FALSE; + jint* attrib_base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0); + jint* num_base = (jint *)_env->GetPrimitiveArrayCritical(num_config, (jboolean *)0); + EGLConfig nativeConfigs[config_size]; + success = eglChooseConfig(dpy, attrib_base, nativeConfigs, config_size, num_base); + int num = num_base[0]; + _env->ReleasePrimitiveArrayCritical(num_config, num_base, JNI_ABORT); + _env->ReleasePrimitiveArrayCritical(attrib_list, attrib_base, JNI_ABORT); + if (success) { + for (int i=0 ; i<num ; i++) { + jobject obj = _env->NewObject(gConfig_class, gConfig_ctorID, (jint)nativeConfigs[i]); + _env->SetObjectArrayElement(configs, i, obj); + } + } + return success; +} + +jint jni_eglCreateContext(JNIEnv *_env, jobject _this, jobject display, + jobject config, jobject share_context, jintArray attrib_list) { + EGLDisplay dpy = getDisplay(_env, display); + EGLConfig cnf = getConfig(_env, config); + EGLContext shr = getContext(_env, share_context); + jint* base = 0; + if (attrib_list) { + // XXX: if array is malformed, we should return an NPE instead of segfault + base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0); + } + EGLContext ctx = eglCreateContext(dpy, cnf, shr, base); + if (attrib_list) { + _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT); + } + return (jint)ctx; +} + +jint jni_eglCreatePbufferSurface(JNIEnv *_env, jobject _this, jobject display, + jobject config, jintArray attrib_list) { + EGLDisplay dpy = getDisplay(_env, display); + EGLConfig cnf = getConfig(_env, config); + jint* base = 0; + if (attrib_list) { + // XXX: if array is malformed, we should return an NPE instead of segfault + base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0); + } + EGLSurface sur = eglCreatePbufferSurface(dpy, cnf, base); + if (attrib_list) { + _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT); + } + return (jint)sur; +} + +static PixelFormat convertPixelFormat(SkBitmap::Config format) +{ + switch (format) { + case SkBitmap::kARGB_8888_Config: return PIXEL_FORMAT_RGBA_8888; + case SkBitmap::kARGB_4444_Config: return PIXEL_FORMAT_RGBA_4444; + case SkBitmap::kRGB_565_Config: return PIXEL_FORMAT_RGB_565; + case SkBitmap::kA8_Config: return PIXEL_FORMAT_A_8; + default: return PIXEL_FORMAT_NONE; + } +} + +void jni_eglCreatePixmapSurface(JNIEnv *_env, jobject _this, jobject out_sur, + jobject display, jobject config, jobject native_pixmap, + jintArray attrib_list) +{ + EGLDisplay dpy = getDisplay(_env, display); + EGLConfig cnf = getConfig(_env, config); + jint* base = 0; + + SkBitmap const * nativeBitmap = + (SkBitmap const *)_env->GetIntField(native_pixmap, + gBitmap_NativeBitmapFieldID); + SkPixelRef* ref = nativeBitmap ? nativeBitmap->pixelRef() : 0; + if (ref == NULL) { + doThrow(_env, "java/lang/NullPointerException", "Bitmap has no PixelRef"); + return; + } + + ref->safeRef(); + ref->lockPixels(); + + egl_native_pixmap_t pixmap; + pixmap.version = sizeof(pixmap); + pixmap.width = nativeBitmap->width(); + pixmap.height = nativeBitmap->height(); + pixmap.stride = nativeBitmap->rowBytes() / nativeBitmap->bytesPerPixel(); + pixmap.format = convertPixelFormat(nativeBitmap->config()); + pixmap.data = (uint8_t*)ref->pixels(); + + if (attrib_list) { + // XXX: if array is malformed, we should return an NPE instead of segfault + base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0); + } + EGLSurface sur = eglCreatePixmapSurface(dpy, cnf, &pixmap, base); + if (attrib_list) { + _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT); + } + + if (sur != EGL_NO_SURFACE) { + _env->SetIntField(out_sur, gSurface_EGLSurfaceFieldID, (int)sur); + _env->SetIntField(out_sur, gSurface_NativePixelRefFieldID, (int)ref); + } else { + ref->unlockPixels(); + ref->safeUnref(); + } +} + +jint jni_eglCreateWindowSurface(JNIEnv *_env, jobject _this, jobject display, + jobject config, jobject native_window, jintArray attrib_list) { + EGLDisplay dpy = getDisplay(_env, display); + EGLContext cnf = getConfig(_env, config); + Surface* window = 0; + if (native_window == NULL) { +not_valid_surface: + doThrow(_env, "java/lang/NullPointerException", + "Make sure the SurfaceView or associated SurfaceHolder has a valid Surface"); + return 0; + } + window = (Surface*)_env->GetIntField(native_window, gSurface_SurfaceFieldID); + if (window == NULL) + goto not_valid_surface; + + jint* base = 0; + if (attrib_list) { + // XXX: if array is malformed, we should return an NPE instead of segfault + base = (jint *)_env->GetPrimitiveArrayCritical(attrib_list, (jboolean *)0); + } + EGLSurface sur = eglCreateWindowSurface(dpy, cnf, new EGLNativeWindowSurface(window), base); + if (attrib_list) { + _env->ReleasePrimitiveArrayCritical(attrib_list, base, JNI_ABORT); + } + return (jint)sur; +} + +jboolean jni_eglGetConfigAttrib(JNIEnv *_env, jobject _this, jobject display, + jobject config, jint attribute, jintArray value) { + EGLDisplay dpy = getDisplay(_env, display); + EGLContext cnf = getConfig(_env, config); + if (value == NULL) { + doThrow(_env, "java/lang/NullPointerException"); + return JNI_FALSE; + } + jboolean success = JNI_FALSE; + int len = _env->GetArrayLength(value); + if (len) { + jint* base = (jint *)_env->GetPrimitiveArrayCritical(value, (jboolean *)0); + success = eglGetConfigAttrib(dpy, cnf, attribute, base); + _env->ReleasePrimitiveArrayCritical(value, base, JNI_ABORT); + } + return success; +} + +jboolean jni_eglGetConfigs(JNIEnv *_env, jobject _this, jobject display, + jobjectArray configs, jint config_size, jintArray num_config) { + EGLDisplay dpy = getDisplay(_env, display); + jboolean success = JNI_FALSE; + if (num_config == NULL) { + doThrow(_env, "java/lang/NullPointerException"); + return JNI_FALSE; + } + jint* num_base = (jint *)_env->GetPrimitiveArrayCritical(num_config, (jboolean *)0); + EGLConfig nativeConfigs[config_size]; + success = eglGetConfigs(dpy, configs ? nativeConfigs : 0, config_size, num_base); + int num = num_base[0]; + _env->ReleasePrimitiveArrayCritical(num_config, num_base, JNI_ABORT); + + if (success && configs) { + for (int i=0 ; i<num ; i++) { + jobject obj = _env->GetObjectArrayElement(configs, i); + if (obj == NULL) { + doThrow(_env, "java/lang/NullPointerException"); + break; + } + _env->SetIntField(obj, gConfig_EGLConfigFieldID, (jint)nativeConfigs[i]); + } + } + return success; +} + +jint jni_eglGetError(JNIEnv *_env, jobject _this) { + EGLint error = eglGetError(); + return error; +} + +jint jni_eglGetCurrentContext(JNIEnv *_env, jobject _this) { + return (jint)eglGetCurrentContext(); +} + +jint jni_eglGetCurrentDisplay(JNIEnv *_env, jobject _this) { + return (jint)eglGetCurrentDisplay(); +} + +jint jni_eglGetCurrentSurface(JNIEnv *_env, jobject _this, jint readdraw) { + return (jint)eglGetCurrentSurface(readdraw); +} + +jboolean jni_eglDestroyContext(JNIEnv *_env, jobject _this, jobject display, jobject context) { + EGLDisplay dpy = getDisplay(_env, display); + EGLContext ctx = getContext(_env, context); + return eglDestroyContext(dpy, ctx); +} + +jboolean jni_eglDestroySurface(JNIEnv *_env, jobject _this, jobject display, jobject surface) { + EGLDisplay dpy = getDisplay(_env, display); + EGLSurface sur = getSurface(_env, surface); + + if (sur) { + SkPixelRef* ref = (SkPixelRef*)(_env->GetIntField(surface, + gSurface_NativePixelRefFieldID)); + if (ref) { + ref->unlockPixels(); + ref->safeUnref(); + } + } + return eglDestroySurface(dpy, sur); +} + +jint jni_eglGetDisplay(JNIEnv *_env, jobject _this, jobject native_display) { + return (jint)eglGetDisplay(EGL_DEFAULT_DISPLAY); +} + +jboolean jni_eglMakeCurrent(JNIEnv *_env, jobject _this, jobject display, jobject draw, jobject read, jobject context) { + EGLDisplay dpy = getDisplay(_env, display); + EGLSurface sdr = getSurface(_env, draw); + EGLSurface srd = getSurface(_env, read); + EGLContext ctx = getContext(_env, context); + return eglMakeCurrent(dpy, sdr, srd, ctx); +} + +jstring jni_eglQueryString(JNIEnv *_env, jobject _this, jobject display, jint name) { + EGLDisplay dpy = getDisplay(_env, display); + const char* chars = eglQueryString(dpy, name); + return _env->NewString((const jchar *)chars, + (jsize)strlen((const char *)chars)); +} + +jboolean jni_eglSwapBuffers(JNIEnv *_env, jobject _this, jobject display, jobject surface) { + EGLDisplay dpy = getDisplay(_env, display); + EGLSurface sur = getSurface(_env, surface); + return eglSwapBuffers(dpy, sur); +} + +jboolean jni_eglTerminate(JNIEnv *_env, jobject _this, jobject display) { + EGLDisplay dpy = getDisplay(_env, display); + return eglTerminate(dpy); +} + +jboolean jni_eglCopyBuffers(JNIEnv *_env, jobject _this, jobject display, + jobject surface, jobject native_pixmap) { + // TODO: implement me + return JNI_FALSE; +} + +jboolean jni_eglWaitGL(JNIEnv *_env, jobject _this) { + return eglWaitGL(); +} + +jboolean jni_eglWaitNative(JNIEnv *_env, jobject _this, jint engine, jobject bindTarget) { + return eglWaitNative(engine); +} + + +static const char *classPathName = "com/google/android/gles_jni/EGLImpl"; + +#define DISPLAY "Ljavax/microedition/khronos/egl/EGLDisplay;" +#define CONTEXT "Ljavax/microedition/khronos/egl/EGLContext;" +#define CONFIG "Ljavax/microedition/khronos/egl/EGLConfig;" +#define SURFACE "Ljavax/microedition/khronos/egl/EGLSurface;" +#define OBJECT "Ljava/lang/Object;" +#define STRING "Ljava/lang/String;" + +static JNINativeMethod methods[] = { +{"_nativeClassInit","()V", (void*)nativeClassInit }, +{"eglWaitGL", "()Z", (void*)jni_eglWaitGL }, +{"eglInitialize", "(" DISPLAY "[I)Z", (void*)jni_eglInitialize }, +{"eglQueryContext", "(" DISPLAY CONTEXT "I[I)Z", (void*)jni_eglQueryContext }, +{"eglQuerySurface", "(" DISPLAY SURFACE "I[I)Z", (void*)jni_eglQuerySurface }, +{"eglChooseConfig", "(" DISPLAY "[I[" CONFIG "I[I)Z", (void*)jni_eglChooseConfig }, +{"_eglCreateContext","(" DISPLAY CONFIG CONTEXT "[I)I", (void*)jni_eglCreateContext }, +{"eglGetConfigs", "(" DISPLAY "[" CONFIG "I[I)Z", (void*)jni_eglGetConfigs }, +{"eglTerminate", "(" DISPLAY ")Z", (void*)jni_eglTerminate }, +{"eglCopyBuffers", "(" DISPLAY SURFACE OBJECT ")Z", (void*)jni_eglCopyBuffers }, +{"eglWaitNative", "(I" OBJECT ")Z", (void*)jni_eglWaitNative }, +{"eglGetError", "()I", (void*)jni_eglGetError }, +{"eglGetConfigAttrib", "(" DISPLAY CONFIG "I[I)Z", (void*)jni_eglGetConfigAttrib }, +{"_eglGetDisplay", "(" OBJECT ")I", (void*)jni_eglGetDisplay }, +{"_eglGetCurrentContext", "()I", (void*)jni_eglGetCurrentContext }, +{"_eglGetCurrentDisplay", "()I", (void*)jni_eglGetCurrentDisplay }, +{"_eglGetCurrentSurface", "(I)I", (void*)jni_eglGetCurrentSurface }, +{"_eglCreatePbufferSurface","(" DISPLAY CONFIG "[I)I", (void*)jni_eglCreatePbufferSurface }, +{"_eglCreatePixmapSurface", "(" SURFACE DISPLAY CONFIG OBJECT "[I)V", (void*)jni_eglCreatePixmapSurface }, +{"_eglCreateWindowSurface", "(" DISPLAY CONFIG OBJECT "[I)I", (void*)jni_eglCreateWindowSurface }, +{"eglDestroyContext", "(" DISPLAY CONTEXT ")Z", (void*)jni_eglDestroyContext }, +{"eglDestroySurface", "(" DISPLAY SURFACE ")Z", (void*)jni_eglDestroySurface }, +{"eglMakeCurrent", "(" DISPLAY SURFACE SURFACE CONTEXT")Z", (void*)jni_eglMakeCurrent }, +{"eglQueryString", "(" DISPLAY "I)" STRING, (void*)jni_eglQueryString }, +{"eglSwapBuffers", "(" DISPLAY SURFACE ")Z", (void*)jni_eglSwapBuffers }, +}; + +} // namespace android + +int register_com_google_android_gles_jni_EGLImpl(JNIEnv *_env) +{ + int err; + err = android::AndroidRuntime::registerNativeMethods(_env, + android::classPathName, android::methods, NELEM(android::methods)); + return err; +} + diff --git a/core/jni/com_google_android_gles_jni_GLImpl.cpp b/core/jni/com_google_android_gles_jni_GLImpl.cpp new file mode 100644 index 0000000..1cd23b0 --- /dev/null +++ b/core/jni/com_google_android_gles_jni_GLImpl.cpp @@ -0,0 +1,6571 @@ +/* //device/libs/android_runtime/com_google_android_gles_jni_GLImpl.cpp +** +** Copyright 2006, 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. +*/ + +// This source file is automatically generated + +#include <android_runtime/AndroidRuntime.h> +#include <utils/misc.h> + +#include <assert.h> +#include <GLES/gl.h> + +#include <private/opengles/gl_context.h> + +#define _NUM_COMPRESSED_TEXTURE_FORMATS \ + (::android::OGLES_NUM_COMPRESSED_TEXTURE_FORMATS) + +static int initialized = 0; + +static jclass nioAccessClass; +static jclass bufferClass; +static jclass OOMEClass; +static jclass UOEClass; +static jclass IAEClass; +static jmethodID getBasePointerID; +static jmethodID getBaseArrayID; +static jmethodID getBaseArrayOffsetID; +static jfieldID positionID; +static jfieldID limitID; +static jfieldID elementSizeShiftID; + +/* Cache method IDs each time the class is loaded. */ + +void +nativeClassInitBuffer(JNIEnv *_env) +{ + jclass nioAccessClassLocal = _env->FindClass("java/nio/NIOAccess"); + nioAccessClass = (jclass) _env->NewGlobalRef(nioAccessClassLocal); + + jclass bufferClassLocal = _env->FindClass("java/nio/Buffer"); + bufferClass = (jclass) _env->NewGlobalRef(bufferClassLocal); + + getBasePointerID = _env->GetStaticMethodID(nioAccessClass, + "getBasePointer", "(Ljava/nio/Buffer;)J"); + getBaseArrayID = _env->GetStaticMethodID(nioAccessClass, + "getBaseArray", "(Ljava/nio/Buffer;)Ljava/lang/Object;"); + getBaseArrayOffsetID = _env->GetStaticMethodID(nioAccessClass, + "getBaseArrayOffset", "(Ljava/nio/Buffer;)I"); + + positionID = _env->GetFieldID(bufferClass, "position", "I"); + limitID = _env->GetFieldID(bufferClass, "limit", "I"); + elementSizeShiftID = + _env->GetFieldID(bufferClass, "_elementSizeShift", "I"); +} + + +static void +nativeClassInit(JNIEnv *_env, jclass glImplClass) +{ + nativeClassInitBuffer(_env); + + jclass IAEClassLocal = + _env->FindClass("java/lang/IllegalArgumentException"); + jclass OOMEClassLocal = + _env->FindClass("java/lang/OutOfMemoryError"); + jclass UOEClassLocal = + _env->FindClass("java/lang/UnsupportedOperationException"); + + IAEClass = (jclass) _env->NewGlobalRef(IAEClassLocal); + OOMEClass = (jclass) _env->NewGlobalRef(OOMEClassLocal); + UOEClass = (jclass) _env->NewGlobalRef(UOEClassLocal); +} + +static void * +getPointer(JNIEnv *_env, jobject buffer, jarray *array, jint *remaining) +{ + jint position; + jint limit; + jint elementSizeShift; + jlong pointer; + jint offset; + void *data; + + position = _env->GetIntField(buffer, positionID); + limit = _env->GetIntField(buffer, limitID); + elementSizeShift = _env->GetIntField(buffer, elementSizeShiftID); + *remaining = (limit - position) << elementSizeShift; + pointer = _env->CallStaticLongMethod(nioAccessClass, + getBasePointerID, buffer); + if (pointer != 0L) { + *array = NULL; + return (void *) (jint) pointer; + } + + *array = (jarray) _env->CallStaticObjectMethod(nioAccessClass, + getBaseArrayID, buffer); + offset = _env->CallStaticIntMethod(nioAccessClass, + getBaseArrayOffsetID, buffer); + data = _env->GetPrimitiveArrayCritical(*array, (jboolean *) 0); + + return (void *) ((char *) data + offset); +} + + +static void +releasePointer(JNIEnv *_env, jarray array, void *data, jboolean commit) +{ + _env->ReleasePrimitiveArrayCritical(array, data, + commit ? 0 : JNI_ABORT); +} + +// -------------------------------------------------------------------------- + +/* void glActiveTexture ( GLenum texture ) */ +static void +android_glActiveTexture__I + (JNIEnv *_env, jobject _this, jint texture) { + glActiveTexture( + (GLenum)texture + ); +} + +/* void glAlphaFunc ( GLenum func, GLclampf ref ) */ +static void +android_glAlphaFunc__IF + (JNIEnv *_env, jobject _this, jint func, jfloat ref) { + glAlphaFunc( + (GLenum)func, + (GLclampf)ref + ); +} + +/* void glAlphaFuncx ( GLenum func, GLclampx ref ) */ +static void +android_glAlphaFuncx__II + (JNIEnv *_env, jobject _this, jint func, jint ref) { + glAlphaFuncx( + (GLenum)func, + (GLclampx)ref + ); +} + +/* void glBindTexture ( GLenum target, GLuint texture ) */ +static void +android_glBindTexture__II + (JNIEnv *_env, jobject _this, jint target, jint texture) { + glBindTexture( + (GLenum)target, + (GLuint)texture + ); +} + +/* void glBlendFunc ( GLenum sfactor, GLenum dfactor ) */ +static void +android_glBlendFunc__II + (JNIEnv *_env, jobject _this, jint sfactor, jint dfactor) { + glBlendFunc( + (GLenum)sfactor, + (GLenum)dfactor + ); +} + +/* void glClear ( GLbitfield mask ) */ +static void +android_glClear__I + (JNIEnv *_env, jobject _this, jint mask) { + glClear( + (GLbitfield)mask + ); +} + +/* void glClearColor ( GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha ) */ +static void +android_glClearColor__FFFF + (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) { + glClearColor( + (GLclampf)red, + (GLclampf)green, + (GLclampf)blue, + (GLclampf)alpha + ); +} + +/* void glClearColorx ( GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha ) */ +static void +android_glClearColorx__IIII + (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) { + glClearColorx( + (GLclampx)red, + (GLclampx)green, + (GLclampx)blue, + (GLclampx)alpha + ); +} + +/* void glClearDepthf ( GLclampf depth ) */ +static void +android_glClearDepthf__F + (JNIEnv *_env, jobject _this, jfloat depth) { + glClearDepthf( + (GLclampf)depth + ); +} + +/* void glClearDepthx ( GLclampx depth ) */ +static void +android_glClearDepthx__I + (JNIEnv *_env, jobject _this, jint depth) { + glClearDepthx( + (GLclampx)depth + ); +} + +/* void glClearStencil ( GLint s ) */ +static void +android_glClearStencil__I + (JNIEnv *_env, jobject _this, jint s) { + glClearStencil( + (GLint)s + ); +} + +/* void glClientActiveTexture ( GLenum texture ) */ +static void +android_glClientActiveTexture__I + (JNIEnv *_env, jobject _this, jint texture) { + glClientActiveTexture( + (GLenum)texture + ); +} + +/* void glColor4f ( GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha ) */ +static void +android_glColor4f__FFFF + (JNIEnv *_env, jobject _this, jfloat red, jfloat green, jfloat blue, jfloat alpha) { + glColor4f( + (GLfloat)red, + (GLfloat)green, + (GLfloat)blue, + (GLfloat)alpha + ); +} + +/* void glColor4x ( GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha ) */ +static void +android_glColor4x__IIII + (JNIEnv *_env, jobject _this, jint red, jint green, jint blue, jint alpha) { + glColor4x( + (GLfixed)red, + (GLfixed)green, + (GLfixed)blue, + (GLfixed)alpha + ); +} + +/* void glColorMask ( GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha ) */ +static void +android_glColorMask__ZZZZ + (JNIEnv *_env, jobject _this, jboolean red, jboolean green, jboolean blue, jboolean alpha) { + glColorMask( + (GLboolean)red, + (GLboolean)green, + (GLboolean)blue, + (GLboolean)alpha + ); +} + +/* void glColorPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ +static void +android_glColorPointerBounds__IIILjava_nio_Buffer_2I + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *pointer = (GLvoid *) 0; + + pointer = (GLvoid *)getPointer(_env, pointer_buf, &_array, &_remaining); + glColorPointerBounds( + (GLint)size, + (GLenum)type, + (GLsizei)stride, + (GLvoid *)pointer, + (GLsizei)remaining + ); + if (_array) { + releasePointer(_env, _array, pointer, JNI_FALSE); + } +} + +/* void glCompressedTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data ) */ +static void +android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint imageSize, jobject data_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *data = (GLvoid *) 0; + + data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining); + glCompressedTexImage2D( + (GLenum)target, + (GLint)level, + (GLenum)internalformat, + (GLsizei)width, + (GLsizei)height, + (GLint)border, + (GLsizei)imageSize, + (GLvoid *)data + ); + if (_array) { + releasePointer(_env, _array, data, JNI_FALSE); + } +} + +/* void glCompressedTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data ) */ +static void +android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint imageSize, jobject data_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *data = (GLvoid *) 0; + + data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining); + glCompressedTexSubImage2D( + (GLenum)target, + (GLint)level, + (GLint)xoffset, + (GLint)yoffset, + (GLsizei)width, + (GLsizei)height, + (GLenum)format, + (GLsizei)imageSize, + (GLvoid *)data + ); + if (_array) { + releasePointer(_env, _array, data, JNI_FALSE); + } +} + +/* void glCopyTexImage2D ( GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border ) */ +static void +android_glCopyTexImage2D__IIIIIIII + (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint x, jint y, jint width, jint height, jint border) { + glCopyTexImage2D( + (GLenum)target, + (GLint)level, + (GLenum)internalformat, + (GLint)x, + (GLint)y, + (GLsizei)width, + (GLsizei)height, + (GLint)border + ); +} + +/* void glCopyTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height ) */ +static void +android_glCopyTexSubImage2D__IIIIIIII + (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint x, jint y, jint width, jint height) { + glCopyTexSubImage2D( + (GLenum)target, + (GLint)level, + (GLint)xoffset, + (GLint)yoffset, + (GLint)x, + (GLint)y, + (GLsizei)width, + (GLsizei)height + ); +} + +/* void glCullFace ( GLenum mode ) */ +static void +android_glCullFace__I + (JNIEnv *_env, jobject _this, jint mode) { + glCullFace( + (GLenum)mode + ); +} + +/* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */ +static void +android_glDeleteTextures__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) { + GLuint *textures_base = (GLuint *) 0; + jint _remaining; + GLuint *textures = (GLuint *) 0; + + if (!textures_ref) { + _env->ThrowNew(IAEClass, "textures == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(textures_ref) - offset; + if (_remaining < n) { + _env->ThrowNew(IAEClass, "length - offset < n"); + goto exit; + } + textures_base = (GLuint *) + _env->GetPrimitiveArrayCritical(textures_ref, (jboolean *)0); + textures = textures_base + offset; + + glDeleteTextures( + (GLsizei)n, + (GLuint *)textures + ); + +exit: + if (textures_base) { + _env->ReleasePrimitiveArrayCritical(textures_ref, textures_base, + JNI_ABORT); + } +} + +/* void glDeleteTextures ( GLsizei n, const GLuint *textures ) */ +static void +android_glDeleteTextures__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLuint *textures = (GLuint *) 0; + + textures = (GLuint *)getPointer(_env, textures_buf, &_array, &_remaining); + if (_remaining < n) { + _env->ThrowNew(IAEClass, "remaining() < n"); + goto exit; + } + glDeleteTextures( + (GLsizei)n, + (GLuint *)textures + ); + +exit: + if (_array) { + releasePointer(_env, _array, textures, JNI_FALSE); + } +} + +/* void glDepthFunc ( GLenum func ) */ +static void +android_glDepthFunc__I + (JNIEnv *_env, jobject _this, jint func) { + glDepthFunc( + (GLenum)func + ); +} + +/* void glDepthMask ( GLboolean flag ) */ +static void +android_glDepthMask__Z + (JNIEnv *_env, jobject _this, jboolean flag) { + glDepthMask( + (GLboolean)flag + ); +} + +/* void glDepthRangef ( GLclampf zNear, GLclampf zFar ) */ +static void +android_glDepthRangef__FF + (JNIEnv *_env, jobject _this, jfloat zNear, jfloat zFar) { + glDepthRangef( + (GLclampf)zNear, + (GLclampf)zFar + ); +} + +/* void glDepthRangex ( GLclampx zNear, GLclampx zFar ) */ +static void +android_glDepthRangex__II + (JNIEnv *_env, jobject _this, jint zNear, jint zFar) { + glDepthRangex( + (GLclampx)zNear, + (GLclampx)zFar + ); +} + +/* void glDisable ( GLenum cap ) */ +static void +android_glDisable__I + (JNIEnv *_env, jobject _this, jint cap) { + glDisable( + (GLenum)cap + ); +} + +/* void glDisableClientState ( GLenum array ) */ +static void +android_glDisableClientState__I + (JNIEnv *_env, jobject _this, jint array) { + glDisableClientState( + (GLenum)array + ); +} + +/* void glDrawArrays ( GLenum mode, GLint first, GLsizei count ) */ +static void +android_glDrawArrays__III + (JNIEnv *_env, jobject _this, jint mode, jint first, jint count) { + glDrawArrays( + (GLenum)mode, + (GLint)first, + (GLsizei)count + ); +} + +/* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, const GLvoid *indices ) */ +static void +android_glDrawElements__IIILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jobject indices_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *indices = (GLvoid *) 0; + + indices = (GLvoid *)getPointer(_env, indices_buf, &_array, &_remaining); + glDrawElements( + (GLenum)mode, + (GLsizei)count, + (GLenum)type, + (GLvoid *)indices + ); + if (_array) { + releasePointer(_env, _array, indices, JNI_FALSE); + } +} + +/* void glEnable ( GLenum cap ) */ +static void +android_glEnable__I + (JNIEnv *_env, jobject _this, jint cap) { + glEnable( + (GLenum)cap + ); +} + +/* void glEnableClientState ( GLenum array ) */ +static void +android_glEnableClientState__I + (JNIEnv *_env, jobject _this, jint array) { + glEnableClientState( + (GLenum)array + ); +} + +/* void glFinish ( void ) */ +static void +android_glFinish__ + (JNIEnv *_env, jobject _this) { + glFinish(); +} + +/* void glFlush ( void ) */ +static void +android_glFlush__ + (JNIEnv *_env, jobject _this) { + glFlush(); +} + +/* void glFogf ( GLenum pname, GLfloat param ) */ +static void +android_glFogf__IF + (JNIEnv *_env, jobject _this, jint pname, jfloat param) { + glFogf( + (GLenum)pname, + (GLfloat)param + ); +} + +/* void glFogfv ( GLenum pname, const GLfloat *params ) */ +static void +android_glFogfv__I_3FI + (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_FOG_MODE) + case GL_FOG_MODE: +#endif // defined(GL_FOG_MODE) +#if defined(GL_FOG_DENSITY) + case GL_FOG_DENSITY: +#endif // defined(GL_FOG_DENSITY) +#if defined(GL_FOG_START) + case GL_FOG_START: +#endif // defined(GL_FOG_START) +#if defined(GL_FOG_END) + case GL_FOG_END: +#endif // defined(GL_FOG_END) + _needed = 1; + break; +#if defined(GL_FOG_COLOR) + case GL_FOG_COLOR: +#endif // defined(GL_FOG_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glFogfv( + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glFogfv ( GLenum pname, const GLfloat *params ) */ +static void +android_glFogfv__ILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_FOG_MODE) + case GL_FOG_MODE: +#endif // defined(GL_FOG_MODE) +#if defined(GL_FOG_DENSITY) + case GL_FOG_DENSITY: +#endif // defined(GL_FOG_DENSITY) +#if defined(GL_FOG_START) + case GL_FOG_START: +#endif // defined(GL_FOG_START) +#if defined(GL_FOG_END) + case GL_FOG_END: +#endif // defined(GL_FOG_END) + _needed = 1; + break; +#if defined(GL_FOG_COLOR) + case GL_FOG_COLOR: +#endif // defined(GL_FOG_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glFogfv( + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glFogx ( GLenum pname, GLfixed param ) */ +static void +android_glFogx__II + (JNIEnv *_env, jobject _this, jint pname, jint param) { + glFogx( + (GLenum)pname, + (GLfixed)param + ); +} + +/* void glFogxv ( GLenum pname, const GLfixed *params ) */ +static void +android_glFogxv__I_3II + (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_FOG_MODE) + case GL_FOG_MODE: +#endif // defined(GL_FOG_MODE) +#if defined(GL_FOG_DENSITY) + case GL_FOG_DENSITY: +#endif // defined(GL_FOG_DENSITY) +#if defined(GL_FOG_START) + case GL_FOG_START: +#endif // defined(GL_FOG_START) +#if defined(GL_FOG_END) + case GL_FOG_END: +#endif // defined(GL_FOG_END) + _needed = 1; + break; +#if defined(GL_FOG_COLOR) + case GL_FOG_COLOR: +#endif // defined(GL_FOG_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glFogxv( + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glFogxv ( GLenum pname, const GLfixed *params ) */ +static void +android_glFogxv__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_FOG_MODE) + case GL_FOG_MODE: +#endif // defined(GL_FOG_MODE) +#if defined(GL_FOG_DENSITY) + case GL_FOG_DENSITY: +#endif // defined(GL_FOG_DENSITY) +#if defined(GL_FOG_START) + case GL_FOG_START: +#endif // defined(GL_FOG_START) +#if defined(GL_FOG_END) + case GL_FOG_END: +#endif // defined(GL_FOG_END) + _needed = 1; + break; +#if defined(GL_FOG_COLOR) + case GL_FOG_COLOR: +#endif // defined(GL_FOG_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glFogxv( + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glFrontFace ( GLenum mode ) */ +static void +android_glFrontFace__I + (JNIEnv *_env, jobject _this, jint mode) { + glFrontFace( + (GLenum)mode + ); +} + +/* void glFrustumf ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */ +static void +android_glFrustumf__FFFFFF + (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) { + glFrustumf( + (GLfloat)left, + (GLfloat)right, + (GLfloat)bottom, + (GLfloat)top, + (GLfloat)zNear, + (GLfloat)zFar + ); +} + +/* void glFrustumx ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */ +static void +android_glFrustumx__IIIIII + (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) { + glFrustumx( + (GLfixed)left, + (GLfixed)right, + (GLfixed)bottom, + (GLfixed)top, + (GLfixed)zNear, + (GLfixed)zFar + ); +} + +/* void glGenTextures ( GLsizei n, GLuint *textures ) */ +static void +android_glGenTextures__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray textures_ref, jint offset) { + jint _exception = 0; + GLuint *textures_base = (GLuint *) 0; + jint _remaining; + GLuint *textures = (GLuint *) 0; + + if (!textures_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "textures == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(textures_ref) - offset; + if (_remaining < n) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < n"); + goto exit; + } + textures_base = (GLuint *) + _env->GetPrimitiveArrayCritical(textures_ref, (jboolean *)0); + textures = textures_base + offset; + + glGenTextures( + (GLsizei)n, + (GLuint *)textures + ); + +exit: + if (textures_base) { + _env->ReleasePrimitiveArrayCritical(textures_ref, textures_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGenTextures ( GLsizei n, GLuint *textures ) */ +static void +android_glGenTextures__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject textures_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLuint *textures = (GLuint *) 0; + + textures = (GLuint *)getPointer(_env, textures_buf, &_array, &_remaining); + if (_remaining < n) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < n"); + goto exit; + } + glGenTextures( + (GLsizei)n, + (GLuint *)textures + ); + +exit: + if (_array) { + releasePointer(_env, _array, textures, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* GLenum glGetError ( void ) */ +static jint +android_glGetError__ + (JNIEnv *_env, jobject _this) { + GLenum _returnValue; + _returnValue = glGetError(); + return _returnValue; +} + +/* void glGetIntegerv ( GLenum pname, GLint *params ) */ +static void +android_glGetIntegerv__I_3II + (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_ALPHA_BITS) + case GL_ALPHA_BITS: +#endif // defined(GL_ALPHA_BITS) +#if defined(GL_ALPHA_TEST_FUNC) + case GL_ALPHA_TEST_FUNC: +#endif // defined(GL_ALPHA_TEST_FUNC) +#if defined(GL_ALPHA_TEST_REF) + case GL_ALPHA_TEST_REF: +#endif // defined(GL_ALPHA_TEST_REF) +#if defined(GL_BLEND_DST) + case GL_BLEND_DST: +#endif // defined(GL_BLEND_DST) +#if defined(GL_BLUE_BITS) + case GL_BLUE_BITS: +#endif // defined(GL_BLUE_BITS) +#if defined(GL_COLOR_ARRAY_BUFFER_BINDING) + case GL_COLOR_ARRAY_BUFFER_BINDING: +#endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING) +#if defined(GL_COLOR_ARRAY_SIZE) + case GL_COLOR_ARRAY_SIZE: +#endif // defined(GL_COLOR_ARRAY_SIZE) +#if defined(GL_COLOR_ARRAY_STRIDE) + case GL_COLOR_ARRAY_STRIDE: +#endif // defined(GL_COLOR_ARRAY_STRIDE) +#if defined(GL_COLOR_ARRAY_TYPE) + case GL_COLOR_ARRAY_TYPE: +#endif // defined(GL_COLOR_ARRAY_TYPE) +#if defined(GL_CULL_FACE) + case GL_CULL_FACE: +#endif // defined(GL_CULL_FACE) +#if defined(GL_DEPTH_BITS) + case GL_DEPTH_BITS: +#endif // defined(GL_DEPTH_BITS) +#if defined(GL_DEPTH_CLEAR_VALUE) + case GL_DEPTH_CLEAR_VALUE: +#endif // defined(GL_DEPTH_CLEAR_VALUE) +#if defined(GL_DEPTH_FUNC) + case GL_DEPTH_FUNC: +#endif // defined(GL_DEPTH_FUNC) +#if defined(GL_DEPTH_WRITEMASK) + case GL_DEPTH_WRITEMASK: +#endif // defined(GL_DEPTH_WRITEMASK) +#if defined(GL_FOG_DENSITY) + case GL_FOG_DENSITY: +#endif // defined(GL_FOG_DENSITY) +#if defined(GL_FOG_END) + case GL_FOG_END: +#endif // defined(GL_FOG_END) +#if defined(GL_FOG_MODE) + case GL_FOG_MODE: +#endif // defined(GL_FOG_MODE) +#if defined(GL_FOG_START) + case GL_FOG_START: +#endif // defined(GL_FOG_START) +#if defined(GL_FRONT_FACE) + case GL_FRONT_FACE: +#endif // defined(GL_FRONT_FACE) +#if defined(GL_GREEN_BITS) + case GL_GREEN_BITS: +#endif // defined(GL_GREEN_BITS) +#if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES) + case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES: +#endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES) +#if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES) + case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES: +#endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES) +#if defined(GL_LIGHT_MODEL_TWO_SIDE) + case GL_LIGHT_MODEL_TWO_SIDE: +#endif // defined(GL_LIGHT_MODEL_TWO_SIDE) +#if defined(GL_LINE_SMOOTH_HINT) + case GL_LINE_SMOOTH_HINT: +#endif // defined(GL_LINE_SMOOTH_HINT) +#if defined(GL_LINE_WIDTH) + case GL_LINE_WIDTH: +#endif // defined(GL_LINE_WIDTH) +#if defined(GL_LOGIC_OP_MODE) + case GL_LOGIC_OP_MODE: +#endif // defined(GL_LOGIC_OP_MODE) +#if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES) + case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES: +#endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES) +#if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES) + case GL_MATRIX_INDEX_ARRAY_SIZE_OES: +#endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES) +#if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES) + case GL_MATRIX_INDEX_ARRAY_STRIDE_OES: +#endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES) +#if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES) + case GL_MATRIX_INDEX_ARRAY_TYPE_OES: +#endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES) +#if defined(GL_MATRIX_MODE) + case GL_MATRIX_MODE: +#endif // defined(GL_MATRIX_MODE) +#if defined(GL_MAX_CLIP_PLANES) + case GL_MAX_CLIP_PLANES: +#endif // defined(GL_MAX_CLIP_PLANES) +#if defined(GL_MAX_ELEMENTS_INDICES) + case GL_MAX_ELEMENTS_INDICES: +#endif // defined(GL_MAX_ELEMENTS_INDICES) +#if defined(GL_MAX_ELEMENTS_VERTICES) + case GL_MAX_ELEMENTS_VERTICES: +#endif // defined(GL_MAX_ELEMENTS_VERTICES) +#if defined(GL_MAX_LIGHTS) + case GL_MAX_LIGHTS: +#endif // defined(GL_MAX_LIGHTS) +#if defined(GL_MAX_MODELVIEW_STACK_DEPTH) + case GL_MAX_MODELVIEW_STACK_DEPTH: +#endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH) +#if defined(GL_MAX_PALETTE_MATRICES_OES) + case GL_MAX_PALETTE_MATRICES_OES: +#endif // defined(GL_MAX_PALETTE_MATRICES_OES) +#if defined(GL_MAX_PROJECTION_STACK_DEPTH) + case GL_MAX_PROJECTION_STACK_DEPTH: +#endif // defined(GL_MAX_PROJECTION_STACK_DEPTH) +#if defined(GL_MAX_TEXTURE_SIZE) + case GL_MAX_TEXTURE_SIZE: +#endif // defined(GL_MAX_TEXTURE_SIZE) +#if defined(GL_MAX_TEXTURE_STACK_DEPTH) + case GL_MAX_TEXTURE_STACK_DEPTH: +#endif // defined(GL_MAX_TEXTURE_STACK_DEPTH) +#if defined(GL_MAX_TEXTURE_UNITS) + case GL_MAX_TEXTURE_UNITS: +#endif // defined(GL_MAX_TEXTURE_UNITS) +#if defined(GL_MAX_VERTEX_UNITS_OES) + case GL_MAX_VERTEX_UNITS_OES: +#endif // defined(GL_MAX_VERTEX_UNITS_OES) +#if defined(GL_MODELVIEW_STACK_DEPTH) + case GL_MODELVIEW_STACK_DEPTH: +#endif // defined(GL_MODELVIEW_STACK_DEPTH) +#if defined(GL_NORMAL_ARRAY_BUFFER_BINDING) + case GL_NORMAL_ARRAY_BUFFER_BINDING: +#endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING) +#if defined(GL_NORMAL_ARRAY_STRIDE) + case GL_NORMAL_ARRAY_STRIDE: +#endif // defined(GL_NORMAL_ARRAY_STRIDE) +#if defined(GL_NORMAL_ARRAY_TYPE) + case GL_NORMAL_ARRAY_TYPE: +#endif // defined(GL_NORMAL_ARRAY_TYPE) +#if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS) + case GL_NUM_COMPRESSED_TEXTURE_FORMATS: +#endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS) +#if defined(GL_PACK_ALIGNMENT) + case GL_PACK_ALIGNMENT: +#endif // defined(GL_PACK_ALIGNMENT) +#if defined(GL_PERSPECTIVE_CORRECTION_HINT) + case GL_PERSPECTIVE_CORRECTION_HINT: +#endif // defined(GL_PERSPECTIVE_CORRECTION_HINT) +#if defined(GL_POINT_SIZE) + case GL_POINT_SIZE: +#endif // defined(GL_POINT_SIZE) +#if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES) + case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: +#endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES) +#if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES) + case GL_POINT_SIZE_ARRAY_STRIDE_OES: +#endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES) +#if defined(GL_POINT_SIZE_ARRAY_TYPE_OES) + case GL_POINT_SIZE_ARRAY_TYPE_OES: +#endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES) +#if defined(GL_POINT_SMOOTH_HINT) + case GL_POINT_SMOOTH_HINT: +#endif // defined(GL_POINT_SMOOTH_HINT) +#if defined(GL_POLYGON_OFFSET_FACTOR) + case GL_POLYGON_OFFSET_FACTOR: +#endif // defined(GL_POLYGON_OFFSET_FACTOR) +#if defined(GL_POLYGON_OFFSET_UNITS) + case GL_POLYGON_OFFSET_UNITS: +#endif // defined(GL_POLYGON_OFFSET_UNITS) +#if defined(GL_PROJECTION_STACK_DEPTH) + case GL_PROJECTION_STACK_DEPTH: +#endif // defined(GL_PROJECTION_STACK_DEPTH) +#if defined(GL_RED_BITS) + case GL_RED_BITS: +#endif // defined(GL_RED_BITS) +#if defined(GL_SHADE_MODEL) + case GL_SHADE_MODEL: +#endif // defined(GL_SHADE_MODEL) +#if defined(GL_STENCIL_BITS) + case GL_STENCIL_BITS: +#endif // defined(GL_STENCIL_BITS) +#if defined(GL_STENCIL_CLEAR_VALUE) + case GL_STENCIL_CLEAR_VALUE: +#endif // defined(GL_STENCIL_CLEAR_VALUE) +#if defined(GL_STENCIL_FAIL) + case GL_STENCIL_FAIL: +#endif // defined(GL_STENCIL_FAIL) +#if defined(GL_STENCIL_FUNC) + case GL_STENCIL_FUNC: +#endif // defined(GL_STENCIL_FUNC) +#if defined(GL_STENCIL_PASS_DEPTH_FAIL) + case GL_STENCIL_PASS_DEPTH_FAIL: +#endif // defined(GL_STENCIL_PASS_DEPTH_FAIL) +#if defined(GL_STENCIL_PASS_DEPTH_PASS) + case GL_STENCIL_PASS_DEPTH_PASS: +#endif // defined(GL_STENCIL_PASS_DEPTH_PASS) +#if defined(GL_STENCIL_REF) + case GL_STENCIL_REF: +#endif // defined(GL_STENCIL_REF) +#if defined(GL_STENCIL_VALUE_MASK) + case GL_STENCIL_VALUE_MASK: +#endif // defined(GL_STENCIL_VALUE_MASK) +#if defined(GL_STENCIL_WRITEMASK) + case GL_STENCIL_WRITEMASK: +#endif // defined(GL_STENCIL_WRITEMASK) +#if defined(GL_SUBPIXEL_BITS) + case GL_SUBPIXEL_BITS: +#endif // defined(GL_SUBPIXEL_BITS) +#if defined(GL_TEXTURE_BINDING_2D) + case GL_TEXTURE_BINDING_2D: +#endif // defined(GL_TEXTURE_BINDING_2D) +#if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING) + case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: +#endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING) +#if defined(GL_TEXTURE_COORD_ARRAY_SIZE) + case GL_TEXTURE_COORD_ARRAY_SIZE: +#endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE) +#if defined(GL_TEXTURE_COORD_ARRAY_STRIDE) + case GL_TEXTURE_COORD_ARRAY_STRIDE: +#endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE) +#if defined(GL_TEXTURE_COORD_ARRAY_TYPE) + case GL_TEXTURE_COORD_ARRAY_TYPE: +#endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE) +#if defined(GL_TEXTURE_STACK_DEPTH) + case GL_TEXTURE_STACK_DEPTH: +#endif // defined(GL_TEXTURE_STACK_DEPTH) +#if defined(GL_UNPACK_ALIGNMENT) + case GL_UNPACK_ALIGNMENT: +#endif // defined(GL_UNPACK_ALIGNMENT) +#if defined(GL_VERTEX_ARRAY_BUFFER_BINDING) + case GL_VERTEX_ARRAY_BUFFER_BINDING: +#endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING) +#if defined(GL_VERTEX_ARRAY_SIZE) + case GL_VERTEX_ARRAY_SIZE: +#endif // defined(GL_VERTEX_ARRAY_SIZE) +#if defined(GL_VERTEX_ARRAY_STRIDE) + case GL_VERTEX_ARRAY_STRIDE: +#endif // defined(GL_VERTEX_ARRAY_STRIDE) +#if defined(GL_VERTEX_ARRAY_TYPE) + case GL_VERTEX_ARRAY_TYPE: +#endif // defined(GL_VERTEX_ARRAY_TYPE) +#if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES) + case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES: +#endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES) +#if defined(GL_WEIGHT_ARRAY_SIZE_OES) + case GL_WEIGHT_ARRAY_SIZE_OES: +#endif // defined(GL_WEIGHT_ARRAY_SIZE_OES) +#if defined(GL_WEIGHT_ARRAY_STRIDE_OES) + case GL_WEIGHT_ARRAY_STRIDE_OES: +#endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES) +#if defined(GL_WEIGHT_ARRAY_TYPE_OES) + case GL_WEIGHT_ARRAY_TYPE_OES: +#endif // defined(GL_WEIGHT_ARRAY_TYPE_OES) + _needed = 1; + break; +#if defined(GL_ALIASED_POINT_SIZE_RANGE) + case GL_ALIASED_POINT_SIZE_RANGE: +#endif // defined(GL_ALIASED_POINT_SIZE_RANGE) +#if defined(GL_ALIASED_LINE_WIDTH_RANGE) + case GL_ALIASED_LINE_WIDTH_RANGE: +#endif // defined(GL_ALIASED_LINE_WIDTH_RANGE) +#if defined(GL_DEPTH_RANGE) + case GL_DEPTH_RANGE: +#endif // defined(GL_DEPTH_RANGE) +#if defined(GL_MAX_VIEWPORT_DIMS) + case GL_MAX_VIEWPORT_DIMS: +#endif // defined(GL_MAX_VIEWPORT_DIMS) +#if defined(GL_SMOOTH_LINE_WIDTH_RANGE) + case GL_SMOOTH_LINE_WIDTH_RANGE: +#endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE) +#if defined(GL_SMOOTH_POINT_SIZE_RANGE) + case GL_SMOOTH_POINT_SIZE_RANGE: +#endif // defined(GL_SMOOTH_POINT_SIZE_RANGE) + _needed = 2; + break; +#if defined(GL_COLOR_CLEAR_VALUE) + case GL_COLOR_CLEAR_VALUE: +#endif // defined(GL_COLOR_CLEAR_VALUE) +#if defined(GL_COLOR_WRITEMASK) + case GL_COLOR_WRITEMASK: +#endif // defined(GL_COLOR_WRITEMASK) +#if defined(GL_SCISSOR_BOX) + case GL_SCISSOR_BOX: +#endif // defined(GL_SCISSOR_BOX) +#if defined(GL_VIEWPORT) + case GL_VIEWPORT: +#endif // defined(GL_VIEWPORT) + _needed = 4; + break; +#if defined(GL_MODELVIEW_MATRIX) + case GL_MODELVIEW_MATRIX: +#endif // defined(GL_MODELVIEW_MATRIX) +#if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES) + case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: +#endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES) +#if defined(GL_PROJECTION_MATRIX) + case GL_PROJECTION_MATRIX: +#endif // defined(GL_PROJECTION_MATRIX) +#if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES) + case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: +#endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES) +#if defined(GL_TEXTURE_MATRIX) + case GL_TEXTURE_MATRIX: +#endif // defined(GL_TEXTURE_MATRIX) +#if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES) + case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: +#endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES) + _needed = 16; + break; +#if defined(GL_COMPRESSED_TEXTURE_FORMATS) + case GL_COMPRESSED_TEXTURE_FORMATS: +#endif // defined(GL_COMPRESSED_TEXTURE_FORMATS) +#if defined(GL_FOG_COLOR) + case GL_FOG_COLOR: +#endif // defined(GL_FOG_COLOR) +#if defined(GL_LIGHT_MODEL_AMBIENT) + case GL_LIGHT_MODEL_AMBIENT: +#endif // defined(GL_LIGHT_MODEL_AMBIENT) + _needed = _NUM_COMPRESSED_TEXTURE_FORMATS; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetIntegerv( + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetIntegerv ( GLenum pname, GLint *params ) */ +static void +android_glGetIntegerv__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_ALPHA_BITS) + case GL_ALPHA_BITS: +#endif // defined(GL_ALPHA_BITS) +#if defined(GL_ALPHA_TEST_FUNC) + case GL_ALPHA_TEST_FUNC: +#endif // defined(GL_ALPHA_TEST_FUNC) +#if defined(GL_ALPHA_TEST_REF) + case GL_ALPHA_TEST_REF: +#endif // defined(GL_ALPHA_TEST_REF) +#if defined(GL_BLEND_DST) + case GL_BLEND_DST: +#endif // defined(GL_BLEND_DST) +#if defined(GL_BLUE_BITS) + case GL_BLUE_BITS: +#endif // defined(GL_BLUE_BITS) +#if defined(GL_COLOR_ARRAY_BUFFER_BINDING) + case GL_COLOR_ARRAY_BUFFER_BINDING: +#endif // defined(GL_COLOR_ARRAY_BUFFER_BINDING) +#if defined(GL_COLOR_ARRAY_SIZE) + case GL_COLOR_ARRAY_SIZE: +#endif // defined(GL_COLOR_ARRAY_SIZE) +#if defined(GL_COLOR_ARRAY_STRIDE) + case GL_COLOR_ARRAY_STRIDE: +#endif // defined(GL_COLOR_ARRAY_STRIDE) +#if defined(GL_COLOR_ARRAY_TYPE) + case GL_COLOR_ARRAY_TYPE: +#endif // defined(GL_COLOR_ARRAY_TYPE) +#if defined(GL_CULL_FACE) + case GL_CULL_FACE: +#endif // defined(GL_CULL_FACE) +#if defined(GL_DEPTH_BITS) + case GL_DEPTH_BITS: +#endif // defined(GL_DEPTH_BITS) +#if defined(GL_DEPTH_CLEAR_VALUE) + case GL_DEPTH_CLEAR_VALUE: +#endif // defined(GL_DEPTH_CLEAR_VALUE) +#if defined(GL_DEPTH_FUNC) + case GL_DEPTH_FUNC: +#endif // defined(GL_DEPTH_FUNC) +#if defined(GL_DEPTH_WRITEMASK) + case GL_DEPTH_WRITEMASK: +#endif // defined(GL_DEPTH_WRITEMASK) +#if defined(GL_FOG_DENSITY) + case GL_FOG_DENSITY: +#endif // defined(GL_FOG_DENSITY) +#if defined(GL_FOG_END) + case GL_FOG_END: +#endif // defined(GL_FOG_END) +#if defined(GL_FOG_MODE) + case GL_FOG_MODE: +#endif // defined(GL_FOG_MODE) +#if defined(GL_FOG_START) + case GL_FOG_START: +#endif // defined(GL_FOG_START) +#if defined(GL_FRONT_FACE) + case GL_FRONT_FACE: +#endif // defined(GL_FRONT_FACE) +#if defined(GL_GREEN_BITS) + case GL_GREEN_BITS: +#endif // defined(GL_GREEN_BITS) +#if defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES) + case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES: +#endif // defined(GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES) +#if defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES) + case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES: +#endif // defined(GL_IMPLEMENTATION_COLOR_READ_TYPE_OES) +#if defined(GL_LIGHT_MODEL_TWO_SIDE) + case GL_LIGHT_MODEL_TWO_SIDE: +#endif // defined(GL_LIGHT_MODEL_TWO_SIDE) +#if defined(GL_LINE_SMOOTH_HINT) + case GL_LINE_SMOOTH_HINT: +#endif // defined(GL_LINE_SMOOTH_HINT) +#if defined(GL_LINE_WIDTH) + case GL_LINE_WIDTH: +#endif // defined(GL_LINE_WIDTH) +#if defined(GL_LOGIC_OP_MODE) + case GL_LOGIC_OP_MODE: +#endif // defined(GL_LOGIC_OP_MODE) +#if defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES) + case GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES: +#endif // defined(GL_MATRIX_INDEX_ARRAY_BUFFER_BINDING_OES) +#if defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES) + case GL_MATRIX_INDEX_ARRAY_SIZE_OES: +#endif // defined(GL_MATRIX_INDEX_ARRAY_SIZE_OES) +#if defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES) + case GL_MATRIX_INDEX_ARRAY_STRIDE_OES: +#endif // defined(GL_MATRIX_INDEX_ARRAY_STRIDE_OES) +#if defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES) + case GL_MATRIX_INDEX_ARRAY_TYPE_OES: +#endif // defined(GL_MATRIX_INDEX_ARRAY_TYPE_OES) +#if defined(GL_MATRIX_MODE) + case GL_MATRIX_MODE: +#endif // defined(GL_MATRIX_MODE) +#if defined(GL_MAX_CLIP_PLANES) + case GL_MAX_CLIP_PLANES: +#endif // defined(GL_MAX_CLIP_PLANES) +#if defined(GL_MAX_ELEMENTS_INDICES) + case GL_MAX_ELEMENTS_INDICES: +#endif // defined(GL_MAX_ELEMENTS_INDICES) +#if defined(GL_MAX_ELEMENTS_VERTICES) + case GL_MAX_ELEMENTS_VERTICES: +#endif // defined(GL_MAX_ELEMENTS_VERTICES) +#if defined(GL_MAX_LIGHTS) + case GL_MAX_LIGHTS: +#endif // defined(GL_MAX_LIGHTS) +#if defined(GL_MAX_MODELVIEW_STACK_DEPTH) + case GL_MAX_MODELVIEW_STACK_DEPTH: +#endif // defined(GL_MAX_MODELVIEW_STACK_DEPTH) +#if defined(GL_MAX_PALETTE_MATRICES_OES) + case GL_MAX_PALETTE_MATRICES_OES: +#endif // defined(GL_MAX_PALETTE_MATRICES_OES) +#if defined(GL_MAX_PROJECTION_STACK_DEPTH) + case GL_MAX_PROJECTION_STACK_DEPTH: +#endif // defined(GL_MAX_PROJECTION_STACK_DEPTH) +#if defined(GL_MAX_TEXTURE_SIZE) + case GL_MAX_TEXTURE_SIZE: +#endif // defined(GL_MAX_TEXTURE_SIZE) +#if defined(GL_MAX_TEXTURE_STACK_DEPTH) + case GL_MAX_TEXTURE_STACK_DEPTH: +#endif // defined(GL_MAX_TEXTURE_STACK_DEPTH) +#if defined(GL_MAX_TEXTURE_UNITS) + case GL_MAX_TEXTURE_UNITS: +#endif // defined(GL_MAX_TEXTURE_UNITS) +#if defined(GL_MAX_VERTEX_UNITS_OES) + case GL_MAX_VERTEX_UNITS_OES: +#endif // defined(GL_MAX_VERTEX_UNITS_OES) +#if defined(GL_MODELVIEW_STACK_DEPTH) + case GL_MODELVIEW_STACK_DEPTH: +#endif // defined(GL_MODELVIEW_STACK_DEPTH) +#if defined(GL_NORMAL_ARRAY_BUFFER_BINDING) + case GL_NORMAL_ARRAY_BUFFER_BINDING: +#endif // defined(GL_NORMAL_ARRAY_BUFFER_BINDING) +#if defined(GL_NORMAL_ARRAY_STRIDE) + case GL_NORMAL_ARRAY_STRIDE: +#endif // defined(GL_NORMAL_ARRAY_STRIDE) +#if defined(GL_NORMAL_ARRAY_TYPE) + case GL_NORMAL_ARRAY_TYPE: +#endif // defined(GL_NORMAL_ARRAY_TYPE) +#if defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS) + case GL_NUM_COMPRESSED_TEXTURE_FORMATS: +#endif // defined(GL_NUM_COMPRESSED_TEXTURE_FORMATS) +#if defined(GL_PACK_ALIGNMENT) + case GL_PACK_ALIGNMENT: +#endif // defined(GL_PACK_ALIGNMENT) +#if defined(GL_PERSPECTIVE_CORRECTION_HINT) + case GL_PERSPECTIVE_CORRECTION_HINT: +#endif // defined(GL_PERSPECTIVE_CORRECTION_HINT) +#if defined(GL_POINT_SIZE) + case GL_POINT_SIZE: +#endif // defined(GL_POINT_SIZE) +#if defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES) + case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES: +#endif // defined(GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES) +#if defined(GL_POINT_SIZE_ARRAY_STRIDE_OES) + case GL_POINT_SIZE_ARRAY_STRIDE_OES: +#endif // defined(GL_POINT_SIZE_ARRAY_STRIDE_OES) +#if defined(GL_POINT_SIZE_ARRAY_TYPE_OES) + case GL_POINT_SIZE_ARRAY_TYPE_OES: +#endif // defined(GL_POINT_SIZE_ARRAY_TYPE_OES) +#if defined(GL_POINT_SMOOTH_HINT) + case GL_POINT_SMOOTH_HINT: +#endif // defined(GL_POINT_SMOOTH_HINT) +#if defined(GL_POLYGON_OFFSET_FACTOR) + case GL_POLYGON_OFFSET_FACTOR: +#endif // defined(GL_POLYGON_OFFSET_FACTOR) +#if defined(GL_POLYGON_OFFSET_UNITS) + case GL_POLYGON_OFFSET_UNITS: +#endif // defined(GL_POLYGON_OFFSET_UNITS) +#if defined(GL_PROJECTION_STACK_DEPTH) + case GL_PROJECTION_STACK_DEPTH: +#endif // defined(GL_PROJECTION_STACK_DEPTH) +#if defined(GL_RED_BITS) + case GL_RED_BITS: +#endif // defined(GL_RED_BITS) +#if defined(GL_SHADE_MODEL) + case GL_SHADE_MODEL: +#endif // defined(GL_SHADE_MODEL) +#if defined(GL_STENCIL_BITS) + case GL_STENCIL_BITS: +#endif // defined(GL_STENCIL_BITS) +#if defined(GL_STENCIL_CLEAR_VALUE) + case GL_STENCIL_CLEAR_VALUE: +#endif // defined(GL_STENCIL_CLEAR_VALUE) +#if defined(GL_STENCIL_FAIL) + case GL_STENCIL_FAIL: +#endif // defined(GL_STENCIL_FAIL) +#if defined(GL_STENCIL_FUNC) + case GL_STENCIL_FUNC: +#endif // defined(GL_STENCIL_FUNC) +#if defined(GL_STENCIL_PASS_DEPTH_FAIL) + case GL_STENCIL_PASS_DEPTH_FAIL: +#endif // defined(GL_STENCIL_PASS_DEPTH_FAIL) +#if defined(GL_STENCIL_PASS_DEPTH_PASS) + case GL_STENCIL_PASS_DEPTH_PASS: +#endif // defined(GL_STENCIL_PASS_DEPTH_PASS) +#if defined(GL_STENCIL_REF) + case GL_STENCIL_REF: +#endif // defined(GL_STENCIL_REF) +#if defined(GL_STENCIL_VALUE_MASK) + case GL_STENCIL_VALUE_MASK: +#endif // defined(GL_STENCIL_VALUE_MASK) +#if defined(GL_STENCIL_WRITEMASK) + case GL_STENCIL_WRITEMASK: +#endif // defined(GL_STENCIL_WRITEMASK) +#if defined(GL_SUBPIXEL_BITS) + case GL_SUBPIXEL_BITS: +#endif // defined(GL_SUBPIXEL_BITS) +#if defined(GL_TEXTURE_BINDING_2D) + case GL_TEXTURE_BINDING_2D: +#endif // defined(GL_TEXTURE_BINDING_2D) +#if defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING) + case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING: +#endif // defined(GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING) +#if defined(GL_TEXTURE_COORD_ARRAY_SIZE) + case GL_TEXTURE_COORD_ARRAY_SIZE: +#endif // defined(GL_TEXTURE_COORD_ARRAY_SIZE) +#if defined(GL_TEXTURE_COORD_ARRAY_STRIDE) + case GL_TEXTURE_COORD_ARRAY_STRIDE: +#endif // defined(GL_TEXTURE_COORD_ARRAY_STRIDE) +#if defined(GL_TEXTURE_COORD_ARRAY_TYPE) + case GL_TEXTURE_COORD_ARRAY_TYPE: +#endif // defined(GL_TEXTURE_COORD_ARRAY_TYPE) +#if defined(GL_TEXTURE_STACK_DEPTH) + case GL_TEXTURE_STACK_DEPTH: +#endif // defined(GL_TEXTURE_STACK_DEPTH) +#if defined(GL_UNPACK_ALIGNMENT) + case GL_UNPACK_ALIGNMENT: +#endif // defined(GL_UNPACK_ALIGNMENT) +#if defined(GL_VERTEX_ARRAY_BUFFER_BINDING) + case GL_VERTEX_ARRAY_BUFFER_BINDING: +#endif // defined(GL_VERTEX_ARRAY_BUFFER_BINDING) +#if defined(GL_VERTEX_ARRAY_SIZE) + case GL_VERTEX_ARRAY_SIZE: +#endif // defined(GL_VERTEX_ARRAY_SIZE) +#if defined(GL_VERTEX_ARRAY_STRIDE) + case GL_VERTEX_ARRAY_STRIDE: +#endif // defined(GL_VERTEX_ARRAY_STRIDE) +#if defined(GL_VERTEX_ARRAY_TYPE) + case GL_VERTEX_ARRAY_TYPE: +#endif // defined(GL_VERTEX_ARRAY_TYPE) +#if defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES) + case GL_WEIGHT_ARRAY_BUFFER_BINDING_OES: +#endif // defined(GL_WEIGHT_ARRAY_BUFFER_BINDING_OES) +#if defined(GL_WEIGHT_ARRAY_SIZE_OES) + case GL_WEIGHT_ARRAY_SIZE_OES: +#endif // defined(GL_WEIGHT_ARRAY_SIZE_OES) +#if defined(GL_WEIGHT_ARRAY_STRIDE_OES) + case GL_WEIGHT_ARRAY_STRIDE_OES: +#endif // defined(GL_WEIGHT_ARRAY_STRIDE_OES) +#if defined(GL_WEIGHT_ARRAY_TYPE_OES) + case GL_WEIGHT_ARRAY_TYPE_OES: +#endif // defined(GL_WEIGHT_ARRAY_TYPE_OES) + _needed = 1; + break; +#if defined(GL_ALIASED_POINT_SIZE_RANGE) + case GL_ALIASED_POINT_SIZE_RANGE: +#endif // defined(GL_ALIASED_POINT_SIZE_RANGE) +#if defined(GL_ALIASED_LINE_WIDTH_RANGE) + case GL_ALIASED_LINE_WIDTH_RANGE: +#endif // defined(GL_ALIASED_LINE_WIDTH_RANGE) +#if defined(GL_DEPTH_RANGE) + case GL_DEPTH_RANGE: +#endif // defined(GL_DEPTH_RANGE) +#if defined(GL_MAX_VIEWPORT_DIMS) + case GL_MAX_VIEWPORT_DIMS: +#endif // defined(GL_MAX_VIEWPORT_DIMS) +#if defined(GL_SMOOTH_LINE_WIDTH_RANGE) + case GL_SMOOTH_LINE_WIDTH_RANGE: +#endif // defined(GL_SMOOTH_LINE_WIDTH_RANGE) +#if defined(GL_SMOOTH_POINT_SIZE_RANGE) + case GL_SMOOTH_POINT_SIZE_RANGE: +#endif // defined(GL_SMOOTH_POINT_SIZE_RANGE) + _needed = 2; + break; +#if defined(GL_COLOR_CLEAR_VALUE) + case GL_COLOR_CLEAR_VALUE: +#endif // defined(GL_COLOR_CLEAR_VALUE) +#if defined(GL_COLOR_WRITEMASK) + case GL_COLOR_WRITEMASK: +#endif // defined(GL_COLOR_WRITEMASK) +#if defined(GL_SCISSOR_BOX) + case GL_SCISSOR_BOX: +#endif // defined(GL_SCISSOR_BOX) +#if defined(GL_VIEWPORT) + case GL_VIEWPORT: +#endif // defined(GL_VIEWPORT) + _needed = 4; + break; +#if defined(GL_MODELVIEW_MATRIX) + case GL_MODELVIEW_MATRIX: +#endif // defined(GL_MODELVIEW_MATRIX) +#if defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES) + case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES: +#endif // defined(GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES) +#if defined(GL_PROJECTION_MATRIX) + case GL_PROJECTION_MATRIX: +#endif // defined(GL_PROJECTION_MATRIX) +#if defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES) + case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES: +#endif // defined(GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES) +#if defined(GL_TEXTURE_MATRIX) + case GL_TEXTURE_MATRIX: +#endif // defined(GL_TEXTURE_MATRIX) +#if defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES) + case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES: +#endif // defined(GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES) + _needed = 16; + break; +#if defined(GL_COMPRESSED_TEXTURE_FORMATS) + case GL_COMPRESSED_TEXTURE_FORMATS: +#endif // defined(GL_COMPRESSED_TEXTURE_FORMATS) +#if defined(GL_FOG_COLOR) + case GL_FOG_COLOR: +#endif // defined(GL_FOG_COLOR) +#if defined(GL_LIGHT_MODEL_AMBIENT) + case GL_LIGHT_MODEL_AMBIENT: +#endif // defined(GL_LIGHT_MODEL_AMBIENT) + _needed = _NUM_COMPRESSED_TEXTURE_FORMATS; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glGetIntegerv( + (GLenum)pname, + (GLint *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +#include <string.h> + +/* const GLubyte * glGetString ( GLenum name ) */ +jstring +android_glGetString + (JNIEnv *_env, jobject _this, jint name) { + const GLubyte * chars = glGetString((GLenum)name); + + int len = strlen((const char *)chars); + jchar * wchars = (jchar *)malloc(len * sizeof(jchar)); + if (wchars == (jchar*) 0) { + _env->ThrowNew(OOMEClass, "No space for glGetString output"); + return (jstring) 0; + } + // Copy bytes -> chars, including trailing '\0' + for (int i = 0; i <= len; i++) { + wchars[i] = (jchar) chars[i]; + } + jstring output = _env->NewString(wchars, (jsize) len); + free(wchars); + return output; +} +/* void glHint ( GLenum target, GLenum mode ) */ +static void +android_glHint__II + (JNIEnv *_env, jobject _this, jint target, jint mode) { + glHint( + (GLenum)target, + (GLenum)mode + ); +} + +/* void glLightModelf ( GLenum pname, GLfloat param ) */ +static void +android_glLightModelf__IF + (JNIEnv *_env, jobject _this, jint pname, jfloat param) { + glLightModelf( + (GLenum)pname, + (GLfloat)param + ); +} + +/* void glLightModelfv ( GLenum pname, const GLfloat *params ) */ +static void +android_glLightModelfv__I_3FI + (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_LIGHT_MODEL_TWO_SIDE) + case GL_LIGHT_MODEL_TWO_SIDE: +#endif // defined(GL_LIGHT_MODEL_TWO_SIDE) + _needed = 1; + break; +#if defined(GL_LIGHT_MODEL_AMBIENT) + case GL_LIGHT_MODEL_AMBIENT: +#endif // defined(GL_LIGHT_MODEL_AMBIENT) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glLightModelfv( + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glLightModelfv ( GLenum pname, const GLfloat *params ) */ +static void +android_glLightModelfv__ILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_LIGHT_MODEL_TWO_SIDE) + case GL_LIGHT_MODEL_TWO_SIDE: +#endif // defined(GL_LIGHT_MODEL_TWO_SIDE) + _needed = 1; + break; +#if defined(GL_LIGHT_MODEL_AMBIENT) + case GL_LIGHT_MODEL_AMBIENT: +#endif // defined(GL_LIGHT_MODEL_AMBIENT) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glLightModelfv( + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glLightModelx ( GLenum pname, GLfixed param ) */ +static void +android_glLightModelx__II + (JNIEnv *_env, jobject _this, jint pname, jint param) { + glLightModelx( + (GLenum)pname, + (GLfixed)param + ); +} + +/* void glLightModelxv ( GLenum pname, const GLfixed *params ) */ +static void +android_glLightModelxv__I_3II + (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_LIGHT_MODEL_TWO_SIDE) + case GL_LIGHT_MODEL_TWO_SIDE: +#endif // defined(GL_LIGHT_MODEL_TWO_SIDE) + _needed = 1; + break; +#if defined(GL_LIGHT_MODEL_AMBIENT) + case GL_LIGHT_MODEL_AMBIENT: +#endif // defined(GL_LIGHT_MODEL_AMBIENT) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glLightModelxv( + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glLightModelxv ( GLenum pname, const GLfixed *params ) */ +static void +android_glLightModelxv__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_LIGHT_MODEL_TWO_SIDE) + case GL_LIGHT_MODEL_TWO_SIDE: +#endif // defined(GL_LIGHT_MODEL_TWO_SIDE) + _needed = 1; + break; +#if defined(GL_LIGHT_MODEL_AMBIENT) + case GL_LIGHT_MODEL_AMBIENT: +#endif // defined(GL_LIGHT_MODEL_AMBIENT) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glLightModelxv( + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glLightf ( GLenum light, GLenum pname, GLfloat param ) */ +static void +android_glLightf__IIF + (JNIEnv *_env, jobject _this, jint light, jint pname, jfloat param) { + glLightf( + (GLenum)light, + (GLenum)pname, + (GLfloat)param + ); +} + +/* void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) */ +static void +android_glLightfv__II_3FI + (JNIEnv *_env, jobject _this, jint light, jint pname, jfloatArray params_ref, jint offset) { + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_SPOT_EXPONENT) + case GL_SPOT_EXPONENT: +#endif // defined(GL_SPOT_EXPONENT) +#if defined(GL_SPOT_CUTOFF) + case GL_SPOT_CUTOFF: +#endif // defined(GL_SPOT_CUTOFF) +#if defined(GL_CONSTANT_ATTENUATION) + case GL_CONSTANT_ATTENUATION: +#endif // defined(GL_CONSTANT_ATTENUATION) +#if defined(GL_LINEAR_ATTENUATION) + case GL_LINEAR_ATTENUATION: +#endif // defined(GL_LINEAR_ATTENUATION) +#if defined(GL_QUADRATIC_ATTENUATION) + case GL_QUADRATIC_ATTENUATION: +#endif // defined(GL_QUADRATIC_ATTENUATION) + _needed = 1; + break; +#if defined(GL_SPOT_DIRECTION) + case GL_SPOT_DIRECTION: +#endif // defined(GL_SPOT_DIRECTION) + _needed = 3; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glLightfv( + (GLenum)light, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glLightfv ( GLenum light, GLenum pname, const GLfloat *params ) */ +static void +android_glLightfv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_SPOT_EXPONENT) + case GL_SPOT_EXPONENT: +#endif // defined(GL_SPOT_EXPONENT) +#if defined(GL_SPOT_CUTOFF) + case GL_SPOT_CUTOFF: +#endif // defined(GL_SPOT_CUTOFF) +#if defined(GL_CONSTANT_ATTENUATION) + case GL_CONSTANT_ATTENUATION: +#endif // defined(GL_CONSTANT_ATTENUATION) +#if defined(GL_LINEAR_ATTENUATION) + case GL_LINEAR_ATTENUATION: +#endif // defined(GL_LINEAR_ATTENUATION) +#if defined(GL_QUADRATIC_ATTENUATION) + case GL_QUADRATIC_ATTENUATION: +#endif // defined(GL_QUADRATIC_ATTENUATION) + _needed = 1; + break; +#if defined(GL_SPOT_DIRECTION) + case GL_SPOT_DIRECTION: +#endif // defined(GL_SPOT_DIRECTION) + _needed = 3; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glLightfv( + (GLenum)light, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glLightx ( GLenum light, GLenum pname, GLfixed param ) */ +static void +android_glLightx__III + (JNIEnv *_env, jobject _this, jint light, jint pname, jint param) { + glLightx( + (GLenum)light, + (GLenum)pname, + (GLfixed)param + ); +} + +/* void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) */ +static void +android_glLightxv__II_3II + (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) { + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_SPOT_EXPONENT) + case GL_SPOT_EXPONENT: +#endif // defined(GL_SPOT_EXPONENT) +#if defined(GL_SPOT_CUTOFF) + case GL_SPOT_CUTOFF: +#endif // defined(GL_SPOT_CUTOFF) +#if defined(GL_CONSTANT_ATTENUATION) + case GL_CONSTANT_ATTENUATION: +#endif // defined(GL_CONSTANT_ATTENUATION) +#if defined(GL_LINEAR_ATTENUATION) + case GL_LINEAR_ATTENUATION: +#endif // defined(GL_LINEAR_ATTENUATION) +#if defined(GL_QUADRATIC_ATTENUATION) + case GL_QUADRATIC_ATTENUATION: +#endif // defined(GL_QUADRATIC_ATTENUATION) + _needed = 1; + break; +#if defined(GL_SPOT_DIRECTION) + case GL_SPOT_DIRECTION: +#endif // defined(GL_SPOT_DIRECTION) + _needed = 3; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glLightxv( + (GLenum)light, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glLightxv ( GLenum light, GLenum pname, const GLfixed *params ) */ +static void +android_glLightxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_SPOT_EXPONENT) + case GL_SPOT_EXPONENT: +#endif // defined(GL_SPOT_EXPONENT) +#if defined(GL_SPOT_CUTOFF) + case GL_SPOT_CUTOFF: +#endif // defined(GL_SPOT_CUTOFF) +#if defined(GL_CONSTANT_ATTENUATION) + case GL_CONSTANT_ATTENUATION: +#endif // defined(GL_CONSTANT_ATTENUATION) +#if defined(GL_LINEAR_ATTENUATION) + case GL_LINEAR_ATTENUATION: +#endif // defined(GL_LINEAR_ATTENUATION) +#if defined(GL_QUADRATIC_ATTENUATION) + case GL_QUADRATIC_ATTENUATION: +#endif // defined(GL_QUADRATIC_ATTENUATION) + _needed = 1; + break; +#if defined(GL_SPOT_DIRECTION) + case GL_SPOT_DIRECTION: +#endif // defined(GL_SPOT_DIRECTION) + _needed = 3; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glLightxv( + (GLenum)light, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glLineWidth ( GLfloat width ) */ +static void +android_glLineWidth__F + (JNIEnv *_env, jobject _this, jfloat width) { + glLineWidth( + (GLfloat)width + ); +} + +/* void glLineWidthx ( GLfixed width ) */ +static void +android_glLineWidthx__I + (JNIEnv *_env, jobject _this, jint width) { + glLineWidthx( + (GLfixed)width + ); +} + +/* void glLoadIdentity ( void ) */ +static void +android_glLoadIdentity__ + (JNIEnv *_env, jobject _this) { + glLoadIdentity(); +} + +/* void glLoadMatrixf ( const GLfloat *m ) */ +static void +android_glLoadMatrixf___3FI + (JNIEnv *_env, jobject _this, jfloatArray m_ref, jint offset) { + GLfloat *m_base = (GLfloat *) 0; + jint _remaining; + GLfloat *m = (GLfloat *) 0; + + if (!m_ref) { + _env->ThrowNew(IAEClass, "m == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(m_ref) - offset; + m_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0); + m = m_base + offset; + + glLoadMatrixf( + (GLfloat *)m + ); + +exit: + if (m_base) { + _env->ReleasePrimitiveArrayCritical(m_ref, m_base, + JNI_ABORT); + } +} + +/* void glLoadMatrixf ( const GLfloat *m ) */ +static void +android_glLoadMatrixf__Ljava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jobject m_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *m = (GLfloat *) 0; + + m = (GLfloat *)getPointer(_env, m_buf, &_array, &_remaining); + glLoadMatrixf( + (GLfloat *)m + ); + if (_array) { + releasePointer(_env, _array, m, JNI_FALSE); + } +} + +/* void glLoadMatrixx ( const GLfixed *m ) */ +static void +android_glLoadMatrixx___3II + (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) { + GLfixed *m_base = (GLfixed *) 0; + jint _remaining; + GLfixed *m = (GLfixed *) 0; + + if (!m_ref) { + _env->ThrowNew(IAEClass, "m == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(m_ref) - offset; + m_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0); + m = m_base + offset; + + glLoadMatrixx( + (GLfixed *)m + ); + +exit: + if (m_base) { + _env->ReleasePrimitiveArrayCritical(m_ref, m_base, + JNI_ABORT); + } +} + +/* void glLoadMatrixx ( const GLfixed *m ) */ +static void +android_glLoadMatrixx__Ljava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jobject m_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *m = (GLfixed *) 0; + + m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining); + glLoadMatrixx( + (GLfixed *)m + ); + if (_array) { + releasePointer(_env, _array, m, JNI_FALSE); + } +} + +/* void glLogicOp ( GLenum opcode ) */ +static void +android_glLogicOp__I + (JNIEnv *_env, jobject _this, jint opcode) { + glLogicOp( + (GLenum)opcode + ); +} + +/* void glMaterialf ( GLenum face, GLenum pname, GLfloat param ) */ +static void +android_glMaterialf__IIF + (JNIEnv *_env, jobject _this, jint face, jint pname, jfloat param) { + glMaterialf( + (GLenum)face, + (GLenum)pname, + (GLfloat)param + ); +} + +/* void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) */ +static void +android_glMaterialfv__II_3FI + (JNIEnv *_env, jobject _this, jint face, jint pname, jfloatArray params_ref, jint offset) { + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_SHININESS) + case GL_SHININESS: +#endif // defined(GL_SHININESS) + _needed = 1; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) +#if defined(GL_AMBIENT_AND_DIFFUSE) + case GL_AMBIENT_AND_DIFFUSE: +#endif // defined(GL_AMBIENT_AND_DIFFUSE) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glMaterialfv( + (GLenum)face, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glMaterialfv ( GLenum face, GLenum pname, const GLfloat *params ) */ +static void +android_glMaterialfv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_SHININESS) + case GL_SHININESS: +#endif // defined(GL_SHININESS) + _needed = 1; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) +#if defined(GL_AMBIENT_AND_DIFFUSE) + case GL_AMBIENT_AND_DIFFUSE: +#endif // defined(GL_AMBIENT_AND_DIFFUSE) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glMaterialfv( + (GLenum)face, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glMaterialx ( GLenum face, GLenum pname, GLfixed param ) */ +static void +android_glMaterialx__III + (JNIEnv *_env, jobject _this, jint face, jint pname, jint param) { + glMaterialx( + (GLenum)face, + (GLenum)pname, + (GLfixed)param + ); +} + +/* void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) */ +static void +android_glMaterialxv__II_3II + (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) { + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_SHININESS) + case GL_SHININESS: +#endif // defined(GL_SHININESS) + _needed = 1; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) +#if defined(GL_AMBIENT_AND_DIFFUSE) + case GL_AMBIENT_AND_DIFFUSE: +#endif // defined(GL_AMBIENT_AND_DIFFUSE) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glMaterialxv( + (GLenum)face, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glMaterialxv ( GLenum face, GLenum pname, const GLfixed *params ) */ +static void +android_glMaterialxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_SHININESS) + case GL_SHININESS: +#endif // defined(GL_SHININESS) + _needed = 1; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) +#if defined(GL_AMBIENT_AND_DIFFUSE) + case GL_AMBIENT_AND_DIFFUSE: +#endif // defined(GL_AMBIENT_AND_DIFFUSE) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glMaterialxv( + (GLenum)face, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glMatrixMode ( GLenum mode ) */ +static void +android_glMatrixMode__I + (JNIEnv *_env, jobject _this, jint mode) { + glMatrixMode( + (GLenum)mode + ); +} + +/* void glMultMatrixf ( const GLfloat *m ) */ +static void +android_glMultMatrixf___3FI + (JNIEnv *_env, jobject _this, jfloatArray m_ref, jint offset) { + GLfloat *m_base = (GLfloat *) 0; + jint _remaining; + GLfloat *m = (GLfloat *) 0; + + if (!m_ref) { + _env->ThrowNew(IAEClass, "m == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(m_ref) - offset; + m_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0); + m = m_base + offset; + + glMultMatrixf( + (GLfloat *)m + ); + +exit: + if (m_base) { + _env->ReleasePrimitiveArrayCritical(m_ref, m_base, + JNI_ABORT); + } +} + +/* void glMultMatrixf ( const GLfloat *m ) */ +static void +android_glMultMatrixf__Ljava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jobject m_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *m = (GLfloat *) 0; + + m = (GLfloat *)getPointer(_env, m_buf, &_array, &_remaining); + glMultMatrixf( + (GLfloat *)m + ); + if (_array) { + releasePointer(_env, _array, m, JNI_FALSE); + } +} + +/* void glMultMatrixx ( const GLfixed *m ) */ +static void +android_glMultMatrixx___3II + (JNIEnv *_env, jobject _this, jintArray m_ref, jint offset) { + GLfixed *m_base = (GLfixed *) 0; + jint _remaining; + GLfixed *m = (GLfixed *) 0; + + if (!m_ref) { + _env->ThrowNew(IAEClass, "m == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(m_ref) - offset; + m_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(m_ref, (jboolean *)0); + m = m_base + offset; + + glMultMatrixx( + (GLfixed *)m + ); + +exit: + if (m_base) { + _env->ReleasePrimitiveArrayCritical(m_ref, m_base, + JNI_ABORT); + } +} + +/* void glMultMatrixx ( const GLfixed *m ) */ +static void +android_glMultMatrixx__Ljava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jobject m_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *m = (GLfixed *) 0; + + m = (GLfixed *)getPointer(_env, m_buf, &_array, &_remaining); + glMultMatrixx( + (GLfixed *)m + ); + if (_array) { + releasePointer(_env, _array, m, JNI_FALSE); + } +} + +/* void glMultiTexCoord4f ( GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q ) */ +static void +android_glMultiTexCoord4f__IFFFF + (JNIEnv *_env, jobject _this, jint target, jfloat s, jfloat t, jfloat r, jfloat q) { + glMultiTexCoord4f( + (GLenum)target, + (GLfloat)s, + (GLfloat)t, + (GLfloat)r, + (GLfloat)q + ); +} + +/* void glMultiTexCoord4x ( GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q ) */ +static void +android_glMultiTexCoord4x__IIIII + (JNIEnv *_env, jobject _this, jint target, jint s, jint t, jint r, jint q) { + glMultiTexCoord4x( + (GLenum)target, + (GLfixed)s, + (GLfixed)t, + (GLfixed)r, + (GLfixed)q + ); +} + +/* void glNormal3f ( GLfloat nx, GLfloat ny, GLfloat nz ) */ +static void +android_glNormal3f__FFF + (JNIEnv *_env, jobject _this, jfloat nx, jfloat ny, jfloat nz) { + glNormal3f( + (GLfloat)nx, + (GLfloat)ny, + (GLfloat)nz + ); +} + +/* void glNormal3x ( GLfixed nx, GLfixed ny, GLfixed nz ) */ +static void +android_glNormal3x__III + (JNIEnv *_env, jobject _this, jint nx, jint ny, jint nz) { + glNormal3x( + (GLfixed)nx, + (GLfixed)ny, + (GLfixed)nz + ); +} + +/* void glNormalPointer ( GLenum type, GLsizei stride, const GLvoid *pointer ) */ +static void +android_glNormalPointerBounds__IILjava_nio_Buffer_2I + (JNIEnv *_env, jobject _this, jint type, jint stride, jobject pointer_buf, jint remaining) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *pointer = (GLvoid *) 0; + + pointer = (GLvoid *)getPointer(_env, pointer_buf, &_array, &_remaining); + glNormalPointerBounds( + (GLenum)type, + (GLsizei)stride, + (GLvoid *)pointer, + (GLsizei)remaining + ); + if (_array) { + releasePointer(_env, _array, pointer, JNI_FALSE); + } +} + +/* void glOrthof ( GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar ) */ +static void +android_glOrthof__FFFFFF + (JNIEnv *_env, jobject _this, jfloat left, jfloat right, jfloat bottom, jfloat top, jfloat zNear, jfloat zFar) { + glOrthof( + (GLfloat)left, + (GLfloat)right, + (GLfloat)bottom, + (GLfloat)top, + (GLfloat)zNear, + (GLfloat)zFar + ); +} + +/* void glOrthox ( GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar ) */ +static void +android_glOrthox__IIIIII + (JNIEnv *_env, jobject _this, jint left, jint right, jint bottom, jint top, jint zNear, jint zFar) { + glOrthox( + (GLfixed)left, + (GLfixed)right, + (GLfixed)bottom, + (GLfixed)top, + (GLfixed)zNear, + (GLfixed)zFar + ); +} + +/* void glPixelStorei ( GLenum pname, GLint param ) */ +static void +android_glPixelStorei__II + (JNIEnv *_env, jobject _this, jint pname, jint param) { + glPixelStorei( + (GLenum)pname, + (GLint)param + ); +} + +/* void glPointSize ( GLfloat size ) */ +static void +android_glPointSize__F + (JNIEnv *_env, jobject _this, jfloat size) { + glPointSize( + (GLfloat)size + ); +} + +/* void glPointSizex ( GLfixed size ) */ +static void +android_glPointSizex__I + (JNIEnv *_env, jobject _this, jint size) { + glPointSizex( + (GLfixed)size + ); +} + +/* void glPolygonOffset ( GLfloat factor, GLfloat units ) */ +static void +android_glPolygonOffset__FF + (JNIEnv *_env, jobject _this, jfloat factor, jfloat units) { + glPolygonOffset( + (GLfloat)factor, + (GLfloat)units + ); +} + +/* void glPolygonOffsetx ( GLfixed factor, GLfixed units ) */ +static void +android_glPolygonOffsetx__II + (JNIEnv *_env, jobject _this, jint factor, jint units) { + glPolygonOffsetx( + (GLfixed)factor, + (GLfixed)units + ); +} + +/* void glPopMatrix ( void ) */ +static void +android_glPopMatrix__ + (JNIEnv *_env, jobject _this) { + glPopMatrix(); +} + +/* void glPushMatrix ( void ) */ +static void +android_glPushMatrix__ + (JNIEnv *_env, jobject _this) { + glPushMatrix(); +} + +/* void glReadPixels ( GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels ) */ +static void +android_glReadPixels__IIIIIILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height, jint format, jint type, jobject pixels_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *pixels = (GLvoid *) 0; + + pixels = (GLvoid *)getPointer(_env, pixels_buf, &_array, &_remaining); + glReadPixels( + (GLint)x, + (GLint)y, + (GLsizei)width, + (GLsizei)height, + (GLenum)format, + (GLenum)type, + (GLvoid *)pixels + ); + if (_array) { + releasePointer(_env, _array, pixels, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glRotatef ( GLfloat angle, GLfloat x, GLfloat y, GLfloat z ) */ +static void +android_glRotatef__FFFF + (JNIEnv *_env, jobject _this, jfloat angle, jfloat x, jfloat y, jfloat z) { + glRotatef( + (GLfloat)angle, + (GLfloat)x, + (GLfloat)y, + (GLfloat)z + ); +} + +/* void glRotatex ( GLfixed angle, GLfixed x, GLfixed y, GLfixed z ) */ +static void +android_glRotatex__IIII + (JNIEnv *_env, jobject _this, jint angle, jint x, jint y, jint z) { + glRotatex( + (GLfixed)angle, + (GLfixed)x, + (GLfixed)y, + (GLfixed)z + ); +} + +/* void glSampleCoverage ( GLclampf value, GLboolean invert ) */ +static void +android_glSampleCoverage__FZ + (JNIEnv *_env, jobject _this, jfloat value, jboolean invert) { + glSampleCoverage( + (GLclampf)value, + (GLboolean)invert + ); +} + +/* void glSampleCoveragex ( GLclampx value, GLboolean invert ) */ +static void +android_glSampleCoveragex__IZ + (JNIEnv *_env, jobject _this, jint value, jboolean invert) { + glSampleCoveragex( + (GLclampx)value, + (GLboolean)invert + ); +} + +/* void glScalef ( GLfloat x, GLfloat y, GLfloat z ) */ +static void +android_glScalef__FFF + (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z) { + glScalef( + (GLfloat)x, + (GLfloat)y, + (GLfloat)z + ); +} + +/* void glScalex ( GLfixed x, GLfixed y, GLfixed z ) */ +static void +android_glScalex__III + (JNIEnv *_env, jobject _this, jint x, jint y, jint z) { + glScalex( + (GLfixed)x, + (GLfixed)y, + (GLfixed)z + ); +} + +/* void glScissor ( GLint x, GLint y, GLsizei width, GLsizei height ) */ +static void +android_glScissor__IIII + (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) { + glScissor( + (GLint)x, + (GLint)y, + (GLsizei)width, + (GLsizei)height + ); +} + +/* void glShadeModel ( GLenum mode ) */ +static void +android_glShadeModel__I + (JNIEnv *_env, jobject _this, jint mode) { + glShadeModel( + (GLenum)mode + ); +} + +/* void glStencilFunc ( GLenum func, GLint ref, GLuint mask ) */ +static void +android_glStencilFunc__III + (JNIEnv *_env, jobject _this, jint func, jint ref, jint mask) { + glStencilFunc( + (GLenum)func, + (GLint)ref, + (GLuint)mask + ); +} + +/* void glStencilMask ( GLuint mask ) */ +static void +android_glStencilMask__I + (JNIEnv *_env, jobject _this, jint mask) { + glStencilMask( + (GLuint)mask + ); +} + +/* void glStencilOp ( GLenum fail, GLenum zfail, GLenum zpass ) */ +static void +android_glStencilOp__III + (JNIEnv *_env, jobject _this, jint fail, jint zfail, jint zpass) { + glStencilOp( + (GLenum)fail, + (GLenum)zfail, + (GLenum)zpass + ); +} + +/* void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ +static void +android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *pointer = (GLvoid *) 0; + + pointer = (GLvoid *)getPointer(_env, pointer_buf, &_array, &_remaining); + glTexCoordPointerBounds( + (GLint)size, + (GLenum)type, + (GLsizei)stride, + (GLvoid *)pointer, + (GLsizei)remaining + ); + if (_array) { + releasePointer(_env, _array, pointer, JNI_FALSE); + } +} + +/* void glTexEnvf ( GLenum target, GLenum pname, GLfloat param ) */ +static void +android_glTexEnvf__IIF + (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) { + glTexEnvf( + (GLenum)target, + (GLenum)pname, + (GLfloat)param + ); +} + +/* void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) */ +static void +android_glTexEnvfv__II_3FI + (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glTexEnvfv( + (GLenum)target, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glTexEnvfv ( GLenum target, GLenum pname, const GLfloat *params ) */ +static void +android_glTexEnvfv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glTexEnvfv( + (GLenum)target, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glTexEnvx ( GLenum target, GLenum pname, GLfixed param ) */ +static void +android_glTexEnvx__III + (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { + glTexEnvx( + (GLenum)target, + (GLenum)pname, + (GLfixed)param + ); +} + +/* void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) */ +static void +android_glTexEnvxv__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glTexEnvxv( + (GLenum)target, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glTexEnvxv ( GLenum target, GLenum pname, const GLfixed *params ) */ +static void +android_glTexEnvxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glTexEnvxv( + (GLenum)target, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glTexImage2D ( GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels ) */ +static void +android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint format, jint type, jobject pixels_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *pixels = (GLvoid *) 0; + + if (pixels_buf) { + pixels = (GLvoid *)getPointer(_env, pixels_buf, &_array, &_remaining); + } + glTexImage2D( + (GLenum)target, + (GLint)level, + (GLint)internalformat, + (GLsizei)width, + (GLsizei)height, + (GLint)border, + (GLenum)format, + (GLenum)type, + (GLvoid *)pixels + ); + if (_array) { + releasePointer(_env, _array, pixels, JNI_FALSE); + } +} + +/* void glTexParameterf ( GLenum target, GLenum pname, GLfloat param ) */ +static void +android_glTexParameterf__IIF + (JNIEnv *_env, jobject _this, jint target, jint pname, jfloat param) { + glTexParameterf( + (GLenum)target, + (GLenum)pname, + (GLfloat)param + ); +} + +/* void glTexParameterx ( GLenum target, GLenum pname, GLfixed param ) */ +static void +android_glTexParameterx__III + (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { + glTexParameterx( + (GLenum)target, + (GLenum)pname, + (GLfixed)param + ); +} + +/* void glTexSubImage2D ( GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels ) */ +static void +android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint type, jobject pixels_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *pixels = (GLvoid *) 0; + + if (pixels_buf) { + pixels = (GLvoid *)getPointer(_env, pixels_buf, &_array, &_remaining); + } + glTexSubImage2D( + (GLenum)target, + (GLint)level, + (GLint)xoffset, + (GLint)yoffset, + (GLsizei)width, + (GLsizei)height, + (GLenum)format, + (GLenum)type, + (GLvoid *)pixels + ); + if (_array) { + releasePointer(_env, _array, pixels, JNI_FALSE); + } +} + +/* void glTranslatef ( GLfloat x, GLfloat y, GLfloat z ) */ +static void +android_glTranslatef__FFF + (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z) { + glTranslatef( + (GLfloat)x, + (GLfloat)y, + (GLfloat)z + ); +} + +/* void glTranslatex ( GLfixed x, GLfixed y, GLfixed z ) */ +static void +android_glTranslatex__III + (JNIEnv *_env, jobject _this, jint x, jint y, jint z) { + glTranslatex( + (GLfixed)x, + (GLfixed)y, + (GLfixed)z + ); +} + +/* void glVertexPointer ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ +static void +android_glVertexPointerBounds__IIILjava_nio_Buffer_2I + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf, jint remaining) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *pointer = (GLvoid *) 0; + + pointer = (GLvoid *)getPointer(_env, pointer_buf, &_array, &_remaining); + glVertexPointerBounds( + (GLint)size, + (GLenum)type, + (GLsizei)stride, + (GLvoid *)pointer, + (GLsizei)remaining + ); + if (_array) { + releasePointer(_env, _array, pointer, JNI_FALSE); + } +} + +/* void glViewport ( GLint x, GLint y, GLsizei width, GLsizei height ) */ +static void +android_glViewport__IIII + (JNIEnv *_env, jobject _this, jint x, jint y, jint width, jint height) { + glViewport( + (GLint)x, + (GLint)y, + (GLsizei)width, + (GLsizei)height + ); +} + +/* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */ +static jint +android_glQueryMatrixxOES___3II_3II + (JNIEnv *_env, jobject _this, jintArray mantissa_ref, jint mantissaOffset, jintArray exponent_ref, jint exponentOffset) { + jint _exception = 0; + GLbitfield _returnValue = -1; + GLfixed *mantissa_base = (GLfixed *) 0; + jint _mantissaRemaining; + GLfixed *mantissa = (GLfixed *) 0; + GLint *exponent_base = (GLint *) 0; + jint _exponentRemaining; + GLint *exponent = (GLint *) 0; + + if (!mantissa_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "mantissa == null"); + goto exit; + } + if (mantissaOffset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "mantissaOffset < 0"); + goto exit; + } + _mantissaRemaining = _env->GetArrayLength(mantissa_ref) - mantissaOffset; + if (_mantissaRemaining < 16) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - mantissaOffset < 16"); + goto exit; + } + mantissa_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(mantissa_ref, (jboolean *)0); + mantissa = mantissa_base + mantissaOffset; + + if (!exponent_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "exponent == null"); + goto exit; + } + if (exponentOffset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "exponentOffset < 0"); + goto exit; + } + _exponentRemaining = _env->GetArrayLength(exponent_ref) - exponentOffset; + if (_exponentRemaining < 16) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - exponentOffset < 16"); + goto exit; + } + exponent_base = (GLint *) + _env->GetPrimitiveArrayCritical(exponent_ref, (jboolean *)0); + exponent = exponent_base + exponentOffset; + + _returnValue = glQueryMatrixxOES( + (GLfixed *)mantissa, + (GLint *)exponent + ); + +exit: + if (exponent_base) { + _env->ReleasePrimitiveArrayCritical(exponent_ref, exponent_base, + _exception ? JNI_ABORT: 0); + } + if (mantissa_base) { + _env->ReleasePrimitiveArrayCritical(mantissa_ref, mantissa_base, + _exception ? JNI_ABORT: 0); + } + return _returnValue; +} + +/* GLbitfield glQueryMatrixxOES ( GLfixed *mantissa, GLint *exponent ) */ +static jint +android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jobject mantissa_buf, jobject exponent_buf) { + jint _exception = 0; + jarray _mantissaArray = (jarray) 0; + jarray _exponentArray = (jarray) 0; + GLbitfield _returnValue = -1; + jint _mantissaRemaining; + GLfixed *mantissa = (GLfixed *) 0; + jint _exponentRemaining; + GLint *exponent = (GLint *) 0; + + mantissa = (GLfixed *)getPointer(_env, mantissa_buf, &_mantissaArray, &_mantissaRemaining); + if (_mantissaRemaining < 16) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < 16"); + goto exit; + } + exponent = (GLint *)getPointer(_env, exponent_buf, &_exponentArray, &_exponentRemaining); + if (_exponentRemaining < 16) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < 16"); + goto exit; + } + _returnValue = glQueryMatrixxOES( + (GLfixed *)mantissa, + (GLint *)exponent + ); + +exit: + if (_mantissaArray) { + releasePointer(_env, _mantissaArray, exponent, _exception ? JNI_FALSE : JNI_TRUE); + } + if (_exponentArray) { + releasePointer(_env, _exponentArray, mantissa, _exception ? JNI_FALSE : JNI_TRUE); + } + return _returnValue; +} + +/* void glBindBuffer ( GLenum target, GLuint buffer ) */ +static void +android_glBindBuffer__II + (JNIEnv *_env, jobject _this, jint target, jint buffer) { + glBindBuffer( + (GLenum)target, + (GLuint)buffer + ); +} + +/* void glBufferData ( GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage ) */ +static void +android_glBufferData__IILjava_nio_Buffer_2I + (JNIEnv *_env, jobject _this, jint target, jint size, jobject data_buf, jint usage) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *data = (GLvoid *) 0; + + if (data_buf) { + data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining); + } + glBufferData( + (GLenum)target, + (GLsizeiptr)size, + (GLvoid *)data, + (GLenum)usage + ); + if (_array) { + releasePointer(_env, _array, data, JNI_FALSE); + } +} + +/* void glBufferSubData ( GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data ) */ +static void +android_glBufferSubData__IIILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint target, jint offset, jint size, jobject data_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *data = (GLvoid *) 0; + + data = (GLvoid *)getPointer(_env, data_buf, &_array, &_remaining); + glBufferSubData( + (GLenum)target, + (GLintptr)offset, + (GLsizeiptr)size, + (GLvoid *)data + ); + if (_array) { + releasePointer(_env, _array, data, JNI_FALSE); + } +} + +/* void glClipPlanef ( GLenum plane, const GLfloat *equation ) */ +static void +android_glClipPlanef__I_3FI + (JNIEnv *_env, jobject _this, jint plane, jfloatArray equation_ref, jint offset) { + GLfloat *equation_base = (GLfloat *) 0; + jint _remaining; + GLfloat *equation = (GLfloat *) 0; + + if (!equation_ref) { + _env->ThrowNew(IAEClass, "equation == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(equation_ref) - offset; + if (_remaining < 4) { + _env->ThrowNew(IAEClass, "length - offset < 4"); + goto exit; + } + equation_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0); + equation = equation_base + offset; + + glClipPlanef( + (GLenum)plane, + (GLfloat *)equation + ); + +exit: + if (equation_base) { + _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base, + JNI_ABORT); + } +} + +/* void glClipPlanef ( GLenum plane, const GLfloat *equation ) */ +static void +android_glClipPlanef__ILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *equation = (GLfloat *) 0; + + equation = (GLfloat *)getPointer(_env, equation_buf, &_array, &_remaining); + if (_remaining < 4) { + _env->ThrowNew(IAEClass, "remaining() < 4"); + goto exit; + } + glClipPlanef( + (GLenum)plane, + (GLfloat *)equation + ); + +exit: + if (_array) { + releasePointer(_env, _array, equation, JNI_FALSE); + } +} + +/* void glClipPlanex ( GLenum plane, const GLfixed *equation ) */ +static void +android_glClipPlanex__I_3II + (JNIEnv *_env, jobject _this, jint plane, jintArray equation_ref, jint offset) { + GLfixed *equation_base = (GLfixed *) 0; + jint _remaining; + GLfixed *equation = (GLfixed *) 0; + + if (!equation_ref) { + _env->ThrowNew(IAEClass, "equation == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(equation_ref) - offset; + if (_remaining < 4) { + _env->ThrowNew(IAEClass, "length - offset < 4"); + goto exit; + } + equation_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(equation_ref, (jboolean *)0); + equation = equation_base + offset; + + glClipPlanex( + (GLenum)plane, + (GLfixed *)equation + ); + +exit: + if (equation_base) { + _env->ReleasePrimitiveArrayCritical(equation_ref, equation_base, + JNI_ABORT); + } +} + +/* void glClipPlanex ( GLenum plane, const GLfixed *equation ) */ +static void +android_glClipPlanex__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint plane, jobject equation_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *equation = (GLfixed *) 0; + + equation = (GLfixed *)getPointer(_env, equation_buf, &_array, &_remaining); + if (_remaining < 4) { + _env->ThrowNew(IAEClass, "remaining() < 4"); + goto exit; + } + glClipPlanex( + (GLenum)plane, + (GLfixed *)equation + ); + +exit: + if (_array) { + releasePointer(_env, _array, equation, JNI_FALSE); + } +} + +/* void glColor4ub ( GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha ) */ +static void +android_glColor4ub__BBBB + (JNIEnv *_env, jobject _this, jbyte red, jbyte green, jbyte blue, jbyte alpha) { + glColor4ub( + (GLubyte)red, + (GLubyte)green, + (GLubyte)blue, + (GLubyte)alpha + ); +} + +/* void glColorPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ +static void +android_glColorPointer__IIII + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { + glColorPointer( + (GLint)size, + (GLenum)type, + (GLsizei)stride, + (const GLvoid *)offset + ); +} + +/* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */ +static void +android_glDeleteBuffers__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) { + GLuint *buffers_base = (GLuint *) 0; + jint _remaining; + GLuint *buffers = (GLuint *) 0; + + if (!buffers_ref) { + _env->ThrowNew(IAEClass, "buffers == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(buffers_ref) - offset; + if (_remaining < n) { + _env->ThrowNew(IAEClass, "length - offset < n"); + goto exit; + } + buffers_base = (GLuint *) + _env->GetPrimitiveArrayCritical(buffers_ref, (jboolean *)0); + buffers = buffers_base + offset; + + glDeleteBuffers( + (GLsizei)n, + (GLuint *)buffers + ); + +exit: + if (buffers_base) { + _env->ReleasePrimitiveArrayCritical(buffers_ref, buffers_base, + JNI_ABORT); + } +} + +/* void glDeleteBuffers ( GLsizei n, const GLuint *buffers ) */ +static void +android_glDeleteBuffers__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLuint *buffers = (GLuint *) 0; + + buffers = (GLuint *)getPointer(_env, buffers_buf, &_array, &_remaining); + if (_remaining < n) { + _env->ThrowNew(IAEClass, "remaining() < n"); + goto exit; + } + glDeleteBuffers( + (GLsizei)n, + (GLuint *)buffers + ); + +exit: + if (_array) { + releasePointer(_env, _array, buffers, JNI_FALSE); + } +} + +/* void glDrawElements ( GLenum mode, GLsizei count, GLenum type, GLint offset ) */ +static void +android_glDrawElements__IIII + (JNIEnv *_env, jobject _this, jint mode, jint count, jint type, jint offset) { + glDrawElements( + (GLenum)mode, + (GLsizei)count, + (GLenum)type, + (const GLvoid *)offset + ); +} + +/* void glGenBuffers ( GLsizei n, GLuint *buffers ) */ +static void +android_glGenBuffers__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray buffers_ref, jint offset) { + jint _exception = 0; + GLuint *buffers_base = (GLuint *) 0; + jint _remaining; + GLuint *buffers = (GLuint *) 0; + + if (!buffers_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "buffers == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(buffers_ref) - offset; + if (_remaining < n) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < n"); + goto exit; + } + buffers_base = (GLuint *) + _env->GetPrimitiveArrayCritical(buffers_ref, (jboolean *)0); + buffers = buffers_base + offset; + + glGenBuffers( + (GLsizei)n, + (GLuint *)buffers + ); + +exit: + if (buffers_base) { + _env->ReleasePrimitiveArrayCritical(buffers_ref, buffers_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGenBuffers ( GLsizei n, GLuint *buffers ) */ +static void +android_glGenBuffers__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject buffers_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLuint *buffers = (GLuint *) 0; + + buffers = (GLuint *)getPointer(_env, buffers_buf, &_array, &_remaining); + if (_remaining < n) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < n"); + goto exit; + } + glGenBuffers( + (GLsizei)n, + (GLuint *)buffers + ); + +exit: + if (_array) { + releasePointer(_env, _array, buffers, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */ +static void +android_glGetBooleanv__I_3ZI + (JNIEnv *_env, jobject _this, jint pname, jbooleanArray params_ref, jint offset) { + jint _exception = 0; + GLboolean *params_base = (GLboolean *) 0; + jint _remaining; + GLboolean *params = (GLboolean *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLboolean *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetBooleanv( + (GLenum)pname, + (GLboolean *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetBooleanv ( GLenum pname, GLboolean *params ) */ +static void +android_glGetBooleanv__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLboolean *params = (GLboolean *) 0; + + params = (GLboolean *)getPointer(_env, params_buf, &_array, &_remaining); + glGetBooleanv( + (GLenum)pname, + (GLboolean *)params + ); + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ +static void +android_glGetBufferParameteriv__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glGetBufferParameteriv"); +} + +/* void glGetBufferParameteriv ( GLenum target, GLenum pname, GLint *params ) */ +static void +android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + _env->ThrowNew(UOEClass, + "glGetBufferParameteriv"); +} + +/* void glGetClipPlanef ( GLenum pname, GLfloat *eqn ) */ +static void +android_glGetClipPlanef__I_3FI + (JNIEnv *_env, jobject _this, jint pname, jfloatArray eqn_ref, jint offset) { + jint _exception = 0; + GLfloat *eqn_base = (GLfloat *) 0; + jint _remaining; + GLfloat *eqn = (GLfloat *) 0; + + if (!eqn_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "eqn == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(eqn_ref) - offset; + eqn_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0); + eqn = eqn_base + offset; + + glGetClipPlanef( + (GLenum)pname, + (GLfloat *)eqn + ); + +exit: + if (eqn_base) { + _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetClipPlanef ( GLenum pname, GLfloat *eqn ) */ +static void +android_glGetClipPlanef__ILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *eqn = (GLfloat *) 0; + + eqn = (GLfloat *)getPointer(_env, eqn_buf, &_array, &_remaining); + glGetClipPlanef( + (GLenum)pname, + (GLfloat *)eqn + ); + if (_array) { + releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetClipPlanex ( GLenum pname, GLfixed *eqn ) */ +static void +android_glGetClipPlanex__I_3II + (JNIEnv *_env, jobject _this, jint pname, jintArray eqn_ref, jint offset) { + jint _exception = 0; + GLfixed *eqn_base = (GLfixed *) 0; + jint _remaining; + GLfixed *eqn = (GLfixed *) 0; + + if (!eqn_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "eqn == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(eqn_ref) - offset; + eqn_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(eqn_ref, (jboolean *)0); + eqn = eqn_base + offset; + + glGetClipPlanex( + (GLenum)pname, + (GLfixed *)eqn + ); + +exit: + if (eqn_base) { + _env->ReleasePrimitiveArrayCritical(eqn_ref, eqn_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetClipPlanex ( GLenum pname, GLfixed *eqn ) */ +static void +android_glGetClipPlanex__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject eqn_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *eqn = (GLfixed *) 0; + + eqn = (GLfixed *)getPointer(_env, eqn_buf, &_array, &_remaining); + glGetClipPlanex( + (GLenum)pname, + (GLfixed *)eqn + ); + if (_array) { + releasePointer(_env, _array, eqn, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetFixedv ( GLenum pname, GLfixed *params ) */ +static void +android_glGetFixedv__I_3II + (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetFixedv( + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetFixedv ( GLenum pname, GLfixed *params ) */ +static void +android_glGetFixedv__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + glGetFixedv( + (GLenum)pname, + (GLfixed *)params + ); + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetFloatv ( GLenum pname, GLfloat *params ) */ +static void +android_glGetFloatv__I_3FI + (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { + jint _exception = 0; + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetFloatv( + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetFloatv ( GLenum pname, GLfloat *params ) */ +static void +android_glGetFloatv__ILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + glGetFloatv( + (GLenum)pname, + (GLfloat *)params + ); + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) */ +static void +android_glGetLightfv__II_3FI + (JNIEnv *_env, jobject _this, jint light, jint pname, jfloatArray params_ref, jint offset) { + jint _exception = 0; + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_SPOT_EXPONENT) + case GL_SPOT_EXPONENT: +#endif // defined(GL_SPOT_EXPONENT) +#if defined(GL_SPOT_CUTOFF) + case GL_SPOT_CUTOFF: +#endif // defined(GL_SPOT_CUTOFF) +#if defined(GL_CONSTANT_ATTENUATION) + case GL_CONSTANT_ATTENUATION: +#endif // defined(GL_CONSTANT_ATTENUATION) +#if defined(GL_LINEAR_ATTENUATION) + case GL_LINEAR_ATTENUATION: +#endif // defined(GL_LINEAR_ATTENUATION) +#if defined(GL_QUADRATIC_ATTENUATION) + case GL_QUADRATIC_ATTENUATION: +#endif // defined(GL_QUADRATIC_ATTENUATION) + _needed = 1; + break; +#if defined(GL_SPOT_DIRECTION) + case GL_SPOT_DIRECTION: +#endif // defined(GL_SPOT_DIRECTION) + _needed = 3; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetLightfv( + (GLenum)light, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetLightfv ( GLenum light, GLenum pname, GLfloat *params ) */ +static void +android_glGetLightfv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_SPOT_EXPONENT) + case GL_SPOT_EXPONENT: +#endif // defined(GL_SPOT_EXPONENT) +#if defined(GL_SPOT_CUTOFF) + case GL_SPOT_CUTOFF: +#endif // defined(GL_SPOT_CUTOFF) +#if defined(GL_CONSTANT_ATTENUATION) + case GL_CONSTANT_ATTENUATION: +#endif // defined(GL_CONSTANT_ATTENUATION) +#if defined(GL_LINEAR_ATTENUATION) + case GL_LINEAR_ATTENUATION: +#endif // defined(GL_LINEAR_ATTENUATION) +#if defined(GL_QUADRATIC_ATTENUATION) + case GL_QUADRATIC_ATTENUATION: +#endif // defined(GL_QUADRATIC_ATTENUATION) + _needed = 1; + break; +#if defined(GL_SPOT_DIRECTION) + case GL_SPOT_DIRECTION: +#endif // defined(GL_SPOT_DIRECTION) + _needed = 3; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glGetLightfv( + (GLenum)light, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetLightxv ( GLenum light, GLenum pname, GLfixed *params ) */ +static void +android_glGetLightxv__II_3II + (JNIEnv *_env, jobject _this, jint light, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_SPOT_EXPONENT) + case GL_SPOT_EXPONENT: +#endif // defined(GL_SPOT_EXPONENT) +#if defined(GL_SPOT_CUTOFF) + case GL_SPOT_CUTOFF: +#endif // defined(GL_SPOT_CUTOFF) +#if defined(GL_CONSTANT_ATTENUATION) + case GL_CONSTANT_ATTENUATION: +#endif // defined(GL_CONSTANT_ATTENUATION) +#if defined(GL_LINEAR_ATTENUATION) + case GL_LINEAR_ATTENUATION: +#endif // defined(GL_LINEAR_ATTENUATION) +#if defined(GL_QUADRATIC_ATTENUATION) + case GL_QUADRATIC_ATTENUATION: +#endif // defined(GL_QUADRATIC_ATTENUATION) + _needed = 1; + break; +#if defined(GL_SPOT_DIRECTION) + case GL_SPOT_DIRECTION: +#endif // defined(GL_SPOT_DIRECTION) + _needed = 3; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetLightxv( + (GLenum)light, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetLightxv ( GLenum light, GLenum pname, GLfixed *params ) */ +static void +android_glGetLightxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint light, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_SPOT_EXPONENT) + case GL_SPOT_EXPONENT: +#endif // defined(GL_SPOT_EXPONENT) +#if defined(GL_SPOT_CUTOFF) + case GL_SPOT_CUTOFF: +#endif // defined(GL_SPOT_CUTOFF) +#if defined(GL_CONSTANT_ATTENUATION) + case GL_CONSTANT_ATTENUATION: +#endif // defined(GL_CONSTANT_ATTENUATION) +#if defined(GL_LINEAR_ATTENUATION) + case GL_LINEAR_ATTENUATION: +#endif // defined(GL_LINEAR_ATTENUATION) +#if defined(GL_QUADRATIC_ATTENUATION) + case GL_QUADRATIC_ATTENUATION: +#endif // defined(GL_QUADRATIC_ATTENUATION) + _needed = 1; + break; +#if defined(GL_SPOT_DIRECTION) + case GL_SPOT_DIRECTION: +#endif // defined(GL_SPOT_DIRECTION) + _needed = 3; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glGetLightxv( + (GLenum)light, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) */ +static void +android_glGetMaterialfv__II_3FI + (JNIEnv *_env, jobject _this, jint face, jint pname, jfloatArray params_ref, jint offset) { + jint _exception = 0; + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_SHININESS) + case GL_SHININESS: +#endif // defined(GL_SHININESS) + _needed = 1; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) +#if defined(GL_AMBIENT_AND_DIFFUSE) + case GL_AMBIENT_AND_DIFFUSE: +#endif // defined(GL_AMBIENT_AND_DIFFUSE) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetMaterialfv( + (GLenum)face, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetMaterialfv ( GLenum face, GLenum pname, GLfloat *params ) */ +static void +android_glGetMaterialfv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_SHININESS) + case GL_SHININESS: +#endif // defined(GL_SHININESS) + _needed = 1; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) +#if defined(GL_AMBIENT_AND_DIFFUSE) + case GL_AMBIENT_AND_DIFFUSE: +#endif // defined(GL_AMBIENT_AND_DIFFUSE) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glGetMaterialfv( + (GLenum)face, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetMaterialxv ( GLenum face, GLenum pname, GLfixed *params ) */ +static void +android_glGetMaterialxv__II_3II + (JNIEnv *_env, jobject _this, jint face, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_SHININESS) + case GL_SHININESS: +#endif // defined(GL_SHININESS) + _needed = 1; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) +#if defined(GL_AMBIENT_AND_DIFFUSE) + case GL_AMBIENT_AND_DIFFUSE: +#endif // defined(GL_AMBIENT_AND_DIFFUSE) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetMaterialxv( + (GLenum)face, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetMaterialxv ( GLenum face, GLenum pname, GLfixed *params ) */ +static void +android_glGetMaterialxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint face, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_SHININESS) + case GL_SHININESS: +#endif // defined(GL_SHININESS) + _needed = 1; + break; +#if defined(GL_AMBIENT) + case GL_AMBIENT: +#endif // defined(GL_AMBIENT) +#if defined(GL_DIFFUSE) + case GL_DIFFUSE: +#endif // defined(GL_DIFFUSE) +#if defined(GL_SPECULAR) + case GL_SPECULAR: +#endif // defined(GL_SPECULAR) +#if defined(GL_EMISSION) + case GL_EMISSION: +#endif // defined(GL_EMISSION) +#if defined(GL_AMBIENT_AND_DIFFUSE) + case GL_AMBIENT_AND_DIFFUSE: +#endif // defined(GL_AMBIENT_AND_DIFFUSE) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glGetMaterialxv( + (GLenum)face, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetTexEnviv ( GLenum env, GLenum pname, GLint *params ) */ +static void +android_glGetTexEnviv__II_3II + (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetTexEnviv( + (GLenum)env, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetTexEnviv ( GLenum env, GLenum pname, GLint *params ) */ +static void +android_glGetTexEnviv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glGetTexEnviv( + (GLenum)env, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetTexEnvxv ( GLenum env, GLenum pname, GLfixed *params ) */ +static void +android_glGetTexEnvxv__II_3II + (JNIEnv *_env, jobject _this, jint env, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetTexEnvxv( + (GLenum)env, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetTexEnvxv ( GLenum env, GLenum pname, GLfixed *params ) */ +static void +android_glGetTexEnvxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint env, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glGetTexEnvxv( + (GLenum)env, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */ +static void +android_glGetTexParameterfv__II_3FI + (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { + jint _exception = 0; + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + if (_remaining < 1) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < 1"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetTexParameterfv( + (GLenum)target, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetTexParameterfv ( GLenum target, GLenum pname, GLfloat *params ) */ +static void +android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + if (_remaining < 1) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < 1"); + goto exit; + } + glGetTexParameterfv( + (GLenum)target, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */ +static void +android_glGetTexParameteriv__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + if (_remaining < 1) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < 1"); + goto exit; + } + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetTexParameteriv( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetTexParameteriv ( GLenum target, GLenum pname, GLint *params ) */ +static void +android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining); + if (_remaining < 1) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < 1"); + goto exit; + } + glGetTexParameteriv( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* void glGetTexParameterxv ( GLenum target, GLenum pname, GLfixed *params ) */ +static void +android_glGetTexParameterxv__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + jint _exception = 0; + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _exception = 1; + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _exception = 1; + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + if (_remaining < 1) { + _exception = 1; + _env->ThrowNew(IAEClass, "length - offset < 1"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glGetTexParameterxv( + (GLenum)target, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + _exception ? JNI_ABORT: 0); + } +} + +/* void glGetTexParameterxv ( GLenum target, GLenum pname, GLfixed *params ) */ +static void +android_glGetTexParameterxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jint _exception = 0; + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + if (_remaining < 1) { + _exception = 1; + _env->ThrowNew(IAEClass, "remaining() < 1"); + goto exit; + } + glGetTexParameterxv( + (GLenum)target, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, _exception ? JNI_FALSE : JNI_TRUE); + } +} + +/* GLboolean glIsBuffer ( GLuint buffer ) */ +static jboolean +android_glIsBuffer__I + (JNIEnv *_env, jobject _this, jint buffer) { + GLboolean _returnValue; + _returnValue = glIsBuffer( + (GLuint)buffer + ); + return _returnValue; +} + +/* GLboolean glIsEnabled ( GLenum cap ) */ +static jboolean +android_glIsEnabled__I + (JNIEnv *_env, jobject _this, jint cap) { + GLboolean _returnValue; + _returnValue = glIsEnabled( + (GLenum)cap + ); + return _returnValue; +} + +/* GLboolean glIsTexture ( GLuint texture ) */ +static jboolean +android_glIsTexture__I + (JNIEnv *_env, jobject _this, jint texture) { + GLboolean _returnValue; + _returnValue = glIsTexture( + (GLuint)texture + ); + return _returnValue; +} + +/* void glNormalPointer ( GLenum type, GLsizei stride, GLint offset ) */ +static void +android_glNormalPointer__III + (JNIEnv *_env, jobject _this, jint type, jint stride, jint offset) { + glNormalPointer( + (GLenum)type, + (GLsizei)stride, + (const GLvoid *)offset + ); +} + +/* void glPointParameterf ( GLenum pname, GLfloat param ) */ +static void +android_glPointParameterf__IF + (JNIEnv *_env, jobject _this, jint pname, jfloat param) { + glPointParameterf( + (GLenum)pname, + (GLfloat)param + ); +} + +/* void glPointParameterfv ( GLenum pname, const GLfloat *params ) */ +static void +android_glPointParameterfv__I_3FI + (JNIEnv *_env, jobject _this, jint pname, jfloatArray params_ref, jint offset) { + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "length - offset < 1"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glPointParameterfv( + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glPointParameterfv ( GLenum pname, const GLfloat *params ) */ +static void +android_glPointParameterfv__ILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "remaining() < 1"); + goto exit; + } + glPointParameterfv( + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glPointParameterx ( GLenum pname, GLfixed param ) */ +static void +android_glPointParameterx__II + (JNIEnv *_env, jobject _this, jint pname, jint param) { + glPointParameterx( + (GLenum)pname, + (GLfixed)param + ); +} + +/* void glPointParameterxv ( GLenum pname, const GLfixed *params ) */ +static void +android_glPointParameterxv__I_3II + (JNIEnv *_env, jobject _this, jint pname, jintArray params_ref, jint offset) { + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "length - offset < 1"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glPointParameterxv( + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glPointParameterxv ( GLenum pname, const GLfixed *params ) */ +static void +android_glPointParameterxv__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "remaining() < 1"); + goto exit; + } + glPointParameterxv( + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glPointSizePointerOES ( GLenum type, GLsizei stride, const GLvoid *pointer ) */ +static void +android_glPointSizePointerOES__IILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint type, jint stride, jobject pointer_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLvoid *pointer = (GLvoid *) 0; + + pointer = (GLvoid *)getPointer(_env, pointer_buf, &_array, &_remaining); + glPointSizePointerOES( + (GLenum)type, + (GLsizei)stride, + (GLvoid *)pointer + ); + if (_array) { + releasePointer(_env, _array, pointer, JNI_FALSE); + } +} + +/* void glTexCoordPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ +static void +android_glTexCoordPointer__IIII + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { + glTexCoordPointer( + (GLint)size, + (GLenum)type, + (GLsizei)stride, + (const GLvoid *)offset + ); +} + +/* void glTexEnvi ( GLenum target, GLenum pname, GLint param ) */ +static void +android_glTexEnvi__III + (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { + glTexEnvi( + (GLenum)target, + (GLenum)pname, + (GLint)param + ); +} + +/* void glTexEnviv ( GLenum target, GLenum pname, const GLint *params ) */ +static void +android_glTexEnviv__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "length - offset < needed"); + goto exit; + } + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glTexEnviv( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glTexEnviv ( GLenum target, GLenum pname, const GLint *params ) */ +static void +android_glTexEnviv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining); + int _needed; + switch (pname) { +#if defined(GL_TEXTURE_ENV_MODE) + case GL_TEXTURE_ENV_MODE: +#endif // defined(GL_TEXTURE_ENV_MODE) +#if defined(GL_COMBINE_RGB) + case GL_COMBINE_RGB: +#endif // defined(GL_COMBINE_RGB) +#if defined(GL_COMBINE_ALPHA) + case GL_COMBINE_ALPHA: +#endif // defined(GL_COMBINE_ALPHA) + _needed = 1; + break; +#if defined(GL_TEXTURE_ENV_COLOR) + case GL_TEXTURE_ENV_COLOR: +#endif // defined(GL_TEXTURE_ENV_COLOR) + _needed = 4; + break; + default: + _needed = 0; + break; + } + if (_remaining < _needed) { + _env->ThrowNew(IAEClass, "remaining() < needed"); + goto exit; + } + glTexEnviv( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */ +static void +android_glTexParameterfv__II_3FI + (JNIEnv *_env, jobject _this, jint target, jint pname, jfloatArray params_ref, jint offset) { + GLfloat *params_base = (GLfloat *) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "length - offset < 1"); + goto exit; + } + params_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glTexParameterfv( + (GLenum)target, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glTexParameterfv ( GLenum target, GLenum pname, const GLfloat *params ) */ +static void +android_glTexParameterfv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *params = (GLfloat *) 0; + + params = (GLfloat *)getPointer(_env, params_buf, &_array, &_remaining); + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "remaining() < 1"); + goto exit; + } + glTexParameterfv( + (GLenum)target, + (GLenum)pname, + (GLfloat *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glTexParameteri ( GLenum target, GLenum pname, GLint param ) */ +static void +android_glTexParameteri__III + (JNIEnv *_env, jobject _this, jint target, jint pname, jint param) { + glTexParameteri( + (GLenum)target, + (GLenum)pname, + (GLint)param + ); +} + +/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */ +static void +android_glTexParameteriv__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + GLint *params_base = (GLint *) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "length - offset < 1"); + goto exit; + } + params_base = (GLint *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glTexParameteriv( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glTexParameteriv ( GLenum target, GLenum pname, const GLint *params ) */ +static void +android_glTexParameteriv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLint *params = (GLint *) 0; + + params = (GLint *)getPointer(_env, params_buf, &_array, &_remaining); + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "remaining() < 1"); + goto exit; + } + glTexParameteriv( + (GLenum)target, + (GLenum)pname, + (GLint *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glTexParameterxv ( GLenum target, GLenum pname, const GLfixed *params ) */ +static void +android_glTexParameterxv__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + GLfixed *params_base = (GLfixed *) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + if (!params_ref) { + _env->ThrowNew(IAEClass, "params == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(params_ref) - offset; + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "length - offset < 1"); + goto exit; + } + params_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(params_ref, (jboolean *)0); + params = params_base + offset; + + glTexParameterxv( + (GLenum)target, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (params_base) { + _env->ReleasePrimitiveArrayCritical(params_ref, params_base, + JNI_ABORT); + } +} + +/* void glTexParameterxv ( GLenum target, GLenum pname, const GLfixed *params ) */ +static void +android_glTexParameterxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *params = (GLfixed *) 0; + + params = (GLfixed *)getPointer(_env, params_buf, &_array, &_remaining); + if (_remaining < 1) { + _env->ThrowNew(IAEClass, "remaining() < 1"); + goto exit; + } + glTexParameterxv( + (GLenum)target, + (GLenum)pname, + (GLfixed *)params + ); + +exit: + if (_array) { + releasePointer(_env, _array, params, JNI_FALSE); + } +} + +/* void glVertexPointer ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ +static void +android_glVertexPointer__IIII + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { + glVertexPointer( + (GLint)size, + (GLenum)type, + (GLsizei)stride, + (const GLvoid *)offset + ); +} + +/* void glCurrentPaletteMatrixOES ( GLuint matrixpaletteindex ) */ +static void +android_glCurrentPaletteMatrixOES__I + (JNIEnv *_env, jobject _this, jint matrixpaletteindex) { + _env->ThrowNew(UOEClass, + "glCurrentPaletteMatrixOES"); +} + +/* void glDrawTexfOES ( GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height ) */ +static void +android_glDrawTexfOES__FFFFF + (JNIEnv *_env, jobject _this, jfloat x, jfloat y, jfloat z, jfloat width, jfloat height) { + glDrawTexfOES( + (GLfloat)x, + (GLfloat)y, + (GLfloat)z, + (GLfloat)width, + (GLfloat)height + ); +} + +/* void glDrawTexfvOES ( const GLfloat *coords ) */ +static void +android_glDrawTexfvOES___3FI + (JNIEnv *_env, jobject _this, jfloatArray coords_ref, jint offset) { + GLfloat *coords_base = (GLfloat *) 0; + jint _remaining; + GLfloat *coords = (GLfloat *) 0; + + if (!coords_ref) { + _env->ThrowNew(IAEClass, "coords == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(coords_ref) - offset; + if (_remaining < 5) { + _env->ThrowNew(IAEClass, "length - offset < 5"); + goto exit; + } + coords_base = (GLfloat *) + _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0); + coords = coords_base + offset; + + glDrawTexfvOES( + (GLfloat *)coords + ); + +exit: + if (coords_base) { + _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base, + JNI_ABORT); + } +} + +/* void glDrawTexfvOES ( const GLfloat *coords ) */ +static void +android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jobject coords_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfloat *coords = (GLfloat *) 0; + + coords = (GLfloat *)getPointer(_env, coords_buf, &_array, &_remaining); + if (_remaining < 5) { + _env->ThrowNew(IAEClass, "remaining() < 5"); + goto exit; + } + glDrawTexfvOES( + (GLfloat *)coords + ); + +exit: + if (_array) { + releasePointer(_env, _array, coords, JNI_FALSE); + } +} + +/* void glDrawTexiOES ( GLint x, GLint y, GLint z, GLint width, GLint height ) */ +static void +android_glDrawTexiOES__IIIII + (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) { + glDrawTexiOES( + (GLint)x, + (GLint)y, + (GLint)z, + (GLint)width, + (GLint)height + ); +} + +/* void glDrawTexivOES ( const GLint *coords ) */ +static void +android_glDrawTexivOES___3II + (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) { + GLint *coords_base = (GLint *) 0; + jint _remaining; + GLint *coords = (GLint *) 0; + + if (!coords_ref) { + _env->ThrowNew(IAEClass, "coords == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(coords_ref) - offset; + if (_remaining < 5) { + _env->ThrowNew(IAEClass, "length - offset < 5"); + goto exit; + } + coords_base = (GLint *) + _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0); + coords = coords_base + offset; + + glDrawTexivOES( + (GLint *)coords + ); + +exit: + if (coords_base) { + _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base, + JNI_ABORT); + } +} + +/* void glDrawTexivOES ( const GLint *coords ) */ +static void +android_glDrawTexivOES__Ljava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jobject coords_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLint *coords = (GLint *) 0; + + coords = (GLint *)getPointer(_env, coords_buf, &_array, &_remaining); + if (_remaining < 5) { + _env->ThrowNew(IAEClass, "remaining() < 5"); + goto exit; + } + glDrawTexivOES( + (GLint *)coords + ); + +exit: + if (_array) { + releasePointer(_env, _array, coords, JNI_FALSE); + } +} + +/* void glDrawTexsOES ( GLshort x, GLshort y, GLshort z, GLshort width, GLshort height ) */ +static void +android_glDrawTexsOES__SSSSS + (JNIEnv *_env, jobject _this, jshort x, jshort y, jshort z, jshort width, jshort height) { + glDrawTexsOES( + (GLshort)x, + (GLshort)y, + (GLshort)z, + (GLshort)width, + (GLshort)height + ); +} + +/* void glDrawTexsvOES ( const GLshort *coords ) */ +static void +android_glDrawTexsvOES___3SI + (JNIEnv *_env, jobject _this, jshortArray coords_ref, jint offset) { + GLshort *coords_base = (GLshort *) 0; + jint _remaining; + GLshort *coords = (GLshort *) 0; + + if (!coords_ref) { + _env->ThrowNew(IAEClass, "coords == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(coords_ref) - offset; + if (_remaining < 5) { + _env->ThrowNew(IAEClass, "length - offset < 5"); + goto exit; + } + coords_base = (GLshort *) + _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0); + coords = coords_base + offset; + + glDrawTexsvOES( + (GLshort *)coords + ); + +exit: + if (coords_base) { + _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base, + JNI_ABORT); + } +} + +/* void glDrawTexsvOES ( const GLshort *coords ) */ +static void +android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 + (JNIEnv *_env, jobject _this, jobject coords_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLshort *coords = (GLshort *) 0; + + coords = (GLshort *)getPointer(_env, coords_buf, &_array, &_remaining); + if (_remaining < 5) { + _env->ThrowNew(IAEClass, "remaining() < 5"); + goto exit; + } + glDrawTexsvOES( + (GLshort *)coords + ); + +exit: + if (_array) { + releasePointer(_env, _array, coords, JNI_FALSE); + } +} + +/* void glDrawTexxOES ( GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height ) */ +static void +android_glDrawTexxOES__IIIII + (JNIEnv *_env, jobject _this, jint x, jint y, jint z, jint width, jint height) { + glDrawTexxOES( + (GLfixed)x, + (GLfixed)y, + (GLfixed)z, + (GLfixed)width, + (GLfixed)height + ); +} + +/* void glDrawTexxvOES ( const GLfixed *coords ) */ +static void +android_glDrawTexxvOES___3II + (JNIEnv *_env, jobject _this, jintArray coords_ref, jint offset) { + GLfixed *coords_base = (GLfixed *) 0; + jint _remaining; + GLfixed *coords = (GLfixed *) 0; + + if (!coords_ref) { + _env->ThrowNew(IAEClass, "coords == null"); + goto exit; + } + if (offset < 0) { + _env->ThrowNew(IAEClass, "offset < 0"); + goto exit; + } + _remaining = _env->GetArrayLength(coords_ref) - offset; + if (_remaining < 5) { + _env->ThrowNew(IAEClass, "length - offset < 5"); + goto exit; + } + coords_base = (GLfixed *) + _env->GetPrimitiveArrayCritical(coords_ref, (jboolean *)0); + coords = coords_base + offset; + + glDrawTexxvOES( + (GLfixed *)coords + ); + +exit: + if (coords_base) { + _env->ReleasePrimitiveArrayCritical(coords_ref, coords_base, + JNI_ABORT); + } +} + +/* void glDrawTexxvOES ( const GLfixed *coords ) */ +static void +android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jobject coords_buf) { + jarray _array = (jarray) 0; + jint _remaining; + GLfixed *coords = (GLfixed *) 0; + + coords = (GLfixed *)getPointer(_env, coords_buf, &_array, &_remaining); + if (_remaining < 5) { + _env->ThrowNew(IAEClass, "remaining() < 5"); + goto exit; + } + glDrawTexxvOES( + (GLfixed *)coords + ); + +exit: + if (_array) { + releasePointer(_env, _array, coords, JNI_FALSE); + } +} + +/* void glLoadPaletteFromModelViewMatrixOES ( void ) */ +static void +android_glLoadPaletteFromModelViewMatrixOES__ + (JNIEnv *_env, jobject _this) { + _env->ThrowNew(UOEClass, + "glLoadPaletteFromModelViewMatrixOES"); +} + +/* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ +static void +android_glMatrixIndexPointerOES__IIILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf) { + _env->ThrowNew(UOEClass, + "glMatrixIndexPointerOES"); +} + +/* void glMatrixIndexPointerOES ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ +static void +android_glMatrixIndexPointerOES__IIII + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { + _env->ThrowNew(UOEClass, + "glMatrixIndexPointerOES"); +} + +/* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, const GLvoid *pointer ) */ +static void +android_glWeightPointerOES__IIILjava_nio_Buffer_2 + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jobject pointer_buf) { + _env->ThrowNew(UOEClass, + "glWeightPointerOES"); +} + +/* void glWeightPointerOES ( GLint size, GLenum type, GLsizei stride, GLint offset ) */ +static void +android_glWeightPointerOES__IIII + (JNIEnv *_env, jobject _this, jint size, jint type, jint stride, jint offset) { + _env->ThrowNew(UOEClass, + "glWeightPointerOES"); +} + +/* void glBindFramebufferOES ( GLint target, GLint framebuffer ) */ +static void +android_glBindFramebufferOES__II + (JNIEnv *_env, jobject _this, jint target, jint framebuffer) { + _env->ThrowNew(UOEClass, + "glBindFramebufferOES"); +} + +/* void glBindRenderbufferOES ( GLint target, GLint renderbuffer ) */ +static void +android_glBindRenderbufferOES__II + (JNIEnv *_env, jobject _this, jint target, jint renderbuffer) { + _env->ThrowNew(UOEClass, + "glBindRenderbufferOES"); +} + +/* void glBlendEquation ( GLint mode ) */ +static void +android_glBlendEquation__I + (JNIEnv *_env, jobject _this, jint mode) { + _env->ThrowNew(UOEClass, + "glBlendEquation"); +} + +/* void glBlendEquationSeparate ( GLint modeRGB, GLint modeAlpha ) */ +static void +android_glBlendEquationSeparate__II + (JNIEnv *_env, jobject _this, jint modeRGB, jint modeAlpha) { + _env->ThrowNew(UOEClass, + "glBlendEquationSeparate"); +} + +/* void glBlendFuncSeparate ( GLint srcRGB, GLint dstRGB, GLint srcAlpha, GLint dstAlpha ) */ +static void +android_glBlendFuncSeparate__IIII + (JNIEnv *_env, jobject _this, jint srcRGB, jint dstRGB, jint srcAlpha, jint dstAlpha) { + _env->ThrowNew(UOEClass, + "glBlendFuncSeparate"); +} + +/* GLint glCheckFramebufferStatusOES ( GLint target ) */ +static jint +android_glCheckFramebufferStatusOES__I + (JNIEnv *_env, jobject _this, jint target) { + _env->ThrowNew(UOEClass, + "glCheckFramebufferStatusOES"); + return 0; +} + +/* void glDeleteFramebuffersOES ( GLint n, GLint *framebuffers ) */ +static void +android_glDeleteFramebuffersOES__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glDeleteFramebuffersOES"); +} + +/* void glDeleteFramebuffersOES ( GLint n, GLint *framebuffers ) */ +static void +android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) { + _env->ThrowNew(UOEClass, + "glDeleteFramebuffersOES"); +} + +/* void glDeleteRenderbuffersOES ( GLint n, GLint *renderbuffers ) */ +static void +android_glDeleteRenderbuffersOES__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glDeleteRenderbuffersOES"); +} + +/* void glDeleteRenderbuffersOES ( GLint n, GLint *renderbuffers ) */ +static void +android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) { + _env->ThrowNew(UOEClass, + "glDeleteRenderbuffersOES"); +} + +/* void glFramebufferRenderbufferOES ( GLint target, GLint attachment, GLint renderbuffertarget, GLint renderbuffer ) */ +static void +android_glFramebufferRenderbufferOES__IIII + (JNIEnv *_env, jobject _this, jint target, jint attachment, jint renderbuffertarget, jint renderbuffer) { + _env->ThrowNew(UOEClass, + "glFramebufferRenderbufferOES"); +} + +/* void glFramebufferTexture2DOES ( GLint target, GLint attachment, GLint textarget, GLint texture, GLint level ) */ +static void +android_glFramebufferTexture2DOES__IIIII + (JNIEnv *_env, jobject _this, jint target, jint attachment, jint textarget, jint texture, jint level) { + _env->ThrowNew(UOEClass, + "glFramebufferTexture2DOES"); +} + +/* void glGenerateMipmapOES ( GLint target ) */ +static void +android_glGenerateMipmapOES__I + (JNIEnv *_env, jobject _this, jint target) { + _env->ThrowNew(UOEClass, + "glGenerateMipmapOES"); +} + +/* void glGenFramebuffersOES ( GLint n, GLint *framebuffers ) */ +static void +android_glGenFramebuffersOES__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray framebuffers_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glGenFramebuffersOES"); +} + +/* void glGenFramebuffersOES ( GLint n, GLint *framebuffers ) */ +static void +android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject framebuffers_buf) { + _env->ThrowNew(UOEClass, + "glGenFramebuffersOES"); +} + +/* void glGenRenderbuffersOES ( GLint n, GLint *renderbuffers ) */ +static void +android_glGenRenderbuffersOES__I_3II + (JNIEnv *_env, jobject _this, jint n, jintArray renderbuffers_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glGenRenderbuffersOES"); +} + +/* void glGenRenderbuffersOES ( GLint n, GLint *renderbuffers ) */ +static void +android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint n, jobject renderbuffers_buf) { + _env->ThrowNew(UOEClass, + "glGenRenderbuffersOES"); +} + +/* void glGetFramebufferAttachmentParameterivOES ( GLint target, GLint attachment, GLint pname, GLint *params ) */ +static void +android_glGetFramebufferAttachmentParameterivOES__III_3II + (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jintArray params_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glGetFramebufferAttachmentParameterivOES"); +} + +/* void glGetFramebufferAttachmentParameterivOES ( GLint target, GLint attachment, GLint pname, GLint *params ) */ +static void +android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint attachment, jint pname, jobject params_buf) { + _env->ThrowNew(UOEClass, + "glGetFramebufferAttachmentParameterivOES"); +} + +/* void glGetRenderbufferParameterivOES ( GLint target, GLint pname, GLint *params ) */ +static void +android_glGetRenderbufferParameterivOES__II_3II + (JNIEnv *_env, jobject _this, jint target, jint pname, jintArray params_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glGetRenderbufferParameterivOES"); +} + +/* void glGetRenderbufferParameterivOES ( GLint target, GLint pname, GLint *params ) */ +static void +android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint target, jint pname, jobject params_buf) { + _env->ThrowNew(UOEClass, + "glGetRenderbufferParameterivOES"); +} + +/* void glGetTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */ +static void +android_glGetTexGenfv__II_3FI + (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glGetTexGenfv"); +} + +/* void glGetTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */ +static void +android_glGetTexGenfv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { + _env->ThrowNew(UOEClass, + "glGetTexGenfv"); +} + +/* void glGetTexGeniv ( GLint coord, GLint pname, GLint *params ) */ +static void +android_glGetTexGeniv__II_3II + (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glGetTexGeniv"); +} + +/* void glGetTexGeniv ( GLint coord, GLint pname, GLint *params ) */ +static void +android_glGetTexGeniv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { + _env->ThrowNew(UOEClass, + "glGetTexGeniv"); +} + +/* void glGetTexGenxv ( GLint coord, GLint pname, GLint *params ) */ +static void +android_glGetTexGenxv__II_3II + (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glGetTexGenxv"); +} + +/* void glGetTexGenxv ( GLint coord, GLint pname, GLint *params ) */ +static void +android_glGetTexGenxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { + _env->ThrowNew(UOEClass, + "glGetTexGenxv"); +} + +/* GLboolean glIsFramebufferOES ( GLint framebuffer ) */ +static jboolean +android_glIsFramebufferOES__I + (JNIEnv *_env, jobject _this, jint framebuffer) { + _env->ThrowNew(UOEClass, + "glIsFramebufferOES"); + return JNI_FALSE; +} + +/* GLboolean glIsRenderbufferOES ( GLint renderbuffer ) */ +static jboolean +android_glIsRenderbufferOES__I + (JNIEnv *_env, jobject _this, jint renderbuffer) { + _env->ThrowNew(UOEClass, + "glIsRenderbufferOES"); + return JNI_FALSE; +} + +/* void glRenderbufferStorageOES ( GLint target, GLint internalformat, GLint width, GLint height ) */ +static void +android_glRenderbufferStorageOES__IIII + (JNIEnv *_env, jobject _this, jint target, jint internalformat, jint width, jint height) { + _env->ThrowNew(UOEClass, + "glRenderbufferStorageOES"); +} + +/* void glTexGenf ( GLint coord, GLint pname, GLfloat param ) */ +static void +android_glTexGenf__IIF + (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloat param) { + _env->ThrowNew(UOEClass, + "glTexGenf"); +} + +/* void glTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */ +static void +android_glTexGenfv__II_3FI + (JNIEnv *_env, jobject _this, jint coord, jint pname, jfloatArray params_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glTexGenfv"); +} + +/* void glTexGenfv ( GLint coord, GLint pname, GLfloat *params ) */ +static void +android_glTexGenfv__IILjava_nio_FloatBuffer_2 + (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { + _env->ThrowNew(UOEClass, + "glTexGenfv"); +} + +/* void glTexGeni ( GLint coord, GLint pname, GLint param ) */ +static void +android_glTexGeni__III + (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) { + _env->ThrowNew(UOEClass, + "glTexGeni"); +} + +/* void glTexGeniv ( GLint coord, GLint pname, GLint *params ) */ +static void +android_glTexGeniv__II_3II + (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glTexGeniv"); +} + +/* void glTexGeniv ( GLint coord, GLint pname, GLint *params ) */ +static void +android_glTexGeniv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { + _env->ThrowNew(UOEClass, + "glTexGeniv"); +} + +/* void glTexGenx ( GLint coord, GLint pname, GLint param ) */ +static void +android_glTexGenx__III + (JNIEnv *_env, jobject _this, jint coord, jint pname, jint param) { + _env->ThrowNew(UOEClass, + "glTexGenx"); +} + +/* void glTexGenxv ( GLint coord, GLint pname, GLint *params ) */ +static void +android_glTexGenxv__II_3II + (JNIEnv *_env, jobject _this, jint coord, jint pname, jintArray params_ref, jint offset) { + _env->ThrowNew(UOEClass, + "glTexGenxv"); +} + +/* void glTexGenxv ( GLint coord, GLint pname, GLint *params ) */ +static void +android_glTexGenxv__IILjava_nio_IntBuffer_2 + (JNIEnv *_env, jobject _this, jint coord, jint pname, jobject params_buf) { + _env->ThrowNew(UOEClass, + "glTexGenxv"); +} + +static const char *classPathName = "com/google/android/gles_jni/GLImpl"; + +static JNINativeMethod methods[] = { +{"_nativeClassInit", "()V", (void*)nativeClassInit }, +{"glActiveTexture", "(I)V", (void *) android_glActiveTexture__I }, +{"glAlphaFunc", "(IF)V", (void *) android_glAlphaFunc__IF }, +{"glAlphaFuncx", "(II)V", (void *) android_glAlphaFuncx__II }, +{"glBindTexture", "(II)V", (void *) android_glBindTexture__II }, +{"glBlendFunc", "(II)V", (void *) android_glBlendFunc__II }, +{"glClear", "(I)V", (void *) android_glClear__I }, +{"glClearColor", "(FFFF)V", (void *) android_glClearColor__FFFF }, +{"glClearColorx", "(IIII)V", (void *) android_glClearColorx__IIII }, +{"glClearDepthf", "(F)V", (void *) android_glClearDepthf__F }, +{"glClearDepthx", "(I)V", (void *) android_glClearDepthx__I }, +{"glClearStencil", "(I)V", (void *) android_glClearStencil__I }, +{"glClientActiveTexture", "(I)V", (void *) android_glClientActiveTexture__I }, +{"glColor4f", "(FFFF)V", (void *) android_glColor4f__FFFF }, +{"glColor4x", "(IIII)V", (void *) android_glColor4x__IIII }, +{"glColorMask", "(ZZZZ)V", (void *) android_glColorMask__ZZZZ }, +{"glColorPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glColorPointerBounds__IIILjava_nio_Buffer_2I }, +{"glCompressedTexImage2D", "(IIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexImage2D__IIIIIIILjava_nio_Buffer_2 }, +{"glCompressedTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glCompressedTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 }, +{"glCopyTexImage2D", "(IIIIIIII)V", (void *) android_glCopyTexImage2D__IIIIIIII }, +{"glCopyTexSubImage2D", "(IIIIIIII)V", (void *) android_glCopyTexSubImage2D__IIIIIIII }, +{"glCullFace", "(I)V", (void *) android_glCullFace__I }, +{"glDeleteTextures", "(I[II)V", (void *) android_glDeleteTextures__I_3II }, +{"glDeleteTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteTextures__ILjava_nio_IntBuffer_2 }, +{"glDepthFunc", "(I)V", (void *) android_glDepthFunc__I }, +{"glDepthMask", "(Z)V", (void *) android_glDepthMask__Z }, +{"glDepthRangef", "(FF)V", (void *) android_glDepthRangef__FF }, +{"glDepthRangex", "(II)V", (void *) android_glDepthRangex__II }, +{"glDisable", "(I)V", (void *) android_glDisable__I }, +{"glDisableClientState", "(I)V", (void *) android_glDisableClientState__I }, +{"glDrawArrays", "(III)V", (void *) android_glDrawArrays__III }, +{"glDrawElements", "(IIILjava/nio/Buffer;)V", (void *) android_glDrawElements__IIILjava_nio_Buffer_2 }, +{"glEnable", "(I)V", (void *) android_glEnable__I }, +{"glEnableClientState", "(I)V", (void *) android_glEnableClientState__I }, +{"glFinish", "()V", (void *) android_glFinish__ }, +{"glFlush", "()V", (void *) android_glFlush__ }, +{"glFogf", "(IF)V", (void *) android_glFogf__IF }, +{"glFogfv", "(I[FI)V", (void *) android_glFogfv__I_3FI }, +{"glFogfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glFogfv__ILjava_nio_FloatBuffer_2 }, +{"glFogx", "(II)V", (void *) android_glFogx__II }, +{"glFogxv", "(I[II)V", (void *) android_glFogxv__I_3II }, +{"glFogxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glFogxv__ILjava_nio_IntBuffer_2 }, +{"glFrontFace", "(I)V", (void *) android_glFrontFace__I }, +{"glFrustumf", "(FFFFFF)V", (void *) android_glFrustumf__FFFFFF }, +{"glFrustumx", "(IIIIII)V", (void *) android_glFrustumx__IIIIII }, +{"glGenTextures", "(I[II)V", (void *) android_glGenTextures__I_3II }, +{"glGenTextures", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenTextures__ILjava_nio_IntBuffer_2 }, +{"glGetError", "()I", (void *) android_glGetError__ }, +{"glGetIntegerv", "(I[II)V", (void *) android_glGetIntegerv__I_3II }, +{"glGetIntegerv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetIntegerv__ILjava_nio_IntBuffer_2 }, +{"_glGetString", "(I)Ljava/lang/String;", (void *) android_glGetString }, +{"glHint", "(II)V", (void *) android_glHint__II }, +{"glLightModelf", "(IF)V", (void *) android_glLightModelf__IF }, +{"glLightModelfv", "(I[FI)V", (void *) android_glLightModelfv__I_3FI }, +{"glLightModelfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glLightModelfv__ILjava_nio_FloatBuffer_2 }, +{"glLightModelx", "(II)V", (void *) android_glLightModelx__II }, +{"glLightModelxv", "(I[II)V", (void *) android_glLightModelxv__I_3II }, +{"glLightModelxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glLightModelxv__ILjava_nio_IntBuffer_2 }, +{"glLightf", "(IIF)V", (void *) android_glLightf__IIF }, +{"glLightfv", "(II[FI)V", (void *) android_glLightfv__II_3FI }, +{"glLightfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glLightfv__IILjava_nio_FloatBuffer_2 }, +{"glLightx", "(III)V", (void *) android_glLightx__III }, +{"glLightxv", "(II[II)V", (void *) android_glLightxv__II_3II }, +{"glLightxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glLightxv__IILjava_nio_IntBuffer_2 }, +{"glLineWidth", "(F)V", (void *) android_glLineWidth__F }, +{"glLineWidthx", "(I)V", (void *) android_glLineWidthx__I }, +{"glLoadIdentity", "()V", (void *) android_glLoadIdentity__ }, +{"glLoadMatrixf", "([FI)V", (void *) android_glLoadMatrixf___3FI }, +{"glLoadMatrixf", "(Ljava/nio/FloatBuffer;)V", (void *) android_glLoadMatrixf__Ljava_nio_FloatBuffer_2 }, +{"glLoadMatrixx", "([II)V", (void *) android_glLoadMatrixx___3II }, +{"glLoadMatrixx", "(Ljava/nio/IntBuffer;)V", (void *) android_glLoadMatrixx__Ljava_nio_IntBuffer_2 }, +{"glLogicOp", "(I)V", (void *) android_glLogicOp__I }, +{"glMaterialf", "(IIF)V", (void *) android_glMaterialf__IIF }, +{"glMaterialfv", "(II[FI)V", (void *) android_glMaterialfv__II_3FI }, +{"glMaterialfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glMaterialfv__IILjava_nio_FloatBuffer_2 }, +{"glMaterialx", "(III)V", (void *) android_glMaterialx__III }, +{"glMaterialxv", "(II[II)V", (void *) android_glMaterialxv__II_3II }, +{"glMaterialxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glMaterialxv__IILjava_nio_IntBuffer_2 }, +{"glMatrixMode", "(I)V", (void *) android_glMatrixMode__I }, +{"glMultMatrixf", "([FI)V", (void *) android_glMultMatrixf___3FI }, +{"glMultMatrixf", "(Ljava/nio/FloatBuffer;)V", (void *) android_glMultMatrixf__Ljava_nio_FloatBuffer_2 }, +{"glMultMatrixx", "([II)V", (void *) android_glMultMatrixx___3II }, +{"glMultMatrixx", "(Ljava/nio/IntBuffer;)V", (void *) android_glMultMatrixx__Ljava_nio_IntBuffer_2 }, +{"glMultiTexCoord4f", "(IFFFF)V", (void *) android_glMultiTexCoord4f__IFFFF }, +{"glMultiTexCoord4x", "(IIIII)V", (void *) android_glMultiTexCoord4x__IIIII }, +{"glNormal3f", "(FFF)V", (void *) android_glNormal3f__FFF }, +{"glNormal3x", "(III)V", (void *) android_glNormal3x__III }, +{"glNormalPointerBounds", "(IILjava/nio/Buffer;I)V", (void *) android_glNormalPointerBounds__IILjava_nio_Buffer_2I }, +{"glOrthof", "(FFFFFF)V", (void *) android_glOrthof__FFFFFF }, +{"glOrthox", "(IIIIII)V", (void *) android_glOrthox__IIIIII }, +{"glPixelStorei", "(II)V", (void *) android_glPixelStorei__II }, +{"glPointSize", "(F)V", (void *) android_glPointSize__F }, +{"glPointSizex", "(I)V", (void *) android_glPointSizex__I }, +{"glPolygonOffset", "(FF)V", (void *) android_glPolygonOffset__FF }, +{"glPolygonOffsetx", "(II)V", (void *) android_glPolygonOffsetx__II }, +{"glPopMatrix", "()V", (void *) android_glPopMatrix__ }, +{"glPushMatrix", "()V", (void *) android_glPushMatrix__ }, +{"glReadPixels", "(IIIIIILjava/nio/Buffer;)V", (void *) android_glReadPixels__IIIIIILjava_nio_Buffer_2 }, +{"glRotatef", "(FFFF)V", (void *) android_glRotatef__FFFF }, +{"glRotatex", "(IIII)V", (void *) android_glRotatex__IIII }, +{"glSampleCoverage", "(FZ)V", (void *) android_glSampleCoverage__FZ }, +{"glSampleCoveragex", "(IZ)V", (void *) android_glSampleCoveragex__IZ }, +{"glScalef", "(FFF)V", (void *) android_glScalef__FFF }, +{"glScalex", "(III)V", (void *) android_glScalex__III }, +{"glScissor", "(IIII)V", (void *) android_glScissor__IIII }, +{"glShadeModel", "(I)V", (void *) android_glShadeModel__I }, +{"glStencilFunc", "(III)V", (void *) android_glStencilFunc__III }, +{"glStencilMask", "(I)V", (void *) android_glStencilMask__I }, +{"glStencilOp", "(III)V", (void *) android_glStencilOp__III }, +{"glTexCoordPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glTexCoordPointerBounds__IIILjava_nio_Buffer_2I }, +{"glTexEnvf", "(IIF)V", (void *) android_glTexEnvf__IIF }, +{"glTexEnvfv", "(II[FI)V", (void *) android_glTexEnvfv__II_3FI }, +{"glTexEnvfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexEnvfv__IILjava_nio_FloatBuffer_2 }, +{"glTexEnvx", "(III)V", (void *) android_glTexEnvx__III }, +{"glTexEnvxv", "(II[II)V", (void *) android_glTexEnvxv__II_3II }, +{"glTexEnvxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnvxv__IILjava_nio_IntBuffer_2 }, +{"glTexImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexImage2D__IIIIIIIILjava_nio_Buffer_2 }, +{"glTexParameterf", "(IIF)V", (void *) android_glTexParameterf__IIF }, +{"glTexParameterx", "(III)V", (void *) android_glTexParameterx__III }, +{"glTexSubImage2D", "(IIIIIIIILjava/nio/Buffer;)V", (void *) android_glTexSubImage2D__IIIIIIIILjava_nio_Buffer_2 }, +{"glTranslatef", "(FFF)V", (void *) android_glTranslatef__FFF }, +{"glTranslatex", "(III)V", (void *) android_glTranslatex__III }, +{"glVertexPointerBounds", "(IIILjava/nio/Buffer;I)V", (void *) android_glVertexPointerBounds__IIILjava_nio_Buffer_2I }, +{"glViewport", "(IIII)V", (void *) android_glViewport__IIII }, +{"glQueryMatrixxOES", "([II[II)I", (void *) android_glQueryMatrixxOES___3II_3II }, +{"glQueryMatrixxOES", "(Ljava/nio/IntBuffer;Ljava/nio/IntBuffer;)I", (void *) android_glQueryMatrixxOES__Ljava_nio_IntBuffer_2Ljava_nio_IntBuffer_2 }, +{"glBindBuffer", "(II)V", (void *) android_glBindBuffer__II }, +{"glBufferData", "(IILjava/nio/Buffer;I)V", (void *) android_glBufferData__IILjava_nio_Buffer_2I }, +{"glBufferSubData", "(IIILjava/nio/Buffer;)V", (void *) android_glBufferSubData__IIILjava_nio_Buffer_2 }, +{"glClipPlanef", "(I[FI)V", (void *) android_glClipPlanef__I_3FI }, +{"glClipPlanef", "(ILjava/nio/FloatBuffer;)V", (void *) android_glClipPlanef__ILjava_nio_FloatBuffer_2 }, +{"glClipPlanex", "(I[II)V", (void *) android_glClipPlanex__I_3II }, +{"glClipPlanex", "(ILjava/nio/IntBuffer;)V", (void *) android_glClipPlanex__ILjava_nio_IntBuffer_2 }, +{"glColor4ub", "(BBBB)V", (void *) android_glColor4ub__BBBB }, +{"glColorPointer", "(IIII)V", (void *) android_glColorPointer__IIII }, +{"glDeleteBuffers", "(I[II)V", (void *) android_glDeleteBuffers__I_3II }, +{"glDeleteBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteBuffers__ILjava_nio_IntBuffer_2 }, +{"glDrawElements", "(IIII)V", (void *) android_glDrawElements__IIII }, +{"glGenBuffers", "(I[II)V", (void *) android_glGenBuffers__I_3II }, +{"glGenBuffers", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenBuffers__ILjava_nio_IntBuffer_2 }, +{"glGetBooleanv", "(I[ZI)V", (void *) android_glGetBooleanv__I_3ZI }, +{"glGetBooleanv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetBooleanv__ILjava_nio_IntBuffer_2 }, +{"glGetBufferParameteriv", "(II[II)V", (void *) android_glGetBufferParameteriv__II_3II }, +{"glGetBufferParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetBufferParameteriv__IILjava_nio_IntBuffer_2 }, +{"glGetClipPlanef", "(I[FI)V", (void *) android_glGetClipPlanef__I_3FI }, +{"glGetClipPlanef", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetClipPlanef__ILjava_nio_FloatBuffer_2 }, +{"glGetClipPlanex", "(I[II)V", (void *) android_glGetClipPlanex__I_3II }, +{"glGetClipPlanex", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetClipPlanex__ILjava_nio_IntBuffer_2 }, +{"glGetFixedv", "(I[II)V", (void *) android_glGetFixedv__I_3II }, +{"glGetFixedv", "(ILjava/nio/IntBuffer;)V", (void *) android_glGetFixedv__ILjava_nio_IntBuffer_2 }, +{"glGetFloatv", "(I[FI)V", (void *) android_glGetFloatv__I_3FI }, +{"glGetFloatv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glGetFloatv__ILjava_nio_FloatBuffer_2 }, +{"glGetLightfv", "(II[FI)V", (void *) android_glGetLightfv__II_3FI }, +{"glGetLightfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetLightfv__IILjava_nio_FloatBuffer_2 }, +{"glGetLightxv", "(II[II)V", (void *) android_glGetLightxv__II_3II }, +{"glGetLightxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetLightxv__IILjava_nio_IntBuffer_2 }, +{"glGetMaterialfv", "(II[FI)V", (void *) android_glGetMaterialfv__II_3FI }, +{"glGetMaterialfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetMaterialfv__IILjava_nio_FloatBuffer_2 }, +{"glGetMaterialxv", "(II[II)V", (void *) android_glGetMaterialxv__II_3II }, +{"glGetMaterialxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetMaterialxv__IILjava_nio_IntBuffer_2 }, +{"glGetTexEnviv", "(II[II)V", (void *) android_glGetTexEnviv__II_3II }, +{"glGetTexEnviv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnviv__IILjava_nio_IntBuffer_2 }, +{"glGetTexEnvxv", "(II[II)V", (void *) android_glGetTexEnvxv__II_3II }, +{"glGetTexEnvxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexEnvxv__IILjava_nio_IntBuffer_2 }, +{"glGetTexParameterfv", "(II[FI)V", (void *) android_glGetTexParameterfv__II_3FI }, +{"glGetTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexParameterfv__IILjava_nio_FloatBuffer_2 }, +{"glGetTexParameteriv", "(II[II)V", (void *) android_glGetTexParameteriv__II_3II }, +{"glGetTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameteriv__IILjava_nio_IntBuffer_2 }, +{"glGetTexParameterxv", "(II[II)V", (void *) android_glGetTexParameterxv__II_3II }, +{"glGetTexParameterxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexParameterxv__IILjava_nio_IntBuffer_2 }, +{"glIsBuffer", "(I)Z", (void *) android_glIsBuffer__I }, +{"glIsEnabled", "(I)Z", (void *) android_glIsEnabled__I }, +{"glIsTexture", "(I)Z", (void *) android_glIsTexture__I }, +{"glNormalPointer", "(III)V", (void *) android_glNormalPointer__III }, +{"glPointParameterf", "(IF)V", (void *) android_glPointParameterf__IF }, +{"glPointParameterfv", "(I[FI)V", (void *) android_glPointParameterfv__I_3FI }, +{"glPointParameterfv", "(ILjava/nio/FloatBuffer;)V", (void *) android_glPointParameterfv__ILjava_nio_FloatBuffer_2 }, +{"glPointParameterx", "(II)V", (void *) android_glPointParameterx__II }, +{"glPointParameterxv", "(I[II)V", (void *) android_glPointParameterxv__I_3II }, +{"glPointParameterxv", "(ILjava/nio/IntBuffer;)V", (void *) android_glPointParameterxv__ILjava_nio_IntBuffer_2 }, +{"glPointSizePointerOES", "(IILjava/nio/Buffer;)V", (void *) android_glPointSizePointerOES__IILjava_nio_Buffer_2 }, +{"glTexCoordPointer", "(IIII)V", (void *) android_glTexCoordPointer__IIII }, +{"glTexEnvi", "(III)V", (void *) android_glTexEnvi__III }, +{"glTexEnviv", "(II[II)V", (void *) android_glTexEnviv__II_3II }, +{"glTexEnviv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexEnviv__IILjava_nio_IntBuffer_2 }, +{"glTexParameterfv", "(II[FI)V", (void *) android_glTexParameterfv__II_3FI }, +{"glTexParameterfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexParameterfv__IILjava_nio_FloatBuffer_2 }, +{"glTexParameteri", "(III)V", (void *) android_glTexParameteri__III }, +{"glTexParameteriv", "(II[II)V", (void *) android_glTexParameteriv__II_3II }, +{"glTexParameteriv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameteriv__IILjava_nio_IntBuffer_2 }, +{"glTexParameterxv", "(II[II)V", (void *) android_glTexParameterxv__II_3II }, +{"glTexParameterxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexParameterxv__IILjava_nio_IntBuffer_2 }, +{"glVertexPointer", "(IIII)V", (void *) android_glVertexPointer__IIII }, +{"glCurrentPaletteMatrixOES", "(I)V", (void *) android_glCurrentPaletteMatrixOES__I }, +{"glDrawTexfOES", "(FFFFF)V", (void *) android_glDrawTexfOES__FFFFF }, +{"glDrawTexfvOES", "([FI)V", (void *) android_glDrawTexfvOES___3FI }, +{"glDrawTexfvOES", "(Ljava/nio/FloatBuffer;)V", (void *) android_glDrawTexfvOES__Ljava_nio_FloatBuffer_2 }, +{"glDrawTexiOES", "(IIIII)V", (void *) android_glDrawTexiOES__IIIII }, +{"glDrawTexivOES", "([II)V", (void *) android_glDrawTexivOES___3II }, +{"glDrawTexivOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexivOES__Ljava_nio_IntBuffer_2 }, +{"glDrawTexsOES", "(SSSSS)V", (void *) android_glDrawTexsOES__SSSSS }, +{"glDrawTexsvOES", "([SI)V", (void *) android_glDrawTexsvOES___3SI }, +{"glDrawTexsvOES", "(Ljava/nio/ShortBuffer;)V", (void *) android_glDrawTexsvOES__Ljava_nio_ShortBuffer_2 }, +{"glDrawTexxOES", "(IIIII)V", (void *) android_glDrawTexxOES__IIIII }, +{"glDrawTexxvOES", "([II)V", (void *) android_glDrawTexxvOES___3II }, +{"glDrawTexxvOES", "(Ljava/nio/IntBuffer;)V", (void *) android_glDrawTexxvOES__Ljava_nio_IntBuffer_2 }, +{"glLoadPaletteFromModelViewMatrixOES", "()V", (void *) android_glLoadPaletteFromModelViewMatrixOES__ }, +{"glMatrixIndexPointerOES", "(IIILjava/nio/Buffer;)V", (void *) android_glMatrixIndexPointerOES__IIILjava_nio_Buffer_2 }, +{"glMatrixIndexPointerOES", "(IIII)V", (void *) android_glMatrixIndexPointerOES__IIII }, +{"glWeightPointerOES", "(IIILjava/nio/Buffer;)V", (void *) android_glWeightPointerOES__IIILjava_nio_Buffer_2 }, +{"glWeightPointerOES", "(IIII)V", (void *) android_glWeightPointerOES__IIII }, +{"glBindFramebufferOES", "(II)V", (void *) android_glBindFramebufferOES__II }, +{"glBindRenderbufferOES", "(II)V", (void *) android_glBindRenderbufferOES__II }, +{"glBlendEquation", "(I)V", (void *) android_glBlendEquation__I }, +{"glBlendEquationSeparate", "(II)V", (void *) android_glBlendEquationSeparate__II }, +{"glBlendFuncSeparate", "(IIII)V", (void *) android_glBlendFuncSeparate__IIII }, +{"glCheckFramebufferStatusOES", "(I)I", (void *) android_glCheckFramebufferStatusOES__I }, +{"glDeleteFramebuffersOES", "(I[II)V", (void *) android_glDeleteFramebuffersOES__I_3II }, +{"glDeleteFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteFramebuffersOES__ILjava_nio_IntBuffer_2 }, +{"glDeleteRenderbuffersOES", "(I[II)V", (void *) android_glDeleteRenderbuffersOES__I_3II }, +{"glDeleteRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glDeleteRenderbuffersOES__ILjava_nio_IntBuffer_2 }, +{"glFramebufferRenderbufferOES", "(IIII)V", (void *) android_glFramebufferRenderbufferOES__IIII }, +{"glFramebufferTexture2DOES", "(IIIII)V", (void *) android_glFramebufferTexture2DOES__IIIII }, +{"glGenerateMipmapOES", "(I)V", (void *) android_glGenerateMipmapOES__I }, +{"glGenFramebuffersOES", "(I[II)V", (void *) android_glGenFramebuffersOES__I_3II }, +{"glGenFramebuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenFramebuffersOES__ILjava_nio_IntBuffer_2 }, +{"glGenRenderbuffersOES", "(I[II)V", (void *) android_glGenRenderbuffersOES__I_3II }, +{"glGenRenderbuffersOES", "(ILjava/nio/IntBuffer;)V", (void *) android_glGenRenderbuffersOES__ILjava_nio_IntBuffer_2 }, +{"glGetFramebufferAttachmentParameterivOES", "(III[II)V", (void *) android_glGetFramebufferAttachmentParameterivOES__III_3II }, +{"glGetFramebufferAttachmentParameterivOES", "(IIILjava/nio/IntBuffer;)V", (void *) android_glGetFramebufferAttachmentParameterivOES__IIILjava_nio_IntBuffer_2 }, +{"glGetRenderbufferParameterivOES", "(II[II)V", (void *) android_glGetRenderbufferParameterivOES__II_3II }, +{"glGetRenderbufferParameterivOES", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetRenderbufferParameterivOES__IILjava_nio_IntBuffer_2 }, +{"glGetTexGenfv", "(II[FI)V", (void *) android_glGetTexGenfv__II_3FI }, +{"glGetTexGenfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glGetTexGenfv__IILjava_nio_FloatBuffer_2 }, +{"glGetTexGeniv", "(II[II)V", (void *) android_glGetTexGeniv__II_3II }, +{"glGetTexGeniv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGeniv__IILjava_nio_IntBuffer_2 }, +{"glGetTexGenxv", "(II[II)V", (void *) android_glGetTexGenxv__II_3II }, +{"glGetTexGenxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glGetTexGenxv__IILjava_nio_IntBuffer_2 }, +{"glIsFramebufferOES", "(I)Z", (void *) android_glIsFramebufferOES__I }, +{"glIsRenderbufferOES", "(I)Z", (void *) android_glIsRenderbufferOES__I }, +{"glRenderbufferStorageOES", "(IIII)V", (void *) android_glRenderbufferStorageOES__IIII }, +{"glTexGenf", "(IIF)V", (void *) android_glTexGenf__IIF }, +{"glTexGenfv", "(II[FI)V", (void *) android_glTexGenfv__II_3FI }, +{"glTexGenfv", "(IILjava/nio/FloatBuffer;)V", (void *) android_glTexGenfv__IILjava_nio_FloatBuffer_2 }, +{"glTexGeni", "(III)V", (void *) android_glTexGeni__III }, +{"glTexGeniv", "(II[II)V", (void *) android_glTexGeniv__II_3II }, +{"glTexGeniv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGeniv__IILjava_nio_IntBuffer_2 }, +{"glTexGenx", "(III)V", (void *) android_glTexGenx__III }, +{"glTexGenxv", "(II[II)V", (void *) android_glTexGenxv__II_3II }, +{"glTexGenxv", "(IILjava/nio/IntBuffer;)V", (void *) android_glTexGenxv__IILjava_nio_IntBuffer_2 }, +}; + +int register_com_google_android_gles_jni_GLImpl(JNIEnv *_env) +{ + int err; + err = android::AndroidRuntime::registerNativeMethods(_env, classPathName, methods, NELEM(methods)); + return err; +} diff --git a/core/jni/server/Android.mk b/core/jni/server/Android.mk new file mode 100644 index 0000000..d108330 --- /dev/null +++ b/core/jni/server/Android.mk @@ -0,0 +1,37 @@ +LOCAL_PATH:= $(call my-dir) +include $(CLEAR_VARS) + +LOCAL_SRC_FILES:= \ + com_android_server_AlarmManagerService.cpp \ + com_android_server_BatteryService.cpp \ + com_android_server_HardwareService.cpp \ + com_android_server_KeyInputQueue.cpp \ + com_android_server_SensorService.cpp \ + com_android_server_SystemServer.cpp \ + onload.cpp + +LOCAL_C_INCLUDES += \ + $(JNI_H_INCLUDE) + +LOCAL_SHARED_LIBRARIES := \ + libcutils \ + libhardware \ + libnativehelper \ + libsystem_server \ + libutils \ + libui + +ifeq ($(TARGET_OS),linux) +ifeq ($(TARGET_ARCH),x86) +LOCAL_LDLIBS += -lpthread -ldl -lrt +endif +endif + +ifeq ($(WITH_MALLOC_LEAK_CHECK),true) + LOCAL_CFLAGS += -DMALLOC_LEAK_CHECK +endif + +LOCAL_MODULE:= libandroid_servers + +include $(BUILD_SHARED_LIBRARY) + diff --git a/core/jni/server/com_android_server_AlarmManagerService.cpp b/core/jni/server/com_android_server_AlarmManagerService.cpp new file mode 100644 index 0000000..a81a0ff --- /dev/null +++ b/core/jni/server/com_android_server_AlarmManagerService.cpp @@ -0,0 +1,120 @@ +/* //device/libs/android_runtime/android_server_AlarmManagerService.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "AlarmManagerService" + +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <fcntl.h> +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <arpa/inet.h> +#include <netinet/in.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> + +#if HAVE_ANDROID_OS +#include <linux/ioctl.h> +#include <linux/android_alarm.h> +#endif + +#define ONE_NANOSECOND 1000000000LL +#define NANOSECONDS_TO_SECONDS(x) (x / ONE_NANOSECOND) +#define SECONDS_TO_NANOSECONDS(x) (x * ONE_NANOSECOND) + +namespace android { + +static jint android_server_AlarmManagerService_init(JNIEnv* env, jobject obj) +{ +#if HAVE_ANDROID_OS + return open("/dev/alarm", O_RDWR); +#else + return -1; +#endif +} + +static void android_server_AlarmManagerService_close(JNIEnv* env, jobject obj, jint fd) +{ +#if HAVE_ANDROID_OS + close(fd); +#endif +} + +static void android_server_AlarmManagerService_set(JNIEnv* env, jobject obj, jint fd, jint type, jlong nanoseconds) +{ +#if HAVE_ANDROID_OS + struct timespec ts; + ts.tv_sec = NANOSECONDS_TO_SECONDS(nanoseconds); + ts.tv_nsec = nanoseconds - SECONDS_TO_NANOSECONDS(ts.tv_sec); + + int result = ioctl(fd, ANDROID_ALARM_SET(type), &ts); + if (result < 0) + { + LOGE("Unable to set alarm to %lld: %s\n", nanoseconds, strerror(errno)); + } +#endif +} + +static jint android_server_AlarmManagerService_waitForAlarm(JNIEnv* env, jobject obj, jint fd) +{ +#if HAVE_ANDROID_OS + int result = 0; + + do + { + result = ioctl(fd, ANDROID_ALARM_WAIT); + } while (result < 0 && errno == EINTR); + + if (result < 0) + { + LOGE("Unable to wait on alarm: %s\n", strerror(errno)); + return 0; + } + + return result; +#endif +} + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + {"init", "()I", (void*)android_server_AlarmManagerService_init}, + {"close", "(I)V", (void*)android_server_AlarmManagerService_close}, + {"set", "(IIJ)V", (void*)android_server_AlarmManagerService_set}, + {"waitForAlarm", "(I)I", (void*)android_server_AlarmManagerService_waitForAlarm}, +}; + +int register_android_server_AlarmManagerService(JNIEnv* env) +{ + jclass clazz = env->FindClass("com/android/server/AlarmManagerService"); + + if (clazz == NULL) + { + LOGE("Can't find com/android/server/AlarmManagerService"); + return -1; + } + + return jniRegisterNativeMethods(env, "com/android/server/AlarmManagerService", + sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/server/com_android_server_BatteryService.cpp b/core/jni/server/com_android_server_BatteryService.cpp new file mode 100644 index 0000000..6636a97 --- /dev/null +++ b/core/jni/server/com_android_server_BatteryService.cpp @@ -0,0 +1,274 @@ +/* + * 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. + */ + +#define LOG_TAG "BatteryService" + +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +#include <fcntl.h> +#include <stdio.h> +#include <string.h> +#include <sys/types.h> +#include <sys/socket.h> +#include <arpa/inet.h> +#include <netinet/in.h> +#include <stdlib.h> +#include <errno.h> +#include <unistd.h> + +#if HAVE_ANDROID_OS +#include <linux/ioctl.h> +#endif + +namespace android { + +#define AC_ONLINE_PATH "/sys/class/power_supply/ac/online" +#define USB_ONLINE_PATH "/sys/class/power_supply/usb/online" +#define BATTERY_STATUS_PATH "/sys/class/power_supply/battery/status" +#define BATTERY_HEALTH_PATH "/sys/class/power_supply/battery/health" +#define BATTERY_PRESENT_PATH "/sys/class/power_supply/battery/present" +#define BATTERY_CAPACITY_PATH "/sys/class/power_supply/battery/capacity" +#define BATTERY_VOLTAGE_PATH "/sys/class/power_supply/battery/batt_vol" +#define BATTERY_TEMPERATURE_PATH "/sys/class/power_supply/battery/batt_temp" +#define BATTERY_TECHNOLOGY_PATH "/sys/class/power_supply/battery/technology" + +struct FieldIds { + // members + jfieldID mAcOnline; + jfieldID mUsbOnline; + jfieldID mBatteryStatus; + jfieldID mBatteryHealth; + jfieldID mBatteryPresent; + jfieldID mBatteryLevel; + jfieldID mBatteryVoltage; + jfieldID mBatteryTemperature; + jfieldID mBatteryTechnology; +}; +static FieldIds gFieldIds; + +struct BatteryManagerConstants { + jint statusUnknown; + jint statusCharging; + jint statusDischarging; + jint statusNotCharging; + jint statusFull; + jint healthUnknown; + jint healthGood; + jint healthOverheat; + jint healthDead; + jint healthOverVoltage; + jint healthUnspecifiedFailure; +}; +static BatteryManagerConstants gConstants; + +static jint getBatteryStatus(const char* status) +{ + switch (status[0]) { + case 'C': return gConstants.statusCharging; // Charging + case 'D': return gConstants.statusDischarging; // Discharging + case 'F': return gConstants.statusFull; // Not charging + case 'N': return gConstants.statusNotCharging; // Full + case 'U': return gConstants.statusUnknown; // Unknown + + default: { + LOGW("Unknown battery status '%s'", status); + return gConstants.statusUnknown; + } + } +} + +static jint getBatteryHealth(const char* status) +{ + switch (status[0]) { + case 'D': return gConstants.healthDead; // Dead + case 'G': return gConstants.healthGood; // Good + case 'O': { + if (strcmp(status, "Overheat") == 0) { + return gConstants.healthOverheat; + } else if (strcmp(status, "Over voltage") == 0) { + return gConstants.healthOverVoltage; + } + LOGW("Unknown battery health[1] '%s'", status); + return gConstants.healthUnknown; + } + + case 'U': { + if (strcmp(status, "Unspecified failure") == 0) { + return gConstants.healthUnspecifiedFailure; + } else if (strcmp(status, "Unknown") == 0) { + return gConstants.healthUnknown; + } + // fall through + } + + default: { + LOGW("Unknown battery health[2] '%s'", status); + return gConstants.healthUnknown; + } + } +} + +static int readFromFile(const char* path, char* buf, size_t size) +{ + int fd = open(path, O_RDONLY, 0); + if (fd == -1) { + LOGE("Could not open '%s'", path); + return -1; + } + + size_t count = read(fd, buf, size); + if (count > 0) { + count = (count < size) ? count : size - 1; + while (count > 0 && buf[count-1] == '\n') count--; + buf[count] = '\0'; + } else { + buf[0] = '\0'; + } + + close(fd); + return count; +} + +static void setBooleanField(JNIEnv* env, jobject obj, const char* path, jfieldID fieldID) +{ + const int SIZE = 16; + char buf[SIZE]; + + jboolean value = false; + if (readFromFile(path, buf, SIZE) > 0) { + if (buf[0] == '1') { + value = true; + } + } + env->SetBooleanField(obj, fieldID, value); +} + +static void setIntField(JNIEnv* env, jobject obj, const char* path, jfieldID fieldID) +{ + const int SIZE = 128; + char buf[SIZE]; + + jint value = 0; + if (readFromFile(path, buf, SIZE) > 0) { + value = atoi(buf); + } + env->SetIntField(obj, fieldID, value); +} + +static void android_server_BatteryService_update(JNIEnv* env, jobject obj) +{ + setBooleanField(env, obj, AC_ONLINE_PATH, gFieldIds.mAcOnline); + setBooleanField(env, obj, USB_ONLINE_PATH, gFieldIds.mUsbOnline); + setBooleanField(env, obj, BATTERY_PRESENT_PATH, gFieldIds.mBatteryPresent); + + setIntField(env, obj, BATTERY_CAPACITY_PATH, gFieldIds.mBatteryLevel); + setIntField(env, obj, BATTERY_VOLTAGE_PATH, gFieldIds.mBatteryVoltage); + setIntField(env, obj, BATTERY_TEMPERATURE_PATH, gFieldIds.mBatteryTemperature); + + const int SIZE = 128; + char buf[SIZE]; + + if (readFromFile(BATTERY_STATUS_PATH, buf, SIZE) > 0) + env->SetIntField(obj, gFieldIds.mBatteryStatus, getBatteryStatus(buf)); + + if (readFromFile(BATTERY_HEALTH_PATH, buf, SIZE) > 0) + env->SetIntField(obj, gFieldIds.mBatteryHealth, getBatteryHealth(buf)); + + if (readFromFile(BATTERY_TECHNOLOGY_PATH, buf, SIZE) > 0) + env->SetObjectField(obj, gFieldIds.mBatteryTechnology, env->NewStringUTF(buf)); +} + +static JNINativeMethod sMethods[] = { + /* name, signature, funcPtr */ + {"native_update", "()V", (void*)android_server_BatteryService_update}, +}; + +int register_android_server_BatteryService(JNIEnv* env) +{ + jclass clazz = env->FindClass("com/android/server/BatteryService"); + + if (clazz == NULL) { + LOGE("Can't find com/android/server/BatteryService"); + return -1; + } + + gFieldIds.mAcOnline = env->GetFieldID(clazz, "mAcOnline", "Z"); + gFieldIds.mUsbOnline = env->GetFieldID(clazz, "mUsbOnline", "Z"); + gFieldIds.mBatteryStatus = env->GetFieldID(clazz, "mBatteryStatus", "I"); + gFieldIds.mBatteryHealth = env->GetFieldID(clazz, "mBatteryHealth", "I"); + gFieldIds.mBatteryPresent = env->GetFieldID(clazz, "mBatteryPresent", "Z"); + gFieldIds.mBatteryLevel = env->GetFieldID(clazz, "mBatteryLevel", "I"); + gFieldIds.mBatteryTechnology = env->GetFieldID(clazz, "mBatteryTechnology", "Ljava/lang/String;"); + gFieldIds.mBatteryVoltage = env->GetFieldID(clazz, "mBatteryVoltage", "I"); + gFieldIds.mBatteryTemperature = env->GetFieldID(clazz, "mBatteryTemperature", "I"); + + LOG_FATAL_IF(gFieldIds.mAcOnline == NULL, "Unable to find BatteryService.AC_ONLINE_PATH"); + LOG_FATAL_IF(gFieldIds.mUsbOnline == NULL, "Unable to find BatteryService.USB_ONLINE_PATH"); + LOG_FATAL_IF(gFieldIds.mBatteryStatus == NULL, "Unable to find BatteryService.BATTERY_STATUS_PATH"); + LOG_FATAL_IF(gFieldIds.mBatteryHealth == NULL, "Unable to find BatteryService.BATTERY_HEALTH_PATH"); + LOG_FATAL_IF(gFieldIds.mBatteryPresent == NULL, "Unable to find BatteryService.BATTERY_PRESENT_PATH"); + LOG_FATAL_IF(gFieldIds.mBatteryLevel == NULL, "Unable to find BatteryService.BATTERY_CAPACITY_PATH"); + LOG_FATAL_IF(gFieldIds.mBatteryVoltage == NULL, "Unable to find BatteryService.BATTERY_VOLTAGE_PATH"); + LOG_FATAL_IF(gFieldIds.mBatteryTemperature == NULL, "Unable to find BatteryService.BATTERY_TEMPERATURE_PATH"); + LOG_FATAL_IF(gFieldIds.mBatteryTechnology == NULL, "Unable to find BatteryService.BATTERY_TECHNOLOGY_PATH"); + + clazz = env->FindClass("android/os/BatteryManager"); + + if (clazz == NULL) { + LOGE("Can't find android/os/BatteryManager"); + return -1; + } + + gConstants.statusUnknown = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_STATUS_UNKNOWN", "I")); + + gConstants.statusCharging = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_STATUS_CHARGING", "I")); + + gConstants.statusDischarging = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_STATUS_DISCHARGING", "I")); + + gConstants.statusNotCharging = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_STATUS_NOT_CHARGING", "I")); + + gConstants.statusFull = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_STATUS_FULL", "I")); + + gConstants.healthUnknown = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_HEALTH_UNKNOWN", "I")); + + gConstants.healthGood = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_HEALTH_GOOD", "I")); + + gConstants.healthOverheat = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_HEALTH_OVERHEAT", "I")); + + gConstants.healthDead = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_HEALTH_DEAD", "I")); + + gConstants.healthOverVoltage = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_HEALTH_OVER_VOLTAGE", "I")); + + gConstants.healthUnspecifiedFailure = env->GetStaticIntField(clazz, + env->GetStaticFieldID(clazz, "BATTERY_HEALTH_UNSPECIFIED_FAILURE", "I")); + + return jniRegisterNativeMethods(env, "com/android/server/BatteryService", sMethods, NELEM(sMethods)); +} + +} /* namespace android */ diff --git a/core/jni/server/com_android_server_HardwareService.cpp b/core/jni/server/com_android_server_HardwareService.cpp new file mode 100644 index 0000000..479e57d --- /dev/null +++ b/core/jni/server/com_android_server_HardwareService.cpp @@ -0,0 +1,54 @@ +/* //device/libs/android_runtime/android_os_Vibrator.cpp +** +** Copyright 2006, 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. +*/ + +#define LOG_TAG "Vibrator" + +#include "jni.h" +#include "JNIHelp.h" +#include <stdio.h> +#include "android_runtime/AndroidRuntime.h" +#include <utils/misc.h> +#include <utils/Log.h> +#include <hardware/vibrator.h> + +namespace android +{ + +static void on(JNIEnv *env, jobject clazz) +{ + // LOGI("on\n"); + vibrator_on(); +} + +static void off(JNIEnv *env, jobject clazz) +{ + // LOGI("off\n"); + vibrator_off(); +} + +static JNINativeMethod method_table[] = { + { "on", "()V", (void*)on }, + { "off", "()V", (void*)off } +}; + +int register_android_os_Vibrator(JNIEnv *env) +{ + return jniRegisterNativeMethods(env, "com/android/server/HardwareService", + method_table, NELEM(method_table)); +} + +}; diff --git a/core/jni/server/com_android_server_KeyInputQueue.cpp b/core/jni/server/com_android_server_KeyInputQueue.cpp new file mode 100644 index 0000000..4e9ffb1 --- /dev/null +++ b/core/jni/server/com_android_server_KeyInputQueue.cpp @@ -0,0 +1,299 @@ +/* + * Copyright (C) 2007 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. + */ + +#define LOG_TAG "Input" + +#include "jni.h" +#include "JNIHelp.h" +#include <utils/misc.h> +#include <utils/Log.h> + +#include <ui/EventHub.h> +#include <utils/threads.h> + +#include <stdio.h> + +namespace android { + +// ---------------------------------------------------------------------------- + +static struct input_offsets_t +{ + jfieldID mMinValue; + jfieldID mMaxValue; + jfieldID mFlat; + jfieldID mFuzz; + + jfieldID mDeviceId; + jfieldID mType; + jfieldID mScancode; + jfieldID mKeycode; + jfieldID mFlags; + jfieldID mValue; + jfieldID mWhen; +} gInputOffsets; + +// ---------------------------------------------------------------------------- + +static Mutex gLock; +static sp<EventHub> gHub; + +static jboolean +android_server_KeyInputQueue_readEvent(JNIEnv* env, jobject clazz, + jobject event) +{ + gLock.lock(); + sp<EventHub> hub = gHub; + if (hub == NULL) { + hub = new EventHub; + gHub = hub; + } + gLock.unlock(); + + int32_t deviceId; + int32_t type; + int32_t scancode, keycode; + uint32_t flags; + int32_t value; + nsecs_t when; + bool res = hub->getEvent(&deviceId, &type, &scancode, &keycode, + &flags, &value, &when); + + env->SetIntField(event, gInputOffsets.mDeviceId, (jint)deviceId); + env->SetIntField(event, gInputOffsets.mType, (jint)type); + env->SetIntField(event, gInputOffsets.mScancode, (jint)scancode); + env->SetIntField(event, gInputOffsets.mKeycode, (jint)keycode); + env->SetIntField(event, gInputOffsets.mFlags, (jint)flags); + env->SetIntField(event, gInputOffsets.mValue, value); + env->SetLongField(event, gInputOffsets.mWhen, + (jlong)(nanoseconds_to_milliseconds(when))); + + return res; +} + +static jint +android_server_KeyInputQueue_getDeviceClasses(JNIEnv* env, jobject clazz, + jint deviceId) +{ + jint classes = 0; + gLock.lock(); + if (gHub != NULL) classes = gHub->getDeviceClasses(deviceId); + gLock.unlock(); + return classes; +} + +static jstring +android_server_KeyInputQueue_getDeviceName(JNIEnv* env, jobject clazz, + jint deviceId) +{ + String8 name; + gLock.lock(); + if (gHub != NULL) name = gHub->getDeviceName(deviceId); + gLock.unlock(); + + if (name.size() > 0) { + return env->NewStringUTF(name.string()); + } + return NULL; +} + +static jboolean +android_server_KeyInputQueue_getAbsoluteInfo(JNIEnv* env, jobject clazz, + jint deviceId, jint axis, + jobject info) +{ + int32_t minValue, maxValue, flat, fuzz; + int res = -1; + gLock.lock(); + if (gHub != NULL) { + res = gHub->getAbsoluteInfo(deviceId, axis, + &minValue, &maxValue, &flat, &fuzz); + } + gLock.unlock(); + + if (res < 0) return JNI_FALSE; + + env->SetIntField(info, gInputOffsets.mMinValue, (jint)minValue); + env->SetIntField(info, gInputOffsets.mMaxValue, (jint)maxValue); + env->SetIntField(info, gInputOffsets.mFlat, (jint)flat); + env->SetIntField(info, gInputOffsets.mFuzz, (jint)fuzz); + return JNI_TRUE; +} + +static jint +android_server_KeyInputQueue_getSwitchState(JNIEnv* env, jobject clazz, + jint sw) +{ + jint st = -1; + gLock.lock(); + if (gHub != NULL) st = gHub->getSwitchState(sw); + gLock.unlock(); + + return st; +} + +static jint +android_server_KeyInputQueue_getSwitchStateDevice(JNIEnv* env, jobject clazz, + jint deviceId, jint sw) +{ + jint st = -1; + gLock.lock(); + if (gHub != NULL) st = gHub->getSwitchState(deviceId, sw); + gLock.unlock(); + + return st; +} + +static jint +android_server_KeyInputQueue_getScancodeState(JNIEnv* env, jobject clazz, + jint sw) +{ + jint st = -1; + gLock.lock(); + if (gHub != NULL) st = gHub->getScancodeState(sw); + gLock.unlock(); + + return st; +} + +static jint +android_server_KeyInputQueue_getScancodeStateDevice(JNIEnv* env, jobject clazz, + jint deviceId, jint sw) +{ + jint st = -1; + gLock.lock(); + if (gHub != NULL) st = gHub->getScancodeState(deviceId, sw); + gLock.unlock(); + + return st; +} + +static jint +android_server_KeyInputQueue_getKeycodeState(JNIEnv* env, jobject clazz, + jint sw) +{ + jint st = -1; + gLock.lock(); + if (gHub != NULL) st = gHub->getKeycodeState(sw); + gLock.unlock(); + + return st; +} + +static jint +android_server_KeyInputQueue_getKeycodeStateDevice(JNIEnv* env, jobject clazz, + jint deviceId, jint sw) +{ + jint st = -1; + gLock.lock(); + if (gHub != NULL) st = gHub->getKeycodeState(deviceId, sw); + gLock.unlock(); + + return st; +} + + +// ---------------------------------------------------------------------------- + +/* + * JNI registration. + */ +static JNINativeMethod gInputMethods[] = { + /* name, signature, funcPtr */ + { "readEvent", "(Landroid/view/RawInputEvent;)Z", + (void*) android_server_KeyInputQueue_readEvent }, + { "getDeviceClasses", "(I)I", + (void*) android_server_KeyInputQueue_getDeviceClasses }, + { "getDeviceName", "(I)Ljava/lang/String;", + (void*) android_server_KeyInputQueue_getDeviceName }, + { "getAbsoluteInfo", "(IILcom/android/server/InputDevice$AbsoluteInfo;)Z", + (void*) android_server_KeyInputQueue_getAbsoluteInfo }, + { "getSwitchState", "(I)I", + (void*) android_server_KeyInputQueue_getSwitchState }, + { "getSwitchState", "(II)I", + (void*) android_server_KeyInputQueue_getSwitchStateDevice }, + { "getScancodeState", "(I)I", + (void*) android_server_KeyInputQueue_getScancodeState }, + { "getScancodeState", "(II)I", + (void*) android_server_KeyInputQueue_getScancodeStateDevice }, + { "getKeycodeState", "(I)I", + (void*) android_server_KeyInputQueue_getKeycodeState }, + { "getKeycodeState", "(II)I", + (void*) android_server_KeyInputQueue_getKeycodeStateDevice }, +}; + +int register_android_server_KeyInputQueue(JNIEnv* env) +{ + jclass input = env->FindClass("com/android/server/KeyInputQueue"); + LOG_FATAL_IF(input == NULL, "Unable to find class com/android/server/KeyInputQueue"); + int res = jniRegisterNativeMethods(env, "com/android/server/KeyInputQueue", + gInputMethods, NELEM(gInputMethods)); + + jclass absoluteInfo = env->FindClass("com/android/server/InputDevice$AbsoluteInfo"); + LOG_FATAL_IF(absoluteInfo == NULL, "Unable to find class com/android/server/InputDevice$AbsoluteInfo"); + + gInputOffsets.mMinValue + = env->GetFieldID(absoluteInfo, "minValue", "I"); + LOG_FATAL_IF(gInputOffsets.mMinValue == NULL, "Unable to find InputDevice.AbsoluteInfo.minValue"); + + gInputOffsets.mMaxValue + = env->GetFieldID(absoluteInfo, "maxValue", "I"); + LOG_FATAL_IF(gInputOffsets.mMaxValue == NULL, "Unable to find InputDevice.AbsoluteInfo.maxValue"); + + gInputOffsets.mFlat + = env->GetFieldID(absoluteInfo, "flat", "I"); + LOG_FATAL_IF(gInputOffsets.mFlat == NULL, "Unable to find InputDevice.AbsoluteInfo.flat"); + + gInputOffsets.mFuzz + = env->GetFieldID(absoluteInfo, "fuzz", "I"); + LOG_FATAL_IF(gInputOffsets.mFuzz == NULL, "Unable to find InputDevice.AbsoluteInfo.fuzz"); + + jclass inputEvent = env->FindClass("android/view/RawInputEvent"); + LOG_FATAL_IF(inputEvent == NULL, "Unable to find class android/view/RawInputEvent"); + + gInputOffsets.mDeviceId + = env->GetFieldID(inputEvent, "deviceId", "I"); + LOG_FATAL_IF(gInputOffsets.mDeviceId == NULL, "Unable to find RawInputEvent.deviceId"); + + gInputOffsets.mType + = env->GetFieldID(inputEvent, "type", "I"); + LOG_FATAL_IF(gInputOffsets.mType == NULL, "Unable to find RawInputEvent.type"); + + gInputOffsets.mScancode + = env->GetFieldID(inputEvent, "scancode", "I"); + LOG_FATAL_IF(gInputOffsets.mScancode == NULL, "Unable to find RawInputEvent.scancode"); + + gInputOffsets.mKeycode + = env->GetFieldID(inputEvent, "keycode", "I"); + LOG_FATAL_IF(gInputOffsets.mKeycode == NULL, "Unable to find RawInputEvent.keycode"); + + gInputOffsets.mFlags + = env->GetFieldID(inputEvent, "flags", "I"); + LOG_FATAL_IF(gInputOffsets.mFlags == NULL, "Unable to find RawInputEvent.flags"); + + gInputOffsets.mValue + = env->GetFieldID(inputEvent, "value", "I"); + LOG_FATAL_IF(gInputOffsets.mValue == NULL, "Unable to find RawInputEvent.value"); + + gInputOffsets.mWhen + = env->GetFieldID(inputEvent, "when", "J"); + LOG_FATAL_IF(gInputOffsets.mWhen == NULL, "Unable to find RawInputEvent.when"); + + return res; +} + +}; // namespace android + diff --git a/core/jni/server/com_android_server_SensorService.cpp b/core/jni/server/com_android_server_SensorService.cpp new file mode 100644 index 0000000..37f6231 --- /dev/null +++ b/core/jni/server/com_android_server_SensorService.cpp @@ -0,0 +1,107 @@ +/* + * Copyright 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. + */ + +#define LOG_TAG "Sensors" + +#include <hardware/sensors.h> + +#include "jni.h" +#include "JNIHelp.h" + +namespace android { + + +static struct file_descriptor_offsets_t +{ + jclass mClass; + jmethodID mConstructor; + jfieldID mDescriptor; +} gFileDescriptorOffsets; + +static struct parcel_file_descriptor_offsets_t +{ + jclass mClass; + jmethodID mConstructor; +} gParcelFileDescriptorOffsets; + +/* + * The method below are not thread-safe and not intended to be + */ + +static jint +android_init(JNIEnv *env, jclass clazz) +{ + return sensors_control_init(); +} + +static jobject +android_open(JNIEnv *env, jclass clazz) +{ + int fd = sensors_control_open(); + // new FileDescriptor() + jobject filedescriptor = env->NewObject( + gFileDescriptorOffsets.mClass, + gFileDescriptorOffsets.mConstructor); + + if (filedescriptor != NULL) { + env->SetIntField(filedescriptor, gFileDescriptorOffsets.mDescriptor, fd); + // new ParcelFileDescriptor() + return env->NewObject(gParcelFileDescriptorOffsets.mClass, + gParcelFileDescriptorOffsets.mConstructor, + filedescriptor); + } + close(fd); + return NULL; +} + +static jboolean +android_activate(JNIEnv *env, jclass clazz, jint sensor, jboolean activate) +{ + uint32_t active = sensors_control_activate(activate ? sensor : 0, sensor); + return (activate && !active) ? false : true; +} + +static jint +android_set_delay(JNIEnv *env, jclass clazz, jint ms) +{ + return sensors_control_delay(ms); +} + +static JNINativeMethod gMethods[] = { + {"_sensors_control_init", "()I", (void*) android_init }, + {"_sensors_control_open", "()Landroid/os/ParcelFileDescriptor;", (void*) android_open }, + {"_sensors_control_activate", "(IZ)Z", (void*) android_activate }, + {"_sensors_control_set_delay","(I)I", (void*) android_set_delay }, +}; + +int register_android_server_SensorService(JNIEnv *env) +{ + jclass clazz; + + clazz = env->FindClass("java/io/FileDescriptor"); + gFileDescriptorOffsets.mClass = (jclass)env->NewGlobalRef(clazz); + gFileDescriptorOffsets.mConstructor = env->GetMethodID(clazz, "<init>", "()V"); + gFileDescriptorOffsets.mDescriptor = env->GetFieldID(clazz, "descriptor", "I"); + + clazz = env->FindClass("android/os/ParcelFileDescriptor"); + gParcelFileDescriptorOffsets.mClass = (jclass) env->NewGlobalRef(clazz); + gParcelFileDescriptorOffsets.mConstructor = env->GetMethodID(clazz, "<init>", "(Ljava/io/FileDescriptor;)V"); + + return jniRegisterNativeMethods(env, "com/android/server/SensorService", + gMethods, NELEM(gMethods)); +} + +}; // namespace android diff --git a/core/jni/server/com_android_server_SystemServer.cpp b/core/jni/server/com_android_server_SystemServer.cpp new file mode 100644 index 0000000..ae29405 --- /dev/null +++ b/core/jni/server/com_android_server_SystemServer.cpp @@ -0,0 +1,47 @@ +/* + * Copyright (C) 2007 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. + */ +#include <utils/Log.h> +#include <utils/misc.h> + +#include "jni.h" +#include "JNIHelp.h" + +namespace android { + +extern "C" int system_init(); + +static void android_server_SystemServer_init1(JNIEnv* env, jobject clazz) +{ + system_init(); +} + +/* + * JNI registration. + */ +static JNINativeMethod gMethods[] = { + /* name, signature, funcPtr */ + { "init1", "([Ljava/lang/String;)V", (void*) android_server_SystemServer_init1 }, +}; + +int register_android_server_SystemServer(JNIEnv* env) +{ + return jniRegisterNativeMethods(env, "com/android/server/SystemServer", + gMethods, NELEM(gMethods)); +} + +}; // namespace android + + diff --git a/core/jni/server/onload.cpp b/core/jni/server/onload.cpp new file mode 100644 index 0000000..3d68cfb --- /dev/null +++ b/core/jni/server/onload.cpp @@ -0,0 +1,36 @@ +#include "JNIHelp.h" +#include "jni.h" +#include "utils/Log.h" +#include "utils/misc.h" + +namespace android { +int register_android_server_AlarmManagerService(JNIEnv* env); +int register_android_server_BatteryService(JNIEnv* env); +int register_android_server_KeyInputQueue(JNIEnv* env); +int register_android_os_Vibrator(JNIEnv* env); +int register_android_server_SensorService(JNIEnv* env); +int register_android_server_SystemServer(JNIEnv* env); +}; + +using namespace android; + +extern "C" jint JNI_OnLoad(JavaVM* vm, void* reserved) +{ + JNIEnv* env = NULL; + jint result = -1; + + if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) { + LOGE("GetEnv failed!"); + return result; + } + LOG_ASSERT(env, "Could not retrieve the env!"); + + register_android_server_KeyInputQueue(env); + register_android_os_Vibrator(env); + register_android_server_AlarmManagerService(env); + register_android_server_BatteryService(env); + register_android_server_SensorService(env); + register_android_server_SystemServer(env); + + return JNI_VERSION_1_4; +} diff --git a/core/jni/sqlite3_exception.h b/core/jni/sqlite3_exception.h new file mode 100644 index 0000000..13735a1 --- /dev/null +++ b/core/jni/sqlite3_exception.h @@ -0,0 +1,47 @@ +/* //device/libs/include/android_runtime/sqlite3_exception.h +** +** Copyright 2007, 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 _SQLITE3_EXCEPTION_H +#define _SQLITE3_EXCEPTION_H 1 + +#include <jni.h> +#include <JNIHelp.h> +//#include <android_runtime/AndroidRuntime.h> + +#include <sqlite3.h> + +namespace android { + +/* throw a SQLiteException with a message appropriate for the error in handle */ +void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle); + +/* throw a SQLiteException with the given message */ +void throw_sqlite3_exception(JNIEnv* env, const char* message); + +/* throw a SQLiteException with a message appropriate for the error in handle + concatenated with the given message + */ +void throw_sqlite3_exception(JNIEnv* env, sqlite3* handle, const char* message); + +/* throw a SQLiteException for a given error code */ +void throw_sqlite3_exception_errcode(JNIEnv* env, int errcode, const char* message); + +void throw_sqlite3_exception(JNIEnv* env, int errcode, + const char* sqlite3Message, const char* message); +} + +#endif // _SQLITE3_EXCEPTION_H |