int32_t cxAndroid::HandleMotionInput(AInputEvent* event)
{
cxInt action = AMotionEvent_getAction(event);
cxInt atype = action & AMOTION_EVENT_ACTION_MASK;
switch (atype) {
case AMOTION_EVENT_ACTION_POINTER_DOWN:{
cxInt idx = action >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
cxTouchId id = AMotionEvent_getPointerId(event, idx);
cxFloat x = AMotionEvent_getX(event, idx);
cxFloat y = AMotionEvent_getY(event, idx);
cxEngine::Instance()->Dispatch(id, cxTouchPoint::Began, x, y);
break;
}
case AMOTION_EVENT_ACTION_POINTER_UP:{
cxInt idx = action >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
cxTouchId id = AMotionEvent_getPointerId(event, idx);
cxFloat x = AMotionEvent_getX(event, idx);
cxFloat y = AMotionEvent_getY(event, idx);
cxEngine::Instance()->Dispatch(id, cxTouchPoint::Ended, x, y);
break;
}
case AMOTION_EVENT_ACTION_MOVE:{
cxInt count = (cxInt)AMotionEvent_getPointerCount(event);
for(cxInt i=0; i < count; i++){
cxTouchId id = AMotionEvent_getPointerId(event, i);
cxFloat x = AMotionEvent_getX(event, i);
cxFloat y =AMotionEvent_getY(event, i);
cxEngine::Instance()->Dispatch(id, cxTouchPoint::Moved, x, y);
}
break;
}
case AMOTION_EVENT_ACTION_DOWN:{
cxInt count = (cxInt)AMotionEvent_getPointerCount(event);
for(cxInt i=0; i < count; i++){
cxTouchId id = AMotionEvent_getPointerId(event, i);
cxFloat x = AMotionEvent_getX(event, i);
cxFloat y =AMotionEvent_getY(event, i);
cxEngine::Instance()->Dispatch(id, cxTouchPoint::Began, x, y);
}
break;
}
case AMOTION_EVENT_ACTION_UP:{
cxInt count = (cxInt)AMotionEvent_getPointerCount(event);
for(cxInt i=0; i < count; i++){
cxTouchId id = AMotionEvent_getPointerId(event, i);
cxFloat x = AMotionEvent_getX(event, i);
cxFloat y =AMotionEvent_getY(event, i);
cxEngine::Instance()->Dispatch(id, cxTouchPoint::Ended, x, y);
}
break;
}
}
return 0;
}
void UpdateTouchPositions(int32 phase, AInputEvent* event)
{
int32 numEvents = AMotionEvent_getPointerCount(event);
for (int32 index = 0; index < numEvents; ++index)
{
int32 id = AMotionEvent_getPointerId(event, index);
bool isFound = false;
for(int32 touchIndex = 0; touchIndex < (int32)activeTouches.size(); ++touchIndex)
{
if(id == activeTouches[touchIndex].tid)
{
FillEventData(activeTouches[touchIndex], phase, event, index);
isFound = true;
break;
}
}
if(!isFound)
{
UIEvent uiEvent;
FillEventData(uiEvent, phase, event, index);
uiEvent.tid = id;
activeTouches.push_back(uiEvent);
}
}
ProcessTouches(phase);
}
//--------------------------------------------------------------------------------
// TapDetector
//--------------------------------------------------------------------------------
GESTURE_STATE TapDetector::Detect(const AInputEvent* motion_event) {
if (AMotionEvent_getPointerCount(motion_event) > 1) {
// Only support single touch
return false;
}
int32_t action = AMotionEvent_getAction(motion_event);
unsigned int flags = action & AMOTION_EVENT_ACTION_MASK;
switch (flags) {
case AMOTION_EVENT_ACTION_DOWN:
down_pointer_id_ = AMotionEvent_getPointerId(motion_event, 0);
down_x_ = AMotionEvent_getX(motion_event, 0);
down_y_ = AMotionEvent_getY(motion_event, 0);
break;
case AMOTION_EVENT_ACTION_UP: {
int64_t eventTime = AMotionEvent_getEventTime(motion_event);
int64_t downTime = AMotionEvent_getDownTime(motion_event);
if (eventTime - downTime <= TAP_TIMEOUT) {
if (down_pointer_id_ == AMotionEvent_getPointerId(motion_event, 0)) {
float x = AMotionEvent_getX(motion_event, 0) - down_x_;
float y = AMotionEvent_getY(motion_event, 0) - down_y_;
if (x * x + y * y < TOUCH_SLOP * TOUCH_SLOP * dp_factor_) {
LOGI("TapDetector: Tap detected");
return GESTURE_STATE_ACTION;
}
}
}
break;
}
}
return GESTURE_STATE_NONE;
}
void rAndroidInputManager::ProcessMoveEvent(AInputEvent* event){
int pointerCount = AMotionEvent_getPointerCount(event);
for (int index = 0; index < pointerCount; index++){
UpdateTouchEvent(index, rTOUCH_MOVE, event);
}
}
//--------------------------------------------------------------------------------
// DoubletapDetector
//--------------------------------------------------------------------------------
GESTURE_STATE DoubletapDetector::Detect(const AInputEvent* motion_event) {
if (AMotionEvent_getPointerCount(motion_event) > 1) {
// Only support single double tap
return false;
}
bool tap_detected = tap_detector_.Detect(motion_event);
int32_t action = AMotionEvent_getAction(motion_event);
unsigned int flags = action & AMOTION_EVENT_ACTION_MASK;
switch (flags) {
case AMOTION_EVENT_ACTION_DOWN: {
int64_t eventTime = AMotionEvent_getEventTime(motion_event);
if (eventTime - last_tap_time_ <= DOUBLE_TAP_TIMEOUT) {
float x = AMotionEvent_getX(motion_event, 0) - last_tap_x_;
float y = AMotionEvent_getY(motion_event, 0) - last_tap_y_;
if (x * x + y * y < DOUBLE_TAP_SLOP * DOUBLE_TAP_SLOP * dp_factor_) {
LOGI("DoubletapDetector: Doubletap detected");
return GESTURE_STATE_ACTION;
}
}
break;
}
case AMOTION_EVENT_ACTION_UP:
if (tap_detected) {
last_tap_time_ = AMotionEvent_getEventTime(motion_event);
last_tap_x_ = AMotionEvent_getX(motion_event, 0);
last_tap_y_ = AMotionEvent_getY(motion_event, 0);
}
break;
}
return GESTURE_STATE_NONE;
}
/**
* Process the next input event.
*/
static int32_t handle_motion_event(struct android_app* app, AInputEvent* event)
{
struct engine* engine = (struct engine*)app->userData;
int i, c = AMotionEvent_getPointerCount(event);
for( i = 0; i<c; i++) {
int32_t action = AMotionEvent_getAction(event);
uint32_t id = action >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
uint32_t index = AMotionEvent_getPointerId(event, i);
float x = AMotionEvent_getX(event, i);
float y = AMotionEvent_getY(event, i);
action = action & AMOTION_EVENT_ACTION_MASK;
if (action == AMOTION_EVENT_ACTION_DOWN) {
/* Workaround, these are needed in order to
dispatch GK_ON_MOUSE_DOWN. The problem is that
the library assumes that the 'mouse' is moved over
a panel, before it's pressed.
In case of thouchscreen the 'press' event happens before
the 'move' which results in wrong/invalid gkMouseTarget.
The mouse down event is dispatched ON the gkMouseTarget.
*/
onWindowMouseMove(x,y);
gkUpdateMouseTarget(gkMainPanel);
gkCheckFocusedPanel();
onWindowMouseDown(x,y,index);
}else if (action == AMOTION_EVENT_ACTION_MOVE) {
onWindowMouseMove(x,y);
}else if (action == AMOTION_EVENT_ACTION_UP) {
onWindowMouseUp(x,y,index);
}
__android_log_print(ANDROID_LOG_INFO, "GK", "action: %d index: %d id: %d i: %d", action, index, id, i);
}
return 1;
}
int32_t Engine::onMotionEvent(android_app* app, AInputEvent* event) {
if (!this->loaded) return 0;
if (!this->focused) return 0;
size_t pointerCount = AMotionEvent_getPointerCount(event);
this->updateUptime();
for (size_t i = 0; i < pointerCount; i++) {
size_t pointerId = AMotionEvent_getPointerId(event, i);
size_t action = AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_MASK;
size_t pointerIndex = i;
if (action == AMOTION_EVENT_ACTION_POINTER_DOWN || action == AMOTION_EVENT_ACTION_POINTER_UP) {
pointerIndex = (AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
pointerId = AMotionEvent_getPointerId(event, pointerIndex);
}
this->touchEventParamCache[0] = pointerId;
this->touchEventParamCache[1] = action;
this->touchEventParamCache[2] = AMotionEvent_getX(event, pointerIndex);
this->touchEventParamCache[3] = AMotionEvent_getY(event, pointerIndex);
this->touchEventParamCache[4] = this->uptime.time;
this->touchEventParamCache[5] = this->uptime.millitm;
this->touchEventParamCache[6] = AInputEvent_getDeviceId(event);
this->touchEventParamCache[7] = AInputEvent_getSource(event);
if (callSqFunction_Bool_Floats(this->sqvm, EMO_NAMESPACE, EMO_FUNC_MOTIONEVENT, this->touchEventParamCache, MOTION_EVENT_PARAMS_SIZE, false)) {
return 1;
}
}
bool CAndroidJoyStick::onJoyStickMotionEvent(AInputEvent *event)
{
if (event == NULL)
return false;
// match this device to a created device struct,
// create it if we do not find it.
APP_InputDeviceAxes *device_axes = NULL;
int32_t device = AInputEvent_getDeviceId(event);
// look for device name in our inputdevice cache.
for (size_t i = 0; i < m_input_devices.size(); i++)
{
if (m_input_devices[i]->id == device)
device_axes = m_input_devices[i];
}
if (!device_axes)
{
// as we see each axis, create a device axes and cache it.
device_axes = new APP_InputDeviceAxes;
SetupJoySticks(device_axes, device);
m_input_devices.push_back(device_axes);
}
// handle queued motion events, we
// ingnore history as it only relates to touch.
for (size_t p = 0; p < AMotionEvent_getPointerCount(event); p++)
ProcessMotionEvents(event, p, device, device_axes);
return true;
}
int32_t DragDetector::FindIndex(const AInputEvent* event, int32_t id) {
int32_t count = AMotionEvent_getPointerCount(event);
for (uint32_t i = 0; i < count; ++i) {
if (id == AMotionEvent_getPointerId(event, i)) return i;
}
return -1;
}
//callback
extern int32_t __android_handle_input(struct android_app* app, AInputEvent* event){
unsigned int action = AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_MASK;
unsigned int actionPointerIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
if (action == AMOTION_EVENT_ACTION_DOWN || action == AMOTION_EVENT_ACTION_POINTER_DOWN) {
if(fingerDown){
int count = AMotionEvent_getPointerCount(event);
int i = 0;
for(;i < count ; i++) {
unsigned int pointerFingerId = AMotionEvent_getPointerId(event, i);
fingerDown(app->userData,pointerFingerId,
AMotionEvent_getX(event, i),
AMotionEvent_getY(event, i),
AMotionEvent_getPressure(event, i));
}
}
} else if (action == AMOTION_EVENT_ACTION_UP || action == AMOTION_EVENT_ACTION_POINTER_UP) { //up
if(fingerUp){
int count = AMotionEvent_getPointerCount(event);
int i = 0;
for(;i < count ; i++) {
unsigned int pointerFingerId = AMotionEvent_getPointerId(event, i);
fingerUp(app->userData,pointerFingerId,
AMotionEvent_getX(event, i),
AMotionEvent_getY(event, i),
AMotionEvent_getPressure(event, i));
}
}
} else if (action == AMOTION_EVENT_ACTION_MOVE) { //move
if(fingerMove){
int count = AMotionEvent_getPointerCount(event);
int i = 0;
for(;i < count ; i++) {
unsigned int pointerFingerId = AMotionEvent_getPointerId(event, i);
fingerMove(app->userData,pointerFingerId,
AMotionEvent_getX(event, i),
AMotionEvent_getY(event, i),
AMotionEvent_getPressure(event, i));
}
}
} else if (action == AMOTION_EVENT_ACTION_CANCEL) {
} else {
return 0;
}
}
/*
* Get X, Y positions and ID's for all pointers
*/
static void getTouchPos(AInputEvent *event, int ids[], float xs[], float ys[]) {
int pointerCount = AMotionEvent_getPointerCount(event);
for(int i = 0; i < pointerCount; ++i) {
ids[i] = AMotionEvent_getPointerId(event, i);
xs[i] = AMotionEvent_getX(event, i);
ys[i] = AMotionEvent_getY(event, i);
}
}
GESTURE_STATE DragDetector::Detect(const AInputEvent* event) {
GESTURE_STATE ret = GESTURE_STATE_NONE;
int32_t action = AMotionEvent_getAction(event);
int32_t index = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
uint32_t flags = action & AMOTION_EVENT_ACTION_MASK;
event_ = event;
int32_t count = AMotionEvent_getPointerCount(event);
switch (flags) {
case AMOTION_EVENT_ACTION_DOWN:
vec_pointers_.push_back(AMotionEvent_getPointerId(event, 0));
ret = GESTURE_STATE_START;
break;
case AMOTION_EVENT_ACTION_POINTER_DOWN:
vec_pointers_.push_back(AMotionEvent_getPointerId(event, index));
break;
case AMOTION_EVENT_ACTION_UP:
vec_pointers_.pop_back();
ret = GESTURE_STATE_END;
break;
case AMOTION_EVENT_ACTION_POINTER_UP: {
int32_t released_pointer_id = AMotionEvent_getPointerId(event, index);
std::vector<int32_t>::iterator it = vec_pointers_.begin();
std::vector<int32_t>::iterator it_end = vec_pointers_.end();
int32_t i = 0;
for (; it != it_end; ++it, ++i) {
if (*it == released_pointer_id) {
vec_pointers_.erase(it);
break;
}
}
if (i <= 1) {
// Reset pinch or drag
if (count == 2) {
ret = GESTURE_STATE_START;
}
}
break;
}
case AMOTION_EVENT_ACTION_MOVE:
switch (count) {
case 1:
// Drag
ret = GESTURE_STATE_MOVE;
break;
default:
break;
}
break;
case AMOTION_EVENT_ACTION_CANCEL:
break;
}
return ret;
}
// Process the next input event.
static int32_t engine_handle_input(struct android_app* app, AInputEvent* event)
{
if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION)
{
int32_t action = AMotionEvent_getAction(event);
size_t pointerIndex;
size_t pointerId;
size_t pointerCount;
switch (action & AMOTION_EVENT_ACTION_MASK)
{
case AMOTION_EVENT_ACTION_DOWN:
// Primary pointer down
pointerId = AMotionEvent_getPointerId(event, 0);
gameplay::Platform::touchEventInternal(Touch::TOUCH_PRESS, AMotionEvent_getX(event, 0), AMotionEvent_getY(event, 0), pointerId);
__primaryTouchId = pointerId;
break;
case AMOTION_EVENT_ACTION_UP:
pointerId = AMotionEvent_getPointerId(event, 0);
if (__multiTouch || __primaryTouchId == pointerId)
{
gameplay::Platform::touchEventInternal(Touch::TOUCH_RELEASE, AMotionEvent_getX(event, 0), AMotionEvent_getY(event, 0), pointerId);
}
__primaryTouchId = -1;
break;
case AMOTION_EVENT_ACTION_POINTER_DOWN:
// Non-primary pointer down
if (__multiTouch)
{
pointerIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
pointerId = AMotionEvent_getPointerId(event, pointerIndex);
gameplay::Platform::touchEventInternal(Touch::TOUCH_PRESS, AMotionEvent_getX(event, pointerIndex), AMotionEvent_getY(event, pointerIndex), pointerId);
}
break;
case AMOTION_EVENT_ACTION_POINTER_UP:
pointerIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
pointerId = AMotionEvent_getPointerId(event, pointerIndex);
if (__multiTouch || __primaryTouchId == pointerId)
{
gameplay::Platform::touchEventInternal(Touch::TOUCH_RELEASE, AMotionEvent_getX(event, pointerIndex), AMotionEvent_getY(event, pointerIndex), pointerId);
}
if (__primaryTouchId == pointerId)
__primaryTouchId = -1;
break;
case AMOTION_EVENT_ACTION_MOVE:
// ACTION_MOVE events are batched, unlike the other events.
pointerCount = AMotionEvent_getPointerCount(event);
for (size_t i = 0; i < pointerCount; ++i)
{
pointerId = AMotionEvent_getPointerId(event, i);
if (__multiTouch || __primaryTouchId == pointerId)
{
gameplay::Platform::touchEventInternal(Touch::TOUCH_MOVE, AMotionEvent_getX(event, i), AMotionEvent_getY(event, i), pointerId);
}
}
break;
}
return 1;
}
int32 CorePlatformAndroid::HandleInput(AppHandle handle, AInputEvent* event)
{
CorePlatformAndroid *core = (CorePlatformAndroid *)handle->userData;
int32 eventType = AInputEvent_getType(event);
if (eventType == AINPUT_EVENT_TYPE_MOTION)
{
// Logger::Info("***[ TOUCH START ]***");
int32 actionUnmasked = AMotionEvent_getAction(event);
int32 action = (actionUnmasked & AMOTION_EVENT_ACTION_MASK);
// Logger::Info("Action unmasked = %d", actionUnmasked);
// Logger::Info("Action = %d", action);
int32 numEvents = AMotionEvent_getPointerCount(event);
// Logger::Info("Pointers count = %d", numEvents);
switch (action)
{
case AMOTION_EVENT_ACTION_DOWN:
case AMOTION_EVENT_ACTION_POINTER_DOWN:
UpdateTouchPositions(UIEvent::PHASE_BEGAN, event);
break;
case AMOTION_EVENT_ACTION_CANCEL:
UpdateTouchPositions(UIEvent::PHASE_CANCELLED, event);
break;
case AMOTION_EVENT_ACTION_UP:
UpdateTouchPositions(UIEvent::PHASE_ENDED, event);
break;
case AMOTION_EVENT_ACTION_POINTER_UP:
{
int32 actindex = (actionUnmasked & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK);
actindex >>= AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
// Logger::Debug("[CorePlatformAndroid::HandleInput] pointer up (%d)", actindex);
UpdateSingleTouchPosition(UIEvent::PHASE_ENDED, event, actindex);
break;
}
case AMOTION_EVENT_ACTION_MOVE:
UpdateTouchPositions(DAVA::UIEvent::PHASE_DRAG, event);
break;
default:
Logger::Warning("[CorePlatformAndroid::HandleInput] Unhandled motion event!");
break;
}
// Logger::Info("***[ TOUCH END ]***");
return 1;
}
static bool CookEvent_Motion(AInputEvent *event, CookedEventCallback callback) {
int src = AInputEvent_getSource(event);
int action = AMotionEvent_getAction(event);
int actionMasked = action & AMOTION_EVENT_ACTION_MASK;
int ptrIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
struct CookedEvent ev;
memset(&ev, 0, sizeof(ev));
if (actionMasked == AMOTION_EVENT_ACTION_DOWN || actionMasked ==
AMOTION_EVENT_ACTION_POINTER_DOWN) {
ev.type = COOKED_EVENT_TYPE_POINTER_DOWN;
} else if (actionMasked == AMOTION_EVENT_ACTION_UP || actionMasked ==
AMOTION_EVENT_ACTION_POINTER_UP) {
ev.type = COOKED_EVENT_TYPE_POINTER_UP;
} else {
ev.type = COOKED_EVENT_TYPE_POINTER_MOVE;
}
ev.motionPointerId = AMotionEvent_getPointerId(event, ptrIndex);
ev.motionIsOnScreen = (src == AINPUT_SOURCE_TOUCHSCREEN);
ev.motionX = AMotionEvent_getX(event, ptrIndex);
ev.motionY = AMotionEvent_getY(event, ptrIndex);
if (ev.motionIsOnScreen) {
// use screen size as the motion range
ev.motionMinX = 0.0f;
ev.motionMaxX = SceneManager::GetInstance()->GetScreenWidth();
ev.motionMinY = 0.0f;
ev.motionMaxY = SceneManager::GetInstance()->GetScreenHeight();
} else {
// look up motion range for this device
_look_up_motion_range((int) AInputEvent_getDeviceId(event),
(int)AInputEvent_getSource(event), &ev.motionMinX, &ev.motionMaxX,
&ev.motionMinY, &ev.motionMaxY);
}
// deliver event
callback(&ev);
// deliver motion info about other pointers (for multi-touch)
int ptrCount = AMotionEvent_getPointerCount(event);
for (int i = 0; i < ptrCount; i++) {
ev.type = COOKED_EVENT_TYPE_POINTER_MOVE;
ev.motionX = AMotionEvent_getX(event, i);
ev.motionY = AMotionEvent_getY(event, i);
ev.motionPointerId = AMotionEvent_getPointerId(event, i);
callback(&ev);
}
// If this is a touch-nav event, return false to indicate that we haven't handled it.
// This will trigger translation of swipes to DPAD keys, which is what we want.
// Otherwise, we say that we've handled it.
return (src != SOURCE_TOUCH_NAVIGATION);
}
bool CAndroidTouch::onTouchEvent(AInputEvent* event)
{
CXBMCApp::android_printf("%s", __PRETTY_FUNCTION__);
if (event == NULL)
return false;
size_t numPointers = AMotionEvent_getPointerCount(event);
if (numPointers <= 0)
{
CXBMCApp::android_printf(" => aborting touch event because there are no active pointers");
return false;
}
if (numPointers > TOUCH_MAX_POINTERS)
numPointers = TOUCH_MAX_POINTERS;
int32_t eventAction = AMotionEvent_getAction(event);
int8_t touchAction = eventAction & AMOTION_EVENT_ACTION_MASK;
size_t touchPointer = eventAction >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
CTouchInput::TouchEvent touchEvent = CTouchInput::TouchEventAbort;
switch (touchAction)
{
case AMOTION_EVENT_ACTION_DOWN:
case AMOTION_EVENT_ACTION_POINTER_DOWN:
touchEvent = CTouchInput::TouchEventDown;
break;
case AMOTION_EVENT_ACTION_UP:
case AMOTION_EVENT_ACTION_POINTER_UP:
touchEvent = CTouchInput::TouchEventUp;
break;
case AMOTION_EVENT_ACTION_MOVE:
touchEvent = CTouchInput::TouchEventMove;
break;
case AMOTION_EVENT_ACTION_OUTSIDE:
case AMOTION_EVENT_ACTION_CANCEL:
default:
break;
}
float x = AMotionEvent_getX(event, touchPointer);
float y = AMotionEvent_getY(event, touchPointer);
float size = m_dpi / 16.0f;
int64_t time = AMotionEvent_getEventTime(event);
// first update all touch pointers
for (unsigned int pointer = 0; pointer < numPointers; pointer++)
CTouchInput::Get().Update(pointer, AMotionEvent_getX(event, pointer), AMotionEvent_getY(event, pointer),
AMotionEvent_getEventTime(event), m_dpi / 16.0f);
// now send the event
return CTouchInput::Get().Handle(touchEvent, x, y, time, touchPointer, size);
}
bool NativeEngine::HandleInput(AInputEvent *event) {
if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION)
{
int32_t action = AMotionEvent_getAction(event);
size_t pointerIndex;
size_t pointerId;
size_t pointerCount;
int x;
int y;
switch (action & AMOTION_EVENT_ACTION_MASK)
{
case AMOTION_EVENT_ACTION_DOWN:
pointerId = AMotionEvent_getPointerId(event, 0);
x = AMotionEvent_getX(event, 0);
y = AMotionEvent_getY(event, 0);
touchBegan(pointerId, Origami::maths::vec2(x, y));
break;
case AMOTION_EVENT_ACTION_UP:
pointerId = AMotionEvent_getPointerId(event, 0);
x = AMotionEvent_getX(event, 0);
y = AMotionEvent_getY(event, 0);
touchended(pointerId, Origami::maths::vec2(x, y));
break;
case AMOTION_EVENT_ACTION_POINTER_DOWN:
pointerIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
pointerId = AMotionEvent_getPointerId(event, pointerIndex);
x = AMotionEvent_getX(event, pointerIndex);
y = AMotionEvent_getY(event, pointerIndex);
touchBegan(pointerId, Origami::maths::vec2(x, y));
break;
case AMOTION_EVENT_ACTION_POINTER_UP:
pointerIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
pointerId = AMotionEvent_getPointerId(event, pointerIndex);
x = AMotionEvent_getX(event, pointerIndex);
y = AMotionEvent_getY(event, pointerIndex);
touchended(pointerId, Origami::maths::vec2(x, y));
break;
case AMOTION_EVENT_ACTION_MOVE:
pointerCount = AMotionEvent_getPointerCount(event);
for (size_t i = 0; i < pointerCount; ++i) {
pointerId = AMotionEvent_getPointerId(event, i);
x = AMotionEvent_getX(event, i);
y = AMotionEvent_getY(event, i);
touchMoved(pointerId, Origami::maths::vec2(x, y));
}
break;
}
}
int32_t Window::handle_input( AInputEvent* event )
{
switch( AInputEvent_getType( event ) )
{
case AINPUT_EVENT_TYPE_MOTION:
{
int action = AMotionEvent_getAction( event );
int index = action >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
action &= AMOTION_EVENT_ACTION_MASK;
switch( action )
{
case AMOTION_EVENT_ACTION_DOWN:
case AMOTION_EVENT_ACTION_POINTER_DOWN:
pointevent(
"pointdown",
index + 1,
AMotionEvent_getX( event, 0 ),
AMotionEvent_getY( event, 0 ) );
break;
case AMOTION_EVENT_ACTION_UP:
case AMOTION_EVENT_ACTION_CANCEL:
pointevent(
"pointup",
AMotionEvent_getPointerId( event, 0 ) + 1,
-1,
-1 );
break;
case AMOTION_EVENT_ACTION_POINTER_UP:
pointevent(
"pointup",
index + 1,
-1,
-1 );
break;
case AMOTION_EVENT_ACTION_MOVE:
for(
int i = 0;
i < int( AMotionEvent_getPointerCount( event ) );
++i )
{
pointevent(
"pointmove",
AMotionEvent_getPointerId( event, i ) + 1,
AMotionEvent_getX( event, i ),
AMotionEvent_getY( event, i ) );
}
break;
}
return 0;
} break;
}
return 0;
}
static void computeMoveValues(AInputEvent* event, tMotionEvent* evt)
{
short index;
evt->packetCount = 0;
for (index=0; index<AMotionEvent_getPointerCount(event); ++index)
{
evt->eventArray[index].x = AMotionEvent_getX(event, AMotionEvent_getPointerId(event, index));
evt->eventArray[index].y = AMotionEvent_getY(event, AMotionEvent_getPointerId(event, index));
evt->eventArray[index].time = AMotionEvent_getEventTime(event);
evt->eventArray[index].pointerIndex = AMotionEvent_getPointerId(event, index);
evt->packetCount++;
}
}
void handleMotionEvent(AInputEvent* input)
{
int32_t action = AMotionEvent_getAction(input);
int actionMasked = action & AMOTION_EVENT_ACTION_MASK;
int actionPointerIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
// LOG(0, ".. motion: %d %d\n", actionMasked, actionPointerIndex);
size_t numPointers = AMotionEvent_getPointerCount(input);
float scale = 1.0f / _inputScale;
for (size_t i=0; i<numPointers; ++i)
{
int sysIndex = i;
Touch* touch = NULL;
bool on = false;
switch (actionMasked)
{
case AMOTION_EVENT_ACTION_DOWN:
case AMOTION_EVENT_ACTION_POINTER_DOWN:
touch = assignTouch(sysIndex);
on = true;
break;
case AMOTION_EVENT_ACTION_MOVE:
touch = getTouch(sysIndex);
on = true;
break;
case AMOTION_EVENT_ACTION_POINTER_UP:
case AMOTION_EVENT_ACTION_UP:
touch = getTouch(sysIndex);
on = sysIndex != actionPointerIndex;
break;
}
if (touch == NULL) continue;
float x = AMotionEvent_getX(input, sysIndex);
float y = AMotionEvent_getY(input, sysIndex);
Vector3 pos(x, y, 0);
pos *= scale;
// LOG(0, ".. pointer %d %f %f\n", sysIndex, pos.x, pos.y);
touch->pointer->move(on, pos);
}
if (actionMasked == AMOTION_EVENT_ACTION_POINTER_UP || actionMasked == AMOTION_EVENT_ACTION_UP)
releaseTouch(actionPointerIndex);
}
bool InputService::onTouchEvent(AInputEvent* pEvent) {
#ifdef INPUTSERVICE_LOG_EVENTS
packt_Log_debug("AMotionEvent_getAction=%d", AMotionEvent_getAction(pEvent));
packt_Log_debug("AMotionEvent_getFlags=%d", AMotionEvent_getFlags(pEvent));
packt_Log_debug("AMotionEvent_getMetaState=%d", AMotionEvent_getMetaState(pEvent));
packt_Log_debug("AMotionEvent_getEdgeFlags=%d", AMotionEvent_getEdgeFlags(pEvent));
packt_Log_debug("AMotionEvent_getDownTime=%lld", AMotionEvent_getDownTime(pEvent));
packt_Log_debug("AMotionEvent_getEventTime=%lld", AMotionEvent_getEventTime(pEvent));
packt_Log_debug("AMotionEvent_getXOffset=%f", AMotionEvent_getXOffset(pEvent));
packt_Log_debug("AMotionEvent_getYOffset=%f", AMotionEvent_getYOffset(pEvent));
packt_Log_debug("AMotionEvent_getXPrecision=%f", AMotionEvent_getXPrecision(pEvent));
packt_Log_debug("AMotionEvent_getYPrecision=%f", AMotionEvent_getYPrecision(pEvent));
packt_Log_debug("AMotionEvent_getPointerCount=%d", AMotionEvent_getPointerCount(pEvent));
packt_Log_debug("AMotionEvent_getRawX=%f", AMotionEvent_getRawX(pEvent, 0));
packt_Log_debug("AMotionEvent_getRawY=%f", AMotionEvent_getRawY(pEvent, 0));
packt_Log_debug("AMotionEvent_getX=%f", AMotionEvent_getX(pEvent, 0));
packt_Log_debug("AMotionEvent_getY=%f", AMotionEvent_getY(pEvent, 0));
packt_Log_debug("AMotionEvent_getPressure=%f", AMotionEvent_getPressure(pEvent, 0));
packt_Log_debug("AMotionEvent_getSize=%f", AMotionEvent_getSize(pEvent, 0));
packt_Log_debug("AMotionEvent_getOrientation=%f", AMotionEvent_getOrientation(pEvent, 0));
packt_Log_debug("AMotionEvent_getTouchMajor=%f", AMotionEvent_getTouchMajor(pEvent, 0));
packt_Log_debug("AMotionEvent_getTouchMinor=%f", AMotionEvent_getTouchMinor(pEvent, 0));
#endif
const float TOUCH_MAX_RANGE = 65.0f; // In pixels.
if (mRefPoint != NULL) {
if (AMotionEvent_getAction(pEvent)
== AMOTION_EVENT_ACTION_MOVE) {
// Needs a conversion to proper coordinates
// (origin at bottom/left). Only lMoveY needs it.
float lMoveX = AMotionEvent_getX(pEvent, 0)
- mRefPoint->mPosX;
float lMoveY = mHeight - AMotionEvent_getY(pEvent, 0)
- mRefPoint->mPosY;
float lMoveRange = sqrt((lMoveX * lMoveX)
+ (lMoveY * lMoveY));
if (lMoveRange > TOUCH_MAX_RANGE) {
float lCropFactor = TOUCH_MAX_RANGE / lMoveRange;
lMoveX *= lCropFactor; lMoveY *= lCropFactor;
}
mHorizontal = lMoveX / TOUCH_MAX_RANGE;
mVertical = lMoveY / TOUCH_MAX_RANGE;
} else {
mHorizontal = 0.0f; mVertical = 0.0f;
}
}
return true;
}
int32_t process_input(struct android_app* app, AInputEvent* event)
{
if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION)
{
const int32_t action = AMotionEvent_getAction(event);
const int32_t pointerIndex = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
const int32_t pointerCount = AMotionEvent_getPointerCount(event);
const int32_t pointerId = AMotionEvent_getPointerId(event, pointerIndex);
const float x = AMotionEvent_getX(event, pointerIndex);
const float y = AMotionEvent_getY(event, pointerIndex);
const int32_t actionMasked = (action & AMOTION_EVENT_ACTION_MASK);
switch (actionMasked)
{
case AMOTION_EVENT_ACTION_DOWN:
case AMOTION_EVENT_ACTION_POINTER_DOWN:
{
_queue.push_touch_event((int16_t)x, (int16_t)y, (uint8_t)pointerId, true);
break;
}
case AMOTION_EVENT_ACTION_UP:
case AMOTION_EVENT_ACTION_POINTER_UP:
{
_queue.push_touch_event((int16_t)x, (int16_t)y, (uint8_t)pointerId, false);
break;
}
case AMOTION_EVENT_ACTION_OUTSIDE:
case AMOTION_EVENT_ACTION_CANCEL:
{
_queue.push_touch_event((int16_t)x, (int16_t)y, (uint8_t)pointerId, false);
break;
}
case AMOTION_EVENT_ACTION_MOVE:
{
for (int index = 0; index < pointerCount; index++)
{
const float xx = AMotionEvent_getX(event, index);
const float yy = AMotionEvent_getY(event, index);
const int32_t id = AMotionEvent_getPointerId(event, index);
_queue.push_touch_event((int16_t)xx, (int16_t)yy, (uint8_t)id);
}
break;
}
}
return 1;
}
else if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY)
s32 process_input(struct android_app* app, AInputEvent* event)
{
if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION)
{
const s32 action = AMotionEvent_getAction(event);
const s32 pointer_index = (action & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
const s32 pointer_count = AMotionEvent_getPointerCount(event);
const s32 pointer_id = AMotionEvent_getPointerId(event, pointer_index);
const f32 x = AMotionEvent_getX(event, pointer_index);
const f32 y = AMotionEvent_getY(event, pointer_index);
const s32 actionMasked = (action & AMOTION_EVENT_ACTION_MASK);
switch (actionMasked)
{
case AMOTION_EVENT_ACTION_DOWN:
case AMOTION_EVENT_ACTION_POINTER_DOWN:
_queue.push_touch_event((s16)x, (s16)y, (u8)pointer_id, true);
break;
case AMOTION_EVENT_ACTION_UP:
case AMOTION_EVENT_ACTION_POINTER_UP:
_queue.push_touch_event((s16)x, (s16)y, (u8)pointer_id, false);
break;
case AMOTION_EVENT_ACTION_OUTSIDE:
case AMOTION_EVENT_ACTION_CANCEL:
_queue.push_touch_event((s16)x, (s16)y, (u8)pointer_id, false);
break;
case AMOTION_EVENT_ACTION_MOVE:
for (int index = 0; index < pointer_count; index++)
{
const f32 xx = AMotionEvent_getX(event, index);
const f32 yy = AMotionEvent_getY(event, index);
const s32 id = AMotionEvent_getPointerId(event, index);
_queue.push_touch_event((s16)xx, (s16)yy, (u8)id);
}
break;
}
return 1;
}
else if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY)
static int32_t custom_handle_input(struct android_app* _application, AInputEvent* _event)
{
if( AInputEvent_getType(_event) == AINPUT_EVENT_TYPE_MOTION )
{
i32 pointerCount = AMotionEvent_getPointerCount(_event);
i32 sourceId = AInputEvent_getSource(_event);
for(ui32 i = 0 ; i < pointerCount ; ++i)
{
i32 pointerId = AMotionEvent_getPointerId(_event, i);
i32 action = AMOTION_EVENT_ACTION_MASK & AMotionEvent_getAction(_event);
i32 rawAction = AMotionEvent_getAction(_event);
if(sourceId == AINPUT_SOURCE_TOUCHPAD)
{
}
else
{
}
f32 pointX = AMotionEvent_getX(_event, 0);
f32 pointY = AMotionEvent_getY(_event, 0);
if(action == AMOTION_EVENT_ACTION_POINTER_DOWN || action == AMOTION_EVENT_ACTION_POINTER_UP)
{
i32 pointerIndex = (AMotionEvent_getAction(_event) & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
pointerId = AMotionEvent_getPointerId(_event, pointerIndex);
}
if(action == AMOTION_EVENT_ACTION_DOWN || action == AMOTION_EVENT_ACTION_POINTER_DOWN)
{
IInputContext::NativeCallTapRecognizerPressed(glm::ivec2(pointX, pointY));
}
else if( action == AMOTION_EVENT_ACTION_UP || action == AMOTION_EVENT_ACTION_POINTER_UP || action == AMOTION_EVENT_ACTION_CANCEL )
{
IInputContext::NativeCallTapRecognizerReleased(glm::ivec2(pointX, pointY));
}
else if(action == AMOTION_EVENT_ACTION_MOVE)
{
IInputContext::NativeCallTapRecognizerMoved(glm::ivec2(pointX, pointY));
}
}
/**
* Process the next input event.
*/
static
int32_t
engine_handle_input( struct android_app* app, AInputEvent* event )
{
struct ENGINE* engine = (struct ENGINE*)app->userData;
if( AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION )
{
engine->render = 1;
int nPointerCount = AMotionEvent_getPointerCount( event );
int nSourceId = AInputEvent_getSource( event );
int n;
for( n = 0 ; n < nPointerCount ; ++n )
{
int nPointerId = AMotionEvent_getPointerId( event, n );
int nAction = AMOTION_EVENT_ACTION_MASK & AMotionEvent_getAction( event );
struct TOUCHSTATE *touchstate = 0;
if( nSourceId == AINPUT_SOURCE_TOUCHPAD )
touchstate = engine->touchstate_pad;
else
touchstate = engine->touchstate_screen;
if( nAction == AMOTION_EVENT_ACTION_POINTER_DOWN || nAction == AMOTION_EVENT_ACTION_POINTER_UP )
{
int nPointerIndex = (AMotionEvent_getAction( event ) & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
nPointerId = AMotionEvent_getPointerId( event, nPointerIndex );
}
if( nAction == AMOTION_EVENT_ACTION_DOWN || nAction == AMOTION_EVENT_ACTION_POINTER_DOWN )
{
touchstate[nPointerId].down = 1;
}
else if( nAction == AMOTION_EVENT_ACTION_UP || nAction == AMOTION_EVENT_ACTION_POINTER_UP || nAction == AMOTION_EVENT_ACTION_CANCEL )
{
touchstate[nPointerId].down = 0;
}
if (touchstate[nPointerId].down == 1)
{
touchstate[nPointerId].x = AMotionEvent_getX( event, n );
touchstate[nPointerId].y = AMotionEvent_getY( event, n );
}
}
int WindowImplAndroid::processMotionEvent(AInputEvent* _event, ActivityStates* states)
{
int32_t device = AInputEvent_getSource(_event);
int32_t action = AMotionEvent_getAction(_event);
Event event;
if (device == AINPUT_SOURCE_MOUSE)
event.type = Event::MouseMoved;
else if (device & AINPUT_SOURCE_TOUCHSCREEN)
event.type = Event::TouchMoved;
int pointerCount = AMotionEvent_getPointerCount(_event);
for (int p = 0; p < pointerCount; p++)
{
int id = AMotionEvent_getPointerId(_event, p);
float x = AMotionEvent_getX(_event, p);
float y = AMotionEvent_getY(_event, p);
if (device == AINPUT_SOURCE_MOUSE)
{
event.mouseMove.x = x;
event.mouseMove.y = y;
states->mousePosition = Vector2i(event.mouseMove.x, event.mouseMove.y);
}
else if (device & AINPUT_SOURCE_TOUCHSCREEN)
{
if (states->touchEvents[id].x == x && states->touchEvents[id].y == y)
continue;
event.touch.finger = id;
event.touch.x = x;
event.touch.y = y;
states->touchEvents[id] = Vector2i(event.touch.x, event.touch.y);
}
forwardEvent(event);
}
return 1;
}
int onTouchEvent(AInputEvent* event) {
int h, historySize;
const float TOUCH_MAX_RANGE = 65.0f; // In pixels.
int actionType;
int countPointers = AMotionEvent_getPointerCount(event);
float xPositionTouch, yPositionTouch;
int actionIndex;
int pointerId;
int idTouch;
for(int i = 0; i < countPointers; i++) {
pointerId = AMotionEvent_getPointerId(event,i);
actionType = AMotionEvent_getAction(event);
actionIndex = (actionType&AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
actionType = actionType & AMOTION_EVENT_ACTION_MASK;
if(actionIndex != i)continue;
switch(actionType) {
case AMOTION_EVENT_ACTION_DOWN:
case AMOTION_EVENT_ACTION_POINTER_DOWN:
xPositionTouch = AMotionEvent_getX(event,i);
yPositionTouch = AMotionEvent_getY(event,i);
idTouch = AMotionEvent_getPointerId(event,i);
Input::getInstance()->newEvent(idTouch, xPositionTouch, (float)GlobalData::getInstance()->screenHeight - yPositionTouch);
break;
case AMOTION_EVENT_ACTION_MOVE:
xPositionTouch = AMotionEvent_getX(event,i);
yPositionTouch = AMotionEvent_getY(event,i);
idTouch = AMotionEvent_getPointerId(event,i);
Input::getInstance()->updateEvent(idTouch, xPositionTouch, (float)GlobalData::getInstance()->screenHeight - yPositionTouch);
break;
case AMOTION_EVENT_ACTION_UP:
case AMOTION_EVENT_ACTION_CANCEL:
case AMOTION_EVENT_ACTION_POINTER_UP:
xPositionTouch = AMotionEvent_getX(event,i);
yPositionTouch = AMotionEvent_getY(event,i);
idTouch = AMotionEvent_getPointerId(event,i);
Input::getInstance()->updateEventToEnd(idTouch);
break;
}
}
return true;
}
///// タッチイベント処理
void get_touch_position(struct android_app* app, AInputEvent* event) {
struct engine* engine = (struct engine*) app->userData;
// タッチの状態を取得する
int32_t action = AMotionEvent_getAction(event); /////------(1)
// １点以上押している
if (action != AKEY_EVENT_ACTION_UP) { /////------(1)
// 押しているポイントの数を取得
size_t count = AMotionEvent_getPointerCount(event); /////-----(2)
int i;
engine->point_count = count;
// 押しているポイントの位置を取得
for (i = 0; i < count; i++) {
engine->point[i].x = AMotionEvent_getX(event, i); /////-----(3) ここから
engine->point[i].y = AMotionEvent_getY(event, i); /////-----(3) ここまで
}
} else {
// 指が全部離れた
engine->point_count = 0;
}
}
int32_t android_handle_motion(struct android_app* app, AInputEvent* event)
{
Director* director = static_cast<AInstance*>(app->userData)->director.get();
switch (AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_MASK)
{
case AMOTION_EVENT_ACTION_DOWN:
case AMOTION_EVENT_ACTION_POINTER_DOWN: {
const int32_t index = (AMotionEvent_getAction(event) &
AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
Pointer p = get_pointer_event(event, index);
director->input().on_pointer_began(ArrayView<Pointer>(p));
break;
}
case AMOTION_EVENT_ACTION_UP:
case AMOTION_EVENT_ACTION_POINTER_UP: {
const int32_t index = (AMotionEvent_getAction(event) &
AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >>
AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
Pointer p = get_pointer_event(event, index);
director->input().on_pointer_ended(ArrayView<Pointer>(p));
break;
}
case AMOTION_EVENT_ACTION_MOVE: {
const size_t count = AMotionEvent_getPointerCount(event);
auto pointers = std::make_unique<Pointer[]>(count);
for (size_t i = 0; i < count; ++i)
pointers[i] = get_pointer_event(event, i);
director->input().on_pointer_moved(
ArrayView<Pointer>(pointers.get(), count));
break;
}
case AMOTION_EVENT_ACTION_CANCEL:
case AMOTION_EVENT_ACTION_OUTSIDE:
director->input().on_pointer_canceled();
break;
default:
break;
}
return 1;
}
static int32_t handle_input(struct android_app* app, AInputEvent* event) {
/* app->userData is available here */
if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) {
app_has_focus = true;
// LOGI("Motion Event, pressed = %d", (pressed?1:0));
for (int i=0; i< AMotionEvent_getPointerCount(event); ++i)
{
int action = AMotionEvent_getAction(event);
// LOGI("Motion Event, action = %d", action);
if ((action & AMOTION_EVENT_ACTION_DOWN)
||(action & AMOTION_EVENT_ACTION_POINTER_DOWN))
{
//LOGI("In");
if (!pressed)
{
pressed = true;
float px = AMotionEvent_getX(event, i);
float py = AMotionEvent_getY(event, i);
cd->clickat(px,py);
}
}
else
pressed = false;
}
return 1;
} else if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_KEY) {
LOGI("Key event: action=%d keyCode=%d metaState=0x%x",
AKeyEvent_getAction(event),
AKeyEvent_getKeyCode(event),
AKeyEvent_getMetaState(event));
}
return 0;
}
