k_platform_anyplatform,
k_platform_windows,
k_platform_linux,
- k_platform_android
}
platform;
k_architecture_anyarch,
k_architecture_i386,
k_architecture_x86_64,
- k_architecture_aarch64,
- k_architecture_armv7a
}
arch;
k_compiler_blob,
k_compiler_clang,
k_compiler_zigcc,
- k_compiler_clang_android
}
compiler;
.arch = k_architecture_x86_64,
.compiler = k_compiler_clang,
.libc = k_libc_version_native
+},
+vg_release_env =
+{
+ .optimization = 3,
+ .debug_asan = 0,
+ .platform = k_platform_anyplatform,
+ .arch = k_architecture_x86_64,
+ .compiler = k_compiler_zigcc,
+ .libc = k_libc_version_2_23
};
struct vg_compiler_conf
[k_platform_anyplatform] = "anyplatform",
[k_platform_windows] = "windows",
[k_platform_linux] = "linux",
- [k_platform_android] = "android"
};
static const char *architecture_names[] =
[k_architecture_anyarch] = "anyarch",
[k_architecture_i386] = "i386",
[k_architecture_x86_64] = "x86_64",
- [k_architecture_aarch64] = "aarch64",
- [k_architecture_armv7a] = "armv7a"
};
static const char *compiler_names[] =
[k_compiler_blob] = "blob",
[k_compiler_clang] = "clang",
[k_compiler_zigcc] = "zig-cc",
- [k_compiler_clang_android] = "clang"
};
static const char *libc_names[] =
bool vg_platform_posix( enum platform p )
{
- if( (p == k_platform_linux) || (p == k_platform_android) ) return 1;
+ if( p == k_platform_linux ) return 1;
else return 0;
}
if( env->platform != k_platform_linux )
vg_fatal_error( "Cannot compile for '%s' using the '%s' compiler;" );
- if( env->compiler == k_compiler_clang_android )
- if( env->platform != k_platform_android )
- vg_fatal_error( "Cannot compile for '%s' using the '%s' compiler;" );
-
vg_str cmd = {0};
+ vg_strcat( &cmd, "ccache " );
/* compiler specification */
- vg_strcat( &cmd, "ccache " );
if( env->compiler == k_compiler_zigcc )
vg_strcat( &cmd, "zig cc " );
else if( env->compiler == k_compiler_clang )
vg_strcat( &cmd, "clang" );
- else if( env->compiler == k_compiler_clang_android )
- {
- if( env->arch == k_architecture_armv7a )
- {
- vg_strcat( &cmd,
- "/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "bin/armv7a-linux-androideabi22-clang \\\n" );
- }
- else if( env->arch == k_architecture_aarch64 )
- {
- vg_strcat( &cmd,
- "/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "bin/aarch64-linux-android22-clang \\\n" );
- }
- }
vg_strcat( &cmd, " -std=gnu99 -D_REENTRANT \\\n" );
{
vg_strcat( &cmd, " -O" );
vg_strcati32( &cmd, env->optimization );
- vg_strcat( &cmd, " -flto \\\n" );
}
else
{
- /* add debugger / asan information */
vg_strcat( &cmd, " -O0 -ggdb3 -fno-omit-frame-pointer " );
-
- if( (env->compiler == k_compiler_clang) && env->debug_asan )
- {
- vg_strcat( &cmd, " -rdynamic -fsanitize=address -fPIE "
- "-fstack-protector-strong " );
- }
-
vg_strcat( &cmd, "\\\n" );
}
+ if( (env->compiler == k_compiler_clang) && env->debug_asan )
+ {
+ vg_strcat( &cmd, " -rdynamic -fsanitize=address -fPIE "
+ "-fstack-protector-strong " );
+ }
+
+ /* always want this */
+ vg_strcat( &cmd, " -flto \\\n" );
+
/* want a lot of warnings but not useless ones */
vg_strcat( &cmd, " -Wall -ferror-limit=8\\\n"
" -Wno-unused-function -Wno-unused-variable\\\n"
vg_strcat( &cmd, " -Wno-format-truncation\\\n" );
/* defines */
- vg_strcat( &cmd, " " );
- vg_strcat( &cmd, conf->defines.buffer );
- vg_strcat( &cmd, "\\\n" );
+ vg_strcatf( &cmd, " %s \\\n", conf->defines.buffer );
/* include paths */
vg_strcat( &cmd, " " );
if( type == k_obj_type_shared )
{
vg_strcat( &cmd, "-shared -fPIC " );
-
- if( env->platform == k_platform_android )
- {
- vg_strcat( &cmd, "-Wl,-soname," );
- vg_strcat( &cmd, target_name );
- vg_strcat( &cmd, ".so " );
- }
}
vg_strcat( &cmd, sources );
return res;
}
-#if 0
-void vg_android_pack( struct vg_project *proj )
-{
- vg_str AndroidManifest_xml;
- vg_strcatf( &AndroidManifest_xml,
-"<?xml version=\"1.0\" encoding=\"utf-8\" standalone=\"no\"?>\n"
-"<manifest \n"
-" xmlns:tools=\"http://schemas.android.com/tools\" \n"
-" xmlns:android=\"http://schemas.android.com/apk/res/android\" \n"
-" package=\"org.mtzero.carrot\">\n"
-" <uses-sdk android:minSdkVersion=\"22\" android:targetSdkVersion=\"22\" />\n"
-" <uses-permission android:name=\"android.permission.SET_RELEASE_APP\" />\n"
-" <uses-feature android:glEsVersion=\"0x00030002\" android:required=\"true\" />\n"
-" <application android:debuggable=\"true\" android:hasCode=\"false\" \n"
-" android:label=\"carrot\" \n"
-" tools:replace=\"android:icon,android:theme,android:allowBackup,label\" \n"
-" android:icon=\"@mipmap/icon\">\n"
-" <activity android:configChanges=\"keyboardHidden|orientation\" \n"
-" android:label=\"carrot\" android:name=\"android.app.NativeActivity\">\n"
-" <meta-data android:name=\"android.app.lib_name\" android:value=\"carrot\"/>\n"
-" <intent-filter>\n"
-" <action android:name=\"android.intent.action.MAIN\"/>\n"
-" <category android:name=\"android.intent.category.LAUNCHER\"/>\n"
-" </intent-filter>\n"
-" </activity>\n"
-" </application>\n"
-"</manifest>\n" );
-
- vg_syscall( "aapt package -vf \\\n"
- "--target-sdk-version 22 \\\n"
- "-F bin/temp.apk \\\n"
- "-I /opt/android-sdk/platforms/android-22/android.jar \\\n"
- "-M AndroidManifest.xml \\\n"
- "-S resources/ \\\n"
- "-A assets/ "
- );
- vg_syscall( "aapt add -v \\\n"
- "bin/temp.apk \\\n"
- "%s", proj->compiled_objects.buffer );
-
- /* sign */
-#if 0
-keytool -genkey -v -keystore debug.keystore -storepass android -alias \
-androiddebugkey -keypass android -keyalg RSA -keysize 2048 -validity 10000 \
--dname "C=US, O=Android, CN=Android Debug"
-#endif
- vg_syscall( "/opt/android-sdk/build-tools/34.0.0/apksigner sign \\\n"
- "--key-pass pass:android --ks-pass pass:android \\\n"
- "--ks debug.keystore bin/temp.apk"
- );
-}
-#endif
-
/*
* Standard VG includes & libraries which we use for games/graphics
* -------------------------------------------------------------------------- */
.custom_shaders = 0
};
-/* add engine to build target. It will recompile the engine using compiler,
- * and update the configuration, and build a list of sources to link with */
-void vg_add_engine( struct vg_project *proj,
- struct vg_engine_config *vg_conf,
- struct vg_compiler_env *env,
- struct vg_compiler_conf *conf,
- vg_str *sources )
+struct compile_result
+vg_make_app( struct vg_project *proj,
+ struct vg_engine_config *vg_conf,
+ struct vg_compiler_env *env,
+ struct vg_compiler_conf *conf,
+ const char *sources,
+ const char *appname )
{
struct vg_project vg_proj;
vg_project_init( &vg_proj, "bin", ".vg", 0 );
if( vg_conf->custom_shaders )
vg_strcat( &conf->defines, "-DVG_CUSTOM_SHADERS \\\n" );
- if( env->arch == k_architecture_i386 ||
- env->arch == k_architecture_armv7a )
+ if( env->arch == k_architecture_i386 )
vg_strcat( &conf->defines, "-DVG_32 \\\n" );
else
vg_strcat( &conf->defines, "-DVG_64 \\\n" );
- if( env->platform == k_platform_android )
- {
- vg_strcat( &conf->defines, "-DVG_ANDROID \\\n" );
-
- /* FIXME: -m32 womp womp */
- vg_strcatf( &conf->defines,
- "-DANDROID -DAPPNAME=\\\"%s\\\" -DANDROID_FULLSCREEN \\\n"
- "-DANDROIDVERSION=22 -mfloat-abi=softfp -m32 \\\n",
- proj->uid.buffer );
-
-#if 0
- vg_strcat( &config_string,
- "-L/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "sysroot/usr/lib/arm-linux-androideabi/22 \\\n"
- "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "sysroot/usr/include \\\n"
- "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "sysroot/usr/include/android \\\n"
- );
-#endif
- }
-
vg_strcat( &conf->defines, "\\\n" );
-
vg_strcat( &conf->include, "-I. -I./vg -I./vg/dep " );
/* compile all the components
* ----------------------------------------------------------------------- */
+ vg_str components = {0};
+ vg_strcatf( &components, "%s ", sources );
+
struct vg_compiler_env denv = *env;
denv.optimization = 3;
- denv.debug_asan = 0;
/* external dependencies */
struct compile_result depencies =
vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_depencies.c",
"vg_deps", k_obj_type_obj );
- vg_strcatf( sources, "%s ", depencies.path );
+ vg_strcatf( &components, "%s ", depencies.path );
/* glad */
- if( env->platform != k_platform_android )
- {
- struct compile_result glad =
- vg_compiler_run( &vg_proj, &denv, conf, "vg/dep/glad/glad.c",
- "vg_glad", k_obj_type_obj );
- vg_strcatf( sources, "%s ", glad.path );
- }
+ struct compile_result glad =
+ vg_compiler_run( &vg_proj, &denv, conf, "vg/dep/glad/glad.c",
+ "vg_glad", k_obj_type_obj );
+ vg_strcatf( &components, "%s ", glad.path );
/* core engine */
struct compile_result vg =
vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_engine.c",
"vg_engine_core", k_obj_type_obj );
- vg_strcatf( sources, "%s ", vg.path );
+ vg_strcatf( &components, "%s ", vg.path );
/* steamworks */
if( vg_conf->steam_api )
{
- if( env->platform == k_platform_android )
+ struct compile_result steam =
+ vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_steam.c",
+ "vg_steam", k_obj_type_obj );
+ vg_strcatf( &components, "%s ", steam.path );
+
+ if( env->platform == k_platform_linux )
{
- vg_warn( "Cannot use steam_api on android (build script mistake?)" );
+ vg_add_blob( proj, "vg/dep/steam/libsteam_api.so", "" );
+ vg_strcat( &conf->link, "-lsteam_api " );
}
- else
+ else if( env->platform == k_platform_windows )
{
- struct compile_result steam =
- vg_compiler_run( &vg_proj, &denv, conf, "vg/vg_steam.c",
- "vg_steam", k_obj_type_obj );
- vg_strcatf( sources, "%s ", steam.path );
-
- if( env->platform == k_platform_linux )
- {
- vg_add_blob( proj, "vg/dep/steam/libsteam_api.so", "" );
- vg_strcat( &conf->link, "-lsteam_api " );
- }
- else if( env->platform == k_platform_windows )
- {
- vg_add_blob( proj, "vg/dep/steam/steam_api64.dll", "" );
- vg_strcat( &conf->link, "vg/dep/steam/steam_api64.dll " );
- }
-
- vg_strcat( &conf->library, "-L./vg/dep/steam " );
+ vg_add_blob( proj, "vg/dep/steam/steam_api64.dll", "" );
+ vg_strcat( &conf->link, "vg/dep/steam/steam_api64.dll " );
}
+
+ vg_strcat( &conf->library, "-L./vg/dep/steam " );
}
/* link */
+ vg_strcat( &conf->library, "-L. -L/usr/lib " );
vg_strcat( &conf->link, "-lm " );
+
if( env->platform == k_platform_linux )
{
vg_strcat( &conf->link, "-lSDL2 -lGL -lX11 -lXxf86vm "
"-lXrandr -lXi -ldl -pthread " );
+
+ return vg_compiler_run( proj, env, conf, components.buffer,
+ appname, k_obj_type_exe );
}
else if( env->platform == k_platform_windows )
{
vg_strcat( &conf->link, "vg/dep/sdl/SDL2.dll " );
vg_add_blob( proj, "vg/dep/sdl/SDL2.dll ", "" );
vg_strcat( &conf->library, "-L./vg/dep/sdl " );
+
+ return vg_compiler_run( proj, env, conf, components.buffer,
+ appname, k_obj_type_exe );
}
- else if( env->platform == k_platform_android )
- {
- vg_strcat( &conf->link,
- "-lGLESv3 -lEGL -lOpenSLES -pthread -landroid -llog "
- "-uANativeActivity_onCreate ");
- }
+ else
+ vg_fatal_error( "Programming error" );
+
+ return (struct compile_result){};
}
void vg_add_controller_database( struct vg_project *proj )
+++ /dev/null
-#include <stdlib.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <time.h>
-#include <stdarg.h>
-#include "vg_opt.h"
-#include "vg_log.h"
-#include "vg_string.h"
-#include "vg_build_font.h"
-
-/* we dont free dynamic vg_strs in this program. so, we dont care.. */
-const char *__asan_default_options() { return "detect_leaks=0"; }
struct vg_engine vg = {
.time_rate = 1.0,
.time_fixed_delta = VG_TIMESTEP_FIXED,
-#ifdef VG_ANDROID
- .sl_status = PTHREAD_MUTEX_INITIALIZER
-#endif
};
#include <string.h>
#include "vg/vg_ui/imgui_impl_opengl.c"
#include "vg/vg_default_font.gc"
-#ifdef VG_ANDROID
-
-int _wrap_sem_getvalue( sem_t *sem )
-{
- int v;
- sem_getvalue( sem, &v );
- return v;
-}
-
-#define TEMP_STATUS_LOCK pthread_mutex_lock
-#define TEMP_STATUS_UNLOCK pthread_mutex_unlock
-#define TEMP_SEM_POST(X) sem_post( &X )
-#define TEMP_SEM_WAIT(X) sem_wait( &X )
-#define TEMP_SEM_GET(X) _wrap_sem_getvalue( &X )
-#else
#define TEMP_STATUS_LOCK SDL_AtomicLock
#define TEMP_STATUS_UNLOCK SDL_AtomicUnlock
#define TEMP_SEM_POST(X) SDL_SemPost( X )
#define TEMP_SEM_WAIT(X) SDL_SemWait( X )
#define TEMP_SEM_GET(X) SDL_SemValue( X )
-#endif
enum engine_status _vg_engine_status(void)
{
static void _vg_opengl_sync_init(void)
{
-#ifdef VG_ANDROID
- sem_init( &vg.sem_loader, 0, 1 );
-#else
vg.sem_loader = SDL_CreateSemaphore(1);
-#endif
}
#include "vg_console.h"
{
vg_success( "Internal async setup complete\n" );
-#ifdef VG_ANDROID
- pthread_mutex_lock( &vg.sl_status );
-#else
TEMP_STATUS_LOCK( &vg.sl_status );
-#endif
if( vg.engine_status == k_engine_status_crashed )
{
-#ifdef VG_ANDROID
- pthread_mutex_unlock( &vg.sl_status );
-#else
TEMP_STATUS_UNLOCK( &vg.sl_status );
-#endif
return;
}
else
vg.engine_status = k_engine_status_running;
}
-#ifdef VG_ANDROID
- pthread_mutex_unlock( &vg.sl_status );
-#else
TEMP_STATUS_UNLOCK( &vg.sl_status );
-#endif
}
#ifdef VG_CUSTOM_SHADERS
vg_preload();
vg_tex2d_replace_with_error_async( &vg.tex_missing );
vg_async_stall();
-#ifndef VG_ANDROID
vg_ui.tex_bg = vg.tex_missing;
-#endif
/* internal */
vg_loader_step( vg_input_init, vg_input_free );
v2_zero( vg.mouse_wheel );
v2_zero( vg.mouse_delta );
-#ifdef VG_ANDROID
-#else
/* SDL event loop */
SDL_Event event;
while( SDL_PollEvent( &event ) )
vg.mouse_state = SDL_GetMouseState( &vg.mouse_pos[0], &vg.mouse_pos[1] );
vg_process_inputs();
-#endif
}
static void _vg_gameloop_update(void)
return 0;
}
-static void _vg_gameloop(void){
- //vg.time_fixed_accumulator = 0.75f * (1.0f/60.0f);
-
+static void _vg_gameloop(void)
+{
vg.time_hp = SDL_GetPerformanceCounter();
vg.time_hp_last = vg.time_hp;
if( status == k_engine_status_running )
vg_profile_begin( &vg_prof_swap );
-#ifdef VG_ANDROID
- // TODO: eglSwapBuffers(
-#else
SDL_GL_SwapWindow( vg.window );
-#endif
if( status == k_engine_status_running )
vg_profile_end( &vg_prof_swap );
static void _vg_init_window( const char *window_name )
{
-#ifdef VG_ANDROID
-
-
-
-#else
vg_info( "SDL_INIT\n" );
if( SDL_Init( SDL_INIT_VIDEO ) != 0 )
vg_info( "Display refresh rate: %d\n", dispmode.refresh_rate );
if( !vg.fps_limit )
vg.fps_limit = vg.display_refresh_rate;
-#endif
}
static void _vg_terminate(void)
vg_success( "If you see this it means everything went.. \"well\".....\n" );
-#ifdef VG_ANDROID
-
-
-
-#else
SDL_GL_DeleteContext( vg.gl_context );
SDL_Quit();
-#endif
exit(0);
}
vg_async_init();
SDL_SetRelativeMouseMode(1);
-#ifdef VG_ANDROID
- vg.thread_id_main = pthread_self();
-#else
vg.thread_id_main = SDL_GetThreadID(NULL);
-#endif
/* Opengl-required systems */
vg_ui_init();
static void vg_settings_video_apply(void)
{
-#ifdef VG_ANDROID
-#else
if( vg_settings_enum_diff( &vg_settings.screenmode ) )
{
vg.screen_mode = vg_settings.screenmode.new_value;
SDL_SetWindowMaximumSize( vg.window, 4096, 4096 );
}
}
-#endif
vg.fps_limit = vg_settings.fps_limit.new_value;
vg.quality_profile = vg_settings.quality.new_value;
#define VG_ENGINE
#include "vg_opengl.h"
-#ifdef VG_ANDROID
-
-/* TODO: android gl includes */
-#include <pthread.h>
-#include <semaphore.h>
-
-#else
- #define SDL_MAIN_HANDLED
- #include "dep/sdl/include/SDL.h"
-#endif
+#define SDL_MAIN_HANDLED
+#include "dep/sdl/include/SDL.h"
#include "vg_platform.h"
#include "vg_mem.h"
struct vg_engine
{
/* Engine sync */
-#ifdef VG_ANDROID
- pthread_mutex_t sl_status;
- pthread_t thread_id_main, thread_id_loader;
- sem_t sem_loader;
-#else
SDL_Window *window;
SDL_GLContext gl_context;
SDL_sem *sem_loader; /* allows only one loader at a time */
thread_id_loader;
SDL_SpinLock sl_status;
-#endif
jmp_buf env_loader_exit;
void *thread_data;
GLuint tex_glyphs;
v2f inverse_font_sheet;
-#ifdef VG_ANDROID
-#else
SDL_Cursor *cursor_map[ k_ui_cursor_max ];
-#endif
/* at some point this should be implementation specific? */
v4f colour;
static int _vg_loader_thread( void *pfn )
{
-#ifdef VG_ANDROID
- vg.thread_id_loader = pthread_self();
-#else
vg.thread_id_loader = SDL_GetThreadID(NULL);
-#endif
if( setjmp( vg.env_loader_exit ) )
{
void vg_print_backtrace(void)
{
-#if !defined(_WIN32) && !defined(VG_ANDROID)
+#if !defined(_WIN32)
void *array[20];
char **strings;
int size, i;
-#ifdef VG_ANDROID
-#include <EGL/egl.h>
-#include <GLES3/gl3.h>
-#else
#include "dep/glad/glad.h"
-#endif
+++ /dev/null
-<?xml version="1.0" encoding="utf-8" standalone="no"?>
-<manifest
- xmlns:tools="http://schemas.android.com/tools"
- xmlns:android="http://schemas.android.com/apk/res/android"
- package="org.mtzero.carrot">
- <uses-sdk android:minSdkVersion="22" android:targetSdkVersion="22" />
- <uses-permission android:name="android.permission.SET_RELEASE_APP" />
- <uses-feature android:glEsVersion="0x00030002" android:required="true" />
- <application android:debuggable="true" android:hasCode="false"
- android:label="carrot"
- tools:replace="android:icon,android:theme,android:allowBackup,label"
- android:icon="@mipmap/icon">
- <activity android:configChanges="keyboardHidden|orientation"
- android:label="carrot" android:name="android.app.NativeActivity">
- <meta-data android:name="android.app.lib_name" android:value="carrot"/>
- <intent-filter>
- <action android:name="android.intent.action.MAIN"/>
- <category android:name="android.intent.category.LAUNCHER"/>
- </intent-filter>
- </activity>
- </application>
-</manifest>
+++ /dev/null
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include "android_native_app_glue.h"
-
-#include <jni.h>
-
-#include <errno.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-
-#include <android/log.h>
-
-#define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "threaded_app", __VA_ARGS__))
-#define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "threaded_app", __VA_ARGS__))
-
-/* For debug builds, always enable the debug traces in this library */
-#ifndef NDEBUG
-# define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, "threaded_app", __VA_ARGS__))
-#else
-# define LOGV(...) ((void)0)
-#endif
-
-static void free_saved_state(struct android_app* android_app) {
- pthread_mutex_lock(&android_app->mutex);
- if (android_app->savedState != NULL) {
- free(android_app->savedState);
- android_app->savedState = NULL;
- android_app->savedStateSize = 0;
- }
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-int8_t android_app_read_cmd(struct android_app* android_app) {
- int8_t cmd;
- if (read(android_app->msgread, &cmd, sizeof(cmd)) != sizeof(cmd)) {
- LOGE("No data on command pipe!");
- return -1;
- }
- if (cmd == APP_CMD_SAVE_STATE) free_saved_state(android_app);
- return cmd;
-}
-
-static void print_cur_config(struct android_app* android_app) {
- char lang[2], country[2];
- AConfiguration_getLanguage(android_app->config, lang);
- AConfiguration_getCountry(android_app->config, country);
-
- LOGV("Config: mcc=%d mnc=%d lang=%c%c cnt=%c%c orien=%d touch=%d dens=%d "
- "keys=%d nav=%d keysHid=%d navHid=%d sdk=%d size=%d long=%d "
- "modetype=%d modenight=%d",
- AConfiguration_getMcc(android_app->config),
- AConfiguration_getMnc(android_app->config),
- lang[0], lang[1], country[0], country[1],
- AConfiguration_getOrientation(android_app->config),
- AConfiguration_getTouchscreen(android_app->config),
- AConfiguration_getDensity(android_app->config),
- AConfiguration_getKeyboard(android_app->config),
- AConfiguration_getNavigation(android_app->config),
- AConfiguration_getKeysHidden(android_app->config),
- AConfiguration_getNavHidden(android_app->config),
- AConfiguration_getSdkVersion(android_app->config),
- AConfiguration_getScreenSize(android_app->config),
- AConfiguration_getScreenLong(android_app->config),
- AConfiguration_getUiModeType(android_app->config),
- AConfiguration_getUiModeNight(android_app->config));
-}
-
-void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd) {
- switch (cmd) {
- case APP_CMD_INPUT_CHANGED:
- LOGV("APP_CMD_INPUT_CHANGED");
- pthread_mutex_lock(&android_app->mutex);
- if (android_app->inputQueue != NULL) {
- AInputQueue_detachLooper(android_app->inputQueue);
- }
- android_app->inputQueue = android_app->pendingInputQueue;
- if (android_app->inputQueue != NULL) {
- LOGV("Attaching input queue to looper");
- AInputQueue_attachLooper(android_app->inputQueue,
- android_app->looper, LOOPER_ID_INPUT, NULL,
- &android_app->inputPollSource);
- }
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- break;
-
- case APP_CMD_INIT_WINDOW:
- LOGV("APP_CMD_INIT_WINDOW");
- pthread_mutex_lock(&android_app->mutex);
- android_app->window = android_app->pendingWindow;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- break;
-
- case APP_CMD_TERM_WINDOW:
- LOGV("APP_CMD_TERM_WINDOW");
- pthread_cond_broadcast(&android_app->cond);
- break;
-
- case APP_CMD_RESUME:
- case APP_CMD_START:
- case APP_CMD_PAUSE:
- case APP_CMD_STOP:
- LOGV("activityState=%d", cmd);
- pthread_mutex_lock(&android_app->mutex);
- android_app->activityState = cmd;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- break;
-
- case APP_CMD_CONFIG_CHANGED:
- LOGV("APP_CMD_CONFIG_CHANGED");
- AConfiguration_fromAssetManager(android_app->config,
- android_app->activity->assetManager);
- print_cur_config(android_app);
- break;
-
- case APP_CMD_DESTROY:
- LOGV("APP_CMD_DESTROY");
- android_app->destroyRequested = 1;
- break;
- }
-}
-
-void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd) {
- switch (cmd) {
- case APP_CMD_TERM_WINDOW:
- LOGV("APP_CMD_TERM_WINDOW");
- pthread_mutex_lock(&android_app->mutex);
- android_app->window = NULL;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- break;
-
- case APP_CMD_SAVE_STATE:
- LOGV("APP_CMD_SAVE_STATE");
- pthread_mutex_lock(&android_app->mutex);
- android_app->stateSaved = 1;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- break;
-
- case APP_CMD_RESUME:
- free_saved_state(android_app);
- break;
- }
-}
-
-void app_dummy() {
-}
-
-static void android_app_destroy(struct android_app* android_app) {
- LOGV("android_app_destroy!");
- free_saved_state(android_app);
- pthread_mutex_lock(&android_app->mutex);
- if (android_app->inputQueue != NULL) {
- AInputQueue_detachLooper(android_app->inputQueue);
- }
- AConfiguration_delete(android_app->config);
- android_app->destroyed = 1;
- pthread_cond_broadcast(&android_app->cond);
- pthread_mutex_unlock(&android_app->mutex);
- // Can't touch android_app object after this.
-}
-
-static void process_input(struct android_app* app, struct android_poll_source* source) {
- AInputEvent* event = NULL;
- while (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
- LOGV("New input event: type=%d", AInputEvent_getType(event));
- if (AInputQueue_preDispatchEvent(app->inputQueue, event)) {
- continue;
- }
- int32_t handled = 0;
- if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
- AInputQueue_finishEvent(app->inputQueue, event, handled);
- }
-}
-
-static void process_cmd(struct android_app* app, struct android_poll_source* source) {
- int8_t cmd = android_app_read_cmd(app);
- android_app_pre_exec_cmd(app, cmd);
- if (app->onAppCmd != NULL) app->onAppCmd(app, cmd);
- android_app_post_exec_cmd(app, cmd);
-}
-
-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;
-}
-
-// --------------------------------------------------------------------
-// Native activity interaction (called from main thread)
-// --------------------------------------------------------------------
-
-static struct android_app* android_app_create(ANativeActivity* activity,
- void* savedState, size_t savedStateSize) {
- struct android_app* android_app = calloc(1, sizeof(struct android_app));
- android_app->activity = activity;
-
- pthread_mutex_init(&android_app->mutex, NULL);
- pthread_cond_init(&android_app->cond, NULL);
-
- if (savedState != NULL) {
- android_app->savedState = malloc(savedStateSize);
- android_app->savedStateSize = savedStateSize;
- memcpy(android_app->savedState, savedState, savedStateSize);
- }
-
- int msgpipe[2];
- if (pipe(msgpipe)) {
- LOGE("could not create pipe: %s", strerror(errno));
- return NULL;
- }
- android_app->msgread = msgpipe[0];
- android_app->msgwrite = msgpipe[1];
-
- pthread_attr_t attr;
- pthread_attr_init(&attr);
- pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- pthread_create(&android_app->thread, &attr, android_app_entry, android_app);
-
- // Wait for thread to start.
- pthread_mutex_lock(&android_app->mutex);
- while (!android_app->running) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
- pthread_mutex_unlock(&android_app->mutex);
-
- return android_app;
-}
-
-static void android_app_write_cmd(struct android_app* android_app, int8_t cmd) {
- if (write(android_app->msgwrite, &cmd, sizeof(cmd)) != sizeof(cmd)) {
- LOGE("Failure writing android_app cmd: %s", strerror(errno));
- }
-}
-
-static void android_app_set_input(struct android_app* android_app, AInputQueue* inputQueue) {
- pthread_mutex_lock(&android_app->mutex);
- android_app->pendingInputQueue = inputQueue;
- android_app_write_cmd(android_app, APP_CMD_INPUT_CHANGED);
- while (android_app->inputQueue != android_app->pendingInputQueue) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-static void android_app_set_window(struct android_app* android_app, ANativeWindow* window) {
- pthread_mutex_lock(&android_app->mutex);
- if (android_app->pendingWindow != NULL) {
- android_app_write_cmd(android_app, APP_CMD_TERM_WINDOW);
- }
- android_app->pendingWindow = window;
- if (window != NULL) {
- android_app_write_cmd(android_app, APP_CMD_INIT_WINDOW);
- }
- while (android_app->window != android_app->pendingWindow) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-static void android_app_set_activity_state(struct android_app* android_app, int8_t cmd) {
- pthread_mutex_lock(&android_app->mutex);
- android_app_write_cmd(android_app, cmd);
- while (android_app->activityState != cmd) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
- pthread_mutex_unlock(&android_app->mutex);
-}
-
-static void android_app_free(struct android_app* android_app) {
- pthread_mutex_lock(&android_app->mutex);
- android_app_write_cmd(android_app, APP_CMD_DESTROY);
- while (!android_app->destroyed) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
- pthread_mutex_unlock(&android_app->mutex);
-
- close(android_app->msgread);
- close(android_app->msgwrite);
- pthread_cond_destroy(&android_app->cond);
- pthread_mutex_destroy(&android_app->mutex);
- free(android_app);
-}
-
-static struct android_app* ToApp(ANativeActivity* activity) {
- return (struct android_app*) activity->instance;
-}
-
-static void onDestroy(ANativeActivity* activity) {
- LOGV("Destroy: %p", activity);
- android_app_free(ToApp(activity));
-}
-
-static void onStart(ANativeActivity* activity) {
- LOGV("Start: %p", activity);
- android_app_set_activity_state(ToApp(activity), APP_CMD_START);
-}
-
-static void onResume(ANativeActivity* activity) {
- LOGV("Resume: %p", activity);
- android_app_set_activity_state(ToApp(activity), APP_CMD_RESUME);
-}
-
-static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
- LOGV("SaveInstanceState: %p", activity);
-
- struct android_app* android_app = ToApp(activity);
- void* savedState = NULL;
- pthread_mutex_lock(&android_app->mutex);
- android_app->stateSaved = 0;
- android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
- while (!android_app->stateSaved) {
- pthread_cond_wait(&android_app->cond, &android_app->mutex);
- }
-
- if (android_app->savedState != NULL) {
- savedState = android_app->savedState;
- *outLen = android_app->savedStateSize;
- android_app->savedState = NULL;
- android_app->savedStateSize = 0;
- }
-
- pthread_mutex_unlock(&android_app->mutex);
-
- return savedState;
-}
-
-static void onPause(ANativeActivity* activity) {
- LOGV("Pause: %p", activity);
- android_app_set_activity_state(ToApp(activity), APP_CMD_PAUSE);
-}
-
-static void onStop(ANativeActivity* activity) {
- LOGV("Stop: %p", activity);
- android_app_set_activity_state(ToApp(activity), APP_CMD_STOP);
-}
-
-static void onConfigurationChanged(ANativeActivity* activity) {
- LOGV("ConfigurationChanged: %p", activity);
- android_app_write_cmd(ToApp(activity), APP_CMD_CONFIG_CHANGED);
-}
-
-static void onContentRectChanged(ANativeActivity* activity, const ARect* r) {
- LOGV("ContentRectChanged: l=%d,t=%d,r=%d,b=%d", r->left, r->top, r->right, r->bottom);
- struct android_app* android_app = ToApp(activity);
- pthread_mutex_lock(&android_app->mutex);
- android_app->contentRect = *r;
- pthread_mutex_unlock(&android_app->mutex);
- android_app_write_cmd(ToApp(activity), APP_CMD_CONTENT_RECT_CHANGED);
-}
-
-static void onLowMemory(ANativeActivity* activity) {
- LOGV("LowMemory: %p", activity);
- android_app_write_cmd(ToApp(activity), APP_CMD_LOW_MEMORY);
-}
-
-static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
- LOGV("WindowFocusChanged: %p -- %d", activity, focused);
- android_app_write_cmd(ToApp(activity), focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
-}
-
-static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
- LOGV("NativeWindowCreated: %p -- %p", activity, window);
- android_app_set_window(ToApp(activity), window);
-}
-
-static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
- LOGV("NativeWindowDestroyed: %p -- %p", activity, window);
- android_app_set_window(ToApp(activity), NULL);
-}
-
-static void onNativeWindowRedrawNeeded(ANativeActivity* activity, ANativeWindow* window) {
- LOGV("NativeWindowRedrawNeeded: %p -- %p", activity, window);
- android_app_write_cmd(ToApp(activity), APP_CMD_WINDOW_REDRAW_NEEDED);
-}
-
-static void onNativeWindowResized(ANativeActivity* activity, ANativeWindow* window) {
- LOGV("NativeWindowResized: %p -- %p", activity, window);
- android_app_write_cmd(ToApp(activity), APP_CMD_WINDOW_RESIZED);
-}
-
-static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
- LOGV("InputQueueCreated: %p -- %p", activity, queue);
- android_app_set_input(ToApp(activity), queue);
-}
-
-static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
- LOGV("InputQueueDestroyed: %p -- %p", activity, queue);
- android_app_set_input(ToApp(activity), NULL);
-}
-
-JNIEXPORT
-void ANativeActivity_onCreate(ANativeActivity* activity, void* savedState, size_t savedStateSize) {
- LOGV("Creating: %p", activity);
-
- activity->callbacks->onConfigurationChanged = onConfigurationChanged;
- activity->callbacks->onContentRectChanged = onContentRectChanged;
- activity->callbacks->onDestroy = onDestroy;
- activity->callbacks->onInputQueueCreated = onInputQueueCreated;
- activity->callbacks->onInputQueueDestroyed = onInputQueueDestroyed;
- activity->callbacks->onLowMemory = onLowMemory;
- activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
- activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
- activity->callbacks->onNativeWindowRedrawNeeded = onNativeWindowRedrawNeeded;
- activity->callbacks->onNativeWindowResized = onNativeWindowResized;
- activity->callbacks->onPause = onPause;
- activity->callbacks->onResume = onResume;
- activity->callbacks->onSaveInstanceState = onSaveInstanceState;
- activity->callbacks->onStart = onStart;
- activity->callbacks->onStop = onStop;
- activity->callbacks->onWindowFocusChanged = onWindowFocusChanged;
-
- activity->instance = android_app_create(activity, savedState, savedStateSize);
-}
+++ /dev/null
-/*
- * Copyright (C) 2010 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <poll.h>
-#include <pthread.h>
-#include <sched.h>
-
-#include <android/configuration.h>
-#include <android/looper.h>
-#include <android/native_activity.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/**
- * The native activity interface provided by <android/native_activity.h>
- * is based on a set of application-provided callbacks that will be called
- * by the Activity's main thread when certain events occur.
- *
- * This means that each one of this callbacks _should_ _not_ block, or they
- * risk having the system force-close the application. This programming
- * model is direct, lightweight, but constraining.
- *
- * The 'android_native_app_glue' static library is used to provide a different
- * execution model where the application can implement its own main event
- * loop in a different thread instead. Here's how it works:
- *
- * 1/ The application must provide a function named "android_main()" that
- * will be called when the activity is created, in a new thread that is
- * distinct from the activity's main thread.
- *
- * 2/ android_main() receives a pointer to a valid "android_app" structure
- * that contains references to other important objects, e.g. the
- * ANativeActivity object instance the application is running in.
- *
- * 3/ the "android_app" object holds an ALooper instance that already
- * listens to two important things:
- *
- * - activity lifecycle events (e.g. "pause", "resume"). See APP_CMD_XXX
- * declarations below.
- *
- * - input events coming from the AInputQueue attached to the activity.
- *
- * Each of these correspond to an ALooper identifier returned by
- * ALooper_pollOnce with values of LOOPER_ID_MAIN and LOOPER_ID_INPUT,
- * respectively.
- *
- * Your application can use the same ALooper to listen to additional
- * file-descriptors. They can either be callback based, or with return
- * identifiers starting with LOOPER_ID_USER.
- *
- * 4/ Whenever you receive a LOOPER_ID_MAIN or LOOPER_ID_INPUT event,
- * the returned data will point to an android_poll_source structure. You
- * can call the process() function on it, and fill in android_app->onAppCmd
- * and android_app->onInputEvent to be called for your own processing
- * of the event.
- *
- * Alternatively, you can call the low-level functions to read and process
- * the data directly... look at the process_cmd() and process_input()
- * implementations in the glue to see how to do this.
- *
- * See the sample named "native-activity" that comes with the NDK with a
- * full usage example. Also look at the JavaDoc of NativeActivity.
- */
-
-struct android_app;
-
-/**
- * Data associated with an ALooper fd that will be returned as the "outData"
- * when that source has data ready.
- */
-struct android_poll_source {
- // The identifier of this source. May be LOOPER_ID_MAIN or
- // LOOPER_ID_INPUT.
- int32_t id;
-
- // The android_app this ident is associated with.
- struct android_app* app;
-
- // Function to call to perform the standard processing of data from
- // this source.
- void (*process)(struct android_app* app, struct android_poll_source* source);
-};
-
-/**
- * This is the interface for the standard glue code of a threaded
- * application. In this model, the application's code is running
- * in its own thread separate from the main thread of the process.
- * It is not required that this thread be associated with the Java
- * VM, although it will need to be in order to make JNI calls any
- * Java objects.
- */
-struct android_app {
- // The application can place a pointer to its own state object
- // here if it likes.
- void* userData;
-
- // Fill this in with the function to process main app commands (APP_CMD_*)
- void (*onAppCmd)(struct android_app* app, int32_t cmd);
-
- // Fill this in with the function to process input events. At this point
- // the event has already been pre-dispatched, and it will be finished upon
- // return. Return 1 if you have handled the event, 0 for any default
- // dispatching.
- int32_t (*onInputEvent)(struct android_app* app, AInputEvent* event);
-
- // The ANativeActivity object instance that this app is running in.
- ANativeActivity* activity;
-
- // The current configuration the app is running in.
- AConfiguration* config;
-
- // This is the last instance's saved state, as provided at creation time.
- // It is NULL if there was no state. You can use this as you need; the
- // memory will remain around until you call android_app_exec_cmd() for
- // APP_CMD_RESUME, at which point it will be freed and savedState set to NULL.
- // These variables should only be changed when processing a APP_CMD_SAVE_STATE,
- // at which point they will be initialized to NULL and you can malloc your
- // state and place the information here. In that case the memory will be
- // freed for you later.
- void* savedState;
- size_t savedStateSize;
-
- // The ALooper associated with the app's thread.
- ALooper* looper;
-
- // When non-NULL, this is the input queue from which the app will
- // receive user input events.
- AInputQueue* inputQueue;
-
- // When non-NULL, this is the window surface that the app can draw in.
- ANativeWindow* window;
-
- // Current content rectangle of the window; this is the area where the
- // window's content should be placed to be seen by the user.
- ARect contentRect;
-
- // Current state of the app's activity. May be either APP_CMD_START,
- // APP_CMD_RESUME, APP_CMD_PAUSE, or APP_CMD_STOP; see below.
- int activityState;
-
- // This is non-zero when the application's NativeActivity is being
- // destroyed and waiting for the app thread to complete.
- int destroyRequested;
-
- // -------------------------------------------------
- // Below are "private" implementation of the glue code.
-
- pthread_mutex_t mutex;
- pthread_cond_t cond;
-
- int msgread;
- int msgwrite;
-
- pthread_t thread;
-
- struct android_poll_source cmdPollSource;
- struct android_poll_source inputPollSource;
-
- int running;
- int stateSaved;
- int destroyed;
- int redrawNeeded;
- AInputQueue* pendingInputQueue;
- ANativeWindow* pendingWindow;
- ARect pendingContentRect;
-};
-
-enum {
- /**
- * Looper data ID of commands coming from the app's main thread, which
- * is returned as an identifier from ALooper_pollOnce(). The data for this
- * identifier is a pointer to an android_poll_source structure.
- * These can be retrieved and processed with android_app_read_cmd()
- * and android_app_exec_cmd().
- */
- LOOPER_ID_MAIN = 1,
-
- /**
- * Looper data ID of events coming from the AInputQueue of the
- * application's window, which is returned as an identifier from
- * ALooper_pollOnce(). The data for this identifier is a pointer to an
- * android_poll_source structure. These can be read via the inputQueue
- * object of android_app.
- */
- LOOPER_ID_INPUT = 2,
-
- /**
- * Start of user-defined ALooper identifiers.
- */
- LOOPER_ID_USER = 3,
-};
-
-enum {
- /**
- * Command from main thread: the AInputQueue has changed. Upon processing
- * this command, android_app->inputQueue will be updated to the new queue
- * (or NULL).
- */
- APP_CMD_INPUT_CHANGED,
-
- /**
- * Command from main thread: a new ANativeWindow is ready for use. Upon
- * receiving this command, android_app->window will contain the new window
- * surface.
- */
- APP_CMD_INIT_WINDOW,
-
- /**
- * Command from main thread: the existing ANativeWindow needs to be
- * terminated. Upon receiving this command, android_app->window still
- * contains the existing window; after calling android_app_exec_cmd
- * it will be set to NULL.
- */
- APP_CMD_TERM_WINDOW,
-
- /**
- * Command from main thread: the current ANativeWindow has been resized.
- * Please redraw with its new size.
- */
- APP_CMD_WINDOW_RESIZED,
-
- /**
- * Command from main thread: the system needs that the current ANativeWindow
- * be redrawn. You should redraw the window before handing this to
- * android_app_exec_cmd() in order to avoid transient drawing glitches.
- */
- APP_CMD_WINDOW_REDRAW_NEEDED,
-
- /**
- * Command from main thread: the content area of the window has changed,
- * such as from the soft input window being shown or hidden. You can
- * find the new content rect in android_app::contentRect.
- */
- APP_CMD_CONTENT_RECT_CHANGED,
-
- /**
- * Command from main thread: the app's activity window has gained
- * input focus.
- */
- APP_CMD_GAINED_FOCUS,
-
- /**
- * Command from main thread: the app's activity window has lost
- * input focus.
- */
- APP_CMD_LOST_FOCUS,
-
- /**
- * Command from main thread: the current device configuration has changed.
- */
- APP_CMD_CONFIG_CHANGED,
-
- /**
- * Command from main thread: the system is running low on memory.
- * Try to reduce your memory use.
- */
- APP_CMD_LOW_MEMORY,
-
- /**
- * Command from main thread: the app's activity has been started.
- */
- APP_CMD_START,
-
- /**
- * Command from main thread: the app's activity has been resumed.
- */
- APP_CMD_RESUME,
-
- /**
- * Command from main thread: the app should generate a new saved state
- * for itself, to restore from later if needed. If you have saved state,
- * allocate it with malloc and place it in android_app.savedState with
- * the size in android_app.savedStateSize. The will be freed for you
- * later.
- */
- APP_CMD_SAVE_STATE,
-
- /**
- * Command from main thread: the app's activity has been paused.
- */
- APP_CMD_PAUSE,
-
- /**
- * Command from main thread: the app's activity has been stopped.
- */
- APP_CMD_STOP,
-
- /**
- * Command from main thread: the app's activity is being destroyed,
- * and waiting for the app thread to clean up and exit before proceeding.
- */
- APP_CMD_DESTROY,
-};
-
-/**
- * Call when ALooper_pollAll() returns LOOPER_ID_MAIN, reading the next
- * app command message.
- */
-int8_t android_app_read_cmd(struct android_app* android_app);
-
-/**
- * Call with the command returned by android_app_read_cmd() to do the
- * initial pre-processing of the given command. You can perform your own
- * actions for the command after calling this function.
- */
-void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd);
-
-/**
- * Call with the command returned by android_app_read_cmd() to do the
- * final post-processing of the given command. You must have done your own
- * actions for the command before calling this function.
- */
-void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd);
-
-/**
- * No-op function that used to be used to prevent the linker from stripping app
- * glue code. No longer necessary, since __attribute__((visibility("default")))
- * does this for us.
- */
-__attribute__((
- deprecated("Calls to app_dummy are no longer necessary. See "
- "https://github.com/android-ndk/ndk/issues/381."))) void
-app_dummy();
-
-/**
- * This is the function that application code must implement, representing
- * the main entry to the app.
- */
-extern void android_main(struct android_app* app);
-
-#ifdef __cplusplus
-}
-#endif
+++ /dev/null
-#include "vg/vg_tool.h"
-#include "vg/vg_platform.h"
-#include "vg/vg_log.h"
-#include "vg/vg_opt.h"
-#include "vg/vg_build.h"
-#include "vg/vg_build_utils_shader.h"
-#include "vg/vg_msg.h"
-
-/*
- * Scripts
- * -------------------------------------------------------------------------- */
-
-void s_testing_build(void)
-{
- vg_info( "running script: s_testing_build(void)\n" );
-
- /* build 64 bit*/
- vg_syscall( "/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "bin/aarch64-linux-android22-clang \\\n"
- "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "sysroot/usr/include \\\n"
- "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "sysroot/usr/include/android \\\n"
- "-I.\\\n"
- "-Wall -fPIC \\\n"
- "-DANDROID -DAPPNAME=\\\"carrot\\\" -DANDROID_FULLSCREEN \\\n"
- "-DANDROIDVERSION=22 -m64 \\\n"
- "main.c android_native_app_glue.c \\\n"
- "-o lib/arm64-v8a/libcarrot.so \\\n"
- "-L /opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "sysroot/usr/lib/aarch64-linux-android/22 \\\n"
- "-lm -lGLESv3 -lEGL -landroid -llog -lOpenSLES -shared \\\n"
- "-uANativeActivity_onCreate "
- );
-
- /* build 32 bit*/
- vg_syscall( "/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "bin/armv7a-linux-androideabi22-clang \\\n"
- "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "sysroot/usr/include \\\n"
- "-I/opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "sysroot/usr/include/android \\\n"
- "-I.\\\n"
- "-Wall -fPIC \\\n"
- "-DANDROID -DAPPNAME=\\\"carrot\\\" -DANDROID_FULLSCREEN \\\n"
- "-DANDROIDVERSION=22 -mfloat-abi=softfp -m32 \\\n"
- "main.c android_native_app_glue.c \\\n"
- "-o lib/armeabi-v7a/libcarrot.so \\\n"
- "-L /opt/android-ndk/toolchains/llvm/prebuilt/linux-x86_64/"
- "sysroot/usr/lib/arm-linux-androideabi/22 \\\n"
- "-lm -lGLESv3 -lEGL -landroid -llog -lOpenSLES -shared \\\n"
- "-uANativeActivity_onCreate "
- );
-
- /* pack */
- vg_syscall( "/opt/android-sdk/build-tools/34.0.0/aapt package -vf \\\n"
- "--target-sdk-version 22 \\\n"
- "-F bin/temp.apk \\\n"
- "-I /opt/android-sdk/platforms/android-22/android.jar \\\n"
- "-M AndroidManifest.xml \\\n"
- "-S resources/ \\\n"
- "-A assets/ "
- );
- vg_syscall( "/opt/android-sdk/build-tools/34.0.0/aapt add -v \\\n"
- "bin/temp.apk \\\n"
- "lib/arm64-v8a/libcarrot.so \\\n"
- );
- vg_syscall( "/opt/android-sdk/build-tools/34.0.0/aapt add -v \\\n"
- "bin/temp.apk \\\n"
- "lib/armeabi-v7a/libcarrot.so \\\n"
- );
-
- /* sign */
-#if 0
-keytool -genkey -v -keystore debug.keystore -storepass android -alias \
-androiddebugkey -keypass android -keyalg RSA -keysize 2048 -validity 10000 \
--dname "C=US, O=Android, CN=Android Debug"
-#endif
- vg_syscall( "/opt/android-sdk/build-tools/34.0.0/apksigner sign \\\n"
- "--key-pass pass:android --ks-pass pass:android \\\n"
- "--ks debug.keystore bin/temp.apk"
- );
-
- /* push */
- vg_syscall( "/opt/android-sdk/platform-tools/adb install -r \\\n"
- "bin/temp.apk "
- );
-
- /* run */
- vg_syscall( "/opt/android-sdk/platform-tools/adb shell am start -n \\\n"
- "org.mtzero.carrot/android.app.NativeActivity "
- );
-}
-
-int main( int argc, char *argv[] )
-{
- char *arg;
- while( vg_argp( argc, argv ) )
- {
- if( vg_long_opt( "testing-build" ) )
- s_testing_build();
-
- if( vg_opt('r') )
- vg_test_env.optimization = 3;
- }
-
- vg_success( "All scripts completed\n" );
-}
+++ /dev/null
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
- <string name="app_name">carrot</string>
- <string name="lib_name">carrot</string>
- <string name="package_name">org.mtzero.carrot</string>
-</resources>
-
void vg_ui_post_update(void)
{
-#ifdef VG_ANDROID
-#else
if( vg_ui.ctx.wants_mouse )
{
SDL_SetWindowGrab( vg.window, SDL_FALSE );
SDL_SetCursor( vg_ui.cursor_map[ vg_ui.ctx.cursor ] );
SDL_ShowCursor(1);
-#endif
}
void vg_ui_set_mouse_pos( ui_px x, ui_px y )
{
-#ifdef VG_ANDROID
-#else
SDL_WarpMouseInWindow( vg.window, x, y );
vg_ui.ctx.mouse[0] = x;
vg_ui.ctx.mouse[1] = y;
vg_ui.ctx.mouse_pos_overriden = 1;
-#endif
}
-#ifdef VG_ANDROID
-#else
void vg_ui_handle_sdl_key( ui_context *ctx, SDL_Keysym ev )
{
if( ctx->focused_control_type != k_ui_control_textbox )
{
return SDL_HasClipboardText();
}
-#endif
void vg_ui_init(void)
{
/* callbacks */
vg_ui.ctx.render_batch = ui_impl_render_batch;
-#ifdef VG_ANDROID
-#else
vg_ui.ctx.have_clipboard_text = _wrap_sdl_hasclipboard_text;
vg_ui.ctx.get_clipboard_text = SDL_GetClipboardText;
vg_ui.ctx.free_clipboard_text = SDL_free;
vg_ui.ctx.set_clipboard_text = SDL_SetClipboardText;
vg_ui.ctx.start_text_input = SDL_StartTextInput;
vg_ui.ctx.stop_text_input = SDL_StopTextInput;
-#endif
/* Generate the buffer we are gonna be drawing to */
glGenVertexArrays( 1, &vg_ui.vao );
(void *)offsetof( ui_vert, colour ) );
glEnableVertexAttribArray( 2 );
-#ifdef VG_ANDROID
-#else
vg_ui.cursor_map[ k_ui_cursor_default ] =
SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_ARROW );
vg_ui.cursor_map[ k_ui_cursor_hand ] =
SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_HAND );
vg_ui.cursor_map[ k_ui_cursor_ibeam ] =
SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_IBEAM );
-#endif
/* font
* -----------------------------------------------------
projects / vg.git / commitdiff
