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