void* SkiaAndroidApp::pthread_main(void* arg) {
SkDebugf("pthread_main begins");
auto skiaAndroidApp = (SkiaAndroidApp*)arg;
// Because JNIEnv is thread sensitive, we need AttachCurrentThread to set our fPThreadEnv
skiaAndroidApp->fJavaVM->AttachCurrentThread(&(skiaAndroidApp->fPThreadEnv), nullptr);
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
pipe(skiaAndroidApp->fPipes);
ALooper_addFd(looper, skiaAndroidApp->fPipes[0], LOOPER_ID_MESSAGEPIPE, ALOOPER_EVENT_INPUT,
message_callback, skiaAndroidApp);
skiaAndroidApp->fApp = Application::Create(0, nullptr, skiaAndroidApp);
double currentTime = 0.0;
double previousTime = 0.0;
while (true) {
const int ident = ALooper_pollAll(0, nullptr, nullptr, nullptr);
if (ident >= 0) {
SkDebugf("Unhandled ALooper_pollAll ident=%d !", ident);
} else {
previousTime = currentTime;
currentTime = now_ms();
skiaAndroidApp->fApp->onIdle(currentTime - previousTime);
}
}
SkDebugf("pthread_main ends");
return nullptr;
}
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 *cxAndroid::AndroidEntry(void *data)
{
cxAndroid *app = (cxAndroid *)data;
AConfiguration_fromAssetManager(app->config, app->activity->assetManager);
app->cmd.id = LOOPER_ID_MAIN;
app->cmd.app = app;
app->cmd.process = cxAndroid::cxAndroidExec;
app->input.id = LOOPER_ID_INPUT;
app->input.app = app;
app->input.process = cxAndroid::cxAndroidInputExec;
app->looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(app->looper, app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,&app->cmd);
pthread_mutex_lock(&app->mutex);
app->running = true;
pthread_cond_broadcast(&app->cond);
pthread_mutex_unlock(&app->mutex);
app->cxAndroidMain();
pthread_mutex_lock(&app->mutex);
if (app->inputQueue != NULL) {
AInputQueue_detachLooper(app->inputQueue);
app->inputQueue = NULL;
}
AConfiguration_delete(app->config);
app->config = NULL;
app->destroyed = true;
pthread_cond_broadcast(&app->cond);
pthread_mutex_unlock(&app->mutex);
return data;
}
static void* android_app_entry(void* param) {
struct android_app* android_app = (struct android_app*)param;
android_app->config = AConfiguration_new();
AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
print_cur_config(android_app);
android_app->cmdPollSource.id = LOOPER_ID_MAIN;
android_app->cmdPollSource.app = android_app;
android_app->cmdPollSource.process = process_cmd;
android_app->inputPollSource.id = LOOPER_ID_INPUT;
android_app->inputPollSource.app = android_app;
android_app->inputPollSource.process = process_input;
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
&android_app->cmdPollSource);
android_app->looper = looper;
pthread_mutex_lock(&android_app->mutex);
android_app->running = 1;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
android_main(android_app);
android_app_destroy(android_app);
return NULL;
}
void* SkiaAndroidApp::pthread_main(void* arg) {
SkDebugf("pthread_main begins");
auto skiaAndroidApp = (SkiaAndroidApp*)arg;
// Because JNIEnv is thread sensitive, we need AttachCurrentThread to set our fPThreadEnv
skiaAndroidApp->fJavaVM->AttachCurrentThread(&(skiaAndroidApp->fPThreadEnv), nullptr);
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
pipe(skiaAndroidApp->fPipes);
ALooper_addFd(looper, skiaAndroidApp->fPipes[0], LOOPER_ID_MESSAGEPIPE, ALOOPER_EVENT_INPUT,
message_callback, skiaAndroidApp);
int ident;
int events;
struct android_poll_source* source;
skiaAndroidApp->fApp = Application::Create(0, nullptr, skiaAndroidApp);
while ((ident = ALooper_pollAll(-1, nullptr, &events, (void**)&source)) >= 0) {
SkDebugf("ALooper_pollAll ident=%d", ident);
}
return nullptr;
}
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;
}
static void frontend_android_init(void *data)
{
JNIEnv *env;
ALooper *looper;
jclass class = NULL;
jobject obj = NULL;
struct android_app* android_app = (struct android_app*)data;
if (!android_app)
return;
looper = (ALooper*)ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL, NULL);
android_app->looper = looper;
slock_lock(android_app->mutex);
android_app->running = 1;
scond_broadcast(android_app->cond);
slock_unlock(android_app->mutex);
memset(&g_android, 0, sizeof(g_android));
g_android = (struct android_app*)android_app;
RARCH_LOG("Waiting for Android Native Window to be initialized ...\n");
while (!android_app->window)
{
if (!android_run_events(android_app))
{
frontend_android_deinit(android_app);
frontend_android_shutdown(android_app);
return;
}
}
RARCH_LOG("Android Native Window initialized.\n");
env = jni_thread_getenv();
if (!env)
return;
GET_OBJECT_CLASS(env, class, android_app->activity->clazz);
GET_METHOD_ID(env, android_app->getIntent, class, "getIntent", "()Landroid/content/Intent;");
CALL_OBJ_METHOD(env, obj, android_app->activity->clazz, android_app->getIntent);
#if 0
GET_METHOD_ID(env, android_app->hasPendingIntent, class, "hasPendingIntent", "()Z");
GET_METHOD_ID(env, android_app->clearPendingIntent, class, "clearPendingIntent", "()V");
GET_METHOD_ID(env, android_app->getPendingIntentConfigPath, class, "getPendingIntentConfigPath",
"()Ljava/lang/String;");
GET_METHOD_ID(env, android_app->getPendingIntentLibretroPath, class, "getPendingIntentLibretroPath",
"()Ljava/lang/String;");
GET_METHOD_ID(env, android_app->getPendingIntentFullPath, class, "getPendingIntentFullPath",
"()Ljava/lang/String;");
GET_METHOD_ID(env, android_app->getPendingIntentIME, class, "getPendingIntentIME",
"()Ljava/lang/String;");
#endif
GET_OBJECT_CLASS(env, class, obj);
GET_METHOD_ID(env, android_app->getStringExtra, class, "getStringExtra", "(Ljava/lang/String;)Ljava/lang/String;");
}
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);
}
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!!!!!!!!!!!!!");
}
}
}
Device::Device(int32_t id, int fd, std::unique_ptr<DeviceCallback> callback) :
mId(id), mFd(fd), mDeviceCallback(std::move(callback)) {
ALooper* aLooper = ALooper_forThread();
if (aLooper == NULL) {
LOGE("Could not get ALooper, ALooper_forThread returned NULL");
aLooper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
}
ALooper_addFd(aLooper, fd, 0, ALOOPER_EVENT_INPUT, handleLooperEvents,
reinterpret_cast<void*>(this));
}
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 message_dispatcher::prepare()
{
scoped_lock lock(m_mutex);
m_looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
if (!m_looper)
throw std::runtime_error("cannot create the internal looper");
ALooper_addFd(m_looper, m_readfd, MSG_ID_SYSTEM, ALOOPER_EVENT_INPUT, NULL, NULL);
if (m_iqueue) {
attach_queue(m_iqueue);
}
}
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;
}
static void initializeMain(ActivityStates* states)
{
// Protect from concurrent access
Lock lock(states->mutex);
// Prepare and share the looper to be read later
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
states->looper = looper;
// Get the default configuration
states->config = AConfiguration_new();
AConfiguration_fromAssetManager(states->config, states->activity->assetManager);
}
/*
* 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);
}
void ConfigureSampling(JNIEnv *JNI, jobject Self) {
int I;
State->Looper = ALooper_forThread();
if (NULL == State->Looper) {
State->Looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
}
for (I = 0; I < State->Count; I++) {
if (0 == State->Info[I].Interval) {
LOG(ANDROID_LOG_INFO, "Event queue for sensor #%d not created", I);
continue;
}
State->Info[I].Queue = ASensorManager_createEventQueue(State->Manager, State->Looper,
0xDEF00ABC, SampleHandler,
&(State->Info[I]));
LOG(ANDROID_LOG_INFO, "Event queue for sensor #%d created", I);
}
State->Data = (*JNI)->NewGlobalRef(JNI, CallSelfData(JNI, Self));
State->Exchange = (*JNI)->NewGlobalRef(JNI, (*JNI)->NewByteArray(JNI, State->Maximum));
pthread_mutex_init(&State->Lock, NULL);
}
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();
}
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 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);
int setEventRateResult = ASensorEventQueue_setEventRate(accelerometerEventQueue,
accelerometer,
int32_t(1000000 /
SENSOR_REFRESH_RATE));
int enableSensorResult = ASensorEventQueue_enableSensor(accelerometerEventQueue,
accelerometer);
assert(enableSensorResult >= 0);
generateXPos();
}
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);
}
void* SkiaAndroidApp::pthread_main(void* arg) {
SkDebugf("pthread_main begins");
auto skiaAndroidApp = (SkiaAndroidApp*)arg;
// Because JNIEnv is thread sensitive, we need AttachCurrentThread to set our fPThreadEnv
skiaAndroidApp->fJavaVM->AttachCurrentThread(&(skiaAndroidApp->fPThreadEnv), nullptr);
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
pipe(skiaAndroidApp->fPipes);
ALooper_addFd(looper, skiaAndroidApp->fPipes[0], LOOPER_ID_MESSAGEPIPE, ALOOPER_EVENT_INPUT,
message_callback, skiaAndroidApp);
static const char* gCmdLine[] = {
"viewer",
// TODO: figure out how to use am start with extra params to pass in additional arguments at
// runtime. Or better yet make an in app switch to enable
// "--atrace",
};
skiaAndroidApp->fApp = Application::Create(SK_ARRAY_COUNT(gCmdLine),
const_cast<char**>(gCmdLine),
skiaAndroidApp);
while (true) {
const int ident = ALooper_pollAll(0, nullptr, nullptr, nullptr);
if (ident >= 0) {
SkDebugf("Unhandled ALooper_pollAll ident=%d !", ident);
} else {
skiaAndroidApp->fApp->onIdle();
}
}
SkDebugf("pthread_main ends");
return nullptr;
}
// Called before main() to initialize JNI bindings
static void orxAndroid_Init(JNIEnv* mEnv, jobject jActivity)
{
LOGI("orxAndroid_Init()");
jclass objClass;
orxAndroid_JNI_SetupThread();
sstAndroid.mActivity = mEnv->NewGlobalRef(jActivity);
objClass = mEnv->FindClass("org/orx/lib/OrxActivity");
sstAndroid.midGetRotation = mEnv->GetMethodID(objClass, "getRotation","()I");
sstAndroid.midGetDeviceIds = mEnv->GetMethodID(objClass, "getDeviceIds", "()[I");
if(!sstAndroid.midGetRotation
|| !sstAndroid.midGetDeviceIds) {
__android_log_print(ANDROID_LOG_WARN, "Orx", "Couldn't locate Java callbacks, check that they're named and typed correctly");
}
// setup AssetManager
jmethodID midGetAssets = mEnv->GetMethodID(objClass, "getAssets", "()Landroid/content/res/AssetManager;");
jobject jAssetManager = mEnv->CallObjectMethod(jActivity, midGetAssets);
sstAndroid.jAssetManager = mEnv->NewGlobalRef(jAssetManager);
sstAndroid.poAssetManager = AAssetManager_fromJava(mEnv, sstAndroid.jAssetManager);
mEnv->DeleteLocalRef(objClass);
mEnv->DeleteLocalRef(jActivity);
mEnv->DeleteLocalRef(jAssetManager);
sstAndroid.looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(sstAndroid.looper, sstAndroid.pipeCmd[0], LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL, NULL);
ALooper_addFd(sstAndroid.looper, sstAndroid.pipeKeyEvent[0], LOOPER_ID_KEY_EVENT, ALOOPER_EVENT_INPUT, NULL, NULL);
ALooper_addFd(sstAndroid.looper, sstAndroid.pipeTouchEvent[0], LOOPER_ID_TOUCH_EVENT, ALOOPER_EVENT_INPUT, NULL, NULL);
ALooper_addFd(sstAndroid.looper, sstAndroid.pipeJoystickEvent[0], LOOPER_ID_JOYSTICK_EVENT, ALOOPER_EVENT_INPUT, NULL, NULL);
LOGI("orxAndroid_Init() finished!");
}
JNIEXPORT jboolean JNICALL Java_edu_ucla_nesl_sigma_base_SigmaJNI_waitForMessage
(JNIEnv *env, jclass _class, jint fd) {
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALOGD("waitForMessage: pollOnce looper@%d fd@%d", (int)looper, fd);
ALooper_addFd(looper, fd, fd, ALOOPER_EVENT_INPUT, NULL, NULL);
int events;
int result = ALooper_pollOnce(-1, NULL, &events, NULL);
if (result == ALOOPER_POLL_ERROR) {
ALOGE("waitForMessage error (errno=%d)", errno);
result = -1337; // unknown error, so we make up one
return JNI_FALSE;
}
if (events & ALOOPER_EVENT_HANGUP) {
// the other-side has died
ALOGE("waitForMessage error HANGUP");
result = -1337; // unknown error, so we make up one
return JNI_FALSE;
}
return JNI_TRUE;
ALOGD("waitForMessage: got something.");
}
// try and open up the JoyWarrior file descriptor
bool CSensorAndroidBuiltIn::detect()
{
setType();
setPort();
// get the singleton instance of the m_pSensorManager
if (!m_pSensorManager) m_pSensorManager = (ASensorManager*) ASensorManager_getInstance();
/*
// sensor listing
ASensorList pSensorList = NULL;
int iNum = ASensorManager_getSensorList(m_pSensorManager, &pSensorList);
if (iNum && pSensorList) {
fprintf(stdout, "\n\n%d Detected Sensors:\n", iNum);
//int i = 0;
for (int i=0; i < iNum; i++) {
//while (i<10 && (pSensorList+i)) { //for (int i=0; i < iNum; i++) {
fprintf(stdout, " %s\n", ASensor_getName(*(pSensorList+i)));
i++;
}
}
else {
fprintf(stdout, "\n\nNo Sensor List? %d\n\n", iNum);
}
*/
// create looper
m_pLooper = ALooper_forThread(); // get existing looper
if (!m_pLooper) { // make new looper
//m_pLooper = ALooper_prepare(0);
m_pLooper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
}
if (!m_pLooper) { // no existing or new looper -- error
fprintf(stderr, "can't create Looper\n");
return false; // can't create looper
}
// setup event queue
//m_pSensorEventQueue = ASensorManager_createEventQueue(m_pSensorManager, m_pLooper,
// LOOPER_ID_QCN, QCN_ALooper_callback, &l_SensorVector);
m_pSensorEventQueue = ASensorManager_createEventQueue(m_pSensorManager, m_pLooper,
LOOPER_ID_QCN, NULL, NULL);
if (!m_pSensorEventQueue) {
fprintf(stderr, "can't create SensorEventQueue\n");
return false; // can't setup queue
}
// get the default accelerometer
m_pSensor = (ASensor*) ASensorManager_getDefaultSensor(m_pSensorManager, ASENSOR_TYPE_ACCELEROMETER);
if (!m_pSensor) {
//fprintf(stdout, "No Android accelerometer detected.\n");
return false; // no sensor
}
int iRetVal = 0;
if ((iRetVal = ASensorEventQueue_enableSensor(m_pSensorEventQueue, m_pSensor)) < 0) {
fprintf(stderr, "Error in enableSensor %d\n", iRetVal);
return false;
};
m_fResolution = ASensor_getResolution(m_pSensor);
m_minDelayMsec = ASensor_getMinDelay(m_pSensor);
int rateMsec = (int)((sm->dt > 0. ? sm->dt : g_DT) * 1000.);
//fprintf(stdout, "Rates: m_minDelayMSec = %d raceMsec = %d\n", m_minDelayMsec, rateMsec);
//if (rateMsec > m_minDelayMsec) m_minDelayMsec = rateMsec;
if (rateMsec < m_minDelayMsec) m_minDelayMsec = rateMsec;
fprintf(stdout, "Setting data rate to %d Hz\n", 1000L/m_minDelayMsec);
strlcpy(m_strSensor, ASensor_getName(m_pSensor), _MAX_PATH);
strlcpy(m_strVendor, ASensor_getVendor(m_pSensor), _MAX_PATH);
// NB: the rate is in microseconds!
if ((iRetVal = ASensorEventQueue_setEventRate(m_pSensorEventQueue, m_pSensor, m_minDelayMsec * 1000L)) < 0) {
fprintf(stderr, "Error in setEventRate %d\n", iRetVal);
// return false; // not really a fatal error
}
fprintf(stdout, "Android Default Sensor Detected: \n\n %s - %s\n"
" Res = %f --- Min Delay msec = %d\n"
" m_pSensor=%x m_pSensorEventQueue=%x\n",
m_strVendor, m_strSensor, m_fResolution, m_minDelayMsec, m_pSensor, m_pSensorEventQueue);
setType(SENSOR_ANDROID);
setSingleSampleDT(true); // set to true in raw mode so we don't get any interpolated/avg points (i.e. just the "integer" value hopefully)
return (bool)(getTypeEnum() == SENSOR_ANDROID);
}
static void* android_app_entry(void* param) {
LOGV("+android_app_entry");
struct android_app* android_app = (struct android_app*)param;
android_app->config = AConfiguration_new();
AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
print_cur_config(android_app);
android_app->cmdPollSource.id = LOOPER_ID_MAIN;
android_app->cmdPollSource.app = android_app;
android_app->cmdPollSource.process = process_cmd;
android_app->inputPollSource.id = LOOPER_ID_INPUT;
android_app->inputPollSource.app = android_app;
android_app->inputPollSource.process = process_input;
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
&android_app->cmdPollSource);
android_app->looper = looper;
pthread_mutex_lock(&android_app->mutex);
android_app->running = 1;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
std::string sargv;
// Load command line from ARGV parameter
JNIEnv *env = GetEnvAttachThread(android_app->activity->vm);
if(env) {
jobject me = android_app->activity->clazz;
jclass acl = env->GetObjectClass(me); //class pointer of NativeActivity
jmethodID giid = env->GetMethodID(acl, "getIntent", "()Landroid/content/Intent;");
jobject intent = env->CallObjectMethod(me, giid); //Got our intent
jclass icl = env->GetObjectClass(intent); //class pointer of Intent
jmethodID gseid = env->GetMethodID(icl, "getStringExtra", "(Ljava/lang/String;)Ljava/lang/String;");
jstring jsARGV = (jstring)env->CallObjectMethod(intent, gseid, env->NewStringUTF("ARGV"));
if(jsARGV) {
const char *chARGV = env->GetStringUTFChars(jsARGV, 0);
if(chARGV) {
sargv = std::string(chARGV);
LOGI("ARGV: pango %s", chARGV);
}
env->ReleaseStringUTFChars(jsARGV, chARGV);
}
android_app->activity->vm->DetachCurrentThread();
}
// Set up argv/argc to pass to users main
std::vector<std::string> vargv;
vargv.push_back("pango");
// Parse parameters from ARGV android intent parameter
std::istringstream iss(sargv);
std::copy(std::istream_iterator<std::string>(iss),
std::istream_iterator<std::string>(),
std::back_inserter<std::vector<std::string> >(vargv));
char* argv[vargv.size()+1];
for(size_t ac = 0; ac < vargv.size(); ++ac) {
argv[ac] = new char[vargv[ac].size()];
strcpy( argv[ac], vargv[ac].c_str() );
}
argv[vargv.size()] = NULL;
// Call users standard main entry point.
main(vargv.size(), argv);
// Clean up parameters
for(size_t ac = 0; ac < vargv.size(); ++ac) {
delete[] argv[ac];
}
android_app_destroy(android_app);
LOGV("-android_app_entry");
return NULL;
}
static void *android_app_entry(void *data)
{
struct android_app* android_app = (struct android_app*)data;
android_app->config = AConfiguration_new();
AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
print_cur_config(android_app);
ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL, NULL);
android_app->looper = looper;
pthread_mutex_lock(&android_app->mutex);
android_app->running = 1;
pthread_cond_broadcast(&android_app->cond);
pthread_mutex_unlock(&android_app->mutex);
memset(&g_android, 0, sizeof(g_android));
g_android = android_app;
RARCH_LOG("Native Activity started.\n");
rarch_main_clear_state();
while (!android_app->window)
{
if (!android_run_events(android_app))
goto exit;
}
rarch_init_msg_queue();
if (!android_app_start_main(android_app))
{
g_settings.input.overlay[0] = 0;
// threaded video doesn't work right for just displaying one frame
g_settings.video.threaded = false;
init_drivers();
driver.video_poke->set_aspect_ratio(driver.video_data, ASPECT_RATIO_SQUARE);
rarch_render_cached_frame();
sleep(2);
goto exit;
}
if (!g_extern.libretro_dummy)
menu_rom_history_push_current();
for (;;)
{
if (g_extern.system.shutdown)
break;
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_LOAD_GAME))
{
load_menu_game_prepare();
// If ROM load fails, we exit RetroArch. On console it might make more sense to go back to menu though ...
if (load_menu_game())
g_extern.lifecycle_mode_state |= (1ULL << MODE_GAME);
else
{
#ifdef RARCH_CONSOLE
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU);
#else
return NULL;
#endif
}
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_LOAD_GAME);
}
else if (g_extern.lifecycle_mode_state & (1ULL << MODE_GAME))
{
driver.input->poll(NULL);
if (driver.video_poke->set_aspect_ratio)
driver.video_poke->set_aspect_ratio(driver.video_data, g_settings.video.aspect_ratio_idx);
if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_THROTTLE_ENABLE))
audio_start_func();
// Main loop
while (rarch_main_iterate());
if (g_extern.lifecycle_mode_state & (1ULL << MODE_VIDEO_THROTTLE_ENABLE))
audio_stop_func();
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_GAME);
}
else if(g_extern.lifecycle_mode_state & (1ULL << MODE_MENU))
{
g_extern.lifecycle_mode_state |= (1ULL << MODE_MENU_PREINIT);
while((input_key_pressed_func(RARCH_PAUSE_TOGGLE)) ?
android_run_events(android_app) : menu_iterate());
g_extern.lifecycle_mode_state &= ~(1ULL << MODE_MENU);
}
else
break;
}
exit:
android_app->activityState = APP_CMD_DEAD;
RARCH_LOG("Deinitializing RetroArch...\n");
menu_free();
if (g_extern.config_save_on_exit && *g_extern.config_path)
config_save_file(g_extern.config_path);
if (g_extern.main_is_init)
rarch_main_deinit();
rarch_deinit_msg_queue();
#ifdef PERF_TEST
rarch_perf_log();
#endif
rarch_main_clear_state();
RARCH_LOG("android_app_destroy!");
if (android_app->inputQueue != NULL)
AInputQueue_detachLooper(android_app->inputQueue);
AConfiguration_delete(android_app->config);
// exit() here is nasty.
// pthread_exit(NULL) or return NULL; causes hanging ...
// Should probably called ANativeActivity_finsih(), but it's bugged, it will hang our app.
exit(0);
}
void StAndroidGlue::threadEntry() {
if(myJavaVM->AttachCurrentThread(&myThJniEnv, NULL) < 0) {
ST_ERROR_LOG("Failed to attach working thread to Java VM");
return;
}
THE_ANDROID_GLUE = this;
StMessageBox::setCallback(msgBoxCallback);
myConfig = AConfiguration_new();
AConfiguration_fromAssetManager(myConfig, myActivity->assetManager);
updateMonitors();
printConfig();
ALooper* aLooper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
ALooper_addFd(aLooper, myMsgRead, LooperId_MAIN, ALOOPER_EVENT_INPUT, NULL, &myCmdPollSource);
myLooper = aLooper;
pthread_mutex_lock(&myMutex);
myIsRunning = true;
pthread_cond_broadcast(&myCond);
pthread_mutex_unlock(&myMutex);
// try to load stereo APIs
/**jclass aJClass_Real3D = myThJniEnv->FindClass("com/lge/real3d/Real3D");
if(aJClass_Real3D != NULL) {
jmethodID aJMet_isStereoDisplayAvailable = myThJniEnv->GetStaticMethodID(aJClass_Real3D, "isStereoDisplayAvailable", "(Landroid/content/Contex;)Z");
postMessage("com.lge.real3d.Real3D !!!");
}
jclass aJClass_HTC = myThJniEnv->FindClass("com/htc/view/DisplaySetting");
if(aJClass_HTC != NULL) {
jmethodID aJMet_isStereoDisplayAvailable = myThJniEnv->GetStaticMethodID(aJClass_HTC, "setStereoscopic3DFormat", "(Landroid/view/Surface;I)Z");
postMessage("com.htc.view.DisplaySetting !!!");
}
jclass aJClass_Sharp = myThJniEnv->FindClass("jp/co/sharp/android/stereo3dlcd/SurfaceController");
if(aJClass_Sharp != NULL) {
jmethodID aJMet_setStereoView = myThJniEnv->GetMethodID(aJClass_Sharp, "setStereoView", "(Z)V");
postMessage("jp.co.sharp.android.stereo3dlcd !!!");
}*/
createApplication();
if(!myApp.isNull()) {
if(!myApp->open()) {
stError("Error: application can not be executed!");
}
myApp->exec();
} else {
stError("Error: no application to execute!");
}
myApp.nullify();
// application is done but we are waiting for destroying event...
bool isFirstWait = true;
for(; !myToDestroy; ) {
if(isFirstWait) {
postExit();
isFirstWait = false;
}
StAndroidPollSource* aSource = NULL;
int aNbEvents = 0;
ALooper_pollAll(-1, NULL, &aNbEvents, (void** )&aSource);
if(aSource != NULL) {
aSource->process(this, aSource);
}
}
freeSavedState();
pthread_mutex_lock(&myMutex);
if(myInputQueue != NULL) {
AInputQueue_detachLooper(myInputQueue);
}
AConfiguration_delete(myConfig);
pthread_cond_broadcast(&myCond);
pthread_mutex_unlock(&myMutex);
myThJniEnv = NULL;
StMessageBox::setCallback(NULL);
THE_ANDROID_GLUE = NULL;
myJavaVM->DetachCurrentThread();
}
static bool gfx_ctx_init(void)
{
struct android_app *android_app = (struct android_app*)g_android;
const EGLint attribs[] = {
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_NONE
};
EGLint num_config;
EGLint egl_version_major, egl_version_minor;
EGLint format;
EGLint context_attributes[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
RARCH_LOG("Initializing context\n");
if ((g_egl_dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY)) == EGL_NO_DISPLAY)
{
RARCH_ERR("eglGetDisplay failed.\n");
goto error;
}
if (!eglInitialize(g_egl_dpy, &egl_version_major, &egl_version_minor))
{
RARCH_ERR("eglInitialize failed.\n");
goto error;
}
RARCH_LOG("[ANDROID/EGL]: EGL version: %d.%d\n", egl_version_major, egl_version_minor);
if (!eglChooseConfig(g_egl_dpy, attribs, &g_config, 1, &num_config))
{
RARCH_ERR("eglChooseConfig failed.\n");
goto error;
}
int var = eglGetConfigAttrib(g_egl_dpy, g_config, EGL_NATIVE_VISUAL_ID, &format);
if (!var)
{
RARCH_ERR("eglGetConfigAttrib failed: %d.\n", var);
goto error;
}
ANativeWindow_setBuffersGeometry(android_app->window, 0, 0, format);
if (!(g_egl_surf = eglCreateWindowSurface(g_egl_dpy, g_config, android_app->window, 0)))
{
RARCH_ERR("eglCreateWindowSurface failed.\n");
goto error;
}
if (!(g_egl_ctx = eglCreateContext(g_egl_dpy, g_config, 0, context_attributes)))
{
RARCH_ERR("eglCreateContext failed.\n");
goto error;
}
if (!eglMakeCurrent(g_egl_dpy, g_egl_surf, g_egl_surf, g_egl_ctx))
{
RARCH_ERR("eglMakeCurrent failed.\n");
goto error;
}
ALooper *looper = ALooper_forThread();
if (!looper)
ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
return true;
error:
RARCH_ERR("EGL error: %d.\n", eglGetError());
gfx_ctx_destroy();
return false;
}
