864 lines
29 KiB
C++
864 lines
29 KiB
C++
// Copyright (C) 2002-2007 Nikolaus Gebhardt
|
|
// Copyright (C) 2007-2011 Christian Stehno
|
|
// This file is part of the "Irrlicht Engine".
|
|
// For conditions of distribution and use, see copyright notice in irrlicht.h
|
|
|
|
#include "CIrrDeviceAndroid.h"
|
|
|
|
#include "os.h"
|
|
#include "CFileSystem.h"
|
|
#include "CAndroidAssetReader.h"
|
|
#include "CAndroidAssetFileArchive.h"
|
|
#include "CKeyEventWrapper.h"
|
|
#include "CEGLManager.h"
|
|
#include "ISceneManager.h"
|
|
#include "IGUIEnvironment.h"
|
|
#include "CEGLManager.h"
|
|
|
|
namespace irr
|
|
{
|
|
namespace video
|
|
{
|
|
IVideoDriver* createOGLES1Driver(const SIrrlichtCreationParameters& params,
|
|
io::IFileSystem* io, video::IContextManager* contextManager);
|
|
|
|
IVideoDriver* createOGLES2Driver(const SIrrlichtCreationParameters& params,
|
|
io::IFileSystem* io, video::IContextManager* contextManager);
|
|
}
|
|
}
|
|
|
|
namespace irr
|
|
{
|
|
|
|
CIrrDeviceAndroid::CIrrDeviceAndroid(const SIrrlichtCreationParameters& param)
|
|
: CIrrDeviceStub(param), Accelerometer(0), Gyroscope(0), Focused(false), Initialized(false), Paused(true), JNIEnvAttachedToVM(0)
|
|
{
|
|
#ifdef _DEBUG
|
|
setDebugName("CIrrDeviceAndroid");
|
|
#endif
|
|
|
|
// Get the interface to the native Android activity.
|
|
Android = (android_app*)(param.PrivateData);
|
|
|
|
// Set the private data so we can use it in any static callbacks.
|
|
Android->userData = this;
|
|
|
|
// Set the default command handler. This is a callback function that the Android
|
|
// OS invokes to send the native activity messages.
|
|
Android->onAppCmd = handleAndroidCommand;
|
|
|
|
createKeyMap();
|
|
|
|
// Create a sensor manager to receive touch screen events from the java activity.
|
|
SensorManager = ASensorManager_getInstance();
|
|
SensorEventQueue = ASensorManager_createEventQueue(SensorManager, Android->looper, LOOPER_ID_USER, 0, 0);
|
|
Android->onInputEvent = handleInput;
|
|
|
|
// Create EGL manager.
|
|
ContextManager = new video::CEGLManager();
|
|
|
|
os::Printer::log("Waiting for Android activity window to be created.", ELL_DEBUG);
|
|
|
|
do
|
|
{
|
|
s32 Events = 0;
|
|
android_poll_source* Source = 0;
|
|
|
|
while ((ALooper_pollAll(((Focused && !Paused) || !Initialized) ? 0 : -1, 0, &Events, (void**)&Source)) >= 0)
|
|
{
|
|
if(Source)
|
|
Source->process(Android, Source);
|
|
}
|
|
}
|
|
while(!Initialized);
|
|
}
|
|
|
|
|
|
CIrrDeviceAndroid::~CIrrDeviceAndroid()
|
|
{
|
|
if (GUIEnvironment)
|
|
{
|
|
GUIEnvironment->drop();
|
|
GUIEnvironment = 0;
|
|
}
|
|
|
|
if (SceneManager)
|
|
{
|
|
SceneManager->drop();
|
|
SceneManager = 0;
|
|
}
|
|
|
|
if (VideoDriver)
|
|
{
|
|
VideoDriver->drop();
|
|
VideoDriver = 0;
|
|
}
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::run()
|
|
{
|
|
if (!Initialized)
|
|
return false;
|
|
|
|
os::Timer::tick();
|
|
|
|
s32 id;
|
|
s32 Events = 0;
|
|
android_poll_source* Source = 0;
|
|
|
|
while ((id = ALooper_pollAll(0, 0, &Events, (void**)&Source)) >= 0)
|
|
{
|
|
if(Source)
|
|
Source->process(Android, Source);
|
|
|
|
// if a sensor has data, we'll process it now.
|
|
if (id == LOOPER_ID_USER)
|
|
{
|
|
ASensorEvent sensorEvent;
|
|
while (ASensorEventQueue_getEvents(SensorEventQueue, &sensorEvent, 1) > 0)
|
|
{
|
|
switch (sensorEvent.type)
|
|
{
|
|
case ASENSOR_TYPE_ACCELEROMETER:
|
|
SEvent accEvent;
|
|
accEvent.EventType = EET_ACCELEROMETER_EVENT;
|
|
accEvent.AccelerometerEvent.X = sensorEvent.acceleration.x;
|
|
accEvent.AccelerometerEvent.Y = sensorEvent.acceleration.y;
|
|
accEvent.AccelerometerEvent.Z = sensorEvent.acceleration.z;
|
|
|
|
postEventFromUser(accEvent);
|
|
break;
|
|
|
|
case ASENSOR_TYPE_GYROSCOPE:
|
|
SEvent gyroEvent;
|
|
gyroEvent.EventType = EET_GYROSCOPE_EVENT;
|
|
gyroEvent.GyroscopeEvent.X = sensorEvent.vector.x;
|
|
gyroEvent.GyroscopeEvent.Y = sensorEvent.vector.y;
|
|
gyroEvent.GyroscopeEvent.Z = sensorEvent.vector.z;
|
|
|
|
postEventFromUser(gyroEvent);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(!Initialized)
|
|
break;
|
|
}
|
|
|
|
return Initialized;
|
|
}
|
|
|
|
void CIrrDeviceAndroid::yield()
|
|
{
|
|
struct timespec ts = {0,1};
|
|
nanosleep(&ts, NULL);
|
|
}
|
|
|
|
void CIrrDeviceAndroid::sleep(u32 timeMs, bool pauseTimer)
|
|
{
|
|
const bool wasStopped = Timer ? Timer->isStopped() : true;
|
|
|
|
struct timespec ts;
|
|
ts.tv_sec = (time_t) (timeMs / 1000);
|
|
ts.tv_nsec = (long) (timeMs % 1000) * 1000000;
|
|
|
|
if (pauseTimer && !wasStopped)
|
|
Timer->stop();
|
|
|
|
nanosleep(&ts, NULL);
|
|
|
|
if (pauseTimer && !wasStopped)
|
|
Timer->start();
|
|
}
|
|
|
|
void CIrrDeviceAndroid::setWindowCaption(const wchar_t* text)
|
|
{
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::isWindowActive() const
|
|
{
|
|
return (Focused && !Paused);
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::isWindowFocused() const
|
|
{
|
|
return Focused;
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::isWindowMinimized() const
|
|
{
|
|
return !Focused;
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::isWindowVisible() const
|
|
{
|
|
return !Paused;
|
|
}
|
|
|
|
void CIrrDeviceAndroid::closeDevice()
|
|
{
|
|
ANativeActivity_finish(Android->activity);
|
|
}
|
|
|
|
void CIrrDeviceAndroid::setResizable(bool resize)
|
|
{
|
|
}
|
|
|
|
void CIrrDeviceAndroid::minimizeWindow()
|
|
{
|
|
}
|
|
|
|
void CIrrDeviceAndroid::maximizeWindow()
|
|
{
|
|
}
|
|
|
|
void CIrrDeviceAndroid::restoreWindow()
|
|
{
|
|
}
|
|
|
|
core::position2di CIrrDeviceAndroid::getWindowPosition()
|
|
{
|
|
return core::position2di(0, 0);
|
|
}
|
|
|
|
E_DEVICE_TYPE CIrrDeviceAndroid::getType() const
|
|
{
|
|
return EIDT_ANDROID;
|
|
}
|
|
|
|
void CIrrDeviceAndroid::handleAndroidCommand(android_app* app, int32_t cmd)
|
|
{
|
|
CIrrDeviceAndroid* device = (CIrrDeviceAndroid*)app->userData;
|
|
|
|
SEvent event;
|
|
event.EventType = EET_SYSTEM_EVENT;
|
|
event.SystemEvent.EventType = ESET_ANDROID_CMD;
|
|
event.SystemEvent.AndroidCmd.Cmd = cmd;
|
|
if ( device->postEventFromUser(event) )
|
|
return;
|
|
|
|
switch (cmd)
|
|
{
|
|
case APP_CMD_INPUT_CHANGED:
|
|
os::Printer::log("Android command APP_CMD_INPUT_CHANGED", ELL_DEBUG);
|
|
break;
|
|
case APP_CMD_WINDOW_RESIZED:
|
|
os::Printer::log("Android command APP_CMD_WINDOW_RESIZED", ELL_DEBUG);
|
|
break;
|
|
case APP_CMD_WINDOW_REDRAW_NEEDED:
|
|
os::Printer::log("Android command APP_CMD_WINDOW_REDRAW_NEEDED", ELL_DEBUG);
|
|
break;
|
|
case APP_CMD_SAVE_STATE:
|
|
os::Printer::log("Android command APP_CMD_SAVE_STATE", ELL_DEBUG);
|
|
break;
|
|
case APP_CMD_CONTENT_RECT_CHANGED:
|
|
os::Printer::log("Android command APP_CMD_CONTENT_RECT_CHANGED", ELL_DEBUG);
|
|
break;
|
|
case APP_CMD_CONFIG_CHANGED:
|
|
os::Printer::log("Android command APP_CMD_CONFIG_CHANGED", ELL_DEBUG);
|
|
break;
|
|
case APP_CMD_LOW_MEMORY:
|
|
os::Printer::log("Android command APP_CMD_LOW_MEMORY", ELL_DEBUG);
|
|
break;
|
|
case APP_CMD_START:
|
|
os::Printer::log("Android command APP_CMD_START", ELL_DEBUG);
|
|
break;
|
|
case APP_CMD_INIT_WINDOW:
|
|
os::Printer::log("Android command APP_CMD_INIT_WINDOW", ELL_DEBUG);
|
|
device->getExposedVideoData().OGLESAndroid.Window = app->window;
|
|
|
|
if (device->CreationParams.WindowSize.Width == 0 || device->CreationParams.WindowSize.Height == 0)
|
|
{
|
|
device->CreationParams.WindowSize.Width = ANativeWindow_getWidth(app->window);
|
|
device->CreationParams.WindowSize.Height = ANativeWindow_getHeight(app->window);
|
|
}
|
|
|
|
device->getContextManager()->initialize(device->CreationParams, device->ExposedVideoData);
|
|
device->getContextManager()->generateSurface();
|
|
device->getContextManager()->generateContext();
|
|
device->getContextManager()->activateContext(device->getContextManager()->getContext());
|
|
|
|
if (!device->Initialized)
|
|
{
|
|
io::CAndroidAssetFileArchive* assets = new io::CAndroidAssetFileArchive( device->Android->activity->assetManager, false, false);
|
|
assets->addDirectoryToFileList("");
|
|
device->FileSystem->addFileArchive(assets);
|
|
assets->drop();
|
|
|
|
device->createDriver();
|
|
|
|
if (device->VideoDriver)
|
|
device->createGUIAndScene();
|
|
}
|
|
device->Initialized = true;
|
|
break;
|
|
case APP_CMD_TERM_WINDOW:
|
|
os::Printer::log("Android command APP_CMD_TERM_WINDOW", ELL_DEBUG);
|
|
device->getContextManager()->destroySurface();
|
|
break;
|
|
case APP_CMD_GAINED_FOCUS:
|
|
os::Printer::log("Android command APP_CMD_GAINED_FOCUS", ELL_DEBUG);
|
|
device->Focused = true;
|
|
break;
|
|
case APP_CMD_LOST_FOCUS:
|
|
os::Printer::log("Android command APP_CMD_LOST_FOCUS", ELL_DEBUG);
|
|
device->Focused = false;
|
|
break;
|
|
case APP_CMD_DESTROY:
|
|
os::Printer::log("Android command APP_CMD_DESTROY", ELL_DEBUG);
|
|
if ( device->JNIEnvAttachedToVM )
|
|
{
|
|
device->JNIEnvAttachedToVM = 0;
|
|
device->Android->activity->vm->DetachCurrentThread();
|
|
}
|
|
device->Initialized = false;
|
|
break;
|
|
case APP_CMD_PAUSE:
|
|
os::Printer::log("Android command APP_CMD_PAUSE", ELL_DEBUG);
|
|
device->Paused = true;
|
|
break;
|
|
case APP_CMD_STOP:
|
|
os::Printer::log("Android command APP_CMD_STOP", ELL_DEBUG);
|
|
break;
|
|
case APP_CMD_RESUME:
|
|
os::Printer::log("Android command APP_CMD_RESUME", ELL_DEBUG);
|
|
device->Paused = false;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
s32 CIrrDeviceAndroid::handleInput(android_app* app, AInputEvent* androidEvent)
|
|
{
|
|
CIrrDeviceAndroid* device = (CIrrDeviceAndroid*)app->userData;
|
|
s32 status = 0;
|
|
|
|
switch ( AInputEvent_getType(androidEvent) )
|
|
{
|
|
case AINPUT_EVENT_TYPE_MOTION:
|
|
{
|
|
SEvent event;
|
|
event.EventType = EET_TOUCH_INPUT_EVENT;
|
|
|
|
s32 eventAction = AMotionEvent_getAction(androidEvent);
|
|
s32 eventType = eventAction & AMOTION_EVENT_ACTION_MASK;
|
|
|
|
#if 0
|
|
// Useful for debugging. We might have to pass some of those infos on at some point.
|
|
// but preferably device independent (so iphone can use same irrlicht flags).
|
|
int32_t flags = AMotionEvent_getFlags(androidEvent);
|
|
os::Printer::log("flags: ", core::stringc(flags).c_str(), ELL_DEBUG);
|
|
int32_t metaState = AMotionEvent_getMetaState(androidEvent);
|
|
os::Printer::log("metaState: ", core::stringc(metaState).c_str(), ELL_DEBUG);
|
|
int32_t edgeFlags = AMotionEvent_getEdgeFlags(androidEvent);
|
|
os::Printer::log("edgeFlags: ", core::stringc(flags).c_str(), ELL_DEBUG);
|
|
#endif
|
|
|
|
bool touchReceived = true;
|
|
|
|
switch (eventType)
|
|
{
|
|
case AMOTION_EVENT_ACTION_DOWN:
|
|
case AMOTION_EVENT_ACTION_POINTER_DOWN:
|
|
event.TouchInput.Event = ETIE_PRESSED_DOWN;
|
|
break;
|
|
case AMOTION_EVENT_ACTION_MOVE:
|
|
event.TouchInput.Event = ETIE_MOVED;
|
|
break;
|
|
case AMOTION_EVENT_ACTION_UP:
|
|
case AMOTION_EVENT_ACTION_POINTER_UP:
|
|
case AMOTION_EVENT_ACTION_CANCEL:
|
|
event.TouchInput.Event = ETIE_LEFT_UP;
|
|
break;
|
|
default:
|
|
touchReceived = false;
|
|
break;
|
|
}
|
|
|
|
if (touchReceived)
|
|
{
|
|
// Process all touches for move action.
|
|
if (event.TouchInput.Event == ETIE_MOVED)
|
|
{
|
|
s32 pointerCount = AMotionEvent_getPointerCount(androidEvent);
|
|
|
|
for (s32 i = 0; i < pointerCount; ++i)
|
|
{
|
|
event.TouchInput.ID = AMotionEvent_getPointerId(androidEvent, i);
|
|
event.TouchInput.X = AMotionEvent_getX(androidEvent, i);
|
|
event.TouchInput.Y = AMotionEvent_getY(androidEvent, i);
|
|
event.TouchInput.touchedCount = AMotionEvent_getPointerCount(androidEvent);
|
|
|
|
device->postEventFromUser(event);
|
|
}
|
|
}
|
|
else // Process one touch for other actions.
|
|
{
|
|
s32 pointerIndex = (eventAction & AMOTION_EVENT_ACTION_POINTER_INDEX_MASK) >> AMOTION_EVENT_ACTION_POINTER_INDEX_SHIFT;
|
|
|
|
event.TouchInput.ID = AMotionEvent_getPointerId(androidEvent, pointerIndex);
|
|
event.TouchInput.X = AMotionEvent_getX(androidEvent, pointerIndex);
|
|
event.TouchInput.Y = AMotionEvent_getY(androidEvent, pointerIndex);
|
|
event.TouchInput.touchedCount = AMotionEvent_getPointerCount(androidEvent);
|
|
|
|
device->postEventFromUser(event);
|
|
}
|
|
|
|
status = 1;
|
|
}
|
|
}
|
|
break;
|
|
case AINPUT_EVENT_TYPE_KEY:
|
|
{
|
|
SEvent event;
|
|
event.EventType = EET_KEY_INPUT_EVENT;
|
|
|
|
int32_t keyCode = AKeyEvent_getKeyCode(androidEvent);
|
|
// os::Printer::log("keyCode: ", core::stringc(keyCode).c_str(), ELL_DEBUG);
|
|
|
|
int32_t keyAction = AKeyEvent_getAction(androidEvent);
|
|
int32_t keyMetaState = AKeyEvent_getMetaState(androidEvent);
|
|
|
|
if ( keyCode >= 0 && (u32)keyCode < device->KeyMap.size() )
|
|
event.KeyInput.Key = device->KeyMap[keyCode];
|
|
else
|
|
event.KeyInput.Key = KEY_UNKNOWN;
|
|
event.KeyInput.SystemKeyCode = (u32)keyCode;
|
|
if ( keyAction == AKEY_EVENT_ACTION_DOWN )
|
|
event.KeyInput.PressedDown = true;
|
|
else if ( keyAction == AKEY_EVENT_ACTION_UP )
|
|
event.KeyInput.PressedDown = false;
|
|
else if ( keyAction == AKEY_EVENT_ACTION_MULTIPLE )
|
|
{
|
|
// TODO: Multiple duplicate key events have occurred in a row,
|
|
// or a complex string is being delivered. The repeat_count
|
|
// property of the key event contains the number of times the
|
|
// given key code should be executed.
|
|
// I guess this might necessary for more complicated i18n key input,
|
|
// but don't see yet how to handle this correctly.
|
|
}
|
|
|
|
/* no use for meta keys so far.
|
|
if ( keyMetaState & AMETA_ALT_ON
|
|
|| keyMetaState & AMETA_ALT_LEFT_ON
|
|
|| keyMetaState & AMETA_ALT_RIGHT_ON )
|
|
;
|
|
// what is a sym?
|
|
if ( keyMetaState & AMETA_SYM_ON )
|
|
;
|
|
*/
|
|
if ( keyMetaState & AMETA_SHIFT_ON
|
|
|| keyMetaState & AMETA_SHIFT_LEFT_ON
|
|
|| keyMetaState & AMETA_SHIFT_RIGHT_ON )
|
|
event.KeyInput.Shift = true;
|
|
else
|
|
event.KeyInput.Shift = false;
|
|
event.KeyInput.Control = false;
|
|
|
|
// Having memory allocations + going through JNI for each key-press is pretty bad (slow).
|
|
// So we do it only for those keys which are likely text-characters and avoid it for all other keys.
|
|
// So it's fast for keys like game controller input and special keys. And text keys are typically
|
|
// only used or entering text and not for gaming on Android, so speed likely doesn't matter there too much.
|
|
if ( event.KeyInput.Key > 0 )
|
|
{
|
|
// TODO:
|
|
// Not sure why we have to attach a JNIEnv here, but it won't work when doing that in the constructor or
|
|
// trying to use the activity->env. My best guess is that the event-handling happens in an own thread.
|
|
// It means JNIEnvAttachedToVM will never get detached as I don't know a safe way where to do that
|
|
// (we could attach & detach each time, but that would probably be slow)
|
|
// Also - it has to be each time as it get's invalid when the application mode changes.
|
|
if ( device->Initialized && device->Android && device->Android->activity && device->Android->activity->vm )
|
|
{
|
|
JavaVMAttachArgs attachArgs;
|
|
attachArgs.version = JNI_VERSION_1_6;
|
|
attachArgs.name = 0;
|
|
attachArgs.group = NULL;
|
|
|
|
// Not a big problem calling it each time - it's a no-op when the thread already is attached.
|
|
// And we have to do that as someone else can have detached the thread in the meantime.
|
|
jint result = device->Android->activity->vm->AttachCurrentThread(&device->JNIEnvAttachedToVM, &attachArgs);
|
|
if(result == JNI_ERR)
|
|
{
|
|
os::Printer::log("AttachCurrentThread for the JNI environment failed.", ELL_WARNING);
|
|
device->JNIEnvAttachedToVM = 0;
|
|
}
|
|
|
|
if ( device->JNIEnvAttachedToVM )
|
|
{
|
|
jni::CKeyEventWrapper * keyEventWrapper = new jni::CKeyEventWrapper(device->JNIEnvAttachedToVM, keyAction, keyCode);
|
|
event.KeyInput.Char = keyEventWrapper->getUnicodeChar(keyMetaState);
|
|
delete keyEventWrapper;
|
|
}
|
|
}
|
|
if ( event.KeyInput.Key == KEY_BACK )
|
|
{
|
|
event.KeyInput.Char = 0x08; // same key-code as on other operating systems. Otherwise we have to handle too much system specific stuff in the editbox.
|
|
}
|
|
//os::Printer::log("char-code: ", core::stringc((int)event.KeyInput.Char).c_str(), ELL_DEBUG);
|
|
|
|
}
|
|
else
|
|
{
|
|
// os::Printer::log("keyCode: ", core::stringc(keyCode).c_str(), ELL_DEBUG);
|
|
event.KeyInput.Char = 0;
|
|
}
|
|
|
|
status = device->postEventFromUser(event);
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return status;
|
|
}
|
|
|
|
void CIrrDeviceAndroid::createDriver()
|
|
{
|
|
switch(CreationParams.DriverType)
|
|
{
|
|
case video::EDT_OGLES1:
|
|
#ifdef _IRR_COMPILE_WITH_OGLES1_
|
|
VideoDriver = video::createOGLES1Driver(CreationParams, FileSystem, ContextManager);
|
|
#else
|
|
os::Printer::log("No OpenGL ES 1.0 support compiled in.", ELL_ERROR);
|
|
#endif
|
|
break;
|
|
case video::EDT_OGLES2:
|
|
#ifdef _IRR_COMPILE_WITH_OGLES2_
|
|
VideoDriver = video::createOGLES2Driver(CreationParams, FileSystem, ContextManager);
|
|
#else
|
|
os::Printer::log("No OpenGL ES 2.0 support compiled in.", ELL_ERROR);
|
|
#endif
|
|
break;
|
|
case video::EDT_NULL:
|
|
VideoDriver = video::createNullDriver(FileSystem, CreationParams.WindowSize);
|
|
break;
|
|
case video::EDT_OPENGL:
|
|
os::Printer::log("This driver is not available in Android. Try OpenGL ES 1.0 or ES 2.0.", ELL_ERROR);
|
|
break;
|
|
default:
|
|
os::Printer::log("Unable to create video driver of unknown type.", ELL_ERROR);
|
|
break;
|
|
}
|
|
}
|
|
|
|
video::SExposedVideoData& CIrrDeviceAndroid::getExposedVideoData()
|
|
{
|
|
return ExposedVideoData;
|
|
}
|
|
|
|
void CIrrDeviceAndroid::createKeyMap()
|
|
{
|
|
KeyMap.set_used(223);
|
|
|
|
KeyMap[0] = KEY_UNKNOWN; // AKEYCODE_UNKNOWN
|
|
KeyMap[1] = KEY_LBUTTON; // AKEYCODE_SOFT_LEFT
|
|
KeyMap[2] = KEY_RBUTTON; // AKEYCODE_SOFT_RIGHT
|
|
KeyMap[3] = KEY_HOME; // AKEYCODE_HOME
|
|
KeyMap[4] = KEY_CANCEL; // AKEYCODE_BACK
|
|
KeyMap[5] = KEY_UNKNOWN; // AKEYCODE_CALL
|
|
KeyMap[6] = KEY_UNKNOWN; // AKEYCODE_ENDCALL
|
|
KeyMap[7] = KEY_KEY_0; // AKEYCODE_0
|
|
KeyMap[8] = KEY_KEY_1; // AKEYCODE_1
|
|
KeyMap[9] = KEY_KEY_2; // AKEYCODE_2
|
|
KeyMap[10] = KEY_KEY_3; // AKEYCODE_3
|
|
KeyMap[11] = KEY_KEY_4; // AKEYCODE_4
|
|
KeyMap[12] = KEY_KEY_5; // AKEYCODE_5
|
|
KeyMap[13] = KEY_KEY_6; // AKEYCODE_6
|
|
KeyMap[14] = KEY_KEY_7; // AKEYCODE_7
|
|
KeyMap[15] = KEY_KEY_8; // AKEYCODE_8
|
|
KeyMap[16] = KEY_KEY_9; // AKEYCODE_9
|
|
KeyMap[17] = KEY_UNKNOWN; // AKEYCODE_STAR
|
|
KeyMap[18] = KEY_UNKNOWN; // AKEYCODE_POUND
|
|
KeyMap[19] = KEY_UP; // AKEYCODE_DPAD_UP
|
|
KeyMap[20] = KEY_DOWN; // AKEYCODE_DPAD_DOWN
|
|
KeyMap[21] = KEY_LEFT; // AKEYCODE_DPAD_LEFT
|
|
KeyMap[22] = KEY_RIGHT; // AKEYCODE_DPAD_RIGHT
|
|
KeyMap[23] = KEY_SELECT; // AKEYCODE_DPAD_CENTER
|
|
KeyMap[24] = KEY_VOLUME_DOWN; // AKEYCODE_VOLUME_UP
|
|
KeyMap[25] = KEY_VOLUME_UP; // AKEYCODE_VOLUME_DOWN
|
|
KeyMap[26] = KEY_UNKNOWN; // AKEYCODE_POWER
|
|
KeyMap[27] = KEY_UNKNOWN; // AKEYCODE_CAMERA
|
|
KeyMap[28] = KEY_CLEAR; // AKEYCODE_CLEAR
|
|
KeyMap[29] = KEY_KEY_A; // AKEYCODE_A
|
|
KeyMap[30] = KEY_KEY_B; // AKEYCODE_B
|
|
KeyMap[31] = KEY_KEY_C; // AKEYCODE_C
|
|
KeyMap[32] = KEY_KEY_D; // AKEYCODE_D
|
|
KeyMap[33] = KEY_KEY_E; // AKEYCODE_E
|
|
KeyMap[34] = KEY_KEY_F; // AKEYCODE_F
|
|
KeyMap[35] = KEY_KEY_G; // AKEYCODE_G
|
|
KeyMap[36] = KEY_KEY_H; // AKEYCODE_H
|
|
KeyMap[37] = KEY_KEY_I; // AKEYCODE_I
|
|
KeyMap[38] = KEY_KEY_J; // AKEYCODE_J
|
|
KeyMap[39] = KEY_KEY_K; // AKEYCODE_K
|
|
KeyMap[40] = KEY_KEY_L; // AKEYCODE_L
|
|
KeyMap[41] = KEY_KEY_M; // AKEYCODE_M
|
|
KeyMap[42] = KEY_KEY_N; // AKEYCODE_N
|
|
KeyMap[43] = KEY_KEY_O; // AKEYCODE_O
|
|
KeyMap[44] = KEY_KEY_P; // AKEYCODE_P
|
|
KeyMap[45] = KEY_KEY_Q; // AKEYCODE_Q
|
|
KeyMap[46] = KEY_KEY_R; // AKEYCODE_R
|
|
KeyMap[47] = KEY_KEY_S; // AKEYCODE_S
|
|
KeyMap[48] = KEY_KEY_T; // AKEYCODE_T
|
|
KeyMap[49] = KEY_KEY_U; // AKEYCODE_U
|
|
KeyMap[50] = KEY_KEY_V; // AKEYCODE_V
|
|
KeyMap[51] = KEY_KEY_W; // AKEYCODE_W
|
|
KeyMap[52] = KEY_KEY_X; // AKEYCODE_X
|
|
KeyMap[53] = KEY_KEY_Y; // AKEYCODE_Y
|
|
KeyMap[54] = KEY_KEY_Z; // AKEYCODE_Z
|
|
KeyMap[55] = KEY_COMMA; // AKEYCODE_COMMA
|
|
KeyMap[56] = KEY_PERIOD; // AKEYCODE_PERIOD
|
|
KeyMap[57] = KEY_MENU; // AKEYCODE_ALT_LEFT
|
|
KeyMap[58] = KEY_MENU; // AKEYCODE_ALT_RIGHT
|
|
KeyMap[59] = KEY_LSHIFT; // AKEYCODE_SHIFT_LEFT
|
|
KeyMap[60] = KEY_RSHIFT; // AKEYCODE_SHIFT_RIGHT
|
|
KeyMap[61] = KEY_TAB; // AKEYCODE_TAB
|
|
KeyMap[62] = KEY_SPACE; // AKEYCODE_SPACE
|
|
KeyMap[63] = KEY_UNKNOWN; // AKEYCODE_SYM
|
|
KeyMap[64] = KEY_UNKNOWN; // AKEYCODE_EXPLORER
|
|
KeyMap[65] = KEY_UNKNOWN; // AKEYCODE_ENVELOPE
|
|
KeyMap[66] = KEY_RETURN; // AKEYCODE_ENTER
|
|
KeyMap[67] = KEY_BACK; // AKEYCODE_DEL
|
|
KeyMap[68] = KEY_OEM_3; // AKEYCODE_GRAVE
|
|
KeyMap[69] = KEY_MINUS; // AKEYCODE_MINUS
|
|
KeyMap[70] = KEY_UNKNOWN; // AKEYCODE_EQUALS
|
|
KeyMap[71] = KEY_UNKNOWN; // AKEYCODE_LEFT_BRACKET
|
|
KeyMap[72] = KEY_UNKNOWN; // AKEYCODE_RIGHT_BRACKET
|
|
KeyMap[73] = KEY_UNKNOWN; // AKEYCODE_BACKSLASH
|
|
KeyMap[74] = KEY_UNKNOWN; // AKEYCODE_SEMICOLON
|
|
KeyMap[75] = KEY_UNKNOWN; // AKEYCODE_APOSTROPHE
|
|
KeyMap[76] = KEY_UNKNOWN; // AKEYCODE_SLASH
|
|
KeyMap[77] = KEY_UNKNOWN; // AKEYCODE_AT
|
|
KeyMap[78] = KEY_UNKNOWN; // AKEYCODE_NUM
|
|
KeyMap[79] = KEY_UNKNOWN; // AKEYCODE_HEADSETHOOK
|
|
KeyMap[80] = KEY_UNKNOWN; // AKEYCODE_FOCUS (*Camera* focus)
|
|
KeyMap[81] = KEY_PLUS; // AKEYCODE_PLUS
|
|
KeyMap[82] = KEY_MENU; // AKEYCODE_MENU
|
|
KeyMap[83] = KEY_UNKNOWN; // AKEYCODE_NOTIFICATION
|
|
KeyMap[84] = KEY_UNKNOWN; // AKEYCODE_SEARCH
|
|
KeyMap[85] = KEY_MEDIA_PLAY_PAUSE; // AKEYCODE_MEDIA_PLAY_PAUSE
|
|
KeyMap[86] = KEY_MEDIA_STOP; // AKEYCODE_MEDIA_STOP
|
|
KeyMap[87] = KEY_MEDIA_NEXT_TRACK; // AKEYCODE_MEDIA_NEXT
|
|
KeyMap[88] = KEY_MEDIA_PREV_TRACK; // AKEYCODE_MEDIA_PREVIOUS
|
|
KeyMap[89] = KEY_UNKNOWN; // AKEYCODE_MEDIA_REWIND
|
|
KeyMap[90] = KEY_UNKNOWN; // AKEYCODE_MEDIA_FAST_FORWARD
|
|
KeyMap[91] = KEY_VOLUME_MUTE; // AKEYCODE_MUTE
|
|
KeyMap[92] = KEY_PRIOR; // AKEYCODE_PAGE_UP
|
|
KeyMap[93] = KEY_NEXT; // AKEYCODE_PAGE_DOWN
|
|
KeyMap[94] = KEY_UNKNOWN; // AKEYCODE_PICTSYMBOLS
|
|
KeyMap[95] = KEY_UNKNOWN; // AKEYCODE_SWITCH_CHARSET
|
|
|
|
// following look like controller inputs
|
|
KeyMap[96] = KEY_UNKNOWN; // AKEYCODE_BUTTON_A
|
|
KeyMap[97] = KEY_UNKNOWN; // AKEYCODE_BUTTON_B
|
|
KeyMap[98] = KEY_UNKNOWN; // AKEYCODE_BUTTON_C
|
|
KeyMap[99] = KEY_UNKNOWN; // AKEYCODE_BUTTON_X
|
|
KeyMap[100] = KEY_UNKNOWN; // AKEYCODE_BUTTON_Y
|
|
KeyMap[101] = KEY_UNKNOWN; // AKEYCODE_BUTTON_Z
|
|
KeyMap[102] = KEY_UNKNOWN; // AKEYCODE_BUTTON_L1
|
|
KeyMap[103] = KEY_UNKNOWN; // AKEYCODE_BUTTON_R1
|
|
KeyMap[104] = KEY_UNKNOWN; // AKEYCODE_BUTTON_L2
|
|
KeyMap[105] = KEY_UNKNOWN; // AKEYCODE_BUTTON_R2
|
|
KeyMap[106] = KEY_UNKNOWN; // AKEYCODE_BUTTON_THUMBL
|
|
KeyMap[107] = KEY_UNKNOWN; // AKEYCODE_BUTTON_THUMBR
|
|
KeyMap[108] = KEY_UNKNOWN; // AKEYCODE_BUTTON_START
|
|
KeyMap[109] = KEY_UNKNOWN; // AKEYCODE_BUTTON_SELECT
|
|
KeyMap[110] = KEY_UNKNOWN; // AKEYCODE_BUTTON_MODE
|
|
|
|
KeyMap[111] = KEY_ESCAPE; // AKEYCODE_ESCAPE
|
|
KeyMap[112] = KEY_DELETE; // AKEYCODE_FORWARD_DEL
|
|
KeyMap[113] = KEY_CONTROL; // AKEYCODE_CTRL_LEFT
|
|
KeyMap[114] = KEY_CONTROL; // AKEYCODE_CTRL_RIGHT
|
|
KeyMap[115] = KEY_CAPITAL; // AKEYCODE_CAPS_LOCK
|
|
KeyMap[116] = KEY_SCROLL; // AKEYCODE_SCROLL_LOCK
|
|
KeyMap[117] = KEY_UNKNOWN; // AKEYCODE_META_LEFT
|
|
KeyMap[118] = KEY_UNKNOWN; // AKEYCODE_META_RIGHT
|
|
KeyMap[119] = KEY_UNKNOWN; // AKEYCODE_FUNCTION
|
|
KeyMap[120] = KEY_SNAPSHOT; // AKEYCODE_SYSRQ
|
|
KeyMap[121] = KEY_PAUSE; // AKEYCODE_BREAK
|
|
KeyMap[122] = KEY_HOME; // AKEYCODE_MOVE_HOME
|
|
KeyMap[123] = KEY_END; // AKEYCODE_MOVE_END
|
|
KeyMap[124] = KEY_INSERT; // AKEYCODE_INSERT
|
|
KeyMap[125] = KEY_UNKNOWN; // AKEYCODE_FORWARD
|
|
KeyMap[126] = KEY_PLAY; // AKEYCODE_MEDIA_PLAY
|
|
KeyMap[127] = KEY_MEDIA_PLAY_PAUSE; // AKEYCODE_MEDIA_PAUSE
|
|
KeyMap[128] = KEY_UNKNOWN; // AKEYCODE_MEDIA_CLOSE
|
|
KeyMap[129] = KEY_UNKNOWN; // AKEYCODE_MEDIA_EJECT
|
|
KeyMap[130] = KEY_UNKNOWN; // AKEYCODE_MEDIA_RECORD
|
|
KeyMap[131] = KEY_F1; // AKEYCODE_F1
|
|
KeyMap[132] = KEY_F2; // AKEYCODE_F2
|
|
KeyMap[133] = KEY_F3; // AKEYCODE_F3
|
|
KeyMap[134] = KEY_F4; // AKEYCODE_F4
|
|
KeyMap[135] = KEY_F5; // AKEYCODE_F5
|
|
KeyMap[136] = KEY_F6; // AKEYCODE_F6
|
|
KeyMap[137] = KEY_F7; // AKEYCODE_F7
|
|
KeyMap[138] = KEY_F8; // AKEYCODE_F8
|
|
KeyMap[139] = KEY_F9; // AKEYCODE_F9
|
|
KeyMap[140] = KEY_F10; // AKEYCODE_F10
|
|
KeyMap[141] = KEY_F11; // AKEYCODE_F11
|
|
KeyMap[142] = KEY_F12; // AKEYCODE_F12
|
|
KeyMap[143] = KEY_NUMLOCK; // AKEYCODE_NUM_LOCK
|
|
KeyMap[144] = KEY_NUMPAD0; // AKEYCODE_NUMPAD_0
|
|
KeyMap[145] = KEY_NUMPAD1; // AKEYCODE_NUMPAD_1
|
|
KeyMap[146] = KEY_NUMPAD2; // AKEYCODE_NUMPAD_2
|
|
KeyMap[147] = KEY_NUMPAD3; // AKEYCODE_NUMPAD_3
|
|
KeyMap[148] = KEY_NUMPAD4; // AKEYCODE_NUMPAD_4
|
|
KeyMap[149] = KEY_NUMPAD5; // AKEYCODE_NUMPAD_5
|
|
KeyMap[150] = KEY_NUMPAD6; // AKEYCODE_NUMPAD_6
|
|
KeyMap[151] = KEY_NUMPAD7; // AKEYCODE_NUMPAD_7
|
|
KeyMap[152] = KEY_NUMPAD8; // AKEYCODE_NUMPAD_8
|
|
KeyMap[153] = KEY_NUMPAD9; // AKEYCODE_NUMPAD_9
|
|
KeyMap[154] = KEY_DIVIDE; // AKEYCODE_NUMPAD_DIVIDE
|
|
KeyMap[155] = KEY_MULTIPLY; // AKEYCODE_NUMPAD_MULTIPLY
|
|
KeyMap[156] = KEY_SUBTRACT; // AKEYCODE_NUMPAD_SUBTRACT
|
|
KeyMap[157] = KEY_ADD; // AKEYCODE_NUMPAD_ADD
|
|
KeyMap[158] = KEY_UNKNOWN; // AKEYCODE_NUMPAD_DOT
|
|
KeyMap[159] = KEY_COMMA; // AKEYCODE_NUMPAD_COMMA
|
|
KeyMap[160] = KEY_RETURN; // AKEYCODE_NUMPAD_ENTER
|
|
KeyMap[161] = KEY_UNKNOWN; // AKEYCODE_NUMPAD_EQUALS
|
|
KeyMap[162] = KEY_UNKNOWN; // AKEYCODE_NUMPAD_LEFT_PAREN
|
|
KeyMap[163] = KEY_UNKNOWN; // AKEYCODE_NUMPAD_RIGHT_PAREN
|
|
KeyMap[164] = KEY_VOLUME_MUTE; // AKEYCODE_VOLUME_MUTE
|
|
KeyMap[165] = KEY_UNKNOWN; // AKEYCODE_INFO
|
|
KeyMap[166] = KEY_UNKNOWN; // AKEYCODE_CHANNEL_UP
|
|
KeyMap[167] = KEY_UNKNOWN; // AKEYCODE_CHANNEL_DOWN
|
|
KeyMap[168] = KEY_ZOOM; // AKEYCODE_ZOOM_IN
|
|
KeyMap[169] = KEY_UNKNOWN; // AKEYCODE_ZOOM_OUT
|
|
KeyMap[170] = KEY_UNKNOWN; // AKEYCODE_TV
|
|
KeyMap[171] = KEY_UNKNOWN; // AKEYCODE_WINDOW
|
|
KeyMap[172] = KEY_UNKNOWN; // AKEYCODE_GUIDE
|
|
KeyMap[173] = KEY_UNKNOWN; // AKEYCODE_DVR
|
|
KeyMap[174] = KEY_UNKNOWN; // AKEYCODE_BOOKMARK
|
|
KeyMap[175] = KEY_UNKNOWN; // AKEYCODE_CAPTIONS
|
|
KeyMap[176] = KEY_UNKNOWN; // AKEYCODE_SETTINGS
|
|
KeyMap[177] = KEY_UNKNOWN; // AKEYCODE_TV_POWER
|
|
KeyMap[178] = KEY_UNKNOWN; // AKEYCODE_TV_INPUT
|
|
KeyMap[179] = KEY_UNKNOWN; // AKEYCODE_STB_POWER
|
|
KeyMap[180] = KEY_UNKNOWN; // AKEYCODE_STB_INPUT
|
|
KeyMap[181] = KEY_UNKNOWN; // AKEYCODE_AVR_POWER
|
|
KeyMap[182] = KEY_UNKNOWN; // AKEYCODE_AVR_INPUT
|
|
KeyMap[183] = KEY_UNKNOWN; // AKEYCODE_PROG_RED
|
|
KeyMap[184] = KEY_UNKNOWN; // AKEYCODE_PROG_GREEN
|
|
KeyMap[185] = KEY_UNKNOWN; // AKEYCODE_PROG_YELLOW
|
|
KeyMap[186] = KEY_UNKNOWN; // AKEYCODE_PROG_BLUE
|
|
KeyMap[187] = KEY_UNKNOWN; // AKEYCODE_APP_SWITCH
|
|
KeyMap[188] = KEY_UNKNOWN; // AKEYCODE_BUTTON_1
|
|
KeyMap[189] = KEY_UNKNOWN; // AKEYCODE_BUTTON_2
|
|
KeyMap[190] = KEY_UNKNOWN; // AKEYCODE_BUTTON_3
|
|
KeyMap[191] = KEY_UNKNOWN; // AKEYCODE_BUTTON_4
|
|
KeyMap[192] = KEY_UNKNOWN; // AKEYCODE_BUTTON_5
|
|
KeyMap[193] = KEY_UNKNOWN; // AKEYCODE_BUTTON_6
|
|
KeyMap[194] = KEY_UNKNOWN; // AKEYCODE_BUTTON_7
|
|
KeyMap[195] = KEY_UNKNOWN; // AKEYCODE_BUTTON_8
|
|
KeyMap[196] = KEY_UNKNOWN; // AKEYCODE_BUTTON_9
|
|
KeyMap[197] = KEY_UNKNOWN; // AKEYCODE_BUTTON_10
|
|
KeyMap[198] = KEY_UNKNOWN; // AKEYCODE_BUTTON_11
|
|
KeyMap[199] = KEY_UNKNOWN; // AKEYCODE_BUTTON_12
|
|
KeyMap[200] = KEY_UNKNOWN; // AKEYCODE_BUTTON_13
|
|
KeyMap[201] = KEY_UNKNOWN; // AKEYCODE_BUTTON_14
|
|
KeyMap[202] = KEY_UNKNOWN; // AKEYCODE_BUTTON_15
|
|
KeyMap[203] = KEY_UNKNOWN; // AKEYCODE_BUTTON_16
|
|
KeyMap[204] = KEY_UNKNOWN; // AKEYCODE_LANGUAGE_SWITCH
|
|
KeyMap[205] = KEY_UNKNOWN; // AKEYCODE_MANNER_MODE
|
|
KeyMap[206] = KEY_UNKNOWN; // AKEYCODE_3D_MODE
|
|
KeyMap[207] = KEY_UNKNOWN; // AKEYCODE_CONTACTS
|
|
KeyMap[208] = KEY_UNKNOWN; // AKEYCODE_CALENDAR
|
|
KeyMap[209] = KEY_UNKNOWN; // AKEYCODE_MUSIC
|
|
KeyMap[210] = KEY_UNKNOWN; // AKEYCODE_CALCULATOR
|
|
KeyMap[211] = KEY_UNKNOWN; // AKEYCODE_ZENKAKU_HANKAKU
|
|
KeyMap[212] = KEY_UNKNOWN; // AKEYCODE_EISU
|
|
KeyMap[213] = KEY_UNKNOWN; // AKEYCODE_MUHENKAN
|
|
KeyMap[214] = KEY_UNKNOWN; // AKEYCODE_HENKAN
|
|
KeyMap[215] = KEY_UNKNOWN; // AKEYCODE_KATAKANA_HIRAGANA
|
|
KeyMap[216] = KEY_UNKNOWN; // AKEYCODE_YEN
|
|
KeyMap[217] = KEY_UNKNOWN; // AKEYCODE_RO
|
|
KeyMap[218] = KEY_UNKNOWN; // AKEYCODE_KANA
|
|
KeyMap[219] = KEY_UNKNOWN; // AKEYCODE_ASSIST
|
|
KeyMap[220] = KEY_UNKNOWN; // AKEYCODE_BRIGHTNESS_DOWN
|
|
KeyMap[221] = KEY_UNKNOWN; // AKEYCODE_BRIGHTNESS_UP ,
|
|
KeyMap[222] = KEY_UNKNOWN; // AKEYCODE_MEDIA_AUDIO_TRACK
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::activateAccelerometer(float updateInterval)
|
|
{
|
|
if (!isAccelerometerAvailable())
|
|
return false;
|
|
|
|
ASensorEventQueue_enableSensor(SensorEventQueue, Accelerometer);
|
|
ASensorEventQueue_setEventRate(SensorEventQueue, Accelerometer, (int32_t)(updateInterval*1000.f*1000.f)); // in microseconds
|
|
|
|
os::Printer::log("Activated accelerometer", ELL_DEBUG);
|
|
return true;
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::deactivateAccelerometer()
|
|
{
|
|
if (Accelerometer)
|
|
{
|
|
ASensorEventQueue_disableSensor(SensorEventQueue, Accelerometer);
|
|
Accelerometer = 0;
|
|
os::Printer::log("Deactivated accelerometer", ELL_DEBUG);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::isAccelerometerActive()
|
|
{
|
|
return (Accelerometer != 0);
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::isAccelerometerAvailable()
|
|
{
|
|
if (!Accelerometer)
|
|
Accelerometer = ASensorManager_getDefaultSensor(SensorManager, ASENSOR_TYPE_ACCELEROMETER);
|
|
|
|
return (Accelerometer != 0);
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::activateGyroscope(float updateInterval)
|
|
{
|
|
if (!isGyroscopeAvailable())
|
|
return false;
|
|
|
|
ASensorEventQueue_enableSensor(SensorEventQueue, Gyroscope);
|
|
ASensorEventQueue_setEventRate(SensorEventQueue, Gyroscope, (int32_t)(updateInterval*1000.f*1000.f)); // in microseconds
|
|
|
|
os::Printer::log("Activated gyroscope", ELL_DEBUG);
|
|
return true;
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::deactivateGyroscope()
|
|
{
|
|
if (Gyroscope)
|
|
{
|
|
ASensorEventQueue_disableSensor(SensorEventQueue, Gyroscope);
|
|
Gyroscope = 0;
|
|
os::Printer::log("Deactivated gyroscope", ELL_DEBUG);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::isGyroscopeActive()
|
|
{
|
|
return (Gyroscope != 0);
|
|
}
|
|
|
|
bool CIrrDeviceAndroid::isGyroscopeAvailable()
|
|
{
|
|
if (!Gyroscope)
|
|
Gyroscope = ASensorManager_getDefaultSensor(SensorManager, ASENSOR_TYPE_GYROSCOPE);
|
|
|
|
return (Gyroscope != 0);
|
|
}
|
|
|
|
} // end namespace irr
|