int32_t handle_input_events(struct android_app* app, AInputEvent* event) { int etype = AInputEvent_getType(event); switch (etype) { case AINPUT_EVENT_TYPE_KEY: int32_t eaction, eflags, ekeycode, escancode; eaction = AKeyEvent_getAction(event); eflags = AKeyEvent_getFlags(event); ekeycode = AKeyEvent_getKeyCode(event); // LOGI(2, "%s", get_key_event_str(eaction, eflags, ekeycode)); break; case AINPUT_EVENT_TYPE_MOTION: int32_t action, posX, pointer_index; action = AMotionEvent_getAction(event); pointer_index = (action&AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT; posX = AMotionEvent_getX(event, pointer_index); //write a command to the activity lifecycle event queue (pipe) if (action == AMOTION_EVENT_ACTION_MOVE) { int xMove = posX - mPreviousX; USERDATA* userData = (USERDATA*)app->userData; userData->xMove = xMove; app->redrawNeeded = 1; } mPreviousX = posX; // LOGI(2, "action: %d, posX: %d, mPreviousX: %d, posX: %d", action, posX, mPreviousX, posX); break; default: LOGI(2, "other input event"); break; } }
int WindowImplAndroid::getUnicode(AInputEvent* event) { // Retrieve activity states ActivityStates* states = getActivity(NULL); Lock lock(states->mutex); // Initializes JNI jint lResult; jint lFlags = 0; JavaVM* lJavaVM = states->activity->vm; JNIEnv* lJNIEnv = states->activity->env; JavaVMAttachArgs lJavaVMAttachArgs; lJavaVMAttachArgs.version = JNI_VERSION_1_6; lJavaVMAttachArgs.name = "NativeThread"; lJavaVMAttachArgs.group = NULL; lResult=lJavaVM->AttachCurrentThread(&lJNIEnv, &lJavaVMAttachArgs); if (lResult == JNI_ERR) err() << "Failed to initialize JNI, couldn't get the Unicode value" << std::endl; // Retrieve key data from the input event jlong downTime = AKeyEvent_getDownTime(event); jlong eventTime = AKeyEvent_getEventTime(event); jint action = AKeyEvent_getAction(event); jint code = AKeyEvent_getKeyCode(event); jint repeat = AKeyEvent_getRepeatCount(event); // not sure! jint metaState = AKeyEvent_getMetaState(event); jint deviceId = AInputEvent_getDeviceId(event); jint scancode = AKeyEvent_getScanCode(event); jint flags = AKeyEvent_getFlags(event); jint source = AInputEvent_getSource(event); // Construct a KeyEvent object from the event data jclass ClassKeyEvent = lJNIEnv->FindClass("android/view/KeyEvent"); jmethodID KeyEventConstructor = lJNIEnv->GetMethodID(ClassKeyEvent, "<init>", "(JJIIIIIIII)V"); jobject ObjectKeyEvent = lJNIEnv->NewObject(ClassKeyEvent, KeyEventConstructor, downTime, eventTime, action, code, repeat, metaState, deviceId, scancode, flags, source); // Call its getUnicodeChar() method to get the Unicode value jmethodID MethodGetUnicode = lJNIEnv->GetMethodID(ClassKeyEvent, "getUnicodeChar", "(I)I"); int unicode = lJNIEnv->CallIntMethod(ObjectKeyEvent, MethodGetUnicode, metaState); lJNIEnv->DeleteLocalRef(ClassKeyEvent); lJNIEnv->DeleteLocalRef(ObjectKeyEvent); // Detach this thread from the JVM lJavaVM->DetachCurrentThread(); return unicode; }
bool InputService::onKeyboardEvent(AInputEvent* pEvent) { #ifdef INPUTSERVICE_LOG_EVENTS packt_Log_debug("AKeyEvent_getAction=%d", AKeyEvent_getAction(pEvent)); packt_Log_debug("AKeyEvent_getFlags=%d", AKeyEvent_getFlags(pEvent)); packt_Log_debug("AKeyEvent_getKeyCode=%d", AKeyEvent_getKeyCode(pEvent)); packt_Log_debug("AKeyEvent_getScanCode=%d", AKeyEvent_getScanCode(pEvent)); packt_Log_debug("AKeyEvent_getMetaState=%d", AKeyEvent_getMetaState(pEvent)); packt_Log_debug("AKeyEvent_getRepeatCount=%d", AKeyEvent_getRepeatCount(pEvent)); packt_Log_debug("AKeyEvent_getDownTime=%lld", AKeyEvent_getDownTime(pEvent)); packt_Log_debug("AKeyEvent_getEventTime=%lld", AKeyEvent_getEventTime(pEvent)); #endif const float ORTHOGONAL_MOVE = 1.0f; if (AKeyEvent_getAction(pEvent) == AKEY_EVENT_ACTION_DOWN) { switch (AKeyEvent_getKeyCode(pEvent)) { case AKEYCODE_DPAD_LEFT: mHorizontal = -ORTHOGONAL_MOVE; break; case AKEYCODE_DPAD_RIGHT: mHorizontal = ORTHOGONAL_MOVE; break; case AKEYCODE_DPAD_DOWN: mVertical = -ORTHOGONAL_MOVE; break; case AKEYCODE_DPAD_UP: mVertical = ORTHOGONAL_MOVE; break; case AKEYCODE_BACK: return false; } } else { switch (AKeyEvent_getKeyCode(pEvent)) { case AKEYCODE_DPAD_LEFT: case AKEYCODE_DPAD_RIGHT: mHorizontal = 0.0f; break; case AKEYCODE_DPAD_DOWN: case AKEYCODE_DPAD_UP: mVertical = 0.0f; break; case AKEYCODE_MENU: mMenuKey = true; break; case AKEYCODE_BACK: return false; } } return true; }
extern "C" int AndroidGetKeyText( AInputEvent *event ) { int result = 0; // Attaches the current thread to the JVM. jint lResult; jint lFlags = 0; JavaVM* lJavaVM = engine.app->activity->vm; JNIEnv* lJNIEnv = engine.app->activity->env; JavaVMAttachArgs lJavaVMAttachArgs; lJavaVMAttachArgs.version = JNI_VERSION_1_6; lJavaVMAttachArgs.name = "NativeThread"; lJavaVMAttachArgs.group = NULL; lResult=lJavaVM->AttachCurrentThread(&lJNIEnv, &lJavaVMAttachArgs); if (lResult == JNI_ERR) { return 0; } // Retrieves NativeActivity. jobject lNativeActivity = engine.app->activity->clazz; jclass ClassNativeActivity = lJNIEnv->GetObjectClass(lNativeActivity); jmethodID MethodSetFlags = lJNIEnv->GetMethodID( ClassNativeActivity, "getKeyText", "(JJIIIIIII)I"); lprintf( "..." ); if( MethodSetFlags ) result = lJNIEnv->CallIntMethod( lNativeActivity, MethodSetFlags , AKeyEvent_getDownTime(event) , AKeyEvent_getEventTime(event) , AKeyEvent_getAction(event) , AKeyEvent_getKeyCode(event) , AKeyEvent_getRepeatCount(event) , AKeyEvent_getMetaState(event) , AInputEvent_getDeviceId(event) , AKeyEvent_getScanCode(event) , AKeyEvent_getFlags(event) ); else { lprintf( "Failed to get method." ); result = 0; } // Finished with the JVM. lJavaVM->DetachCurrentThread(); return result; }
static int32_t handle_key_event(struct android_app* app, AInputEvent* event) { struct engine* engine = (struct engine*)app->userData; int32_t action = AKeyEvent_getAction(event); int32_t keyCode = AKeyEvent_getKeyCode(event); int32_t scanCode = AKeyEvent_getScanCode(event); int32_t flags = AKeyEvent_getFlags(event); if (action == AKEY_EVENT_ACTION_DOWN) { return onWindowKeyDown(keyCode, scanCode) ? 0 : 1; } else if (action == AKEY_EVENT_ACTION_UP) { if ((flags & AKEY_EVENT_FLAG_CANCELED) == 0) { return onWindowKeyUp(keyCode, scanCode) ? 0 : 1; } } else if (action == AKEY_EVENT_ACTION_MULTIPLE) { LOGI("AKEY_EVENT_ACTION_MULTIPLE received"); } return 0; }
bool AndroidGameApplication::onKeyEvent(AInputEvent* event) { int32 action = AKeyEvent_getAction(event); int32 flags = AKeyEvent_getFlags(event); int32 keyCode = AKeyEvent_getKeyCode(event); int32 scanCode = AKeyEvent_getScanCode(event); int32 state = AKeyEvent_getMetaState(event); int32 repeatCount = AKeyEvent_getRepeatCount(event); LOGI("AndroidGameApplication::onKeyEvent"); switch(action) { case AKEY_EVENT_ACTION_DOWN: { LOGI("AKEY_EVENT_ACTION_DOWN [keyCode = %d, scanCode = %d, repeatCount = %d, flags = 0x%X, state = 0x%X]", keyCode, scanCode, repeatCount, flags, state); for(std::list<IKeyboardController*>::iterator it = m_keyboardInputHandlers.begin(); it != m_keyboardInputHandlers.end(); ++it) { (*it)->onKeyDown(keyCode, flags); } } break; case AKEY_EVENT_ACTION_UP: { LOGI("AKEY_EVENT_ACTION_DOWN [keyCode = %d, scanCode = %d, repeatCount = %d, flags = 0x%X, state = 0x%X]", keyCode, scanCode, repeatCount, flags, state); for(std::list<IKeyboardController*>::iterator it = m_keyboardInputHandlers.begin(); it != m_keyboardInputHandlers.end(); ++it) { (*it)->onKeyUp(keyCode, flags); } } break; } return true; }
bool OuyaInputView::dispatchKeyEvent(AInputEvent* keyEvent) { int64_t downTime = AKeyEvent_getDownTime(keyEvent); int64_t eventTime = AKeyEvent_getEventTime(keyEvent); int32_t action = AKeyEvent_getAction(keyEvent); int32_t code = AKeyEvent_getKeyCode(keyEvent); int32_t repeat = AKeyEvent_getRepeatCount(keyEvent); int32_t metaState = AKeyEvent_getMetaState(keyEvent); int32_t deviceId = AInputEvent_getDeviceId(keyEvent); int32_t scancode = AKeyEvent_getScanCode(keyEvent); int32_t flags = AKeyEvent_getFlags(keyEvent); int32_t source = AInputEvent_getSource(keyEvent); #if ENABLE_VERBOSE_LOGGING __android_log_print(ANDROID_LOG_VERBOSE, LOG_TAG, "downTime=%lld eventTime=%lld action=%d code=%d repeat=%d metaState=%d deviceId=%d scancode=%d flags=%d source=%d", downTime, eventTime, action, code, repeat, metaState, deviceId, scancode, flags, source); #endif return javaDispatchKeyEvent(downTime, eventTime, action, code, repeat, metaState, deviceId, scancode, flags, source); }
bool CAndroidKey::onKeyboardEvent(AInputEvent *event) { if (event == NULL) return false; int32_t flags = AKeyEvent_getFlags(event); int32_t state = AKeyEvent_getMetaState(event); int32_t action = AKeyEvent_getAction(event); int32_t repeat = AKeyEvent_getRepeatCount(event); int32_t keycode = AKeyEvent_getKeyCode(event); int32_t deviceId = AInputEvent_getDeviceId(event); CJNIKeyCharacterMap map = CJNIKeyCharacterMap::load(deviceId); uint16_t unicode = map.get(keycode, state); // Check if we got some special key uint16_t sym = XBMCK_UNKNOWN; for (unsigned int index = 0; index < sizeof(keyMap) / sizeof(KeyMap); index++) { if (keycode == keyMap[index].nativeKey) { sym = keyMap[index].xbmcKey; break; } } if (m_handleMediaKeys) { for (unsigned int index = 0; index < sizeof(MediakeyMap) / sizeof(KeyMap); index++) { if (keycode == MediakeyMap[index].nativeKey) { sym = MediakeyMap[index].xbmcKey; break; } } } // check if this is a key we don't want to handle if (sym == XBMCK_LAST || sym == XBMCK_UNKNOWN) { CXBMCApp::android_printf("CAndroidKey: key ignored (code: %d)", keycode); return false; } uint16_t modifiers = 0; if (state & AMETA_ALT_LEFT_ON) modifiers |= XBMCKMOD_LALT; if (state & AMETA_ALT_RIGHT_ON) modifiers |= XBMCKMOD_RALT; if (state & AMETA_SHIFT_LEFT_ON) modifiers |= XBMCKMOD_LSHIFT; if (state & AMETA_SHIFT_RIGHT_ON) modifiers |= XBMCKMOD_RSHIFT; if (state & AMETA_CTRL_LEFT_ON) modifiers |= XBMCKMOD_LCTRL; if (state & AMETA_CTRL_RIGHT_ON) modifiers |= XBMCKMOD_RCTRL; /* TODO: if (state & AMETA_SYM_ON) modifiers |= 0x000?;*/ switch (action) { case AKEY_EVENT_ACTION_DOWN: #if 1 CXBMCApp::android_printf("CAndroidKey: key down (code: %d; repeat: %d; flags: 0x%0X; alt: %s; shift: %s; sym: %s)", keycode, repeat, flags, (state & AMETA_ALT_ON) ? "yes" : "no", (state & AMETA_SHIFT_ON) ? "yes" : "no", (state & AMETA_SYM_ON) ? "yes" : "no"); #endif XBMC_Key((uint8_t)keycode, sym, modifiers, unicode, false); return true; case AKEY_EVENT_ACTION_UP: #if 1 CXBMCApp::android_printf("CAndroidKey: key up (code: %d; repeat: %d; flags: 0x%0X; alt: %s; shift: %s; sym: %s)", keycode, repeat, flags, (state & AMETA_ALT_ON) ? "yes" : "no", (state & AMETA_SHIFT_ON) ? "yes" : "no", (state & AMETA_SYM_ON) ? "yes" : "no"); #endif XBMC_Key((uint8_t)keycode, sym, modifiers, unicode, true); return true; case AKEY_EVENT_ACTION_MULTIPLE: #if 1 CXBMCApp::android_printf("CAndroidKey: key multiple (code: %d; repeat: %d; flags: 0x%0X; alt: %s; shift: %s; sym: %s)", keycode, repeat, flags, (state & AMETA_ALT_ON) ? "yes" : "no", (state & AMETA_SHIFT_ON) ? "yes" : "no", (state & AMETA_SYM_ON) ? "yes" : "no"); #endif break; default: #if 1 CXBMCApp::android_printf("CAndroidKey: unknown key (code: %d; repeat: %d; flags: 0x%0X; alt: %s; shift: %s; sym: %s)", keycode, repeat, flags, (state & AMETA_ALT_ON) ? "yes" : "no", (state & AMETA_SHIFT_ON) ? "yes" : "no", (state & AMETA_SYM_ON) ? "yes" : "no"); #endif break; } return false; }
bool CAndroidKey::onKeyboardEvent(AInputEvent* event) { CXBMCApp::android_printf("%s", __PRETTY_FUNCTION__); if (event == NULL) return false; int32_t keycode = AKeyEvent_getKeyCode(event); int32_t flags = AKeyEvent_getFlags(event); int32_t state = AKeyEvent_getMetaState(event); int32_t repeatCount = AKeyEvent_getRepeatCount(event); // Check if we got some special key uint16_t sym = XBMCK_UNKNOWN; for (unsigned int index = 0; index < sizeof(keyMap) / sizeof(KeyMap); index++) { if (keycode == keyMap[index].nativeKey) { sym = keyMap[index].xbmcKey; break; } } // check if this is a key we don't want to handle if (sym == XBMCK_LAST) return false; uint16_t modifiers = 0; if (state & AMETA_ALT_LEFT_ON) modifiers |= XBMCKMOD_LALT; if (state & AMETA_ALT_RIGHT_ON) modifiers |= XBMCKMOD_RALT; if (state & AMETA_SHIFT_LEFT_ON) modifiers |= XBMCKMOD_LSHIFT; if (state & AMETA_SHIFT_RIGHT_ON) modifiers |= XBMCKMOD_RSHIFT; /* TODO: if (state & AMETA_SYM_ON) modifiers |= 0x000?;*/ switch (AKeyEvent_getAction(event)) { case AKEY_EVENT_ACTION_DOWN: CXBMCApp::android_printf("CXBMCApp: key down (code: %d; repeat: %d; flags: 0x%0X; alt: %s; shift: %s; sym: %s)", keycode, repeatCount, flags, (state & AMETA_ALT_ON) ? "yes" : "no", (state & AMETA_SHIFT_ON) ? "yes" : "no", (state & AMETA_SYM_ON) ? "yes" : "no"); XBMC_Key((uint8_t)keycode, sym, modifiers, false); return true; case AKEY_EVENT_ACTION_UP: CXBMCApp::android_printf("CXBMCApp: key up (code: %d; repeat: %d; flags: 0x%0X; alt: %s; shift: %s; sym: %s)", keycode, repeatCount, flags, (state & AMETA_ALT_ON) ? "yes" : "no", (state & AMETA_SHIFT_ON) ? "yes" : "no", (state & AMETA_SYM_ON) ? "yes" : "no"); XBMC_Key((uint8_t)keycode, sym, modifiers, true); return true; case AKEY_EVENT_ACTION_MULTIPLE: CXBMCApp::android_printf("CXBMCApp: key multiple (code: %d; repeat: %d; flags: 0x%0X; alt: %s; shift: %s; sym: %s)", keycode, repeatCount, flags, (state & AMETA_ALT_ON) ? "yes" : "no", (state & AMETA_SHIFT_ON) ? "yes" : "no", (state & AMETA_SYM_ON) ? "yes" : "no"); break; default: CXBMCApp::android_printf("CXBMCApp: unknown key (code: %d; repeat: %d; flags: 0x%0X; alt: %s; shift: %s; sym: %s)", keycode, repeatCount, flags, (state & AMETA_ALT_ON) ? "yes" : "no", (state & AMETA_SHIFT_ON) ? "yes" : "no", (state & AMETA_SYM_ON) ? "yes" : "no"); break; } return false; }