自学教程：C++ AKeyEvent_getKeyCode函数代码示例

/** * Convert an Android key event to ASCII. */static unsigned char key_ascii(struct android_app* app, AInputEvent* event) {  int32_t code = AKeyEvent_getKeyCode(event);  /* Handle a few special cases: */  switch (code) {  case AKEYCODE_DEL:    return 8;  case AKEYCODE_FORWARD_DEL:    return 127;  case AKEYCODE_ESCAPE:    return 27;  }  /* Get usable JNI context */  JNIEnv* env = app->activity->env;  JavaVM* vm = app->activity->vm;  (*vm)->AttachCurrentThread(vm, &env, NULL);  jclass KeyEventClass = (*env)->FindClass(env, "android/view/KeyEvent");  jmethodID KeyEventConstructor = (*env)->GetMethodID(env, KeyEventClass, "<init>", "(II)V");  jobject keyEvent = (*env)->NewObject(env, KeyEventClass, KeyEventConstructor,				       AKeyEvent_getAction(event), AKeyEvent_getKeyCode(event));  jmethodID KeyEvent_getUnicodeChar = (*env)->GetMethodID(env, KeyEventClass, "getUnicodeChar", "(I)I");  int ascii = (*env)->CallIntMethod(env, keyEvent, KeyEvent_getUnicodeChar, AKeyEvent_getMetaState(event));  /* LOGI("getUnicodeChar(%d) = %d ('%c')", AKeyEvent_getKeyCode(event), ascii, ascii); */  return ascii;}

    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;    }

static int32_t input(struct android_app * app, AInputEvent * e) {    int handled = 1;    int kc;    cvkey cvkc;    int action;    switch (AInputEvent_getType(e)) {    case AINPUT_EVENT_TYPE_KEY:        kc = AKeyEvent_getKeyCode(e);        action = AKeyEvent_getAction(e);        cvkc = mapkey(kc);        handled = kc != CVK_NONE;        if (handled) {            if (action == AKEY_EVENT_ACTION_DOWN)                cvInject(CVE_DOWN, cvkc, 0);            if (action == AKEY_EVENT_ACTION_UP)                cvInject(CVE_UP, cvkc, 0);        }        break;    case AINPUT_EVENT_TYPE_MOTION:        cvInject(CVE_MOTION,                 AMotionEvent_getX(e, 0), AMotionEvent_getY(e, 0));        break;    default:        handled = 0;    }    return handled;}

static bool _process_keys(bool isJoy, AInputEvent *event, CookedEventCallback callback) {    if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY) {        int action = AKeyEvent_getAction(event);        int code = _translate_keycode(AKeyEvent_getKeyCode(event));        bool handled = code >= 0;        if (code >= 0 && action == AKEY_EVENT_ACTION_DOWN) {            _report_key_state(code, true, callback);        } else if (code >= 0 && action == AKEY_EVENT_ACTION_UP) {            _report_key_state(code, false, callback);        }        return handled;    } else if (isJoy) {        // use joystick axes to emulate directional key events (we could leave this        // up to the platform, but joystick-to-dpad conversion doesn't work        // on NDK on older devices,  so we implement manually for maximum compatibility)        float x = AMotionEvent_getX(event, 0);        float y = AMotionEvent_getY(event, 0);        if (_getAxisValue) {            // take the hat switches into account too, so that either the            // regular axes or the hat axes can be used to navigate UIs            x += _getAxisValue(event, AXIS_HAT_X, 0);            y += _getAxisValue(event, AXIS_HAT_Y, 0);            x = Clamp(x, -1.0f, 1.0f);            y = Clamp(y, -1.0f, 1.0f);        }        _report_key_states_from_axes(x, y, callback);        return true;    }}

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;	}}

bool CookEvent(AInputEvent *event, CookedEventCallback callback) {    int type = AInputEvent_getType(event);    int src = AInputEvent_getSource(event);    bool isJoy = (type == AINPUT_EVENT_TYPE_MOTION) && (src & AINPUT_SOURCE_CLASS_MASK) ==            SOURCE_CLASS_JOYSTICK;    if (!_init_done) {        _init();        _init_done = true;    }    if (isJoy) {        return CookEvent_Joy(event, callback);    } else if (type == AINPUT_EVENT_TYPE_KEY) {        bool handled = _process_keys(false, event, callback);        if (AKeyEvent_getKeyCode(event) == AKEYCODE_BACK && 0 == AKeyEvent_getAction(event)) {            // back key was pressed            struct CookedEvent ev;            memset(&ev, 0, sizeof(ev));            ev.type = COOKED_EVENT_TYPE_BACK;            return callback(&ev);        }        // Note: if you want to handle other keys, add code here. For now we only        // handle DPAD keys as indicated in _process_keys.        return handled;    } else if (type == AINPUT_EVENT_TYPE_MOTION) {        return CookEvent_Motion(event, callback);    }    return false;}

/***  @brief*    Call this to process the next key input event*/void AndroidKeyboardDevice::OnKeyInputEvent(const struct AInputEvent &cAKeyInputEvent){	// Check if input device is valid	if (m_pDevice) {		// Get Android key code		const int32_t nKeyCode = AKeyEvent_getKeyCode(&cAKeyInputEvent);		// Lookout! The virtual keyboard of Android sends "down" and "up" directly one after another		// -> This is really a problem and we have to delay further keys...		if (m_lstProcessedKeys.IsElement(nKeyCode)) {			// Add key for later processing			KeyInfo sKeyInfo;			sKeyInfo.nKeyCode = nKeyCode;			sKeyInfo.bPressed = (AKeyEvent_getAction(&cAKeyInputEvent) == AKEY_EVENT_ACTION_DOWN);			m_lstDelayedKeys.Add(sKeyInfo);		} else {			// Get keyboard device			Keyboard *pKeyboard = static_cast<Keyboard*>(m_pDevice);			// Get button			Button *pButton = GetKeyboardKey(*pKeyboard, nKeyCode);			if (pButton) {				// Get button state				const bool bPressed = (AKeyEvent_getAction(&cAKeyInputEvent) == AKEY_EVENT_ACTION_DOWN);				// Propagate changes				if (pButton->IsPressed() != bPressed)					pButton->SetPressed(bPressed);			}			// Add this key to the processed keys			m_lstProcessedKeys.Add(nKeyCode);		}	}}

	event_result message_dispatcher::fire_on_dpad(app& the_app, AInputEvent *ie)	{		int kcode = AKeyEvent_getKeyCode(ie);		int type = AKeyEvent_getAction(ie);		bool h = false;		switch (kcode) {		case AKEYCODE_DPAD_UP:			h = the_app.on_dpad_up(type == AKEY_EVENT_ACTION_DOWN ? button_event::down : button_event::up);			break;		case AKEYCODE_DPAD_DOWN:			h = the_app.on_dpad_down(type == AKEY_EVENT_ACTION_DOWN ? button_event::down : button_event::up);			break;		case AKEYCODE_DPAD_LEFT:			h = the_app.on_dpad_left(type == AKEY_EVENT_ACTION_DOWN ? button_event::down : button_event::up);			break;		case AKEYCODE_DPAD_RIGHT:			h = the_app.on_dpad_right(type == AKEY_EVENT_ACTION_DOWN ? button_event::down : button_event::up);			break;		case AKEYCODE_DPAD_CENTER:			h = the_app.on_dpad_center(type == AKEY_EVENT_ACTION_DOWN ? button_event::down : button_event::up);			break;		default:			break;		}		return h ? event_result::handled : event_result::unhandled;	}

///// キ
C++ ALCcontext_DecRef函数代码示例
C++ AKLOGE函数代码示例