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 
18 #include <jni.h>
19 
20 #include <errno.h>
21 #include <string.h>
22 #include <unistd.h>
23 #include <sys/resource.h>
24 
25 #include "android_native_app_glue.h"
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         switch (cmd) {
52             case APP_CMD_SAVE_STATE:
53                 free_saved_state(android_app);
54                 break;
55         }
56         return cmd;
57     } else {
58         LOGE("No data on command pipe!");
59     }
60     return -1;
61 }
62 
print_cur_config(struct android_app * android_app)63 static void print_cur_config(struct android_app* android_app) {
64     char lang[2], country[2];
65     AConfiguration_getLanguage(android_app->config, lang);
66     AConfiguration_getCountry(android_app->config, country);
67 
68     LOGV("Config: mcc=%d mnc=%d lang=%c%c cnt=%c%c orien=%d touch=%d dens=%d "
69             "keys=%d nav=%d keysHid=%d navHid=%d sdk=%d size=%d long=%d "
70             "modetype=%d modenight=%d",
71             AConfiguration_getMcc(android_app->config),
72             AConfiguration_getMnc(android_app->config),
73             lang[0], lang[1], country[0], country[1],
74             AConfiguration_getOrientation(android_app->config),
75             AConfiguration_getTouchscreen(android_app->config),
76             AConfiguration_getDensity(android_app->config),
77             AConfiguration_getKeyboard(android_app->config),
78             AConfiguration_getNavigation(android_app->config),
79             AConfiguration_getKeysHidden(android_app->config),
80             AConfiguration_getNavHidden(android_app->config),
81             AConfiguration_getSdkVersion(android_app->config),
82             AConfiguration_getScreenSize(android_app->config),
83             AConfiguration_getScreenLong(android_app->config),
84             AConfiguration_getUiModeType(android_app->config),
85             AConfiguration_getUiModeNight(android_app->config));
86 }
87 
android_app_pre_exec_cmd(struct android_app * android_app,int8_t cmd)88 void android_app_pre_exec_cmd(struct android_app* android_app, int8_t cmd) {
89     switch (cmd) {
90         case APP_CMD_INPUT_CHANGED:
91             LOGV("APP_CMD_INPUT_CHANGED\n");
92             pthread_mutex_lock(&android_app->mutex);
93             if (android_app->inputQueue != NULL) {
94                 AInputQueue_detachLooper(android_app->inputQueue);
95             }
96             android_app->inputQueue = android_app->pendingInputQueue;
97             if (android_app->inputQueue != NULL) {
98                 LOGV("Attaching input queue to looper");
99                 AInputQueue_attachLooper(android_app->inputQueue,
100                         android_app->looper, LOOPER_ID_INPUT, NULL,
101                         &android_app->inputPollSource);
102             }
103             pthread_cond_broadcast(&android_app->cond);
104             pthread_mutex_unlock(&android_app->mutex);
105             break;
106 
107         case APP_CMD_INIT_WINDOW:
108             LOGV("APP_CMD_INIT_WINDOW\n");
109             pthread_mutex_lock(&android_app->mutex);
110             android_app->window = android_app->pendingWindow;
111             pthread_cond_broadcast(&android_app->cond);
112             pthread_mutex_unlock(&android_app->mutex);
113             break;
114 
115         case APP_CMD_TERM_WINDOW:
116             LOGV("APP_CMD_TERM_WINDOW\n");
117             pthread_cond_broadcast(&android_app->cond);
118             break;
119 
120         case APP_CMD_RESUME:
121         case APP_CMD_START:
122         case APP_CMD_PAUSE:
123         case APP_CMD_STOP:
124             LOGV("activityState=%d\n", cmd);
125             pthread_mutex_lock(&android_app->mutex);
126             android_app->activityState = cmd;
127             pthread_cond_broadcast(&android_app->cond);
128             pthread_mutex_unlock(&android_app->mutex);
129             break;
130 
131         case APP_CMD_CONFIG_CHANGED:
132             LOGV("APP_CMD_CONFIG_CHANGED\n");
133             AConfiguration_fromAssetManager(android_app->config,
134                     android_app->activity->assetManager);
135             print_cur_config(android_app);
136             break;
137 
138         case APP_CMD_DESTROY:
139             LOGV("APP_CMD_DESTROY\n");
140             android_app->destroyRequested = 1;
141             break;
142     }
143 }
144 
android_app_post_exec_cmd(struct android_app * android_app,int8_t cmd)145 void android_app_post_exec_cmd(struct android_app* android_app, int8_t cmd) {
146     switch (cmd) {
147         case APP_CMD_TERM_WINDOW:
148             LOGV("APP_CMD_TERM_WINDOW\n");
149             pthread_mutex_lock(&android_app->mutex);
150             android_app->window = NULL;
151             pthread_cond_broadcast(&android_app->cond);
152             pthread_mutex_unlock(&android_app->mutex);
153             break;
154 
155         case APP_CMD_SAVE_STATE:
156             LOGV("APP_CMD_SAVE_STATE\n");
157             pthread_mutex_lock(&android_app->mutex);
158             android_app->stateSaved = 1;
159             pthread_cond_broadcast(&android_app->cond);
160             pthread_mutex_unlock(&android_app->mutex);
161             break;
162 
163         case APP_CMD_RESUME:
164             free_saved_state(android_app);
165             break;
166     }
167 }
168 
app_dummy()169 void app_dummy() {
170 
171 }
172 
android_app_destroy(struct android_app * android_app)173 static void android_app_destroy(struct android_app* android_app) {
174     LOGV("android_app_destroy!");
175     free_saved_state(android_app);
176     pthread_mutex_lock(&android_app->mutex);
177     if (android_app->inputQueue != NULL) {
178         AInputQueue_detachLooper(android_app->inputQueue);
179     }
180     AConfiguration_delete(android_app->config);
181     android_app->destroyed = 1;
182     pthread_cond_broadcast(&android_app->cond);
183     pthread_mutex_unlock(&android_app->mutex);
184     // Can't touch android_app object after this.
185 }
186 
process_input(struct android_app * app,struct android_poll_source * source)187 static void process_input(struct android_app* app, struct android_poll_source* source) {
188     AInputEvent* event = NULL;
189     while (AInputQueue_getEvent(app->inputQueue, &event) >= 0) {
190         LOGV("New input event: type=%d\n", AInputEvent_getType(event));
191         if (AInputQueue_preDispatchEvent(app->inputQueue, event)) {
192             continue;
193         }
194         int32_t handled = 0;
195         if (app->onInputEvent != NULL) handled = app->onInputEvent(app, event);
196         AInputQueue_finishEvent(app->inputQueue, event, handled);
197     }
198 }
199 
process_cmd(struct android_app * app,struct android_poll_source * source)200 static void process_cmd(struct android_app* app, struct android_poll_source* source) {
201     int8_t cmd = android_app_read_cmd(app);
202     android_app_pre_exec_cmd(app, cmd);
203     if (app->onAppCmd != NULL) app->onAppCmd(app, cmd);
204     android_app_post_exec_cmd(app, cmd);
205 }
206 
android_app_entry(void * param)207 static void* android_app_entry(void* param) {
208     struct android_app* android_app = (struct android_app*)param;
209 
210     android_app->config = AConfiguration_new();
211     AConfiguration_fromAssetManager(android_app->config, android_app->activity->assetManager);
212 
213     print_cur_config(android_app);
214 
215     android_app->cmdPollSource.id = LOOPER_ID_MAIN;
216     android_app->cmdPollSource.app = android_app;
217     android_app->cmdPollSource.process = process_cmd;
218     android_app->inputPollSource.id = LOOPER_ID_INPUT;
219     android_app->inputPollSource.app = android_app;
220     android_app->inputPollSource.process = process_input;
221 
222     ALooper* looper = ALooper_prepare(ALOOPER_PREPARE_ALLOW_NON_CALLBACKS);
223     ALooper_addFd(looper, android_app->msgread, LOOPER_ID_MAIN, ALOOPER_EVENT_INPUT, NULL,
224             &android_app->cmdPollSource);
225     android_app->looper = looper;
226 
227     pthread_mutex_lock(&android_app->mutex);
228     android_app->running = 1;
229     pthread_cond_broadcast(&android_app->cond);
230     pthread_mutex_unlock(&android_app->mutex);
231 
232     android_main(android_app);
233 
234     android_app_destroy(android_app);
235     return NULL;
236 }
237 
238 // --------------------------------------------------------------------
239 // Native activity interaction (called from main thread)
240 // --------------------------------------------------------------------
241 
android_app_create(ANativeActivity * activity,void * savedState,size_t savedStateSize)242 static struct android_app* android_app_create(ANativeActivity* activity,
243         void* savedState, size_t savedStateSize) {
244     struct android_app* android_app = (struct android_app*)malloc(sizeof(struct android_app));
245     memset(android_app, 0, sizeof(struct android_app));
246     android_app->activity = activity;
247 
248     pthread_mutex_init(&android_app->mutex, NULL);
249     pthread_cond_init(&android_app->cond, NULL);
250 
251     if (savedState != NULL) {
252         android_app->savedState = malloc(savedStateSize);
253         android_app->savedStateSize = savedStateSize;
254         memcpy(android_app->savedState, savedState, savedStateSize);
255     }
256 
257     int msgpipe[2];
258     if (pipe(msgpipe)) {
259         LOGE("could not create pipe: %s", strerror(errno));
260         return NULL;
261     }
262     android_app->msgread = msgpipe[0];
263     android_app->msgwrite = msgpipe[1];
264 
265     pthread_attr_t attr;
266     pthread_attr_init(&attr);
267     pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
268     pthread_create(&android_app->thread, &attr, android_app_entry, android_app);
269 
270     // Wait for thread to start.
271     pthread_mutex_lock(&android_app->mutex);
272     while (!android_app->running) {
273         pthread_cond_wait(&android_app->cond, &android_app->mutex);
274     }
275     pthread_mutex_unlock(&android_app->mutex);
276 
277     return android_app;
278 }
279 
android_app_write_cmd(struct android_app * android_app,int8_t cmd)280 static void android_app_write_cmd(struct android_app* android_app, int8_t cmd) {
281     if (write(android_app->msgwrite, &cmd, sizeof(cmd)) != sizeof(cmd)) {
282         LOGE("Failure writing android_app cmd: %s\n", strerror(errno));
283     }
284 }
285 
android_app_set_input(struct android_app * android_app,AInputQueue * inputQueue)286 static void android_app_set_input(struct android_app* android_app, AInputQueue* inputQueue) {
287     pthread_mutex_lock(&android_app->mutex);
288     android_app->pendingInputQueue = inputQueue;
289     android_app_write_cmd(android_app, APP_CMD_INPUT_CHANGED);
290     while (android_app->inputQueue != android_app->pendingInputQueue) {
291         pthread_cond_wait(&android_app->cond, &android_app->mutex);
292     }
293     pthread_mutex_unlock(&android_app->mutex);
294 }
295 
android_app_set_window(struct android_app * android_app,ANativeWindow * window)296 static void android_app_set_window(struct android_app* android_app, ANativeWindow* window) {
297     pthread_mutex_lock(&android_app->mutex);
298     if (android_app->pendingWindow != NULL) {
299         android_app_write_cmd(android_app, APP_CMD_TERM_WINDOW);
300     }
301     android_app->pendingWindow = window;
302     if (window != NULL) {
303         android_app_write_cmd(android_app, APP_CMD_INIT_WINDOW);
304     }
305     while (android_app->window != android_app->pendingWindow) {
306         pthread_cond_wait(&android_app->cond, &android_app->mutex);
307     }
308     pthread_mutex_unlock(&android_app->mutex);
309 }
310 
android_app_set_activity_state(struct android_app * android_app,int8_t cmd)311 static void android_app_set_activity_state(struct android_app* android_app, int8_t cmd) {
312     pthread_mutex_lock(&android_app->mutex);
313     android_app_write_cmd(android_app, cmd);
314     while (android_app->activityState != cmd) {
315         pthread_cond_wait(&android_app->cond, &android_app->mutex);
316     }
317     pthread_mutex_unlock(&android_app->mutex);
318 }
319 
android_app_free(struct android_app * android_app)320 static void android_app_free(struct android_app* android_app) {
321     pthread_mutex_lock(&android_app->mutex);
322     android_app_write_cmd(android_app, APP_CMD_DESTROY);
323     while (!android_app->destroyed) {
324         pthread_cond_wait(&android_app->cond, &android_app->mutex);
325     }
326     pthread_mutex_unlock(&android_app->mutex);
327 
328     close(android_app->msgread);
329     close(android_app->msgwrite);
330     pthread_cond_destroy(&android_app->cond);
331     pthread_mutex_destroy(&android_app->mutex);
332     free(android_app);
333 }
334 
onDestroy(ANativeActivity * activity)335 static void onDestroy(ANativeActivity* activity) {
336     LOGV("Destroy: %p\n", activity);
337     android_app_free((struct android_app*)activity->instance);
338 }
339 
onStart(ANativeActivity * activity)340 static void onStart(ANativeActivity* activity) {
341     LOGV("Start: %p\n", activity);
342     android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_START);
343 }
344 
onResume(ANativeActivity * activity)345 static void onResume(ANativeActivity* activity) {
346     LOGV("Resume: %p\n", activity);
347     android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_RESUME);
348 }
349 
onSaveInstanceState(ANativeActivity * activity,size_t * outLen)350 static void* onSaveInstanceState(ANativeActivity* activity, size_t* outLen) {
351     struct android_app* android_app = (struct android_app*)activity->instance;
352     void* savedState = NULL;
353 
354     LOGV("SaveInstanceState: %p\n", activity);
355     pthread_mutex_lock(&android_app->mutex);
356     android_app->stateSaved = 0;
357     android_app_write_cmd(android_app, APP_CMD_SAVE_STATE);
358     while (!android_app->stateSaved) {
359         pthread_cond_wait(&android_app->cond, &android_app->mutex);
360     }
361 
362     if (android_app->savedState != NULL) {
363         savedState = android_app->savedState;
364         *outLen = android_app->savedStateSize;
365         android_app->savedState = NULL;
366         android_app->savedStateSize = 0;
367     }
368 
369     pthread_mutex_unlock(&android_app->mutex);
370 
371     return savedState;
372 }
373 
onPause(ANativeActivity * activity)374 static void onPause(ANativeActivity* activity) {
375     LOGV("Pause: %p\n", activity);
376     android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_PAUSE);
377 }
378 
onStop(ANativeActivity * activity)379 static void onStop(ANativeActivity* activity) {
380     LOGV("Stop: %p\n", activity);
381     android_app_set_activity_state((struct android_app*)activity->instance, APP_CMD_STOP);
382 }
383 
onConfigurationChanged(ANativeActivity * activity)384 static void onConfigurationChanged(ANativeActivity* activity) {
385     struct android_app* android_app = (struct android_app*)activity->instance;
386     LOGV("ConfigurationChanged: %p\n", activity);
387     android_app_write_cmd(android_app, APP_CMD_CONFIG_CHANGED);
388 }
389 
onLowMemory(ANativeActivity * activity)390 static void onLowMemory(ANativeActivity* activity) {
391     struct android_app* android_app = (struct android_app*)activity->instance;
392     LOGV("LowMemory: %p\n", activity);
393     android_app_write_cmd(android_app, APP_CMD_LOW_MEMORY);
394 }
395 
onWindowFocusChanged(ANativeActivity * activity,int focused)396 static void onWindowFocusChanged(ANativeActivity* activity, int focused) {
397     LOGV("WindowFocusChanged: %p -- %d\n", activity, focused);
398     android_app_write_cmd((struct android_app*)activity->instance,
399             focused ? APP_CMD_GAINED_FOCUS : APP_CMD_LOST_FOCUS);
400 }
401 
onNativeWindowCreated(ANativeActivity * activity,ANativeWindow * window)402 static void onNativeWindowCreated(ANativeActivity* activity, ANativeWindow* window) {
403     LOGV("NativeWindowCreated: %p -- %p\n", activity, window);
404     android_app_set_window((struct android_app*)activity->instance, window);
405 }
406 
onNativeWindowDestroyed(ANativeActivity * activity,ANativeWindow * window)407 static void onNativeWindowDestroyed(ANativeActivity* activity, ANativeWindow* window) {
408     LOGV("NativeWindowDestroyed: %p -- %p\n", activity, window);
409     android_app_set_window((struct android_app*)activity->instance, NULL);
410 }
411 
onInputQueueCreated(ANativeActivity * activity,AInputQueue * queue)412 static void onInputQueueCreated(ANativeActivity* activity, AInputQueue* queue) {
413     LOGV("InputQueueCreated: %p -- %p\n", activity, queue);
414     android_app_set_input((struct android_app*)activity->instance, queue);
415 }
416 
onInputQueueDestroyed(ANativeActivity * activity,AInputQueue * queue)417 static void onInputQueueDestroyed(ANativeActivity* activity, AInputQueue* queue) {
418     LOGV("InputQueueDestroyed: %p -- %p\n", activity, queue);
419     android_app_set_input((struct android_app*)activity->instance, NULL);
420 }
421 
ANativeActivity_onCreate(ANativeActivity * activity,void * savedState,size_t savedStateSize)422 void ANativeActivity_onCreate(ANativeActivity* activity,
423         void* savedState, size_t savedStateSize) {
424     LOGV("Creating: %p\n", activity);
425     activity->callbacks->onDestroy = onDestroy;
426     activity->callbacks->onStart = onStart;
427     activity->callbacks->onResume = onResume;
428     activity->callbacks->onSaveInstanceState = onSaveInstanceState;
429     activity->callbacks->onPause = onPause;
430     activity->callbacks->onStop = onStop;
431     activity->callbacks->onConfigurationChanged = onConfigurationChanged;
432     activity->callbacks->onLowMemory = onLowMemory;
433     activity->callbacks->onWindowFocusChanged = onWindowFocusChanged;
434     activity->callbacks->onNativeWindowCreated = onNativeWindowCreated;
435     activity->callbacks->onNativeWindowDestroyed = onNativeWindowDestroyed;
436     activity->callbacks->onInputQueueCreated = onInputQueueCreated;
437     activity->callbacks->onInputQueueDestroyed = onInputQueueDestroyed;
438 
439     activity->instance = android_app_create(activity, savedState, savedStateSize);
440 }
441