os_android.cpp 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951
  1. /*************************************************************************/
  2. /* os_android.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
  9. /* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /*************************************************************************/
  30. #include "os_android.h"
  31. #include "core/project_settings.h"
  32. #include "drivers/gles2/rasterizer_gles2.h"
  33. #include "drivers/gles3/rasterizer_gles3.h"
  34. #include "drivers/unix/dir_access_unix.h"
  35. #include "drivers/unix/file_access_unix.h"
  36. #include "main/main.h"
  37. #include "servers/visual/visual_server_raster.h"
  38. #include "servers/visual/visual_server_wrap_mt.h"
  39. #include "dir_access_jandroid.h"
  40. #include "file_access_android.h"
  41. #include "net_socket_android.h"
  42. #include <android/input.h>
  43. #include <core/os/keyboard.h>
  44. #include <dlfcn.h>
  45. #include "android_keys_utils.h"
  46. #include "java_godot_io_wrapper.h"
  47. #include "java_godot_wrapper.h"
  48. class AndroidLogger : public Logger {
  49. public:
  50. virtual void logv(const char *p_format, va_list p_list, bool p_err) {
  51. __android_log_vprint(p_err ? ANDROID_LOG_ERROR : ANDROID_LOG_INFO, "godot", p_format, p_list);
  52. }
  53. virtual ~AndroidLogger() {}
  54. };
  55. int OS_Android::get_video_driver_count() const {
  56. return 2;
  57. }
  58. const char *OS_Android::get_video_driver_name(int p_driver) const {
  59. switch (p_driver) {
  60. case VIDEO_DRIVER_GLES3:
  61. return "GLES3";
  62. case VIDEO_DRIVER_GLES2:
  63. return "GLES2";
  64. }
  65. ERR_FAIL_V_MSG(NULL, "Invalid video driver index: " + itos(p_driver) + ".");
  66. }
  67. int OS_Android::get_audio_driver_count() const {
  68. return 1;
  69. }
  70. const char *OS_Android::get_audio_driver_name(int p_driver) const {
  71. return "Android";
  72. }
  73. void OS_Android::initialize_core() {
  74. OS_Unix::initialize_core();
  75. if (use_apk_expansion)
  76. FileAccess::make_default<FileAccessUnix>(FileAccess::ACCESS_RESOURCES);
  77. else {
  78. FileAccess::make_default<FileAccessAndroid>(FileAccess::ACCESS_RESOURCES);
  79. }
  80. FileAccess::make_default<FileAccessUnix>(FileAccess::ACCESS_USERDATA);
  81. FileAccess::make_default<FileAccessUnix>(FileAccess::ACCESS_FILESYSTEM);
  82. if (use_apk_expansion)
  83. DirAccess::make_default<DirAccessUnix>(DirAccess::ACCESS_RESOURCES);
  84. else
  85. DirAccess::make_default<DirAccessJAndroid>(DirAccess::ACCESS_RESOURCES);
  86. DirAccess::make_default<DirAccessUnix>(DirAccess::ACCESS_USERDATA);
  87. DirAccess::make_default<DirAccessUnix>(DirAccess::ACCESS_FILESYSTEM);
  88. NetSocketAndroid::make_default();
  89. }
  90. void OS_Android::set_opengl_extensions(const char *p_gl_extensions) {
  91. ERR_FAIL_COND(!p_gl_extensions);
  92. gl_extensions = p_gl_extensions;
  93. }
  94. int OS_Android::get_current_video_driver() const {
  95. return video_driver_index;
  96. }
  97. Error OS_Android::initialize(const VideoMode &p_desired, int p_video_driver, int p_audio_driver) {
  98. bool use_gl3 = godot_java->get_gles_version_code() >= 0x00030000;
  99. use_gl3 = use_gl3 && (GLOBAL_GET("rendering/quality/driver/driver_name") == "GLES3");
  100. bool gl_initialization_error = false;
  101. while (true) {
  102. if (use_gl3) {
  103. if (RasterizerGLES3::is_viable() == OK) {
  104. godot_java->gfx_init(false);
  105. RasterizerGLES3::register_config();
  106. RasterizerGLES3::make_current();
  107. break;
  108. } else {
  109. if (GLOBAL_GET("rendering/quality/driver/fallback_to_gles2")) {
  110. p_video_driver = VIDEO_DRIVER_GLES2;
  111. use_gl3 = false;
  112. continue;
  113. } else {
  114. gl_initialization_error = true;
  115. break;
  116. }
  117. }
  118. } else {
  119. if (RasterizerGLES2::is_viable() == OK) {
  120. godot_java->gfx_init(true);
  121. RasterizerGLES2::register_config();
  122. RasterizerGLES2::make_current();
  123. break;
  124. } else {
  125. gl_initialization_error = true;
  126. break;
  127. }
  128. }
  129. }
  130. if (gl_initialization_error) {
  131. OS::get_singleton()->alert("Your device does not support any of the supported OpenGL versions.\n"
  132. "Please try updating your Android version.",
  133. "Unable to initialize Video driver");
  134. return ERR_UNAVAILABLE;
  135. }
  136. video_driver_index = p_video_driver;
  137. visual_server = memnew(VisualServerRaster);
  138. if (get_render_thread_mode() != RENDER_THREAD_UNSAFE) {
  139. visual_server = memnew(VisualServerWrapMT(visual_server, false));
  140. }
  141. visual_server->init();
  142. AudioDriverManager::initialize(p_audio_driver);
  143. input = memnew(InputDefault);
  144. input->set_fallback_mapping(godot_java->get_input_fallback_mapping());
  145. //power_manager = memnew(PowerAndroid);
  146. return OK;
  147. }
  148. void OS_Android::set_main_loop(MainLoop *p_main_loop) {
  149. main_loop = p_main_loop;
  150. input->set_main_loop(p_main_loop);
  151. }
  152. void OS_Android::delete_main_loop() {
  153. memdelete(main_loop);
  154. }
  155. void OS_Android::finalize() {
  156. memdelete(input);
  157. }
  158. GodotJavaWrapper *OS_Android::get_godot_java() {
  159. return godot_java;
  160. }
  161. GodotIOJavaWrapper *OS_Android::get_godot_io_java() {
  162. return godot_io_java;
  163. }
  164. void OS_Android::alert(const String &p_alert, const String &p_title) {
  165. //print("ALERT: %s\n", p_alert.utf8().get_data());
  166. godot_java->alert(p_alert, p_title);
  167. }
  168. bool OS_Android::request_permission(const String &p_name) {
  169. return godot_java->request_permission(p_name);
  170. }
  171. bool OS_Android::request_permissions() {
  172. return godot_java->request_permissions();
  173. }
  174. Vector<String> OS_Android::get_granted_permissions() const {
  175. return godot_java->get_granted_permissions();
  176. }
  177. Error OS_Android::open_dynamic_library(const String p_path, void *&p_library_handle, bool p_also_set_library_path) {
  178. p_library_handle = dlopen(p_path.utf8().get_data(), RTLD_NOW);
  179. ERR_FAIL_COND_V_MSG(!p_library_handle, ERR_CANT_OPEN, "Can't open dynamic library: " + p_path + ", error: " + dlerror() + ".");
  180. return OK;
  181. }
  182. void OS_Android::set_mouse_show(bool p_show) {
  183. //android has no mouse...
  184. }
  185. void OS_Android::set_mouse_grab(bool p_grab) {
  186. //it really has no mouse...!
  187. }
  188. bool OS_Android::is_mouse_grab_enabled() const {
  189. //*sigh* technology has evolved so much since i was a kid..
  190. return false;
  191. }
  192. Point2 OS_Android::get_mouse_position() const {
  193. return hover_prev_pos;
  194. }
  195. int OS_Android::get_mouse_button_state() const {
  196. return buttons_state;
  197. }
  198. void OS_Android::set_window_title(const String &p_title) {
  199. //This queries/updates the currently connected devices/joypads
  200. //Set_window_title is called when initializing the main loop (main.cpp)
  201. //therefore this place is found to be suitable (I found no better).
  202. godot_java->init_input_devices();
  203. }
  204. void OS_Android::set_video_mode(const VideoMode &p_video_mode, int p_screen) {
  205. }
  206. OS::VideoMode OS_Android::get_video_mode(int p_screen) const {
  207. return default_videomode;
  208. }
  209. void OS_Android::get_fullscreen_mode_list(List<VideoMode> *p_list, int p_screen) const {
  210. p_list->push_back(default_videomode);
  211. }
  212. void OS_Android::set_keep_screen_on(bool p_enabled) {
  213. OS::set_keep_screen_on(p_enabled);
  214. godot_java->set_keep_screen_on(p_enabled);
  215. }
  216. Size2 OS_Android::get_window_size() const {
  217. return Vector2(default_videomode.width, default_videomode.height);
  218. }
  219. Rect2 OS_Android::get_window_safe_area() const {
  220. int xywh[4];
  221. godot_io_java->get_window_safe_area(xywh);
  222. return Rect2(xywh[0], xywh[1], xywh[2], xywh[3]);
  223. }
  224. String OS_Android::get_name() const {
  225. return "Android";
  226. }
  227. MainLoop *OS_Android::get_main_loop() const {
  228. return main_loop;
  229. }
  230. bool OS_Android::can_draw() const {
  231. return true; //always?
  232. }
  233. void OS_Android::main_loop_begin() {
  234. if (main_loop)
  235. main_loop->init();
  236. }
  237. bool OS_Android::main_loop_iterate() {
  238. if (!main_loop)
  239. return false;
  240. return Main::iteration();
  241. }
  242. void OS_Android::main_loop_end() {
  243. if (main_loop)
  244. main_loop->finish();
  245. }
  246. void OS_Android::main_loop_focusout() {
  247. if (main_loop)
  248. main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_OUT);
  249. audio_driver_android.set_pause(true);
  250. }
  251. void OS_Android::main_loop_focusin() {
  252. if (main_loop)
  253. main_loop->notification(MainLoop::NOTIFICATION_WM_FOCUS_IN);
  254. audio_driver_android.set_pause(false);
  255. }
  256. void OS_Android::process_joy_event(OS_Android::JoypadEvent p_event) {
  257. switch (p_event.type) {
  258. case JOY_EVENT_BUTTON:
  259. input->joy_button(p_event.device, p_event.index, p_event.pressed);
  260. break;
  261. case JOY_EVENT_AXIS:
  262. InputDefault::JoyAxis value;
  263. value.min = -1;
  264. value.value = p_event.value;
  265. input->joy_axis(p_event.device, p_event.index, value);
  266. break;
  267. case JOY_EVENT_HAT:
  268. input->joy_hat(p_event.device, p_event.hat);
  269. break;
  270. default:
  271. return;
  272. }
  273. }
  274. void OS_Android::_set_key_modifier_state(Ref<InputEventWithModifiers> ev) const {
  275. ev->set_shift(shift_mem);
  276. ev->set_alt(alt_mem);
  277. ev->set_metakey(meta_mem);
  278. ev->set_control(control_mem);
  279. }
  280. void OS_Android::process_event(Ref<InputEvent> p_event) {
  281. input->parse_input_event(p_event);
  282. }
  283. void OS_Android::process_key_event(int p_scancode, int p_unicode_char, bool p_pressed) {
  284. Ref<InputEventKey> ev;
  285. ev.instance();
  286. int val = p_unicode_char;
  287. unsigned int scancode = android_get_keysym(p_scancode);
  288. switch (scancode) {
  289. case KEY_SHIFT: {
  290. shift_mem = p_pressed;
  291. } break;
  292. case KEY_ALT: {
  293. alt_mem = p_pressed;
  294. } break;
  295. case KEY_CONTROL: {
  296. control_mem = p_pressed;
  297. } break;
  298. case KEY_META: {
  299. meta_mem = p_pressed;
  300. } break;
  301. }
  302. ev->set_scancode(scancode);
  303. ev->set_unicode(val);
  304. ev->set_pressed(p_pressed);
  305. _set_key_modifier_state(ev);
  306. if (val == '\n') {
  307. ev->set_scancode(KEY_ENTER);
  308. } else if (val == 61448) {
  309. ev->set_scancode(KEY_BACKSPACE);
  310. ev->set_unicode(KEY_BACKSPACE);
  311. } else if (val == 61453) {
  312. ev->set_scancode(KEY_ENTER);
  313. ev->set_unicode(KEY_ENTER);
  314. } else if (p_scancode == 4) {
  315. main_loop_request_go_back();
  316. }
  317. input->parse_input_event(ev);
  318. }
  319. void OS_Android::process_touch(int p_event, int p_pointer, const Vector<TouchPos> &p_points) {
  320. switch (p_event) {
  321. case AMOTION_EVENT_ACTION_DOWN: { //gesture begin
  322. if (touch.size()) {
  323. //end all if exist
  324. for (int i = 0; i < touch.size(); i++) {
  325. Ref<InputEventScreenTouch> ev;
  326. ev.instance();
  327. ev->set_index(touch[i].id);
  328. ev->set_pressed(false);
  329. ev->set_position(touch[i].pos);
  330. input->parse_input_event(ev);
  331. }
  332. }
  333. touch.resize(p_points.size());
  334. for (int i = 0; i < p_points.size(); i++) {
  335. touch.write[i].id = p_points[i].id;
  336. touch.write[i].pos = p_points[i].pos;
  337. }
  338. //send touch
  339. for (int i = 0; i < touch.size(); i++) {
  340. Ref<InputEventScreenTouch> ev;
  341. ev.instance();
  342. ev->set_index(touch[i].id);
  343. ev->set_pressed(true);
  344. ev->set_position(touch[i].pos);
  345. input->parse_input_event(ev);
  346. }
  347. } break;
  348. case AMOTION_EVENT_ACTION_MOVE: { //motion
  349. ERR_FAIL_COND(touch.size() != p_points.size());
  350. for (int i = 0; i < touch.size(); i++) {
  351. int idx = -1;
  352. for (int j = 0; j < p_points.size(); j++) {
  353. if (touch[i].id == p_points[j].id) {
  354. idx = j;
  355. break;
  356. }
  357. }
  358. ERR_CONTINUE(idx == -1);
  359. if (touch[i].pos == p_points[idx].pos)
  360. continue; //no move unncesearily
  361. Ref<InputEventScreenDrag> ev;
  362. ev.instance();
  363. ev->set_index(touch[i].id);
  364. ev->set_position(p_points[idx].pos);
  365. ev->set_relative(p_points[idx].pos - touch[i].pos);
  366. input->parse_input_event(ev);
  367. touch.write[i].pos = p_points[idx].pos;
  368. }
  369. } break;
  370. case AMOTION_EVENT_ACTION_CANCEL:
  371. case AMOTION_EVENT_ACTION_UP: { //release
  372. if (touch.size()) {
  373. //end all if exist
  374. for (int i = 0; i < touch.size(); i++) {
  375. Ref<InputEventScreenTouch> ev;
  376. ev.instance();
  377. ev->set_index(touch[i].id);
  378. ev->set_pressed(false);
  379. ev->set_position(touch[i].pos);
  380. input->parse_input_event(ev);
  381. }
  382. touch.clear();
  383. }
  384. } break;
  385. case AMOTION_EVENT_ACTION_POINTER_DOWN: { // add touch
  386. for (int i = 0; i < p_points.size(); i++) {
  387. if (p_points[i].id == p_pointer) {
  388. TouchPos tp = p_points[i];
  389. touch.push_back(tp);
  390. Ref<InputEventScreenTouch> ev;
  391. ev.instance();
  392. ev->set_index(tp.id);
  393. ev->set_pressed(true);
  394. ev->set_position(tp.pos);
  395. input->parse_input_event(ev);
  396. break;
  397. }
  398. }
  399. } break;
  400. case AMOTION_EVENT_ACTION_POINTER_UP: { // remove touch
  401. for (int i = 0; i < touch.size(); i++) {
  402. if (touch[i].id == p_pointer) {
  403. Ref<InputEventScreenTouch> ev;
  404. ev.instance();
  405. ev->set_index(touch[i].id);
  406. ev->set_pressed(false);
  407. ev->set_position(touch[i].pos);
  408. input->parse_input_event(ev);
  409. touch.remove(i);
  410. break;
  411. }
  412. }
  413. } break;
  414. }
  415. }
  416. void OS_Android::process_hover(int p_type, Point2 p_pos) {
  417. // https://developer.android.com/reference/android/view/MotionEvent.html#ACTION_HOVER_ENTER
  418. switch (p_type) {
  419. case AMOTION_EVENT_ACTION_HOVER_MOVE: // hover move
  420. case AMOTION_EVENT_ACTION_HOVER_ENTER: // hover enter
  421. case AMOTION_EVENT_ACTION_HOVER_EXIT: { // hover exit
  422. Ref<InputEventMouseMotion> ev;
  423. ev.instance();
  424. _set_key_modifier_state(ev);
  425. ev->set_position(p_pos);
  426. ev->set_global_position(p_pos);
  427. ev->set_relative(p_pos - hover_prev_pos);
  428. input->parse_input_event(ev);
  429. hover_prev_pos = p_pos;
  430. } break;
  431. }
  432. }
  433. void OS_Android::process_mouse_event(int event_action, int event_android_buttons_mask, Point2 event_pos, float event_vertical_factor, float event_horizontal_factor) {
  434. int event_buttons_mask = _android_button_mask_to_godot_button_mask(event_android_buttons_mask);
  435. switch (event_action) {
  436. case AMOTION_EVENT_ACTION_BUTTON_PRESS:
  437. case AMOTION_EVENT_ACTION_BUTTON_RELEASE: {
  438. Ref<InputEventMouseButton> ev;
  439. ev.instance();
  440. _set_key_modifier_state(ev);
  441. ev->set_position(event_pos);
  442. ev->set_global_position(event_pos);
  443. ev->set_pressed(event_action == AMOTION_EVENT_ACTION_BUTTON_PRESS);
  444. int changed_button_mask = buttons_state ^ event_buttons_mask;
  445. buttons_state = event_buttons_mask;
  446. ev->set_button_index(_button_index_from_mask(changed_button_mask));
  447. ev->set_button_mask(event_buttons_mask);
  448. input->parse_input_event(ev);
  449. } break;
  450. case AMOTION_EVENT_ACTION_MOVE: {
  451. Ref<InputEventMouseMotion> ev;
  452. ev.instance();
  453. _set_key_modifier_state(ev);
  454. ev->set_position(event_pos);
  455. ev->set_global_position(event_pos);
  456. ev->set_relative(event_pos - hover_prev_pos);
  457. ev->set_button_mask(event_buttons_mask);
  458. input->parse_input_event(ev);
  459. hover_prev_pos = event_pos;
  460. } break;
  461. case AMOTION_EVENT_ACTION_SCROLL: {
  462. Ref<InputEventMouseButton> ev;
  463. ev.instance();
  464. _set_key_modifier_state(ev);
  465. ev->set_position(event_pos);
  466. ev->set_global_position(event_pos);
  467. ev->set_pressed(true);
  468. buttons_state = event_buttons_mask;
  469. if (event_vertical_factor > 0) {
  470. _wheel_button_click(event_buttons_mask, ev, BUTTON_WHEEL_UP, event_vertical_factor);
  471. } else if (event_vertical_factor < 0) {
  472. _wheel_button_click(event_buttons_mask, ev, BUTTON_WHEEL_DOWN, -event_vertical_factor);
  473. }
  474. if (event_horizontal_factor > 0) {
  475. _wheel_button_click(event_buttons_mask, ev, BUTTON_WHEEL_RIGHT, event_horizontal_factor);
  476. } else if (event_horizontal_factor < 0) {
  477. _wheel_button_click(event_buttons_mask, ev, BUTTON_WHEEL_LEFT, -event_horizontal_factor);
  478. }
  479. } break;
  480. }
  481. }
  482. void OS_Android::_wheel_button_click(int event_buttons_mask, const Ref<InputEventMouseButton> &ev, int wheel_button, float factor) {
  483. Ref<InputEventMouseButton> evd = ev->duplicate();
  484. evd->set_button_index(wheel_button);
  485. evd->set_button_mask(event_buttons_mask ^ (1 << (wheel_button - 1)));
  486. evd->set_factor(factor);
  487. input->parse_input_event(evd);
  488. Ref<InputEventMouseButton> evdd = evd->duplicate();
  489. evdd->set_pressed(false);
  490. evdd->set_button_mask(event_buttons_mask);
  491. input->parse_input_event(evdd);
  492. }
  493. void OS_Android::process_double_tap(int event_android_button_mask, Point2 p_pos) {
  494. int event_button_mask = _android_button_mask_to_godot_button_mask(event_android_button_mask);
  495. Ref<InputEventMouseButton> ev;
  496. ev.instance();
  497. _set_key_modifier_state(ev);
  498. ev->set_position(p_pos);
  499. ev->set_global_position(p_pos);
  500. ev->set_pressed(event_button_mask != 0);
  501. ev->set_button_index(_button_index_from_mask(event_button_mask));
  502. ev->set_button_mask(event_button_mask);
  503. ev->set_doubleclick(true);
  504. input->parse_input_event(ev);
  505. }
  506. void OS_Android::process_scroll(Point2 p_pos) {
  507. Ref<InputEventPanGesture> ev;
  508. ev.instance();
  509. _set_key_modifier_state(ev);
  510. ev->set_position(p_pos);
  511. ev->set_delta(p_pos - scroll_prev_pos);
  512. input->parse_input_event(ev);
  513. scroll_prev_pos = p_pos;
  514. }
  515. int OS_Android::_button_index_from_mask(int button_mask) {
  516. switch (button_mask) {
  517. case BUTTON_MASK_LEFT:
  518. return BUTTON_LEFT;
  519. case BUTTON_MASK_RIGHT:
  520. return BUTTON_RIGHT;
  521. case BUTTON_MASK_MIDDLE:
  522. return BUTTON_MIDDLE;
  523. case BUTTON_MASK_XBUTTON1:
  524. return BUTTON_XBUTTON1;
  525. case BUTTON_MASK_XBUTTON2:
  526. return BUTTON_XBUTTON2;
  527. default:
  528. return 0;
  529. }
  530. }
  531. int OS_Android::_android_button_mask_to_godot_button_mask(int android_button_mask) {
  532. int godot_button_mask = 0;
  533. if (android_button_mask & AMOTION_EVENT_BUTTON_PRIMARY) {
  534. godot_button_mask |= BUTTON_MASK_LEFT;
  535. }
  536. if (android_button_mask & AMOTION_EVENT_BUTTON_SECONDARY) {
  537. godot_button_mask |= BUTTON_MASK_RIGHT;
  538. }
  539. if (android_button_mask & AMOTION_EVENT_BUTTON_TERTIARY) {
  540. godot_button_mask |= BUTTON_MASK_MIDDLE;
  541. }
  542. if (android_button_mask & AMOTION_EVENT_BUTTON_BACK) {
  543. godot_button_mask |= BUTTON_MASK_XBUTTON1;
  544. }
  545. if (android_button_mask & AMOTION_EVENT_BUTTON_SECONDARY) {
  546. godot_button_mask |= BUTTON_MASK_XBUTTON2;
  547. }
  548. return godot_button_mask;
  549. }
  550. void OS_Android::process_accelerometer(const Vector3 &p_accelerometer) {
  551. input->set_accelerometer(p_accelerometer);
  552. }
  553. void OS_Android::process_gravity(const Vector3 &p_gravity) {
  554. input->set_gravity(p_gravity);
  555. }
  556. void OS_Android::process_magnetometer(const Vector3 &p_magnetometer) {
  557. input->set_magnetometer(p_magnetometer);
  558. }
  559. void OS_Android::process_gyroscope(const Vector3 &p_gyroscope) {
  560. input->set_gyroscope(p_gyroscope);
  561. }
  562. bool OS_Android::has_touchscreen_ui_hint() const {
  563. return true;
  564. }
  565. bool OS_Android::has_virtual_keyboard() const {
  566. return true;
  567. }
  568. int OS_Android::get_virtual_keyboard_height() const {
  569. return godot_io_java->get_vk_height();
  570. // ERR_PRINT("Cannot obtain virtual keyboard height.");
  571. // return 0;
  572. }
  573. void OS_Android::show_virtual_keyboard(const String &p_existing_text, const Rect2 &p_screen_rect, bool p_multiline, int p_max_input_length, int p_cursor_start, int p_cursor_end) {
  574. if (godot_io_java->has_vk()) {
  575. godot_io_java->show_vk(p_existing_text, p_multiline, p_max_input_length, p_cursor_start, p_cursor_end);
  576. } else {
  577. ERR_PRINT("Virtual keyboard not available");
  578. };
  579. }
  580. void OS_Android::hide_virtual_keyboard() {
  581. if (godot_io_java->has_vk()) {
  582. godot_io_java->hide_vk();
  583. } else {
  584. ERR_PRINT("Virtual keyboard not available");
  585. };
  586. }
  587. void OS_Android::init_video_mode(int p_video_width, int p_video_height) {
  588. default_videomode.width = p_video_width;
  589. default_videomode.height = p_video_height;
  590. default_videomode.fullscreen = true;
  591. default_videomode.resizable = false;
  592. }
  593. void OS_Android::main_loop_request_go_back() {
  594. if (main_loop)
  595. main_loop->notification(MainLoop::NOTIFICATION_WM_GO_BACK_REQUEST);
  596. }
  597. void OS_Android::set_display_size(Size2 p_size) {
  598. default_videomode.width = p_size.x;
  599. default_videomode.height = p_size.y;
  600. }
  601. Error OS_Android::shell_open(String p_uri) {
  602. return godot_io_java->open_uri(p_uri);
  603. }
  604. String OS_Android::get_resource_dir() const {
  605. return "/"; //android has its own filesystem for resources inside the APK
  606. }
  607. String OS_Android::get_locale() const {
  608. String locale = godot_io_java->get_locale();
  609. if (locale != "") {
  610. return locale;
  611. }
  612. return OS_Unix::get_locale();
  613. }
  614. void OS_Android::set_clipboard(const String &p_text) {
  615. // DO we really need the fallback to OS_Unix here?!
  616. if (godot_java->has_set_clipboard()) {
  617. godot_java->set_clipboard(p_text);
  618. } else {
  619. OS_Unix::set_clipboard(p_text);
  620. }
  621. }
  622. String OS_Android::get_clipboard() const {
  623. // DO we really need the fallback to OS_Unix here?!
  624. if (godot_java->has_get_clipboard()) {
  625. return godot_java->get_clipboard();
  626. }
  627. return OS_Unix::get_clipboard();
  628. }
  629. String OS_Android::get_model_name() const {
  630. String model = godot_io_java->get_model();
  631. if (model != "")
  632. return model;
  633. return OS_Unix::get_model_name();
  634. }
  635. int OS_Android::get_screen_dpi(int p_screen) const {
  636. return godot_io_java->get_screen_dpi();
  637. }
  638. String OS_Android::get_user_data_dir() const {
  639. if (data_dir_cache != String())
  640. return data_dir_cache;
  641. String data_dir = godot_io_java->get_user_data_dir();
  642. if (data_dir != "") {
  643. //store current dir
  644. char real_current_dir_name[2048];
  645. getcwd(real_current_dir_name, 2048);
  646. //go to data dir
  647. chdir(data_dir.utf8().get_data());
  648. //get actual data dir, so we resolve potential symlink (Android 6.0+ seems to use symlink)
  649. char data_current_dir_name[2048];
  650. getcwd(data_current_dir_name, 2048);
  651. //cache by parsing utf8
  652. data_dir_cache.parse_utf8(data_current_dir_name);
  653. //restore original dir so we don't mess things up
  654. chdir(real_current_dir_name);
  655. return data_dir_cache;
  656. }
  657. return ".";
  658. }
  659. void OS_Android::set_screen_orientation(ScreenOrientation p_orientation) {
  660. godot_io_java->set_screen_orientation(p_orientation);
  661. }
  662. OS::ScreenOrientation OS_Android::get_screen_orientation() const {
  663. const int orientation = godot_io_java->get_screen_orientation();
  664. return OS::ScreenOrientation(orientation);
  665. }
  666. String OS_Android::get_unique_id() const {
  667. String unique_id = godot_io_java->get_unique_id();
  668. if (unique_id != "")
  669. return unique_id;
  670. return OS::get_unique_id();
  671. }
  672. Error OS_Android::native_video_play(String p_path, float p_volume, String p_audio_track, String p_subtitle_track) {
  673. // FIXME: Add support for volume, audio and subtitle tracks
  674. godot_io_java->play_video(p_path);
  675. return OK;
  676. }
  677. bool OS_Android::native_video_is_playing() const {
  678. return godot_io_java->is_video_playing();
  679. }
  680. void OS_Android::native_video_pause() {
  681. godot_io_java->pause_video();
  682. }
  683. String OS_Android::get_system_dir(SystemDir p_dir) const {
  684. return godot_io_java->get_system_dir(p_dir);
  685. }
  686. void OS_Android::native_video_stop() {
  687. godot_io_java->stop_video();
  688. }
  689. void OS_Android::set_context_is_16_bits(bool p_is_16) {
  690. //use_16bits_fbo = p_is_16;
  691. //if (rasterizer)
  692. // rasterizer->set_force_16_bits_fbo(p_is_16);
  693. }
  694. void OS_Android::joy_connection_changed(int p_device, bool p_connected, String p_name) {
  695. return input->joy_connection_changed(p_device, p_connected, p_name, "");
  696. }
  697. bool OS_Android::is_joy_known(int p_device) {
  698. return input->is_joy_mapped(p_device);
  699. }
  700. String OS_Android::get_joy_guid(int p_device) const {
  701. return input->get_joy_guid_remapped(p_device);
  702. }
  703. void OS_Android::vibrate_handheld(int p_duration_ms) {
  704. godot_java->vibrate(p_duration_ms);
  705. }
  706. bool OS_Android::_check_internal_feature_support(const String &p_feature) {
  707. if (p_feature == "mobile") {
  708. //TODO support etc2 only if GLES3 driver is selected
  709. return true;
  710. }
  711. #if defined(__aarch64__)
  712. if (p_feature == "arm64-v8a") {
  713. return true;
  714. }
  715. #elif defined(__ARM_ARCH_7A__)
  716. if (p_feature == "armeabi-v7a" || p_feature == "armeabi") {
  717. return true;
  718. }
  719. #elif defined(__arm__)
  720. if (p_feature == "armeabi") {
  721. return true;
  722. }
  723. #endif
  724. return false;
  725. }
  726. OS_Android::OS_Android(GodotJavaWrapper *p_godot_java, GodotIOJavaWrapper *p_godot_io_java, bool p_use_apk_expansion) {
  727. use_apk_expansion = p_use_apk_expansion;
  728. default_videomode.width = 800;
  729. default_videomode.height = 600;
  730. default_videomode.fullscreen = true;
  731. default_videomode.resizable = false;
  732. buttons_state = 0;
  733. main_loop = NULL;
  734. gl_extensions = NULL;
  735. //rasterizer = NULL;
  736. use_gl2 = false;
  737. godot_java = p_godot_java;
  738. godot_io_java = p_godot_io_java;
  739. Vector<Logger *> loggers;
  740. loggers.push_back(memnew(AndroidLogger));
  741. _set_logger(memnew(CompositeLogger(loggers)));
  742. AudioDriverManager::add_driver(&audio_driver_android);
  743. }
  744. OS_Android::~OS_Android() {
  745. }