istereo2: 48a0660bac82 src/android/android_native_app

istereo2

view src/android/android_native_app_glue.c @ 31:48a0660bac82

fucked up the ads

author	John Tsiombikas <nuclear@member.fsf.org>
date	Thu, 08 Oct 2015 16:23:27 +0300
parents
children

line source

1 /*

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 */

18 #include <jni.h>

20 #include <errno.h>

21 #include <string.h>

22 #include <unistd.h>

23 #include <sys/resource.h>

25 #include "android_native_app_glue.h"

26 #include <android/log.h>

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__))

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

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 }

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 }

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);

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 }

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

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

169 void app_dummy() {

170

171 }

172

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

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

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

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

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

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

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

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

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

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

335 static void onDestroy(ANativeActivity* activity) {

336 LOGV("Destroy: %p\n", activity);

337 android_app_free((struct android_app*)activity->instance);

338 }

339

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

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

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

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

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

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

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

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

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

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

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

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

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 }