clean and add life cycle

android-ext/native_app_glue/android_native_app_glue.c

@@ -334,25 +334,38 @@ static void android_app_free(struct android_app* android_app) {
 }
 
 static void onDestroy(ANativeActivity* activity) {
+    if (onDestroy_android_V_raylib != NULL) {
+        onDestroy_android_V_raylib(activity);
+    }
     LOGV("Destroy: %p\n", activity);
     android_app_free((struct android_app*)activity->instance);
 }
 
 static void onStart(ANativeActivity* activity) {
-    LOGV("Start: %p\n", activity);
+    if (onStart_android_V_raylib != NULL) {
+        onStart_android_V_raylib(activity);
+    }
+    LOGV("Start C: %p\n", activity);
     android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_START);
 }
 
 static void onResume(ANativeActivity* activity) {
-    LOGV("Resume: %p\n", activity);
+    if (onResume_android_V_raylib != NULL) {
+        onResume_android_V_raylib(activity);
+    }
+    LOGV("Resume C: %p\n", activity);
     android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_RESUME);
 }
 
 static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
     struct android_app* android_app = (struct android_app*)activity->instance;
     void* savedState = NULL;
 
-    LOGV("SaveInstanceState: %p\n", activity);
+    if (onSaveInstanceState_android_V_raylib != NULL) {
+        onSaveInstanceState_android_V_raylib(activity, outLen);
+    }
+
+    LOGV("SaveInstanceState C: %p\n", activity);
     pthread_mutex_lock(&android_app->mutex);
     android_app->stateSaved = 0;
     android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
@@ -373,56 +386,86 @@ static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
 }
 
 static void onPause(ANativeActivity* activity) {
-    LOGV("Pause: %p\n", activity);
+    if (onPause_android_V_raylib != NULL) {
+        onPause_android_V_raylib(activity);
+    }
+    LOGV("Pause C: %p\n", activity);
     android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_PAUSE);
 }
 
 static void onStop(ANativeActivity* activity) {
-    LOGV("Stop: %p\n", activity);
+    if (onStop_android_V_raylib != NULL) {
+        onStop_android_V_raylib(activity);
+    }
+    LOGV("Stop C: %p\n", activity);
     android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_STOP);
 }
 
 static void onConfigurationChanged(ANativeActivity* activity) {
+    if (onConfigurationChanged_android_V_raylib != NULL) {
+        onConfigurationChanged_android_V_raylib(activity);
+    }
     struct android_app* android_app = (struct android_app*)activity->instance;
-    LOGV("ConfigurationChanged: %p\n", activity);
+    LOGV("ConfigurationChanged C: %p\n", activity);
     android_app_write_cmd(android_app, APP_CMD_CONFIG_CHANGED);
 }
 
 static void onLowMemory(ANativeActivity* activity) {
+    if (onLowMemory_android_V_raylib != NULL) {
+        onLowMemory_android_V_raylib(activity);
+    }
     struct android_app* android_app = (struct android_app*)activity->instance;
-    LOGV("LowMemory: %p\n", activity);
+    LOGV("LowMemory C: %p\n", activity);    
     android_app_write_cmd(android_app, APP_CMD_LOW_MEMORY);
 }
 
 static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
-    LOGV("WindowFocusChanged: %p -- %d\n", activity, focused);
+    if (onWindowFocusChanged_android_V_raylib != NULL) {
+        onNativeWindowCreated_android_V_raylib(activity, focused);
+    }
+    LOGV("WindowFocusChanged C: %p -- %d\n", activity, focused);
     android_app_write_cmd((struct android_app*)activity->instance,
             focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
 }
 
 static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
-    LOGV("NativeWindowCreated: %p -- %p\n", activity, window);
+    if (onNativeWindowCreated_android_V_raylib != NULL) {
+        onNativeWindowCreated_android_V_raylib(activity, window);
+    }
+    LOGV("NativeWindowCreated C: %p -- %p\n", activity, window);
     android_app_set_window((struct android_app*)activity->instance, window);
 }
 
 static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
-    LOGV("NativeWindowDestroyed: %p -- %p\n", activity, window);
+    if (onNativeWindowDestroyed_android_V_raylib != NULL) {
+        onNativeWindowDestroyed_android_V_raylib(activity);
+    }
+    LOGV("NativeWindowDestroyed C: %p -- %p\n", activity, window);
     android_app_set_window((struct android_app*)activity->instance, NULL);
 }
 
 static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
-    LOGV("InputQueueCreated: %p -- %p\n", activity, queue);
+    if (onInputQueueCreated_android_V_raylib != NULL) {
+        onInputQueueCreated_android_V_raylib(activity, queue);
+    }
+    LOGV("InputQueueCreated C: %p -- %p\n", activity, queue);
     android_app_set_input((struct android_app*)activity->instance, queue);
 }
 
 static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
+    if (onInputQueueDestroyed_android_V_raylib != NULL) {
+        onInputQueueDestroyed_android_V_raylib(activity);
+    }
     LOGV("InputQueueDestroyed: %p -- %p\n", activity, queue);
     android_app_set_input((struct android_app*)activity->instance, NULL);
 }
 
 JNIEXPORT
 void ANativeActivity_onCreate(ANativeActivity* activity, void* savedState,
-                              size_t savedStateSize) {
+                              size_t savedStateSize) {    
+    if (save_jni_android_V_raylib_onCreate != NULL) {
+        save_jni_android_V_raylib_onCreate(activity);
+    }
     LOGV("Creating: %p\n", activity);
     activity->callbacks->onDestroy = onDestroy;
     activity->callbacks->onStart = onStart;

android-ext/native_app_glue/android_native_app_glue.h

@@ -347,6 +347,22 @@ app_dummy();
  */
 extern void android_main(struct android_app* app);
 
+__attribute__((weak)) void save_jni_android_V_raylib_onCreate(voidptr);
+
+__attribute__((weak)) void onDestroy_android_V_raylib(voidptr);
+__attribute__((weak)) void onStart_android_V_raylib(voidptr);
+__attribute__((weak)) void onResume_android_V_raylib(voidptr);
+__attribute__((weak)) void* onSaveInstanceState_android_V_raylib(voidptr, voidptr);
+__attribute__((weak)) void onPause_android_V_raylib(voidptr);
+__attribute__((weak)) void onStop_android_Vvoidptr_raylib(voidptr);
+__attribute__((weak)) void onConfigurationChanged_android_V_raylib(voidptr);
+__attribute__((weak)) void onLowMemory_android_V_raylib(voidptr);
+__attribute__((weak)) void onWindowFocusChanged_android_V_raylib(voidptr, int);
+__attribute__((weak)) void onNativeWindowCreated_android_V_raylib(voidptr, voidptr);
+__attribute__((weak)) void onNativeWindowDestroyed_android_V_raylib(voidptr, voidptr);
+__attribute__((weak)) void onInputQueueCreated_android_V_raylib(voidptr, voidptr);
+__attribute__((weak)) void onInputQueueDestroyed_android_V_raylib(voidptr, voidptr);
+
 #ifdef __cplusplus
 }
 #endif

examples/android/hello.v

@@ -0,0 +1,28 @@
+import raylib as rl
+
+const screen_width = 800
+const screen_height = 600
+const white = rl.Color{255, 255, 255, 255}
+const blue = rl.Color{0, 0, 200, 255}
+
+@[export: 'android_run']
+fn run(){
+	rl.init_window(screen_width, screen_height, 'Example of using V and Raylib together on android but runable for pc')
+	rl.set_target_fps(60)
+	for !rl.window_should_close() {
+		rl.begin_drawing()
+		rl.clear_background(white)
+		$if android{
+			rl.draw_text('Hello from V and Raylib on Android.', 160, 270, 40, blue)
+		}
+		$else{
+			rl.draw_text('Hello from V and Raylib on PC.', 160, 270, 40, blue)
+		}
+		rl.end_drawing()
+	}
+	rl.close_window()
+}
+
+fn main(){
+	run()
+}

examples/android/life_time/callbacks.v

@@ -0,0 +1,94 @@
+module main
+
+import raylib as rl
+
+$if android {
+#include <android/native_activity.h>
+#include <android/native_window.h>
+#include <android/input.h>
+
+/*
+__global (
+	activity &C.ANativeActivity
+)
+*/
+}
+
+
+fn set_jni(activity voidptr) {
+
+$if android {
+	// cast activity and set your globals jni ......
+}
+}
+
+
+@[export: 'save_jni_android_V_raylib_onCreate']
+pub fn on_create(activity voidptr) {
+	rl.trace_log(0, '[V] onCreate_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+@[export: 'onDestroy_android_V_raylib']
+pub fn on_destroy(activity voidptr) {
+	rl.trace_log(0, '[V] onDestroy_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onStart_android_V_raylib']
+pub fn on_start(activity voidptr) {
+	rl.trace_log(0, '[V] onStart_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onResume_android_V_raylib']
+pub fn on_resume(activity voidptr) {
+	rl.trace_log(0, '[V] onResume_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onSaveInstanceState_android_V_raylib']
+pub fn on_save_instance_state(activity voidptr, out_size voidptr) voidptr {
+	rl.trace_log(0, '[V] onSaveInstanceState_android_V_raylib', rl.TraceLogLevel.log_all)
+	return voidptr(0)
+}
+
+@[export: 'onPause_android_V_raylib']
+pub fn on_pause(activity voidptr) {
+	rl.trace_log(0, '[V] onPause_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onStop_android_V_raylib']
+pub fn on_stop(activity voidptr) {
+	rl.trace_log(0, '[V] onStop_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onConfigurationChanged_android_V_raylib']
+pub fn on_configuration_changed(activity voidptr) {
+	rl.trace_log(0, '[V] onConfigurationChanged_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onLowMemory_android_V_raylib']
+pub fn on_low_memory(activity voidptr) {
+	rl.trace_log(0, '[V] onLowMemory_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onWindowFocusChanged_android_V_raylib']
+pub fn on_window_focus_changed(activity voidptr, has_focus int) {
+	rl.trace_log(0, '[V] onWindowFocusChanged_android_V_raylib: focus=$has_focus', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onNativeWindowCreated_android_V_raylib']
+pub fn on_native_window_created(activity  voidptr, window voidptr) {
+	rl.trace_log(0, '[V] onNativeWindowCreated_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onNativeWindowDestroyed_android_V_raylib']
+pub fn on_native_window_destroyed(activity voidptr, window voidptr) {
+	rl.trace_log(0, '[V] onNativeWindowDestroyed_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onInputQueueCreated_android_V_raylib']
+pub fn on_input_queue_created(activity voidptr, queue voidptr) {
+	rl.trace_log(0, '[V] onInputQueueCreated_android_V_raylib', rl.TraceLogLevel.log_all)
+}
+
+@[export: 'onInputQueueDestroyed_android_V_raylib']
+pub fn on_input_queue_destroyed(activity voidptr, queue voidptr) {
+	rl.trace_log(0, '[V] onInputQueueDestroyed_android_V_raylib', rl.TraceLogLevel.log_all)
+}

examples/android/life_time/main.v

@@ -0,0 +1,39 @@
+module main
+
+import raylib as rl
+
+const screen_width = 800
+const screen_height = 600
+const white = rl.Color{255, 255, 255, 255}
+const blue = rl.Color{0, 0, 200, 255}
+
+@[export: 'android_run']
+fn run(){
+	rl.set_trace_log_level(int(rl.TraceLogLevel.log_all))
+	mut counter := 0
+	println("ordinary V")
+	rl.init_window(screen_width, screen_height, 'Example of using V and Raylib together on android but runable for pc')
+	rl.set_target_fps(60)
+	for !rl.window_should_close() {
+		rl.begin_drawing()
+		rl.clear_background(white)
+		$if android{
+			rl.draw_text('look logcat.', 160, 270, 40, blue)
+			counter++
+			if counter == 120{
+				counter = 0
+				println('[V] main')
+    			//rl.trace_log(0, '[V] main', rl.TraceLogLevel.log_all)
+			}
+		}
+		$else{
+			rl.draw_text('Hello from V and Raylib on PC.', 160, 270, 40, blue)
+		}
+		rl.end_drawing()
+	}
+	rl.close_window()
+}
+
+fn main(){
+	run()
+}

examples/hello.v

@@ -1,23 +1,16 @@
-import raylib { Color, begin_drawing, clear_background, close_window, draw_text, end_drawing, init_window, set_target_fps, window_should_close }
+import raylib as rl
 
 const screen_width = 800
 const screen_height = 600
-const white = Color{255, 255, 255, 255}
-const blue = Color{0, 0, 200, 255}
+const white = rl.Color{255, 255, 255, 255}
+const blue = rl.Color{0, 0, 200, 255}
 
-@[export: 'android_run']
-fn run(){
-	init_window(screen_width, screen_height, 'Example of using V and Raylib together')
-	set_target_fps(60)
-	for !window_should_close() {
-		begin_drawing()
-		clear_background(white)
-		draw_text('Hello from V and Raylib.', 160, 270, 40, blue)
-		end_drawing()
-	}
-	close_window()
-}
-
-fn main(){
-	run()
+rl.init_window(screen_width, screen_height, 'Example of using V and Raylib together')
+rl.set_target_fps(60)
+for !rl.window_should_close() {
+	rl.begin_drawing()
+	rl.clear_background(white)
+	rl.draw_text('Hello from V and Raylib.', 160, 270, 40, blue)
+	rl.end_drawing()
 }
+rl.close_window()