1 /*
2 * Copyright (C) 2010 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #include "android_native_app_glue.h"
18
19 #include <jni.h>
20
21 #include <errno.h>
22 #include <stdlib.h>
23 #include <string.h>
24 #include <unistd.h>
25
26 #include <android/log.h>
27
28 #define LOGI(...) ((void)__android_log_print(ANDROID_LOG_INFO, "threaded_app", __VA_ARGS__))
29 #define LOGE(...) ((void)__android_log_print(ANDROID_LOG_ERROR, "threaded_app", __VA_ARGS__))
30
31 /* For debug builds, always enable the debug traces in this library */
32 #ifndef NDEBUG
33 # define LOGV(...) ((void)__android_log_print(ANDROID_LOG_VERBOSE, "threaded_app", __VA_ARGS__))
34 #else
35 # define LOGV(...) ((void)0)
36 #endif
37
free_saved_state(struct android_app * android_app)38 static void free_saved_state(struct android_app* android_app) {
39 pthread_mutex_lock(&android_app->mutex);
40 if (android_app->savedState != NULL) {
41 free(android_app->savedState);
42 android_app->savedState = NULL;
43 android_app->savedStateSize = 0;
44 }
45 pthread_mutex_unlock(&android_app->mutex);
46 }
47
android_app_read_cmd(struct android_app * android_app)48 int8_t android_app_read_cmd(struct android_app* android_app) {
49 int8_t cmd;
50 if (read(android_app->msgread, &cmd, sizeof(cmd)) != sizeof(cmd)) {
51 LOGE("No data on command pipe!");
52 return -1;
53 }
54 if (cmd == APP_CMD_SAVE_STATE) free_saved_state(android_app);
55 return cmd;
56 }
57
print_cur_config(struct android_app * android_app)58 static void print_cur_config(struct android_app* android_app) {
59 char lang[2], country[2];
60 AConfiguration_getLanguage(android_app->config, lang);
61 AConfiguration_getCountry(android_app->config, country);
62
63 LOGV("Config: mcc=%d mnc=%d lang=%c%c cnt=%c%c orien=%d touch=%d dens=%d "
64 "keys=%d nav=%d keysHid=%d navHid=%d sdk=%d size=%d long=%d "
65 "modetype=%d modenight=%d",
66 AConfiguration_getMcc(android_app->config),
67 AConfiguration_getMnc(android_app->config),
68 lang[0], lang[1], country[0], country[1],
69 AConfiguration_getOrientation(android_app->config),
70 AConfiguration_getTouchscreen(android_app->config),
71 AConfiguration_getDensity(android_app->config),
72 AConfiguration_getKeyboard(android_app->config),
73 AConfiguration_getNavigation(android_app->config),
74 AConfiguration_getKeysHidden(android_app->config),
75 AConfiguration_getNavHidden(android_app->config),
76 AConfiguration_getSdkVersion(android_app->config),
77 AConfiguration_getScreenSize(android_app->config),
78 AConfiguration_getScreenLong(android_app->config),
79 AConfiguration_getUiModeType(android_app->config),
80 AConfiguration_getUiModeNight(android_app->config));
81 }
82
android_app_pre_exec_cmd(struct android_app * android_app,int8_t cmd)83 void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd) {
84 switch (cmd) {
85 case APP_CMD_INPUT_CHANGED:
86 LOGV("APP_CMD_INPUT_CHANGED");
87 pthread_mutex_lock(&android_app->mutex);
88 if (android_app->inputQueue != NULL) {
89 AInputQueue_detachLooper(android_app->inputQueue);
90 }
91 android_app->inputQueue = android_app->pendingInputQueue;
92 if (android_app->inputQueue != NULL) {
93 LOGV("Attaching input queue to looper");
94 AInputQueue_attachLooper(android_app->inputQueue,
95 android_app->looper, LOOPER_ID_INPUT, NULL,
96 &android_app->inputPollSource);
97 }
98 pthread_cond_broadcast(&android_app->cond);
99 pthread_mutex_unlock(&android_app->mutex);
100 break;
101
102 case APP_CMD_INIT_WINDOW:
103 LOGV("APP_CMD_INIT_WINDOW");
104 pthread_mutex_lock(&android_app->mutex);
105 android_app->window = android_app->pendingWindow;
106 pthread_cond_broadcast(&android_app->cond);
107 pthread_mutex_unlock(&android_app->mutex);
108 break;
109
110 case APP_CMD_TERM_WINDOW:
111 LOGV("APP_CMD_TERM_WINDOW");
112 pthread_cond_broadcast(&android_app->cond);
113 break;
114
115 case APP_CMD_RESUME:
116 case APP_CMD_START:
117 case APP_CMD_PAUSE:
118 case APP_CMD_STOP:
119 LOGV("activityState=%d", cmd);
120 pthread_mutex_lock(&android_app->mutex);
121 android_app->activityState = cmd;
122 pthread_cond_broadcast(&android_app->cond);
123 pthread_mutex_unlock(&android_app->mutex);
124 break;
125
126 case APP_CMD_CONFIG_CHANGED:
127 LOGV("APP_CMD_CONFIG_CHANGED");
128 AConfiguration_fromAssetManager(android_app->config,
129 android_app->activity->assetManager);
130 print_cur_config(android_app);
131 break;
132
133 case APP_CMD_DESTROY:
134 LOGV("APP_CMD_DESTROY");
135 android_app->destroyRequested = 1;
136 break;
137 }
138 }
139
android_app_post_exec_cmd(struct android_app * android_app,int8_t cmd)140 void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd) {
141 switch (cmd) {
142 case APP_CMD_TERM_WINDOW:
143 LOGV("APP_CMD_TERM_WINDOW");
144 pthread_mutex_lock(&android_app->mutex);
145 android_app->window = NULL;
146 pthread_cond_broadcast(&android_app->cond);
147 pthread_mutex_unlock(&android_app->mutex);
148 break;
149
150 case APP_CMD_SAVE_STATE:
151 LOGV("APP_CMD_SAVE_STATE");
152 pthread_mutex_lock(&android_app->mutex);
153 android_app->stateSaved = 1;
154 pthread_cond_broadcast(&android_app->cond);
155 pthread_mutex_unlock(&android_app->mutex);
156 break;
157
158 case APP_CMD_RESUME:
159 free_saved_state(android_app);
160 break;
161 }
162 }
163
app_dummy(void)164 void app_dummy(void) {
165
166 }
167
android_app_destroy(struct android_app * android_app)168 static void android_app_destroy(struct android_app* android_app) {
169 LOGV("android_app_destroy!");
170 free_saved_state(android_app);
171 pthread_mutex_lock(&android_app->mutex);
172 if (android_app->inputQueue != NULL) {
173 AInputQueue_detachLooper(android_app->inputQueue);
174 }
175 AConfiguration_delete(android_app->config);
176 android_app->destroyed = 1;
177 pthread_cond_broadcast(&android_app->cond);
178 pthread_mutex_unlock(&android_app->mutex);
179 // Can't touch android_app object after this.
180 }
181
process_input(struct android_app * app,struct android_poll_source * source)182 static void process_input(struct android_app* app, struct android_poll_source* source) {
183 AInputEvent* event = NULL;
184 while (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
185 LOGV("New input event: type=%d", AInputEvent_getType(event));
186 if (AInputQueue_preDispatchEvent(app->inputQueue, event)) {
187 continue;
188 }
189 int32_t handled = 0;
190 if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
191 AInputQueue_finishEvent(app->inputQueue, event, handled);
192 }
193 }
194
process_cmd(struct android_app * app,struct android_poll_source * source)195 static void process_cmd(struct android_app* app, struct android_poll_source* source) {
196 int8_t cmd = android_app_read_cmd(app);
197 android_app_pre_exec_cmd(app, cmd);
198 if (app->onAppCmd != NULL) app->onAppCmd(app, cmd);
199 android_app_post_exec_cmd(app, cmd);
200 }
201
android_app_entry(void * param)202 static void* android_app_entry(void* param) {
203 struct android_app* android_app = (struct android_app*)param;
204
205 android_app->config = AConfiguration_new();
206 AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
207
208 print_cur_config(android_app);
209
210 android_app->cmdPollSource.id = LOOPER_ID_MAIN;
211 android_app->cmdPollSource.app = android_app;
212 android_app->cmdPollSource.process = process_cmd;
213 android_app->inputPollSource.id = LOOPER_ID_INPUT;
214 android_app->inputPollSource.app = android_app;
215 android_app->inputPollSource.process = process_input;
216
217 ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
218 ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
219 &android_app->cmdPollSource);
220 android_app->looper = looper;
221
222 pthread_mutex_lock(&android_app->mutex);
223 android_app->running = 1;
224 pthread_cond_broadcast(&android_app->cond);
225 pthread_mutex_unlock(&android_app->mutex);
226
227 android_main(android_app);
228
229 android_app_destroy(android_app);
230 return NULL;
231 }
232
233 // --------------------------------------------------------------------
234 // Native activity interaction (called from main thread)
235 // --------------------------------------------------------------------
236
android_app_create(ANativeActivity * activity,void * savedState,size_t savedStateSize)237 static struct android_app* android_app_create(ANativeActivity* activity,
238 void* savedState, size_t savedStateSize) {
239 struct android_app* android_app = calloc(1, sizeof(struct android_app));
240 android_app->activity = activity;
241
242 pthread_mutex_init(&android_app->mutex, NULL);
243 pthread_cond_init(&android_app->cond, NULL);
244
245 if (savedState != NULL) {
246 android_app->savedState = malloc(savedStateSize);
247 android_app->savedStateSize = savedStateSize;
248 memcpy(android_app->savedState, savedState, savedStateSize);
249 }
250
251 int msgpipe[2];
252 if (pipe(msgpipe)) {
253 LOGE("could not create pipe: %s", strerror(errno));
254 return NULL;
255 }
256 android_app->msgread = msgpipe[0];
257 android_app->msgwrite = msgpipe[1];
258
259 pthread_attr_t attr;
260 pthread_attr_init(&attr);
261 pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
262 pthread_create(&android_app->thread, &attr, android_app_entry, android_app);
263
264 // Wait for thread to start.
265 pthread_mutex_lock(&android_app->mutex);
266 while (!android_app->running) {
267 pthread_cond_wait(&android_app->cond, &android_app->mutex);
268 }
269 pthread_mutex_unlock(&android_app->mutex);
270
271 return android_app;
272 }
273
android_app_write_cmd(struct android_app * android_app,int8_t cmd)274 static void android_app_write_cmd(struct android_app* android_app, int8_t cmd) {
275 if (write(android_app->msgwrite, &cmd, sizeof(cmd)) != sizeof(cmd)) {
276 LOGE("Failure writing android_app cmd: %s", strerror(errno));
277 }
278 }
279
android_app_set_input(struct android_app * android_app,AInputQueue * inputQueue)280 static void android_app_set_input(struct android_app* android_app, AInputQueue* inputQueue) {
281 pthread_mutex_lock(&android_app->mutex);
282 android_app->pendingInputQueue = inputQueue;
283 android_app_write_cmd(android_app, APP_CMD_INPUT_CHANGED);
284 while (android_app->inputQueue != android_app->pendingInputQueue) {
285 pthread_cond_wait(&android_app->cond, &android_app->mutex);
286 }
287 pthread_mutex_unlock(&android_app->mutex);
288 }
289
android_app_set_window(struct android_app * android_app,ANativeWindow * window)290 static void android_app_set_window(struct android_app* android_app, ANativeWindow* window) {
291 pthread_mutex_lock(&android_app->mutex);
292 if (android_app->pendingWindow != NULL) {
293 android_app_write_cmd(android_app, APP_CMD_TERM_WINDOW);
294 }
295 android_app->pendingWindow = window;
296 if (window != NULL) {
297 android_app_write_cmd(android_app, APP_CMD_INIT_WINDOW);
298 }
299 while (android_app->window != android_app->pendingWindow) {
300 pthread_cond_wait(&android_app->cond, &android_app->mutex);
301 }
302 pthread_mutex_unlock(&android_app->mutex);
303 }
304
android_app_set_activity_state(struct android_app * android_app,int8_t cmd)305 static void android_app_set_activity_state(struct android_app* android_app, int8_t cmd) {
306 pthread_mutex_lock(&android_app->mutex);
307 android_app_write_cmd(android_app, cmd);
308 while (android_app->activityState != cmd) {
309 pthread_cond_wait(&android_app->cond, &android_app->mutex);
310 }
311 pthread_mutex_unlock(&android_app->mutex);
312 }
313
android_app_free(struct android_app * android_app)314 static void android_app_free(struct android_app* android_app) {
315 pthread_mutex_lock(&android_app->mutex);
316 android_app_write_cmd(android_app, APP_CMD_DESTROY);
317 while (!android_app->destroyed) {
318 pthread_cond_wait(&android_app->cond, &android_app->mutex);
319 }
320 pthread_mutex_unlock(&android_app->mutex);
321
322 close(android_app->msgread);
323 close(android_app->msgwrite);
324 pthread_cond_destroy(&android_app->cond);
325 pthread_mutex_destroy(&android_app->mutex);
326 free(android_app);
327 }
328
ToApp(ANativeActivity * activity)329 static struct android_app* ToApp(ANativeActivity* activity) {
330 return (struct android_app*) activity->instance;
331 }
332
onDestroy(ANativeActivity * activity)333 static void onDestroy(ANativeActivity* activity) {
334 LOGV("Destroy: %p", activity);
335 android_app_free(ToApp(activity));
336 }
337
onStart(ANativeActivity * activity)338 static void onStart(ANativeActivity* activity) {
339 LOGV("Start: %p", activity);
340 android_app_set_activity_state(ToApp(activity), APP_CMD_START);
341 }
342
onResume(ANativeActivity * activity)343 static void onResume(ANativeActivity* activity) {
344 LOGV("Resume: %p", activity);
345 android_app_set_activity_state(ToApp(activity), APP_CMD_RESUME);
346 }
347
onSaveInstanceState(ANativeActivity * activity,size_t * outLen)348 static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
349 LOGV("SaveInstanceState: %p", activity);
350
351 struct android_app* android_app = ToApp(activity);
352 void* savedState = NULL;
353 pthread_mutex_lock(&android_app->mutex);
354 android_app->stateSaved = 0;
355 android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
356 while (!android_app->stateSaved) {
357 pthread_cond_wait(&android_app->cond, &android_app->mutex);
358 }
359
360 if (android_app->savedState != NULL) {
361 savedState = android_app->savedState;
362 *outLen = android_app->savedStateSize;
363 android_app->savedState = NULL;
364 android_app->savedStateSize = 0;
365 }
366
367 pthread_mutex_unlock(&android_app->mutex);
368
369 return savedState;
370 }
371
onPause(ANativeActivity * activity)372 static void onPause(ANativeActivity* activity) {
373 LOGV("Pause: %p", activity);
374 android_app_set_activity_state(ToApp(activity), APP_CMD_PAUSE);
375 }
376
onStop(ANativeActivity * activity)377 static void onStop(ANativeActivity* activity) {
378 LOGV("Stop: %p", activity);
379 android_app_set_activity_state(ToApp(activity), APP_CMD_STOP);
380 }
381
onConfigurationChanged(ANativeActivity * activity)382 static void onConfigurationChanged(ANativeActivity* activity) {
383 LOGV("ConfigurationChanged: %p", activity);
384 android_app_write_cmd(ToApp(activity), APP_CMD_CONFIG_CHANGED);
385 }
386
onContentRectChanged(ANativeActivity * activity,const ARect * r)387 static void onContentRectChanged(ANativeActivity* activity, const ARect* r) {
388 LOGV("ContentRectChanged: l=%d,t=%d,r=%d,b=%d", r->left, r->top, r->right, r->bottom);
389 struct android_app* android_app = ToApp(activity);
390 pthread_mutex_lock(&android_app->mutex);
391 android_app->contentRect = *r;
392 pthread_mutex_unlock(&android_app->mutex);
393 android_app_write_cmd(ToApp(activity), APP_CMD_CONTENT_RECT_CHANGED);
394 }
395
onLowMemory(ANativeActivity * activity)396 static void onLowMemory(ANativeActivity* activity) {
397 LOGV("LowMemory: %p", activity);
398 android_app_write_cmd(ToApp(activity), APP_CMD_LOW_MEMORY);
399 }
400
onWindowFocusChanged(ANativeActivity * activity,int focused)401 static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
402 LOGV("WindowFocusChanged: %p -- %d", activity, focused);
403 android_app_write_cmd(ToApp(activity), focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
404 }
405
onNativeWindowCreated(ANativeActivity * activity,ANativeWindow * window)406 static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
407 LOGI("NativeWindowCreated: %p -- %p", activity, window);
408 android_app_set_window(ToApp(activity), window);
409 }
410
onNativeWindowDestroyed(ANativeActivity * activity,ANativeWindow * window)411 static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
412 LOGI("NativeWindowDestroyed: %p -- %p", activity, window);
413 android_app_set_window(ToApp(activity), NULL);
414 }
415
onNativeWindowRedrawNeeded(ANativeActivity * activity,ANativeWindow * window)416 static void onNativeWindowRedrawNeeded(ANativeActivity* activity, ANativeWindow* window) {
417 LOGI("NativeWindowRedrawNeeded: %p -- %p", activity, window);
418 android_app_write_cmd(ToApp(activity), APP_CMD_WINDOW_REDRAW_NEEDED);
419 }
420
onNativeWindowResized(ANativeActivity * activity,ANativeWindow * window)421 static void onNativeWindowResized(ANativeActivity* activity, ANativeWindow* window) {
422 LOGI("NativeWindowResized: %p -- %p", activity, window);
423 android_app_write_cmd(ToApp(activity), APP_CMD_WINDOW_RESIZED);
424 }
425
onInputQueueCreated(ANativeActivity * activity,AInputQueue * queue)426 static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
427 LOGV("InputQueueCreated: %p -- %p", activity, queue);
428 android_app_set_input(ToApp(activity), queue);
429 }
430
onInputQueueDestroyed(ANativeActivity * activity,AInputQueue * queue)431 static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
432 LOGV("InputQueueDestroyed: %p -- %p", activity, queue);
433 android_app_set_input(ToApp(activity), NULL);
434 }
435
ANativeActivity_onCreate(ANativeActivity * activity,void * savedState,size_t savedStateSize)436 __attribute__((visibility("default"))) void ANativeActivity_onCreate(ANativeActivity* activity,
437 void* savedState, size_t savedStateSize) {
438 LOGV("Creating: %p", activity);
439
440 activity->callbacks->onConfigurationChanged = onConfigurationChanged;
441 activity->callbacks->onContentRectChanged = onContentRectChanged;
442 activity->callbacks->onDestroy = onDestroy;
443 activity->callbacks->onInputQueueCreated = onInputQueueCreated;
444 activity->callbacks->onInputQueueDestroyed = onInputQueueDestroyed;
445 activity->callbacks->onLowMemory = onLowMemory;
446 activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
447 activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
448 activity->callbacks->onNativeWindowRedrawNeeded = onNativeWindowRedrawNeeded;
449 activity->callbacks->onNativeWindowResized = onNativeWindowResized;
450 activity->callbacks->onPause = onPause;
451 activity->callbacks->onResume = onResume;
452 activity->callbacks->onSaveInstanceState = onSaveInstanceState;
453 activity->callbacks->onStart = onStart;
454 activity->callbacks->onStop = onStop;
455 activity->callbacks->onWindowFocusChanged = onWindowFocusChanged;
456
457 activity->instance = android_app_create(activity, savedState, savedStateSize);
458 }
459