/*
* Called once one file was sent successfully. Starts the sending of the next file, if there is one.
*/
static void upload_done( void *context, const char *format, ... ) {
upload_context * uContext = (upload_context *)context;
int new_count;
char ** new_cursor;
const char * target_url;
char * new_full_path;
char msg[500];
int total;
va_list ap;
if(format){
va_start(ap, format);
vsnprintf(msg,sizeof(msg),format,ap);
va_end(ap);
roadmap_log(ROADMAP_DEBUG,"done uploading log file : %s. Received response : %s",*uContext->cursor,msg);
}
new_cursor = (uContext->cursor)+1;
new_count = (uContext->file_num)+1;
total = uContext->total;
roadmap_file_remove(NULL, uContext->full_path); // remove the previous file
if(new_count==total){ // finished - sent all the files!
in_process = 0 ;
roadmap_path_list_free(uContext->files);
ssd_progress_msg_dialog_hide();
roadmap_messagebox_timeout("Thank you!!!", "Logs submitted successfully to waze",3);
}else{ // still more files - call the next one
upload_context * new_context;
sprintf (warning_message,"%s\n%d/%d",roadmap_lang_get("Uploading logs..."),new_count+1, total);
ssd_progress_msg_dialog_show(warning_message);
roadmap_main_flush();
new_full_path = roadmap_path_join( roadmap_path_debug(), *new_cursor );
new_context= malloc(sizeof(upload_context));
new_context->cursor = new_cursor;
new_context->files = uContext->files;
new_context->full_path = new_full_path;
new_context->file_num = new_count;
new_context->total = total;
target_url = roadmap_config_get ( &RMCfgDebugInfoServer);
if ( editor_upload_auto( new_full_path, &gUploadCallbackFunctions, target_url, LOG_UPLOAD_CONTENT_TYPE,(void *)new_context) )
{
roadmap_log( ROADMAP_ERROR, "File upload error. for file %s , number %d", new_full_path, new_count);
roadmap_path_free(new_full_path);
roadmap_path_list_free (new_context->files);
ssd_progress_msg_dialog_hide();
roadmap_messagebox_timeout("Error", "Error sending files",5);
in_process = 0;
}
}
roadmap_path_free(uContext->full_path);
free(uContext);
}
/* Name : download_done_callback( void *context )
* Purpose : Download callback: Done
*
*/
static void download_done_callback( void *context_cb, char *last_modified, const char *format, ... )
{
DownloadContext* context = (DownloadContext*) context_cb;
const char* path = context->voice_path;
RoadMapFile file;
roadmap_log( ROADMAP_INFO, "Download is finished. Writing %d bytes to the file: %s", context->data_size, path );
// Save the voice to the file
file = roadmap_file_open( path, "w" );
if ( !file )
{
roadmap_log( ROADMAP_WARNING, "File openning error for file: %s", path );
}
roadmap_file_write( file, context->data, context->data_size );
roadmap_file_close(file);
ssd_progress_msg_dialog_hide();
context->download_cb( context->context_cb, 0, context->voice_path );
// Add file to cache
download_cache_add( path );
// Deallocate the download context
free( context->data );
roadmap_path_free( context->voice_path );
free( context );
}
void RealtimeAltRoutes_OnRouteResults (NavigateRouteRC rc, int num_res, const NavigateRouteResult *res){
int i;
CalculatingAltRoutes = FALSE;
if (num_res > MAX_ROUTES)
num_res = MAX_ROUTES;
if (rc != route_succeeded){
roadmap_main_remove_periodic(route_request_timeout);
ssd_progress_msg_dialog_hide ();
roadmap_log(ROADMAP_ERROR,"RealtimeAltRoutes_OnRouteResults failed rc=%d", rc );
return;
}
roadmap_log (ROADMAP_DEBUG,"RealtimeAltRoutes_OnRouteResults %d", num_res);
altRoutesTrips.altRoutTrip[0].iNumRoutes = num_res;
for (i = 0; i < num_res ; i++){
altRoutesTrips.altRoutTrip[0].pRouteResults[i] = *(res+i);//todo check
}
altRoutesTrips.altRoutTrip[0].iTripLenght = altRoutesTrips.altRoutTrip[0].pRouteResults[0].total_time;
altRoutesTrips.altRoutTrip[0].iTripDistance = altRoutesTrips.altRoutTrip[0].pRouteResults[0].total_length;
roadmap_alternative_routes_routes_dialog(gShowListFirst);
roadmap_screen_refresh();
}
static void on_user_lang_downloaded(void){
clean_up();
ssd_progress_msg_dialog_hide();
roadmap_screen_refresh();
if (GeoConfigContext.callback)
(*GeoConfigContext.callback)();
GeoConfigContext.callback = NULL;
}
static void RealtimeAltRoutes_OnRouteRC (NavigateRouteRC rc, int protocol_rc, const char *description) {
CalculatingAltRoutes = FALSE;
// TODO put error handling
if (rc == route_succeeded) {
roadmap_main_remove_periodic(route_request_timeout);
ssd_progress_msg_dialog_hide ();
}
}
static void on_lang_conf_downloaded(void){
ssd_progress_msg_dialog_hide();
clean_up();
#ifndef IPHONE_NATIVE
lang_dlg();
#else
roadmap_general_settings_show_lang_initial(lang_loaded);
#endif // !IPHONE_NATIVE
}
static void upload_error_callback( void *context) {
upload_context * uContext = (upload_context *)context;
ssd_progress_msg_dialog_hide();
roadmap_messagebox_timeout("Error", "Error sending files",5);
in_process = 0;
roadmap_file_remove(NULL, uContext->full_path);
roadmap_path_list_free(uContext->files);
roadmap_path_free(uContext->full_path);
free(uContext);
}
const char* roadmap_foursquare_response(int status, roadmap_result* rc, int NumParams, const char* pData){
roadmap_main_remove_periodic(request_time_out);
ssd_progress_msg_dialog_hide();
if (status != 200){
switch (gsRequestType) {
case ROADMAP_FOURSQUARE_LOGIN:
roadmap_log( ROADMAP_ERROR, "roadmap_foursquare_response (login) - Command failed (status= %d)", status );
roadmap_foursquare_login_failed(status);
break;
case ROADMAP_FOURSQUARE_SEARCH:
roadmap_log( ROADMAP_ERROR, "roadmap_foursquare_response (search) - Command failed (status= %d)", status );
roadmap_messagebox ("Oops", "Could not connect with Foursquare. Try again later.");
break;
case ROADMAP_FOURSQUARE_CHECKIN:
roadmap_log( ROADMAP_ERROR, "roadmap_foursquare_response (checkin) - Command failed (status= %d)", status );
roadmap_messagebox ("Oops", "Could not connect with Foursquare. Try again later.");
break;
default:
roadmap_log( ROADMAP_ERROR, "roadmap_foursquare_response (unknown) - Command failed (status= %d)", status );
}
gsRequestType = ROADMAP_FOURSQUARE_NONE;
return pData;
}
switch (gsRequestType) {
case ROADMAP_FOURSQUARE_LOGIN:
roadmap_log( ROADMAP_DEBUG, "roadmap_foursquare_response (login) - successful");
roadmap_foursquare_set_logged_in(TRUE);
gsRequestType = ROADMAP_FOURSQUARE_NONE;
if (gsCheckInOnLogin)
roadmap_foursquare_checkin();
break;
case ROADMAP_FOURSQUARE_SEARCH:
roadmap_log( ROADMAP_DEBUG, "roadmap_foursquare_response (search) - successful");
gsRequestType = ROADMAP_FOURSQUARE_NONE;
return parse_search_results(rc, NumParams, pData);
break;
case ROADMAP_FOURSQUARE_CHECKIN:
roadmap_log( ROADMAP_DEBUG, "roadmap_foursquare_response (checkin) - successful");
gsRequestType = ROADMAP_FOURSQUARE_NONE;
return parse_checkin_results(rc, NumParams, pData);
break;
default:
roadmap_log( ROADMAP_DEBUG, "roadmap_foursquare_response (unknown) - - successful");
}
return pData;
}
static void route_request_timeout(void)
{
roadmap_main_remove_periodic( route_request_timeout );
ssd_progress_msg_dialog_hide();
if (CalculatingAltRoutes)
{
char msg[128];
snprintf(msg, sizeof(msg), "%s.\n%s", roadmap_lang_get("Routing service timed out"), roadmap_lang_get("Please try again later"));
roadmap_messagebox_timeout("Oops",msg ,5);
roadmap_analytics_log_event (ANALYTICS_EVENT_ROUTE_ERROR, ANALYTICS_EVENT_INFO_ERROR, "TimeOut");
navigate_route_cancel_request();
CalculatingAltRoutes = FALSE;
}
}
static void on_search(void)
{
SsdWidget list_cont;
SsdWidget edit;
const char* text;
roadmap_result rc;
SsdWidget dlg = generic_search_dlg_get_search_dlg(search_local);
if (!RealTimeLoginState()){
roadmap_messagebox( roadmap_lang_get( "Search location"),
roadmap_lang_get( "Search requires internet connection."
"Please make sure you are connected."));
return;
}
edit = generic_search_dlg_get_search_edit_box(search_local);
s_searching = TRUE;
roadmap_main_set_periodic( 100, search_progress_message_delayed );
text = ssd_text_get_text( edit );
list_cont= dlg->context;
rc = local_search_resolve_address( list_cont, on_address_resolved, text );
if( succeeded == rc)
{
roadmap_main_set_cursor( ROADMAP_CURSOR_WAIT);
roadmap_log(ROADMAP_DEBUG,
"local_search_dlg::on_search() - Started Web-Service transaction: Resolve address");
}
else
{
const char* err = roadmap_result_string( rc);
s_searching = FALSE;
roadmap_log(ROADMAP_ERROR,
"local_search_dlg::on_search() - Resolve process transaction failed to start");
/* Close the progress message */
ssd_progress_msg_dialog_hide();
roadmap_messagebox_cb ( roadmap_lang_get( "Search location"),
roadmap_lang_get( err ), on_search_error_message );
}
}
void roadmap_geo_config_transaction_failed(void){
ssd_progress_msg_dialog_hide();
#ifdef J2ME
roadmap_messagebox_cb ("Oops",
"Network connection is not available. Please check your device's network settings.",roadmap_geo_config_failed_cb);
#else
roadmap_messagebox ("Oops",
"Network connection is not available. Please check your device's network settings.");
#endif
clean_up();
//Remove timer
roadmap_main_remove_periodic (GeoConfigTimer);
roadmap_screen_refresh();
// on error, exit, don't continue.
if (GeoConfigContext.callback)
(*GeoConfigContext.callback)();
}
void roadmap_foursquare_login (const char *user_name, const char *password) {
BOOL success;
gsRequestType = ROADMAP_FOURSQUARE_LOGIN;
#ifdef IPHONE
delayed_show_progress();
#else
roadmap_main_set_periodic(100, delayed_show_progress);
#endif //IPHONE
roadmap_main_set_periodic(FOURSQUARE_REQUEST_TIMEOUT, request_time_out);
success = Realtime_FoursquareConnect(user_name, password,
roadmap_foursquare_is_tweet_login_enabled() && roadmap_twitter_logged_in());
if (!success) {
roadmap_main_remove_periodic(request_time_out);
ssd_progress_msg_dialog_hide();
gsRequestType = ROADMAP_FOURSQUARE_NONE;
roadmap_main_set_periodic (100, foursquare_network_error);
}
}
void roadmap_foursquare_request_failed (roadmap_result status) {
roadmap_main_remove_periodic(request_time_out);
ssd_progress_msg_dialog_hide();
switch (gsRequestType) {
case ROADMAP_FOURSQUARE_LOGIN:
roadmap_log( ROADMAP_ERROR, "roadmap_foursquare_response (login) - network failed (status= %d)", status );
roadmap_foursquare_login_failed(status);
break;
case ROADMAP_FOURSQUARE_SEARCH:
roadmap_log( ROADMAP_ERROR, "roadmap_foursquare_response (search) - network failed failed (status= %d)", status );
roadmap_messagebox ("Oops", "Could not connect with Foursquare. Try again later.");
break;
case ROADMAP_FOURSQUARE_CHECKIN:
roadmap_log( ROADMAP_ERROR, "roadmap_foursquare_response (checkin) - network failed (status= %d)", status );
roadmap_messagebox ("Oops", "Could not connect with Foursquare. Try again later.");
break;
default:
roadmap_log( ROADMAP_ERROR, "roadmap_foursquare_response (unknown) - network failed (status= %d)", status );
}
gsRequestType = ROADMAP_FOURSQUARE_NONE;
}
void GeoConfigTimer (void) {
roadmap_log (ROADMAP_ERROR,"GeoServerConfig Timeout!! received %d out of %d", GeoConfigContext.num_received+1, GeoConfigContext.num_results );
ssd_progress_msg_dialog_hide();
roadmap_log(ROADMAP_ERROR,"Geo config timed out : exiting");
roadmap_messagebox_cb ("Oops",
"Could not establish network connection. Please check your device's network settings.", roadmap_geo_config_failed_cb);
clean_up();
roadmap_screen_refresh();
//Remove timer
roadmap_main_remove_periodic (GeoConfigTimer);
/* - if geo config failed - Exit.
if (GeoConfigContext.callback)
(*GeoConfigContext.callback)();
*/
}
const char* on_get_pois_res(int NumParams,const char* pData){
int i;
int iBufferSize;
int longitude;
int latitude;
char poiName[MAX_POI_NAME];
char *argv[ahi__count];
char temp[20];
char msg[100];
int numRecords = NumParams/3;
roadmap_log( ROADMAP_WARNING, "roadmap_tripserver_response- got GetPOIsRes (Num parameters= %d )",NumParams );
if (numRecords > 0)
purge_old_favorites();
for (i = 0; i < numRecords; i++){
//POI name
iBufferSize = sizeof(poiName);
pData = ExtractNetworkString(
pData, // [in] Source string
poiName, // [out] Output buffer
&iBufferSize, // [in,out] Buffer size / Size of extracted string
",", // [in] Array of chars to terminate the copy operation
1); // [in] Remove additional termination chars
if (!pData){
roadmap_log( ROADMAP_ERROR, "Tripserver::on_get_pois_res() - Failed to read POI name");
return NULL;
}
//POI Lon
pData = ReadIntFromString(
pData, // [in] Source string
",", // [in,opt] Value termination
NULL, // [in,opt] Allowed padding
&longitude, // [out] Put it here
1); // [in] Remove
if (!pData){
roadmap_log( ROADMAP_ERROR, "Tripserver::on_get_pois_res() - Failed to read Destination longitude. POI Name=%s",poiName );
return NULL;
}
//POI Lat
pData = ReadIntFromString(
pData, // [in] Source string
",\r\n", // [in,opt] Value termination
NULL, // [in,opt] Allowed padding
&latitude, // [out] Put it here
TRIM_ALL_CHARS);// [in] Remove
if (!pData){
roadmap_log( ROADMAP_ERROR, "Tripserver::on_get_pois_res() - Failed to read Destination latitude. POI Name=%s",poiName );
return NULL;
}
argv[ahi_house_number] = "";
argv[ahi_street] = "";
argv[ahi_city] = "";
argv[ahi_state] = "";
argv[ahi_name] = (char *)poiName;
sprintf(temp, "%d", latitude);
argv[ahi_latitude] = strdup(temp);
sprintf(temp, "%d", longitude);
argv[ahi_longtitude] = strdup(temp);
argv[ahi_synced] = "true";
roadmap_log( ROADMAP_WARNING, "roadmap_tripserver_response- GetPOIsRes Adding favorite (name=%s, lat=%s, lon=%s )", argv[ahi_name], argv[ahi_latitude], argv[ahi_longtitude]);
roadmap_history_add (ADDRESS_FAVORITE_CATEGORY, (const char **)argv);
}
ssd_progress_msg_dialog_hide();
if (numRecords == 0)
sprintf(msg, "%s", roadmap_lang_get("No favorite destinations were found"));
else if (numRecords == 1)
sprintf(msg, "%s", roadmap_lang_get("1 destination was restored to your favorites"));
else
sprintf(msg, "%d %s", numRecords, roadmap_lang_get("destinations were restored to your favorites"));
roadmap_messagebox_timeout("Favorites", msg, 5);
roadmap_history_save();
return pData;
}
static void request_time_out (void){
roadmap_main_remove_periodic(request_time_out);
ssd_progress_msg_dialog_hide();
roadmap_messagebox("Oops", "Could not connect with Foursquare. Try again later.");
}
static void on_address_resolved( void* context,
address_candidate* array,
int size,
roadmap_result rc)
{
static const char* results[ADSR_MAX_RESULTS+1];
static void* indexes[ADSR_MAX_RESULTS+1];
static const char* icons[ADSR_MAX_RESULTS+1];
SsdWidget list_cont = (SsdWidget)context;
SsdWidget list;
int i;
s_searching = FALSE;
/* Close the progress message */
ssd_progress_msg_dialog_hide();
roadmap_main_set_cursor( ROADMAP_CURSOR_NORMAL);
assert(list_cont);
list = ssd_widget_get( list_cont, ASD_RC_LIST_NAME);
if( succeeded != rc)
{
if( is_network_error( rc))
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"),
roadmap_lang_get( "Search requires internet connection.\r\nPlease make sure you are connected."), on_search_error_message );
else if( err_as_could_not_find_matches == rc)
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"),
roadmap_lang_get( "Sorry, no results were found for this search"), on_search_error_message );
else
{
char msg[128];
snprintf( msg, sizeof(msg), "%s\n%s",roadmap_lang_get("Sorry we were unable to complete the search"), roadmap_lang_get("Please try again later"));
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"), msg, on_search_error_message );
}
roadmap_log(ROADMAP_ERROR,
"address_search_dlg::on_address_resolved() - Resolve process failed with error '%s' (%d)",
roadmap_result_string( rc), rc);
return;
}
if( !size)
{
roadmap_log(ROADMAP_DEBUG,
"address_search_dlg::on_address_resolved() - NO RESULTS for the address-resolve process");
return;
}
assert( size <= ADSR_MAX_RESULTS);
if (size == 1 && s_auto_start_nav) {
s_auto_start_nav = FALSE;
generic_search_dlg_switch_gui();
ssd_dialog_hide_all( dec_close);
navigate(1);
return;
}
for( i=0; i<size; i++)
{
results[i] = array[i].address;
indexes[i] = (void*)i;
icons[i] = "search_address";
}
results[i] = roadmap_lang_get(COULDNT_FIND_ADDRESS_TEXT);
indexes[i] = (void*)COULDNT_FIND_INDEX;
icons[i] = "submit_logs";
if ( roadmap_native_keyboard_enabled() )
{
roadmap_native_keyboard_hide();
}
ssd_list_populate(list,
size+1,
results,
(const void **)indexes,
icons,
0,
on_list_item_selected,
NULL,
FALSE);
generic_search_dlg_switch_gui();
}
static void on_search(void)
{
SsdWidget list_cont;
SsdWidget edit;
const char* text;
roadmap_result rc;
const char* dl_prefix = roadmap_lang_get ("map:");
SsdWidget dlg = generic_search_dlg_get_search_dlg(search_address);
edit = generic_search_dlg_get_search_edit_box(search_address);
if ( !strcmp( DEBUG_LEVEL_SET_PATTERN, ssd_text_get_text( edit ) ) )
{
roadmap_start_reset_debug_mode();
return;
}
if ( !strcmp( "##@coord", ssd_text_get_text( edit ) ) )
{
roadmap_gps_reset_show_coordinates();
return;
}
if ( !strcmp( "##@il", ssd_text_get_text( edit ) ) )
{
roadmap_geo_config_il(NULL);
return;
}
if ( !strcmp( "##@usa", ssd_text_get_text( edit ) ) )
{
roadmap_geo_config_usa(NULL);
return;
}
if ( !strcmp( "##@other", ssd_text_get_text( edit ) ) )
{
roadmap_geo_config_other(NULL);
return;
}
if ( !strcmp( "##@stg", ssd_text_get_text( edit ) ) )
{
roadmap_geo_config_stg(NULL);
return;
}
if ( !strcmp( "##@heb", ssd_text_get_text( edit ) ) )
{
roadmap_lang_set_system_lang("heb", TRUE);
roadmap_messagebox("", "Language changed to Hebrew, please restart waze");
return;
}
if ( !strcmp( "##@eng", ssd_text_get_text( edit ) ) )
{
roadmap_lang_set_system_lang("eng", TRUE);
roadmap_messagebox("","Language changed to English, please restart waze");
return;
}
if ( !strcmp( "cc@tts", ssd_text_get_text( edit ) ) )
{
tts_clear_cache();
roadmap_messagebox("","TTS cache has been cleared!");
return;
}
if ( !strcmp( "##@tts", ssd_text_get_text( edit ) ) )
{
tts_set_feature_enabled( !tts_feature_enabled() );
if ( tts_feature_enabled() )
{
roadmap_messagebox("","TTS Feature is enabled!\nPlease restart WAZE.");
}
else
{
roadmap_messagebox("","TTS Feature is disabled!");
}
navigate_main_override_nav_settings();
return;
}
if ( !strcmp( "dbg@tts", ssd_text_get_text( edit ) ) )
{
if ( !strcmp( tts_was_provider_voices_set(), TTS_WAS_VOICES_SET_PRODUCTION ) )
{
tts_was_provider_apply_voices_set( TTS_WAS_VOICES_SET_DEBUG );
roadmap_messagebox("","TTS Feature is running in debug mode!\nPlease restart WAZE.");
}
else
{
tts_was_provider_apply_voices_set( TTS_WAS_VOICES_SET_PRODUCTION );
roadmap_messagebox("","TTS Feature is running in production mode!\nPlease restart WAZE.");
}
return;
}
if ( !strncmp( dl_prefix, ssd_text_get_text( edit ), strlen( dl_prefix ) ) )
{
roadmap_map_download_region( ssd_text_get_text( edit ) + strlen( dl_prefix ),
roadmap_locator_static_county() );
ssd_dialog_hide_all( dec_close);
if (!roadmap_screen_refresh ())
roadmap_screen_redraw();
return;
}
s_searching = TRUE;
roadmap_main_set_periodic( 100, search_progress_message_delayed );
text = ssd_text_get_text( edit );
list_cont= dlg->context;
rc = address_search_resolve_address( list_cont, on_address_resolved, text );
if( succeeded == rc)
{
roadmap_main_set_cursor( ROADMAP_CURSOR_WAIT);
roadmap_log(ROADMAP_DEBUG,
"address_search_dlg::on_search() - Started Web-Service transaction: Resolve address");
}
else
{
const char* err = roadmap_result_string( rc);
s_searching = FALSE;
roadmap_log(ROADMAP_ERROR,
"address_search_dlg::on_search() - Resolve process transaction failed to start");
/* Close the progress message */
ssd_progress_msg_dialog_hide();
roadmap_messagebox_cb ( roadmap_lang_get( "Resolve Address"),
roadmap_lang_get( err ), on_search_error_message );
}
}
static void on_address_resolved( void* context,
address_candidate* array,
int size,
roadmap_result rc)
{
static const char* results[ADSR_MAX_RESULTS+1];
static void* indexes[ADSR_MAX_RESULTS+1];
static const char* icons[ADSR_MAX_RESULTS+1];
const char* provider_icon = NULL;
SsdWidget list_cont = (SsdWidget)context;
SsdWidget list;
SsdWidget bmp_logo = NULL;
int i;
s_searching = FALSE;
/* Close the progress message */
ssd_progress_msg_dialog_hide();
roadmap_main_set_cursor( ROADMAP_CURSOR_NORMAL);
assert(list_cont);
list = ssd_widget_get( list_cont, LSD_RC_LIST_NAME);
if( succeeded != rc)
{
if( is_network_error( rc))
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"),
roadmap_lang_get( "Search requires internet connection.\r\n"
"Please make sure you are connected."), on_search_error_message );
else if( err_as_could_not_find_matches == rc)
roadmap_messagebox_cb ( roadmap_lang_get( "Oops"),
roadmap_lang_get( "Sorry, no results were found for this search"), on_search_error_message );
else
{
char msg[128];
snprintf( msg, sizeof(msg), "%s\n%s",roadmap_lang_get("Sorry we were unable to complete the search"), roadmap_lang_get("Please try again later"));
roadmap_messagebox_cb ( roadmap_lang_get( "Search location"), msg, on_search_error_message );
}
roadmap_log(ROADMAP_ERROR,
"local_search_dlg::on_address_resolved() - Resolve process failed with error '%s' (%d)",
roadmap_result_string( rc), rc);
return;
}
if( !size)
{
roadmap_log(ROADMAP_DEBUG,
"local_search_dlg::on_address_resolved() - NO RESULTS for the address-resolve process");
return;
}
assert( size <= ADSR_MAX_RESULTS);
provider_icon = local_search_get_icon_name();
for( i=0; i<size; i++)
{
results[i] = array[i].address;
indexes[i] = (void*)i;
icons[i] = provider_icon;
}
if ( roadmap_native_keyboard_enabled() )
{
roadmap_native_keyboard_hide();
}
/*
* Update the results container logo
* dynamically according to the current provider
*/
bmp_logo = ssd_widget_get( s_result_container, "local search icon" );
ssd_bitmap_update( bmp_logo, local_search_get_logo_name() );
ssd_list_populate(list,
size,
results,
(const void **)indexes,
icons,
0,
on_list_item_selected,
NULL,
FALSE);
generic_search_dlg_switch_gui();
}
static void on_recieved_completed (void) {
char updateText[] = "We've made a few infrastructural changes that require re-start. Please exit and re-start waze.";
const char *user_lang = roadmap_lang_get_user_lang();//"heb";//todomt
const char *force_lang = roadmap_config_get( &RoadMapConfigForceLanguage);
// compare the old and new server id's - if different, user needs to restart
int oldServerId = roadmap_config_get_integer(&RoadMapConfigSystemServerId);
int newServerId = GeoConfigContext.id;
// Save the RT server ID.
roadmap_config_set_integer (&RoadMapConfigSystemServerId,
GeoConfigContext.id);
#ifndef J2ME // in J2ME don't download the language until user chooses it manually // TODODAN
//set the language
if (!strcmp(force_lang, "")){
roadmap_lang_set_system_lang (GeoConfigContext.lang, NULL);
}else{
roadmap_lang_set_system_lang (force_lang, NULL);
}
#endif
// Save version
roadmap_config_set_integer (&RoadMapConfigGeoConfigVersion,
GeoConfigContext.version);
//Save new configuration
roadmap_config_save (0);
//Remove timer
roadmap_main_remove_periodic (GeoConfigTimer);
roadmap_log (ROADMAP_DEBUG,"GeoServerConfig Completed setting all parameters!!" );
roadmap_log (ROADMAP_INFO, "GeoServerConfig: user_lang='%s' newServerId=%d", user_lang, newServerId );
if ((user_lang[0] == 0) && (newServerId != 2)){
roadmap_lang_download_conf_file(on_lang_conf_downloaded);
return;
}
if ((user_lang[0] == 0) && (newServerId == 2)){
roadmap_lang_set_system_lang(GeoConfigContext.lang, NULL);
}
if ((oldServerId==-1)){
ssd_progress_msg_dialog_show("Downloading language");
roadmap_lang_download_lang_file(roadmap_lang_get_system_lang(), on_user_lang_downloaded); //on_user_lang_downloaded();//todomt
return;
}
#ifndef J2ME
roadmap_lang_download_lang_file(GeoConfigContext.lang, NULL);
#endif
ssd_progress_msg_dialog_hide();
clean_up();
roadmap_screen_refresh();
if (GeoConfigContext.callback)
(*GeoConfigContext.callback)();
GeoConfigContext.callback = NULL;
// if ((oldServerId!=newServerId)&&(oldServerId!=-1)){
//
// roadmap_lang_set_update_time("");
//#ifndef J2ME
// roadmap_lang_set_lang_file_update_time("heb","");
// roadmap_lang_set_lang_file_update_time("eng","");
//#endif
// roadmap_prompts_set_update_time ("");
// roadmap_splash_set_update_time ("");
// roadmap_splash_reset_check_time();
// roadmap_config_save(FALSE);
//#if (defined (IPHONE) || defined (ANDROID))
// roadmap_tile_remove_all(roadmap_locator_active());
//#endif
// roadmap_messagebox_cb(roadmap_lang_get("Please restart Waze"), roadmap_lang_get(updateText), restart_msg_cb);
// }
}
static void hide_timer(void){
ssd_progress_msg_dialog_hide();
if (!roadmap_screen_refresh())
roadmap_screen_redraw();
roadmap_main_remove_periodic (hide_timer);
}
static void on_search(void)
{
SsdWidget list_cont;
SsdWidget edit;
const char* text;
roadmap_result rc;
const char* dl_prefix = roadmap_lang_get ("map:");
SsdWidget dlg = generic_search_dlg_get_search_dlg(search_address);
edit = generic_search_dlg_get_search_edit_box(search_address);
if ( !strcmp( DEBUG_LEVEL_SET_PATTERN, ssd_text_get_text( edit ) ) )
{
roadmap_start_reset_debug_mode();
return;
}
if ( !strcmp( "##@il", ssd_text_get_text( edit ) ) )
{
roadmap_geo_config_il(NULL);
return;
}
if ( !strcmp( "##@usa", ssd_text_get_text( edit ) ) )
{
roadmap_geo_config_usa(NULL);
return;
}
if ( !strcmp( "##@heb", ssd_text_get_text( edit ) ) )
{
roadmap_lang_set_system_lang("heb");
roadmap_messagebox("", "changed to hebrew, please restart wase");
return;
}
if ( !strcmp( "##@eng", ssd_text_get_text( edit ) ) )
{
roadmap_messagebox("","changed to english, please restart wase");
roadmap_lang_set_system_lang("eng");
return;
}
if ( !strncmp( dl_prefix, ssd_text_get_text( edit ), strlen( dl_prefix ) ) )
{
roadmap_map_download_region( ssd_text_get_text( edit ) + strlen( dl_prefix ),
roadmap_locator_static_county() );
ssd_dialog_hide_all( dec_close);
if (!roadmap_screen_refresh ())
roadmap_screen_redraw();
return;
}
s_searching = TRUE;
roadmap_main_set_periodic( 100, search_progress_message_delayed );
text = ssd_text_get_text( edit );
list_cont= dlg->context;
rc = address_search_resolve_address( list_cont, on_address_resolved, text );
if( succeeded == rc)
{
roadmap_main_set_cursor( ROADMAP_CURSOR_WAIT);
roadmap_log(ROADMAP_DEBUG,
"address_search_dlg::on_search() - Started Web-Service transaction: Resolve address");
}
else
{
const char* err = roadmap_result_string( rc);
s_searching = FALSE;
roadmap_log(ROADMAP_ERROR,
"address_search_dlg::on_search() - Resolve process transaction failed to start");
/* Close the progress message */
ssd_progress_msg_dialog_hide();
roadmap_messagebox_cb ( roadmap_lang_get( "Resolve Address"),
roadmap_lang_get( err ), on_search_error_message );
}
}
///////////////////////////////////////////////////////
// Compress files and prepare for upload
int upload () {
const char* directory = roadmap_path_debug();
const char* target_url;
char *full_path;
upload_context * context;
#ifndef RIMAPI
char **files = roadmap_path_list (directory, ".gz");
#else
char ** files = malloc(sizeof(char *)*2); // temporary workaround, until path list is implemented
files[0] = strdup(zipped_log_name);
files[1] = NULL;
#endif
int count;
int total;
char **cursor;
// Set the target to upload to
sprintf (warning_message,"%s",roadmap_lang_get("Uploading logs..."));
ssd_progress_msg_dialog_show(warning_message);
roadmap_main_flush();
count = 0;
for (cursor = files; *cursor != NULL; ++cursor) {
count++;
}
cursor = files;
total = count;
count = 0;
target_url = roadmap_config_get ( &RMCfgDebugInfoServer);
context= malloc(sizeof(upload_context));
context->cursor = cursor;
context->files = files;
context->file_num = count;
context->total = total;
full_path = roadmap_path_join( directory, *cursor );
context->full_path = full_path;
sprintf (warning_message,"%s\n%d/%d",roadmap_lang_get("Uploading logs..."),count+1, context->total);
ssd_progress_msg_dialog_show(warning_message);
roadmap_main_flush();
// this starts the async sending sequence. Further progress is done through the callbacks.
if ( editor_upload_auto( full_path, &gUploadCallbackFunctions, target_url, LOG_UPLOAD_CONTENT_TYPE,(void *)context) )
{
roadmap_log( ROADMAP_ERROR, "File upload error. for file %s ", full_path);
roadmap_path_free(full_path);
roadmap_path_list_free (files);
ssd_progress_msg_dialog_hide();
free(context);
return 0;
}
return 1;
}
///////////////////////////////////////////////////////
// Compress files and prepare for upload
int prepare_for_upload ()
{
int res;
char out_filename[256];
char **files;
char **cursor;
const char* directory;
int count;
int total;
time_t now;
struct tm *tms;
char year[5], month[5], day[5];
#ifdef RIMAPI
timeStruct time_s;
#endif
sprintf (warning_message,"%s",roadmap_lang_get("Preparing files for upload..."));
ssd_progress_msg_dialog_show(warning_message);
roadmap_main_flush();
//Count files for upload
directory = roadmap_path_gps();
files = roadmap_path_list (directory, ".csv");
count = 1; //Counting also the postmortem
for (cursor = files; *cursor != NULL; ++cursor) {
count++;
}
total = count;
count = 0;
//Prepare log
count++;
sprintf (warning_message,"%s\n%d/%d",roadmap_lang_get("Preparing files for upload..."),count, total);
ssd_progress_msg_dialog_show(warning_message);
roadmap_main_flush();
// Building the filename
time( &now );
tms = localtime( &now );
#ifdef RIMAPI
roadmap_time_get_time(&time_s);
tms->tm_hour = time_s.hours;
tms->tm_min = time_s.minutes;
#endif
GET_2_DIGIT_STRING( tms->tm_mday, day );
GET_2_DIGIT_STRING( tms->tm_mon+1, month ); // Zero based from January
GET_2_DIGIT_STRING( tms->tm_year-100, year ); // Year from 1900
snprintf(out_filename,256, "%s%s%s__%d_%d__%s_%d_%s__%s.gz", day, month, year,
tms->tm_hour, tms->tm_min, RealTime_GetUserName(), RT_DEVICE_ID, roadmap_start_version(), roadmap_log_filename());
#ifndef RIMAPI
res = roadmap_zlib_compress(roadmap_log_path(), roadmap_log_filename(), roadmap_path_debug(), out_filename, COMPRESSION_LEVEL,TRUE);
#else
// 0 = Z_OK = SUCCESS. 1 = failure.
res = NOPH_ZLib_compress(roadmap_log_path(), roadmap_log_filename(), roadmap_path_debug(),out_filename,COMPRESSION_LEVEL);
strcpy(zipped_log_name,out_filename); // emporary until path_list is implemented
#endif
if (res != Z_OK) {
ssd_progress_msg_dialog_hide();
return 0;
}
//Prepare CSV files
for (cursor = files; *cursor != NULL; ++cursor) {
count++;
sprintf (warning_message,"%s\n%d/%d",roadmap_lang_get("Preparing files for upload..."),count, total);
ssd_progress_msg_dialog_show(warning_message);
roadmap_main_flush();
sprintf(out_filename, "%s%s.gz", *cursor, RealTime_GetUserName());
#ifndef J2ME
res = roadmap_zlib_compress(directory, *cursor, roadmap_path_debug(), out_filename, COMPRESSION_LEVEL,FALSE);
#else
// 0 = Z_OK = SUCCESS. 1 = failure.
res = NOPH_ZLib_compress(directory, *cursor, roadmap_path_debug(),out_filename,COMPRESSION_LEVEL);
#endif
if (res != Z_OK) {
ssd_progress_msg_dialog_hide();
return 0;
} else {
roadmap_file_remove(directory, *cursor);
}
}
roadmap_path_list_free (files);
ssd_progress_msg_dialog_hide();
return 1;
}
static void retry(void){
if (!request_geo_config())
ssd_progress_msg_dialog_hide();
}
