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 SensorCollector::EnableSensors(bool enableAccel, bool enableGyro, bool enableMagneto) { if (!(enableAccel || enableGyro || enableMagneto)) { LOGW(LOGTAG_SENSOR,"All sensor enable selections are false..."); return; } int defaultRate = 15; bool success = true; if (enableAccel) { LOGI(LOGTAG_SENSOR,"Enabling accelerometer"); int resultEnable = ASensorEventQueue_enableSensor(sensorQueue,accelSensor); int resultQueue = ASensorEventQueue_setEventRate(sensorQueue,accelSensor, (1000L/ defaultRate)*1000); if (resultEnable < 0) LOGE("Error enabling accelerometer sensor"); if (resultQueue < 0) LOGE("Error setting event rate for accelerometer"); accelEnabled = (resultEnable >= 0 && resultQueue >= 0); success = success && accelEnabled; } if (enableGyro) { LOGI(LOGTAG_SENSOR,"Enabling gyroscope"); int resultEnable = ASensorEventQueue_enableSensor(sensorQueue,gyroSensor); int resultQueue =ASensorEventQueue_setEventRate(sensorQueue,gyroSensor, (1000L/ defaultRate)*1000); if (resultEnable < 0) LOGE("Error enabling gyroscope sensor"); if (resultQueue < 0) LOGE("Error setting event rate for gyroscope"); gyroEnabled = (resultEnable >= 0 && resultQueue >= 0); success = success && gyroEnabled; } if (enableMagneto) { LOGI(LOGTAG_SENSOR,"Enabling magnetic field sensor"); int resultEnable = ASensorEventQueue_enableSensor(sensorQueue,magnetoSensor); int resultQueue =ASensorEventQueue_setEventRate(sensorQueue,magnetoSensor, (1000L/ defaultRate)*1000); if (resultEnable < 0) LOGE("Error enabling magnetic sensor"); if (resultQueue < 0) LOGE("Error setting event rate for magnetic sensor"); magEnabled = (resultEnable >= 0 && resultQueue >= 0); success = success && magEnabled; } if (success) LOGI(LOGTAG_SENSOR,"All sensors enabled successfully!"); }
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::setEnabled(bool enabled) { if (enabled) ASensorEventQueue_enableSensor(sensorEventQueue, m_sensor); else ASensorEventQueue_disableSensor(sensorEventQueue, m_sensor); }
static int SDL_ANDROID_SensorOpen(SDL_Sensor *sensor, int device_index) { struct sensor_hwdata *hwdata; hwdata = (struct sensor_hwdata *)SDL_calloc(1, sizeof(*hwdata)); if (hwdata == NULL) { return SDL_OutOfMemory(); } hwdata->asensor = SDL_sensors[device_index].asensor; hwdata->eventqueue = ASensorManager_createEventQueue(SDL_sensor_manager, SDL_sensor_looper, LOOPER_ID_USER, NULL, NULL); if (!hwdata->eventqueue) { SDL_free(hwdata); return SDL_SetError("Couldn't create sensor event queue"); } if (ASensorEventQueue_enableSensor(hwdata->eventqueue, hwdata->asensor) < 0) { ASensorManager_destroyEventQueue(SDL_sensor_manager, hwdata->eventqueue); SDL_free(hwdata); return SDL_SetError("Couldn't enable sensor"); } /* FIXME: What rate should we set for this sensor? 60 FPS? Let's try the default rate for now... */ sensor->hwdata = hwdata; return 0; }
/** * 繝。繧、繝ウ繧ウ繝槭Φ繝峨�蜃ヲ逅� */ static void engine_handle_cmd(struct android_app* app, int32_t cmd) { struct engine* engine = (struct engine*) app->userData; switch (cmd) { case APP_CMD_SAVE_STATE: engine->app->savedState = malloc(sizeof(struct saved_state)); *((struct saved_state*) engine->app->savedState) = engine->state; engine->app->savedStateSize = sizeof(struct saved_state); break; case APP_CMD_INIT_WINDOW: if (engine->app->window != NULL) { engine_init_display(engine); engine_draw_frame(engine); } break; case APP_CMD_TERM_WINDOW: engine_term_display(engine); break; case APP_CMD_GAINED_FOCUS: if (engine->accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->accelerometerSensor); ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->accelerometerSensor, (1000L / 60) * 1000); } break; case APP_CMD_LOST_FOCUS: if (engine->accelerometerSensor != NULL) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->accelerometerSensor); } engine->animating = 0; engine_draw_frame(engine); break; } }
void resume() { ASensorEventQueue_enableSensor(accelerometerEventQueue, accelerometer); auto status = ASensorEventQueue_setEventRate(accelerometerEventQueue, accelerometer, SENSOR_REFRESH_PERIOD_US); assert(status >= 0); }
status Sensor::enable() { if (mEventLoop.mEnabled) { mSensor = ASensorManager_getDefaultSensor(mEventLoop.mSensorManager, mSensorType); if (mSensor != NULL) { if (ASensorEventQueue_enableSensor(mEventLoop.mSensorEventQueue, mSensor) < 0) { goto ERROR; } int32_t lMinDelay = ASensor_getMinDelay(mSensor); if (ASensorEventQueue_setEventRate(mEventLoop.mSensorEventQueue, mSensor, lMinDelay) < 0) { goto ERROR; } } else { Pegas_log_error("No sensor type %d", mSensorType); } } return STATUS_OK; ERROR: Pegas_log_error("Error while activating sensor."); disable(); return STATUS_KO; }
/* * 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); }
static TCGvoid EngineHandleCmd(struct android_app* app, TCGint cmd) { struct Engine* engine = (struct Engine*)app->userData; switch (cmd) { case APP_CMD_SAVE_STATE: // The system has asked us to save our current state. Do so. engine->app->savedState = TCG_MALLOC(sizeof(struct SavedState), eTCG_MAIN); *((struct SavedState*)engine->app->savedState) = engine->state; engine->app->savedStateSize = sizeof(struct SavedState); break; case APP_CMD_INIT_WINDOW: //窗口初始化 _Lock.Lock(); g_bWindowMax = TCG_TRUE; _Lock.UnLock(); if (engine->app->window != NULL) { g_WindowType = engine->app->window; } break; case APP_CMD_TERM_WINDOW: //窗口销毁 _Lock.Lock(); g_bWindowMax = TCG_FALSE; _Lock.UnLock(); break; case APP_CMD_GAINED_FOCUS: // When our app gains focus, we start monitoring the accelerometer. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->accelerometerSensor); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->accelerometerSensor, (1000L/60)*1000); } break; case APP_CMD_LOST_FOCUS: // When our app loses focus, we stop monitoring the accelerometer. // This is to avoid consuming battery while not being used. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->accelerometerSensor); } // Also stop animating. engine->animating = 0; break; default: break; } }
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!!!!!!!!!!!!!"); } } }
static void enableSensorManager() { if(sstJoystick.u32Frequency > 0 && !sstJoystick.bAccelerometerEnabled) { ASensorEventQueue_enableSensor(sstJoystick.sensorEventQueue, sstJoystick.accelerometerSensor); ASensorEventQueue_setEventRate(sstJoystick.sensorEventQueue, sstJoystick.accelerometerSensor, (1000L/sstJoystick.u32Frequency)*1000); sstJoystick.bAccelerometerEnabled = orxTRUE; } }
void Engine::resumeSensors() { // When our app gains focus, we start monitoring the accelerometer. if( mAccelerometerSensor != NULL ) { ASensorEventQueue_enableSensor( mSensorEventQueue, mAccelerometerSensor ); ASensorEventQueue_setEventRate( mSensorEventQueue, mAccelerometerSensor, (1000L / 30) * 1000 ); } }
void Engine::ResumeSensors() { // When our app gains focus, we start monitoring the accelerometer. if (accelerometer_sensor_ != NULL) { ASensorEventQueue_enableSensor(sensor_event_queue_, accelerometer_sensor_); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(sensor_event_queue_, accelerometer_sensor_, (1000L / 60) * 1000); } }
void SensorManager::Resume() { // When the app gains focus, start monitoring the accelerometer. if (accelerometerSensor_ != NULL) { ASensorEventQueue_enableSensor(sensorEventQueue_, accelerometerSensor_); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(sensorEventQueue_, accelerometerSensor_, (1000L / 60) * 1000); } }
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 setEnableAccelerometer(int32_t framerate){ if(sensors.accelerometerSensor){ ASensorEventQueue_enableSensor(sensors.sensorEventQueue, sensors.accelerometerSensor); ASensorEventQueue_setEventRate( sensors.sensorEventQueue, sensors.accelerometerSensor, framerate); } }
/** * Process the next main command. */ static void engine_handle_cmd(struct android_app* app, int32_t cmd) { struct engine* engine = (struct engine*)app->userData; switch (cmd) { case APP_CMD_SAVE_STATE: // The system has asked us to save our current state. Do so. engine->app->savedState = malloc(sizeof(struct saved_state)); *((struct saved_state*)engine->app->savedState) = engine->state; engine->app->savedStateSize = sizeof(struct saved_state); break; case APP_CMD_INIT_WINDOW: // The window is being shown, get it ready. if (engine->app->window != NULL) { engine_init_display(engine); nuiAndroidBridge::androidResize(ANativeWindow_getWidth(app->window), ANativeWindow_getHeight(app->window)); nuiButton* pButton = new nuiButton("Prout!"); // pButton->SetPosition(nuiCenter); gpBridge->AddChild(pButton); engine_draw_frame(engine); engine->animating = 1; } break; case APP_CMD_TERM_WINDOW: // The window is being hidden or closed, clean it up. engine_term_display(engine); break; case APP_CMD_GAINED_FOCUS: // When our app gains focus, we start monitoring the accelerometer. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->accelerometerSensor); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->accelerometerSensor, (1000L/60)*1000); } break; case APP_CMD_LOST_FOCUS: // When our app loses focus, we stop monitoring the accelerometer. // This is to avoid consuming battery while not being used. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->accelerometerSensor); } // Also stop animating. engine->animating = 1; engine_draw_frame(engine); break; } }
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::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; }
/*********************************************************************************** * Process the next main command. **********************************************************************************/ static void engine_handle_cmd(struct android_app* app, int32_t cmd) { struct engine* engine = (struct engine*)app->userData; switch (cmd) { case APP_CMD_SAVE_STATE: // The system has asked us to save our current state. Do so. engine->app->savedState = malloc(sizeof(struct saved_state)); *((struct saved_state*)engine->app->savedState) = engine->state; engine->app->savedStateSize = sizeof(struct saved_state); break; case APP_CMD_INIT_WINDOW: // The window is being shown, get it ready. LOGI("APP_CMD_INIT_WINDOW 11"); if (engine->app->window != NULL) { engine_init_display(engine); //engine_draw_frame(engine); } break; case APP_CMD_TERM_WINDOW: LOGI("APP_CMD_TERM_WINDOW 11"); // The window is being hidden or closed, clean it up. engine_term_display(engine); break; case APP_CMD_GAINED_FOCUS: // When our app gains focus, we start monitoring the accelerometer. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->accelerometerSensor); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->accelerometerSensor, (1000L/60)*1000); } break; case APP_CMD_LOST_FOCUS: // When our app loses focus, we stop monitoring the accelerometer. // This is to avoid consuming battery while not being used. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->accelerometerSensor); } //engine_draw_frame(engine); break; } }
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 enableAccelerometer(void) { LOGI("enableAccelerometer()"); if (engine.accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(engine.sensorEventQueue, engine.accelerometerSensor); // Set a default sample rate // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(engine.sensorEventQueue, engine.accelerometerSensor, (1000L/60)*1000); } }
// センサーからの値取得を許可する void enable_sensors(struct engine* engine) { int i; for (i = 0; i < SENSOR_MAX; i++) { sensor_type* st = &engine->sensors[i]; if (st->sensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, /////-----(1) st->sensor); // 値を取得する周期を設定する ASensorEventQueue_setEventRate(engine->sensorEventQueue, /////-----(2) st->sensor, (1000L / 60) * 1000); } } }
/** * Process the next main command. */ static void engine_handle_cmd(struct android_app* app, int32_t cmd) { struct engine* engine = (struct engine*)app->userData; switch (cmd) { case APP_CMD_SAVE_STATE: LOGI("from APP_CMD_SAVE_STATE\n"); saveState(app); break; case APP_CMD_INIT_WINDOW: LOGI("from APP_CMD_INIT_WINDOW\n"); // The window is being shown, get it ready. if (engine->app->window != NULL) { engine_init_display(engine); engine_init_shaders(engine); engine_draw_frame(engine); } break; case APP_CMD_TERM_WINDOW: LOGI("from APP_CMD_TERM_WINDOW\n"); // The window is being hidden or closed, clean it up. cleanup(engine); break; case APP_CMD_GAINED_FOCUS: saveState(app); #if 0 // When our app gains focus, we start monitoring the accelerometer. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->accelerometerSensor); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->accelerometerSensor, (1000L/60)*1000); } #endif LOGI("from APP_CMD_GAINED_FOCUS\n"); break; case APP_CMD_LOST_FOCUS: LOGI("from APP_CMD_LOST_FOCUS\n"); // When our app loses focus, we stop monitoring the accelerometer. // This is to avoid consuming battery while not being used. if (engine->accelerometerSensor != NULL) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->accelerometerSensor); } // Also stop animating. engine->animating = 0; engine_draw_frame(engine); break; } }
/** * Process the next main command. */ static void window_handle_cmd(struct android_app* app, int32_t cmd) { la_window_t* window = (la_window_t*)app->userData; switch (cmd) { case APP_CMD_SAVE_STATE: la_print("---------------------------- app save state"); // The system has asked us to save our current state. Do so. // window->app->savedState = malloc(sizeof(struct saved_state)); // *((struct saved_state*)window->app->savedState) = NULL;//window->state; // window->app->savedStateSize = sizeof(struct saved_state); break; case APP_CMD_INIT_WINDOW: // The window is being shown, get it ready. if (window->app->window != NULL) { window_init_display(window); la_port_swap_buffers(window); } main(0, NULL); break; case APP_CMD_TERM_WINDOW: // The cross-platform window kill. la_window_kill__(window); // The window is being hidden or closed, clean it up. window_term_display(window); break; case APP_CMD_GAINED_FOCUS: // When our app gains focus, we start monitoring the accelerometer. if (window->accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(window->sensorEventQueue, window->accelerometerSensor); // We'd like to get 60 events per second (in us). ASensorEventQueue_setEventRate(window->sensorEventQueue, window->accelerometerSensor, (1000L/60)*1000); } break; case APP_CMD_LOST_FOCUS: // When our app loses focus, we stop monitoring the accelerometer. // This is to avoid consuming battery while not being used. if (window->accelerometerSensor != NULL) { ASensorEventQueue_disableSensor(window->sensorEventQueue, window->accelerometerSensor); } la_port_swap_buffers(window); break; } }
void gdk_android_handle_glue_cmd(struct android_app* app, int32_t cmd) { GError *err = NULL; //GTKAndroidInitPhase *engine = (GTKAndroidInitPhase *) app->userData; switch (cmd) { case APP_CMD_SAVE_STATE: // The system has asked us to save our current state. Do so. app->savedState = NULL; app->savedStateSize = 0; break; case APP_CMD_INIT_WINDOW: // The window is being shown, get it ready. if (app->window != NULL && !gdk_android_init_display(app, &err)) { g_error("%s", err->message); g_error_free(err); } break; case APP_CMD_TERM_WINDOW: if (gdk_android_stop) gdk_android_stop(); break; case APP_CMD_PAUSE: case APP_CMD_STOP: if (gdk_android_stop) gdk_android_stop(); break; case APP_CMD_GAINED_FOCUS: // When our app gains focus, we start monitoring the accelerometer. if (accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(sensorEventQueue, accelerometerSensor); ASensorEventQueue_setEventRate(sensorEventQueue, accelerometerSensor, 0.5); } break; case APP_CMD_LOST_FOCUS: // When our app loses focus, we stop monitoring the accelerometer. // This is to avoid consuming battery while not being used. if (accelerometerSensor != NULL) ASensorEventQueue_disableSensor(sensorEventQueue, accelerometerSensor); break; } }
/** *处理下一主命令。 */ static void engine_handle_cmd(struct android_app* app, int32_t cmd) { struct engine* engine = (struct engine*)app->userData; switch (cmd) { case APP_CMD_SAVE_STATE: //系统已经要求我们保存当前状态。就这样做。 engine->app->savedState = malloc(sizeof(struct saved_state)); *((struct saved_state*)engine->app->savedState) = engine->state; engine->app->savedStateSize = sizeof(struct saved_state); break; case APP_CMD_INIT_WINDOW: //正在显示窗口,让其准备就绪。 if (engine->app->window != NULL) { engine_init_display(engine); engine_draw_frame(engine); } break; case APP_CMD_TERM_WINDOW: //正在隐藏或关闭窗口,请其进行清理。 engine_term_display(engine); break; case APP_CMD_GAINED_FOCUS: //当我们的应用获得焦点时,我们开始监控加速计。 if (engine->accelerometerSensor != NULL) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->accelerometerSensor); //我们想要每秒获得 60 个事件(在美国)。 ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->accelerometerSensor, (1000L / 60) * 1000); } break; case APP_CMD_LOST_FOCUS: //当我们的应用程序失去焦点时,我们会停止监控加速计。 //这可在不使用时避免使用电池。 if (engine->accelerometerSensor != NULL) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->accelerometerSensor); } //另外,停止动画。 engine->animating = 0; engine_draw_frame(engine); break; } }
static void engine_handle_command(struct android_app* app, int32_t cmd) { struct engine* engine = (struct engine*)app->userData; switch (cmd) { case APP_CMD_SAVE_STATE: app_save_state_callback(); break; case APP_CMD_INIT_WINDOW: if (engine->app->window != nullptr) { engine_init_display(engine); engine_draw_frame(engine); } break; case APP_CMD_TERM_WINDOW: engine_term_display(engine); break; case APP_CMD_GAINED_FOCUS: if (engine->accelerometerSensor != nullptr) { ASensorEventQueue_enableSensor(engine->sensorEventQueue, engine->accelerometerSensor); ASensorEventQueue_setEventRate(engine->sensorEventQueue, engine->accelerometerSensor, (1000L/60)*1000); accelerometer_enable_callback(); } break; case APP_CMD_LOST_FOCUS: if (engine->accelerometerSensor != nullptr) { ASensorEventQueue_disableSensor(engine->sensorEventQueue, engine->accelerometerSensor); accelerometer_disable_callback(); } engine_draw_frame(engine); break; } }
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 = AcquireASensorManagerInstance(); 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(); }