path: root/app/src/main/jni/main.c

#include <vosk_api.h>
#include <aaudio/AAudio.h>
#include <android_native_app_glue.h>
#include <android/log.h>
#include <android/sensor.h>
#include <stdint.h>
#include <stdlib.h>
#include <inttypes.h>
#include <string.h>
#include <android/native_window.h>
#include <android/set_abort_message.h>
#include <android/choreographer.h>
#include <android/hardware_buffer.h>
#include <time.h>
#include <jni.h>

#define LOG_TAG "moku"

#define _LOG(priority, fmt, ...)                    \
  ((void)__android_log_print((priority), (LOG_TAG), \
                             (fmt)__VA_OPT__(, ) __VA_ARGS__))

#define LOGE(fmt, ...) _LOG(ANDROID_LOG_ERROR, (fmt)__VA_OPT__(, ) __VA_ARGS__)
#define LOGW(fmt, ...) _LOG(ANDROID_LOG_WARN, (fmt)__VA_OPT__(, ) __VA_ARGS__)
#define LOGI(fmt, ...) _LOG(ANDROID_LOG_INFO, (fmt)__VA_OPT__(, ) __VA_ARGS__)

enum Color {
	COLOR_RED = 0x000000ff,
	COLOR_GREEN = 0x0000ff00,
	COLOR_BLUE = 0x00ff0000
};

struct engine {
	struct android_app *app;
	int window_initialized;
	int running;
	uint64_t last_update;
	int color;
	int service_started;
};

/* DO NOT USE THIS INSTANCE.
 * USE VARIABLES THAT HAVE BEEN PASSED TO THE FUNCTION(s) IN PARTICULAR
 * THIS INSTANCE IS FOR JNI FUNCTIONS AND JNI FUNCTIONS ONLY.
 * IT IS VERY JANK.
 * GLOBALS ARE A MEMORY LEAK OR UAF WAITING TO HAPPEN.
 */
static struct engine *engine_instance = NULL;

void request_mic_permission(struct android_app *app) {
	JNIEnv *env;
	JavaVM *jvm = app->activity->vm;

	(*jvm)->AttachCurrentThread(jvm, &env, NULL);

	jclass activity_class = (*env)->GetObjectClass(env, app->activity->clazz);
	jmethodID request_permissions = (*env)->GetMethodID(env, activity_class, "requestPermissions", "([Ljava/lang/String;I)V");

	jstring perm_string = (*env)->NewStringUTF(env, "android.permission.RECORD_AUDIO");
	jobjectArray perm_array = (*env)->NewObjectArray(env, 1, (*env)->FindClass(env, "java/lang/String"), perm_string);

	(*env)->CallVoidMethod(env, app->activity->clazz, request_permissions, perm_array, 0);

	(*env)->DeleteLocalRef(env, perm_string);
	(*env)->DeleteLocalRef(env, perm_array);

	(*jvm)->DetachCurrentThread(jvm);

	LOGI("Mic permission requested");
}

void request_notification_permission(struct android_app *app) {
	JNIEnv *env;
	JavaVM *jvm = app->activity->vm;

	(*jvm)->AttachCurrentThread(jvm, &env, NULL);

	jclass activity_class = (*env)->GetObjectClass(env, app->activity->clazz);
	jmethodID request_permissions = (*env)->GetMethodID(env, activity_class, "requestPermissions", "([Ljava/lang/String;I)V");

	jstring perm_string = (*env)->NewStringUTF(env, "android.permission.POST_NOTIFICATIONS");
	jobjectArray perm_array = (*env)->NewObjectArray(env, 1, (*env)->FindClass(env, "java/lang/String"), perm_string);

	(*env)->CallVoidMethod(env, app->activity->clazz, request_permissions, perm_array, 0);

	(*env)->DeleteLocalRef(env, perm_string);
	(*env)->DeleteLocalRef(env, perm_array);

	(*jvm)->DetachCurrentThread(jvm);

	LOGI("Notification permission requested");
}

JNIEXPORT void JNICALL Java_com_arslaancodes_mokuassistant_AssistantService_startAssistant(JNIEnv *env, jclass clazz) {
	(void)env;
	(void)clazz;
	LOGI("startAssistant called");
	if (!engine_instance) return;
	request_mic_permission(engine_instance->app);
}

JNIEXPORT void JNICALL Java_com_arslaancodes_mokuassistant_AssistantService_stopAssistant(JNIEnv *env, jclass clazz) {
	(void)env;
	(void)clazz;
	LOGI("stopAssistant called");
}

void start_assistant_service(struct android_app *app) {
	JNIEnv *env;
	JavaVM *jvm = app->activity->vm;

	(*jvm)->AttachCurrentThread(jvm, &env, NULL);

	jclass activity_class = (*env)->GetObjectClass(env, app->activity->clazz);

	jmethodID get_class_loader = (*env)->GetMethodID(env, activity_class, "getClassLoader", "()Ljava/lang/ClassLoader;");
	jobject class_loader = (*env)->CallObjectMethod(env, app->activity->clazz, get_class_loader);

	jclass class_loader_cls = (*env)->FindClass(env, "java/lang/ClassLoader");
	jmethodID load_class = (*env)->GetMethodID(env, class_loader_cls, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");

	jstring class_name = (*env)->NewStringUTF(env, "com.arslaancodes.mokuassistant.AssistantService");
	jclass service_class = (jclass)(*env)->CallObjectMethod(env, class_loader, load_class, class_name);
	(*env)->DeleteLocalRef(env, class_name);

	if (service_class == NULL) {
		LOGE("Failed to find AssistantService class!");
		(*jvm)->DetachCurrentThread(jvm);
		return;
	}

	jmethodID start_service = (*env)->GetMethodID(env, activity_class, "startService", "(Landroid/content/Intent;)Landroid/content/ComponentName;");

	jclass intent_class = (*env)->FindClass(env, "android/content/Intent");
	jmethodID intent_constructor = (*env)->GetMethodID(env, intent_class, "<init>", "(Landroid/content/Context;Ljava/lang/Class;)V");
	jobject intent = (*env)->NewObject(env, intent_class, intent_constructor, app->activity->clazz, service_class);

	(*env)->CallObjectMethod(env, app->activity->clazz, start_service, intent);

	(*jvm)->DetachCurrentThread(jvm);

	LOGI("AssistantService started from C via JNI");
}

struct engine *engine_new(struct android_app* app) {
	struct engine *engine;

	engine = malloc(sizeof(struct engine));
	if (!engine) {
		LOGE("Failed to allocate engine!");
		return NULL;
	}

	engine->window_initialized = 0;
	engine->app = app;
	engine->running = 0;
	engine->color = COLOR_RED;
	engine->last_update = (uint64_t)0;

	return engine;
}

uint64_t get_timestamp_ns() {
	struct timespec ts;
	clock_gettime(CLOCK_REALTIME, &ts);
	return (uint64_t)ts.tv_nsec + (uint64_t)ts.tv_sec * 1000000000;
}

static void engine_schedule_tick(struct engine *engine);

static void engine_draw_frame(struct engine *engine) {
	ANativeWindow_Buffer buffer;
	int x, y;
	size_t pixel_idx;

	if (!engine->app->window) return;

	if (ANativeWindow_lock(engine->app->window, &buffer, NULL) < 0) {
		LOGE("Unable to lock window buffer");
		return;
	}

	if (!engine->window_initialized) {
		return;
	}

	for (y = 0; y < buffer.height; y++) {
		for (x = 0; x < buffer.width; x++) {
			pixel_idx = y * buffer.stride + x;
			((uint32_t*)(buffer.bits))[pixel_idx] = (uint32_t)engine->color;
		}
	}

	ANativeWindow_unlockAndPost(engine->app->window);
}

static void engine_update(struct engine *engine) {
	(void)engine;
	/* uint64_t now = get_timestamp_ns();
	if (now - engine->last_update > 1000000000LL) {
		switch (engine->color) {
			case COLOR_RED:
				engine->color = COLOR_GREEN;
				break;
			case COLOR_GREEN:
				engine->color = COLOR_BLUE;
				break;
			case COLOR_BLUE:
				engine->color = COLOR_RED;
				break;
			default:
				LOGE("unexpected color %08x", (uint32_t)engine->color);
		}
		engine->last_update = now;
	} */
}

static void engine_real_tick(struct engine *engine) {
	if (!engine->running) return;

	// LOGI("tick");
	engine_schedule_tick(engine);
	engine_update(engine);
	engine_draw_frame(engine);
}

static void engine_tick(long frameTimeNanos, void *data) {
	(void)frameTimeNanos;
	struct engine *engine;

	if (!data) return;
	engine = (struct engine*)data;

	engine_real_tick(engine);
}

static void engine_schedule_tick(struct engine *engine) {
	AChoreographer_postFrameCallback(AChoreographer_getInstance(), engine_tick, (void*)engine);
}

/* TODO implement these stubs */
void engine_attach_window(struct engine *engine) {
	if (ANativeWindow_setBuffersGeometry(engine->app->window, 0, 0, AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM) < 0) {
		engine->window_initialized = 0;
		return;
	}
	engine->window_initialized = 1;	
	engine->last_update = get_timestamp_ns();
	if (!engine->service_started) {
		start_assistant_service(state);
		engine->service_started;
	}
};

void engine_detach_window(struct engine *engine) {
	/* Called when native window for app is destroyed. 
	 * Doesn't mean app is being killed, also happens on rotate
	 * Normally, with a traditional OpenGL app, do cleanup here
	 * At the moment, it's fine to just set a flag to disable the rendering loop
	 */
	engine->window_initialized = 0;
};

void engine_resume(struct engine *engine) { 
	if (!engine->running) {
		engine->running = 1;
		engine_schedule_tick(engine);
		LOGI("engine running");
	}
};


void engine_pause(struct engine *engine) {	
	engine->running = 0;
	LOGI("engine paused");
};

static void engine_handle_cmd(struct android_app *app, int32_t cmd) {
	struct engine *engine;

	engine = (struct engine *)app->userData;

	switch (cmd) {
		case APP_CMD_INIT_WINDOW:
			engine_attach_window(engine);
			break;
		case APP_CMD_TERM_WINDOW:
			engine_detach_window(engine);
			break;
		case APP_CMD_GAINED_FOCUS:
			engine_resume(engine);
			break;
		case APP_CMD_LOST_FOCUS:
			engine_pause(engine);
			break;
	}
}

void android_main(struct android_app *state) {
	/* Declarations */
	struct android_poll_source *source;
	struct engine *engine;
	int events;

	engine = engine_new(state);
	if (!engine) {
		LOGE("Failed to create engine!");
		return;
	}
	engine_instance = engine;

	state->userData = engine;
	state->onAppCmd = engine_handle_cmd;

	request_notification_permission(state);
	request_mic_permission(state);
	
	while (!state->destroyRequested) {
		if (ALooper_pollAll(-1, NULL, &events, (void**)&source) >= 0) {
			if (source) {
				source->process(state, source);
			}
		}
		/* more stuff here */
	}

	engine_instance = NULL;
	free(engine);
}