bool CorePlatformAndroid::InitializeAndroidEnvironment(AppHandle handle)
{
appHandle = handle;
appHandle->userData = this;
appHandle->onAppCmd = CorePlatformAndroid::HandleCommand;
appHandle->onInputEvent = CorePlatformAndroid::HandleInput;
// Prepare to monitor accelerometer
sensorManager = ASensorManager_getInstance();
//TODO: temporary disabled
accelerometerSensor = ASensorManager_getDefaultSensor(sensorManager, ASENSOR_TYPE_ACCELEROMETER);
sensorEventQueue = ASensorManager_createEventQueue(sensorManager, appHandle->looper, LOOPER_ID_USER, NULL, NULL);
assetManager = handle->activity->assetManager;
if (appHandle->savedState != NULL)
{
// We are starting with a previous saved state; restore from it.
savedState = *(SavedState*)appHandle->savedState;
}
return true;
}
static int
SDL_ANDROID_SensorInit(void)
{
int i, sensors_count;
ASensorList sensors;
SDL_sensor_manager = ASensorManager_getInstance();
if (!SDL_sensor_manager) {
return SDL_SetError("Couldn't create sensor manager");
}
SDL_sensor_looper = ALooper_forThread();
if (!SDL_sensor_looper) {
SDL_sensor_looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
if (!SDL_sensor_looper) {
return SDL_SetError("Couldn't create sensor event loop");
}
}
/* FIXME: Is the sensor list dynamic? */
sensors_count = ASensorManager_getSensorList(SDL_sensor_manager, &sensors);
if (sensors_count > 0) {
SDL_sensors = (SDL_AndroidSensor *)SDL_calloc(sensors_count, sizeof(*SDL_sensors));
if (!SDL_sensors) {
return SDL_OutOfMemory();
}
for (i = 0; i < sensors_count; ++i) {
SDL_sensors[i].asensor = sensors[i];
SDL_sensors[i].instance_id = SDL_GetNextSensorInstanceID();
}
SDL_sensors_count = sensors_count;
}
return 0;
}
//センサーの初期化
void init_sensors(struct engine* engine,struct android_app* state) {
// センサーマネージャの取得
ASensorList list;
int sensor_list[] = {
ASENSOR_TYPE_ACCELEROMETER, ASENSOR_TYPE_MAGNETIC_FIELD,
ASENSOR_TYPE_GYROSCOPE, ASENSOR_TYPE_LIGHT, ASENSOR_TYPE_PROXIMITY
};
engine->sensorManager = ASensorManager_getInstance(); /////-----(1)
// 利用可能なセンサーの一覧を取得
int num = ASensorManager_getSensorList(engine->sensorManager, &list); /////-----(2)
int i, j;
// バッファの初期化
for (i = 0; i < SENSOR_MAX; i++) {
engine->sensors[i].sensor = NULL;
engine->sensors[i].type = sensor_list[i];
}
// センサーのデータ取得準備
for (i = 0; i < num; i++) {
ASensorRef sensor = list[i];
int type = ASensor_getType(sensor); // センサーのTYPEを取得 /////-----(3)
LOGI("type=%d sensor=%s", type, ASensor_getName(sensor));
// センサーから値を取得できるようにする
for (j = 0; j < SENSOR_MAX; j++) {
if ((type == engine->sensors[j].type) && (engine->sensors[j].sensor == NULL)) {
engine->sensors[j].sensor = ASensorManager_getDefaultSensor( /////-----(4)
engine->sensorManager, type);
break;
}
}
}
// センサー情報取得キューの新規作成
engine->sensorEventQueue = ASensorManager_createEventQueue( /////-----(5)
engine->sensorManager, state->looper, LOOPER_ID_USER, NULL, NULL);
}
//-------------------------------------------------------------------------
// Sensor handlers
//-------------------------------------------------------------------------
void Engine::InitSensors() {
sensor_manager_ = ASensorManager_getInstance();
accelerometer_sensor_ = ASensorManager_getDefaultSensor(
sensor_manager_, ASENSOR_TYPE_ACCELEROMETER);
sensor_event_queue_ = ASensorManager_createEventQueue(
sensor_manager_, app_->looper, LOOPER_ID_USER, NULL, NULL);
}
void SensorManager::Init(android_app *app) {
sensorManager_ = ASensorManager_getInstance();
accelerometerSensor_ = ASensorManager_getDefaultSensor(
sensorManager_, ASENSOR_TYPE_ACCELEROMETER);
sensorEventQueue_ = ASensorManager_createEventQueue(
sensorManager_, app->looper, LOOPER_ID_USER, NULL, NULL);
}
void EventLoop::activate()
{
if ((!enabled_) && (application_->window != 0))
{
sensorPollSource_.id = LOOPER_ID_USER;
sensorPollSource_.app = application_;
sensorPollSource_.process = callback_sensor;
sensorManager_ = ASensorManager_getInstance();
if (sensorManager_ != 0)
{
sensorEventQueue_ =
ASensorManager_createEventQueue(sensorManager_,
application_->looper,
LOOPER_ID_USER,
0,
&sensorPollSource_);
if (sensorEventQueue_ == 0) return;
}
quit_ = false;
enabled_ = true;
if (activity_->onActivate() != 0)
{
quit_ = true;
deactivate();
ANativeActivity_finish(application_->activity);
}
}
return;
}
xl_ekf_context *xl_ekf_context_create() {
xl_ekf_context *ctx = (xl_ekf_context *) malloc(sizeof(xl_ekf_context));
memset(ctx, 0, sizeof(xl_ekf_context));
// ctx->sensor_manager = ASensorManager_getInstanceForPackage("com.cls.xl.xl");
ctx->sensor_manager = ASensorManager_getInstance();
ctx->acc = ASensorManager_getDefaultSensor(ctx->sensor_manager, ASENSOR_TYPE_ACCELEROMETER);
ctx->gyro = ASensorManager_getDefaultSensor(ctx->sensor_manager, ASENSOR_TYPE_GYROSCOPE);
ctx->acc_min_delay = ASensor_getMinDelay(ctx->acc);
ctx->gyro_min_delay = ASensor_getMinDelay(ctx->gyro);
if (ctx->acc == NULL || ctx->gyro == NULL) {
free(ctx);
return NULL;
}
ctx->looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ctx->event_queue = ASensorManager_createEventQueue(
ctx->sensor_manager,
ctx->looper,
LOOPER_ID_USER,
NULL,
NULL
);
ASensorEventQueue_enableSensor(ctx->event_queue, ctx->acc);
ASensorEventQueue_enableSensor(ctx->event_queue, ctx->gyro);
int acc_delay = 20000;
int gyro_delay = 20000;
acc_delay = acc_delay > ctx->acc_min_delay ? acc_delay : ctx->acc_min_delay;
gyro_delay = gyro_delay > ctx->gyro_min_delay ? gyro_delay : ctx->gyro_min_delay;
ASensorEventQueue_setEventRate(ctx->event_queue, ctx->acc, acc_delay);
ASensorEventQueue_setEventRate(ctx->event_queue, ctx->gyro, gyro_delay);
ctx->lock = malloc(sizeof(pthread_mutex_t));
pthread_mutex_init(ctx->lock, NULL);
return ctx;
}
void GoAndroid_createManager() {
ASensorManager* manager = ASensorManager_getInstance();
looper = ALooper_forThread();
if (looper == NULL) {
looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
}
queue = ASensorManager_createEventQueue(manager, looper, GO_ANDROID_SENSOR_LOOPER_ID, NULL, NULL);
}
void android_main(struct android_app* state)
{
app_dummy();
state->userData = &app;
// Prepare to monitor accelerometer
app.sensorManager = ASensorManager_getInstance();
app.sensorEventQueue = ASensorManager_createEventQueue(app.sensorManager, state->looper, LOOPER_ID_USER, NULL, NULL);
if (state->savedState != NULL)
{
// We are starting with a previous saved state; restore from it.
app.state = *(AppState*)state->savedState;
}
if(gRoot == NULL)
{
gRoot = new Ogre::Root();
#ifdef OGRE_STATIC_LIB
gStaticPluginLoader = new Ogre::StaticPluginLoader();
gStaticPluginLoader->load();
#endif
gRoot->setRenderSystem(gRoot->getAvailableRenderers().at(0));
gRoot->initialise(false);
}
state->onAppCmd = &handleCmd;
state->onInputEvent = &handleInput;
int ident, events;
struct android_poll_source* source;
while (true)
{
while ((ident = ALooper_pollAll(0, NULL, &events, (void**)&source)) >= 0)
{
if (source != NULL)
{
source->process(state, source);
}
if (state->destroyRequested != 0)
{
return;
}
}
if(gRenderWnd != NULL && gRenderWnd->isActive())
{
gRenderWnd->windowMovedOrResized();
gRoot->renderOneFrame();
InitGameScene();
}
}
}
JNIEXPORT void JNICALL Java_org_nzdis_sensorspeed_CMagneticField_magneticFieldStartup (JNIEnv *e, jclass c, jobject handler) {
updateHandler = handler;
env = e;
jclass handlerClass = env->FindClass("org/nzdis/sensorspeed/CMagneticField");
if (handlerClass == NULL) {
LOGI("big error 1");
}
mid = env->GetMethodID(handlerClass, "onSensorChanged", "()V");
if (mid == NULL) {
LOGI("big error 2");
}
ASensorEvent event;
int events, ident;
ASensorManager * sensorManager;
const ASensor* magSensor;
void* sensor_data = malloc(10000);
SENSORS_ENABLED = 1;
ALooper* looper = ALooper_forThread();
if (looper == NULL) {
looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
}
sensorManager = ASensorManager_getInstance();
magSensor = ASensorManager_getDefaultSensor(sensorManager, ASENSOR_TYPE_MAGNETIC_FIELD);
sensorEventQueue = ASensorManager_createEventQueue(sensorManager, looper, LOOPER_ID,
(ALooper_callbackFunc)get_sensorevents, sensor_data);
ASensorEventQueue_enableSensor(sensorEventQueue, magSensor);
int minDelay = ASensor_getMinDelay(magSensor);
//LOGI("min-delay: %d", minDelay);
ASensorEventQueue_setEventRate(sensorEventQueue, magSensor, (1000L/SAMP_PER_SEC)*1000);
while ((ident = ALooper_pollAll(-1, NULL, &events, NULL) >= 0)) {
// If a sensor has data, process it now.
if (ident == LOOPER_ID) {
LOGI("magneticFieldStartup() - LOOPER!!!!!!!!");
ASensorEvent event;
while (ASensorEventQueue_getEvents(sensorEventQueue, &event, 1) > 0) {
if (event.type == ASENSOR_TYPE_MAGNETIC_FIELD) {
env->CallVoidMethod(updateHandler, mid);
magneticfield_x = event.magnetic.x;
magneticfield_y = event.magnetic.y;
magneticfield_z = event.magnetic.z;
}
}
} else {
LOGI("magneticFieldStartup() - else!!!!!!!!!!!!!");
}
}
}
int GoAndroid_enableSensor(int s, int32_t usec) {
ASensorManager* manager = ASensorManager_getInstance();
const ASensor* sensor = ASensorManager_getDefaultSensor(manager, s);
if (sensor == NULL) {
return 1;
}
ASensorEventQueue_enableSensor(queue, sensor);
ASensorEventQueue_setEventRate(queue, sensor, usec);
return 0;
}
static void createSensorsEventQueue(){
//get sensor istance
sensors.sensorManager = ASensorManager_getInstance();
//create queue
sensors.sensorEventQueue =
ASensorManager_createEventQueue(
sensors.sensorManager,
getAndroidApp()->looper,
LOOPER_ID_USER, NULL, NULL);
}
void setup_sensors() {
ASensorEvent event;
int events, ident;
ASensorManager * sensorManager;
const ASensor* accSensor;
const ASensor* gyroSensor;
const ASensor* magSensor;
void* sensor_data = malloc(10000);
LOGI("sensorValue() - ALooper_forThread()");
SENSORS_ENABLED = 1;
ALooper* looper = ALooper_forThread();
if (looper == NULL) {
looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
}
sensorManager = ASensorManager_getInstance();
accSensor = ASensorManager_getDefaultSensor(sensorManager,
ASENSOR_TYPE_ACCELEROMETER);
gyroSensor = ASensorManager_getDefaultSensor(sensorManager,
ASENSOR_TYPE_GYROSCOPE);
magSensor = ASensorManager_getDefaultSensor(sensorManager,
ASENSOR_TYPE_MAGNETIC_FIELD);
sensorEventQueue = ASensorManager_createEventQueue(sensorManager, looper, LOOPER_ID,
(ALooper_callbackFunc)get_sensorevents, sensor_data);
ASensorEventQueue_enableSensor(sensorEventQueue, accSensor);
ASensorEventQueue_enableSensor(sensorEventQueue, gyroSensor);
ASensorEventQueue_enableSensor(sensorEventQueue, magSensor);
//Sampling rate: 100Hz
int a = ASensor_getMinDelay(accSensor);
int b = ASensor_getMinDelay(gyroSensor);
int c = ASensor_getMinDelay(magSensor);
LOGI("min-delay: %d, %d, %d", a, b, c);
ASensorEventQueue_setEventRate(sensorEventQueue, accSensor, (1000L/SAMP_PER_SEC)*1000);
ASensorEventQueue_setEventRate(sensorEventQueue, gyroSensor, (1000L/SAMP_PER_SEC)*1000);
ASensorEventQueue_setEventRate(sensorEventQueue, magSensor, (1000L/SAMP_PER_SEC)*1000);
LOGI("sensorValue() - START");
while ((ident = ALooper_pollAll(-1, NULL, &events, NULL) >= 0)) {
// If a sensor has data, process it now.
if (ident == LOOPER_ID) {
ASensorEvent event;
while (ASensorEventQueue_getEvents(sensorEventQueue, &event, 1) > 0) {
LOGI("accelerometer X = %f y = %f z=%f ", event.acceleration.x, event.acceleration.y, event.acceleration.z);
}
}
}
}
void SensorImpl::init()
{
// looper for threading
ns_looper = ALooper_forThread();
// get sensor manager
ns_sensorManager = ASensorManager_getInstance();
// create sensor event queue & attach to looper
ns_sensorEventQueue = ASensorManager_createEventQueue(ns_sensorManager, ns_looper, 1, &getSensorEvents, nullptr);
}
static void* AndroidEventThreadWorker( void* param )
{
struct android_app* state = (struct android_app*)param;
FPlatformProcess::SetThreadAffinityMask(FPlatformAffinity::GetMainGameMask());
FPlatformMisc::LowLevelOutputDebugString(L"Entering event processing thread engine entry point");
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(looper, state->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
&state->cmdPollSource);
state->looper = looper;
FPlatformMisc::LowLevelOutputDebugString(L"Prepared looper for event thread");
//Assign the callbacks
state->onAppCmd = OnAppCommandCB;
state->onInputEvent = HandleInputCB;
FPlatformMisc::LowLevelOutputDebugString(L"Passed callback initialization");
// Acquire sensors
SensorManager = ASensorManager_getInstance();
if (NULL != SensorManager)
{
// Register for the various sensor events we want. Some
// may return NULL indicating that the sensor data is not
// available in the device. For those empty data will eventually
// get fed into the motion events.
SensorAccelerometer = ASensorManager_getDefaultSensor(
SensorManager, ASENSOR_TYPE_ACCELEROMETER);
SensorGyroscope = ASensorManager_getDefaultSensor(
SensorManager, ASENSOR_TYPE_GYROSCOPE);
// Create the queue for events to arrive.
SensorQueue = ASensorManager_createEventQueue(
SensorManager, state->looper, LOOPER_ID_USER, HandleSensorEvents, NULL);
}
FPlatformMisc::LowLevelOutputDebugString(L"Passed sensor initialization");
//continue to process events until the engine is shutting down
while (!GIsRequestingExit)
{
// FPlatformMisc::LowLevelOutputDebugString(L"AndroidEventThreadWorker");
AndroidProcessEvents(state);
sleep(EventRefreshRate); // this is really 0 since it takes int seconds.
}
UE_LOG(LogAndroid, Log, TEXT("Exiting"));
return NULL;
}
void SensorImpl::initialize()
{
// Get the looper associated with this thread
looper = ALooper_forThread();
// Get the unique sensor manager
sensorManager = ASensorManager_getInstance();
// Create the sensor events queue and attach it to the looper
sensorEventQueue = ASensorManager_createEventQueue(sensorManager, looper,
1, &processSensorEvents, NULL);
}
void android_main(struct android_app* state)
{
struct engine engine;
// Make sure glue isn't stripped.
app_dummy();
memset(&engine, 0, sizeof(engine));
state->userData = &engine;
state->onAppCmd = engine_handle_command;
state->onInputEvent = engine_handle_input;
engine.app = state;
engine.sensorManager = ASensorManager_getInstance();
engine.accelerometerSensor = ASensorManager_getDefaultSensor(engine.sensorManager, ASENSOR_TYPE_ACCELEROMETER);
engine.sensorEventQueue = ASensorManager_createEventQueue(engine.sensorManager, state->looper, LOOPER_ID_USER, 0, 0);
ANativeActivity* nativeActivity = state->activity;
android_pre_init_filesystem(state);
while (1)
{
int ident;
int events;
struct android_poll_source* source;
while ((ident=ALooper_pollAll(engine.animating ? 0 : -1, 0, &events, (void**)&source)) >= 0)
{
if (source != nullptr)
{
source->process(state, source);
}
if (ident == LOOPER_ID_USER)
{
if (engine.accelerometerSensor != nullptr)
{
ASensorEvent event;
while (ASensorEventQueue_getEvents(engine.sensorEventQueue, &event, 1) > 0)
{
accelerometer_input_callback(event.acceleration.x, event.acceleration.y, event.acceleration.z);
}
}
}
if (state->destroyRequested != 0)
{
engine_term_display(&engine);
return;
}
}
if (engine.animating)
{
engine_draw_frame(&engine);
}
}
}
/*
* Class: io_quadroid_ndk_QuadroidLib
* Method: init
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_io_quadroid_UDPSensor_ndk_QuadroidLib_init(JNIEnv *env, jclass clazz) {
sensorManager = ASensorManager_getInstance();
looper = ALooper_forThread();
if(looper == NULL) {
looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
}
queue = ASensorManager_createEventQueue(sensorManager, looper, LOOPER_ID, get_sensor_events, NULL);
if(USE_PRESSURE==1) {
pressureSensor = ASensorManager_getDefaultSensor(sensorManager, 6);
ASensorEventQueue_enableSensor(queue, pressureSensor);
ASensorEventQueue_setEventRate(queue, pressureSensor, SAMP_PER_SEC);
}
if(USE_ACCELEROMETER==1) {
acceSensor = ASensorManager_getDefaultSensor(sensorManager, ASENSOR_TYPE_ACCELEROMETER);
ASensorEventQueue_enableSensor(queue, acceSensor);
ASensorEventQueue_setEventRate(queue, acceSensor, SAMP_PER_SEC);
log_acce = ASensor_getMinDelay(acceSensor);
}
if(USE_GYROSCOPE==1) {
gyroSensor = ASensorManager_getDefaultSensor(sensorManager, ASENSOR_TYPE_GYROSCOPE);
ASensorEventQueue_enableSensor(queue, gyroSensor);
ASensorEventQueue_setEventRate(queue, gyroSensor, SAMP_PER_SEC);
log_gyro = ASensor_getMinDelay(gyroSensor);
}
if(USE_MAGNETIC==1) {
magnSensor = ASensorManager_getDefaultSensor(sensorManager, ASENSOR_TYPE_MAGNETIC_FIELD);
ASensorEventQueue_enableSensor(queue, magnSensor);
ASensorEventQueue_setEventRate(queue, magnSensor, SAMP_PER_SEC);
log_magn = ASensor_getMinDelay(magnSensor);
}
if(USE_DISTANCE==1) {
proxSensor = ASensorManager_getDefaultSensor(sensorManager, ASENSOR_TYPE_PROXIMITY);
ASensorEventQueue_enableSensor(queue, proxSensor);
ASensorEventQueue_setEventRate(queue, proxSensor, SAMP_PER_SEC);
}
currentTime = time(0);
ALooper_pollAll(-1, NULL, &events, NULL);
}
gkAndroidApp::gkAndroidApp(android_app* state)
: m_state(state),
m_window(NULL) {
state->userData = this;
state->onAppCmd = handleCmd;
state->onInputEvent = handleInput;
// prepare to monitor accelerometer
ASensorManager *sensorManager = ASensorManager_getInstance();
m_accelerometerSensor = ASensorManager_getDefaultSensor(sensorManager,
ASENSOR_TYPE_ACCELEROMETER);
m_sensorEventQueue = ASensorManager_createEventQueue(sensorManager,
state->looper, LOOPER_ID_USER, NULL, NULL);
ANativeActivity_setWindowFlags(state->activity,
AWINDOW_FLAG_FULLSCREEN | AWINDOW_FLAG_KEEP_SCREEN_ON, 0);
}
int defaultInitializeApplication()
{
struct android_app *vid = main_view_id;
if (is_valid(vid) == false)
return Failed;
gy::r3::initialize(GY_RENDERER_OPENGLES);
asset_manager = vid->activity->assetManager;
sensor_manager = ASensorManager_getInstance();
sensor_accelerometer = ASensorManager_getDefaultSensor(sensor_manager, ASENSOR_TYPE_ACCELEROMETER);
sensor_gyroscope = ASensorManager_getDefaultSensor(sensor_manager, ASENSOR_TYPE_GYROSCOPE);
sensor_event_queue = ASensorManager_createEventQueue(sensor_manager, vid->looper, LOOPER_ID_USER, NullPtr, NullPtr);
vid->onAppCmd = gy__onApplicationCommand;
vid->onInputEvent = gy__onInputEvent;
return Success;
}
TCGvoid TCGClient::AndroidInit(struct android_app* state)
{
state->userData = &m_engineObj;
state->onAppCmd = EngineHandleCmd;
state->onInputEvent = EngineHandleInput;
m_engineObj.app = state;
// Prepare to monitor accelerometer
m_engineObj.sensorManager = ASensorManager_getInstance();
m_engineObj.accelerometerSensor = ASensorManager_getDefaultSensor(m_engineObj.sensorManager, ASENSOR_TYPE_ACCELEROMETER);
m_engineObj.sensorEventQueue = ASensorManager_createEventQueue(m_engineObj.sensorManager, state->looper, LOOPER_ID_USER, NULL, NULL);
if (state->savedState != NULL)
{
// We are starting with a previous saved state; restore from it.
m_engineObj.state = *(struct SavedState*)state->savedState;
}
}
void EventLoop::activate()
{
Pegas_log_info("EventLoop::activate");
if((!mEnabled) && (mApplication->window != NULL))
{
mSensorPollSource.id = LOOPER_ID_USER;
mSensorPollSource.app = mApplication;
mSensorPollSource.process = callback_sensor;
mSensorManager = ASensorManager_getInstance();
if (mSensorManager != NULL)
{
mSensorEventQueue = ASensorManager_createEventQueue(mSensorManager,
mApplication->looper, LOOPER_ID_USER, NULL, &mSensorPollSource);
if (mSensorEventQueue == NULL)
{
Pegas_log_warning("EventLoop::activate:");
Pegas_log_warning("ASensorManager_createEventQueue == NULL");
goto ERROR;
}
}
mQuit = false;
mEnabled = true;
if(mActivityHandler->onActivate() != STATUS_OK)
{
Pegas_log_warning("EventLoop::activate:");
Pegas_log_warning("mActivityHandler->onActivate() != STATUS_OK");
goto ERROR;
}
}
return;
ERROR:
Pegas_log_info("Application finish");
mQuit = true;
deactivate();
ANativeActivity_finish(mApplication->activity);
}
void QuerySensors() {
int I;
State->Manager = ASensorManager_getInstance();
State->Count = ASensorManager_getSensorList(State->Manager, &State->Sensors);
State->Info = (InfoStructure *) malloc(State->Count * sizeof(InfoStructure));
LOG(ANDROID_LOG_INFO, "Found %d sensors", State->Count);
for (I = 0; I < State->Count; I++) {
State->Info[I].Index = I;
State->Info[I].Type = ASensor_getType(State->Sensors[I]);
State->Info[I].Vendor = ASensor_getVendor(State->Sensors[I]);
State->Info[I].Name = ASensor_getName(State->Sensors[I]);
State->Info[I].Delay = ASensor_getMinDelay(State->Sensors[I]);
State->Info[I].Resolution = ASensor_getResolution(State->Sensors[I]);
LOG(ANDROID_LOG_INFO, "Sensor: %d, %s, %s, %dus, %f", State->Info[I].Type,
State->Info[I].Vendor,
State->Info[I].Name, State->Info[I].Delay,
State->Info[I].Resolution);
State->Info[I].Shift = 0;
}
}
void initializeEngine(struct android_app* state, Engine * engine)
{
if (engine->animating == 1)
{
LOGI(LOGTAG_MAIN,"Engine already initialized. Returning.");
return;
}
LOGI(LOGTAG_MAIN,"Initializing engine");
//Define engine properties
engine->animating = 1;
//Call this to ensure "glue isn't stripped" (w/e that means..)
app_dummy();
state->onAppCmd = engineHandleCommand;
state->onInputEvent = engineHandleInput;
engine->app = state;
//Default image size
engine->imageWidth = CAMERA_IMAGE_WIDTH;
engine->imageHeight = CAMERA_IMAGE_HEIGHT;
//Initialize objects
try
{
LOGI(LOGTAG_MAIN,"Initializing stateful classes");
engine->imageCollector = new ImageCollector(engine->imageWidth, engine->imageHeight);
engine->inputHandler = new AndroidInputHandler();
engine->sensorCollector = new SensorCollector(ASensorManager_getInstance(), state->looper);
engine->communicator = new ARCommunicator(arClientObject);
engine->preferenceManager = new PreferenceManager(myActivity);
engine->animating = 1;
}
catch (Exception & e)
{
LOGE("Error initializing: %s",e.what());
}
}
void init(AAssetManager *assetManager) {
AAsset *vertexShaderAsset = AAssetManager_open(assetManager, "shader.glslv",
AASSET_MODE_BUFFER);
assert(vertexShaderAsset != NULL);
const void *vertexShaderBuf = AAsset_getBuffer(vertexShaderAsset);
assert(vertexShaderBuf != NULL);
off_t vertexShaderLength = AAsset_getLength(vertexShaderAsset);
vertexShaderSource = std::string((const char*)vertexShaderBuf,
(size_t)vertexShaderLength);
AAsset_close(vertexShaderAsset);
AAsset *fragmentShaderAsset = AAssetManager_open(assetManager, "shader.glslf",
AASSET_MODE_BUFFER);
assert(fragmentShaderAsset != NULL);
const void *fragmentShaderBuf = AAsset_getBuffer(fragmentShaderAsset);
assert(fragmentShaderBuf != NULL);
off_t fragmentShaderLength = AAsset_getLength(fragmentShaderAsset);
fragmentShaderSource = std::string((const char*)fragmentShaderBuf,
(size_t)fragmentShaderLength);
AAsset_close(fragmentShaderAsset);
sensorManager = ASensorManager_getInstance();
assert(sensorManager != NULL);
accelerometer = ASensorManager_getDefaultSensor(sensorManager, ASENSOR_TYPE_ACCELEROMETER);
assert(accelerometer != NULL);
looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
assert(looper != NULL);
accelerometerEventQueue = ASensorManager_createEventQueue(sensorManager, looper,
LOOPER_ID_USER, NULL, NULL);
assert(accelerometerEventQueue != NULL);
auto status = ASensorEventQueue_enableSensor(accelerometerEventQueue,
accelerometer);
assert(status >= 0);
status = ASensorEventQueue_setEventRate(accelerometerEventQueue,
accelerometer,
SENSOR_REFRESH_PERIOD_US);
assert(status >= 0);
(void)status; //to silent unused compiler warning
generateXPos();
}
void SensorHandler::InitializeHandler() {
// Set and prepare looper
SensorHandler::tsInstance().looper = ALooper_forThread();
if (SensorHandler::tsInstance().looper == NULL) {
SensorHandler::tsInstance().looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
}
SensorHandler::tsInstance().sensorManager = ASensorManager_getInstance();
SensorHandler::tsInstance().accelerometerSensor = ASensorManager_getDefaultSensor(
SensorHandler::tsInstance().sensorManager, ASENSOR_TYPE_ACCELEROMETER);
SensorHandler::tsInstance().magneticSensor = ASensorManager_getDefaultSensor(
SensorHandler::tsInstance().sensorManager, ASENSOR_TYPE_MAGNETIC_FIELD);
SensorHandler::tsInstance().gyroscopeSensor = ASensorManager_getDefaultSensor(
SensorHandler::tsInstance().sensorManager, ASENSOR_TYPE_GYROSCOPE);
// Create event queue for sensor events
SensorHandler::tsInstance().sensorEventQueue = ASensorManager_createEventQueue(
SensorHandler::tsInstance().sensorManager, SensorHandler::tsInstance().looper,
3, SensorCallback, sensor_data);
ASensorEventQueue_enableSensor(SensorHandler::tsInstance().sensorEventQueue,
SensorHandler::tsInstance().accelerometerSensor);
ASensorEventQueue_enableSensor(SensorHandler::tsInstance().sensorEventQueue,
SensorHandler::tsInstance().magneticSensor);
ASensorEventQueue_enableSensor(SensorHandler::tsInstance().sensorEventQueue,
SensorHandler::tsInstance().gyroscopeSensor);
// Target sampling rate 100Hz
int a = ASensor_getMinDelay(accelerometerSensor);
int b = ASensor_getMinDelay(magneticSensor);
int c = ASensor_getMinDelay(gyroscopeSensor);
LOGI("Minimum delay; acceleration = %d magnetic = %d gyroscope = %d",a,b,c);
ASensorEventQueue_setEventRate(SensorHandler::tsInstance().sensorEventQueue,
SensorHandler::tsInstance().accelerometerSensor, 100000);
ASensorEventQueue_setEventRate(SensorHandler::tsInstance().sensorEventQueue,
SensorHandler::tsInstance().magneticSensor, 100000);
ASensorEventQueue_setEventRate(SensorHandler::tsInstance().sensorEventQueue,
SensorHandler::tsInstance().gyroscopeSensor, 100000);
}
void startSensor() {
ALooper* looper = ALooper_forThread();
if (looper == NULL) {
looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
}
engine.sensorManager = ASensorManager_getInstance();
// get sensor
// engine.accelerometerSensor = ASensorManager_getDefaultSensor(
// engine.sensorManager, ASENSOR_TYPE_ACCELEROMETER);
engine.gyroscopeSensor = ASensorManager_getDefaultSensor(
engine.sensorManager, ASENSOR_TYPE_GYROSCOPE);
// engine.magneticSensor = ASensorManager_getDefaultSensor(
// engine.sensorManager, ASENSOR_TYPE_MAGNETIC_FIELD);
// engine.accelerometerEventQueue = ASensorManager_createEventQueue(
// engine.sensorManager, looper, LOOPER_ID_USER_ACCELEROMETER,
// accelerometerCallback, &engine);
engine.gyroscopeEventQueue = ASensorManager_createEventQueue(
engine.sensorManager, looper, LOOPER_ID_USER_GYROSCOPE,
gyroscopeCallback, &engine);
// engine.magneticEventQueue = ASensorManager_createEventQueue(
// engine.sensorManager, looper, LOOPER_ID_USER_MAGNETIC,
// magneticCallback, &engine);
// enable sensor
// int a = ASensor_getMinDelay(engine.accelerometerSensor);
// int b = ASensor_getMinDelay(engine.gyroscopeSensor);
// int c = ASensor_getMinDelay(engine.magneticSensor);
// LOGI("min-delay: %d, %d, %d", a, b, c);
// ASensorEventQueue_setEventRate(engine.accelerometerEventQueue,
// engine.accelerometerSensor, 1000);
ASensorEventQueue_setEventRate(engine.gyroscopeEventQueue,
engine.gyroscopeSensor, 100);
// ASensorEventQueue_setEventRate(engine.magneticEventQueue,
// engine.magneticSensor, 1000);
// ASensorEventQueue_enableSensor(engine.accelerometerEventQueue,
// engine.accelerometerSensor);
ASensorEventQueue_enableSensor(engine.gyroscopeEventQueue,
engine.gyroscopeSensor);
// ASensorEventQueue_enableSensor(engine.magneticEventQueue,
// engine.magneticSensor);
}
Window::Window( WindowCreationData const& wcd )
: m_app( wcd.app )
, m_lstateready( false )
, m_finishrequired( false )
, m_finished( false )
{
m_silent = utils::MainConf->boolean( "silent", false );
if( !m_silent )
{
m_app->userData = this;
m_app->onAppCmd = &g_handle_cmd;
m_app->onInputEvent = &g_handle_input;
m_sensorManager = ASensorManager_getInstance();
m_accelerometerSensor = ASensorManager_getDefaultSensor(
m_sensorManager, ASENSOR_TYPE_ACCELEROMETER );
m_sensorEventQueue = ASensorManager_createEventQueue(
m_sensorManager, m_app->looper, LOOPER_ID_USER, 0, 0 );
if( m_app->savedState )
{
}
}
}
void gdk_android_setup_app_callbacks(struct android_app *state, void (*onStop)())
{
if (0)
{
ASensorManager* sensorManager = NULL;
sensorManager = ASensorManager_getInstance();
accelerometerSensor = ASensorManager_getDefaultSensor(sensorManager,
ASENSOR_TYPE_ACCELEROMETER);
sensorEventQueue = ASensorManager_createEventQueue(sensorManager, state->looper,
LOOPER_ID_USER, NULL, NULL);
}
gdk_android_stop = onStop;
state->onAppCmd = gdk_android_handle_glue_cmd;
state->activity->callbacks->onNativeWindowResized = onNativeWindowResized;
state->activity->callbacks->onNativeWindowRedrawNeeded = onNativeWindowRedrawNeeded;
state->activity->callbacks->onContentRectChanged = onContentRectChanged;
state->activity->callbacks->onLowMemory = onLowMemory;
// TODO: consider overriding state->inputPollSource.process instead of the following
// or should we even get rid of this native_app for good?
state->onInputEvent = android_handle_input;
}
void android_main(struct android_app* state) {
struct engine engine;
// Make sure glue isn't stripped.
app_dummy();
memset(&engine, 0, sizeof(engine));
state->userData = &engine;
state->onAppCmd = engine_handle_cmd;
state->onInputEvent = engine_handle_input;
engine.app = state;
engine.requested_quit=false;
engine.os=NULL;
engine.display_active=false;
FileAccessAndroid::asset_manager=state->activity->assetManager;
// Prepare to monitor accelerometer
engine.sensorManager = ASensorManager_getInstance();
engine.accelerometerSensor = ASensorManager_getDefaultSensor(engine.sensorManager,
ASENSOR_TYPE_ACCELEROMETER);
engine.sensorEventQueue = ASensorManager_createEventQueue(engine.sensorManager,
state->looper, LOOPER_ID_USER, NULL, NULL);
ANativeActivity_setWindowFlags(state->activity,AWINDOW_FLAG_FULLSCREEN|AWINDOW_FLAG_KEEP_SCREEN_ON,0);
state->activity->vm->AttachCurrentThread(&engine.jni, NULL);
// loop waiting for stuff to do.
while (1) {
// Read all pending events.
int ident;
int events;
struct android_poll_source* source;
// If not animating, we will block forever waiting for events.
// If animating, we loop until all events are read, then continue
// to draw the next frame of animation.
int nullmax=50;
while ((ident=ALooper_pollAll(engine.animating ? 0 : -1, NULL, &events,
(void**)&source)) >= 0) {
// Process this event.
if (source != NULL) {
// LOGI("process\n");
source->process(state, source);
} else {
nullmax--;
if (nullmax<0)
break;
}
// If a sensor has data, process it now.
// LOGI("events\n");
if (ident == LOOPER_ID_USER) {
if (engine.accelerometerSensor != NULL) {
ASensorEvent event;
while (ASensorEventQueue_getEvents(engine.sensorEventQueue,
&event, 1) > 0) {
if (engine.os) {
engine.os->process_accelerometer(Vector3(event.acceleration.x, event.acceleration.y,
event.acceleration.z));
}
}
}
}
// Check if we are exiting.
if (state->destroyRequested != 0) {
if (engine.os) {
engine.os->main_loop_request_quit();
}
state->destroyRequested=0;
}
if (engine.requested_quit) {
engine_term_display(&engine);
exit(0);
return;
}
// LOGI("end\n");
}
// LOGI("engine animating? %i\n",engine.animating);
if (engine.animating) {
//do os render
engine_draw_frame(&engine);
//LOGI("TERM WINDOW");
}
}
}
