resolved conflicts for merge of 92ae0347 to klp-modular-dev

Change-Id: I703aea4f20985a4bbda0f685254721d6480bb20f

9 files changed, 159 insertions, 128 deletions

diff --git a/services/core/java/com/android/server/input/InputApplicationHandle.java b/services/core/java/com/android/server/input/InputApplicationHandle.java
index 42c1052..3cf7edc 100644
--- a/services/core/java/com/android/server/input/InputApplicationHandle.java
+++ b/services/core/java/com/android/server/input/InputApplicationHandle.java
@@ -26,7 +26,7 @@ public final class InputApplicationHandle {
     // Pointer to the native input application handle.
     // This field is lazily initialized via JNI.
     @SuppressWarnings("unused")
-    private int ptr;
+    private long ptr;
 
     // The window manager's application window token.
     public final Object appWindowToken;
diff --git a/services/core/java/com/android/server/input/InputManagerService.java b/services/core/java/com/android/server/input/InputManagerService.java
index 3145805..9178664 100644
--- a/services/core/java/com/android/server/input/InputManagerService.java
+++ b/services/core/java/com/android/server/input/InputManagerService.java
@@ -107,7 +107,7 @@ public class InputManagerService extends IInputManager.Stub
     private static final int MSG_RELOAD_DEVICE_ALIASES = 5;
 
     // Pointer to native input manager service object.
-    private final int mPtr;
+    private final long mPtr;
 
     private final Context mContext;
     private final InputManagerHandler mHandler;
@@ -146,46 +146,46 @@ public class InputManagerService extends IInputManager.Stub
     IInputFilter mInputFilter; // guarded by mInputFilterLock
     InputFilterHost mInputFilterHost; // guarded by mInputFilterLock
 
-    private static native int nativeInit(InputManagerService service,
+    private static native long nativeInit(InputManagerService service,
             Context context, MessageQueue messageQueue);
-    private static native void nativeStart(int ptr);
-    private static native void nativeSetDisplayViewport(int ptr, boolean external,
+    private static native void nativeStart(long ptr);
+    private static native void nativeSetDisplayViewport(long ptr, boolean external,
             int displayId, int rotation,
             int logicalLeft, int logicalTop, int logicalRight, int logicalBottom,
             int physicalLeft, int physicalTop, int physicalRight, int physicalBottom,
             int deviceWidth, int deviceHeight);
 
-    private static native int nativeGetScanCodeState(int ptr,
+    private static native int nativeGetScanCodeState(long ptr,
             int deviceId, int sourceMask, int scanCode);
-    private static native int nativeGetKeyCodeState(int ptr,
+    private static native int nativeGetKeyCodeState(long ptr,
             int deviceId, int sourceMask, int keyCode);
-    private static native int nativeGetSwitchState(int ptr,
+    private static native int nativeGetSwitchState(long ptr,
             int deviceId, int sourceMask, int sw);
-    private static native boolean nativeHasKeys(int ptr,
+    private static native boolean nativeHasKeys(long ptr,
             int deviceId, int sourceMask, int[] keyCodes, boolean[] keyExists);
-    private static native void nativeRegisterInputChannel(int ptr, InputChannel inputChannel,
+    private static native void nativeRegisterInputChannel(long ptr, InputChannel inputChannel,
             InputWindowHandle inputWindowHandle, boolean monitor);
-    private static native void nativeUnregisterInputChannel(int ptr, InputChannel inputChannel);
-    private static native void nativeSetInputFilterEnabled(int ptr, boolean enable);
-    private static native int nativeInjectInputEvent(int ptr, InputEvent event,
+    private static native void nativeUnregisterInputChannel(long ptr, InputChannel inputChannel);
+    private static native void nativeSetInputFilterEnabled(long ptr, boolean enable);
+    private static native int nativeInjectInputEvent(long ptr, InputEvent event,
             int injectorPid, int injectorUid, int syncMode, int timeoutMillis,
             int policyFlags);
-    private static native void nativeSetInputWindows(int ptr, InputWindowHandle[] windowHandles);
-    private static native void nativeSetInputDispatchMode(int ptr, boolean enabled, boolean frozen);
-    private static native void nativeSetSystemUiVisibility(int ptr, int visibility);
-    private static native void nativeSetFocusedApplication(int ptr,
+    private static native void nativeSetInputWindows(long ptr, InputWindowHandle[] windowHandles);
+    private static native void nativeSetInputDispatchMode(long ptr, boolean enabled, boolean frozen);
+    private static native void nativeSetSystemUiVisibility(long ptr, int visibility);
+    private static native void nativeSetFocusedApplication(long ptr,
             InputApplicationHandle application);
-    private static native boolean nativeTransferTouchFocus(int ptr,
+    private static native boolean nativeTransferTouchFocus(long ptr,
             InputChannel fromChannel, InputChannel toChannel);
-    private static native void nativeSetPointerSpeed(int ptr, int speed);
-    private static native void nativeSetShowTouches(int ptr, boolean enabled);
-    private static native void nativeVibrate(int ptr, int deviceId, long[] pattern,
+    private static native void nativeSetPointerSpeed(long ptr, int speed);
+    private static native void nativeSetShowTouches(long ptr, boolean enabled);
+    private static native void nativeVibrate(long ptr, int deviceId, long[] pattern,
             int repeat, int token);
-    private static native void nativeCancelVibrate(int ptr, int deviceId, int token);
-    private static native void nativeReloadKeyboardLayouts(int ptr);
-    private static native void nativeReloadDeviceAliases(int ptr);
-    private static native String nativeDump(int ptr);
-    private static native void nativeMonitor(int ptr);
+    private static native void nativeCancelVibrate(long ptr, int deviceId, int token);
+    private static native void nativeReloadKeyboardLayouts(long ptr);
+    private static native void nativeReloadDeviceAliases(long ptr);
+    private static native String nativeDump(long ptr);
+    private static native void nativeMonitor(long ptr);
 
     // Input event injection constants defined in InputDispatcher.h.
     private static final int INPUT_EVENT_INJECTION_SUCCEEDED = 0;
diff --git a/services/core/java/com/android/server/input/InputWindowHandle.java b/services/core/java/com/android/server/input/InputWindowHandle.java
index 9eb9a33..9a70f38 100644
--- a/services/core/java/com/android/server/input/InputWindowHandle.java
+++ b/services/core/java/com/android/server/input/InputWindowHandle.java
@@ -28,7 +28,7 @@ public final class InputWindowHandle {
     // Pointer to the native input window handle.
     // This field is lazily initialized via JNI.
     @SuppressWarnings("unused")
-    private int ptr;
+    private long ptr;
 
     // The input application handle.
     public final InputApplicationHandle inputApplicationHandle;
diff --git a/services/core/java/com/android/server/lights/LightsService.java b/services/core/java/com/android/server/lights/LightsService.java
index d814785..62dc090 100644
--- a/services/core/java/com/android/server/lights/LightsService.java
+++ b/services/core/java/com/android/server/lights/LightsService.java
@@ -195,11 +195,11 @@ public class LightsService extends SystemService {
         }
     };
 
-    private static native int init_native();
-    private static native void finalize_native(int ptr);
+    private static native long init_native();
+    private static native void finalize_native(long ptr);
 
-    static native void setLight_native(int ptr, int light, int color, int mode,
+    static native void setLight_native(long ptr, int light, int color, int mode,
             int onMS, int offMS, int brightnessMode);
 
-    int mNativePointer;
+    private long mNativePointer;
 }
diff --git a/services/core/jni/com_android_server_input_InputApplicationHandle.cpp b/services/core/jni/com_android_server_input_InputApplicationHandle.cpp
index b9681ab..f943d16 100644
--- a/services/core/jni/com_android_server_input_InputApplicationHandle.cpp
+++ b/services/core/jni/com_android_server_input_InputApplicationHandle.cpp
@@ -90,7 +90,7 @@ sp<InputApplicationHandle> android_server_InputApplicationHandle_getHandle(
 
     AutoMutex _l(gHandleMutex);
 
-    int ptr = env->GetIntField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr);
+    jlong ptr = env->GetLongField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr);
     NativeInputApplicationHandle* handle;
     if (ptr) {
         handle = reinterpret_cast<NativeInputApplicationHandle*>(ptr);
@@ -98,8 +98,8 @@ sp<InputApplicationHandle> android_server_InputApplicationHandle_getHandle(
         jweak objWeak = env->NewWeakGlobalRef(inputApplicationHandleObj);
         handle = new NativeInputApplicationHandle(objWeak);
         handle->incStrong((void*)android_server_InputApplicationHandle_getHandle);
-        env->SetIntField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr,
-                reinterpret_cast<int>(handle));
+        env->SetLongField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr,
+                reinterpret_cast<jlong>(handle));
     }
     return handle;
 }
@@ -110,9 +110,9 @@ sp<InputApplicationHandle> android_server_InputApplicationHandle_getHandle(
 static void android_server_InputApplicationHandle_nativeDispose(JNIEnv* env, jobject obj) {
     AutoMutex _l(gHandleMutex);
 
-    int ptr = env->GetIntField(obj, gInputApplicationHandleClassInfo.ptr);
+    jlong ptr = env->GetLongField(obj, gInputApplicationHandleClassInfo.ptr);
     if (ptr) {
-        env->SetIntField(obj, gInputApplicationHandleClassInfo.ptr, 0);
+        env->SetLongField(obj, gInputApplicationHandleClassInfo.ptr, 0);
 
         NativeInputApplicationHandle* handle = reinterpret_cast<NativeInputApplicationHandle*>(ptr);
         handle->decStrong((void*)android_server_InputApplicationHandle_getHandle);
@@ -143,7 +143,7 @@ int register_android_server_InputApplicationHandle(JNIEnv* env) {
     FIND_CLASS(clazz, "com/android/server/input/InputApplicationHandle");
 
     GET_FIELD_ID(gInputApplicationHandleClassInfo.ptr, clazz,
-            "ptr", "I");
+            "ptr", "J");
 
     GET_FIELD_ID(gInputApplicationHandleClassInfo.name, clazz,
             "name", "Ljava/lang/String;");
diff --git a/services/core/jni/com_android_server_input_InputManagerService.cpp b/services/core/jni/com_android_server_input_InputManagerService.cpp
index 4ab2086..10ad278 100644
--- a/services/core/jni/com_android_server_input_InputManagerService.cpp
+++ b/services/core/jni/com_android_server_input_InputManagerService.cpp
@@ -977,7 +977,7 @@ void NativeInputManager::loadPointerResources(PointerResources* outResources) {
 
 // ----------------------------------------------------------------------------
 
-static jint nativeInit(JNIEnv* env, jclass clazz,
+static jlong nativeInit(JNIEnv* env, jclass clazz,
         jobject serviceObj, jobject contextObj, jobject messageQueueObj) {
     sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
     if (messageQueue == NULL) {
@@ -988,10 +988,10 @@ static jint nativeInit(JNIEnv* env, jclass clazz,
     NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,
             messageQueue->getLooper());
     im->incStrong(0);
-    return reinterpret_cast<jint>(im);
+    return reinterpret_cast<jlong>(im);
 }
 
-static void nativeStart(JNIEnv* env, jclass clazz, jint ptr) {
+static void nativeStart(JNIEnv* env, jclass clazz, jlong ptr) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     status_t result = im->getInputManager()->start();
@@ -1000,7 +1000,7 @@ static void nativeStart(JNIEnv* env, jclass clazz, jint ptr) {
     }
 }
 
-static void nativeSetDisplayViewport(JNIEnv* env, jclass clazz, jint ptr, jboolean external,
+static void nativeSetDisplayViewport(JNIEnv* env, jclass clazz, jlong ptr, jboolean external,
         jint displayId, jint orientation,
         jint logicalLeft, jint logicalTop, jint logicalRight, jint logicalBottom,
         jint physicalLeft, jint physicalTop, jint physicalRight, jint physicalBottom,
@@ -1024,31 +1024,31 @@ static void nativeSetDisplayViewport(JNIEnv* env, jclass clazz, jint ptr, jboole
 }
 
 static jint nativeGetScanCodeState(JNIEnv* env, jclass clazz,
-        jint ptr, jint deviceId, jint sourceMask, jint scanCode) {
+        jlong ptr, jint deviceId, jint sourceMask, jint scanCode) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
-    return im->getInputManager()->getReader()->getScanCodeState(
+    return (jint) im->getInputManager()->getReader()->getScanCodeState(
             deviceId, uint32_t(sourceMask), scanCode);
 }
 
 static jint nativeGetKeyCodeState(JNIEnv* env, jclass clazz,
-        jint ptr, jint deviceId, jint sourceMask, jint keyCode) {
+        jlong ptr, jint deviceId, jint sourceMask, jint keyCode) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
-    return im->getInputManager()->getReader()->getKeyCodeState(
+    return (jint) im->getInputManager()->getReader()->getKeyCodeState(
             deviceId, uint32_t(sourceMask), keyCode);
 }
 
 static jint nativeGetSwitchState(JNIEnv* env, jclass clazz,
-        jint ptr, jint deviceId, jint sourceMask, jint sw) {
+        jlong ptr, jint deviceId, jint sourceMask, jint sw) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
-    return im->getInputManager()->getReader()->getSwitchState(
+    return (jint) im->getInputManager()->getReader()->getSwitchState(
             deviceId, uint32_t(sourceMask), sw);
 }
 
 static jboolean nativeHasKeys(JNIEnv* env, jclass clazz,
-        jint ptr, jint deviceId, jint sourceMask, jintArray keyCodes, jbooleanArray outFlags) {
+        jlong ptr, jint deviceId, jint sourceMask, jintArray keyCodes, jbooleanArray outFlags) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     int32_t* codes = env->GetIntArrayElements(keyCodes, NULL);
@@ -1056,8 +1056,12 @@ static jboolean nativeHasKeys(JNIEnv* env, jclass clazz,
     jsize numCodes = env->GetArrayLength(keyCodes);
     jboolean result;
     if (numCodes == env->GetArrayLength(keyCodes)) {
-        result = im->getInputManager()->getReader()->hasKeys(
-                deviceId, uint32_t(sourceMask), numCodes, codes, flags);
+        if (im->getInputManager()->getReader()->hasKeys(
+                deviceId, uint32_t(sourceMask), numCodes, codes, flags)) {
+            result = JNI_TRUE;
+        } else {
+            result = JNI_FALSE;
+        }
     } else {
         result = JNI_FALSE;
     }
@@ -1082,7 +1086,7 @@ static void handleInputChannelDisposed(JNIEnv* env,
 }
 
 static void nativeRegisterInputChannel(JNIEnv* env, jclass clazz,
-        jint ptr, jobject inputChannelObj, jobject inputWindowHandleObj, jboolean monitor) {
+        jlong ptr, jobject inputChannelObj, jobject inputWindowHandleObj, jboolean monitor) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env,
@@ -1111,7 +1115,7 @@ static void nativeRegisterInputChannel(JNIEnv* env, jclass clazz,
 }
 
 static void nativeUnregisterInputChannel(JNIEnv* env, jclass clazz,
-        jint ptr, jobject inputChannelObj) {
+        jlong ptr, jobject inputChannelObj) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env,
@@ -1132,14 +1136,14 @@ static void nativeUnregisterInputChannel(JNIEnv* env, jclass clazz,
 }
 
 static void nativeSetInputFilterEnabled(JNIEnv* env, jclass clazz,
-        jint ptr, jboolean enabled) {
+        jlong ptr, jboolean enabled) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->getInputManager()->getDispatcher()->setInputFilterEnabled(enabled);
 }
 
 static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz,
-        jint ptr, jobject inputEventObj, jint injectorPid, jint injectorUid,
+        jlong ptr, jobject inputEventObj, jint injectorPid, jint injectorUid,
         jint syncMode, jint timeoutMillis, jint policyFlags) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
@@ -1151,7 +1155,7 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz,
             return INPUT_EVENT_INJECTION_FAILED;
         }
 
-        return im->getInputManager()->getDispatcher()->injectInputEvent(
+        return (jint) im->getInputManager()->getDispatcher()->injectInputEvent(
                 & keyEvent, injectorPid, injectorUid, syncMode, timeoutMillis,
                 uint32_t(policyFlags));
     } else if (env->IsInstanceOf(inputEventObj, gMotionEventClassInfo.clazz)) {
@@ -1161,7 +1165,7 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz,
             return INPUT_EVENT_INJECTION_FAILED;
         }
 
-        return im->getInputManager()->getDispatcher()->injectInputEvent(
+        return (jint) im->getInputManager()->getDispatcher()->injectInputEvent(
                 motionEvent, injectorPid, injectorUid, syncMode, timeoutMillis,
                 uint32_t(policyFlags));
     } else {
@@ -1171,35 +1175,35 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz,
 }
 
 static void nativeSetInputWindows(JNIEnv* env, jclass clazz,
-        jint ptr, jobjectArray windowHandleObjArray) {
+        jlong ptr, jobjectArray windowHandleObjArray) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->setInputWindows(env, windowHandleObjArray);
 }
 
 static void nativeSetFocusedApplication(JNIEnv* env, jclass clazz,
-        jint ptr, jobject applicationHandleObj) {
+        jlong ptr, jobject applicationHandleObj) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->setFocusedApplication(env, applicationHandleObj);
 }
 
 static void nativeSetInputDispatchMode(JNIEnv* env,
-        jclass clazz, jint ptr, jboolean enabled, jboolean frozen) {
+        jclass clazz, jlong ptr, jboolean enabled, jboolean frozen) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->setInputDispatchMode(enabled, frozen);
 }
 
 static void nativeSetSystemUiVisibility(JNIEnv* env,
-        jclass clazz, jint ptr, jint visibility) {
+        jclass clazz, jlong ptr, jint visibility) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->setSystemUiVisibility(visibility);
 }
 
 static jboolean nativeTransferTouchFocus(JNIEnv* env,
-        jclass clazz, jint ptr, jobject fromChannelObj, jobject toChannelObj) {
+        jclass clazz, jlong ptr, jobject fromChannelObj, jobject toChannelObj) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     sp<InputChannel> fromChannel =
@@ -1208,29 +1212,33 @@ static jboolean nativeTransferTouchFocus(JNIEnv* env,
             android_view_InputChannel_getInputChannel(env, toChannelObj);
 
     if (fromChannel == NULL || toChannel == NULL) {
-        return false;
+        return JNI_FALSE;
     }
 
-    return im->getInputManager()->getDispatcher()->
-            transferTouchFocus(fromChannel, toChannel);
+    if (im->getInputManager()->getDispatcher()->
+            transferTouchFocus(fromChannel, toChannel)) {
+        return JNI_TRUE;
+    } else {
+        return JNI_FALSE;
+    }
 }
 
 static void nativeSetPointerSpeed(JNIEnv* env,
-        jclass clazz, jint ptr, jint speed) {
+        jclass clazz, jlong ptr, jint speed) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->setPointerSpeed(speed);
 }
 
 static void nativeSetShowTouches(JNIEnv* env,
-        jclass clazz, jint ptr, jboolean enabled) {
+        jclass clazz, jlong ptr, jboolean enabled) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->setShowTouches(enabled);
 }
 
 static void nativeVibrate(JNIEnv* env,
-        jclass clazz, jint ptr, jint deviceId, jlongArray patternObj,
+        jclass clazz, jlong ptr, jint deviceId, jlongArray patternObj,
         jint repeat, jint token) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
@@ -1247,7 +1255,7 @@ static void nativeVibrate(JNIEnv* env,
     nsecs_t pattern[patternSize];
     for (size_t i = 0; i < patternSize; i++) {
         pattern[i] = max(jlong(0), min(patternMillis[i],
-                MAX_VIBRATE_PATTERN_DELAY_NSECS / 1000000LL)) * 1000000LL;
+                (jlong)(MAX_VIBRATE_PATTERN_DELAY_NSECS / 1000000LL))) * 1000000LL;
     }
     env->ReleasePrimitiveArrayCritical(patternObj, patternMillis, JNI_ABORT);
 
@@ -1255,14 +1263,14 @@ static void nativeVibrate(JNIEnv* env,
 }
 
 static void nativeCancelVibrate(JNIEnv* env,
-        jclass clazz, jint ptr, jint deviceId, jint token) {
+        jclass clazz, jlong ptr, jint deviceId, jint token) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->getInputManager()->getReader()->cancelVibrate(deviceId, token);
 }
 
 static void nativeReloadKeyboardLayouts(JNIEnv* env,
-        jclass clazz, jint ptr) {
+        jclass clazz, jlong ptr) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->getInputManager()->getReader()->requestRefreshConfiguration(
@@ -1270,14 +1278,14 @@ static void nativeReloadKeyboardLayouts(JNIEnv* env,
 }
 
 static void nativeReloadDeviceAliases(JNIEnv* env,
-        jclass clazz, jint ptr) {
+        jclass clazz, jlong ptr) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->getInputManager()->getReader()->requestRefreshConfiguration(
             InputReaderConfiguration::CHANGE_DEVICE_ALIAS);
 }
 
-static jstring nativeDump(JNIEnv* env, jclass clazz, jint ptr) {
+static jstring nativeDump(JNIEnv* env, jclass clazz, jlong ptr) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     String8 dump;
@@ -1285,7 +1293,7 @@ static jstring nativeDump(JNIEnv* env, jclass clazz, jint ptr) {
     return env->NewStringUTF(dump.string());
 }
 
-static void nativeMonitor(JNIEnv* env, jclass clazz, jint ptr) {
+static void nativeMonitor(JNIEnv* env, jclass clazz, jlong ptr) {
     NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
 
     im->getInputManager()->getReader()->monitor();
@@ -1297,54 +1305,54 @@ static void nativeMonitor(JNIEnv* env, jclass clazz, jint ptr) {
 static JNINativeMethod gInputManagerMethods[] = {
     /* name, signature, funcPtr */
     { "nativeInit",
-            "(Lcom/android/server/input/InputManagerService;Landroid/content/Context;Landroid/os/MessageQueue;)I",
+            "(Lcom/android/server/input/InputManagerService;Landroid/content/Context;Landroid/os/MessageQueue;)J",
             (void*) nativeInit },
-    { "nativeStart", "(I)V",
+    { "nativeStart", "(J)V",
             (void*) nativeStart },
-    { "nativeSetDisplayViewport", "(IZIIIIIIIIIIII)V",
+    { "nativeSetDisplayViewport", "(JZIIIIIIIIIIII)V",
             (void*) nativeSetDisplayViewport },
-    { "nativeGetScanCodeState", "(IIII)I",
+    { "nativeGetScanCodeState", "(JIII)I",
             (void*) nativeGetScanCodeState },
-    { "nativeGetKeyCodeState", "(IIII)I",
+    { "nativeGetKeyCodeState", "(JIII)I",
             (void*) nativeGetKeyCodeState },
-    { "nativeGetSwitchState", "(IIII)I",
+    { "nativeGetSwitchState", "(JIII)I",
             (void*) nativeGetSwitchState },
-    { "nativeHasKeys", "(III[I[Z)Z",
+    { "nativeHasKeys", "(JII[I[Z)Z",
             (void*) nativeHasKeys },
     { "nativeRegisterInputChannel",
-            "(ILandroid/view/InputChannel;Lcom/android/server/input/InputWindowHandle;Z)V",
+            "(JLandroid/view/InputChannel;Lcom/android/server/input/InputWindowHandle;Z)V",
             (void*) nativeRegisterInputChannel },
-    { "nativeUnregisterInputChannel", "(ILandroid/view/InputChannel;)V",
+    { "nativeUnregisterInputChannel", "(JLandroid/view/InputChannel;)V",
             (void*) nativeUnregisterInputChannel },
-    { "nativeSetInputFilterEnabled", "(IZ)V",
+    { "nativeSetInputFilterEnabled", "(JZ)V",
             (void*) nativeSetInputFilterEnabled },
-    { "nativeInjectInputEvent", "(ILandroid/view/InputEvent;IIIII)I",
+    { "nativeInjectInputEvent", "(JLandroid/view/InputEvent;IIIII)I",
             (void*) nativeInjectInputEvent },
-    { "nativeSetInputWindows", "(I[Lcom/android/server/input/InputWindowHandle;)V",
+    { "nativeSetInputWindows", "(J[Lcom/android/server/input/InputWindowHandle;)V",
             (void*) nativeSetInputWindows },
-    { "nativeSetFocusedApplication", "(ILcom/android/server/input/InputApplicationHandle;)V",
+    { "nativeSetFocusedApplication", "(JLcom/android/server/input/InputApplicationHandle;)V",
             (void*) nativeSetFocusedApplication },
-    { "nativeSetInputDispatchMode", "(IZZ)V",
+    { "nativeSetInputDispatchMode", "(JZZ)V",
             (void*) nativeSetInputDispatchMode },
-    { "nativeSetSystemUiVisibility", "(II)V",
+    { "nativeSetSystemUiVisibility", "(JI)V",
             (void*) nativeSetSystemUiVisibility },
-    { "nativeTransferTouchFocus", "(ILandroid/view/InputChannel;Landroid/view/InputChannel;)Z",
+    { "nativeTransferTouchFocus", "(JLandroid/view/InputChannel;Landroid/view/InputChannel;)Z",
             (void*) nativeTransferTouchFocus },
-    { "nativeSetPointerSpeed", "(II)V",
+    { "nativeSetPointerSpeed", "(JI)V",
             (void*) nativeSetPointerSpeed },
-    { "nativeSetShowTouches", "(IZ)V",
+    { "nativeSetShowTouches", "(JZ)V",
             (void*) nativeSetShowTouches },
-    { "nativeVibrate", "(II[JII)V",
+    { "nativeVibrate", "(JI[JII)V",
             (void*) nativeVibrate },
-    { "nativeCancelVibrate", "(III)V",
+    { "nativeCancelVibrate", "(JII)V",
             (void*) nativeCancelVibrate },
-    { "nativeReloadKeyboardLayouts", "(I)V",
+    { "nativeReloadKeyboardLayouts", "(J)V",
             (void*) nativeReloadKeyboardLayouts },
-    { "nativeReloadDeviceAliases", "(I)V",
+    { "nativeReloadDeviceAliases", "(J)V",
             (void*) nativeReloadDeviceAliases },
-    { "nativeDump", "(I)Ljava/lang/String;",
+    { "nativeDump", "(J)Ljava/lang/String;",
             (void*) nativeDump },
-    { "nativeMonitor", "(I)V",
+    { "nativeMonitor", "(J)V",
             (void*) nativeMonitor },
 };
 
diff --git a/services/core/jni/com_android_server_input_InputWindowHandle.cpp b/services/core/jni/com_android_server_input_InputWindowHandle.cpp
index 82e3dad..b80183c 100644
--- a/services/core/jni/com_android_server_input_InputWindowHandle.cpp
+++ b/services/core/jni/com_android_server_input_InputWindowHandle.cpp
@@ -173,7 +173,7 @@ sp<NativeInputWindowHandle> android_server_InputWindowHandle_getHandle(
 
     AutoMutex _l(gHandleMutex);
 
-    int ptr = env->GetIntField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr);
+    jlong ptr = env->GetLongField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr);
     NativeInputWindowHandle* handle;
     if (ptr) {
         handle = reinterpret_cast<NativeInputWindowHandle*>(ptr);
@@ -187,8 +187,8 @@ sp<NativeInputWindowHandle> android_server_InputWindowHandle_getHandle(
         jweak objWeak = env->NewWeakGlobalRef(inputWindowHandleObj);
         handle = new NativeInputWindowHandle(inputApplicationHandle, objWeak);
         handle->incStrong((void*)android_server_InputWindowHandle_getHandle);
-        env->SetIntField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr,
-                reinterpret_cast<int>(handle));
+        env->SetLongField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr,
+                reinterpret_cast<jlong>(handle));
     }
     return handle;
 }
@@ -199,9 +199,9 @@ sp<NativeInputWindowHandle> android_server_InputWindowHandle_getHandle(
 static void android_server_InputWindowHandle_nativeDispose(JNIEnv* env, jobject obj) {
     AutoMutex _l(gHandleMutex);
 
-    int ptr = env->GetIntField(obj, gInputWindowHandleClassInfo.ptr);
+    jlong ptr = env->GetLongField(obj, gInputWindowHandleClassInfo.ptr);
     if (ptr) {
-        env->SetIntField(obj, gInputWindowHandleClassInfo.ptr, 0);
+        env->SetLongField(obj, gInputWindowHandleClassInfo.ptr, 0);
 
         NativeInputWindowHandle* handle = reinterpret_cast<NativeInputWindowHandle*>(ptr);
         handle->decStrong((void*)android_server_InputWindowHandle_getHandle);
@@ -232,7 +232,7 @@ int register_android_server_InputWindowHandle(JNIEnv* env) {
     FIND_CLASS(clazz, "com/android/server/input/InputWindowHandle");
 
     GET_FIELD_ID(gInputWindowHandleClassInfo.ptr, clazz,
-            "ptr", "I");
+            "ptr", "J");
 
     GET_FIELD_ID(gInputWindowHandleClassInfo.inputApplicationHandle,
             clazz,
diff --git a/services/core/jni/com_android_server_lights_LightsService.cpp b/services/core/jni/com_android_server_lights_LightsService.cpp
index ea03cfa..d51e044 100644
--- a/services/core/jni/com_android_server_lights_LightsService.cpp
+++ b/services/core/jni/com_android_server_lights_LightsService.cpp
@@ -60,7 +60,7 @@ static light_device_t* get_device(hw_module_t* module, char const* name)
     }
 }
 
-static jint init_native(JNIEnv *env, jobject clazz)
+static jlong init_native(JNIEnv *env, jobject clazz)
 {
     int err;
     hw_module_t* module;
@@ -90,10 +90,10 @@ static jint init_native(JNIEnv *env, jobject clazz)
         memset(devices, 0, sizeof(Devices));
     }
 
-    return (jint)devices;
+    return (jlong)devices;
 }
 
-static void finalize_native(JNIEnv *env, jobject clazz, int ptr)
+static void finalize_native(JNIEnv *env, jobject clazz, jlong ptr)
 {
     Devices* devices = (Devices*)ptr;
     if (devices == NULL) {
@@ -103,8 +103,8 @@ static void finalize_native(JNIEnv *env, jobject clazz, int ptr)
     free(devices);
 }
 
-static void setLight_native(JNIEnv *env, jobject clazz, int ptr,
-        int light, int colorARGB, int flashMode, int onMS, int offMS, int brightnessMode)
+static void setLight_native(JNIEnv *env, jobject clazz, jlong ptr,
+        jint light, jint colorARGB, jint flashMode, jint onMS, jint offMS, jint brightnessMode)
 {
     Devices* devices = (Devices*)ptr;
     light_state_t state;
@@ -127,9 +127,9 @@ static void setLight_native(JNIEnv *env, jobject clazz, int ptr,
 }
 
 static JNINativeMethod method_table[] = {
-    { "init_native", "()I", (void*)init_native },
-    { "finalize_native", "(I)V", (void*)finalize_native },
-    { "setLight_native", "(IIIIIII)V", (void*)setLight_native },
+    { "init_native", "()J", (void*)init_native },
+    { "finalize_native", "(J)V", (void*)finalize_native },
+    { "setLight_native", "(JIIIIII)V", (void*)setLight_native },
 };
 
 int register_android_server_LightsService(JNIEnv *env)
diff --git a/services/core/jni/com_android_server_location_GpsLocationProvider.cpp b/services/core/jni/com_android_server_location_GpsLocationProvider.cpp
index aec254b..3904af9 100644
--- a/services/core/jni/com_android_server_location_GpsLocationProvider.cpp
+++ b/services/core/jni/com_android_server_location_GpsLocationProvider.cpp
@@ -387,7 +387,11 @@ static void android_location_GpsLocationProvider_class_init_native(JNIEnv* env,
 }
 
 static jboolean android_location_GpsLocationProvider_is_supported(JNIEnv* env, jclass clazz) {
-    return (sGpsInterface != NULL);
+    if (sGpsInterface != NULL) {
+        return JNI_TRUE;
+    } else {
+        return JNI_FALSE;
+    }
 }
 
 static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject obj)
@@ -398,7 +402,7 @@ static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject o
 
     // fail if the main interface fails to initialize
     if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != 0)
-        return false;
+        return JNI_FALSE;
 
     // if XTRA initialization fails we will disable it by sGpsXtraInterface to NULL,
     // but continue to allow the rest of the GPS interface to work.
@@ -413,7 +417,7 @@ static jboolean android_location_GpsLocationProvider_init(JNIEnv* env, jobject o
     if (sGpsGeofencingInterface)
         sGpsGeofencingInterface->init(&sGpsGeofenceCallbacks);
 
-    return true;
+    return JNI_FALSE;
 }
 
 static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject obj)
@@ -425,27 +429,42 @@ static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject ob
 static jboolean android_location_GpsLocationProvider_set_position_mode(JNIEnv* env, jobject obj,
         jint mode, jint recurrence, jint min_interval, jint preferred_accuracy, jint preferred_time)
 {
-    if (sGpsInterface)
-        return (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy,
-                preferred_time) == 0);
+    if (sGpsInterface) {
+        if (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy,
+                preferred_time) == 0) {
+            return JNI_TRUE;
+        } else {
+            return JNI_FALSE;
+        }
+    }
     else
-        return false;
+        return JNI_FALSE;
 }
 
 static jboolean android_location_GpsLocationProvider_start(JNIEnv* env, jobject obj)
 {
-    if (sGpsInterface)
-        return (sGpsInterface->start() == 0);
+    if (sGpsInterface) {
+        if (sGpsInterface->start() == 0) {
+            return JNI_TRUE;
+        } else {
+            return JNI_FALSE;
+        }
+    }
     else
-        return false;
+        return JNI_FALSE;
 }
 
 static jboolean android_location_GpsLocationProvider_stop(JNIEnv* env, jobject obj)
 {
-    if (sGpsInterface)
-        return (sGpsInterface->stop() == 0);
+    if (sGpsInterface) {
+        if (sGpsInterface->stop() == 0) {
+            return JNI_TRUE;
+        } else {
+            return JNI_FALSE;
+        }
+    }
     else
-        return false;
+        return JNI_FALSE;
 }
 
 static void android_location_GpsLocationProvider_delete_aiding_data(JNIEnv* env, jobject obj, jint flags)
@@ -482,7 +501,7 @@ static jint android_location_GpsLocationProvider_read_sv_status(JNIEnv* env, job
     env->ReleaseFloatArrayElements(elevArray, elev, 0);
     env->ReleaseFloatArrayElements(azumArray, azim, 0);
     env->ReleaseIntArrayElements(maskArray, mask, 0);
-    return num_svs;
+    return (jint) num_svs;
 }
 
 static void android_location_GpsLocationProvider_agps_set_reference_location_cellid(JNIEnv* env,
@@ -552,7 +571,7 @@ static jint android_location_GpsLocationProvider_read_nmea(JNIEnv* env, jobject
         length = buffer_size;
     memcpy(nmea, sNmeaString, length);
     env->ReleasePrimitiveArrayCritical(nmeaArray, nmea, JNI_ABORT);
-    return length;
+    return (jint) length;
 }
 
 static void android_location_GpsLocationProvider_inject_time(JNIEnv* env, jobject obj,
@@ -571,7 +590,11 @@ static void android_location_GpsLocationProvider_inject_location(JNIEnv* env, jo
 
 static jboolean android_location_GpsLocationProvider_supports_xtra(JNIEnv* env, jobject obj)
 {
-    return (sGpsXtraInterface != NULL);
+    if (sGpsXtraInterface != NULL) {
+        return JNI_TRUE;
+    } else {
+        return JNI_FALSE;
+    }
 }
 
 static void android_location_GpsLocationProvider_inject_xtra_data(JNIEnv* env, jobject obj,
@@ -658,7 +681,7 @@ static jstring android_location_GpsLocationProvider_get_internal_state(JNIEnv* e
 }
 
 static void android_location_GpsLocationProvider_update_network_state(JNIEnv* env, jobject obj,
-        jboolean connected, int type, jboolean roaming, jboolean available, jstring extraInfo, jstring apn)
+        jboolean connected, jint type, jboolean roaming, jboolean available, jstring extraInfo, jstring apn)
 {
 
     if (sAGpsRilInterface && sAGpsRilInterface->update_network_state) {