Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "AArch64: Use long for pointers in services"

Browse Source
This commit is contained in:
Narayan Kamath
2014-01-08 11:53:00 +00:00
committed by Gerrit Code Review
parent 517e9b11d5 7e2a9dcf1a
commit f210044fb8
9 changed files with 159 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
services/java/com/android/server/LightsService.java
View File

@@ -201,13 +201,13 @@ public class LightsService {
} }
}; };
private static native int init_native(); private static native long init_native();
private static native void finalize_native(int ptr); private static native void finalize_native(long ptr);
private static native void setLight_native(int ptr, int light, int color, int mode, private static native void setLight_native(long ptr, int light, int color, int mode,
int onMS, int offMS, int brightnessMode); int onMS, int offMS, int brightnessMode);
private final Context mContext; private final Context mContext;
private int mNativePointer; private long mNativePointer;
} }

2
services/java/com/android/server/input/InputApplicationHandle.java
View File

@@ -26,7 +26,7 @@ public final class InputApplicationHandle {
// Pointer to the native input application handle. // Pointer to the native input application handle.
// This field is lazily initialized via JNI. // This field is lazily initialized via JNI.
@SuppressWarnings("unused") @SuppressWarnings("unused")
private int ptr; private long ptr;
// The window manager's application window token. // The window manager's application window token.
public final Object appWindowToken; public final Object appWindowToken;

50
services/java/com/android/server/input/InputManagerService.java
View File

@@ -107,7 +107,7 @@ public class InputManagerService extends IInputManager.Stub
private static final int MSG_RELOAD_DEVICE_ALIASES = 5; private static final int MSG_RELOAD_DEVICE_ALIASES = 5;
// Pointer to native input manager service object. // Pointer to native input manager service object.
private final int mPtr; private final long mPtr;
private final Context mContext; private final Context mContext;
private final InputManagerHandler mHandler; private final InputManagerHandler mHandler;
@@ -146,46 +146,46 @@ public class InputManagerService extends IInputManager.Stub
IInputFilter mInputFilter; // guarded by mInputFilterLock IInputFilter mInputFilter; // guarded by mInputFilterLock
InputFilterHost mInputFilterHost; // 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); Context context, MessageQueue messageQueue);
private static native void nativeStart(int ptr); private static native void nativeStart(long ptr);
private static native void nativeSetDisplayViewport(int ptr, boolean external, private static native void nativeSetDisplayViewport(long ptr, boolean external,
int displayId, int rotation, int displayId, int rotation,
int logicalLeft, int logicalTop, int logicalRight, int logicalBottom, int logicalLeft, int logicalTop, int logicalRight, int logicalBottom,
int physicalLeft, int physicalTop, int physicalRight, int physicalBottom, int physicalLeft, int physicalTop, int physicalRight, int physicalBottom,
int deviceWidth, int deviceHeight); int deviceWidth, int deviceHeight);
private static native int nativeGetScanCodeState(int ptr, private static native int nativeGetScanCodeState(long ptr,
int deviceId, int sourceMask, int scanCode); 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); 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); 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); 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); InputWindowHandle inputWindowHandle, boolean monitor);
private static native void nativeUnregisterInputChannel(int ptr, InputChannel inputChannel); private static native void nativeUnregisterInputChannel(long ptr, InputChannel inputChannel);
private static native void nativeSetInputFilterEnabled(int ptr, boolean enable); private static native void nativeSetInputFilterEnabled(long ptr, boolean enable);
private static native int nativeInjectInputEvent(int ptr, InputEvent event, private static native int nativeInjectInputEvent(long ptr, InputEvent event,
int injectorPid, int injectorUid, int syncMode, int timeoutMillis, int injectorPid, int injectorUid, int syncMode, int timeoutMillis,
int policyFlags); int policyFlags);
private static native void nativeSetInputWindows(int ptr, InputWindowHandle[] windowHandles); private static native void nativeSetInputWindows(long ptr, InputWindowHandle[] windowHandles);
private static native void nativeSetInputDispatchMode(int ptr, boolean enabled, boolean frozen); private static native void nativeSetInputDispatchMode(long ptr, boolean enabled, boolean frozen);
private static native void nativeSetSystemUiVisibility(int ptr, int visibility); private static native void nativeSetSystemUiVisibility(long ptr, int visibility);
private static native void nativeSetFocusedApplication(int ptr, private static native void nativeSetFocusedApplication(long ptr,
InputApplicationHandle application); InputApplicationHandle application);
private static native boolean nativeTransferTouchFocus(int ptr, private static native boolean nativeTransferTouchFocus(long ptr,
InputChannel fromChannel, InputChannel toChannel); InputChannel fromChannel, InputChannel toChannel);
private static native void nativeSetPointerSpeed(int ptr, int speed); private static native void nativeSetPointerSpeed(long ptr, int speed);
private static native void nativeSetShowTouches(int ptr, boolean enabled); private static native void nativeSetShowTouches(long ptr, boolean enabled);
private static native void nativeVibrate(int ptr, int deviceId, long[] pattern, private static native void nativeVibrate(long ptr, int deviceId, long[] pattern,
int repeat, int token); int repeat, int token);
private static native void nativeCancelVibrate(int ptr, int deviceId, int token); private static native void nativeCancelVibrate(long ptr, int deviceId, int token);
private static native void nativeReloadKeyboardLayouts(int ptr); private static native void nativeReloadKeyboardLayouts(long ptr);
private static native void nativeReloadDeviceAliases(int ptr); private static native void nativeReloadDeviceAliases(long ptr);
private static native String nativeDump(int ptr); private static native String nativeDump(long ptr);
private static native void nativeMonitor(int ptr); private static native void nativeMonitor(long ptr);
// Input event injection constants defined in InputDispatcher.h. // Input event injection constants defined in InputDispatcher.h.
private static final int INPUT_EVENT_INJECTION_SUCCEEDED = 0; private static final int INPUT_EVENT_INJECTION_SUCCEEDED = 0;

2
services/java/com/android/server/input/InputWindowHandle.java
View File

@@ -28,7 +28,7 @@ public final class InputWindowHandle {
// Pointer to the native input window handle. // Pointer to the native input window handle.
// This field is lazily initialized via JNI. // This field is lazily initialized via JNI.
@SuppressWarnings("unused") @SuppressWarnings("unused")
private int ptr; private long ptr;
// The input application handle. // The input application handle.
public final InputApplicationHandle inputApplicationHandle; public final InputApplicationHandle inputApplicationHandle;

16
services/jni/com_android_server_LightsService.cpp
View File

@@ -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; int err;
hw_module_t* module; hw_module_t* module;
@@ -90,10 +90,10 @@ static jint init_native(JNIEnv *env, jobject clazz)
memset(devices, 0, sizeof(Devices)); 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; Devices* devices = (Devices*)ptr;
if (devices == NULL) { if (devices == NULL) {
@@ -103,8 +103,8 @@ static void finalize_native(JNIEnv *env, jobject clazz, int ptr)
free(devices); free(devices);
} }
static void setLight_native(JNIEnv *env, jobject clazz, int ptr, static void setLight_native(JNIEnv *env, jobject clazz, jlong ptr,
int light, int colorARGB, int flashMode, int onMS, int offMS, int brightnessMode) jint light, jint colorARGB, jint flashMode, jint onMS, jint offMS, jint brightnessMode)
{ {
Devices* devices = (Devices*)ptr; Devices* devices = (Devices*)ptr;
light_state_t state; light_state_t state;
@@ -127,9 +127,9 @@ static void setLight_native(JNIEnv *env, jobject clazz, int ptr,
} }
static JNINativeMethod method_table[] = { static JNINativeMethod method_table[] = {
{ "init_native", "()I", (void*)init_native }, { "init_native", "()J", (void*)init_native },
{ "finalize_native", "(I)V", (void*)finalize_native }, { "finalize_native", "(J)V", (void*)finalize_native },
{ "setLight_native", "(IIIIIII)V", (void*)setLight_native }, { "setLight_native", "(JIIIIII)V", (void*)setLight_native },
}; };
int register_android_server_LightsService(JNIEnv *env) int register_android_server_LightsService(JNIEnv *env)

12
services/jni/com_android_server_input_InputApplicationHandle.cpp
View File

@@ -90,7 +90,7 @@ sp<InputApplicationHandle> android_server_InputApplicationHandle_getHandle(
AutoMutex _l(gHandleMutex); AutoMutex _l(gHandleMutex);
int ptr = env->GetIntField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr); jlong ptr = env->GetLongField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr);
NativeInputApplicationHandle* handle; NativeInputApplicationHandle* handle;
if (ptr) { if (ptr) {
handle = reinterpret_cast<NativeInputApplicationHandle*>(ptr); handle = reinterpret_cast<NativeInputApplicationHandle*>(ptr);
@@ -98,8 +98,8 @@ sp<InputApplicationHandle> android_server_InputApplicationHandle_getHandle(
jweak objWeak = env->NewWeakGlobalRef(inputApplicationHandleObj); jweak objWeak = env->NewWeakGlobalRef(inputApplicationHandleObj);
handle = new NativeInputApplicationHandle(objWeak); handle = new NativeInputApplicationHandle(objWeak);
handle->incStrong((void*)android_server_InputApplicationHandle_getHandle); handle->incStrong((void*)android_server_InputApplicationHandle_getHandle);
env->SetIntField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr, env->SetLongField(inputApplicationHandleObj, gInputApplicationHandleClassInfo.ptr,
reinterpret_cast<int>(handle)); reinterpret_cast<jlong>(handle));
} }
return handle; return handle;
} }
@@ -110,9 +110,9 @@ sp<InputApplicationHandle> android_server_InputApplicationHandle_getHandle(
static void android_server_InputApplicationHandle_nativeDispose(JNIEnv* env, jobject obj) { static void android_server_InputApplicationHandle_nativeDispose(JNIEnv* env, jobject obj) {
AutoMutex _l(gHandleMutex); AutoMutex _l(gHandleMutex);
int ptr = env->GetIntField(obj, gInputApplicationHandleClassInfo.ptr); jlong ptr = env->GetLongField(obj, gInputApplicationHandleClassInfo.ptr);
if (ptr) { if (ptr) {
env->SetIntField(obj, gInputApplicationHandleClassInfo.ptr, 0); env->SetLongField(obj, gInputApplicationHandleClassInfo.ptr, 0);
NativeInputApplicationHandle* handle = reinterpret_cast<NativeInputApplicationHandle*>(ptr); NativeInputApplicationHandle* handle = reinterpret_cast<NativeInputApplicationHandle*>(ptr);
handle->decStrong((void*)android_server_InputApplicationHandle_getHandle); 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"); FIND_CLASS(clazz, "com/android/server/input/InputApplicationHandle");
GET_FIELD_ID(gInputApplicationHandleClassInfo.ptr, clazz, GET_FIELD_ID(gInputApplicationHandleClassInfo.ptr, clazz,
"ptr", "I"); "ptr", "J");
GET_FIELD_ID(gInputApplicationHandleClassInfo.name, clazz, GET_FIELD_ID(gInputApplicationHandleClassInfo.name, clazz,
"name", "Ljava/lang/String;"); "name", "Ljava/lang/String;");

128
services/jni/com_android_server_input_InputManagerService.cpp
View File

@@ -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) { jobject serviceObj, jobject contextObj, jobject messageQueueObj) {
sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj); sp<MessageQueue> messageQueue = android_os_MessageQueue_getMessageQueue(env, messageQueueObj);
if (messageQueue == NULL) { if (messageQueue == NULL) {
@@ -988,10 +988,10 @@ static jint nativeInit(JNIEnv* env, jclass clazz,
NativeInputManager* im = new NativeInputManager(contextObj, serviceObj, NativeInputManager* im = new NativeInputManager(contextObj, serviceObj,
messageQueue->getLooper()); messageQueue->getLooper());
im->incStrong(0); 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
status_t result = im->getInputManager()->start(); 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 displayId, jint orientation,
jint logicalLeft, jint logicalTop, jint logicalRight, jint logicalBottom, jint logicalLeft, jint logicalTop, jint logicalRight, jint logicalBottom,
jint physicalLeft, jint physicalTop, jint physicalRight, jint physicalBottom, 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, 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
return im->getInputManager()->getReader()->getScanCodeState( return (jint) im->getInputManager()->getReader()->getScanCodeState(
deviceId, uint32_t(sourceMask), scanCode); deviceId, uint32_t(sourceMask), scanCode);
} }
static jint nativeGetKeyCodeState(JNIEnv* env, jclass clazz, 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
return im->getInputManager()->getReader()->getKeyCodeState( return (jint) im->getInputManager()->getReader()->getKeyCodeState(
deviceId, uint32_t(sourceMask), keyCode); deviceId, uint32_t(sourceMask), keyCode);
} }
static jint nativeGetSwitchState(JNIEnv* env, jclass clazz, 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
return im->getInputManager()->getReader()->getSwitchState( return (jint) im->getInputManager()->getReader()->getSwitchState(
deviceId, uint32_t(sourceMask), sw); deviceId, uint32_t(sourceMask), sw);
} }
static jboolean nativeHasKeys(JNIEnv* env, jclass clazz, 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
int32_t* codes = env->GetIntArrayElements(keyCodes, NULL); int32_t* codes = env->GetIntArrayElements(keyCodes, NULL);
@@ -1056,8 +1056,12 @@ static jboolean nativeHasKeys(JNIEnv* env, jclass clazz,
jsize numCodes = env->GetArrayLength(keyCodes); jsize numCodes = env->GetArrayLength(keyCodes);
jboolean result; jboolean result;
if (numCodes == env->GetArrayLength(keyCodes)) { if (numCodes == env->GetArrayLength(keyCodes)) {
result = im->getInputManager()->getReader()->hasKeys( if (im->getInputManager()->getReader()->hasKeys(
deviceId, uint32_t(sourceMask), numCodes, codes, flags); deviceId, uint32_t(sourceMask), numCodes, codes, flags)) {
result = JNI_TRUE;
} else {
result = JNI_FALSE;
}
} else { } else {
result = JNI_FALSE; result = JNI_FALSE;
} }
@@ -1082,7 +1086,7 @@ static void handleInputChannelDisposed(JNIEnv* env,
} }
static void nativeRegisterInputChannel(JNIEnv* env, jclass clazz, 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env, 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, static void nativeUnregisterInputChannel(JNIEnv* env, jclass clazz,
jint ptr, jobject inputChannelObj) { jlong ptr, jobject inputChannelObj) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
sp<InputChannel> inputChannel = android_view_InputChannel_getInputChannel(env, 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, static void nativeSetInputFilterEnabled(JNIEnv* env, jclass clazz,
jint ptr, jboolean enabled) { jlong ptr, jboolean enabled) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->getInputManager()->getDispatcher()->setInputFilterEnabled(enabled); im->getInputManager()->getDispatcher()->setInputFilterEnabled(enabled);
} }
static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz, 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) { jint syncMode, jint timeoutMillis, jint policyFlags) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
@@ -1151,7 +1155,7 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz,
return INPUT_EVENT_INJECTION_FAILED; return INPUT_EVENT_INJECTION_FAILED;
} }
return im->getInputManager()->getDispatcher()->injectInputEvent( return (jint) im->getInputManager()->getDispatcher()->injectInputEvent(
& keyEvent, injectorPid, injectorUid, syncMode, timeoutMillis, & keyEvent, injectorPid, injectorUid, syncMode, timeoutMillis,
uint32_t(policyFlags)); uint32_t(policyFlags));
} else if (env->IsInstanceOf(inputEventObj, gMotionEventClassInfo.clazz)) { } else if (env->IsInstanceOf(inputEventObj, gMotionEventClassInfo.clazz)) {
@@ -1161,7 +1165,7 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz,
return INPUT_EVENT_INJECTION_FAILED; return INPUT_EVENT_INJECTION_FAILED;
} }
return im->getInputManager()->getDispatcher()->injectInputEvent( return (jint) im->getInputManager()->getDispatcher()->injectInputEvent(
motionEvent, injectorPid, injectorUid, syncMode, timeoutMillis, motionEvent, injectorPid, injectorUid, syncMode, timeoutMillis,
uint32_t(policyFlags)); uint32_t(policyFlags));
} else { } else {
@@ -1171,35 +1175,35 @@ static jint nativeInjectInputEvent(JNIEnv* env, jclass clazz,
} }
static void nativeSetInputWindows(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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->setInputWindows(env, windowHandleObjArray); im->setInputWindows(env, windowHandleObjArray);
} }
static void nativeSetFocusedApplication(JNIEnv* env, jclass clazz, static void nativeSetFocusedApplication(JNIEnv* env, jclass clazz,
jint ptr, jobject applicationHandleObj) { jlong ptr, jobject applicationHandleObj) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->setFocusedApplication(env, applicationHandleObj); im->setFocusedApplication(env, applicationHandleObj);
} }
static void nativeSetInputDispatchMode(JNIEnv* env, 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->setInputDispatchMode(enabled, frozen); im->setInputDispatchMode(enabled, frozen);
} }
static void nativeSetSystemUiVisibility(JNIEnv* env, static void nativeSetSystemUiVisibility(JNIEnv* env,
jclass clazz, jint ptr, jint visibility) { jclass clazz, jlong ptr, jint visibility) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->setSystemUiVisibility(visibility); im->setSystemUiVisibility(visibility);
} }
static jboolean nativeTransferTouchFocus(JNIEnv* env, 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
sp<InputChannel> fromChannel = sp<InputChannel> fromChannel =
@@ -1208,29 +1212,33 @@ static jboolean nativeTransferTouchFocus(JNIEnv* env,
android_view_InputChannel_getInputChannel(env, toChannelObj); android_view_InputChannel_getInputChannel(env, toChannelObj);
if (fromChannel == NULL || toChannel == NULL) { if (fromChannel == NULL || toChannel == NULL) {
return false; return JNI_FALSE;
} }
return im->getInputManager()->getDispatcher()-> if (im->getInputManager()->getDispatcher()->
transferTouchFocus(fromChannel, toChannel); transferTouchFocus(fromChannel, toChannel)) {
return JNI_TRUE;
} else {
return JNI_FALSE;
}
} }
static void nativeSetPointerSpeed(JNIEnv* env, static void nativeSetPointerSpeed(JNIEnv* env,
jclass clazz, jint ptr, jint speed) { jclass clazz, jlong ptr, jint speed) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->setPointerSpeed(speed); im->setPointerSpeed(speed);
} }
static void nativeSetShowTouches(JNIEnv* env, static void nativeSetShowTouches(JNIEnv* env,
jclass clazz, jint ptr, jboolean enabled) { jclass clazz, jlong ptr, jboolean enabled) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->setShowTouches(enabled); im->setShowTouches(enabled);
} }
static void nativeVibrate(JNIEnv* env, 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) { jint repeat, jint token) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
@@ -1247,7 +1255,7 @@ static void nativeVibrate(JNIEnv* env,
nsecs_t pattern[patternSize]; nsecs_t pattern[patternSize];
for (size_t i = 0; i < patternSize; i++) { for (size_t i = 0; i < patternSize; i++) {
pattern[i] = max(jlong(0), min(patternMillis[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); env->ReleasePrimitiveArrayCritical(patternObj, patternMillis, JNI_ABORT);
@@ -1255,14 +1263,14 @@ static void nativeVibrate(JNIEnv* env,
} }
static void nativeCancelVibrate(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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->getInputManager()->getReader()->cancelVibrate(deviceId, token); im->getInputManager()->getReader()->cancelVibrate(deviceId, token);
} }
static void nativeReloadKeyboardLayouts(JNIEnv* env, static void nativeReloadKeyboardLayouts(JNIEnv* env,
jclass clazz, jint ptr) { jclass clazz, jlong ptr) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->getInputManager()->getReader()->requestRefreshConfiguration( im->getInputManager()->getReader()->requestRefreshConfiguration(
@@ -1270,14 +1278,14 @@ static void nativeReloadKeyboardLayouts(JNIEnv* env,
} }
static void nativeReloadDeviceAliases(JNIEnv* env, static void nativeReloadDeviceAliases(JNIEnv* env,
jclass clazz, jint ptr) { jclass clazz, jlong ptr) {
NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->getInputManager()->getReader()->requestRefreshConfiguration( im->getInputManager()->getReader()->requestRefreshConfiguration(
InputReaderConfiguration::CHANGE_DEVICE_ALIAS); 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
String8 dump; String8 dump;
@@ -1285,7 +1293,7 @@ static jstring nativeDump(JNIEnv* env, jclass clazz, jint ptr) {
return env->NewStringUTF(dump.string()); 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); NativeInputManager* im = reinterpret_cast<NativeInputManager*>(ptr);
im->getInputManager()->getReader()->monitor(); im->getInputManager()->getReader()->monitor();
@@ -1297,54 +1305,54 @@ static void nativeMonitor(JNIEnv* env, jclass clazz, jint ptr) {
static JNINativeMethod gInputManagerMethods[] = { static JNINativeMethod gInputManagerMethods[] = {
/* name, signature, funcPtr */ /* name, signature, funcPtr */
{ "nativeInit", { "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 }, (void*) nativeInit },
{ "nativeStart", "(I)V", { "nativeStart", "(J)V",
(void*) nativeStart }, (void*) nativeStart },
{ "nativeSetDisplayViewport", "(IZIIIIIIIIIIII)V", { "nativeSetDisplayViewport", "(JZIIIIIIIIIIII)V",
(void*) nativeSetDisplayViewport }, (void*) nativeSetDisplayViewport },
{ "nativeGetScanCodeState", "(IIII)I", { "nativeGetScanCodeState", "(JIII)I",
(void*) nativeGetScanCodeState }, (void*) nativeGetScanCodeState },
{ "nativeGetKeyCodeState", "(IIII)I", { "nativeGetKeyCodeState", "(JIII)I",
(void*) nativeGetKeyCodeState }, (void*) nativeGetKeyCodeState },
{ "nativeGetSwitchState", "(IIII)I", { "nativeGetSwitchState", "(JIII)I",
(void*) nativeGetSwitchState }, (void*) nativeGetSwitchState },
{ "nativeHasKeys", "(III[I[Z)Z", { "nativeHasKeys", "(JII[I[Z)Z",
(void*) nativeHasKeys }, (void*) nativeHasKeys },
{ "nativeRegisterInputChannel", { "nativeRegisterInputChannel",
"(ILandroid/view/InputChannel;Lcom/android/server/input/InputWindowHandle;Z)V", "(JLandroid/view/InputChannel;Lcom/android/server/input/InputWindowHandle;Z)V",
(void*) nativeRegisterInputChannel }, (void*) nativeRegisterInputChannel },
{ "nativeUnregisterInputChannel", "(ILandroid/view/InputChannel;)V", { "nativeUnregisterInputChannel", "(JLandroid/view/InputChannel;)V",
(void*) nativeUnregisterInputChannel }, (void*) nativeUnregisterInputChannel },
{ "nativeSetInputFilterEnabled", "(IZ)V", { "nativeSetInputFilterEnabled", "(JZ)V",
(void*) nativeSetInputFilterEnabled }, (void*) nativeSetInputFilterEnabled },
{ "nativeInjectInputEvent", "(ILandroid/view/InputEvent;IIIII)I", { "nativeInjectInputEvent", "(JLandroid/view/InputEvent;IIIII)I",
(void*) nativeInjectInputEvent }, (void*) nativeInjectInputEvent },
{ "nativeSetInputWindows", "(I[Lcom/android/server/input/InputWindowHandle;)V", { "nativeSetInputWindows", "(J[Lcom/android/server/input/InputWindowHandle;)V",
(void*) nativeSetInputWindows }, (void*) nativeSetInputWindows },
{ "nativeSetFocusedApplication", "(ILcom/android/server/input/InputApplicationHandle;)V", { "nativeSetFocusedApplication", "(JLcom/android/server/input/InputApplicationHandle;)V",
(void*) nativeSetFocusedApplication }, (void*) nativeSetFocusedApplication },
{ "nativeSetInputDispatchMode", "(IZZ)V", { "nativeSetInputDispatchMode", "(JZZ)V",
(void*) nativeSetInputDispatchMode }, (void*) nativeSetInputDispatchMode },
{ "nativeSetSystemUiVisibility", "(II)V", { "nativeSetSystemUiVisibility", "(JI)V",
(void*) nativeSetSystemUiVisibility }, (void*) nativeSetSystemUiVisibility },
{ "nativeTransferTouchFocus", "(ILandroid/view/InputChannel;Landroid/view/InputChannel;)Z", { "nativeTransferTouchFocus", "(JLandroid/view/InputChannel;Landroid/view/InputChannel;)Z",
(void*) nativeTransferTouchFocus }, (void*) nativeTransferTouchFocus },
{ "nativeSetPointerSpeed", "(II)V", { "nativeSetPointerSpeed", "(JI)V",
(void*) nativeSetPointerSpeed }, (void*) nativeSetPointerSpeed },
{ "nativeSetShowTouches", "(IZ)V", { "nativeSetShowTouches", "(JZ)V",
(void*) nativeSetShowTouches }, (void*) nativeSetShowTouches },
{ "nativeVibrate", "(II[JII)V", { "nativeVibrate", "(JI[JII)V",
(void*) nativeVibrate }, (void*) nativeVibrate },
{ "nativeCancelVibrate", "(III)V", { "nativeCancelVibrate", "(JII)V",
(void*) nativeCancelVibrate }, (void*) nativeCancelVibrate },
{ "nativeReloadKeyboardLayouts", "(I)V", { "nativeReloadKeyboardLayouts", "(J)V",
(void*) nativeReloadKeyboardLayouts }, (void*) nativeReloadKeyboardLayouts },
{ "nativeReloadDeviceAliases", "(I)V", { "nativeReloadDeviceAliases", "(J)V",
(void*) nativeReloadDeviceAliases }, (void*) nativeReloadDeviceAliases },
{ "nativeDump", "(I)Ljava/lang/String;", { "nativeDump", "(J)Ljava/lang/String;",
(void*) nativeDump }, (void*) nativeDump },
{ "nativeMonitor", "(I)V", { "nativeMonitor", "(J)V",
(void*) nativeMonitor }, (void*) nativeMonitor },
}; };

12
services/jni/com_android_server_input_InputWindowHandle.cpp
View File

@@ -173,7 +173,7 @@ sp<NativeInputWindowHandle> android_server_InputWindowHandle_getHandle(
AutoMutex _l(gHandleMutex); AutoMutex _l(gHandleMutex);
int ptr = env->GetIntField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr); jlong ptr = env->GetLongField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr);
NativeInputWindowHandle* handle; NativeInputWindowHandle* handle;
if (ptr) { if (ptr) {
handle = reinterpret_cast<NativeInputWindowHandle*>(ptr); handle = reinterpret_cast<NativeInputWindowHandle*>(ptr);
@@ -187,8 +187,8 @@ sp<NativeInputWindowHandle> android_server_InputWindowHandle_getHandle(
jweak objWeak = env->NewWeakGlobalRef(inputWindowHandleObj); jweak objWeak = env->NewWeakGlobalRef(inputWindowHandleObj);
handle = new NativeInputWindowHandle(inputApplicationHandle, objWeak); handle = new NativeInputWindowHandle(inputApplicationHandle, objWeak);
handle->incStrong((void*)android_server_InputWindowHandle_getHandle); handle->incStrong((void*)android_server_InputWindowHandle_getHandle);
env->SetIntField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr, env->SetLongField(inputWindowHandleObj, gInputWindowHandleClassInfo.ptr,
reinterpret_cast<int>(handle)); reinterpret_cast<jlong>(handle));
} }
return handle; return handle;
} }
@@ -199,9 +199,9 @@ sp<NativeInputWindowHandle> android_server_InputWindowHandle_getHandle(
static void android_server_InputWindowHandle_nativeDispose(JNIEnv* env, jobject obj) { static void android_server_InputWindowHandle_nativeDispose(JNIEnv* env, jobject obj) {
AutoMutex _l(gHandleMutex); AutoMutex _l(gHandleMutex);
int ptr = env->GetIntField(obj, gInputWindowHandleClassInfo.ptr); jlong ptr = env->GetLongField(obj, gInputWindowHandleClassInfo.ptr);
if (ptr) { if (ptr) {
env->SetIntField(obj, gInputWindowHandleClassInfo.ptr, 0); env->SetLongField(obj, gInputWindowHandleClassInfo.ptr, 0);
NativeInputWindowHandle* handle = reinterpret_cast<NativeInputWindowHandle*>(ptr); NativeInputWindowHandle* handle = reinterpret_cast<NativeInputWindowHandle*>(ptr);
handle->decStrong((void*)android_server_InputWindowHandle_getHandle); 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"); FIND_CLASS(clazz, "com/android/server/input/InputWindowHandle");
GET_FIELD_ID(gInputWindowHandleClassInfo.ptr, clazz, GET_FIELD_ID(gInputWindowHandleClassInfo.ptr, clazz,
"ptr", "I"); "ptr", "J");
GET_FIELD_ID(gInputWindowHandleClassInfo.inputApplicationHandle, GET_FIELD_ID(gInputWindowHandleClassInfo.inputApplicationHandle,
clazz, clazz,

57
services/jni/com_android_server_location_GpsLocationProvider.cpp
View File

@@ -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) { 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) 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 // fail if the main interface fails to initialize
if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != 0) if (!sGpsInterface || sGpsInterface->init(&sGpsCallbacks) != 0)
return false; return JNI_FALSE;
// if XTRA initialization fails we will disable it by sGpsXtraInterface to NULL, // if XTRA initialization fails we will disable it by sGpsXtraInterface to NULL,
// but continue to allow the rest of the GPS interface to work. // 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) if (sGpsGeofencingInterface)
sGpsGeofencingInterface->init(&sGpsGeofenceCallbacks); sGpsGeofencingInterface->init(&sGpsGeofenceCallbacks);
return true; return JNI_FALSE;
} }
static void android_location_GpsLocationProvider_cleanup(JNIEnv* env, jobject obj) 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, 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) jint mode, jint recurrence, jint min_interval, jint preferred_accuracy, jint preferred_time)
{ {
if (sGpsInterface) if (sGpsInterface) {
return (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy, if (sGpsInterface->set_position_mode(mode, recurrence, min_interval, preferred_accuracy,
preferred_time) == 0); preferred_time) == 0) {
return JNI_TRUE;
} else {
return JNI_FALSE;
}
}
else else
return false; return JNI_FALSE;
} }
static jboolean android_location_GpsLocationProvider_start(JNIEnv* env, jobject obj) static jboolean android_location_GpsLocationProvider_start(JNIEnv* env, jobject obj)
{ {
if (sGpsInterface) if (sGpsInterface) {
return (sGpsInterface->start() == 0); if (sGpsInterface->start() == 0) {
return JNI_TRUE;
} else {
return JNI_FALSE;
}
}
else else
return false; return JNI_FALSE;
} }
static jboolean android_location_GpsLocationProvider_stop(JNIEnv* env, jobject obj) static jboolean android_location_GpsLocationProvider_stop(JNIEnv* env, jobject obj)
{ {
if (sGpsInterface) if (sGpsInterface) {
return (sGpsInterface->stop() == 0); if (sGpsInterface->stop() == 0) {
return JNI_TRUE;
} else {
return JNI_FALSE;
}
}
else else
return false; return JNI_FALSE;
} }
static void android_location_GpsLocationProvider_delete_aiding_data(JNIEnv* env, jobject obj, jint flags) 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(elevArray, elev, 0);
env->ReleaseFloatArrayElements(azumArray, azim, 0); env->ReleaseFloatArrayElements(azumArray, azim, 0);
env->ReleaseIntArrayElements(maskArray, mask, 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, 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; length = buffer_size;
memcpy(nmea, sNmeaString, length); memcpy(nmea, sNmeaString, length);
env->ReleasePrimitiveArrayCritical(nmeaArray, nmea, JNI_ABORT); env->ReleasePrimitiveArrayCritical(nmeaArray, nmea, JNI_ABORT);
return length; return (jint) length;
} }
static void android_location_GpsLocationProvider_inject_time(JNIEnv* env, jobject obj, 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) 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, 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, 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) { if (sAGpsRilInterface && sAGpsRilInterface->update_network_state) {