337 lines
11 KiB
C
337 lines
11 KiB
C
/*
|
|
* Copyright (C) 2022 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
/**
|
|
* @addtogroup GameActivity Game Activity Events
|
|
* The interface to use Game Activity Events.
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @file GameActivityEvents.h
|
|
*/
|
|
#ifndef ANDROID_GAME_SDK_GAME_ACTIVITY_EVENTS_H
|
|
#define ANDROID_GAME_SDK_GAME_ACTIVITY_EVENTS_H
|
|
|
|
#include <android/input.h>
|
|
#include <jni.h>
|
|
#include <stdbool.h>
|
|
#include <stdint.h>
|
|
#include <sys/types.h>
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif
|
|
|
|
/**
|
|
* The maximum number of axes supported in an Android MotionEvent.
|
|
* See https://developer.android.com/ndk/reference/group/input.
|
|
*/
|
|
#define GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT 48
|
|
|
|
/**
|
|
* \brief Describe information about a pointer, found in a
|
|
* GameActivityMotionEvent.
|
|
*
|
|
* You can read values directly from this structure, or use helper functions
|
|
* (`GameActivityPointerAxes_getX`, `GameActivityPointerAxes_getY` and
|
|
* `GameActivityPointerAxes_getAxisValue`).
|
|
*
|
|
* The X axis and Y axis are enabled by default but any other axis that you want
|
|
* to read **must** be enabled first, using
|
|
* `GameActivityPointerAxes_enableAxis`.
|
|
*
|
|
* \see GameActivityMotionEvent
|
|
*/
|
|
typedef struct GameActivityPointerAxes {
|
|
int32_t id;
|
|
int32_t toolType;
|
|
float axisValues[GAME_ACTIVITY_POINTER_INFO_AXIS_COUNT];
|
|
float rawX;
|
|
float rawY;
|
|
} GameActivityPointerAxes;
|
|
|
|
/** \brief Get the toolType of the pointer. */
|
|
inline int32_t GameActivityPointerAxes_getToolType(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return pointerInfo->toolType;
|
|
}
|
|
|
|
/** \brief Get the current X coordinate of the pointer. */
|
|
inline float GameActivityPointerAxes_getX(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return pointerInfo->axisValues[AMOTION_EVENT_AXIS_X];
|
|
}
|
|
|
|
/** \brief Get the current Y coordinate of the pointer. */
|
|
inline float GameActivityPointerAxes_getY(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return pointerInfo->axisValues[AMOTION_EVENT_AXIS_Y];
|
|
}
|
|
|
|
/**
|
|
* \brief Enable the specified axis, so that its value is reported in the
|
|
* GameActivityPointerAxes structures stored in a motion event.
|
|
*
|
|
* You must enable any axis that you want to read, apart from
|
|
* `AMOTION_EVENT_AXIS_X` and `AMOTION_EVENT_AXIS_Y` that are enabled by
|
|
* default.
|
|
*
|
|
* If the axis index is out of range, nothing is done.
|
|
*/
|
|
void GameActivityPointerAxes_enableAxis(int32_t axis);
|
|
|
|
/**
|
|
* \brief Disable the specified axis. Its value won't be reported in the
|
|
* GameActivityPointerAxes structures stored in a motion event anymore.
|
|
*
|
|
* Apart from X and Y, any axis that you want to read **must** be enabled first,
|
|
* using `GameActivityPointerAxes_enableAxis`.
|
|
*
|
|
* If the axis index is out of range, nothing is done.
|
|
*/
|
|
void GameActivityPointerAxes_disableAxis(int32_t axis);
|
|
|
|
/**
|
|
* \brief Get the value of the requested axis.
|
|
*
|
|
* Apart from X and Y, any axis that you want to read **must** be enabled first,
|
|
* using `GameActivityPointerAxes_enableAxis`.
|
|
*
|
|
* Find the valid enums for the axis (`AMOTION_EVENT_AXIS_X`,
|
|
* `AMOTION_EVENT_AXIS_Y`, `AMOTION_EVENT_AXIS_PRESSURE`...)
|
|
* in https://developer.android.com/ndk/reference/group/input.
|
|
*
|
|
* @param pointerInfo The structure containing information about the pointer,
|
|
* obtained from GameActivityMotionEvent.
|
|
* @param axis The axis to get the value from
|
|
* @return The value of the axis, or 0 if the axis is invalid or was not
|
|
* enabled.
|
|
*/
|
|
float GameActivityPointerAxes_getAxisValue(
|
|
const GameActivityPointerAxes* pointerInfo, int32_t axis);
|
|
|
|
inline float GameActivityPointerAxes_getPressure(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return GameActivityPointerAxes_getAxisValue(pointerInfo,
|
|
AMOTION_EVENT_AXIS_PRESSURE);
|
|
}
|
|
|
|
inline float GameActivityPointerAxes_getSize(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return GameActivityPointerAxes_getAxisValue(pointerInfo,
|
|
AMOTION_EVENT_AXIS_SIZE);
|
|
}
|
|
|
|
inline float GameActivityPointerAxes_getTouchMajor(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return GameActivityPointerAxes_getAxisValue(pointerInfo,
|
|
AMOTION_EVENT_AXIS_TOUCH_MAJOR);
|
|
}
|
|
|
|
inline float GameActivityPointerAxes_getTouchMinor(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return GameActivityPointerAxes_getAxisValue(pointerInfo,
|
|
AMOTION_EVENT_AXIS_TOUCH_MINOR);
|
|
}
|
|
|
|
inline float GameActivityPointerAxes_getToolMajor(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return GameActivityPointerAxes_getAxisValue(pointerInfo,
|
|
AMOTION_EVENT_AXIS_TOOL_MAJOR);
|
|
}
|
|
|
|
inline float GameActivityPointerAxes_getToolMinor(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return GameActivityPointerAxes_getAxisValue(pointerInfo,
|
|
AMOTION_EVENT_AXIS_TOOL_MINOR);
|
|
}
|
|
|
|
inline float GameActivityPointerAxes_getOrientation(
|
|
const GameActivityPointerAxes* pointerInfo) {
|
|
return GameActivityPointerAxes_getAxisValue(pointerInfo,
|
|
AMOTION_EVENT_AXIS_ORIENTATION);
|
|
}
|
|
|
|
/**
|
|
* The maximum number of pointers returned inside a motion event.
|
|
*/
|
|
#if (defined GAMEACTIVITY_MAX_NUM_POINTERS_IN_MOTION_EVENT_OVERRIDE)
|
|
#define GAMEACTIVITY_MAX_NUM_POINTERS_IN_MOTION_EVENT \
|
|
GAMEACTIVITY_MAX_NUM_POINTERS_IN_MOTION_EVENT_OVERRIDE
|
|
#else
|
|
#define GAMEACTIVITY_MAX_NUM_POINTERS_IN_MOTION_EVENT 8
|
|
#endif
|
|
|
|
/**
|
|
* \brief Describe a motion event that happened on the GameActivity SurfaceView.
|
|
*
|
|
* This is 1:1 mapping to the information contained in a Java `MotionEvent`
|
|
* (see https://developer.android.com/reference/android/view/MotionEvent).
|
|
*/
|
|
typedef struct GameActivityMotionEvent {
|
|
int32_t deviceId;
|
|
int32_t source;
|
|
int32_t action;
|
|
|
|
int64_t eventTime;
|
|
int64_t downTime;
|
|
|
|
int32_t flags;
|
|
int32_t metaState;
|
|
|
|
int32_t actionButton;
|
|
int32_t buttonState;
|
|
int32_t classification;
|
|
int32_t edgeFlags;
|
|
|
|
uint32_t pointerCount;
|
|
GameActivityPointerAxes
|
|
pointers[GAMEACTIVITY_MAX_NUM_POINTERS_IN_MOTION_EVENT];
|
|
|
|
int historySize;
|
|
int64_t* historicalEventTimesMillis;
|
|
int64_t* historicalEventTimesNanos;
|
|
float* historicalAxisValues;
|
|
|
|
float precisionX;
|
|
float precisionY;
|
|
} GameActivityMotionEvent;
|
|
|
|
float GameActivityMotionEvent_getHistoricalAxisValue(
|
|
const GameActivityMotionEvent* event, int axis, int pointerIndex,
|
|
int historyPos);
|
|
|
|
inline int GameActivityMotionEvent_getHistorySize(
|
|
const GameActivityMotionEvent* event) {
|
|
return event->historySize;
|
|
}
|
|
|
|
inline float GameActivityMotionEvent_getHistoricalX(
|
|
const GameActivityMotionEvent* event, int pointerIndex, int historyPos) {
|
|
return GameActivityMotionEvent_getHistoricalAxisValue(
|
|
event, AMOTION_EVENT_AXIS_X, pointerIndex, historyPos);
|
|
}
|
|
|
|
inline float GameActivityMotionEvent_getHistoricalY(
|
|
const GameActivityMotionEvent* event, int pointerIndex, int historyPos) {
|
|
return GameActivityMotionEvent_getHistoricalAxisValue(
|
|
event, AMOTION_EVENT_AXIS_Y, pointerIndex, historyPos);
|
|
}
|
|
|
|
inline float GameActivityMotionEvent_getHistoricalPressure(
|
|
const GameActivityMotionEvent* event, int pointerIndex, int historyPos) {
|
|
return GameActivityMotionEvent_getHistoricalAxisValue(
|
|
event, AMOTION_EVENT_AXIS_PRESSURE, pointerIndex, historyPos);
|
|
}
|
|
|
|
inline float GameActivityMotionEvent_getHistoricalSize(
|
|
const GameActivityMotionEvent* event, int pointerIndex, int historyPos) {
|
|
return GameActivityMotionEvent_getHistoricalAxisValue(
|
|
event, AMOTION_EVENT_AXIS_SIZE, pointerIndex, historyPos);
|
|
}
|
|
|
|
inline float GameActivityMotionEvent_getHistoricalTouchMajor(
|
|
const GameActivityMotionEvent* event, int pointerIndex, int historyPos) {
|
|
return GameActivityMotionEvent_getHistoricalAxisValue(
|
|
event, AMOTION_EVENT_AXIS_TOUCH_MAJOR, pointerIndex, historyPos);
|
|
}
|
|
|
|
inline float GameActivityMotionEvent_getHistoricalTouchMinor(
|
|
const GameActivityMotionEvent* event, int pointerIndex, int historyPos) {
|
|
return GameActivityMotionEvent_getHistoricalAxisValue(
|
|
event, AMOTION_EVENT_AXIS_TOUCH_MINOR, pointerIndex, historyPos);
|
|
}
|
|
|
|
inline float GameActivityMotionEvent_getHistoricalToolMajor(
|
|
const GameActivityMotionEvent* event, int pointerIndex, int historyPos) {
|
|
return GameActivityMotionEvent_getHistoricalAxisValue(
|
|
event, AMOTION_EVENT_AXIS_TOOL_MAJOR, pointerIndex, historyPos);
|
|
}
|
|
|
|
inline float GameActivityMotionEvent_getHistoricalToolMinor(
|
|
const GameActivityMotionEvent* event, int pointerIndex, int historyPos) {
|
|
return GameActivityMotionEvent_getHistoricalAxisValue(
|
|
event, AMOTION_EVENT_AXIS_TOOL_MINOR, pointerIndex, historyPos);
|
|
}
|
|
|
|
inline float GameActivityMotionEvent_getHistoricalOrientation(
|
|
const GameActivityMotionEvent* event, int pointerIndex, int historyPos) {
|
|
return GameActivityMotionEvent_getHistoricalAxisValue(
|
|
event, AMOTION_EVENT_AXIS_ORIENTATION, pointerIndex, historyPos);
|
|
}
|
|
|
|
/** \brief Handle the freeing of the GameActivityMotionEvent struct. */
|
|
void GameActivityMotionEvent_destroy(GameActivityMotionEvent* c_event);
|
|
|
|
/**
|
|
* \brief Convert a Java `MotionEvent` to a `GameActivityMotionEvent`.
|
|
*
|
|
* This is done automatically by the GameActivity: see `onTouchEvent` to set
|
|
* a callback to consume the received events.
|
|
* This function can be used if you re-implement events handling in your own
|
|
* activity.
|
|
* Ownership of out_event is maintained by the caller.
|
|
*/
|
|
void GameActivityMotionEvent_fromJava(JNIEnv* env, jobject motionEvent,
|
|
GameActivityMotionEvent* out_event);
|
|
|
|
/**
|
|
* \brief Describe a key event that happened on the GameActivity SurfaceView.
|
|
*
|
|
* This is 1:1 mapping to the information contained in a Java `KeyEvent`
|
|
* (see https://developer.android.com/reference/android/view/KeyEvent).
|
|
* The only exception is the event times, which are reported as
|
|
* nanoseconds in this struct.
|
|
*/
|
|
typedef struct GameActivityKeyEvent {
|
|
int32_t deviceId;
|
|
int32_t source;
|
|
int32_t action;
|
|
|
|
int64_t eventTime;
|
|
int64_t downTime;
|
|
|
|
int32_t flags;
|
|
int32_t metaState;
|
|
|
|
int32_t modifiers;
|
|
int32_t repeatCount;
|
|
int32_t keyCode;
|
|
int32_t scanCode;
|
|
//int32_t unicodeChar;
|
|
} GameActivityKeyEvent;
|
|
|
|
/**
|
|
* \brief Convert a Java `KeyEvent` to a `GameActivityKeyEvent`.
|
|
*
|
|
* This is done automatically by the GameActivity: see `onKeyUp` and `onKeyDown`
|
|
* to set a callback to consume the received events.
|
|
* This function can be used if you re-implement events handling in your own
|
|
* activity.
|
|
* Ownership of out_event is maintained by the caller.
|
|
*/
|
|
void GameActivityKeyEvent_fromJava(JNIEnv* env, jobject motionEvent,
|
|
GameActivityKeyEvent* out_event);
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif
|
|
|
|
/** @} */
|
|
|
|
#endif // ANDROID_GAME_SDK_GAME_ACTIVITY_EVENTS_H
|