diff options
Diffstat (limited to 'core/jni')
| -rw-r--r-- | core/jni/Android.mk | 3 | ||||
| -rw-r--r-- | core/jni/AndroidRuntime.cpp | 2 | ||||
| -rw-r--r-- | core/jni/android/graphics/NinePatchImpl.cpp | 8 | ||||
| -rw-r--r-- | core/jni/android_bluetooth_BluetoothSocket.cpp | 24 | ||||
| -rw-r--r-- | core/jni/android_hardware_Camera.cpp | 49 | ||||
| -rw-r--r-- | core/jni/android_view_Display.cpp | 51 | ||||
| -rw-r--r-- | core/jni/android_view_GLES20Canvas.cpp | 9 | ||||
| -rw-r--r-- | core/jni/com_android_internal_content_NativeLibraryHelper.cpp | 375 |
8 files changed, 467 insertions, 54 deletions
diff --git a/core/jni/Android.mk b/core/jni/Android.mk index 514e59d..6e73889 100644 --- a/core/jni/Android.mk +++ b/core/jni/Android.mk @@ -29,6 +29,7 @@ LOCAL_SRC_FILES:= \ ActivityManager.cpp \ AndroidRuntime.cpp \ Time.cpp \ + com_android_internal_content_NativeLibraryHelper.cpp \ com_google_android_gles_jni_EGLImpl.cpp \ com_google_android_gles_jni_GLImpl.cpp.arm \ android_app_NativeActivity.cpp \ @@ -178,6 +179,7 @@ LOCAL_C_INCLUDES += \ external/icu4c/common \ external/jpeg \ external/harfbuzz/src \ + external/zlib \ frameworks/opt/emoji \ libcore/include @@ -211,6 +213,7 @@ LOCAL_SHARED_LIBRARIES := \ libnfc_ndef \ libusbhost \ libharfbuzz \ + libz \ ifeq ($(USE_OPENGL_RENDERER),true) LOCAL_SHARED_LIBRARIES += libhwui diff --git a/core/jni/AndroidRuntime.cpp b/core/jni/AndroidRuntime.cpp index 6ab8fe3..9e46d80 100644 --- a/core/jni/AndroidRuntime.cpp +++ b/core/jni/AndroidRuntime.cpp @@ -175,6 +175,7 @@ extern int register_android_view_VelocityTracker(JNIEnv* env); extern int register_android_content_res_ObbScanner(JNIEnv* env); extern int register_android_content_res_Configuration(JNIEnv* env); extern int register_android_animation_PropertyValuesHolder(JNIEnv *env); +extern int register_com_android_internal_content_NativeLibraryHelper(JNIEnv *env); static AndroidRuntime* gCurRuntime = NULL; @@ -1199,6 +1200,7 @@ static const RegJNIRec gRegJNI[] = { REG_JNI(register_android_content_res_Configuration), REG_JNI(register_android_animation_PropertyValuesHolder), + REG_JNI(register_com_android_internal_content_NativeLibraryHelper), }; /* diff --git a/core/jni/android/graphics/NinePatchImpl.cpp b/core/jni/android/graphics/NinePatchImpl.cpp index a3e36ee..579749a 100644 --- a/core/jni/android/graphics/NinePatchImpl.cpp +++ b/core/jni/android/graphics/NinePatchImpl.cpp @@ -160,6 +160,14 @@ void NinePatch_Draw(SkCanvas* canvas, const SkRect& bounds, return; } + // if the nine patch is bigger than the dst on a given axis we cannot + // stretch properly so just draw the bitmap as best as possible and return + if (bitmap.width() >= bounds.width() || bitmap.height() >= bounds.height()) + { + canvas->drawBitmapRect(bitmap, NULL, bounds, paint); + return; + } + // should try a quick-reject test before calling lockPixels SkAutoLockPixels alp(bitmap); diff --git a/core/jni/android_bluetooth_BluetoothSocket.cpp b/core/jni/android_bluetooth_BluetoothSocket.cpp index 4c84324..488b5c2 100644 --- a/core/jni/android_bluetooth_BluetoothSocket.cpp +++ b/core/jni/android_bluetooth_BluetoothSocket.cpp @@ -57,6 +57,9 @@ static const int TYPE_L2CAP = 3; // TODO: Test l2cap code paths static const int RFCOMM_SO_SNDBUF = 70 * 1024; // 70 KB send buffer +static void abortNative(JNIEnv *env, jobject obj); +static void destroyNative(JNIEnv *env, jobject obj); + static struct asocket *get_socketData(JNIEnv *env, jobject obj) { struct asocket *s = (struct asocket *) env->GetIntField(obj, field_mSocketData); @@ -172,6 +175,7 @@ static void connectNative(JNIEnv *env, jobject obj) { socklen_t addr_sz; struct sockaddr *addr; struct asocket *s = get_socketData(env, obj); + int retry = 0; if (!s) return; @@ -226,10 +230,30 @@ static void connectNative(JNIEnv *env, jobject obj) { return; } +connect: ret = asocket_connect(s, addr, addr_sz, -1); LOGV("...connect(%d, %s) = %d (errno %d)", s->fd, TYPE_AS_STR(type), ret, errno); + if (ret && errno == EALREADY && retry < 2) { + /* workaround for bug 5082381 (EALREADY on ACL collision): + * retry the connect. Unfortunately we have to create a new fd. + * It's not ideal to switch the fd underneath the object, but + * is currently safe */ + LOGD("Hit bug 5082381 (EALREADY on ACL collision), trying workaround"); + usleep(100000); + retry++; + abortNative(env, obj); + destroyNative(env, obj); + initSocketNative(env, obj); + if (env->ExceptionOccurred()) { + return; + } + goto connect; + } + if (!ret && retry > 0) + LOGD("...workaround ok"); + if (ret) jniThrowIOException(env, errno); diff --git a/core/jni/android_hardware_Camera.cpp b/core/jni/android_hardware_Camera.cpp index 4687ee0..3dcaa37 100644 --- a/core/jni/android_hardware_Camera.cpp +++ b/core/jni/android_hardware_Camera.cpp @@ -38,6 +38,12 @@ struct fields_t { jfieldID surfaceTexture; jfieldID facing; jfieldID orientation; + jfieldID face_rect; + jfieldID face_score; + jfieldID rect_left; + jfieldID rect_top; + jfieldID rect_right; + jfieldID rect_bottom; jmethodID post_event; }; @@ -708,6 +714,35 @@ static void android_hardware_Camera_setDisplayOrientation(JNIEnv *env, jobject t } } +static void android_hardware_Camera_startFaceDetection(JNIEnv *env, jobject thiz, + jint type, jobjectArray face) +{ + LOGV("startFaceDetection"); + JNICameraContext* context; + sp<Camera> camera = get_native_camera(env, thiz, &context); + if (camera == 0) return; + + status_t rc = camera->sendCommand(CAMERA_CMD_START_FACE_DETECTION, type, 0); + if (rc == BAD_VALUE) { + char msg[64]; + snprintf(msg, sizeof(msg), "invalid face detection type=%d", type); + jniThrowException(env, "java/lang/IllegalArgumentException", msg); + } else if (rc != NO_ERROR) { + jniThrowRuntimeException(env, "start face detection failed"); + } +} + +static void android_hardware_Camera_stopFaceDetection(JNIEnv *env, jobject thiz) +{ + LOGV("stopFaceDetection"); + sp<Camera> camera = get_native_camera(env, thiz, NULL); + if (camera == 0) return; + + if (camera->sendCommand(CAMERA_CMD_STOP_FACE_DETECTION, 0, 0) != NO_ERROR) { + jniThrowRuntimeException(env, "stop face detection failed"); + } +} + //------------------------------------------------- static JNINativeMethod camMethods[] = { @@ -732,7 +767,7 @@ static JNINativeMethod camMethods[] = { { "startPreview", "()V", (void *)android_hardware_Camera_startPreview }, - { "stopPreview", + { "_stopPreview", "()V", (void *)android_hardware_Camera_stopPreview }, { "previewEnabled", @@ -777,6 +812,12 @@ static JNINativeMethod camMethods[] = { { "setDisplayOrientation", "(I)V", (void *)android_hardware_Camera_setDisplayOrientation }, + { "_startFaceDetection", + "(I)V", + (void *)android_hardware_Camera_startFaceDetection }, + { "_stopFaceDetection", + "()V", + (void *)android_hardware_Camera_stopFaceDetection}, }; struct field { @@ -818,6 +859,12 @@ int register_android_hardware_Camera(JNIEnv *env) ANDROID_GRAPHICS_SURFACETEXTURE_JNI_ID, "I", &fields.surfaceTexture }, { "android/hardware/Camera$CameraInfo", "facing", "I", &fields.facing }, { "android/hardware/Camera$CameraInfo", "orientation", "I", &fields.orientation }, + { "android/hardware/Camera$Face", "rect", "Landroid/graphics/Rect;", &fields.face_rect }, + { "android/hardware/Camera$Face", "score", "I", &fields.face_score }, + { "android/graphics/Rect", "left", "I", &fields.rect_left }, + { "android/graphics/Rect", "top", "I", &fields.rect_top }, + { "android/graphics/Rect", "right", "I", &fields.rect_right }, + { "android/graphics/Rect", "bottom", "I", &fields.rect_bottom }, }; if (find_fields(env, fields_to_find, NELEM(fields_to_find)) < 0) diff --git a/core/jni/android_view_Display.cpp b/core/jni/android_view_Display.cpp index 97f9fc3..5e668b9 100644 --- a/core/jni/android_view_Display.cpp +++ b/core/jni/android_view_Display.cpp @@ -45,11 +45,6 @@ struct offsets_t { }; static offsets_t offsets; -static int gShortSize = -1; -static int gLongSize = -1; -static int gOldSize = -1; -static int gNewSize = -1; - // ---------------------------------------------------------------------------- static void android_view_Display_init( @@ -68,30 +63,6 @@ static void android_view_Display_init( env->SetFloatField(clazz, offsets.ydpi, info.ydpi); } -static jint android_view_Display_getWidth( - JNIEnv* env, jobject clazz) -{ - DisplayID dpy = env->GetIntField(clazz, offsets.display); - jint w = SurfaceComposerClient::getDisplayWidth(dpy); - if (gShortSize > 0) { - jint h = SurfaceComposerClient::getDisplayHeight(dpy); - return w < h ? gShortSize : gLongSize; - } - return w == gOldSize ? gNewSize : w; -} - -static jint android_view_Display_getHeight( - JNIEnv* env, jobject clazz) -{ - DisplayID dpy = env->GetIntField(clazz, offsets.display); - int h = SurfaceComposerClient::getDisplayHeight(dpy); - if (gShortSize > 0) { - jint w = SurfaceComposerClient::getDisplayWidth(dpy); - return h < w ? gShortSize : gLongSize; - } - return h == gOldSize ? gNewSize : h; -} - static jint android_view_Display_getRawWidth( JNIEnv* env, jobject clazz) { @@ -132,10 +103,6 @@ static JNINativeMethod gMethods[] = { (void*)android_view_Display_getDisplayCount }, { "init", "(I)V", (void*)android_view_Display_init }, - { "getRealWidth", "()I", - (void*)android_view_Display_getWidth }, - { "getRealHeight", "()I", - (void*)android_view_Display_getHeight }, { "getRawWidth", "()I", (void*)android_view_Display_getRawWidth }, { "getRawHeight", "()I", @@ -156,24 +123,6 @@ void nativeClassInit(JNIEnv* env, jclass clazz) int register_android_view_Display(JNIEnv* env) { - char buf[PROPERTY_VALUE_MAX]; - int len = property_get("persist.demo.screensizehack", buf, ""); - if (len > 0) { - int temp1, temp2; - if (sscanf(buf, "%dx%d", &temp1, &temp2) == 2) { - if (temp1 < temp2) { - gShortSize = temp1; - gLongSize = temp2; - } else { - gShortSize = temp2; - gLongSize = temp1; - } - } else if (sscanf(buf, "%d=%d", &temp1, &temp2) == 2) { - gOldSize = temp1; - gNewSize = temp2; - } - } - return AndroidRuntime::registerNativeMethods(env, kClassPathName, gMethods, NELEM(gMethods)); } diff --git a/core/jni/android_view_GLES20Canvas.cpp b/core/jni/android_view_GLES20Canvas.cpp index b06de9d..b3f2d51 100644 --- a/core/jni/android_view_GLES20Canvas.cpp +++ b/core/jni/android_view_GLES20Canvas.cpp @@ -580,6 +580,11 @@ static DisplayList* android_view_GLES20Canvas_getDisplayList(JNIEnv* env, return renderer->getDisplayList(displayList); } +static jint android_view_GLES20Canvas_getDisplayListSize(JNIEnv* env, + jobject clazz, DisplayList* displayList) { + return displayList->getSize(); +} + static OpenGLRenderer* android_view_GLES20Canvas_createDisplayListRenderer(JNIEnv* env, jobject clazz) { return new DisplayListRenderer; @@ -721,8 +726,7 @@ static jboolean android_view_GLES20Canvas_isAvailable(JNIEnv* env, jobject clazz // ---------------------------------------------------------------------------- static void -android_app_ActivityThread_dumpGraphics(JNIEnv* env, jobject clazz, jobject javaFileDescriptor) -{ +android_app_ActivityThread_dumpGraphics(JNIEnv* env, jobject clazz, jobject javaFileDescriptor) { #ifdef USE_OPENGL_RENDERER int fd = jniGetFDFromFileDescriptor(env, javaFileDescriptor); android::uirenderer::DisplayList::outputLogBuffer(fd); @@ -814,6 +818,7 @@ static JNINativeMethod gMethods[] = { { "nGetDisplayList", "(II)I", (void*) android_view_GLES20Canvas_getDisplayList }, { "nDestroyDisplayList", "(I)V", (void*) android_view_GLES20Canvas_destroyDisplayList }, + { "nGetDisplayListSize", "(I)I", (void*) android_view_GLES20Canvas_getDisplayListSize }, { "nCreateDisplayListRenderer", "()I", (void*) android_view_GLES20Canvas_createDisplayListRenderer }, { "nResetDisplayListRenderer", "(I)V", (void*) android_view_GLES20Canvas_resetDisplayListRenderer }, { "nDrawDisplayList", "(IIIILandroid/graphics/Rect;)Z", diff --git a/core/jni/com_android_internal_content_NativeLibraryHelper.cpp b/core/jni/com_android_internal_content_NativeLibraryHelper.cpp new file mode 100644 index 0000000..830f70e --- /dev/null +++ b/core/jni/com_android_internal_content_NativeLibraryHelper.cpp @@ -0,0 +1,375 @@ +/* + * Copyright (C) 2011 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 "NativeLibraryHelper" +//#define LOG_NDEBUG 0 + +#include <android_runtime/AndroidRuntime.h> + +#include <utils/Log.h> +#include <ScopedUtfChars.h> +#include <utils/ZipFileRO.h> + +#include <zlib.h> + +#include <fcntl.h> +#include <stdlib.h> +#include <string.h> +#include <time.h> +#include <unistd.h> +#include <sys/stat.h> +#include <sys/types.h> + + +#define APK_LIB "lib/" +#define APK_LIB_LEN (sizeof(APK_LIB) - 1) + +#define LIB_PREFIX "/lib" +#define LIB_PREFIX_LEN (sizeof(LIB_PREFIX) - 1) + +#define LIB_SUFFIX ".so" +#define LIB_SUFFIX_LEN (sizeof(LIB_SUFFIX) - 1) + +#define GDBSERVER "gdbserver" +#define GDBSERVER_LEN (sizeof(GDBSERVER) - 1) + +#define TMP_FILE_PATTERN "/tmp.XXXXXX" +#define TMP_FILE_PATTERN_LEN (sizeof(TMP_FILE_PATTERN) - 1) + +namespace android { + +typedef void (*iterFunc)(JNIEnv*, void*, ZipFileRO*, ZipEntryRO, const char*); + +// These match PackageManager.java install codes +typedef enum { + INSTALL_SUCCEEDED = 0, + INSTALL_FAILED_INVALID_APK = -2, + INSTALL_FAILED_INSUFFICIENT_STORAGE = -4, +} install_status_t; + +// Equivalent to isFilenameSafe +static bool +isFilenameSafe(const char* filename) +{ + off_t offset = 0; + for (;;) { + switch (*(filename + offset)) { + case 0: + // Null. + // If we've reached the end, all the other characters are good. + return true; + + case 'A' ... 'Z': + case 'a' ... 'z': + case '0' ... '9': + case '+': + case ',': + case '-': + case '.': + case '/': + case '=': + case '_': + offset++; + break; + + default: + // We found something that is not good. + return false; + } + } + // Should not reach here. +} + +static bool +isFileDifferent(const char* filePath, size_t fileSize, time_t modifiedTime, + long zipCrc, struct stat64* st) +{ + if (lstat64(filePath, st) < 0) { + // File is not found or cannot be read. + LOGV("Couldn't stat %s, copying: %s\n", filePath, strerror(errno)); + return true; + } + + if (!S_ISREG(st->st_mode)) { + return true; + } + + if (st->st_size != fileSize) { + return true; + } + + // For some reason, bionic doesn't define st_mtime as time_t + if (time_t(st->st_mtime) != modifiedTime) { + LOGV("mod time doesn't match: %ld vs. %ld\n", st->st_mtime, modifiedTime); + return true; + } + + int fd = TEMP_FAILURE_RETRY(open(filePath, O_RDONLY)); + if (fd < 0) { + LOGV("Couldn't open file %s: %s", filePath, strerror(errno)); + return true; + } + + long crc = crc32(0L, Z_NULL, 0); + unsigned char crcBuffer[16384]; + ssize_t numBytes; + while ((numBytes = TEMP_FAILURE_RETRY(read(fd, crcBuffer, sizeof(crcBuffer)))) > 0) { + crc = crc32(crc, crcBuffer, numBytes); + } + close(fd); + + LOGV("%s: crc = %lx, zipCrc = %lx\n", filePath, crc, zipCrc); + + if (crc != zipCrc) { + return true; + } + + return false; +} + +static void +sumFiles(JNIEnv* env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName) +{ + size_t* total = (size_t*) arg; + size_t uncompLen; + + if (!zipFile->getEntryInfo(zipEntry, NULL, &uncompLen, NULL, NULL, NULL, NULL)) { + return; + } + + *total += uncompLen; +} + +/* + * Copy the native library if needed. + * + * This function assumes the library and path names passed in are considered safe. + */ +static void +copyFileIfChanged(JNIEnv *env, void* arg, ZipFileRO* zipFile, ZipEntryRO zipEntry, const char* fileName) +{ + jstring* javaNativeLibPath = (jstring*) arg; + ScopedUtfChars nativeLibPath(env, *javaNativeLibPath); + + size_t uncompLen; + long when; + long crc; + time_t modTime; + + if (!zipFile->getEntryInfo(zipEntry, NULL, &uncompLen, NULL, NULL, &when, &crc)) { + return; + } else { + struct tm t; + ZipFileRO::zipTimeToTimespec(when, &t); + modTime = mktime(&t); + } + + // Build local file path + const size_t fileNameLen = strlen(fileName); + char localFileName[nativeLibPath.size() + fileNameLen + 2]; + + if (strlcpy(localFileName, nativeLibPath.c_str(), sizeof(localFileName)) != nativeLibPath.size()) { + LOGD("Couldn't allocate local file name for library: %s", strerror(errno)); + return; + } + + *(localFileName + nativeLibPath.size()) = '/'; + + if (strlcpy(localFileName + nativeLibPath.size() + 1, fileName, sizeof(localFileName) + - nativeLibPath.size() - 1) != fileNameLen) { + LOGD("Couldn't allocate local file name for library: %s", strerror(errno)); + return; + } + + // Only copy out the native file if it's different. + struct stat st; + if (!isFileDifferent(localFileName, uncompLen, modTime, crc, &st)) { + return; + } + + char localTmpFileName[nativeLibPath.size() + TMP_FILE_PATTERN_LEN + 2]; + if (strlcpy(localTmpFileName, nativeLibPath.c_str(), sizeof(localTmpFileName)) + != nativeLibPath.size()) { + LOGD("Couldn't allocate local file name for library: %s", strerror(errno)); + return; + } + + *(localFileName + nativeLibPath.size()) = '/'; + + if (strlcpy(localTmpFileName + nativeLibPath.size(), TMP_FILE_PATTERN, + TMP_FILE_PATTERN_LEN - nativeLibPath.size()) != TMP_FILE_PATTERN_LEN) { + LOGI("Couldn't allocate temporary file name for library: %s", strerror(errno)); + return; + } + + int fd = mkstemp(localTmpFileName); + if (fd < 0) { + LOGI("Couldn't open temporary file name: %s: %s\n", localTmpFileName, strerror(errno)); + return; + } + + if (!zipFile->uncompressEntry(zipEntry, fd)) { + LOGI("Failed uncompressing %s to %s: %s", fileName, localTmpFileName, strerror(errno)); + close(fd); + unlink(localTmpFileName); + return; + } + + close(fd); + + // Set the modification time for this file to the ZIP's mod time. + struct timeval times[2]; + times[0].tv_sec = st.st_atime; + times[1].tv_sec = modTime; + times[0].tv_usec = times[1].tv_usec = 0; + if (utimes(localTmpFileName, times) < 0) { + LOGI("Couldn't change modification time on %s: %s\n", localTmpFileName, strerror(errno)); + unlink(localTmpFileName); + return; + } + + // Set the mode to 755 + static const mode_t mode = S_IRUSR | S_IWUSR | S_IXUSR | S_IRGRP | S_IXGRP | S_IROTH | S_IXOTH; + if (chmod(localTmpFileName, mode) < 0) { + LOGI("Couldn't change permissions on %s: %s\n", localTmpFileName, strerror(errno)); + unlink(localTmpFileName); + return; + } + + // Finally, rename it to the final name. + if (rename(localTmpFileName, localFileName) < 0) { + LOGI("Couldn't rename %s to %s: %s\n", localTmpFileName, localFileName, strerror(errno)); + unlink(localTmpFileName); + return; + } + + LOGV("Successfully moved %s to %s\n", localTmpFileName, localFileName); +} + +static install_status_t +iterateOverNativeFiles(JNIEnv *env, jstring javaFilePath, jstring javaCpuAbi, jstring javaCpuAbi2, + iterFunc callFunc, void* callArg) { + ScopedUtfChars filePath(env, javaFilePath); + ScopedUtfChars cpuAbi(env, javaCpuAbi); + ScopedUtfChars cpuAbi2(env, javaCpuAbi2); + + ZipFileRO zipFile; + + if (zipFile.open(filePath.c_str()) != NO_ERROR) { + LOGI("Couldn't open APK %s\n", filePath.c_str()); + return INSTALL_FAILED_INVALID_APK; + } + + const int N = zipFile.getNumEntries(); + + char fileName[PATH_MAX]; + + for (int i = 0; i < N; i++) { + const ZipEntryRO entry = zipFile.findEntryByIndex(i); + if (entry == NULL) { + continue; + } + + // Make sure this entry has a filename. + if (zipFile.getEntryFileName(entry, fileName, sizeof(fileName))) { + continue; + } + + // Make sure we're in the lib directory of the ZIP. + if (strncmp(fileName, APK_LIB, APK_LIB_LEN)) { + continue; + } + + // Make sure the filename is at least to the minimum library name size. + const size_t fileNameLen = strlen(fileName); + static const size_t minLength = APK_LIB_LEN + 2 + LIB_PREFIX_LEN + 1 + LIB_SUFFIX_LEN; + if (fileNameLen < minLength) { + continue; + } + + const char* lastSlash = strrchr(fileName, '/'); + if (lastSlash == NULL) { + LOG_ASSERT("last slash was null somehow for %s\n", fileName); + continue; + } + + // Check to make sure the CPU ABI of this file is one we support. + const char* cpuAbiOffset = fileName + APK_LIB_LEN; + const size_t cpuAbiRegionSize = lastSlash - cpuAbiOffset; + + LOGV("Comparing ABIs %s and %s versus %s\n", cpuAbi.c_str(), cpuAbi2.c_str(), cpuAbiOffset); + if (cpuAbi.size() == cpuAbiRegionSize + && *(cpuAbiOffset + cpuAbi.size()) == '/' + && !strncmp(cpuAbiOffset, cpuAbi.c_str(), cpuAbiRegionSize)) { + LOGV("Using ABI %s\n", cpuAbi.c_str()); + } else if (cpuAbi2.size() == cpuAbiRegionSize + && *(cpuAbiOffset + cpuAbi2.size()) == '/' + && !strncmp(cpuAbiOffset, cpuAbi2.c_str(), cpuAbiRegionSize)) { + LOGV("Using ABI %s\n", cpuAbi2.c_str()); + } else { + LOGV("abi didn't match anything: %s (end at %zd)\n", cpuAbiOffset, cpuAbiRegionSize); + continue; + } + + // If this is a .so file, check to see if we need to copy it. + if (!strncmp(fileName + fileNameLen - LIB_SUFFIX_LEN, LIB_SUFFIX, LIB_SUFFIX_LEN) + && !strncmp(lastSlash, LIB_PREFIX, LIB_PREFIX_LEN) + && isFilenameSafe(lastSlash + 1)) { + callFunc(env, callArg, &zipFile, entry, lastSlash + 1); + } else if (!strncmp(lastSlash + 1, GDBSERVER, GDBSERVER_LEN)) { + callFunc(env, callArg, &zipFile, entry, lastSlash + 1); + } + } + + return INSTALL_SUCCEEDED; +} + +static jint +com_android_internal_content_NativeLibraryHelper_copyNativeBinaries(JNIEnv *env, jclass clazz, + jstring javaFilePath, jstring javaNativeLibPath, jstring javaCpuAbi, jstring javaCpuAbi2) +{ + return iterateOverNativeFiles(env, javaFilePath, javaCpuAbi, javaCpuAbi2, + copyFileIfChanged, &javaNativeLibPath); +} + +static jlong +com_android_internal_content_NativeLibraryHelper_sumNativeBinaries(JNIEnv *env, jclass clazz, + jstring javaFilePath, jstring javaCpuAbi, jstring javaCpuAbi2) +{ + size_t totalSize = 0; + + iterateOverNativeFiles(env, javaFilePath, javaCpuAbi, javaCpuAbi2, sumFiles, &totalSize); + + return totalSize; +} + +static JNINativeMethod gMethods[] = { + {"nativeCopyNativeBinaries", + "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)I", + (void *)com_android_internal_content_NativeLibraryHelper_copyNativeBinaries}, + {"nativeSumNativeBinaries", + "(Ljava/lang/String;Ljava/lang/String;Ljava/lang/String;)J", + (void *)com_android_internal_content_NativeLibraryHelper_sumNativeBinaries}, +}; + + +int register_com_android_internal_content_NativeLibraryHelper(JNIEnv *env) +{ + return AndroidRuntime::registerNativeMethods(env, + "com/android/internal/content/NativeLibraryHelper", gMethods, NELEM(gMethods)); +} + +}; |