The user wants an Android app in C. This is interesting because Android apps are typically written in Java/Kotlin, but you CAN write Android apps using C via the Android NDK (Native Development Kit). However, there are important nuances: 1. Pure C Android apps are possible with the NDK using `android_native_app_glue` - this lets you write an app entirely in C/C++ with native activity 2. You need the Android NDK and use `NativeActivity` 3. The typical approach: use the NDK's native_app_glue framework which handles the Android lifecycle Let me create a complete example of an Android app written in C. I'll make something simple but functional - maybe a drawing app or a simple game, since that shows off the native activity capabilities well. Key components needed: 1. `AndroidManifest.xml` - declaring NativeActivity 2. `main.c` - the C source code using android_native_app_glue 3. Build files - either ndk-build (Android.mk/Application.mk) or CMake, or a build script 4. Instructions for building Let me write a complete, working example. I'll do a simple app that draws something on screen and responds to touch - maybe a bouncing ball or a touch-painting app. A drawing app is nice and demonstrates touch input + rendering. Actually, let me make a simple "hello" style app that: - Uses NativeActivity - Renders with EGL/OpenGL ES (the standard way for pure native apps) - Handles touch input Let me write the code carefully: **AndroidManifest.xml:** ```xml

``` Important: `android:hasCode="false"` since we have no Java code. **main.c** - using android_native_app_glue: The standard structure: - `android_main(struct android_app* state)` is the entry point - Handle lifecycle events (APP_CMD_INIT_WINDOW etc.) - Set up EGL for rendering - Handle input events - Render loop Let me write a complete drawing app or animated app. I'll do something visually appealing: a touch-reactive animated app with a moving/fading trail. Or simpler: bouncing balls spawned on touch. Let me write clean code: ```c #include #include #include #include #include #include #include #define MAX_BALLS 64 typedef struct { float x, y; // position float vx, vy; // velocity float r, g, b; // color float radius; int alive; } Ball; ``` For GLES2 rendering I need shaders. Let me write minimal vertex/fragment shaders for circles. Rendering circles in GLES2: use a quad and compute distance in fragment shader. Vertex shader: ```glsl attribute vec2 a_pos; uniform vec2 u_resolution; uniform vec2 u_center; uniform float u_radius; void main() { vec2 pos = u_center + a_pos * u_radius; // convert to clip space vec2 clip = (pos / u_resolution) * 2.0 - 1.0; gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0); } ``` Fragment shader: ```glsl precision mediump float; varying vec2 v_local; // need varying from vertex shader uniform vec3 u_color; void main() { float d = length(v_local); if (d > 1.0) discard; float alpha = smoothstep(1.0, 0.8, d); gl_FragColor = vec4(u_color, alpha); } ``` Hmm, need v_local varying. Vertex shader passes a_pos (unit square corners) as varying. Actually, let me keep it simple and robust. Full-screen quad per ball with attributes: ```c static const float quad[] = { -1,-1, 1,-1, -1,1, 1,1 }; // triangle strip ``` Vertex shader: ```glsl attribute vec2 a_pos; // unit quad coords in [-1,1] uniform vec2 u_res; // screen resolution in pixels uniform vec2 u_center; // ball center in pixels uniform float u_radius; // radius in pixels varying vec2 v_local; void main() { v_local = a_pos; vec2 pos = u_center + a_pos * u_radius; vec2 clip = pos / u_res * 2.0 - 1.0; gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0); } ``` Fragment shader: ```glsl precision mediump float; varying vec2 v_local; uniform vec3 u_color; void main() { float d = length(v_local); float alpha = 1.0 - smoothstep(0.85, 1.0, d); gl_FragColor = vec4(u_color, alpha); } ``` Enable blending: `glBlendFunc(SRC_ALPHA, ONE_MINUS_SRC_ALPHA)`. Background color: dark. **EGL setup:** ```c static EGLDisplay display = EGL_NO_DISPLAY; static EGLSurface surface = EGL_NO_SURFACE; static EGLContext context = EGL_NO_CONTEXT; static int init_display(struct android_app* app) { 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 }; ... } ``` Standard EGL boilerplate. Let me write it out fully. **Game state & input:** Handle `AMotionEvent` in the input callback: ```c static int32_t on_input(struct android_app* app, AInputEvent* event) { if (AInputEvent_getType(event) == AINPUT_EVENT_TYPE_MOTION) { int32_t action = AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_MASK; if (action == AMOTION_EVENT_ACTION_DOWN || action == AMOTION_EVENT_ACTION_MOVE) { float x = AMotionEvent_getX(event, 0); float y = AMotionEvent_getY(event, 0); spawn_ball(x, y); } return 1; } return 0; } ``` **Lifecycle:** - APP_CMD_INIT_WINDOW → init display - APP_CMD_TERM_WINDOW → terminate display - APP_CMD_GAINED_FOCUS / LOST_FOCUS → toggle running flag **Main loop:** ```c void android_main(struct android_app* state) { app_dummy(); // older NDK needed this; newer not required but harmless? Actually in newer NDK versions app_dummy was removed. Let me check. ``` In newer NDK versions (r13+?), `app_dummy()` is no longer needed. Actually android_native_app_glue changed - the entry point no longer requires calling app_dummy(). In current NDKs, `android_main` doesn't need app_dummy. To be safe across versions, I could just not call it and note it. Hmm. If someone uses an older NDK, missing app_dummy causes a crash on older Android versions (< 4.4?). Best practice now: don't call it. I'll omit it and mention NDK version requirement. Actually, including it can cause link errors in newer NDKs since app_dummy was removed from the glue... Let me check: In NDK r20+, android_native_app_glue.h no longer declares app_dummy. Actually I recall it was deprecated in r14ish. To be safe, I'll write code for a modern NDK (r19+) without app_dummy. Physics update: gravity, bounce off walls, lifespan fade. Let me add particles that shrink and die. Let me design: touch spawns a burst of colorful balls at the touch point with random velocities. Balls have gravity, bounce off screen edges, fade out over ~3 seconds. Also spawn continuously while dragging. Also an idle demo ball bouncing around so screen isn't empty. Delta time: use clock_gettime(CLOCK_MONOTONIC). Let me write the full code: ```c // main.c — A tiny Android app written in pure C (NDK NativeActivity) // Touch the screen to spawn bouncing particles. #include #include #include #include #include #include #include #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "capp", __VA_ARGS__)) #define MAX_PARTICLES 256 #define PARTICLE_LIFE 4.0f typedef struct { float x, y, vx, vy; float hue; // color hue 0..1 float born; // seconds since epoch of app float life; float radius; int alive; } Particle; struct engine { struct android_app* app; EGLDisplay display; EGLSurface surface; EGLContext context; int32_t width, height; GLuint program; GLint a_pos, u_res, u_center, u_radius, u_color; Particle particles[MAX_PARTICLES]; double last_time; float hue_next; int animating; }; static struct engine g_engine; ``` Hue to RGB conversion function: ```c static void hue_to_rgb(float h, float* r, float* g, float* b) { // h in [0,1) float f = h * 6.0f; int i = (int)f; float frac = f - i; float q = 1.0f - frac; switch (i % 6) { case 0: *r=1; *g=frac; *b=0; break; case 1: *r=q; *g=1; *b=0; break; case 2: *r=0; *g=1; *b=frac; break; case 3: *r=0; *g=q; *b=1; break; case 4: *r=frac; *g=0; *b=1; break; case 5: *r=1; *g=0; *b=q; break; } } ``` Hmm, that's a decent quick HSV->RGB for v=1, s=1. Fine. Shaders: ```c static const char* VERT_SRC = "attribute vec2 a_pos;\n" "uniform vec2 u_res;\n" "uniform vec2 u_center;\n" "uniform float u_radius;\n" "varying vec2 v_local;\n" "void main() {\n" " v_local = a_pos;\n" " vec2 px = u_center + a_pos * u_radius;\n" " vec2 clip = px / u_res * 2.0 - 1.0;\n" " gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);\n" "}\n"; static const char* FRAG_SRC = "precision mediump float;\n" "varying vec2 v_local;\n" "uniform vec3 u_color;\n" "void main() {\n" " float d = length(v_local);\n" " float alpha = 1.0 - smoothstep(0.85, 1.0, d);\n" " gl_FragColor = vec4(u_color, alpha);\n" "}\n"; ``` Compile helper: ```c static GLuint compile_shader(GLenum type, const char* src) { GLuint s = glCreateShader(type); glShaderSource(s, 1, &src, NULL); glCompileShader(s); GLint ok = GL_FALSE; glGetShaderiv(s, GL_COMPILE_STATUS, &ok); if (!ok) { char log[512]; glGetShaderInfoLog(s, sizeof log, NULL, log); LOGI("shader error: %s", log); } return s; } ``` EGL init: ```c static int engine_init_display(struct engine* e) { // Setup EGL 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 w, h, format; EGLint numConfigs; EGLConfig config; EGLSurface surface; EGLContext context; EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY); eglInitialize(display, 0, 0); eglChooseConfig(display, attribs, &config, 1, &numConfigs); eglGetConfigAttrib(display, config, EGL_NATIVE_VISUAL_ID, &format); ANativeWindow_setBuffersGeometry(e->app->window, 0, 0, format); surface = eglCreateWindowSurface(display, config, e->app->window, NULL); EGLint context_attribs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; context = eglCreateContext(display, config, NULL, context_attribs); if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) { LOGI("eglMakeCurrent failed"); return -1; } e->display = display; e->surface = surface; e->context = context; eglQuerySurface(display, surface, EGL_WIDTH, &w); eglQuerySurface(display, surface, EGL_HEIGHT, &h); e->width = w; e->height = h; // Build GL program GLuint vs = compile_shader(GL_VERTEX_SHADER, VERT_SRC); GLuint fs = compile_shader(GL_FRAGMENT_SHADER, FRAG_SRC); GLuint prog = glCreateProgram(); glAttachShader(prog, vs); glAttachShader(prog, fs); glLinkProgram(prog); GLint ok; glGetProgramiv(prog, GL_LINK_STATUS, &ok); if (!ok) { LOGI("link error"); } e->program = prog; e->a_pos = glGetAttribLocation(prog, "a_pos"); e->u_res = glGetUniformLocation(prog, "u_res"); e->u_center = glGetUniformLocation(prog, "u_center"); e->u_radius = glGetUniformLocation(prog, "u_radius"); e->u_color = glGetUniformLocation(prog, "u_color"); glUseProgram(prog); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); e->last_time = now_seconds(); return 0; } ``` Also need check for window/app->window being null. Draw: ```c static void engine_draw(struct engine* e) { glViewport(0, 0, e->width, e->height); glClearColor(0.06f, 0.07f, 0.10f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); static const GLfloat quad[8] = { -1,-1, 1,-1, -1,1, 1,1 }; glVertexAttribPointer(e->a_pos, 2, GL_FLOAT, GL_FALSE, 0, quad); glEnableVertexAttribArray(e->a_pos); glUniform2f(e->u_res, (float)e->width, (float)e->height); for (int i = 0; i < MAX_PARTICLES; i++) { Particle* p = &e->particles[i]; if (!p->alive) continue; float age = (float)(now_seconds() - p->born); float t = age / p->life; if (t >= 1.0f) { p->alive = 0; continue; } float r, g, b; hue_to_rgb(p->hue, &r, &g, &b); glUniform2f(e->u_center, p->x, p->y); glUniform1f(e->u_radius, p->radius * (1.0f - t * 0.5f)); glUniform3f(e->u_color, r, g, b); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } eglSwapBuffers(e->display, e->surface); } ``` Note alpha in fragment shader isn't used to fade; I can fade via radius or multiply color... simpler: keep alpha smooth edge, fade by shrinking radius. Fine. Actually let me add fade by passing uniform alpha or multiplying u_color by (1-t)? Multiplying color darkens toward black on dark background — looks like fading, acceptable. Or add a u_alpha uniform. Let me add u_alpha for niceness: frag: ```glsl "uniform float u_alpha;\n" ... gl_FragColor = vec4(u_color, alpha * u_alpha); ``` Good. Update: ```c static void engine_update(struct engine* e, float dt) { float g = 1400.0f; // px/s^2 for (...) { p->vy += g * dt; p->x += p->vx * dt; p->y += p->vy * dt; // bounce if (p->x < p->radius) { p->x = p->radius; p->vx = -p->vx * 0.8f; } if (p->x > e->width - p->radius) { ... } if (p->y > e->height - p->radius) { p->y = ...; p->vy = -p->vy * 0.8f; p->vx *= 0.98f; } if (p->y < p->radius && p->vy < 0) { ... } } } ``` Note: screen Y increases downward in Android coordinates, which matches our clip transform (we negate clip.y so top of screen = y=0). Gravity positive y = downward. Bounce at bottom: p->y > height - radius. Spawn: ```c static void spawn_burst(struct engine* e, float x, float y, int n) { for (int i = 0; i < n; i++) { Particle* p = free particle; float ang = random 0..2pi; float speed = 200 + rand%500; p->x = x; p->y = y; p->vx = cosf(ang)*speed; p->vy = sinf(ang)*speed; p->hue = e->hue_next; e->hue_next += 0.13f; wrap p->born = now; p->life = 2.5f + rand*2 p->radius = 10 + rand%25 p->alive = 1; } } ``` Random seeding: srand(time(NULL)) — but getrandom... time is fine. Actually for Android, seeding with time(NULL) is fine for this toy. Input callback: on DOWN and MOVE spawn a small burst (or single). MOVE with multiple pointers — use AMotionEvent_getPointerCount and iterate. Keep it simple: iterate pointers. Actually spawning a burst of like 3 per move event could flood; MOVE events fire at ~60Hz. Spawn 1 particle per event per pointer. And a burst of 12 on DOWN. That's fine. Command callback: ```c static void on_cmd(struct android_app* app, int32_t cmd) { struct engine* e = (struct engine*)app->userData; switch (cmd) { case APP_CMD_INIT_WINDOW: if (app->window) engine_init_display(e); break; case APP_CMD_TERM_WINDOW: engine_term_display(e); break; case APP_CMD_GAINED_FOCUS: e->animating = 1; break; case APP_CMD_LOST_FOCUS: e->animating = 0; break; } } ``` android_main: ```c void android_main(struct android_app* state) { struct engine* e = &g_engine; memset(e, 0, sizeof *e); e->app = state; state->userData = e; state->onAppCmd = on_cmd; state->onInputEvent = on_input; srand((unsigned)time(NULL)); while (1) { int ident; int events; struct android_poll_source* source; while ((ident = ALooper_pollAll(e->animating ? 0 : -1, NULL, &events, (void**)&source)) >= 0) { if (source) source->process(state, source); if (state->destroyRequested) { engine_term_display(e); return; } } if (e->animating && e->display) { double now = now_seconds(); float dt = (float)(now - e->last_time); e->last_time = now; if (dt > 0.1f) dt = 0.1f; // avoid huge steps engine_update(e, dt); engine_draw(e); } } } ``` Wait — there's a subtlety with the poll timeout: when not animating, poll with -1 (block). When animating, poll with 0 to render every frame. Standard from the NDK sample. Good. But there's an issue: if not animating (lost focus) we block forever — fine, standard. now_seconds: ```c static double now_seconds(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return ts.tv_sec + ts.tv_nsec * 1e-9; } ``` engine_term_display: ```c static void engine_term_display(struct engine* e) { if (e->display != EGL_NO_DISPLAY) { eglMakeCurrent(e->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); if (e->context != EGL_NO_CONTEXT) eglDestroyContext(e->display, e->context); if (e->surface != EGL_NO_SURFACE) eglDestroySurface(e->display, e->surface); eglTerminate(e->display); } e->animating = 0; e->display = EGL_NO_DISPLAY; e->context = EGL_NO_CONTEXT; e->surface = EGL_NO_SURFACE; } ``` **Build files:** Option A: ndk-build with Android.mk: ```makefile LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := nativeapp LOCAL_SRC_FILES := main.c LOCAL_LDLIBS := -lEGL -lGLESv2 -llog -landroid LOCAL_STATIC_LIBRARIES := android_native_app_glue include $(BUILD_SHARED_LIBRARY) $(call import-module, android/native_app_glue) ``` Application.mk: ```makefile APP_ABI := arm64-v8a armeabi-v7a x86_64 APP_PLATFORM := android-21 APP_STL := none ``` Actually APP_STL := none works for pure C. Or c++_static. Pure C doesn't need STL. `APP_STL := none` is fine. Option B: CMake. ndk-build is simpler for a pure-C NDK app and works out of the box with the classic NDK. But modern Android Studio favors CMake. Since the user probably wants command-line simplicity, I'll use ndk-build (Android.mk + Application.mk). The old NDK includes native_app_glue module. Newer NDKs (r25+) still ship native_app_glue as a static lib importable via `$(call import-module,android/native_app_glue)`. Yes, NDK still ships sources/android/native_app_glue. Good. **Project layout:** ``` CApp/ ├── AndroidManifest.xml ├── jni/ │ ├── Android.mk │ ├── Application.mk │ └── main.c ``` With ndk-build, sources go under `jni/` by default. Then `ndk-build` produces libs/armeabi-v7a/libnativeapp.so etc. Then build APK with aapt etc. Building the APK manually requires aapt2, d8, apksigner, plus the android.jar and the native_app_glue... it's fiddly. Options: 1. Give manual commands with aapt + dx + apksigner (classic). 2. Suggest Android Studio with CMake. 3. Provide a build script. The classic manual build: ``` ndk-build aapt package -f -m -J gen -M AndroidManifest.xml -I $SDK/platforms/android-33/android.jar javac ... # NativeActivity is in framework, no Java code needed! aapt package -f -M AndroidManifest.xml -I android.jar -F unsigned.apk # add libs aapt add unsigned.apk lib/arm64-v8a/libnativeapp.so ... dx? no classes needed since hasCode=false zipalign apksigner sign ``` Since `android:hasCode="false"`, no dex needed! That simplifies manual building a lot: no javac/d8 step. Manual steps (classic tools): ```bash ndk-build # builds libs//libnativeapp.so aapt package -f -M AndroidManifest.xml -I "$PLATFORM/android.jar" -F app.unaligned.apk aapt add app.unaligned.apk lib/arm64-v8a/libnativeapp.so libs? ``` Wait — in APK, native libs go at `lib//libX.so` at APK root. ndk-build puts them in `libs//`. When adding to the APK with `aapt add`, path inside zip must be `lib/arm64-v8a/libnativeapp.so`. aapt add uses the path as given on the command line, so you need to run from a directory containing lib/... or use `aapt add` with correct relative paths. Common trick: `cd` isn't possible per-file; you can do: ```bash mkdir -p lib cp -r libs/* lib/ # hmm, ndk-build outputs to libs/ ``` Actually ndk-build output: `libs/arm64-v8a/libnativeapp.so`. APK needs `lib/arm64-v8a/libnativeapp.so`. So: ```bash cp -r libs lib aapt add app.unaligned.apk lib/arm64-v8a/libnativeapp.so ``` Then zipalign and apksigner: ```bash zipalign -f 4 app.unaligned.apk app.aligned.apk apksigner sign --ks my.keystore ... ``` Need a debug keystore: can generate with keytool: ```bash keytool -genkeypair -keystore debug.keystore -alias androiddebugkey -storepass android -keypass android -dname "CN=Android Debug,O=Android,C=US" -keyalg RSA -keysize 2048 -validity 10000 ``` apksigner sign --ks debug.keystore --ks-pass pass:android --key-pass pass:android --out CApp.apk app.aligned.apk Install: `adb install CApp.apk`. That's a complete manual pipeline. It requires build-tools (aapt, zipalign, apksigner) and platform android.jar in path... Actually for aapt package with -M only, we need -I android.jar to resolve resource references; with no resources it might still need it? `aapt package -f -M AndroidManifest.xml -F out.apk` — I believe -I is required even without resources? To be safe include -I. Hmm, one more wrinkle: targetSdkVersion in manifest and `adb install` on modern devices: fine. Also minSdkVersion 21? NativeActivity exists since API 9. Use 21+ to keep it simple with modern NDK (NDK r19+ default min is 21? APP_PLATFORM android-21 default since r27?). Set explicitly android-21 or 24. I'll use minSdk 21, target 34? targetSdkVersion 34 might require... hasCode=false apps still fine. Keep targetSdk 33 or 34; either installs. I'll put 34. Hmm, also on newer Android (API 29+), executables can't be run from app data, but we're building an APK with a shared library, so fine. Also note: Android 15 (API 35) enforces targetSdkVersion >= 24 for installs. So set minSdk 21, targetSdk 34 to be safe. Actually Android 15 requires targetSdk >= 24; target 34 is fine. Android 16 will require >= 31? Setting targetSdkVersion 34 is fine for now. Let me set target 34. Alternatively provide CMake route for Android Studio users. I'll mention it briefly. Also worth noting the alternative: keep it simple, recommend command-line: download "command line tools" + NDK + build-tools + platform. Let me also double check `android_native_app_glue` import in Application.mk / Android.mk with modern NDK: `$(call import-module,android/native_app_glue)` still exists in NDK r26/r27 (sources/android/native_app_glue). Yes, still shipped. In very new NDKs (r28?) — I believe it's still there; there were talks of deprecating ndk-build, but native_app_glue is still shipped. I'll note "any reasonably recent NDK". One more code check: In the input handler, for ACTION_MOVE, pointer index 0 gives the first changed pointer; to get all pointers use count and index. AMotionEvent_getX(event, 0) fine. Also handle AMOTION_EVENT_ACTION_UP? On up, do nothing (particles keep bouncing). Good. Also should I clear particles when display terminated? Not necessary. Let me also handle APP_CMD_RESUME/PAUSE for last_time reset to avoid dt spike — I clamp dt anyway. Also add a demo auto-spawner: every 1.5 seconds spawn a random burst so there's something on screen at start? Nice touch: spawn one burst at center on init. I'll spawn an initial burst when display initializes. And maybe periodic spawner while animating. Keep code short though. I'll add a small periodic spawn (every 2s, few particles from top with random x). Cute rain effect. Let me include it — small code addition: In engine_update, track spawn timer: ```c e->spawn_timer -= dt; if (e->spawn_timer <= 0) { e->spawn_timer = 1.5f; spawn_burst(e, rand() % e->width, -20, 6); } ``` Hmm y negative - spawn above screen top so they fall in. Since bounce at top only when vy<0... particle at y=-20 with vy positive falls in. But bounce top check: `if (p->y < p->radius && p->vy < 0)` — starting above top with positive vy passes. OK. Wait, gravity positive (down). Spawned above screen, they fall in. Good. Edge case: e->width could be 0 before init; guard animating && display ensures update runs only when display exists. Particle struct fields order fine. One concern: `while ((ident = ALooper_pollAll(e->animating ? 0 : -1, ...)) >= 0)` — with timeout 0, pollAll returns immediately with ident == ALOOPER_POLL_TIMEOUT? Actually ALooper_pollAll with timeout 0 returns -1 if no events? Let me recall: ALooper_pollAll returns ALOOPER_POLL_TIMEOUT (-3)? Hmm. ALooper_pollOnce/pollAll return: identifier >= 0 when event, or ALOOPER_POLL_WAKE (-1)? No... ALooper_pollAll returns: - ALOOPER_POLL_WAKE = -1: "The poll was awoken using wake() before any events" — hmm - ALOOPER_POLL_CALLBACK = -2 - ALOOPER_POLL_TIMEOUT = -3 - ALOOPER_POLL_ERROR = -4 So the loop `while ((ident = ALooper_pollAll(timeout, NULL, &events, &source)) >= 0)` — ALOOPER_POLL_WAKE is -1 which is < 0, so loop exits on wake too. With timeout 0 and no events, returns ALOOPER_POLL_TIMEOUT (-3) → loop exits → render. That's the canonical NDK sample logic (sample_native-activity uses exactly this). Good. Note: in the canonical sample, when not animating they block with -1, and it can starve? The sample does exactly this. Fine. Also `source->process(state, source)` handles input and app cmd callbacks. Good. Term: also on destroy, call engine_term_display. Good. **Shader detail check:** quad as triangle strip: (-1,-1),(1,-1),(-1,1),(1,1) — that's a strip forming the full square. v_local ranges in [-1,1] across it. length(v_local) > 1 near corners → alpha smoothstep(0.85,1.0,d) gives soft circle edge; corners: alpha = 0 since d≈1.41 > 1 → smoothstep clamps to 1 → alpha 0. Good. Clip transform: pos px in pixels, clip = px/res*2-1, y negated so pixel y=0 is top. Android window coordinates: origin top-left. So a particle at y=height appears at bottom. Good, gravity down means increasing y. **glGetAttribLocation** returns -1 if optimized out; a_pos is used. Fine. Also must call glUseProgram before setting uniforms per draw — I set program once after link (glUseProgram in init), uniforms set in draw each frame; program stays bound. OK. View resize: on APP_CMD_INIT_WINDOW only once; if window resized (orientation change) we'd get TERM/INIT again typically because configChanges? I declared configChanges orientation|keyboardHidden so orientation change won't restart activity; but NativeActivity surface will be destroyed/recreated → TERM_WINDOW/INIT_WINDOW events → reinit. Good. Note: when reinit happens we must rebuild everything since we destroyed. engine_term_display destroys context; init rebuilds program. Fine. But careful: eglQuerySurface width/height after resize — ok. Also ANativeWindow_setBuffersGeometry with 0,0,format keeps window size. Good. **AndroidManifest meta-data**: `android.app.lib_name` must equal module name `nativeapp`. Good. Package name: `com.example.capp`. For aapt package without resources, fine. Add `android:label="C App"`. Also for Android 14+ (targetSdk 34) — no special requirement for native activity. OK. Let me also provide the alternative "if you use Android Studio" section: set `externalNativeBuild` with ndk-build pointing at jni/Android.mk, add the manifest. Brief. Now — how much explanation? The user asked "make me android app in C". Provide: quick note that Android apps in C = NDK + NativeActivity, the file tree, all files, build instructions (command-line pipeline), install/run instructions, and short notes on what the app does and how to extend. Use code blocks with filenames as headers. Markdown appropriate since it's code-heavy. Length: This will be long by necessity (full working example). Keep prose tight. The code itself ~250 lines. That's acceptable for a "build me an app" request — they want working code. Let me finalize the C code carefully, double-checking all API signatures: - `#include ` provides `struct android_app`, `android_main`, `ALooper_pollAll` via android/looper.h included by glue. - Input callback signature: `int32_t on_input(struct android_app* app, AInputEvent* event)` — yes, `onInputEvent` field type is `int32_t (*)(struct android_app*, AInputEvent*)`. - Cmd callback: `void (*)(struct android_app*, int32_t)`. - `AMotionEvent_getAction(event)`, `AMOTION_EVENT_ACTION_DOWN`, etc. need `#include ` — the glue includes android/input.h? android_native_app_glue.h includes android/input.h I believe. It includes android/configuration.h, android/looper.h, android/native_activity.h, android/window.h... native_activity.h includes android/input.h? Actually android/native_activity.h includes... Let me be safe and include and explicitly. Including them is harmless. - `AInputEvent_getType(event)` returns AINPUT_EVENT_TYPE_MOTION for motion. - `AMotionEvent_getPointerCount(event)` — signature is `size_t AMotionEvent_getPointerCount(const AInputEvent*)`. fine. - rand() usage: `(float)rand() / RAND_MAX`. Full code: ```c // main.c — a tiny Android app written in pure C (NativeActivity + OpenGL ES 2) // // Touch the screen to throw colorful bouncing particles. #include #include #include #include #include #include #include #include #include #define LOGI(...) __android_log_print(ANDROID_LOG_INFO, "capp", __VA_ARGS__) #define MAX_PARTICLES 256 #define GRAVITY 1500.0f // px/s^2 typedef struct { float x, y; // position (pixels, origin top-left) float vx, vy; // velocity (px/s) float radius; // px float hue; // 0..1 float life; // total lifetime in s double born; // app-time of birth int alive; } Particle; typedef struct { android_app* app; // needs struct keyword: struct android_app* ... } ``` Careful: type is `struct android_app`. I'll write `struct android_app* app;`. Let me now write it in final form: ```c #include #include #include #include #include #include #include #include #include #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "capp", __VA_ARGS__)) #define MAX_PARTICLES 256 #define GRAVITY 1500.0f typedef struct { float x, y, vx, vy; float radius, hue, life; double born; int alive; } Particle; typedef struct { struct android_app* app; EGLDisplay display; EGLSurface surface; EGLContext context; int32_t width, height; GLuint program; GLint a_pos; GLint u_res, u_center, u_radius, u_color, u_alpha; Particle particles[MAX_PARTICLES]; double last_time; float next_hue; float spawn_timer; int animating; } Engine; static Engine g_engine; static double now_s(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return (double)ts.tv_sec + (double)ts.tv_nsec * 1e-9; } static float frand(float lo, float hi) { return lo + (hi - lo) * ((float)rand() / RAND_MAX); } /* ---- shaders ---------------------------------------------------------- */ static const char VERT_SRC[] = "attribute vec2 a_pos;\n" "uniform vec2 u_res;\n" "uniform vec2 u_center;\n" "uniform float u_radius;\n" "varying vec2 v_local;\n" "void main() {\n" " v_local = a_pos;\n" " vec2 clip = (u_center + a_pos * u_radius) / u_res * 2.0 - 1.0;\n" " gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);\n" "}\n"; static const char FRAG_SRC[] = "precision mediump float;\n" "varying vec2 v_local;\n" "uniform vec3 u_color;\n" "uniform float u_alpha;\n" "void main() {\n" " float d = length(v_local);\n" " float edge = 1.0 - smoothstep(0.8, 1.0, d);\n" " gl_FragColor = vec4(u_color, edge * u_alpha);\n" "}\n"; static GLuint compile(GLenum type, const char* src) { GLuint sh = glCreateShader(type); glShaderSource(sh, 1, &src, NULL); glCompileShader(sh); GLint ok = GL_FALSE; glGetShaderiv(sh, GL_COMPILE_STATUS, &ok); if (!ok) { char log[512]; glGetShaderInfoLog(sh, sizeof log, NULL, log); LOGI("shader compile failed: %s", log); } return sh; } ``` hue_to_rgb, spawn, update, draw, init_display, term_display, input, cmd, android_main. Init display details — full EGL error checking lightly. Write it. Spawn burst: ```c static void spawn(Engine* e, float x, float y, int n) { for (int i = 0; i < n; i++) { Particle* p = NULL; for (int j = 0; j < MAX_PARTICLES; j++) if (!e->particles[j].alive) { p = &e->particles[j]; break; } if (!p) return; // pool full float ang = frand(0, 2 * (float)M_PI); float spd = frand(150, 650); p->x = x; p->y = y; p->vx = cosf(ang) * spd; p->vy = sinf(ang) * spd; p->radius = frand(8, 28); p->hue = e->next_hue; e->next_hue = fmodf(e->next_hue + 0.13f, 1.0f); p->life = frand(2.5f, 4.5f); p->born = now_s(); p->alive = 1; } } ``` Update: ```c static void update(Engine* e, float dt) { // occasional automatic shower so the screen is never empty e->spawn_timer -= dt; if (e->spawn_timer <= 0) { e->spawn_timer = 2.0f; spawn(e, frand(0, (float)e->width), -30, 5); } for (int i = 0; i < MAX_PARTICLES; i++) { Particle* p = &e->particles[i]; if (!p->alive) continue; p->vy += GRAVITY * dt; p->x += p->vx * dt; p->y += p->vy * dt; if (p->x < p->radius) { p->x = p->radius; p->vx = -p->vx * 0.8f; } if (p->x > e->width - p->radius) { p->x = e->width - p->radius; p->vx = -p->vx * 0.8f; } if (p->y > e->height - p->radius){ p->y = e->height - p->radius; p->vy = -p->vy * 0.8f; } else if (p->y < p->radius && p->vy < 0) { p->y = p->radius; p->vy = -p->vy * 0.8f; } } } ``` Draw: ```c static void draw(Engine* e) { double t = now_s(); glViewport(0, 0, e->width, e->height); glClearColor(0.05f, 0.06f, 0.09f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); static const float quad[8] = { -1,-1, 1,-1, -1,1, 1,1 }; glVertexAttribPointer(e->a_pos, 2, GL_FLOAT, GL_FALSE, 0, quad); glEnableVertexAttribArray(e->a_pos); glUniform2f(e->u_res, (float)e->width, (float)e->height); for (int i = 0; i < MAX_PARTICLES; i++) { Particle* p = &e->particles[i]; if (!p->alive) continue; float age = (float)(t - p->born); if (age >= p->life) { p->alive = 0; continue; } float r, g, b; hue_rgb(p->hue, &r, &g, &b); glUniform2f(e->u_center, p->x, p->y); glUniform1f(e->u_radius, p->radius); glUniform3f(e->u_color, r, g, b); glUniform1f(e->u_alpha, 1.0f - age / p->life); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } eglSwapBuffers(e->display, e->surface); } ``` hue_rgb: ```c static void hue_rgb(float h, float* r, float* g, float* b) { float f = h * 6.0f; int i = (int)f % 6; float x = f - (int)f; switch (i) { case 0: *r = 1; *g = x; *b = 0; break; case 1: *r = 1 - x; *g = 1; *b = 0; break; case 2: *r = 0; *g = 1; *b = x; break; case 3: *r = 0; *g = 1 - x; *b = 1; break; case 4: *r = x; *g = 0; *b = 1; break; default: *r = 1; *g = 0; *b = 1 - x; break; } } ``` init_display: ```c static int init_display(Engine* e) { const EGLint cfg_attrs[] = { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_NONE }; const EGLint ctx_attrs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); eglInitialize(dpy, NULL, NULL); EGLConfig cfg; EGLint n = 0; eglChooseConfig(dpy, cfg_attrs, &cfg, 1, &n); EGLint format; eglGetConfigAttrib(dpy, cfg, EGL_NATIVE_VISUAL_ID, &format); ANativeWindow_setBuffersGeometry(e->app->window, 0, 0, format); e->surface = eglCreateWindowSurface(dpy, cfg, e->app->window, NULL); e->context = eglCreateContext(dpy, cfg, NULL, ctx_attrs); if (eglMakeCurrent(dpy, e->surface, e->surface, e->context) == EGL_FALSE) { LOGI("eglMakeCurrent failed"); return -1; } e->display = dpy; eglQuerySurface(dpy, e->surface, EGL_WIDTH, &e->width); eglQuerySurface(dpy, e->surface, EGL_HEIGHT, &e->height); GLuint vs = compile(GL_VERTEX_SHADER, VERT_SRC); GLuint fs = compile(GL_FRAGMENT_SHADER, FRAG_SRC); e->program = glCreateProgram(); glAttachShader(e->program, vs); glAttachShader(e->program, fs); glLinkProgram(e->program); glUseProgram(e->program); e->a_pos = glGetAttribLocation(e->program, "a_pos"); e->u_res = glGetUniformLocation(e->program, "u_res"); e->u_center = glGetUniformLocation(e->program, "u_center"); e->u_radius = glGetUniformLocation(e->program, "u_radius"); e->u_color = glGetUniformLocation(e->program, "u_color"); e->u_alpha = glGetUniformLocation(e->program, "u_alpha"); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); e->last_time = now_s(); spawn(e, e->width / 2.0f, e->height / 3.0f, 15); // hello burst LOGI("display ready: %dx%d", e->width, e->height); return 0; } ``` term_display: ```c static void term_display(Engine* e) { if (e->display != EGL_NO_DISPLAY) { eglMakeCurrent(e->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); if (e->context != EGL_NO_CONTEXT) eglDestroyContext(e->display, e->context); if (e->surface != EGL_NO_SURFACE) eglDestroySurface(e->display, e->surface); eglTerminate(e->display); } e->animating = 0; e->display = EGL_NO_DISPLAY; e->context = EGL_NO_CONTEXT; e->surface = EGL_NO_SURFACE; } ``` Input: ```c static int32_t on_input(struct android_app* app, AInputEvent* event) { Engine* e = (Engine*)app->userData; if (AInputEvent_getType(event) != AINPUT_EVENT_TYPE_MOTION) return 0; int32_t action = AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_MASK; if (action == AMOTION_EVENT_ACTION_DOWN) { spawn(e, AMotionEvent_getX(event, 0), AMotionEvent_getY(event, 0), 12); } else if (action == AMOTION_EVENT_ACTION_MOVE) { size_t n = AMotionEvent_getPointerCount(event); for (size_t i = 0; i < n; i++) spawn(e, AMotionEvent_getX(event, i), AMotionEvent_getY(event, i), 1); } return 1; } ``` spawn signature takes int n — pass 1 for move. Good. Cmd: ```c static void on_cmd(struct android_app* app, int32_t cmd) { Engine* e = (Engine*)app->userData; switch (cmd) { case APP_CMD_INIT_WINDOW: if (app->window) init_display(e); break; case APP_CMD_TERM_WINDOW: term_display(e); break; case APP_CMD_GAINED_FOCUS: e->animating = 1; break; case APP_CMD_LOST_FOCUS: e->animating = 0; break; } } ``` android_main: ```c void android_main(struct android_app* state) { Engine* e = &g_engine; memset(e, 0, sizeof *e); e->app = state; state->userData = e; state->onAppCmd = on_cmd; state->onInputEvent = on_input; srand((unsigned)time(NULL)); for (;;) { int ident, events; struct android_poll_source* source; while ((ident = ALooper_pollAll(e->animating ? 0 : -1, NULL, &events, (void**)&source)) >= 0) { if (source != NULL) source->process(state, source); if (state->destroyRequested != 0) { term_display(e); return; } } if (e->animating && e->display != EGL_NO_DISPLAY) { double now = now_s(); float dt = (float)(now - e->last_time); e->last_time = now; if (dt > 0.05f) dt = 0.05f; // don't explode after pauses update(e, dt); draw(e); } } } ``` Unused var ident warning? ident used in loop condition only — fine, no warning since it's assigned and compared. Actually `(void)ident` not needed; `ident` is used in `>= 0` comparison. OK. M_PI with `-std=?` — ndk-build defaults to a gnu dialect where M_PI is defined in math.h. Default NDK uses clang with default std (gnu17?). M_PI available. To be extra safe define fallback: ```c #ifndef M_PI #define M_PI 3.14159265358979f #endif ``` Cheap insurance. Include. **Android.mk:** ```makefile LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := nativeapp LOCAL_SRC_FILES := main.c LOCAL_LDLIBS := -llog -landroid -lEGL -lGLESv2 LOCAL_STATIC_LIBRARIES := android_native_app_glue include $(BUILD_SHARED_LIBRARY) $(call import-module,android/native_app_glue) ``` **Application.mk:** ```makefile APP_ABI := arm64-v8a armeabi-v7a x86_64 APP_PLATFORM := android-21 APP_STL := none ``` **AndroidManifest.xml:** as above with package com.example.capp, targetSdk 34, minSdk 21. Also `android:hardwareAccelerated` irrelevant for native. `android:hasCode="false"` required-ish (tells system no Java classes; without it, install may still work but ART may complain about missing classes.dex — with hasCode=false it's clean). **Build instructions:** Prereqs: Android SDK (platform + build-tools), NDK. Then: ```bash cd CApp ndk-build ``` APK assembly script: ```bash SDK=/path/to/sdk BT=$SDK/build-tools/34.0.0 PLAT=$SDK/platforms/android-34/android.jar # 1. package resources + manifest $BT/aapt package -f -M AndroidManifest.xml -I $PLAT -F app.unsigned.apk # 2. add native libraries (APK expects them under lib//) cp -r libs lib $BT/aapt add app.unsigned.apk lib/arm64-v8a/libnativeapp.so \ lib/armeabi-v7a/libnativeapp.so lib/x86_64/libnativeapp.so # 3. align $BT/zipalign -f 4 app.unsigned.apk app.aligned.apk # 4. sign (create a debug keystore once) keytool -genkeypair -keystore debug.keystore -alias app -storepass android \ -keypass android -dname "CN=capp" -keyalg RSA -validity 10000 $BT/apksigner sign --ks debug.keystore --ks-pass pass:android \ --key-pass pass:android --out capp.apk app.aligned.apk # 5. install & run adb install capp.apk ``` Hmm — the `lib` directory copy: ndk-build puts results in `libs//`. APK needs `lib/`. So `cp -r libs lib`. Right. Note: for targetSdk 34, installing an APK where lib/ entries are stored — need stored or deflated? Modern APKs: `android:extractNativeLibs` default changed in AGP; aapt packaging keeps them compressed which is fine since manifest doesn't set extractNativeLibs=false. Default extractNativeLibs=true pre-AGP behavior; our hand-made manifest doesn't set it → default true → system extracts → fine with compressed entries. OK. zipalign before signing with apksigner — correct order (apksigner after align; v2 signing preserves alignment). Also mention: if you don't want the manual APK dance, easiest alternative is Android Studio: - Create "Native C++" project, replace its main.cpp with this main.c (and CMake target language C), manifest meta-data lib name matching, done. I can mention briefly. Actually, let me double check manifest `` and NativeActivity activity declaration — that's exactly the pattern in NDK docs. Also `android:exported="true"` needed for API 31+ when intent-filter present! Important: apps targeting Android 12+ must declare android:exported on components with intent filters. Since targetSdk 34, must add `android:exported="true"` to the activity. Otherwise install fails? Parsing fails on install. Yes — must include. Add it. Full manifest: ```xml

``` Good. Also a note: The app auto-runs particles; touch spawns bursts. Also mention where logs go: `adb logcat -s capp`. Should I include the alternative CMake build? Brief mention. Keep response focused. One more consideration: `APP_STL := none` — with pure C this is fine. native_app_glue is C. Good. Also NDK r27 renamed some things? ndk-build still supported. OK. Potential pitfall: `ALooper_pollAll` deprecated in NDK 26+? There were deprecation warnings for ALooper_pollAll in newer NDK (r26 deprecated ALooper_pollOnce/All? Actually NDK r26 marked ALooper_pollAll as deprecated? Let me think. In NDK r26, `ALooper_pollOnce` and `ALooper_pollAll` were NOT deprecated; `ALooper_prepare` isn't either. Hmm, there was a doc note that ALooper_pollAll is "pending deprecation"? I recall in 2023 NDK r26 deprecated ALooper_pollAll? Not that I can verify... The glue code itself uses ALooper internally. There IS a known deprecation: NDK r26 changelog: "ALooper_pollAll is deprecated" — I genuinely can't recall this. Let me not worry; it compiles fine regardless, maybe with a warning. The official NDK sample (native-activity) still uses it. Also note newer NDK native_app_glue: `app_dummy()` removed — I won't call it. One subtle thing: in `on_input`, cast `size_t n = AMotionEvent_getPointerCount(event);` then loop `for (size_t i = 0; i < n; i++)` — fine. `AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_MASK` — need `#include ` (pulls motion event constants). android_native_app_glue.h includes android/input.h? It includes which includes ? Actually native_activity.h includes android/input.h? Hmm, native_activity.h declares callbacks with AInputEvent and includes ? I think android/native_activity.h does include — but explicit include is harmless and safer. Keep explicit. Also `struct android_poll_source` — defined in glue header. `source->process` — field `void (*process)(struct android_app* app, struct android_poll_source* source);` yes. Check the glue's android_main signature: `void android_main(struct android_app* state)`. Yes. Now write final answer. Format: - Brief intro: pure-C Android apps run via NDK's NativeActivity — no Java needed. Describe the app: particles. - Project structure tree - 4 files in code blocks: AndroidManifest.xml, jni/Android.mk, jni/Application.mk, jni/main.c - Build & run steps (commands) - Notes: requirements (NDK, SDK, adb), how it works briefly (glue, EGL, GLES2), tweak ideas. Keep prose minimal; code is the bulk. Headers for sections. This is appropriate per formatting guidance: markdown, code blocks with language tags (c, xml, makefile, bash). Let me make sure the build steps are correct and minimal. Also mention that they need `ANDROID_NDK_HOME` or just have ndk-build on PATH. Potential user confusion: `aapt` vs `aapt2`. build-tools ship both; aapt classic works for this. Also: modern Android may warn "targetSdk 34"? fine. Also older devices: armeabi-v7a + arm64 covers most; x86_64 for emulator. Good. Edge: `keytool` comes with a JDK; note that. I think adding a one-line note that "hello world in C is basically this boilerplate; the fun part is main.c" is nice. Write the final response now. Double-check C code compiles logically (mentally): - Engine struct: has `struct android_app* app;` fine. - frand, now_s, hue_rgb, compile, spawn, update, draw, init_display, term_display, on_input, on_cmd, android_main — all declared before use if ordered properly. Order: includes, defines, types, globals, now_s, frand, hue_rgb, shaders, compile, spawn, update, draw, init_display, term_display, on_input, on_cmd, android_main. `draw` uses hue_rgb, compile etc. — defined before. `init_display` uses spawn — defined before? spawn defined before init_display: yes if I order: spawn, update, draw, init_display... update uses spawn: yes. draw uses e->display. on_input uses spawn. on_cmd uses init/term. android_main uses all. Good — define in that order. - In draw(): `static const float quad[8]` — passing `quad` as `const void*` to glVertexAttribPointer — signature takes `const GLvoid*`; passing float array fine. Cast? glVertexAttribPointer(index, size, type, normalized, stride, pointer) — passing `quad` decays to `const float*`; implicit conversion to const void* — in C this is fine (any object pointer to void*). Yes fine in C. - eglInitialize(dpy, NULL, NULL) — signature: eglInitialize(EGLDisplay, EGLint *major, EGLint *minor) — passing NULL ok. - ANativeWindow_setBuffersGeometry — declared in android/native_window.h; included via glue? android_native_app_glue.h includes ? It includes android/native_activity.h which includes android/native_window.h? Hmm. To be safe, add `#include `. Harmless. - LOGI format with %d for int32_t — int32_t is int; %d fine. - In android_main: `(void**)&source` cast needed for ALooper_pollAll's `void** data`. Yes glue sample does `(void**)&source`. - destroyRequested check inside poll loop. Good. One more: after APP_CMD_TERM_WINDOW, e->animating set 0 in term_display; draw guarded by display != NO_DISPLAY. Good. Also when app paused (LOST_FOCUS) we set animating 0 → poll blocks at -1 → wakes on events. Standard. Also initial state: animating 0; after INIT_WINDOW we spawn burst; animating becomes 1 on GAINED_FOCUS which occurs at startup. Good. dt clamp 0.05 vs earlier 0.1 — 0.05 fine (20fps min dt; at 60fps dt≈0.016). Gravity 1500 px/s² and speeds up to 650 px/s — reasonable. Spawn shower at y=-30: radius up to 28 — particle center above screen, partially visible initially. fine. Bounce top condition `else if (p->y < p->radius && p->vy < 0)` — spawned with y=-30, vy from sin(ang) could be negative (moving up) — then immediately p->y (-30) < p->radius and vy<0 → snapped to y=radius, vy negated (downward). Slight teleport but fine, invisible mostly. Or set spawn y to 40. Eh, spawn shower at y = -30 with vy possibly negative → snap. Acceptable; or simpler: spawn at random y in top area? Keep -30; harmless. Actually wait: update runs for the shower spawn before physics in same frame: spawn sets y=-30; update loop then processes it: if vy<0 → snap to radius and bounce. Fine. MAX_PARTICLES 256; move events spawn 1/pointer/event (~60/s per finger) with life ~3.5s → ~210 alive per finger. Cap hits; pool exhaustion returns silently — fine. Now the Application.mk `APP_STL := none`: pure C — OK. But native_app_glue is C — OK. Some NDK versions warn if APP_STL none? It's allowed. Alternatively `c++_static` safer if glue ever needs it — glue is C, fine with none. Android.mk LOCAL_LDLIBS: -llog (logging), -landroid (ANativeWindow, AInputEvent? input is in -landroid), -lEGL, -lGLESv2. native_app_glue static lib needs android lib too — linking order: LOCAL_STATIC_LIBRARIES before LDLIBS, fine as sample does exactly this. Build steps: mention versions tested: "any recent NDK (r19+)". Alternative quick path for people with Android Studio: File > New Project > "Native C++", swap code. I'll add 2-3 lines. Now, response length: it's a code-heavy request; the full listing is necessary. I'll keep explanations tight. Add a short "How it works" bullet list (3-4 bullets). And "What you can change" maybe 3 bullets. Keep it lean. Let me also double check aapt add path requirement: when running `$BT/aapt add app.unsigned.apk lib/arm64-v8a/libnativeapp.so` from project root where `lib/` exists — it stores entry as `lib/arm64-v8a/libnativeapp.so`. Yes, aapt add stores the file at the given path. Good. But note: we created `lib` copy from `libs`. And add `lib/x86_64/...` too. If some ABI missing, adjust. I'll write the command for all three and note to adjust. Alternatively use `-A`? aapt package has `-A dir` to add assets dir (stored under assets/), not libs. So cp approach stands. Also might mention `zipalign -f 4` then sign. Some prefer `zipalign -P 16` for uncompressed .so with 16KB page alignment on newer devices — with compressed .so not needed. Keep simple. keytool note: included in JDK; also in Android Studio JBR. Fine. Alright, compose the answer. Structure: 1. One-liner: Yes — via Android NDK + NativeActivity, app can be 100% C. Here's a complete working app (touch → colorful bouncing particles). 2. Project layout tree. 3. Files (4 code blocks). 4. Build & install (bash block + keystore). 5. Notes: how it works, log command, tweak pointers. Keep each section short. Use headers maybe: `### 1. Project layout` etc. or just bold lines. Headers fine. Final check of main.c listing for syntax errors — I'll write carefully. Also: `#include ` for ANativeWindow_setBuffersGeometry. Write out: ```c /* main.c — pure-C Android app: NativeActivity + EGL + OpenGL ES 2. * Touch the screen to throw colorful particles that bounce under gravity. */ #include #include #include #include #include #include #include #include #include #include #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "capp", __VA_ARGS__)) #define MAX_PARTICLES 256 #define GRAVITY 1500.0f #ifndef M_PI #define M_PI 3.14159265358979f #endif typedef struct { float x, y; /* pixels, origin = top-left */ float vx, vy; /* px/s */ float radius; /* px */ float hue; /* 0..1 */ float life; /* seconds until it dies */ double born; /* birth time (monotonic clock, s) */ int alive; } Particle; typedef struct { struct android_app* app; EGLDisplay display; EGLSurface surface; EGLContext context; int32_t width, height; GLuint program; GLint a_pos, u_res, u_center, u_radius, u_color, u_alpha; Particle particles[MAX_PARTICLES]; double last_time; float next_hue; float spawn_timer; int animating; } Engine; static Engine g_engine; ``` then helpers... good. Everything consistent. Also in init_display after link, maybe check link status — optional; add minimal check like shader. I'll add a small check for link too (cheap). Add: ```c GLint ok = GL_FALSE; glGetProgramiv(e->program, GL_LINK_STATUS, &ok); if (!ok) LOGI("program link failed"); ``` Fine. Write final answer now. Also add a note: no Java/dex needed because hasCode=false and NativeActivity is provided by the framework. One thing: `aapt package -f -M AndroidManifest.xml -I $PLAT -F out.apk` — does it require res dir? No, optional. Good. Also, users on Windows: mention commands are bash; concept same. One line. I think the response is ready. Aim: comprehensive but not bloated; the code dominates. Yes — it's possible! Android apps written **entirely in C** run through the [Android NDK](https://developer.android.com/ndk)'s `NativeActivity` (no Java/Kotlin code at all). Below is a complete, working app: **touch the screen to throw colorful particles** that bounce around under gravity, rendered with OpenGL ES 2. ### Project layout ``` CApp/ ├── AndroidManifest.xml └── jni/ ├── Android.mk ├── Application.mk └── main.c ``` ### `AndroidManifest.xml` ```xml

``` ### `jni/Android.mk` ```makefile LOCAL_PATH := $(call my-dir) include $(CLEAR_VARS) LOCAL_MODULE := nativeapp LOCAL_SRC_FILES := main.c LOCAL_LDLIBS := -llog -landroid -lEGL -lGLESv2 LOCAL_STATIC_LIBRARIES := android_native_app_glue include $(BUILD_SHARED_LIBRARY) $(call import-module,android/native_app_glue) ``` ### `jni/Application.mk` ```makefile APP_ABI := arm64-v8a armeabi-v7a x86_64 APP_PLATFORM := android-21 APP_STL := none ``` ### `jni/main.c` ```c /* main.c — pure-C Android app: NativeActivity + EGL + OpenGL ES 2. * Touch the screen to throw colorful particles that bounce under gravity. */ #include #include #include #include #include #include #include #include #include #include #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "capp", __VA_ARGS__)) #define MAX_PARTICLES 256 #define GRAVITY 1500.0f #ifndef M_PI #define M_PI 3.14159265358979f #endif typedef struct { float x, y; /* pixels, origin = top-left */ float vx, vy; /* px/s */ float radius; /* px */ float hue; /* 0..1 */ float life; /* seconds until it dies */ double born; /* birth time (monotonic clock, s) */ int alive; } Particle; typedef struct { struct android_app* app; EGLDisplay display; EGLSurface surface; EGLContext context; int32_t width, height; GLuint program; GLint a_pos, u_res, u_center, u_radius, u_color, u_alpha; Particle particles[MAX_PARTICLES]; double last_time; float next_hue; float spawn_timer; int animating; } Engine; static Engine g_engine; static double now_s(void) { struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts); return (double)ts.tv_sec + (double)ts.tv_nsec * 1e-9; } static float frand(float lo, float hi) { return lo + (hi - lo) * ((float)rand() / RAND_MAX); } static void hue_rgb(float h, float* r, float* g, float* b) { float f = h * 6.0f; int i = (int)f % 6; float x = f - (int)f; switch (i) { case 0: *r = 1; *g = x; *b = 0; break; case 1: *r = 1 - x; *g = 1; *b = 0; break; case 2: *r = 0; *g = 1; *b = x; break; case 3: *r = 0; *g = 1 - x; *b = 1; break; case 4: *r = x; *g = 0; *b = 1; break; default: *r = 1; *g = 0; *b = 1 - x; break; } } /* ---- shaders --------------------------------------------------------- */ static const char VERT_SRC[] = "attribute vec2 a_pos;\n" "uniform vec2 u_res;\n" "uniform vec2 u_center;\n" "uniform float u_radius;\n" "varying vec2 v_local;\n" "void main() {\n" " v_local = a_pos;\n" " vec2 clip = (u_center + a_pos * u_radius) / u_res * 2.0 - 1.0;\n" " gl_Position = vec4(clip.x, -clip.y, 0.0, 1.0);\n" "}\n"; static const char FRAG_SRC[] = "precision mediump float;\n" "varying vec2 v_local;\n" "uniform vec3 u_color;\n" "uniform float u_alpha;\n" "void main() {\n" " float d = length(v_local);\n" " float edge = 1.0 - smoothstep(0.8, 1.0, d);\n" " gl_FragColor = vec4(u_color, edge * u_alpha);\n" "}\n"; static GLuint compile(GLenum type, const char* src) { GLuint sh = glCreateShader(type); glShaderSource(sh, 1, &src, NULL); glCompileShader(sh); GLint ok = GL_FALSE; glGetShaderiv(sh, GL_COMPILE_STATUS, &ok); if (!ok) { char log[512]; glGetShaderInfoLog(sh, sizeof log, NULL, log); LOGI("shader compile failed: %s", log); } return sh; } /* ---- simulation ------------------------------------------------------ */ static void spawn(Engine* e, float x, float y, int n) { for (int i = 0; i < n; i++) { Particle* p = NULL; for (int j = 0; j < MAX_PARTICLES; j++) if (!e->particles[j].alive) { p = &e->particles[j]; break; } if (!p) return; /* pool full */ float ang = frand(0.0f, 2.0f * (float)M_PI); float spd = frand(150.0f, 650.0f); p->x = x; p->y = y; p->vx = cosf(ang) * spd; p->vy = sinf(ang) * spd; p->radius = frand(8.0f, 28.0f); p->hue = e->next_hue; e->next_hue = fmodf(e->next_hue + 0.13f, 1.0f); p->life = frand(2.5f, 4.5f); p->born = now_s(); p->alive = 1; } } static void update(Engine* e, float dt) { /* occasional automatic shower so the screen is never empty */ e->spawn_timer -= dt; if (e->spawn_timer <= 0.0f) { e->spawn_timer = 2.0f; spawn(e, frand(0.0f, (float)e->width), -30.0f, 5); } for (int i = 0; i < MAX_PARTICLES; i++) { Particle* p = &e->particles[i]; if (!p->alive) continue; p->vy += GRAVITY * dt; p->x += p->vx * dt; p->y += p->vy * dt; if (p->x < p->radius) { p->x = p->radius; p->vx = -p->vx * 0.8f; } if (p->x > e->width - p->radius) { p->x = e->width - p->radius; p->vx = -p->vx * 0.8f; } if (p->y > e->height - p->radius) { p->y = e->height - p->radius; p->vy = -p->vy * 0.8f; } else if (p->y < p->radius && p->vy < 0.0f) { p->y = p->radius; p->vy = -p->vy * 0.8f; } } } static void draw(Engine* e) { double t = now_s(); glViewport(0, 0, e->width, e->height); glClearColor(0.05f, 0.06f, 0.09f, 1.0f); glClear(GL_COLOR_BUFFER_BIT); static const float quad[8] = { -1,-1, 1,-1, -1,1, 1,1 }; glVertexAttribPointer(e->a_pos, 2, GL_FLOAT, GL_FALSE, 0, quad); glEnableVertexAttribArray(e->a_pos); glUniform2f(e->u_res, (float)e->width, (float)e->height); for (int i = 0; i < MAX_PARTICLES; i++) { Particle* p = &e->particles[i]; if (!p->alive) continue; float age = (float)(t - p->born); if (age >= p->life) { p->alive = 0; continue; } float r, g, b; hue_rgb(p->hue, &r, &g, &b); glUniform2f(e->u_center, p->x, p->y); glUniform1f(e->u_radius, p->radius); glUniform3f(e->u_color, r, g, b); glUniform1f(e->u_alpha, 1.0f - age / p->life); glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); } eglSwapBuffers(e->display, e->surface); } /* ---- EGL / lifecycle ------------------------------------------------- */ static int init_display(Engine* e) { const EGLint cfg_attrs[] = { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_RED_SIZE, 8, EGL_GREEN_SIZE, 8, EGL_BLUE_SIZE, 8, EGL_NONE }; const EGLint ctx_attrs[] = { EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE }; EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY); eglInitialize(dpy, NULL, NULL); EGLConfig cfg; EGLint n = 0; eglChooseConfig(dpy, cfg_attrs, &cfg, 1, &n); EGLint format; eglGetConfigAttrib(dpy, cfg, EGL_NATIVE_VISUAL_ID, &format); ANativeWindow_setBuffersGeometry(e->app->window, 0, 0, format); e->surface = eglCreateWindowSurface(dpy, cfg, e->app->window, NULL); e->context = eglCreateContext(dpy, cfg, NULL, ctx_attrs); if (eglMakeCurrent(dpy, e->surface, e->surface, e->context) == EGL_FALSE) { LOGI("eglMakeCurrent failed"); return -1; } e->display = dpy; eglQuerySurface(dpy, e->surface, EGL_WIDTH, &e->width); eglQuerySurface(dpy, e->surface, EGL_HEIGHT, &e->height); GLuint vs = compile(GL_VERTEX_SHADER, VERT_SRC); GLuint fs = compile(GL_FRAGMENT_SHADER, FRAG_SRC); e->program = glCreateProgram(); glAttachShader(e->program, vs); glAttachShader(e->program, fs); glLinkProgram(e->program); glUseProgram(e->program); GLint ok = GL_FALSE; glGetProgramiv(e->program, GL_LINK_STATUS, &ok); if (!ok) LOGI("program link failed"); e->a_pos = glGetAttribLocation(e->program, "a_pos"); e->u_res = glGetUniformLocation(e->program, "u_res"); e->u_center= glGetUniformLocation(e->program, "u_center"); e->u_radius= glGetUniformLocation(e->program, "u_radius"); e->u_color = glGetUniformLocation(e->program, "u_color"); e->u_alpha = glGetUniformLocation(e->program, "u_alpha"); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); e->last_time = now_s(); spawn(e, e->width / 2.0f, e->height / 3.0f, 15); /* hello burst */ LOGI("display ready: %dx%d", e->width, e->height); return 0; } static void term_display(Engine* e) { if (e->display != EGL_NO_DISPLAY) { eglMakeCurrent(e->display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT); if (e->context != EGL_NO_CONTEXT) eglDestroyContext(e->display, e->context); if (e->surface != EGL_NO_SURFACE) eglDestroySurface(e->display, e->surface); eglTerminate(e->display); } e->animating = 0; e->display = EGL_NO_DISPLAY; e->context = EGL_NO_CONTEXT; e->surface = EGL_NO_SURFACE; } static int32_t on_input(struct android_app* app, AInputEvent* event) { Engine* e = (Engine*)app->userData; if (AInputEvent_getType(event) != AINPUT_EVENT_TYPE_MOTION) return 0; int32_t action = AMotionEvent_getAction(event) & AMOTION_EVENT_ACTION_MASK; if (action == AMOTION_EVENT_ACTION_DOWN) { spawn(e, AMotionEvent_getX(event, 0), AMotionEvent_getY(event, 0), 12); } else if (action == AMOTION_EVENT_ACTION_MOVE) { size_t count = AMotionEvent_getPointerCount(event); for (size_t i = 0; i < count; i++) spawn(e, AMotionEvent_getX(event, i), AMotionEvent_getY(event, i), 1); } return 1; } static void on_cmd(struct android_app* app, int32_t cmd) { Engine* e = (Engine*)app->userData; switch (cmd) { case APP_CMD_INIT_WINDOW: if (app->window) init_display(e); break; case APP_CMD_TERM_WINDOW: term_display(e); break; case APP_CMD_GAINED_FOCUS: e->animating = 1; break; case APP_CMD_LOST_FOCUS: e->animating = 0; break; default: break; } } void android_main(struct android_app* state) { Engine* e = &g_engine; memset(e, 0, sizeof *e); e->app = state; state->userData = e; state->onAppCmd = on_cmd; state->onInputEvent = on_input; srand((unsigned)time(NULL)); for (;;) { int ident, events; struct android_poll_source* source; /* 0 = render continuously while animating, -1 = block otherwise */ while ((ident = ALooper_pollAll(e->animating ? 0 : -1, NULL, &events, (void**)&source)) >= 0) { if (source != NULL) source->process(state, source); if (state->destroyRequested != 0) { term_display(e); return; } } if (e->animating && e->display != EGL_NO_DISPLAY) { double now = now_s(); float dt = (float)(now - e->last_time); e->last_time = now; if (dt > 0.05f) dt = 0.05f; /* don't explode after pauses */ update(e, dt); draw(e); } } } ``` ### Build, sign, install You need the Android SDK (a platform + build-tools), the NDK, and `adb`. Then: ```bash cd CApp # 1. compile the C code (produces libs//libnativeapp.so) ndk-build # 2. package the APK (no dex needed — hasCode="false") BT=$ANDROID_HOME/build-tools/34.0.0 $BT/aapt package -f -M AndroidManifest.xml \ -I $ANDROID_HOME/platforms/android-34/android.jar \ -F app.unsigned.apk # 3. add native libs (APK expects them under lib//) cp -r libs lib $BT/aapt add app.unsigned.apk \ lib/arm64-v8a/libnativeapp.so \ lib/armeabi-v7a/libnativeapp.so \ lib/x86_64/libnativeapp.so # 4. align and sign (create a keystore once with keytool) $BT/zipalign -f 4 app.unsigned.apk app.aligned.apk keytool -genkeypair -keystore debug.keystore -alias app -storepass android \ -keypass android -dname "CN=capp" -keyalg RSA -validity 10000 $BT/apksigner sign --ks debug.keystore --ks-pass pass:android \ --key-pass pass:android --out capp.apk app.aligned.apk # 5. install and run adb install capp.apk ``` ### Notes - **How it works:** `android_main()` is your C entry point. The NDK's `native_app_glue` bridges you to the Android lifecycle; you set up EGL/OpenGL ES yourself and run a standard event loop. There's no Java anywhere (`android:hasCode="false"`). - **Logs:** run `adb logcat -s capp` to see `LOGI` output. - **Tweaks:** change `GRAVITY`, spawn counts, or the shaders — it's all in `main.c`. - If you prefer Android Studio instead of command-line building: create a **"Native C++"** project and drop this `main.c` in, setting the build to ndk-build with the `jni/` folder above (and keep the manifest's `lib_name` matching). The whole "app framework" boilerplate is ~120 lines; everything fun is in `main.c`. Want me to turn this into a specific kind of app (game, util, sensor viewer, etc.)?