java_glue.cpp 43 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611
  1. /*************************************************************************/
  2. /* java_glue.cpp */
  3. /*************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* http://www.godotengine.org */
  7. /*************************************************************************/
  8. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  9. /* */
  10. /* Permission is hereby granted, free of charge, to any person obtaining */
  11. /* a copy of this software and associated documentation files (the */
  12. /* "Software"), to deal in the Software without restriction, including */
  13. /* without limitation the rights to use, copy, modify, merge, publish, */
  14. /* distribute, sublicense, and/or sell copies of the Software, and to */
  15. /* permit persons to whom the Software is furnished to do so, subject to */
  16. /* the following conditions: */
  17. /* */
  18. /* The above copyright notice and this permission notice shall be */
  19. /* included in all copies or substantial portions of the Software. */
  20. /* */
  21. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  22. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  23. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
  24. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  25. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  26. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  27. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  28. /*************************************************************************/
  29. #ifndef ANDROID_NATIVE_ACTIVITY
  30. #include "java_glue.h"
  31. #include "os_android.h"
  32. #include "main/main.h"
  33. #include <unistd.h>
  34. #include "file_access_jandroid.h"
  35. #include "dir_access_jandroid.h"
  36. #include "audio_driver_jandroid.h"
  37. #include "globals.h"
  38. #include "thread_jandroid.h"
  39. #include "core/os/keyboard.h"
  40. #include "java_class_wrapper.h"
  41. static JavaClassWrapper *java_class_wrapper=NULL;
  42. static OS_Android *os_android=NULL;
  43. jvalue _variant_to_jvalue(JNIEnv *env, Variant::Type p_type, const Variant* p_arg, bool force_jobject = false) {
  44. jvalue v;
  45. switch(p_type) {
  46. case Variant::BOOL: {
  47. if (force_jobject) {
  48. jclass bclass = env->FindClass("java/lang/Boolean");
  49. jmethodID ctor = env->GetMethodID(bclass, "<init>", "(Z)V");
  50. jvalue val;
  51. val.z = (bool)(*p_arg);
  52. jobject obj = env->NewObjectA(bclass, ctor, &val);
  53. v.l = obj;
  54. } else {
  55. v.z=*p_arg;
  56. };
  57. } break;
  58. case Variant::INT: {
  59. if (force_jobject) {
  60. jclass bclass = env->FindClass("java/lang/Integer");
  61. jmethodID ctor = env->GetMethodID(bclass, "<init>", "(I)V");
  62. jvalue val;
  63. val.i = (int)(*p_arg);
  64. jobject obj = env->NewObjectA(bclass, ctor, &val);
  65. v.l = obj;
  66. } else {
  67. v.i=*p_arg;
  68. };
  69. } break;
  70. case Variant::REAL: {
  71. if (force_jobject) {
  72. jclass bclass = env->FindClass("java/lang/Double");
  73. jmethodID ctor = env->GetMethodID(bclass, "<init>", "(D)V");
  74. jvalue val;
  75. val.d = (double)(*p_arg);
  76. jobject obj = env->NewObjectA(bclass, ctor, &val);
  77. v.l = obj;
  78. } else {
  79. v.f=*p_arg;
  80. };
  81. } break;
  82. case Variant::STRING: {
  83. String s = *p_arg;
  84. jstring jStr = env->NewStringUTF(s.utf8().get_data());
  85. v.l=jStr;
  86. } break;
  87. case Variant::STRING_ARRAY: {
  88. DVector<String> sarray = *p_arg;
  89. jobjectArray arr = env->NewObjectArray(sarray.size(),env->FindClass("java/lang/String"),env->NewStringUTF(""));
  90. for(int j=0;j<sarray.size();j++) {
  91. env->SetObjectArrayElement(arr,j,env->NewStringUTF( sarray[j].utf8().get_data() ));
  92. }
  93. v.l=arr;
  94. } break;
  95. case Variant::DICTIONARY: {
  96. Dictionary dict = *p_arg;
  97. jclass dclass = env->FindClass("com/android/godot/Dictionary");
  98. jmethodID ctor = env->GetMethodID(dclass, "<init>", "()V");
  99. jobject jdict = env->NewObject(dclass, ctor);
  100. Array keys = dict.keys();
  101. jobjectArray jkeys = env->NewObjectArray(keys.size(), env->FindClass("java/lang/String"), env->NewStringUTF(""));
  102. for (int j=0; j<keys.size(); j++) {
  103. env->SetObjectArrayElement(jkeys, j, env->NewStringUTF(String(keys[j]).utf8().get_data()));
  104. };
  105. jmethodID set_keys = env->GetMethodID(dclass, "set_keys", "([Ljava/lang/String;)V");
  106. jvalue val;
  107. val.l = jkeys;
  108. env->CallVoidMethodA(jdict, set_keys, &val);
  109. jobjectArray jvalues = env->NewObjectArray(keys.size(), env->FindClass("java/lang/Object"), NULL);
  110. for (int j=0; j<keys.size(); j++) {
  111. Variant var = dict[keys[j]];
  112. val = _variant_to_jvalue(env, var.get_type(), &var, true);
  113. env->SetObjectArrayElement(jvalues, j, val.l);
  114. };
  115. jmethodID set_values = env->GetMethodID(dclass, "set_values", "([Ljava/lang/Object;)V");
  116. val.l = jvalues;
  117. env->CallVoidMethodA(jdict, set_values, &val);
  118. v.l = jdict;
  119. } break;
  120. case Variant::INT_ARRAY: {
  121. DVector<int> array = *p_arg;
  122. jintArray arr = env->NewIntArray(array.size());
  123. DVector<int>::Read r = array.read();
  124. env->SetIntArrayRegion(arr,0,array.size(),r.ptr());
  125. v.l=arr;
  126. } break;
  127. case Variant::RAW_ARRAY: {
  128. DVector<uint8_t> array = *p_arg;
  129. jbyteArray arr = env->NewByteArray(array.size());
  130. DVector<uint8_t>::Read r = array.read();
  131. env->SetByteArrayRegion(arr,0,array.size(),reinterpret_cast<const signed char*>(r.ptr()));
  132. v.l=arr;
  133. } break;
  134. case Variant::REAL_ARRAY: {
  135. DVector<float> array = *p_arg;
  136. jfloatArray arr = env->NewFloatArray(array.size());
  137. DVector<float>::Read r = array.read();
  138. env->SetFloatArrayRegion(arr,0,array.size(),r.ptr());
  139. v.l=arr;
  140. } break;
  141. default: {
  142. v.i = 0;
  143. } break;
  144. }
  145. return v;
  146. };
  147. String _get_class_name(JNIEnv * env, jclass cls, bool* array) {
  148. jclass cclass = env->FindClass("java/lang/Class");
  149. jmethodID getName = env->GetMethodID(cclass, "getName", "()Ljava/lang/String;");
  150. jstring clsName=(jstring) env->CallObjectMethod(cls, getName);
  151. if (array) {
  152. jmethodID isArray = env->GetMethodID(cclass, "isArray", "()Z");
  153. jboolean isarr = env->CallBooleanMethod(cls, isArray);
  154. (*array) = isarr ? true : false;
  155. }
  156. return env->GetStringUTFChars( clsName, NULL );
  157. };
  158. Variant _jobject_to_variant(JNIEnv * env, jobject obj) {
  159. jclass c = env->GetObjectClass(obj);
  160. bool array;
  161. String name = _get_class_name(env, c, &array);
  162. //print_line("name is " + name + ", array "+Variant(array));
  163. print_line("ARGNAME: "+name);
  164. if (name == "java.lang.String") {
  165. return String::utf8(env->GetStringUTFChars( (jstring)obj, NULL ));
  166. };
  167. if (name == "[Ljava.lang.String;") {
  168. jobjectArray arr = (jobjectArray)obj;
  169. int stringCount = env->GetArrayLength(arr);
  170. //print_line("String array! " + String::num(stringCount));
  171. DVector<String> sarr;
  172. for (int i=0; i<stringCount; i++) {
  173. jstring string = (jstring) env->GetObjectArrayElement(arr, i);
  174. const char *rawString = env->GetStringUTFChars(string, 0);
  175. sarr.push_back(String(rawString));
  176. }
  177. return sarr;
  178. };
  179. if (name == "java.lang.Boolean") {
  180. jmethodID boolValue = env->GetMethodID(c, "booleanValue", "()Z");
  181. bool ret = env->CallBooleanMethod(obj, boolValue);
  182. return ret;
  183. };
  184. if (name == "java.lang.Integer") {
  185. jclass nclass = env->FindClass("java/lang/Number");
  186. jmethodID intValue = env->GetMethodID(nclass, "intValue", "()I");
  187. int ret = env->CallIntMethod(obj, intValue);
  188. return ret;
  189. };
  190. if (name == "[I") {
  191. jintArray arr = (jintArray)obj;
  192. int fCount = env->GetArrayLength(arr);
  193. DVector<int> sarr;
  194. sarr.resize(fCount);
  195. DVector<int>::Write w = sarr.write();
  196. env->GetIntArrayRegion(arr,0,fCount,w.ptr());
  197. w = DVector<int>::Write();
  198. return sarr;
  199. };
  200. if (name == "[B") {
  201. jbyteArray arr = (jbyteArray)obj;
  202. int fCount = env->GetArrayLength(arr);
  203. DVector<uint8_t> sarr;
  204. sarr.resize(fCount);
  205. DVector<uint8_t>::Write w = sarr.write();
  206. env->GetByteArrayRegion(arr,0,fCount,reinterpret_cast<signed char*>(w.ptr()));
  207. w = DVector<uint8_t>::Write();
  208. return sarr;
  209. };
  210. if (name == "java.lang.Float" || name == "java.lang.Double") {
  211. jclass nclass = env->FindClass("java/lang/Number");
  212. jmethodID doubleValue = env->GetMethodID(nclass, "doubleValue", "()D");
  213. double ret = env->CallDoubleMethod(obj, doubleValue);
  214. return ret;
  215. };
  216. if (name == "[D") {
  217. jdoubleArray arr = (jdoubleArray)obj;
  218. int fCount = env->GetArrayLength(arr);
  219. RealArray sarr;
  220. sarr.resize(fCount);
  221. RealArray::Write w = sarr.write();
  222. for (int i=0; i<fCount; i++) {
  223. double n;
  224. env->GetDoubleArrayRegion(arr, i, 1, &n);
  225. w.ptr()[i] = n;
  226. };
  227. return sarr;
  228. };
  229. if (name == "[F") {
  230. jfloatArray arr = (jfloatArray)obj;
  231. int fCount = env->GetArrayLength(arr);
  232. RealArray sarr;
  233. sarr.resize(fCount);
  234. RealArray::Write w = sarr.write();
  235. for (int i=0; i<fCount; i++) {
  236. float n;
  237. env->GetFloatArrayRegion(arr, i, 1, &n);
  238. w.ptr()[i] = n;
  239. };
  240. return sarr;
  241. };
  242. if (name == "[Ljava.lang.Object;") {
  243. jobjectArray arr = (jobjectArray)obj;
  244. int objCount = env->GetArrayLength(arr);
  245. Array varr;
  246. for (int i=0; i<objCount; i++) {
  247. jobject jobj = env->GetObjectArrayElement(arr, i);
  248. Variant v = _jobject_to_variant(env, jobj);
  249. varr.push_back(v);
  250. }
  251. return varr;
  252. };
  253. if (name == "com.android.godot.Dictionary") {
  254. Dictionary ret;
  255. jclass oclass = c;
  256. jmethodID get_keys = env->GetMethodID(oclass, "get_keys", "()[Ljava/lang/String;");
  257. jobjectArray arr = (jobjectArray)env->CallObjectMethod(obj, get_keys);
  258. StringArray keys = _jobject_to_variant(env, arr);
  259. jmethodID get_values = env->GetMethodID(oclass, "get_values", "()[Ljava/lang/Object;");
  260. arr = (jobjectArray)env->CallObjectMethod(obj, get_values);
  261. Array vals = _jobject_to_variant(env, arr);
  262. //print_line("adding " + String::num(keys.size()) + " to Dictionary!");
  263. for (int i=0; i<keys.size(); i++) {
  264. ret[keys[i]] = vals[i];
  265. };
  266. return ret;
  267. };
  268. return Variant();
  269. };
  270. class JNISingleton : public Object {
  271. OBJ_TYPE( JNISingleton, Object );
  272. struct MethodData {
  273. jmethodID method;
  274. Variant::Type ret_type;
  275. Vector<Variant::Type> argtypes;
  276. };
  277. jobject instance;
  278. Map<StringName,MethodData> method_map;
  279. public:
  280. virtual Variant call(const StringName& p_method,const Variant** p_args,int p_argcount,Variant::CallError &r_error) {
  281. //print_line("attempt to call "+String(p_method));
  282. ERR_FAIL_COND_V(!instance,Variant());
  283. r_error.error=Variant::CallError::CALL_OK;
  284. Map<StringName,MethodData >::Element *E=method_map.find(p_method);
  285. if (!E) {
  286. print_line("no exists");
  287. r_error.error=Variant::CallError::CALL_ERROR_INVALID_METHOD;
  288. return Variant();
  289. }
  290. int ac = E->get().argtypes.size();
  291. if (ac<p_argcount) {
  292. print_line("fewargs");
  293. r_error.error=Variant::CallError::CALL_ERROR_TOO_FEW_ARGUMENTS;
  294. r_error.argument=ac;
  295. return Variant();
  296. }
  297. if (ac>p_argcount) {
  298. print_line("manyargs");
  299. r_error.error=Variant::CallError::CALL_ERROR_TOO_MANY_ARGUMENTS;
  300. r_error.argument=ac;
  301. return Variant();
  302. }
  303. for(int i=0;i<p_argcount;i++) {
  304. if (!Variant::can_convert(p_args[i]->get_type(),E->get().argtypes[i])) {
  305. r_error.error=Variant::CallError::CALL_ERROR_INVALID_ARGUMENT;
  306. r_error.argument=i;
  307. r_error.expected=E->get().argtypes[i];
  308. }
  309. }
  310. jvalue *v=NULL;
  311. if (p_argcount) {
  312. v=(jvalue*)alloca( sizeof(jvalue)*p_argcount );
  313. }
  314. JNIEnv *env = ThreadAndroid::get_env();
  315. //print_line("argcount "+String::num(p_argcount));
  316. for(int i=0;i<p_argcount;i++) {
  317. v[i] = _variant_to_jvalue(env, E->get().argtypes[i], p_args[i]);
  318. }
  319. //print_line("calling method!!");
  320. Variant ret;
  321. switch(E->get().ret_type) {
  322. case Variant::NIL: {
  323. //print_line("call void");
  324. env->CallVoidMethodA(instance,E->get().method,v);
  325. } break;
  326. case Variant::BOOL: {
  327. ret = env->CallBooleanMethodA(instance,E->get().method,v);
  328. //print_line("call bool");
  329. } break;
  330. case Variant::INT: {
  331. ret = env->CallIntMethodA(instance,E->get().method,v);
  332. //print_line("call int");
  333. } break;
  334. case Variant::REAL: {
  335. ret = env->CallFloatMethodA(instance,E->get().method,v);
  336. } break;
  337. case Variant::STRING: {
  338. jobject o = env->CallObjectMethodA(instance,E->get().method,v);
  339. String str = env->GetStringUTFChars((jstring)o, NULL );
  340. ret=str;
  341. } break;
  342. case Variant::STRING_ARRAY: {
  343. jobjectArray arr = (jobjectArray)env->CallObjectMethodA(instance,E->get().method,v);
  344. ret = _jobject_to_variant(env, arr);
  345. } break;
  346. case Variant::INT_ARRAY: {
  347. jintArray arr = (jintArray)env->CallObjectMethodA(instance,E->get().method,v);
  348. int fCount = env->GetArrayLength(arr);
  349. DVector<int> sarr;
  350. sarr.resize(fCount);
  351. DVector<int>::Write w = sarr.write();
  352. env->GetIntArrayRegion(arr,0,fCount,w.ptr());
  353. w = DVector<int>::Write();
  354. ret=sarr;
  355. } break;
  356. case Variant::REAL_ARRAY: {
  357. jfloatArray arr = (jfloatArray)env->CallObjectMethodA(instance,E->get().method,v);
  358. int fCount = env->GetArrayLength(arr);
  359. DVector<float> sarr;
  360. sarr.resize(fCount);
  361. DVector<float>::Write w = sarr.write();
  362. env->GetFloatArrayRegion(arr,0,fCount,w.ptr());
  363. w = DVector<float>::Write();
  364. ret=sarr;
  365. } break;
  366. case Variant::DICTIONARY: {
  367. //print_line("call dictionary");
  368. jobject obj = env->CallObjectMethodA(instance, E->get().method, v);
  369. ret = _jobject_to_variant(env, obj);
  370. } break;
  371. default: {
  372. print_line("failure..");
  373. ERR_FAIL_V(Variant());
  374. } break;
  375. }
  376. //print_line("success");
  377. return ret;
  378. }
  379. jobject get_instance() const {
  380. return instance;
  381. }
  382. void set_instance(jobject p_instance) {
  383. instance=p_instance;
  384. }
  385. void add_method(const StringName& p_name, jmethodID p_method,const Vector<Variant::Type>& p_args, Variant::Type p_ret_type) {
  386. MethodData md;
  387. md.method=p_method;
  388. md.argtypes=p_args;
  389. md.ret_type=p_ret_type;
  390. method_map[p_name]=md;
  391. }
  392. JNISingleton() {
  393. instance=NULL;
  394. }
  395. };
  396. struct TST {
  397. int a;
  398. TST() {
  399. a=5;
  400. }
  401. };
  402. TST tst;
  403. struct JAndroidPointerEvent {
  404. Vector<OS_Android::TouchPos> points;
  405. int pointer;
  406. int what;
  407. };
  408. static List<JAndroidPointerEvent> pointer_events;
  409. static List<InputEvent> key_events;
  410. static bool initialized=false;
  411. static Mutex *input_mutex=NULL;
  412. static Mutex *suspend_mutex=NULL;
  413. static int step=0;
  414. static bool resized=false;
  415. static bool resized_reload=false;
  416. static bool quit_request=false;
  417. static Size2 new_size;
  418. static Vector3 accelerometer;
  419. static HashMap<String,JNISingleton*> jni_singletons;
  420. static jobject godot_io;
  421. static Vector<int> joy_device_ids;
  422. typedef void (*GFXInitFunc)(void *ud,bool gl2);
  423. static jmethodID _on_video_init=0;
  424. static jobject _godot_instance;
  425. static jmethodID _openURI=0;
  426. static jmethodID _getDataDir=0;
  427. static jmethodID _getLocale=0;
  428. static jmethodID _getModel=0;
  429. static jmethodID _showKeyboard=0;
  430. static jmethodID _hideKeyboard=0;
  431. static jmethodID _setScreenOrientation=0;
  432. static jmethodID _getUniqueID=0;
  433. static jmethodID _getSystemDir=0;
  434. static jmethodID _playVideo=0;
  435. static jmethodID _isVideoPlaying=0;
  436. static jmethodID _pauseVideo=0;
  437. static jmethodID _stopVideo=0;
  438. static void _gfx_init_func(void* ud, bool gl2) {
  439. }
  440. static int _open_uri(const String& p_uri) {
  441. JNIEnv *env = ThreadAndroid::get_env();
  442. jstring jStr = env->NewStringUTF(p_uri.utf8().get_data());
  443. return env->CallIntMethod(godot_io,_openURI,jStr) ;
  444. }
  445. static String _get_data_dir() {
  446. JNIEnv *env = ThreadAndroid::get_env();
  447. jstring s =(jstring)env->CallObjectMethod(godot_io,_getDataDir);
  448. return String(env->GetStringUTFChars( s, NULL ));
  449. }
  450. static String _get_locale() {
  451. JNIEnv *env = ThreadAndroid::get_env();
  452. jstring s =(jstring)env->CallObjectMethod(godot_io,_getLocale);
  453. return String(env->GetStringUTFChars( s, NULL ));
  454. }
  455. static String _get_model() {
  456. JNIEnv *env = ThreadAndroid::get_env();
  457. jstring s =(jstring)env->CallObjectMethod(godot_io,_getModel);
  458. return String(env->GetStringUTFChars( s, NULL ));
  459. }
  460. static String _get_unique_id() {
  461. JNIEnv *env = ThreadAndroid::get_env();
  462. jstring s =(jstring)env->CallObjectMethod(godot_io,_getUniqueID);
  463. return String(env->GetStringUTFChars( s, NULL ));
  464. }
  465. static void _show_vk(const String& p_existing) {
  466. JNIEnv* env = ThreadAndroid::get_env();
  467. jstring jStr = env->NewStringUTF(p_existing.utf8().get_data());
  468. env->CallVoidMethod(godot_io, _showKeyboard, jStr);
  469. };
  470. static void _set_screen_orient(int p_orient) {
  471. JNIEnv* env = ThreadAndroid::get_env();
  472. env->CallVoidMethod(godot_io, _setScreenOrientation, p_orient );
  473. };
  474. static String _get_system_dir(int p_dir) {
  475. JNIEnv *env = ThreadAndroid::get_env();
  476. jstring s =(jstring)env->CallObjectMethod(godot_io,_getSystemDir,p_dir);
  477. return String(env->GetStringUTFChars( s, NULL ));
  478. };
  479. static void _hide_vk() {
  480. JNIEnv* env = ThreadAndroid::get_env();
  481. env->CallVoidMethod(godot_io, _hideKeyboard);
  482. };
  483. // virtual Error native_video_play(String p_path);
  484. // virtual bool native_video_is_playing();
  485. // virtual void native_video_pause();
  486. // virtual void native_video_stop();
  487. static void _play_video(const String& p_path) {
  488. }
  489. static bool _is_video_playing() {
  490. JNIEnv* env = ThreadAndroid::get_env();
  491. return env->CallBooleanMethod(godot_io, _isVideoPlaying);
  492. //return false;
  493. }
  494. static void _pause_video() {
  495. JNIEnv* env = ThreadAndroid::get_env();
  496. env->CallVoidMethod(godot_io, _pauseVideo);
  497. }
  498. static void _stop_video() {
  499. JNIEnv* env = ThreadAndroid::get_env();
  500. env->CallVoidMethod(godot_io, _stopVideo);
  501. }
  502. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_initialize(JNIEnv * env, jobject obj, jobject activity,jboolean p_need_reload_hook, jobjectArray p_cmdline) {
  503. __android_log_print(ANDROID_LOG_INFO,"godot","**INIT EVENT! - %p\n",env);
  504. initialized=true;
  505. JavaVM *jvm;
  506. env->GetJavaVM(&jvm);
  507. _godot_instance=env->NewGlobalRef(activity);
  508. // _godot_instance=activity;
  509. __android_log_print(ANDROID_LOG_INFO,"godot","***************** HELLO FROM JNI!!!!!!!!");
  510. {
  511. //setup IO Object
  512. jclass cls = env->FindClass("com/android/godot/Godot");
  513. if (cls) {
  514. cls=(jclass)env->NewGlobalRef(cls);
  515. __android_log_print(ANDROID_LOG_INFO,"godot","*******CLASS FOUND!!!");
  516. }
  517. __android_log_print(ANDROID_LOG_INFO,"godot","STEP2, %p",cls);
  518. jfieldID fid = env->GetStaticFieldID(cls, "io", "Lcom/android/godot/GodotIO;");
  519. __android_log_print(ANDROID_LOG_INFO,"godot","STEP3 %i",fid);
  520. jobject ob = env->GetStaticObjectField(cls,fid);
  521. __android_log_print(ANDROID_LOG_INFO,"godot","STEP4, %p",ob);
  522. jobject gob = env->NewGlobalRef(ob);
  523. __android_log_print(ANDROID_LOG_INFO,"godot","STEP4.5, %p",gob);
  524. godot_io=gob;
  525. _on_video_init = env->GetMethodID(cls, "onVideoInit", "(Z)V");
  526. jclass clsio = env->FindClass("com/android/godot/Godot");
  527. if (cls) {
  528. jclass c = env->GetObjectClass(gob);
  529. _openURI = env->GetMethodID(c,"openURI","(Ljava/lang/String;)I");
  530. _getDataDir = env->GetMethodID(c,"getDataDir","()Ljava/lang/String;");
  531. _getLocale = env->GetMethodID(c,"getLocale","()Ljava/lang/String;");
  532. _getModel = env->GetMethodID(c,"getModel","()Ljava/lang/String;");
  533. _getUniqueID = env->GetMethodID(c,"getUniqueID","()Ljava/lang/String;");
  534. _showKeyboard = env->GetMethodID(c,"showKeyboard","(Ljava/lang/String;)V");
  535. _hideKeyboard = env->GetMethodID(c,"hideKeyboard","()V");
  536. _setScreenOrientation = env->GetMethodID(c,"setScreenOrientation","(I)V");
  537. _getSystemDir = env->GetMethodID(c,"getSystemDir","(I)Ljava/lang/String;");
  538. _playVideo = env->GetMethodID(c,"playVideo","(Ljava/lang/String;)V");
  539. _isVideoPlaying = env->GetMethodID(c,"isVideoPlaying","()Z");
  540. _pauseVideo = env->GetMethodID(c,"pauseVideo","()V");
  541. _stopVideo = env->GetMethodID(c,"stopVideo","()V");
  542. }
  543. ThreadAndroid::make_default(jvm);
  544. FileAccessJAndroid::setup(gob);
  545. DirAccessJAndroid::setup(gob);
  546. AudioDriverAndroid::setup(gob);
  547. }
  548. const char ** cmdline=NULL;
  549. int cmdlen=0;
  550. bool use_apk_expansion=false;
  551. if (p_cmdline) {
  552. cmdlen = env->GetArrayLength(p_cmdline);
  553. if (cmdlen) {
  554. cmdline = (const char**)malloc((env->GetArrayLength(p_cmdline)+1)*sizeof(const char*));
  555. cmdline[cmdlen]=NULL;
  556. for (int i=0; i<cmdlen; i++) {
  557. jstring string = (jstring) env->GetObjectArrayElement(p_cmdline, i);
  558. const char *rawString = env->GetStringUTFChars(string, 0);
  559. if (!rawString) {
  560. __android_log_print(ANDROID_LOG_INFO,"godot","cmdline arg %i is null\n",i);
  561. } else {
  562. // __android_log_print(ANDROID_LOG_INFO,"godot","cmdline arg %i is: %s\n",i,rawString);
  563. if (strcmp(rawString,"-main_pack")==0)
  564. use_apk_expansion=true;
  565. }
  566. cmdline[i]=rawString;
  567. }
  568. }
  569. }
  570. __android_log_print(ANDROID_LOG_INFO,"godot","CMDLINE LEN %i - APK EXPANSION %I\n",cmdlen,int(use_apk_expansion));
  571. os_android = new OS_Android(_gfx_init_func,env,_open_uri,_get_data_dir,_get_locale, _get_model,_show_vk, _hide_vk,_set_screen_orient,_get_unique_id, _get_system_dir, _play_video,_is_video_playing, _pause_video, _stop_video,use_apk_expansion);
  572. os_android->set_need_reload_hooks(p_need_reload_hook);
  573. char wd[500];
  574. getcwd(wd,500);
  575. __android_log_print(ANDROID_LOG_INFO,"godot","test construction %i\n",tst.a);
  576. __android_log_print(ANDROID_LOG_INFO,"godot","running from dir %s\n",wd);
  577. __android_log_print(ANDROID_LOG_INFO,"godot","**SETUP");
  578. #if 0
  579. char *args[]={"-test","render",NULL};
  580. __android_log_print(ANDROID_LOG_INFO,"godot","pre asdasd setup...");
  581. Error err = Main::setup("apk",2,args,false);
  582. #else
  583. Error err = Main::setup("apk",cmdlen,(char**)cmdline,false);
  584. #endif
  585. if (err!=OK) {
  586. __android_log_print(ANDROID_LOG_INFO,"godot","*****UNABLE TO SETUP");
  587. return; //should exit instead and print the error
  588. }
  589. __android_log_print(ANDROID_LOG_INFO,"godot","*****SETUP OK");
  590. //video driver is determined here, because once initialized, it cant be changed
  591. String vd = Globals::get_singleton()->get("display/driver");
  592. env->CallVoidMethod(_godot_instance, _on_video_init, (jboolean)true);
  593. __android_log_print(ANDROID_LOG_INFO,"godot","**START");
  594. input_mutex=Mutex::create();
  595. suspend_mutex=Mutex::create();
  596. }
  597. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_resize(JNIEnv * env, jobject obj, jint width, jint height, jboolean reload) {
  598. __android_log_print(ANDROID_LOG_INFO,"godot","^_^_^_^_^ resize %lld, %i, %i\n",Thread::get_caller_ID(),width,height);
  599. if (os_android)
  600. os_android->set_display_size(Size2(width,height));
  601. /*input_mutex->lock();
  602. resized=true;
  603. if (reload)
  604. resized_reload=true;
  605. new_size=Size2(width,height);
  606. input_mutex->unlock();*/
  607. }
  608. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_newcontext(JNIEnv * env, jobject obj) {
  609. __android_log_print(ANDROID_LOG_INFO,"godot","^_^_^_^_^ newcontext %lld\n",Thread::get_caller_ID());
  610. if (os_android && step > 0) {
  611. os_android->reload_gfx();
  612. }
  613. }
  614. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_quit(JNIEnv * env, jobject obj) {
  615. input_mutex->lock();
  616. quit_request=true;
  617. print_line("BACK PRESSED");
  618. input_mutex->unlock();
  619. }
  620. static void _initialize_java_modules() {
  621. String modules = Globals::get_singleton()->get("android/modules");
  622. Vector<String> mods = modules.split(",",false);
  623. __android_log_print(ANDROID_LOG_INFO,"godot","mod count: %i",mods.size());
  624. if (mods.size()) {
  625. JNIEnv *env = ThreadAndroid::get_env();
  626. jclass activityClass = env->FindClass("com/android/godot/Godot");
  627. jmethodID getClassLoader = env->GetMethodID(activityClass,"getClassLoader", "()Ljava/lang/ClassLoader;");
  628. jobject cls = env->CallObjectMethod(_godot_instance, getClassLoader);
  629. //cls=env->NewGlobalRef(cls);
  630. jclass classLoader = env->FindClass("java/lang/ClassLoader");
  631. //classLoader=(jclass)env->NewGlobalRef(classLoader);
  632. jmethodID findClass = env->GetMethodID(classLoader, "loadClass", "(Ljava/lang/String;)Ljava/lang/Class;");
  633. for (int i=0;i<mods.size();i++) {
  634. String m = mods[i];
  635. //jclass singletonClass = env->FindClass(m.utf8().get_data());
  636. print_line("LOADING MODULE: "+m);
  637. jstring strClassName = env->NewStringUTF(m.utf8().get_data());
  638. jclass singletonClass = (jclass)env->CallObjectMethod(cls, findClass, strClassName);
  639. if (!singletonClass) {
  640. ERR_EXPLAIN("Couldn't find singleton for class: "+m);
  641. ERR_CONTINUE(!singletonClass);
  642. }
  643. //singletonClass=(jclass)env->NewGlobalRef(singletonClass);
  644. __android_log_print(ANDROID_LOG_INFO,"godot","****^*^*?^*^*class data %x",singletonClass);
  645. jmethodID initialize = env->GetStaticMethodID(singletonClass, "initialize", "(Landroid/app/Activity;)Lcom/android/godot/Godot$SingletonBase;");
  646. if (!initialize) {
  647. ERR_EXPLAIN("Couldn't find proper initialize function 'public static Godot.SingletonBase Class::initialize(Activity p_activity)' initializer for singleton class: "+m);
  648. ERR_CONTINUE(!initialize);
  649. }
  650. jobject obj = env->CallStaticObjectMethod(singletonClass,initialize,_godot_instance);
  651. __android_log_print(ANDROID_LOG_INFO,"godot","****^*^*?^*^*class instance %x",obj);
  652. jobject gob = env->NewGlobalRef(obj);
  653. }
  654. }
  655. }
  656. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_step(JNIEnv * env, jobject obj)
  657. {
  658. ThreadAndroid::setup_thread();
  659. //__android_log_print(ANDROID_LOG_INFO,"godot","**STEP EVENT! - %p-%i\n",env,Thread::get_caller_ID());
  660. suspend_mutex->lock();
  661. input_mutex->lock();
  662. //first time step happens, initialize
  663. if (step == 0) {
  664. // ugly hack to initialize the rest of the engine
  665. // because of the way android forces you to do everything with threads
  666. java_class_wrapper = memnew( JavaClassWrapper(_godot_instance ));
  667. Globals::get_singleton()->add_singleton(Globals::Singleton("JavaClassWrapper",java_class_wrapper));
  668. _initialize_java_modules();
  669. Main::setup2();
  670. ++step;
  671. suspend_mutex->unlock();
  672. input_mutex->unlock();
  673. return;
  674. };
  675. if (step == 1) {
  676. if (!Main::start()) {
  677. input_mutex->unlock();
  678. suspend_mutex->lock();
  679. return; //should exit instead and print the error
  680. }
  681. os_android->main_loop_begin();
  682. ++step;
  683. }
  684. while(pointer_events.size()) {
  685. JAndroidPointerEvent jpe=pointer_events.front()->get();
  686. os_android->process_touch(jpe.what,jpe.pointer,jpe.points);
  687. pointer_events.pop_front();
  688. }
  689. while (key_events.size()) {
  690. InputEvent event = key_events.front()->get();
  691. os_android->process_event(event);
  692. key_events.pop_front();
  693. };
  694. if (quit_request) {
  695. os_android->main_loop_request_quit();
  696. quit_request=false;
  697. }
  698. input_mutex->unlock();
  699. os_android->process_accelerometer(accelerometer);
  700. if (os_android->main_loop_iterate()==true) {
  701. jclass cls = env->FindClass("com/android/godot/Godot");
  702. jmethodID _finish = env->GetMethodID(cls, "forceQuit", "()V");
  703. env->CallVoidMethod(_godot_instance, _finish);
  704. __android_log_print(ANDROID_LOG_INFO,"godot","**FINISH REQUEST!!! - %p-%i\n",env,Thread::get_caller_ID());
  705. }
  706. suspend_mutex->unlock();
  707. }
  708. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_touch(JNIEnv * env, jobject obj, jint ev,jint pointer, jint count, jintArray positions) {
  709. //__android_log_print(ANDROID_LOG_INFO,"godot","**TOUCH EVENT! - %p-%i\n",env,Thread::get_caller_ID());
  710. Vector<OS_Android::TouchPos> points;
  711. for(int i=0;i<count;i++) {
  712. jint p[3];
  713. env->GetIntArrayRegion(positions,i*3,3,p);
  714. OS_Android::TouchPos tp;
  715. tp.pos=Point2(p[1],p[2]);
  716. tp.id=p[0];
  717. points.push_back(tp);
  718. }
  719. JAndroidPointerEvent jpe;
  720. jpe.pointer=pointer;
  721. jpe.points=points;
  722. jpe.what=ev;
  723. input_mutex->lock();
  724. pointer_events.push_back(jpe);
  725. input_mutex->unlock();
  726. //if (os_android)
  727. // os_android->process_touch(ev,pointer,points);
  728. }
  729. /*
  730. * Android Key codes.
  731. */
  732. enum {
  733. AKEYCODE_UNKNOWN = 0,
  734. AKEYCODE_SOFT_LEFT = 1,
  735. AKEYCODE_SOFT_RIGHT = 2,
  736. AKEYCODE_HOME = 3,
  737. AKEYCODE_BACK = 4,
  738. AKEYCODE_CALL = 5,
  739. AKEYCODE_ENDCALL = 6,
  740. AKEYCODE_0 = 7,
  741. AKEYCODE_1 = 8,
  742. AKEYCODE_2 = 9,
  743. AKEYCODE_3 = 10,
  744. AKEYCODE_4 = 11,
  745. AKEYCODE_5 = 12,
  746. AKEYCODE_6 = 13,
  747. AKEYCODE_7 = 14,
  748. AKEYCODE_8 = 15,
  749. AKEYCODE_9 = 16,
  750. AKEYCODE_STAR = 17,
  751. AKEYCODE_POUND = 18,
  752. AKEYCODE_DPAD_UP = 19,
  753. AKEYCODE_DPAD_DOWN = 20,
  754. AKEYCODE_DPAD_LEFT = 21,
  755. AKEYCODE_DPAD_RIGHT = 22,
  756. AKEYCODE_DPAD_CENTER = 23,
  757. AKEYCODE_VOLUME_UP = 24,
  758. AKEYCODE_VOLUME_DOWN = 25,
  759. AKEYCODE_POWER = 26,
  760. AKEYCODE_CAMERA = 27,
  761. AKEYCODE_CLEAR = 28,
  762. AKEYCODE_A = 29,
  763. AKEYCODE_B = 30,
  764. AKEYCODE_C = 31,
  765. AKEYCODE_D = 32,
  766. AKEYCODE_E = 33,
  767. AKEYCODE_F = 34,
  768. AKEYCODE_G = 35,
  769. AKEYCODE_H = 36,
  770. AKEYCODE_I = 37,
  771. AKEYCODE_J = 38,
  772. AKEYCODE_K = 39,
  773. AKEYCODE_L = 40,
  774. AKEYCODE_M = 41,
  775. AKEYCODE_N = 42,
  776. AKEYCODE_O = 43,
  777. AKEYCODE_P = 44,
  778. AKEYCODE_Q = 45,
  779. AKEYCODE_R = 46,
  780. AKEYCODE_S = 47,
  781. AKEYCODE_T = 48,
  782. AKEYCODE_U = 49,
  783. AKEYCODE_V = 50,
  784. AKEYCODE_W = 51,
  785. AKEYCODE_X = 52,
  786. AKEYCODE_Y = 53,
  787. AKEYCODE_Z = 54,
  788. AKEYCODE_COMMA = 55,
  789. AKEYCODE_PERIOD = 56,
  790. AKEYCODE_ALT_LEFT = 57,
  791. AKEYCODE_ALT_RIGHT = 58,
  792. AKEYCODE_SHIFT_LEFT = 59,
  793. AKEYCODE_SHIFT_RIGHT = 60,
  794. AKEYCODE_TAB = 61,
  795. AKEYCODE_SPACE = 62,
  796. AKEYCODE_SYM = 63,
  797. AKEYCODE_EXPLORER = 64,
  798. AKEYCODE_ENVELOPE = 65,
  799. AKEYCODE_ENTER = 66,
  800. AKEYCODE_DEL = 67,
  801. AKEYCODE_GRAVE = 68,
  802. AKEYCODE_MINUS = 69,
  803. AKEYCODE_EQUALS = 70,
  804. AKEYCODE_LEFT_BRACKET = 71,
  805. AKEYCODE_RIGHT_BRACKET = 72,
  806. AKEYCODE_BACKSLASH = 73,
  807. AKEYCODE_SEMICOLON = 74,
  808. AKEYCODE_APOSTROPHE = 75,
  809. AKEYCODE_SLASH = 76,
  810. AKEYCODE_AT = 77,
  811. AKEYCODE_NUM = 78,
  812. AKEYCODE_HEADSETHOOK = 79,
  813. AKEYCODE_FOCUS = 80, // *Camera* focus
  814. AKEYCODE_PLUS = 81,
  815. AKEYCODE_MENU = 82,
  816. AKEYCODE_NOTIFICATION = 83,
  817. AKEYCODE_SEARCH = 84,
  818. AKEYCODE_MEDIA_PLAY_PAUSE= 85,
  819. AKEYCODE_MEDIA_STOP = 86,
  820. AKEYCODE_MEDIA_NEXT = 87,
  821. AKEYCODE_MEDIA_PREVIOUS = 88,
  822. AKEYCODE_MEDIA_REWIND = 89,
  823. AKEYCODE_MEDIA_FAST_FORWARD = 90,
  824. AKEYCODE_MUTE = 91,
  825. AKEYCODE_PAGE_UP = 92,
  826. AKEYCODE_PAGE_DOWN = 93,
  827. AKEYCODE_PICTSYMBOLS = 94,
  828. AKEYCODE_SWITCH_CHARSET = 95,
  829. AKEYCODE_BUTTON_A = 96,
  830. AKEYCODE_BUTTON_B = 97,
  831. AKEYCODE_BUTTON_C = 98,
  832. AKEYCODE_BUTTON_X = 99,
  833. AKEYCODE_BUTTON_Y = 100,
  834. AKEYCODE_BUTTON_Z = 101,
  835. AKEYCODE_BUTTON_L1 = 102,
  836. AKEYCODE_BUTTON_R1 = 103,
  837. AKEYCODE_BUTTON_L2 = 104,
  838. AKEYCODE_BUTTON_R2 = 105,
  839. AKEYCODE_BUTTON_THUMBL = 106,
  840. AKEYCODE_BUTTON_THUMBR = 107,
  841. AKEYCODE_BUTTON_START = 108,
  842. AKEYCODE_BUTTON_SELECT = 109,
  843. AKEYCODE_BUTTON_MODE = 110,
  844. // NOTE: If you add a new keycode here you must also add it to several other files.
  845. // Refer to frameworks/base/core/java/android/view/KeyEvent.java for the full list.
  846. };
  847. struct _WinTranslatePair {
  848. unsigned int keysym;
  849. unsigned int keycode;
  850. };
  851. static _WinTranslatePair _ak_to_keycode[]={
  852. { KEY_TAB, AKEYCODE_TAB },
  853. { KEY_ENTER, AKEYCODE_ENTER },
  854. { KEY_SHIFT, AKEYCODE_SHIFT_LEFT },
  855. { KEY_SHIFT, AKEYCODE_SHIFT_RIGHT },
  856. { KEY_ALT, AKEYCODE_ALT_LEFT },
  857. { KEY_ALT, AKEYCODE_ALT_RIGHT },
  858. { KEY_MENU, AKEYCODE_MENU },
  859. { KEY_PAUSE, AKEYCODE_MEDIA_PLAY_PAUSE },
  860. { KEY_ESCAPE, AKEYCODE_BACK },
  861. { KEY_SPACE, AKEYCODE_SPACE },
  862. { KEY_PAGEUP, AKEYCODE_PAGE_UP },
  863. { KEY_PAGEDOWN, AKEYCODE_PAGE_DOWN },
  864. { KEY_HOME, AKEYCODE_HOME },//(0x24)
  865. { KEY_LEFT, AKEYCODE_DPAD_LEFT },
  866. { KEY_UP, AKEYCODE_DPAD_UP },
  867. { KEY_RIGHT, AKEYCODE_DPAD_RIGHT },
  868. { KEY_DOWN, AKEYCODE_DPAD_DOWN},
  869. { KEY_PERIODCENTERED, AKEYCODE_DPAD_CENTER },
  870. { KEY_BACKSPACE, AKEYCODE_DEL},
  871. { KEY_0, AKEYCODE_0 },////0 key
  872. { KEY_1, AKEYCODE_1 },////1 key
  873. { KEY_2, AKEYCODE_2 },////2 key
  874. { KEY_3, AKEYCODE_3 },////3 key
  875. { KEY_4, AKEYCODE_4 },////4 key
  876. { KEY_5, AKEYCODE_5 },////5 key
  877. { KEY_6, AKEYCODE_6 },////6 key
  878. { KEY_7, AKEYCODE_7 },////7 key
  879. { KEY_8, AKEYCODE_8 },////8 key
  880. { KEY_9, AKEYCODE_9 },////9 key
  881. { KEY_A, AKEYCODE_A },////A key
  882. { KEY_B, AKEYCODE_B },////B key
  883. { KEY_C, AKEYCODE_C },////C key
  884. { KEY_D, AKEYCODE_D },////D key
  885. { KEY_E, AKEYCODE_E },////E key
  886. { KEY_F, AKEYCODE_F },////F key
  887. { KEY_G, AKEYCODE_G },////G key
  888. { KEY_H, AKEYCODE_H },////H key
  889. { KEY_I, AKEYCODE_I },////I key
  890. { KEY_J, AKEYCODE_J },////J key
  891. { KEY_K, AKEYCODE_K },////K key
  892. { KEY_L, AKEYCODE_L },////L key
  893. { KEY_M, AKEYCODE_M },////M key
  894. { KEY_N, AKEYCODE_N },////N key
  895. { KEY_O, AKEYCODE_O },////O key
  896. { KEY_P, AKEYCODE_P },////P key
  897. { KEY_Q, AKEYCODE_Q },////Q key
  898. { KEY_R, AKEYCODE_R },////R key
  899. { KEY_S, AKEYCODE_S },////S key
  900. { KEY_T, AKEYCODE_T },////T key
  901. { KEY_U, AKEYCODE_U },////U key
  902. { KEY_V, AKEYCODE_V },////V key
  903. { KEY_W, AKEYCODE_W },////W key
  904. { KEY_X, AKEYCODE_X },////X key
  905. { KEY_Y, AKEYCODE_Y },////Y key
  906. { KEY_Z, AKEYCODE_Z },////Z key
  907. { KEY_HOMEPAGE, AKEYCODE_EXPLORER},
  908. { KEY_LAUNCH0, AKEYCODE_BUTTON_A},
  909. { KEY_LAUNCH1, AKEYCODE_BUTTON_B},
  910. { KEY_LAUNCH2, AKEYCODE_BUTTON_C},
  911. { KEY_LAUNCH3, AKEYCODE_BUTTON_X},
  912. { KEY_LAUNCH4, AKEYCODE_BUTTON_Y},
  913. { KEY_LAUNCH5, AKEYCODE_BUTTON_Z},
  914. { KEY_LAUNCH6, AKEYCODE_BUTTON_L1},
  915. { KEY_LAUNCH7, AKEYCODE_BUTTON_R1},
  916. { KEY_LAUNCH8, AKEYCODE_BUTTON_L2},
  917. { KEY_LAUNCH9, AKEYCODE_BUTTON_R2},
  918. { KEY_LAUNCHA, AKEYCODE_BUTTON_THUMBL},
  919. { KEY_LAUNCHB, AKEYCODE_BUTTON_THUMBR},
  920. { KEY_LAUNCHC, AKEYCODE_BUTTON_START},
  921. { KEY_LAUNCHD, AKEYCODE_BUTTON_SELECT},
  922. { KEY_LAUNCHE, AKEYCODE_BUTTON_MODE},
  923. { KEY_VOLUMEMUTE, AKEYCODE_MUTE},
  924. { KEY_VOLUMEDOWN, AKEYCODE_VOLUME_DOWN},
  925. { KEY_VOLUMEUP, AKEYCODE_VOLUME_UP},
  926. { KEY_BACK, AKEYCODE_MEDIA_REWIND },
  927. { KEY_FORWARD, AKEYCODE_MEDIA_FAST_FORWARD },
  928. { KEY_MEDIANEXT, AKEYCODE_MEDIA_NEXT },
  929. { KEY_MEDIAPREVIOUS, AKEYCODE_MEDIA_PREVIOUS },
  930. { KEY_MEDIASTOP, AKEYCODE_MEDIA_STOP },
  931. { KEY_PLUS, AKEYCODE_PLUS },
  932. { KEY_EQUAL, AKEYCODE_EQUALS},// the '+' key
  933. { KEY_COMMA, AKEYCODE_COMMA},// the ',' key
  934. { KEY_MINUS, AKEYCODE_MINUS},// the '-' key
  935. { KEY_SLASH, AKEYCODE_SLASH},// the '/?' key
  936. { KEY_BACKSLASH, AKEYCODE_BACKSLASH},
  937. { KEY_BRACKETLEFT, AKEYCODE_LEFT_BRACKET},
  938. { KEY_BRACKETRIGHT, AKEYCODE_RIGHT_BRACKET},
  939. { KEY_UNKNOWN, 0} };
  940. /*
  941. TODO: map these android key:
  942. AKEYCODE_SOFT_LEFT = 1,
  943. AKEYCODE_SOFT_RIGHT = 2,
  944. AKEYCODE_CALL = 5,
  945. AKEYCODE_ENDCALL = 6,
  946. AKEYCODE_STAR = 17,
  947. AKEYCODE_POUND = 18,
  948. AKEYCODE_POWER = 26,
  949. AKEYCODE_CAMERA = 27,
  950. AKEYCODE_CLEAR = 28,
  951. AKEYCODE_SYM = 63,
  952. AKEYCODE_ENVELOPE = 65,
  953. AKEYCODE_GRAVE = 68,
  954. AKEYCODE_SEMICOLON = 74,
  955. AKEYCODE_APOSTROPHE = 75,
  956. AKEYCODE_AT = 77,
  957. AKEYCODE_NUM = 78,
  958. AKEYCODE_HEADSETHOOK = 79,
  959. AKEYCODE_FOCUS = 80, // *Camera* focus
  960. AKEYCODE_NOTIFICATION = 83,
  961. AKEYCODE_SEARCH = 84,
  962. AKEYCODE_PICTSYMBOLS = 94,
  963. AKEYCODE_SWITCH_CHARSET = 95,
  964. */
  965. static unsigned int android_get_keysym(unsigned int p_code) {
  966. for(int i=0;_ak_to_keycode[i].keysym!=KEY_UNKNOWN;i++) {
  967. if (_ak_to_keycode[i].keycode==p_code) {
  968. //print_line("outcode: " + _ak_to_keycode[i].keysym);
  969. return _ak_to_keycode[i].keysym;
  970. }
  971. }
  972. return KEY_UNKNOWN;
  973. }
  974. static int find_device(int p_device) {
  975. for (int i=0; i<joy_device_ids.size(); i++) {
  976. if (joy_device_ids[i] == p_device) {
  977. //print_line("found device at "+String::num(i));
  978. return i;
  979. };
  980. };
  981. //print_line("adding a device at" + String::num(joy_device_ids.size()));
  982. joy_device_ids.push_back(p_device);
  983. return joy_device_ids.size() - 1;
  984. };
  985. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_joybutton(JNIEnv * env, jobject obj, jint p_device, jint p_button, jboolean p_pressed) {
  986. InputEvent ievent;
  987. ievent.type = InputEvent::JOYSTICK_BUTTON;
  988. ievent.device = find_device(p_device);
  989. ievent.joy_button.button_index = p_button;
  990. ievent.joy_button.pressed = p_pressed;
  991. input_mutex->lock();
  992. key_events.push_back(ievent);
  993. input_mutex->unlock();
  994. };
  995. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_joyaxis(JNIEnv * env, jobject obj, jint p_device, jint p_axis, jfloat p_value) {
  996. InputEvent ievent;
  997. ievent.type = InputEvent::JOYSTICK_MOTION;
  998. ievent.device = find_device(p_device);
  999. ievent.joy_motion.axis = p_axis;
  1000. ievent.joy_motion.axis_value = p_value;
  1001. input_mutex->lock();
  1002. key_events.push_back(ievent);
  1003. input_mutex->unlock();
  1004. };
  1005. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_key(JNIEnv * env, jobject obj, jint p_scancode, jint p_unicode_char, jboolean p_pressed) {
  1006. InputEvent ievent;
  1007. ievent.type = InputEvent::KEY;
  1008. ievent.device = 0;
  1009. int val = p_unicode_char;
  1010. int scancode = android_get_keysym(p_scancode);
  1011. ievent.key.scancode = scancode;
  1012. ievent.key.unicode = val;
  1013. ievent.key.pressed = p_pressed;
  1014. print_line("Scancode: " + String::num(p_scancode) + ":" + String::num(ievent.key.scancode) + " Unicode: " + String::num(val));
  1015. ievent.key.mod.shift=false;
  1016. ievent.key.mod.alt=false;
  1017. ievent.key.mod.control=false;
  1018. ievent.key.echo=false;
  1019. if (val == '\n')
  1020. {
  1021. ievent.key.scancode = KEY_ENTER;
  1022. }else if (val == 61448) {
  1023. ievent.key.scancode = KEY_BACKSPACE;
  1024. ievent.key.unicode = KEY_BACKSPACE;
  1025. } else if (val == 61453) {
  1026. ievent.key.scancode = KEY_ENTER;
  1027. ievent.key.unicode = KEY_ENTER;
  1028. } else if (p_scancode==4) {
  1029. quit_request=true;
  1030. }
  1031. input_mutex->lock();
  1032. key_events.push_back(ievent);
  1033. input_mutex->unlock();
  1034. };
  1035. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_accelerometer(JNIEnv * env, jobject obj, jfloat x, jfloat y, jfloat z) {
  1036. input_mutex->lock();
  1037. accelerometer=Vector3(x,y,z);
  1038. input_mutex->unlock();
  1039. }
  1040. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_focusin(JNIEnv * env, jobject obj){
  1041. if (!suspend_mutex)
  1042. return;
  1043. suspend_mutex->lock();
  1044. if (os_android && step > 0)
  1045. os_android->main_loop_focusin();
  1046. suspend_mutex->unlock();
  1047. }
  1048. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_focusout(JNIEnv * env, jobject obj){
  1049. if (!suspend_mutex)
  1050. return;
  1051. suspend_mutex->lock();
  1052. if (os_android && step > 0)
  1053. os_android->main_loop_focusout();
  1054. suspend_mutex->unlock();
  1055. }
  1056. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_audio(JNIEnv * env, jobject obj) {
  1057. ThreadAndroid::setup_thread();
  1058. AudioDriverAndroid::thread_func(env);
  1059. }
  1060. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_singleton(JNIEnv * env, jobject obj, jstring name,jobject p_object){
  1061. String singname = env->GetStringUTFChars( name, NULL );
  1062. JNISingleton *s = memnew( JNISingleton );
  1063. s->set_instance(env->NewGlobalRef(p_object));
  1064. jni_singletons[singname]=s;
  1065. Globals::get_singleton()->add_singleton(Globals::Singleton(singname,s));
  1066. Globals::get_singleton()->set(singname,s);
  1067. }
  1068. static Variant::Type get_jni_type(const String& p_type) {
  1069. static struct {
  1070. const char *name;
  1071. Variant::Type type;
  1072. } _type_to_vtype[]={
  1073. {"void",Variant::NIL},
  1074. {"boolean",Variant::BOOL},
  1075. {"int",Variant::INT},
  1076. {"float",Variant::REAL},
  1077. {"double", Variant::REAL},
  1078. {"java.lang.String",Variant::STRING},
  1079. {"[I",Variant::INT_ARRAY},
  1080. {"[B",Variant::RAW_ARRAY},
  1081. {"[F",Variant::REAL_ARRAY},
  1082. {"[java.lang.String",Variant::STRING_ARRAY},
  1083. {"com.android.godot.Dictionary", Variant::DICTIONARY},
  1084. {NULL,Variant::NIL}
  1085. };
  1086. int idx=0;
  1087. while (_type_to_vtype[idx].name) {
  1088. if (p_type==_type_to_vtype[idx].name)
  1089. return _type_to_vtype[idx].type;
  1090. idx++;
  1091. }
  1092. return Variant::NIL;
  1093. }
  1094. static const char* get_jni_sig(const String& p_type) {
  1095. static struct {
  1096. const char *name;
  1097. const char *sig;
  1098. } _type_to_vtype[]={
  1099. {"void","V"},
  1100. {"boolean","Z"},
  1101. {"int","I"},
  1102. {"float","F"},
  1103. {"double","D"},
  1104. {"java.lang.String","Ljava/lang/String;"},
  1105. {"com.android.godot.Dictionary", "Lcom/android/godot/Dictionary;"},
  1106. {"[I","[I"},
  1107. {"[B","[B"},
  1108. {"[F","[F"},
  1109. {"[java.lang.String","[Ljava/lang/String;"},
  1110. {NULL,"V"}
  1111. };
  1112. int idx=0;
  1113. while (_type_to_vtype[idx].name) {
  1114. if (p_type==_type_to_vtype[idx].name)
  1115. return _type_to_vtype[idx].sig;
  1116. idx++;
  1117. }
  1118. return "Ljava/lang/Object;";
  1119. }
  1120. JNIEXPORT jstring JNICALL Java_com_android_godot_GodotLib_getGlobal(JNIEnv * env, jobject obj, jstring path) {
  1121. String js = env->GetStringUTFChars( path, NULL );
  1122. return env->NewStringUTF(Globals::get_singleton()->get(js).operator String().utf8().get_data());
  1123. }
  1124. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_method(JNIEnv * env, jobject obj, jstring sname, jstring name, jstring ret, jobjectArray args){
  1125. String singname = env->GetStringUTFChars( sname, NULL );
  1126. ERR_FAIL_COND(!jni_singletons.has(singname));
  1127. JNISingleton *s = jni_singletons.get(singname);
  1128. String mname = env->GetStringUTFChars( name, NULL );
  1129. String retval = env->GetStringUTFChars( ret, NULL );
  1130. Vector<Variant::Type> types;
  1131. String cs="(";
  1132. int stringCount = env->GetArrayLength(args);
  1133. print_line("Singl: "+singname+" Method: "+mname+" RetVal: "+retval);
  1134. for (int i=0; i<stringCount; i++) {
  1135. jstring string = (jstring) env->GetObjectArrayElement(args, i);
  1136. const char *rawString = env->GetStringUTFChars(string, 0);
  1137. types.push_back(get_jni_type(String(rawString)));
  1138. cs+=get_jni_sig(String(rawString));
  1139. }
  1140. cs+=")";
  1141. cs+=get_jni_sig(retval);
  1142. jclass cls = env->GetObjectClass(s->get_instance());
  1143. print_line("METHOD: "+mname+" sig: "+cs);
  1144. jmethodID mid = env->GetMethodID(cls, mname.ascii().get_data(), cs.ascii().get_data());
  1145. if (!mid) {
  1146. print_line("FAILED GETTING METHOID "+mname);
  1147. }
  1148. s->add_method(mname,mid,types,get_jni_type(retval));
  1149. }
  1150. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_callobject(JNIEnv * env, jobject p_obj, jint ID, jstring method, jobjectArray params) {
  1151. String str_method = env->GetStringUTFChars( method, NULL );
  1152. Object* obj = ObjectDB::get_instance(ID);
  1153. ERR_FAIL_COND(!obj);
  1154. int count = env->GetArrayLength(params);
  1155. Variant* vlist = (Variant*)alloca(sizeof(Variant) * count);
  1156. Variant** vptr = (Variant**)alloca(sizeof(Variant*) * count);
  1157. for (int i=0; i<count; i++) {
  1158. jobject obj = env->GetObjectArrayElement(params, i);
  1159. Variant v;
  1160. if (obj)
  1161. v=_jobject_to_variant(env, obj);
  1162. memnew_placement(&vlist[i], Variant);
  1163. vlist[i] = v;
  1164. vptr[i] = &vlist[i];
  1165. };
  1166. Variant::CallError err;
  1167. obj->call(str_method, (const Variant**)vptr, count, err);
  1168. // something
  1169. };
  1170. JNIEXPORT void JNICALL Java_com_android_godot_GodotLib_calldeferred(JNIEnv * env, jobject p_obj, jint ID, jstring method, jobjectArray params) {
  1171. String str_method = env->GetStringUTFChars( method, NULL );
  1172. Object* obj = ObjectDB::get_instance(ID);
  1173. ERR_FAIL_COND(!obj);
  1174. int count = env->GetArrayLength(params);
  1175. Variant args[VARIANT_ARG_MAX];
  1176. // print_line("Java->GD call: "+obj->get_type()+"::"+str_method+" argc "+itos(count));
  1177. for (int i=0; i<MIN(count,VARIANT_ARG_MAX); i++) {
  1178. jobject obj = env->GetObjectArrayElement(params, i);
  1179. if (obj)
  1180. args[i] = _jobject_to_variant(env, obj);
  1181. // print_line("\targ"+itos(i)+": "+Variant::get_type_name(args[i].get_type()));
  1182. };
  1183. obj->call_deferred(str_method, args[0],args[1],args[2],args[3],args[4]);
  1184. // something
  1185. };
  1186. //Main::cleanup();
  1187. //return os.get_exit_code();
  1188. #endif