navit/navit/android.c

   1 #include <stdlib.h>
   2 #include <string.h>
   3 #include <glib.h>
   4 #include "android.h"
   5 #include <android/log.h>
   6 #include "navit.h"
   7 #include "config_.h"
   8 #include "command.h"
   9 #include "debug.h"
  10 #include "event.h"
  11 #include "callback.h"
  12 #include "country.h"
  13 #include "projection.h"
  14 #include "map.h"
  15 #include "mapset.h"
  16 #include "navit_nls.h"
  17 #include "transform.h"
  18 #include "color.h"
  19 #include "types.h"
  20 #include "search.h"
  21 #include "start_real.h"
  22 #include "track.h"
  23
  24
  25 JNIEnv *jnienv;
  26 jobject *android_activity;
  27 int android_version;
  28
  29 int
  30 android_find_class_global(char *name, jclass *ret)
  31 {
  32         *ret=(*jnienv)->FindClass(jnienv, name);
  33         if (! *ret) {
  34                 dbg(0,"Failed to get Class %s\n",name);
  35                 return 0;
  36         }
  37         *ret = (*jnienv)->NewGlobalRef(jnienv, *ret);
  38         return 1;
  39 }
  40
  41 int
  42 android_find_method(jclass class, char *name, char *args, jmethodID *ret)
  43 {
  44         *ret = (*jnienv)->GetMethodID(jnienv, class, name, args);
  45         if (*ret == NULL) {
  46                 dbg(0,"Failed to get Method %s with signature %s\n",name,args);
  47                 return 0;
  48         }
  49         return 1;
  50 }
  51
  52 JNIEXPORT void JNICALL
  53 Java_org_navitproject_navit_Navit_NavitMain( JNIEnv* env, jobject thiz, jobject activity, jobject lang, int version, jobject display_density_string, jobject path)
  54 {
  55         char *strings[]={NULL,NULL};
  56         const char *langstr;
  57         const char *displaydensitystr;
  58         android_version=version;
  59         __android_log_print(ANDROID_LOG_ERROR,"test","called");
  60         jnienv=env;
  61         android_activity = (*jnienv)->NewGlobalRef(jnienv, activity);
  62         langstr=(*env)->GetStringUTFChars(env, lang, NULL);
  63         dbg(0,"enter env=%p thiz=%p activity=%p lang=%s version=%d\n",env,thiz,android_activity,langstr,version);
  64         setenv("LANG",langstr,1);
  65         (*env)->ReleaseStringUTFChars(env, lang, langstr);
  66
  67         displaydensitystr=(*env)->GetStringUTFChars(env, display_density_string, NULL);
  68         dbg(0,"*****displaydensity=%s\n",displaydensitystr);
  69         setenv("ANDROID_DENSITY",displaydensitystr,1);
  70         (*env)->ReleaseStringUTFChars(env, display_density_string, displaydensitystr);
  71         strings[0]=(*env)->GetStringUTFChars(env, path, NULL);
  72         main_real(1, strings);
  73         (*env)->ReleaseStringUTFChars(env, path, strings[0]);
  74
  75 }
  76
  77 JNIEXPORT void JNICALL
  78 Java_org_navitproject_navit_Navit_NavitDestroy( JNIEnv* env)
  79 {
  80         dbg(0, "shutdown navit\n");
  81         exit(0);
  82 }
  83
  84 JNIEXPORT void JNICALL
  85 Java_org_navitproject_navit_NavitGraphics_SizeChangedCallback( JNIEnv* env, jobject thiz, int id, int w, int h)
  86 {
  87         dbg(0,"enter %p %d %d\n",(struct callback *)id,w,h);
  88         if (id)
  89                 callback_call_2((struct callback *)id,w,h);
  90 }
  91
  92 JNIEXPORT void JNICALL
  93 Java_org_navitproject_navit_NavitGraphics_ButtonCallback( JNIEnv* env, jobject thiz, int id, int pressed, int button, int x, int y)
  94 {
  95         dbg(1,"enter %p %d %d\n",(struct callback *)id,pressed,button);
  96         if (id)
  97                 callback_call_4((struct callback *)id,pressed,button,x,y);
  98 }
  99
 100 JNIEXPORT void JNICALL
 101 Java_org_navitproject_navit_NavitGraphics_MotionCallback( JNIEnv* env, jobject thiz, int id, int x, int y)
 102 {
 103         dbg(1,"enter %p %d %d\n",(struct callback *)id,x,y);
 104         if (id)
 105                 callback_call_2((struct callback *)id,x,y);
 106 }
 107
 108 JNIEXPORT void JNICALL
 109 Java_org_navitproject_navit_NavitGraphics_KeypressCallback( JNIEnv* env, jobject thiz, int id, jobject str)
 110 {
 111         const char *s;
 112         dbg(0,"enter %p %p\n",(struct callback *)id,str);
 113         s=(*env)->GetStringUTFChars(env, str, NULL);
 114         dbg(0,"key=%d",s);
 115         if (id)
 116                 callback_call_1((struct callback *)id,s);
 117         (*env)->ReleaseStringUTFChars(env, str, s);
 118 }
 119
 120 JNIEXPORT void JNICALL
 121 Java_org_navitproject_navit_NavitTimeout_TimeoutCallback( JNIEnv* env, jobject thiz, int id)
 122 {
 123         void (*event_handler)(void *) = *(void **)id;
 124         dbg(1,"enter %p %p\n",thiz, (void *)id);
 125         event_handler((void*)id);
 126 }
 127
 128 JNIEXPORT void JNICALL
 129 Java_org_navitproject_navit_NavitVehicle_VehicleCallback( JNIEnv * env, jobject thiz, int id, jobject location)
 130 {
 131         callback_call_1((struct callback *)id, (void *)location);
 132 }
 133
 134 JNIEXPORT void JNICALL
 135 Java_org_navitproject_navit_NavitIdle_IdleCallback( JNIEnv* env, jobject thiz, int id)
 136 {
 137         dbg(1,"enter %p %p\n",thiz, (void *)id);
 138         callback_call_0((struct callback *)id);
 139 }
 140
 141 JNIEXPORT void JNICALL
 142 Java_org_navitproject_navit_NavitWatch_poll( JNIEnv* env, jobject thiz, int func, int fd, int cond)
 143 {
 144         void (*pollfunc)(JNIEnv *env, int fd, int cond)=(void *)func;
 145
 146         pollfunc(env, fd, cond);
 147 }
 148
 149 JNIEXPORT void JNICALL
 150 Java_org_navitproject_navit_NavitWatch_WatchCallback( JNIEnv* env, jobject thiz, int id)
 151 {
 152         dbg(1,"enter %p %p\n",thiz, (void *)id);
 153         callback_call_0((struct callback *)id);
 154 }
 155
 156
 157 JNIEXPORT void JNICALL
 158 Java_org_navitproject_navit_NavitSensors_SensorCallback( JNIEnv* env, jobject thiz, int id, int sensor, float x, float y, float z)
 159 {
 160         dbg(1,"enter %p %p %f %f %f\n",thiz, (void *)id,x,y,z);
 161         callback_call_4((struct callback *)id, sensor, &x, &y, &z);
 162 }
 163
 164 void
 165 android_return_search_result(struct jni_object *jni_o, char *str)
 166 {
 167         jstring js2 = NULL;
 168         JNIEnv* env2;
 169         env2=jni_o->env;
 170         js2 = (*env2)->NewStringUTF(jni_o->env,str);
 171         (*env2)->CallVoidMethod(jni_o->env, jni_o->jo, jni_o->jm, js2);
 172         (*env2)->DeleteLocalRef(jni_o->env, js2);
 173 }
 174
 175 JNIEXPORT void JNICALL
 176 Java_org_navitproject_navit_NavitGraphics_CallbackSearchResultList( JNIEnv* env, jobject thiz, int partial, jobject country, jobject str)
 177 {
 178         struct attr attr;
 179         const char *search_string =(*env)->GetStringUTFChars(env, str, NULL);
 180         dbg(0,"search '%s'\n", search_string);
 181
 182         config_get_attr(config_get(), attr_navit, &attr, NULL);
 183
 184         jclass cls = (*env)->GetObjectClass(env,thiz);
 185         jmethodID aMethodID = (*env)->GetMethodID(env, cls, "fillStringArray", "(Ljava/lang/String;)V");
 186         if(aMethodID != 0)
 187         {
 188                 struct jni_object my_jni_object;
 189                 GList *ret = NULL;
 190                 struct mapset *ms4=navit_get_mapset(attr.u.navit);
 191                 struct search_list *sl = search_list_new(ms4);
 192                 struct attr country_attr;
 193                 const char *str_country=(*env)->GetStringUTFChars(env, country, NULL);
 194
 195                 country_attr.type=attr_country_iso2;
 196                 country_attr.u.str=str_country;
 197
 198                 search_list_search(sl, &country_attr, 0);
 199                 (*env)->ReleaseStringUTFChars(env, country, str_country);
 200
 201                 my_jni_object.env=env;
 202                 my_jni_object.jo=thiz;
 203                 my_jni_object.jm=aMethodID;
 204
 205                 /* TODO (rikky#1#): does return nothing yet, also should use a generic callback instead of jni_object */
 206                 ret=search_by_address(sl,search_string,partial,&my_jni_object);
 207                 search_list_destroy(sl);
 208
 209                 dbg(0,"ret=%p\n",ret);
 210
 211                 g_list_free(ret);
 212         }
 213         else
 214                 dbg(0,"**** Unable to get methodID: fillStringArray");
 215
 216         (*env)->ReleaseStringUTFChars(env, str, search_string);
 217 }
 218
 219
 220 JNIEXPORT jstring JNICALL
 221 Java_org_navitproject_navit_NavitGraphics_CallbackLocalizedString( JNIEnv* env, jobject thiz, jobject str)
 222 {
 223         const char *s;
 224         const char *localized_str;
 225
 226         s=(*env)->GetStringUTFChars(env, str, NULL);
 227         //dbg(0,"*****string=%s\n",s);
 228
 229         localized_str=gettext(s);
 230         //dbg(0,"localized string=%s",localized_str);
 231
 232         // jstring dataStringValue = (jstring) localized_str;
 233         jstring js = (*env)->NewStringUTF(env,localized_str);
 234
 235         (*env)->ReleaseStringUTFChars(env, str, s);
 236
 237         return js;
 238 }
 239
 240 JNIEXPORT void JNICALL
 241 Java_org_navitproject_navit_NavitGraphics_CallbackMessageChannel( JNIEnv* env, jobject thiz, int channel, jobject str)
 242 {
 243         struct attr attr;
 244         const char *s;
 245         dbg(0,"enter %d %p\n",channel,str);
 246
 247         config_get_attr(config_get(), attr_navit, &attr, NULL);
 248
 249         switch(channel)
 250         {
 251         case 1:
 252                 // zoom in
 253                 navit_zoom_in_cursor(attr.u.navit, 2);
 254                 navit_draw(attr.u.navit);
 255                 break;
 256         case 2:
 257                 // zoom out
 258                 navit_zoom_out_cursor(attr.u.navit, 2);
 259                 navit_draw(attr.u.navit);
 260                 break;
 261         case 6:
 262         {
 263                 struct mapset *ms = navit_get_mapset(attr.u.navit);
 264                 struct attr type, name, data, *attrs[4];
 265                 char *map_location=(*env)->GetStringUTFChars(env, str, NULL);
 266                 dbg(0,"*****string=%s\n",map_location);
 267                 type.type=attr_type;
 268                 type.u.str="binfile";
 269
 270                 data.type=attr_data;
 271                 data.u.str=g_strdup(map_location);
 272
 273                 name.type=attr_name;
 274                 name.u.str=g_strdup(map_location);
 275
 276                 attrs[0]=&type; attrs[1]=&data; attrs[2]=&name; attrs[3]=NULL;
 277
 278                 struct map * new_map = map_new(NULL, attrs);
 279                 struct attr map_a;
 280                 map_a.type=attr_map;
 281                 map_a.u.map=new_map;
 282                 mapset_add_attr(ms, &map_a);
 283                 navit_draw(attr.u.navit);
 284                 (*env)->ReleaseStringUTFChars(env, str, map_location);
 285         }
 286         break;
 287         case 7:
 288         {
 289                 struct mapset *ms = navit_get_mapset(attr.u.navit);
 290                 struct attr map_r;
 291                 char *map_location=(*env)->GetStringUTFChars(env, str, NULL);
 292                 struct map * delete_map =  mapset_get_map_by_name(ms, map_location);
 293
 294                 dbg(0,"delete map %s (%p)", map_location, delete_map);
 295                 map_r.type=attr_map;
 296                 map_r.u.map=delete_map;
 297                 mapset_remove_attr(ms, &map_r);
 298                 navit_draw(attr.u.navit);
 299                 (*env)->ReleaseStringUTFChars(env, str, map_location);
 300         }
 301         break;
 302         case 5:
 303                 // call a command (like in gui)
 304                 s=(*env)->GetStringUTFChars(env, str, NULL);
 305                 dbg(0,"*****string=%s\n",s);
 306                 command_evaluate(&attr,s);
 307                 (*env)->ReleaseStringUTFChars(env, str, s);
 308                 break;
 309         case 4:
 310         {
 311                 // navigate to display position
 312                 char *pstr;
 313                 struct point p;
 314                 struct coord c;
 315                 struct pcoord pc;
 316
 317                 struct transformation *transform=navit_get_trans(attr.u.navit);
 318
 319                 s=(*env)->GetStringUTFChars(env, str, NULL);
 320                 char parse_str[strlen(s) + 1];
 321                 strcpy(parse_str, s);
 322                 (*env)->ReleaseStringUTFChars(env, str, s);
 323                 dbg(0,"*****string=%s\n",parse_str);
 324
 325                 // set destination to (pixel-x#pixel-y)
 326                 // pixel-x
 327                 pstr = strtok (parse_str,"#");
 328                 p.x = atoi(pstr);
 329                 // pixel-y
 330                 pstr = strtok (NULL, "#");
 331                 p.y = atoi(pstr);
 332
 333                 dbg(0,"11x=%d\n",p.x);
 334                 dbg(0,"11y=%d\n",p.y);
 335
 336                 transform_reverse(transform, &p, &c);
 337
 338
 339                 pc.x = c.x;
 340                 pc.y = c.y;
 341                 pc.pro = transform_get_projection(transform);
 342
 343                 dbg(0,"22x=%d\n",pc.x);
 344                 dbg(0,"22y=%d\n",pc.y);
 345
 346                 // start navigation asynchronous
 347                 navit_set_destination(attr.u.navit, &pc, parse_str, 1);
 348         }
 349         break;
 350         case 3:
 351         {
 352                 // navigate to geo position
 353                 char *name;
 354                 s=(*env)->GetStringUTFChars(env, str, NULL);
 355                 char parse_str[strlen(s) + 1];
 356                 strcpy(parse_str, s);
 357                 (*env)->ReleaseStringUTFChars(env, str, s);
 358                 dbg(0,"*****string=%s\n",s);
 359
 360                 // set destination to (lat#lon#title)
 361                 struct coord_geo g;
 362                 char *p;
 363                 char *stopstring;
 364
 365                 // lat
 366                 p = strtok (parse_str,"#");
 367                 g.lat = strtof(p, &stopstring);
 368                 // lon
 369                 p = strtok (NULL, "#");
 370                 g.lng = strtof(p, &stopstring);
 371                 // description
 372                 name = strtok (NULL, "#");
 373
 374                 dbg(0,"lat=%f\n",g.lat);
 375                 dbg(0,"lng=%f\n",g.lng);
 376                 dbg(0,"str1=%s\n",name);
 377
 378                 struct coord c;
 379                 transform_from_geo(projection_mg, &g, &c);
 380
 381                 struct pcoord pc;
 382                 pc.x=c.x;
 383                 pc.y=c.y;
 384                 pc.pro=projection_mg;
 385
 386                 // start navigation asynchronous
 387                 navit_set_destination(attr.u.navit, &pc, name, 1);
 388
 389         }
 390         break;
 391         default:
 392                 dbg(0, "Unknown command");
 393         }
 394 }
 395
 396 JNIEXPORT jstring JNICALL
 397 Java_org_navitproject_navit_NavitGraphics_GetDefaultCountry( JNIEnv* env, jobject thiz, int channel, jobject str)
 398 {
 399         struct attr search_attr, country_name, country_iso2, *country_attr;
 400         struct tracking *tracking;
 401         struct search_list_result *res;
 402         jstring return_string = NULL;
 403
 404         struct attr attr;
 405         dbg(0,"enter %d %p\n",channel,str);
 406
 407         config_get_attr(config_get(), attr_navit, &attr, NULL);
 408
 409         country_attr=country_default();
 410         tracking=navit_get_tracking(attr.u.navit);
 411         if (tracking && tracking_get_attr(tracking, attr_country_id, &search_attr, NULL))
 412                 country_attr=&search_attr;
 413         if (country_attr) {
 414                 struct country_search *cs=country_search_new(country_attr, 0);
 415                 struct item *item=country_search_get_item(cs);
 416                 if (item && item_attr_get(item, attr_country_name, &country_name)) {
 417                         struct mapset *ms=navit_get_mapset(attr.u.navit);
 418                         struct search_list *search_list = search_list_new(ms);
 419                         search_attr.type=attr_country_all;
 420                         dbg(0,"country %s\n", country_name.u.str);
 421                         search_attr.u.str=country_name.u.str;
 422                         search_list_search(search_list, &search_attr, 0);
 423                         while((res=search_list_get_result(search_list)))
 424                         {
 425                                 dbg(0,"Get result: %s\n", res->country->iso2);
 426                         }
 427                         if (item_attr_get(item, attr_country_iso2, &country_iso2))
 428                                 return_string = (*env)->NewStringUTF(env,country_iso2.u.str);
 429                 }
 430                 country_search_destroy(cs);
 431         }
 432
 433         return return_string;
 434 }
 435
 436 JNIEXPORT jobjectArray JNICALL
 437 Java_org_navitproject_navit_NavitGraphics_GetAllCountries( JNIEnv* env, jobject thiz)
 438 {
 439         struct attr search_attr;
 440         struct search_list_result *res;
 441         GList* countries = NULL;
 442         int country_count = 0;
 443         jobjectArray all_countries;
 444
 445         struct attr attr;
 446         dbg(0,"enter\n");
 447
 448         config_get_attr(config_get(), attr_navit, &attr, NULL);
 449
 450         struct mapset *ms=navit_get_mapset(attr.u.navit);
 451         struct search_list *search_list = search_list_new(ms);
 452         jobjectArray current_country = NULL;
 453         search_attr.type=attr_country_all;
 454         //dbg(0,"country %s\n", country_name.u.str);
 455         search_attr.u.str=g_strdup("");//country_name.u.str;
 456         search_list_search(search_list, &search_attr, 1);
 457         while((res=search_list_get_result(search_list)))
 458         {
 459                 dbg(0,"Get result: %s\n", res->country->iso2);
 460
 461                 if (strlen(res->country->iso2)==2)
 462                 {
 463                         jstring j_iso2 = (*env)->NewStringUTF(env, res->country->iso2);
 464                         jstring j_name = (*env)->NewStringUTF(env, gettext(res->country->name));
 465
 466                         current_country = (jobjectArray)(*env)->NewObjectArray(env, 2, (*env)->FindClass(env, "java/lang/String"), NULL);
 467
 468                         (*env)->SetObjectArrayElement(env, current_country, 0,  j_iso2);
 469                         (*env)->SetObjectArrayElement(env, current_country, 1,  j_name);
 470
 471                         (*env)->DeleteLocalRef(env, j_iso2);
 472                         (*env)->DeleteLocalRef(env, j_name);
 473
 474                         countries = g_list_prepend(countries, current_country);
 475                         country_count++;
 476                 }
 477         }
 478
 479         search_list_destroy(search_list);
 480         all_countries = (jobjectArray)(*env)->NewObjectArray(env, country_count, (*env)->GetObjectClass(env, current_country), NULL);
 481
 482         while(countries)
 483         {
 484                 (*env)->SetObjectArrayElement(env, all_countries, --country_count, countries->data);
 485                 countries = g_list_delete_link( countries, countries);
 486         }
 487         return all_countries;
 488 }