Skip to content

Commit

Permalink
Moved Android sensor event handling to a separate thread
Browse files Browse the repository at this point in the history 
This makes it so you can interact with sensors on multiple threads, as long as only one thread initializes and cleans up the sensor subsystem.

This also has the benefit that sensor data is available as soon as possible.
  • Loading branch information
@slouken
slouken committed Jun 20, 2023
1 parent 329e1b8 commit 3ddbeab
Show file tree
Hide file tree
Showing 2 changed files with 143 additions and 57 deletions.
193 changes: 143 additions & 50 deletions src/sensor/android/SDL_androidsensor.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -28,6 +28,7 @@
#include "SDL_androidsensor.h"
#include "../SDL_syssensor.h"
#include "../SDL_sensor_c.h"
#include "../../thread/SDL_systhread.h"

#ifndef LOOPER_ID_USER
#define LOOPER_ID_USER 3
Expand All @@ -37,31 +38,116 @@ typedef struct
{
ASensorRef asensor;
SDL_SensorID instance_id;
ASensorEventQueue *event_queue;
SDL_Sensor *sensor;
} SDL_AndroidSensor;

typedef struct
{
SDL_AtomicInt running;
SDL_Thread *thread;
SDL_Semaphore *sem;
} SDL_AndroidSensorThreadContext;

static ASensorManager *SDL_sensor_manager;
static ALooper *SDL_sensor_looper;
static SDL_AndroidSensor *SDL_sensors;
static SDL_AndroidSensorThreadContext SDL_sensor_thread_context;
static SDL_Mutex *SDL_sensors_lock;
static SDL_AndroidSensor *SDL_sensors SDL_GUARDED_BY(SDL_sensors_lock);
static int SDL_sensors_count;

static int SDLCALL SDL_ANDROID_SensorThread(void *data)
{
SDL_AndroidSensorThreadContext *ctx = (SDL_AndroidSensorThreadContext *)data;
int i, events;
ASensorEvent event;
struct android_poll_source *source;

SDL_SetThreadPriority(SDL_THREAD_PRIORITY_HIGH);

SDL_sensor_looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
SDL_PostSemaphore(ctx->sem);

while (SDL_AtomicGet(&ctx->running)) {
Uint64 timestamp = SDL_GetTicksNS();

if (ALooper_pollAll(-1, NULL, &events, (void **)&source) == LOOPER_ID_USER) {
SDL_LockMutex(SDL_sensors_lock);
for (i = 0; i < SDL_sensors_count; ++i) {
if (!SDL_sensors[i].event_queue) {
continue;
}

SDL_zero(event);
while (ASensorEventQueue_getEvents(SDL_sensors[i].event_queue, &event, 1) > 0) {
SDL_SendSensorUpdate(timestamp, SDL_sensors[i].sensor, timestamp, event.data, SDL_arraysize(event.data));
}
}
SDL_UnlockMutex(SDL_sensors_lock);
}
}

SDL_sensor_looper = NULL;

return 0;
}

static void SDL_ANDROID_StopSensorThread(SDL_AndroidSensorThreadContext *ctx)
{
SDL_AtomicSet(&ctx->running, SDL_FALSE);

if (ctx->thread) {
int result;

if (SDL_sensor_looper) {
ALooper_wake(SDL_sensor_looper);
}
SDL_WaitThread(ctx->thread, &result);
ctx->thread = NULL;
}

if (ctx->sem) {
SDL_DestroySemaphore(ctx->sem);
ctx->sem = NULL;
}
}

static int SDL_ANDROID_StartSensorThread(SDL_AndroidSensorThreadContext *ctx)
{
ctx->sem = SDL_CreateSemaphore(0);
if (!ctx->sem) {
SDL_ANDROID_StopSensorThread(ctx);
return -1;
}

SDL_AtomicSet(&ctx->running, SDL_TRUE);
ctx->thread = SDL_CreateThreadInternal(SDL_ANDROID_SensorThread, "Sensors", 0, ctx);
if (!ctx->thread) {
SDL_ANDROID_StopSensorThread(ctx);
return -1;
}

/* Wait for the sensor thread to start */
SDL_WaitSemaphore(ctx->sem);

return 0;
}

static int SDL_ANDROID_SensorInit(void)
{
int i, sensors_count;
ASensorList sensors;

SDL_sensors_lock = SDL_CreateMutex();
if (!SDL_sensors_lock) {
return SDL_SetError("Couldn't create sensor lock");
}

SDL_sensor_manager = ASensorManager_getInstance();
if (SDL_sensor_manager == NULL) {
return SDL_SetError("Couldn't create sensor manager");
}

SDL_sensor_looper = ALooper_forThread();
if (SDL_sensor_looper == NULL) {
SDL_sensor_looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
if (SDL_sensor_looper == NULL) {
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) {
Expand All @@ -76,6 +162,10 @@ static int SDL_ANDROID_SensorInit(void)
}
SDL_sensors_count = sensors_count;
}

if (SDL_ANDROID_StartSensorThread(&SDL_sensor_thread_context) < 0) {
return -1;
}
return 0;
}

Expand Down Expand Up @@ -117,72 +207,75 @@ static SDL_SensorID SDL_ANDROID_SensorGetDeviceInstanceID(int device_index)

static int SDL_ANDROID_SensorOpen(SDL_Sensor *sensor, int device_index)
{
struct sensor_hwdata *hwdata;
int delay_us, min_delay_us;

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");
}
SDL_LockMutex(SDL_sensors_lock);
{
SDL_sensors[device_index].sensor = sensor;
SDL_sensors[device_index].event_queue = ASensorManager_createEventQueue(SDL_sensor_manager, SDL_sensor_looper, LOOPER_ID_USER, NULL, NULL);
if (!SDL_sensors[device_index].event_queue) {
SDL_UnlockMutex(SDL_sensors_lock);
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");
}
if (ASensorEventQueue_enableSensor(SDL_sensors[device_index].event_queue, SDL_sensors[device_index].asensor) < 0) {
ASensorManager_destroyEventQueue(SDL_sensor_manager, SDL_sensors[device_index].event_queue);
SDL_sensors[device_index].event_queue = NULL;
SDL_UnlockMutex(SDL_sensors_lock);
return SDL_SetError("Couldn't enable sensor");
}

/* Use 60 Hz update rate if possible */
/* FIXME: Maybe add a hint for this? */
delay_us = 1000000 / 60;
min_delay_us = ASensor_getMinDelay(hwdata->asensor);
if (delay_us < min_delay_us) {
delay_us = min_delay_us;
/* Use 60 Hz update rate if possible */
/* FIXME: Maybe add a hint for this? */
delay_us = 1000000 / 60;
min_delay_us = ASensor_getMinDelay(SDL_sensors[device_index].asensor);
if (delay_us < min_delay_us) {
delay_us = min_delay_us;
}
ASensorEventQueue_setEventRate(SDL_sensors[device_index].event_queue, SDL_sensors[device_index].asensor, delay_us);
}
ASensorEventQueue_setEventRate(hwdata->eventqueue, hwdata->asensor, delay_us);
SDL_UnlockMutex(SDL_sensors_lock);

sensor->hwdata = hwdata;
return 0;
}

static void SDL_ANDROID_SensorUpdate(SDL_Sensor *sensor)
{
int events;
ASensorEvent event;
struct android_poll_source *source;
Uint64 timestamp = SDL_GetTicksNS();

if (ALooper_pollAll(0, NULL, &events, (void **)&source) == LOOPER_ID_USER) {
SDL_zero(event);
while (ASensorEventQueue_getEvents(sensor->hwdata->eventqueue, &event, 1) > 0) {
SDL_SendSensorUpdate(timestamp, sensor, timestamp, event.data, SDL_arraysize(event.data));
}
}
}

static void SDL_ANDROID_SensorClose(SDL_Sensor *sensor)
{
if (sensor->hwdata) {
ASensorEventQueue_disableSensor(sensor->hwdata->eventqueue, sensor->hwdata->asensor);
ASensorManager_destroyEventQueue(SDL_sensor_manager, sensor->hwdata->eventqueue);
SDL_free(sensor->hwdata);
sensor->hwdata = NULL;
int i;

for (i = 0; i < SDL_sensors_count; ++i) {
if (SDL_sensors[i].sensor == sensor) {
SDL_LockMutex(SDL_sensors_lock);
{
ASensorEventQueue_disableSensor(SDL_sensors[i].event_queue, SDL_sensors[i].asensor);
ASensorManager_destroyEventQueue(SDL_sensor_manager, SDL_sensors[i].event_queue);
SDL_sensors[i].event_queue = NULL;
SDL_sensors[i].sensor = NULL;
}
SDL_UnlockMutex(SDL_sensors_lock);
break;
}
}
}

static void SDL_ANDROID_SensorQuit(void)
{
SDL_ANDROID_StopSensorThread(&SDL_sensor_thread_context);

if (SDL_sensors) {
SDL_free(SDL_sensors);
SDL_sensors = NULL;
SDL_sensors_count = 0;
}

if (SDL_sensors_lock) {
SDL_DestroyMutex(SDL_sensors_lock);
SDL_sensors_lock = NULL;
}
}

SDL_SensorDriver SDL_ANDROID_SensorDriver = {
Expand Down
7 changes: 0 additions & 7 deletions src/sensor/android/SDL_androidsensor.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -19,10 +19,3 @@
3. This notice may not be removed or altered from any source distribution.
*/
#include "SDL_internal.h"

/* The private structure used to keep track of a sensor */
struct sensor_hwdata
{
ASensorRef asensor;
ASensorEventQueue *eventqueue;
};

0 comments on commit 3ddbeab

Please sign in to comment.