From: Duane Gearhart Date: Thu, 21 Jul 2016 20:22:18 +0000 (-0400) Subject: Added capability to process mapzen route reponse X-Git-Tag: submit/tizen_3.0/20161108.012559~43 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=a672be804623d32366363364efa89c57118202aa;p=platform%2Fcore%2Flocation%2Fmaps-plugin-mapzen.git Added capability to process mapzen route reponse Change-Id: Iaaeba2c455db3ca0a281502af058031a26042d87 --- diff --git a/.gitignore b/.gitignore index 33971eb..458de59 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ .project +.tproject .cproject .settings/* diff --git a/src/mapzen/mapzen_jsonparser.cpp b/src/mapzen/mapzen_jsonparser.cpp index 9830db6..a65ebb8 100644 --- a/src/mapzen/mapzen_jsonparser.cpp +++ b/src/mapzen/mapzen_jsonparser.cpp @@ -24,6 +24,7 @@ extern "C" { #include "mapzen_queue.h" #include "mapzen_debug.h" +#include "mapzen_types.h" #include "mapzen_util.h" } @@ -39,17 +40,13 @@ extern "C" { #define ROUTE_UNIT_CONVERSION_MILE_TO_FT(x) (5280 * (x)) #define ROUTE_UNIT_CONVERSION_MILE_TO_YD(x) (1760 * (x)) -static route_unit __route_unit = UNIT_M; -static int __maneuver_index = 0; -static coords_s __destination_point; +static route_unit __route_unit = UNIT_KM; constexpr double kPolylinePrecision = 1E6; constexpr double kInvPolylinePrecision = 1.0 / kPolylinePrecision; //TODO: port this to c? or port the whole project to c++ or add all the proper externs -void decode_shape(const std::string& encoded, - std::vector& output) -{ +void decode_shape(const std::string& encoded, std::vector& output) { // what byte are we looking at size_t i = 0; @@ -77,7 +74,7 @@ void decode_shape(const std::string& encoded, int lon = deserialize(last_lon); // Shift the decimal point 5 places to the left and add to the output - maps_coordinates_s ll; + coords_s ll; ll.latitude = static_cast(lat) * kInvPolylinePrecision; ll.longitude = static_cast(lon) * kInvPolylinePrecision; output.emplace_back(std::move(ll)); @@ -347,11 +344,355 @@ static void __parse_place_response(char *response, int size, GList **placeList) /********************* ROUTE RESPONSE ***********************/ -static void __parse_route_response(char *response, int size, int *status, mapzen_route_resp_s **routeResp) +static void __process_shape(std::vector& decoded_shape, GList *shapePoints) +{ + MAP_DEBUG(">>>>> START __process_shape"); + coords_s *coords = NULL; + + for (auto& shape_pt : decoded_shape) { + coords = (coords_s *)g_malloc0(sizeof(coords_s)); + coords->latitude = shape_pt.latitude; + coords->longitude = shape_pt.longitude; + if (shapePoints == NULL) + shapePoints = g_list_append(shapePoints, (gpointer)coords); + else + shapePoints = g_list_insert_before(shapePoints, NULL, (gpointer)coords); + } + MAP_DEBUG(">>>>> END __process_shape"); +} + +static void __create_bounding_box(std::vector& pts, rectangle_s& bounding_box) +{ + MAP_DEBUG(">>>>> START __create_bounding_box"); + auto p = pts.begin(); + double min_lon = p->longitude; + double max_lon = min_lon; + double min_lat = p->latitude; + double max_lat = min_lat; + p++; + for (; p < pts.end(); p++) { + if (p->longitude < min_lon) + min_lon = p->longitude; + else if (p->longitude > max_lon) + max_lon = p->longitude; + if (p->latitude < min_lat) + min_lat = p->latitude; + else if (p->latitude > max_lat) + max_lat = p->latitude; + } + bounding_box.top_left.latitude = max_lat; + bounding_box.top_left.longitude = min_lon; + bounding_box.bottom_right.latitude = min_lat; + bounding_box.bottom_right.longitude = max_lon; + + MAP_DEBUG(">>>>> END __create_bounding_box"); +} + +static void __parse_maneuvers(rapidjson::Value::ConstMemberIterator maneuvers, mapzen_route_segment *segment_resp, std::vector& segment_shape) { - if (!response || !status || !routeResp) return; + MAP_DEBUG(">>>>> START __parse_maneuvers"); + + rapidjson::Value::ConstMemberIterator begin_shape_index, end_shape_index, maneuver_time, + maneuver_distance, type, travel_type, travel_mode, street_names_resp; + rapidjson::Value::ConstValueIterator street_name; + + for (rapidjson::Value::ConstValueIterator maneuver = + maneuvers->value.Begin(); maneuver != maneuvers->value.End(); + ++maneuver) { + mapzen_route_maneuver *maneuver_resp = (mapzen_route_maneuver *)g_malloc(sizeof(mapzen_route_maneuver)); + + + // Set maneuver start point + begin_shape_index = maneuver->FindMember("begin_shape_index"); + if (begin_shape_index != maneuver->MemberEnd()) { + maneuver_resp->start_point = segment_shape.at(begin_shape_index->value.GetInt()); + MAP_DEBUG(">>>>> PROCESS __parse_maneuvers: maneuver_resp->start_point=%f,%f", maneuver_resp->start_point.latitude, maneuver_resp->start_point.longitude); + } + + // Set maneuver end point + end_shape_index = maneuver->FindMember("end_shape_index"); + if (end_shape_index != maneuver->MemberEnd()) { + maneuver_resp->end_point = segment_shape.at(end_shape_index->value.GetInt()); + MAP_DEBUG(">>>>> PROCESS __parse_maneuvers: maneuver_resp->end_point=%f,%f", maneuver_resp->end_point.latitude, maneuver_resp->end_point.longitude); + } + + // Set maneuver distance + maneuver_distance = maneuver->FindMember("length"); + if (maneuver_distance != maneuver->MemberEnd()) { + MAP_DEBUG(">>>>> __parse_maneuvers: PROCESS maneuver_distance: %f", maneuver_distance->value.GetDouble()); + maneuver_resp->distance = maneuver_distance->value.GetDouble(); + } + + // Set maneuver time + maneuver_time = maneuver->FindMember("time"); + if (maneuver_time != maneuver->MemberEnd()) { + MAP_DEBUG(">>>>> __parse_maneuvers: PROCESS maneuver_time: %d", maneuver_time->value.GetInt()); + maneuver_resp->time = maneuver_time->value.GetInt(); + } + + // Set maneuver type + type = maneuver->FindMember("type"); + if (type != maneuver->MemberEnd()) { + maneuver_resp->type = type->value.GetInt(); + MAP_DEBUG(">>>>> PROCESS __parse_maneuvers: type=%d", maneuver_resp->type); + } + + // Set maneuver instruction + __get_string((*maneuver), "instruction", &maneuver_resp->instruction); + + // Set maneuver street names + maneuver_resp->street_name = NULL; + street_names_resp = maneuver->FindMember("street_names"); + if (street_names_resp != maneuver->MemberEnd() && street_names_resp->value.IsArray()) { + std::string street_name; + + for (rapidjson::Value::ConstValueIterator street_name_resp = street_names_resp->value.Begin(); + street_name_resp != street_names_resp->value.End(); ++street_name_resp) { + street_name += std::string(street_name.size()? "/": ""); + street_name += street_name_resp->GetString(); + } + if (street_name.size() > 0) { + MAP_DEBUG(">>>>> PROCESS __parse_maneuvers: street_name=%s", street_name.c_str()); + maneuver_resp->street_name = (gchar *)g_malloc0(street_name.size() + 1); + if (maneuver_resp->street_name) { + strcpy(maneuver_resp->street_name, street_name.c_str()); + MAP_DEBUG(">>>>> PROCESS __parse_maneuvers: maneuver_resp->street_name=%s", maneuver_resp->street_name); + } + } + } + + // Append maneuver to maneuver list + if (segment_resp->maneuvers == NULL) { + MAP_DEBUG(">>>>> __parse_route_response: PROCESS segment_resp->maneuvers == NULL) - append"); + segment_resp->maneuvers = g_list_append(segment_resp->maneuvers, (gpointer)maneuver_resp); + } else { + MAP_DEBUG(">>>>> __parse_route_response: PROCESS segment_resp->maneuvers != NULL) - insert before"); + segment_resp->maneuvers = g_list_insert_before(segment_resp->maneuvers, NULL, (gpointer)maneuver_resp); + } + } // end process each maneuver + + MAP_DEBUG(">>>>> END __parse_maneuvers"); +} + +static bool __determine_segment_origin_destination(const rapidjson::Value& locations, + rapidjson::SizeType& location_index, coords_s& origin, + coords_s& destination) { + bool origin_set = false; + bool destination_set = false; + + // Set origin + for (rapidjson::SizeType i = location_index; i < locations.Size(); i++) { + auto& location = locations[i]; + if (location["type"] == "break") { + origin.latitude = location["lat"].GetDouble(); + origin.longitude = location["lon"].GetDouble(); + origin_set = true; + // Increment location index to find segment destination + location_index = ++i; + break; + } + } + + // Set destination + for (rapidjson::SizeType i = location_index; i < locations.Size(); i++) { + auto& location = locations[i]; + if (location["type"] == "break") { + destination.latitude = location["lat"].GetDouble(); + destination.longitude = location["lon"].GetDouble(); + destination_set = true; + // Assign location index for next segment origin + location_index = i; + break; + } + } + + // Validate that both origin and destination are set + if (origin_set and destination_set) { + return true; + } + + return false; +} + +static void __parse_route_response(char *response, int size, int *status, mapzen_route_resp_s **routeResp) { + MAP_DEBUG(">>>>> START __parse_route_response"); + + if (!response || !status || !routeResp) + return; *routeResp = NULL; + MAP_DEBUG(">>>>> PROCESS __parse_route_response: ROUTE RESPONSE returned=%s", response); + + rapidjson::Document document; + document.Parse(std::string(response, size).c_str()); + rapidjson::Value::MemberIterator trip = document.FindMember("trip"); + if (trip == document.MemberEnd()) { + MAP_DEBUG(">>>>> PROCESS __parse_route_response: trip object not found in response"); + return; + } + + // Process status + rapidjson::Value::ConstMemberIterator trip_status = trip->value.FindMember("status"); + if (trip_status != trip->value.MemberEnd()) { + *status = trip_status->value.GetInt(); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: trip_status=%d", *status); + } + if (*status != 0) { + MAP_DEBUG(">>>>> PROCESS __parse_route_response: invalid status in response"); + return; + } + + // Create route response object and initialize lists to NULL + *routeResp = (mapzen_route_resp_s *) g_malloc(sizeof(mapzen_route_resp_s)); + if (!(*routeResp)) + return; + (*routeResp)->segments = NULL; + (*routeResp)->shapePoints = NULL; + + // Get trip locations + rapidjson::SizeType location_index = 0; + rapidjson::Value& locations = trip->value["locations"]; + MAP_DEBUG(">>>>> PROCESS __parse_route_response: locations.Size(): %d", locations.Size()); + + // Set trip origin + rapidjson::Value& mapzen_origin = locations[0]; + (*routeResp)->origin.latitude = mapzen_origin["lat"].GetDouble(); + (*routeResp)->origin.longitude = mapzen_origin["lon"].GetDouble(); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: trip origin: %f,%f", (*routeResp)->origin.latitude, (*routeResp)->origin.longitude); + + // Set trip destination + rapidjson::Value& mapzen_destination = locations[locations.Size()-1]; + (*routeResp)->destination.latitude = mapzen_destination["lat"].GetDouble(); + (*routeResp)->destination.longitude = mapzen_destination["lon"].GetDouble(); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: trip destination: %f,%f", (*routeResp)->destination.latitude, (*routeResp)->destination.longitude); + + // Set language + __get_string(trip->value, "language", &(*routeResp)->language); + + // Set distance units + // TODO just read response units and set value + (*routeResp)->distance_unit = __route_unit; + + // Set trip distance and time + rapidjson::Value::ConstMemberIterator trip_summary = trip->value.FindMember("summary"); + if (trip_summary != trip->value.MemberEnd()) { + rapidjson::Value::ConstMemberIterator trip_distance = trip_summary->value.FindMember("length"); + if (trip_distance != trip_summary->value.MemberEnd()) { + (*routeResp)->distance = trip_distance->value.GetDouble(); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: trip length : %f", (*routeResp)->distance); + } + rapidjson::Value::ConstMemberIterator trip_time = trip_summary->value.FindMember("time"); + if (trip_time != trip_summary->value.MemberEnd()) { + (*routeResp)->time = trip_time->value.GetInt(); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: trip time: %d", trip_time->value.GetInt()); + } + } + + // Type + // TODO - set from input + (*routeResp)->type = COSTING_AUTO; + + // Trip bounding box points + std::vector trip_bounding_box_candidates; + + /////////////////////////////////////////////////////////////////////////// + // Process segments (legs) + rapidjson::Value::MemberIterator legs = trip->value.FindMember("legs"); + if (legs == trip->value.MemberEnd() || !legs->value.IsArray()) { + MAP_DEBUG(">>>>> PROCESS __parse_route_response: invalid legs in response"); + return; + } + for (rapidjson::Value::ConstValueIterator leg = legs->value.Begin(); leg != legs->value.End(); ++leg) { + // Create segment response + mapzen_route_segment *segment_resp = (mapzen_route_segment *)g_malloc(sizeof(mapzen_route_segment)); + segment_resp->maneuvers = NULL; + segment_resp->shapePoints = NULL; + + // Determine segment origin and destination + coords_s segment_origin; + coords_s segment_destination; + if (!__determine_segment_origin_destination(locations, location_index, segment_origin, segment_destination)) { + MAP_DEBUG(">>>>> PROCESS __parse_route_response: invalid segment origin and destination"); + return; + } + + // Set segment origin + segment_resp->origin = segment_origin; + MAP_DEBUG(">>>>> PROCESS __parse_route_response: segment_origin: %f,%f", segment_origin.latitude, segment_origin.longitude); + + // Set segment destination + segment_resp->destination = segment_destination; + MAP_DEBUG(">>>>> PROCESS __parse_route_response: segment_destination: %f,%f", segment_destination.latitude, segment_destination.longitude); + + // Set segment distance & time + rapidjson::Value::ConstMemberIterator leg_summary = leg->FindMember("summary"); + if (leg_summary != leg->MemberEnd()) { + rapidjson::Value::ConstMemberIterator leg_distance = leg_summary->value.FindMember("length"); + if (leg_distance != leg_summary->value.MemberEnd()) { + segment_resp->distance = leg_distance->value.GetDouble(); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: leg length=%f", segment_resp->distance); + } + rapidjson::Value::ConstMemberIterator leg_time = leg_summary->value.FindMember("time"); + if (leg_time != leg_summary->value.MemberEnd()) { + segment_resp->time = leg_time->value.GetInt(); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: leg time=%d", segment_resp->time); + } + } + + // Get segment encoded shape and decode + auto encoded_shape = leg->FindMember("shape"); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: ENCODED SHAPE=%s", encoded_shape->value.GetString()); + std::vector decoded_shape; + decode_shape(encoded_shape->value.GetString(), decoded_shape); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: Segment shape point count=%d", decoded_shape.size()); + + // Append shape for route trip and segment + MAP_DEBUG(">>>>> PROCESS __parse_route_response: PRE __process_shape"); + __process_shape(decoded_shape, (*routeResp)->shapePoints); + __process_shape(decoded_shape, segment_resp->shapePoints); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: POST __process_shape"); + + // Set segment bounding box + rectangle_s segment_bounding_box; + __create_bounding_box(decoded_shape, segment_bounding_box); + segment_resp->bounding_box = segment_bounding_box; + MAP_DEBUG(">>>>> PROCESS __parse_route_response: segment_bounding_box.top_left =%f,%f", segment_resp->bounding_box.top_left.latitude, segment_resp->bounding_box.top_left.longitude); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: segment_bounding_box.bottom_right =%f,%f", segment_resp->bounding_box.bottom_right.latitude, segment_resp->bounding_box.bottom_right.longitude); + + // Add segment bounding box points to the trip bounding box candidates + trip_bounding_box_candidates.push_back(segment_bounding_box.top_left); + trip_bounding_box_candidates.push_back(segment_bounding_box.bottom_right); + + rapidjson::Value::ConstMemberIterator maneuvers = leg->FindMember("maneuvers"); + if (maneuvers == leg->MemberEnd() || !maneuvers->value.IsArray()) + return; + + /////////////////////////////////////////////////////////////////////// + // Process each maneuver + MAP_DEBUG(">>>>> PROCESS __parse_route_response: PRE __parse_maneuvers"); + __parse_maneuvers(maneuvers, segment_resp, decoded_shape); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: POST __parse_maneuvers"); + /////////////////////////////////////////////////////////////////////// + + // Add segment to segment list + if ((*routeResp)->segments == NULL) { + MAP_DEBUG(">>>>> PROCESS __parse_route_response: (*routeResp)->maneuvers == NULL) - append"); + (*routeResp)->segments = g_list_append((*routeResp)->segments, (gpointer)segment_resp); + } else { + MAP_DEBUG(">>>>> PROCESS __parse_route_response: (*routeResp)->maneuvers != NULL) - insert before"); + (*routeResp)->segments = g_list_insert_before((*routeResp)->segments, NULL, (gpointer)segment_resp); + } + } // end process each leg + /////////////////////////////////////////////////////////////////////////// + + // Trip Bounding box + rectangle_s trip_bounding_box; + __create_bounding_box(trip_bounding_box_candidates, trip_bounding_box); + (*routeResp)->bounding_box = trip_bounding_box; + MAP_DEBUG(">>>>> PROCESS __parse_route_response: trip_bounding_box.top_left =%f,%f", (*routeResp)->bounding_box.top_left.latitude, (*routeResp)->bounding_box.top_left.longitude); + MAP_DEBUG(">>>>> PROCESS __parse_route_response: trip_bounding_box.bottom_right =%f,%f", (*routeResp)->bounding_box.bottom_right.latitude, (*routeResp)->bounding_box.bottom_right.longitude); + + MAP_DEBUG(">>>>> END __parse_route_response"); } void post_curl_response(char *response, int size, mapzen_resp_type type, void *user_data) @@ -577,53 +918,60 @@ void post_curl_response(char *response, int size, mapzen_resp_type type, void *u break; } case RESP_TYPE_ROUTE: - { - MAP_DEBUG("Inside Route JSON Parsing.."); - int status = -1; - MapzenRouteQueryData *queryData = (MapzenRouteQueryData *)user_data; - __route_unit = queryData->unit; - __maneuver_index = 0; - __destination_point = queryData->destination; - - MapzenRouteResponseData *responseData = (MapzenRouteResponseData *)g_malloc(sizeof(MapzenRouteResponseData)); - - if (responseData) { - responseData->requestId = queryData->requestId; - responseData->route_cb = queryData->route_cb; - responseData->user_data = queryData->user_data; - - if (response && (size > 0)) { - /* Coords Result GList */ - mapzen_route_resp_s *routeResponse = NULL; - - MAP_DEBUG("Route :- Parsing Response"); - __parse_route_response(response, size, &status, &routeResponse); - - if (routeResponse != NULL) { - /* Put the response in queue */ - responseData->error = __convert_status(status); - responseData->routeResponse = routeResponse; - } else { - /* REPSONSE PARSING FAILURE */ - MAP_DEBUG("route Response is NULL"); - responseData->error = __convert_status(status); - responseData->routeResponse = NULL; - } + { + MAP_DEBUG(">>>>> RESP_TYPE_ROUTE"); + int status = -1; + MapzenRouteQueryData *queryData = (MapzenRouteQueryData *)user_data; + MAP_DEBUG(">>>>> set the following: __route_unit"); + __route_unit = queryData->unit; + + MAP_DEBUG(">>>>> PROCESS post_curl_response: prepare MapzenRouteResponseData"); + MapzenRouteResponseData *responseData = (MapzenRouteResponseData *)g_malloc(sizeof(MapzenRouteResponseData)); + + if (responseData) { + responseData->requestId = queryData->requestId; + responseData->route_cb = queryData->route_cb; + responseData->user_data = queryData->user_data; + + if (response && (size > 0)) { + /* Coords Result GList */ + mapzen_route_resp_s *routeResponse = NULL; + + MAP_DEBUG(">>>>> PRE __parse_route_response"); + __parse_route_response(response, size, &status, &routeResponse); + MAP_DEBUG(">>>>> POST __parse_route_response"); + + if (routeResponse != NULL) { + MAP_DEBUG(">>>>> PROCESS post_curl_response: (routeResponse != NULL)"); + MAP_DEBUG(">>>>> PROCESS post_curl_response: status=%d", status); + MAP_DEBUG(">>>>> PROCESS post_curl_response: __convert_status(status)=%d", __convert_status(status)); + /* Put the response in queue */ + responseData->error = __convert_status(status); + responseData->routeResponse = routeResponse; } else { + /* REPSONSE PARSING FAILURE */ + MAP_DEBUG(">>>>> post_curl_response: routeResponse is NULL"); responseData->error = __convert_status(status); responseData->routeResponse = NULL; } - - mapzen_push_to_queue(type, (gpointer)responseData); + } else { + MAP_DEBUG(">>>>> post_curl_response: JSON response is NULL"); + responseData->error = __convert_status(status); + responseData->routeResponse = NULL; } - if (queryData) { - g_free(queryData); - queryData = NULL; - } + MAP_DEBUG(">>>>> PROCESS post_curl_response: PRE mapzen_push_to_queue"); + mapzen_push_to_queue(type, (gpointer)responseData); + MAP_DEBUG(">>>>> PROCESS post_curl_response: POST mapzen_push_to_queue"); + } - break; + if (queryData) { + g_free(queryData); + queryData = NULL; } + + break; + } default: { MAP_DEBUG("Inside default JSON Parsing.."); diff --git a/src/mapzen/mapzen_queue.c b/src/mapzen/mapzen_queue.c index 46a78d0..c140803 100644 --- a/src/mapzen/mapzen_queue.c +++ b/src/mapzen/mapzen_queue.c @@ -1396,70 +1396,140 @@ static void __free_place_list_response(void *ptr) static void __free_route_response(void *ptr) { + MAP_DEBUG(">>>>> START __free_route_response"); + MapzenRouteResponseData *routeData = (MapzenRouteResponseData *) (ptr); if (routeData) { + MAP_DEBUG(">>>>> __free_route_response PROCESS: routeData"); mapzen_route_resp_s *route_info = routeData->routeResponse; if (route_info) { - GList *maneuver_data = NULL; - maneuver_data = g_list_first(route_info->maneuvers); - while (maneuver_data) { - mapzen_route_maneuver *maneuver = (mapzen_route_maneuver *) maneuver_data->data; - - if (maneuver->instruction) { - g_free(maneuver->instruction); - maneuver->instruction = NULL; - } - if (maneuver->formatted_time) { - g_free(maneuver->formatted_time); - maneuver->formatted_time = NULL; - } - if (maneuver->direction_name) { - g_free(maneuver->direction_name); - maneuver->direction_name = NULL; - } - if (maneuver->street_name) { - g_free(maneuver->street_name); - maneuver->street_name = NULL; + MAP_DEBUG(">>>>> __free_route_response PROCESS: route_info"); + + GList *segment_data = NULL; + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE segment_data"); + segment_data = g_list_first(route_info->segments); + while (segment_data) { + mapzen_route_segment *segment = (mapzen_route_segment *) segment_data->data; + + GList *maneuver_data = NULL; + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE maneuver_data"); + maneuver_data = g_list_first(segment->maneuvers); + while (maneuver_data) { + MAP_DEBUG(">>>>> __free_route_response PROCESS: maneuver_data"); + mapzen_route_maneuver *maneuver = (mapzen_route_maneuver *) maneuver_data->data; + + if (maneuver->instruction) { + MAP_DEBUG(">>>>> __free_route_response PROCESS: instruction"); + g_free(maneuver->instruction); + maneuver->instruction = NULL; + } + + if (maneuver->street_name) { + MAP_DEBUG(">>>>> __free_route_response PROCESS: street_name"); + g_free(maneuver->street_name); + maneuver->street_name = NULL; + } + + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE segments->maneuvers g_list_remove"); + segment->maneuvers = g_list_remove(segment->maneuvers, (gpointer)maneuver); + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST segments->maneuvers g_list_remove"); + + g_free(maneuver); + maneuver = NULL; + + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE segment->maneuvers g_list_first"); + /* Fetching the next item from Maneuver/Segment list */ + maneuver_data = g_list_first(segment->maneuvers); + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST segment->maneuvers g_list_first"); + } /* Loop over maneuvers */ + + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST while (maneuver_data)"); + g_list_free(segment->maneuvers); + segment->maneuvers = NULL; + + GList *segmentShapePoints = NULL; + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE segmentShapePoints"); + segmentShapePoints = g_list_first(segment->shapePoints); + while (segmentShapePoints) { + MAP_DEBUG(">>>>> __free_route_response PROCESS: segmentShapePoints"); + coords_s *data = (coords_s *) segmentShapePoints->data; + + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE g_list_remove"); + segment->shapePoints = g_list_remove(segment->shapePoints, (gpointer)data); + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST g_list_remove"); + + g_free(data); + data = NULL; + + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE g_list_first"); + segmentShapePoints = g_list_first(segment->shapePoints); + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST g_list_first"); } - route_info->maneuvers = g_list_remove(route_info->maneuvers, (gpointer)maneuver); + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST while (segmentShapePoints)"); + g_list_free(segment->shapePoints); + segment->shapePoints = NULL; + + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE route_info->segments g_list_remove"); + route_info->segments = g_list_remove(route_info->segments, (gpointer)segment); + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST route_info->segments g_list_remove"); - g_free(maneuver); - maneuver = NULL; + g_free(segment); + segment = NULL; + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE route_info->segments g_list_first"); /* Fetching the next item from Maneuver/Segment list */ - maneuver_data = g_list_first(route_info->maneuvers); - } - g_list_free(route_info->maneuvers); - route_info->maneuvers = NULL; + segment_data = g_list_first(route_info->segments); + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST route_info->segments g_list_first"); + + } /* Loop over segments */ + + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST while (segment_data)"); + g_list_free(route_info->segments); + route_info->segments = NULL; GList *shapePoints = NULL; + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE shapePoints"); shapePoints = g_list_first(route_info->shapePoints); while (shapePoints) { + MAP_DEBUG(">>>>> __free_route_response PROCESS: shapePoints"); coords_s *data = (coords_s *) shapePoints->data; + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE g_list_remove"); route_info->shapePoints = g_list_remove(route_info->shapePoints, (gpointer)data); + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST g_list_remove"); g_free(data); data = NULL; + MAP_DEBUG(">>>>> __free_route_response PROCESS: PRE g_list_first"); shapePoints = g_list_first(route_info->shapePoints); + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST g_list_first"); } + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST while (shapePoints)"); g_list_free(route_info->shapePoints); route_info->shapePoints = NULL; - if (route_info->formatted_time) { - g_free(route_info->formatted_time); - route_info->formatted_time = NULL; + if (route_info->language) { + MAP_DEBUG(">>>>> __free_route_response PROCESS: language"); + g_free(route_info->language); + route_info->language = NULL; } + + MAP_DEBUG(">>>>> __free_route_response PROCESS: g_free(route_info)"); g_free(route_info); route_info = NULL; } + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST route_info"); + if (routeData->user_data) { + MAP_DEBUG(">>>>> __free_route_response PROCESS: user_data"); g_free(routeData->user_data); routeData->user_data = NULL; + MAP_DEBUG(">>>>> __free_route_response PROCESS: POST user_data"); } } + MAP_DEBUG(">>>>> END __free_route_response"); } int mapzen_init_queue() diff --git a/src/mapzen/mapzen_route.cpp b/src/mapzen/mapzen_route.cpp index 1d1195d..41db4f2 100644 --- a/src/mapzen/mapzen_route.cpp +++ b/src/mapzen/mapzen_route.cpp @@ -53,7 +53,7 @@ std::string url_encode(const std::string& unencoded) { int query_route(gchar *maps_key, coords_s startPoint, coords_s endPoint, route_type type, route_feature_avoids avoids, route_driving_style style, GList *waypoints, gpointer user_data) { - MAP_DEBUG("**********IN QUERY ROUTE!!**************"); + MAP_DEBUG(">>>>> START query_route"); rapidjson::StringBuffer buffer; rapidjson::Writer writer(buffer); @@ -64,6 +64,7 @@ int query_route(gchar *maps_key, coords_s startPoint, coords_s endPoint, route_t //{"locations":[{"lat":42.358528,"lon":-83.271400,"street":"Appleton"},{"lat":42.996613,"lon":-78.749855,"street":"Ranch Trail"}] int length = g_list_length(waypoints); if (length != 0) { + MAP_DEBUG(">>>>> query_route: PROCESS list of route locations"); int index = 0; GList *waypoints_list = NULL; waypoints_list = g_list_first(waypoints); @@ -72,7 +73,6 @@ int query_route(gchar *maps_key, coords_s startPoint, coords_s endPoint, route_t while (waypoints_list) { coords_s *data = (coords_s *) waypoints_list->data; - MAP_DEBUG("**********IN WAYPOINT LIST******************"); for (unsigned i = 0; i < sizeof(data); i++) { writer.StartObject(); writer.Key("lat"); @@ -86,6 +86,7 @@ int query_route(gchar *maps_key, coords_s startPoint, coords_s endPoint, route_t } writer.EndArray(); } else { + MAP_DEBUG(">>>>> query_route: PROCESS two route locations"); writer.Key("locations"); writer.StartArray(); @@ -106,6 +107,7 @@ int query_route(gchar *maps_key, coords_s startPoint, coords_s endPoint, route_t writer.EndArray(); } + MAP_DEBUG(">>>>> query_route: PROCESS type"); std::string costing_str; switch (type) { case COSTING_AUTO: @@ -127,16 +129,19 @@ int query_route(gchar *maps_key, coords_s startPoint, coords_s endPoint, route_t costing_str = "auto"; } + MAP_DEBUG(">>>>> query_route: PROCESS costing"); writer.Key("costing"); writer.String(costing_str.c_str()); + MAP_DEBUG(">>>>> query_route: PROCESS directions_options"); writer.Key("directions_options"); writer.StartObject(); writer.Key("units"); - writer.String("mi"); + writer.String("km"); // TODO determine if we should set from userdata writer.EndObject(); if (avoids) { + MAP_DEBUG(">>>>> query_route: PROCESS avoids"); writer.Key("costing_options"); writer.StartObject(); switch (avoids) { @@ -171,13 +176,14 @@ int query_route(gchar *maps_key, coords_s startPoint, coords_s endPoint, route_t // end json request object writer.EndObject(); - MAP_DEBUG("********** query_route: buffer=%s", buffer.GetString()); + MAP_DEBUG(">>>>> query_route: JSON request=%s", buffer.GetString()); const char* jsonString = buffer.GetString(); //we think that this is already being encoded somewhere else //std::string encoded_json = url_encode(json); + MAP_DEBUG(">>>>> query_route: PROCESS routeRequest"); char routeRequest[1024]; if (maps_key != NULL) snprintf(routeRequest, sizeof(routeRequest), ROUTE_URL, maps_key, jsonString); @@ -185,8 +191,11 @@ int query_route(gchar *maps_key, coords_s startPoint, coords_s endPoint, route_t snprintf(routeRequest, sizeof(routeRequest), ROUTE_URL, "null", jsonString); add_handle(routeRequest, REQ_TYPE_ROUTE, user_data); + + MAP_DEBUG(">>>>> END query_route"); return 0; } + #ifdef __cplusplus } #endif diff --git a/src/mapzen/mapzen_types.h b/src/mapzen/mapzen_types.h index 00f452a..8c70154 100644 --- a/src/mapzen/mapzen_types.h +++ b/src/mapzen/mapzen_types.h @@ -51,7 +51,6 @@ typedef enum { } route_type; typedef enum { - UNIT_M = 0, /* for miles */ UNIT_KM /* for kilometers */ } route_unit; @@ -177,25 +176,32 @@ typedef struct { coords_s end_point; gdouble distance; guint time; - gchar *formatted_time; - guint attribute; - guint turn_type; - guint direction; + guint type; gchar *instruction; - gchar *direction_name; - guint index; gchar *street_name; } mapzen_route_maneuver; typedef struct { + coords_s origin; + coords_s destination; + rectangle_s bounding_box; + gdouble distance; + guint time; + GList *maneuvers; /* List of type mapzen_route_maneuver */ + GList *shapePoints; +} mapzen_route_segment; + +typedef struct { + coords_s origin; + coords_s destination; rectangle_s bounding_box; gdouble distance; route_unit distance_unit; guint time; - gchar *formatted_time; route_type type; - GList *maneuvers; /* List of type mapzen_route_maneuver */ + GList *segments; /* List of type mapzen_route_segment */ GList *shapePoints; + gchar *language; } mapzen_route_resp_s; #endif /* _MAPZEN_TYPES_H_ */ diff --git a/src/mapzen_plugin.c b/src/mapzen_plugin.c index 799b0e1..fac363b 100644 --- a/src/mapzen_plugin.c +++ b/src/mapzen_plugin.c @@ -613,167 +613,298 @@ EXPORT_API int maps_plugin_reverse_geocode(double latitude, double longitude, co static void __mapzen_route_cb(mapzen_error_e result, int request_id, mapzen_route_resp_s *route_info, void *user_data) { - MAPS_LOGD("__mapzen_route_cb"); + MAPS_LOGD(">>>>> START __mapzen_route_cb"); + + MAPS_LOGD(">>>>> PRE callback_info_route cast"); callback_info_route *calldata_route = (callback_info_route *) user_data; + MAPS_LOGD(">>>>> POST callback_info_route cast"); + maps_error_e error; if (route_info) { - maps_route_h route; - maps_route_create(&route); - + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS route_info"); + maps_route_h tizen_route; + int route_create_resp = maps_route_create(&tizen_route); + if (route_create_resp != MAPS_ERROR_NONE) + MAPS_LOGD(">>>>> __mapzen_route_cb: ERROR maps_route_create"); + else + MAPS_LOGD(">>>>> __mapzen_route_cb: GOOD maps_route_create"); + if (!tizen_route) + MAPS_LOGD(">>>>> __mapzen_route_cb: ERROR tizen_route handle is null START"); + + /* Set trip origin */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign trip origin"); + maps_coordinates_h origin; + maps_coordinates_create(route_info->origin.latitude, route_info->origin.longitude, &origin); + error = maps_route_set_origin(tizen_route, origin); + if (error != MAPS_ERROR_NONE) + MAPS_LOGD(">>>>> __mapzen_route_cb: ERROR trip maps_route_set_origin"); + maps_coordinates_destroy(origin); + + /* Set trip destination */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign trip destination"); + maps_coordinates_h destination; + maps_coordinates_create(route_info->destination.latitude, route_info->destination.longitude, &destination); + error = maps_route_set_destination(tizen_route, destination); + if (error != MAPS_ERROR_NONE) + MAPS_LOGD(">>>>> __mapzen_route_cb: ERROR trip maps_route_set_destination"); + maps_coordinates_destroy(destination); + + /* Create trip top left point for bounding box */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS trip top_left"); maps_coordinates_h top_left; maps_coordinates_create(route_info->bounding_box.top_left.latitude, route_info->bounding_box.top_left.longitude, &top_left); + /* Create trip bottom right point for bounding box */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS trip bottom_right"); maps_coordinates_h bottom_right; maps_coordinates_create(route_info->bounding_box.bottom_right.latitude, route_info->bounding_box.bottom_right.longitude, &bottom_right); + /* Set trip bounding box */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS trip maps_area_create_rectangle"); maps_area_h bounds = NULL; maps_area_create_rectangle(top_left, bottom_right, &bounds); - maps_route_set_bounding_box(route, bounds); + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS trip maps_route_set_bounding_box"); + maps_route_set_bounding_box(tizen_route, bounds); maps_area_destroy(bounds); + /* Clean up trip top left and bottom right points */ maps_coordinates_destroy(top_left); maps_coordinates_destroy(bottom_right); - maps_distance_unit_e unit = MAPS_DISTANCE_UNIT_M; - - switch (route_info->distance_unit) { - case UNIT_M: - unit = MAPS_DISTANCE_UNIT_M; + /* Set transport mode */ + switch (route_info->type) { + case COSTING_BICYCLE: + maps_route_set_transport_mode(tizen_route, MAPS_ROUTE_TRANSPORT_MODE_BICYCLE); break; - case UNIT_KM: - unit = MAPS_DISTANCE_UNIT_KM; + case COSTING_MULTIMODAL: + maps_route_set_transport_mode(tizen_route, MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT); + break; + case COSTING_PEDESTRIAN: + maps_route_set_transport_mode(tizen_route, MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN); break; - /*case ROUTE_UNIT_FT: - unit = MAPS_DISTANCE_UNIT_FT; + case COSTING_AUTO: + case COSTING_AUTO_SHORTER: + default: + maps_route_set_transport_mode(tizen_route, MAPS_ROUTE_TRANSPORT_MODE_CAR); break; - case ROUTE_UNIT_YD: - unit = MAPS_DISTANCE_UNIT_YD; - break;*/ } - maps_route_set_distance_unit(route, unit); - maps_route_set_total_distance(route, route_info->distance); - maps_route_set_total_duration(route, (long) route_info->time); - if (route_info->type == COSTING_AUTO) - maps_route_set_transport_mode(route, MAPS_ROUTE_TRANSPORT_MODE_CAR); - else if (route_info->type == COSTING_PEDESTRIAN) - maps_route_set_transport_mode(route, MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN); - else if (route_info->type == COSTING_BICYCLE) - maps_route_set_transport_mode(route, MAPS_ROUTE_TRANSPORT_MODE_BICYCLE); - else if (route_info->type == COSTING_MULTIMODAL) - maps_route_set_transport_mode(route, MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT); - else - maps_route_set_transport_mode(route, MAPS_ROUTE_TRANSPORT_MODE_CAR); - - maps_item_list_h segment_list = NULL; - maps_item_list_create(&segment_list); - - GList *maneuver_data = NULL; - maneuver_data = g_list_first(route_info->maneuvers); + /* Set total distance */ + maps_route_set_total_distance(tizen_route, route_info->distance); - while (maneuver_data) { - maps_route_segment_h segment = NULL; - maps_route_segment_create(&segment); + /* Set total duration */ + maps_route_set_total_duration(tizen_route, (long) route_info->time); - maps_route_maneuver_h man = NULL; - maps_route_maneuver_create(&man); - mapzen_route_maneuver *maneuver = (mapzen_route_maneuver *) maneuver_data->data; - - /* Segment Origin and Destination */ - maps_coordinates_h segmentStartPoint; - maps_coordinates_create(maneuver->start_point.latitude, maneuver->start_point.longitude, &segmentStartPoint); - maps_route_segment_set_origin(segment, segmentStartPoint); /* origin */ - maps_coordinates_destroy(segmentStartPoint); - - maps_coordinates_h segmentEndPoint; - maps_coordinates_create(maneuver->end_point.latitude, maneuver->end_point.longitude, &segmentEndPoint); - - MAPS_LOGD(">>> Segment start : %f, %f <<<", maneuver->start_point.latitude, maneuver->start_point.longitude); - MAPS_LOGD(">>> Segment end : %f, %f <<<", maneuver->end_point.latitude, maneuver->end_point.longitude); - - maps_route_segment_set_destination(segment, segmentEndPoint); /* destination */ - maps_coordinates_destroy(segmentEndPoint); - - /* Segment distance */ - maps_route_segment_set_distance(segment, maneuver->distance); - maps_route_segment_set_duration(segment, maneuver->time); + /* Determine distance units */ + maps_distance_unit_e unit = MAPS_DISTANCE_UNIT_KM; + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS distance_unit"); + switch (route_info->distance_unit) { + default: + unit = MAPS_DISTANCE_UNIT_KM; + break; + } - /* Maneuver distance */ - maps_route_maneuver_set_distance_to_next_instruction(man, maneuver->distance); - maps_route_maneuver_set_time_to_next_instruction(man, maneuver->time); + /* Set distance units */ + maps_route_set_distance_unit(tizen_route, unit); + + /* Setup for segment list */ + GList *segment_data = NULL; + segment_data = g_list_first(route_info->segments); + maps_item_list_h tizen_segment_list = NULL; + maps_item_list_create(&tizen_segment_list); + + /*********************************************************************/ + /* Loop over segments */ + MAPS_LOGD(">>>>> PROCESS __mapzen_route_cb: Loop over segments"); + while (segment_data) { + + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS create segment"); + maps_route_segment_h tizen_segment = NULL; + maps_route_segment_create(&tizen_segment); + mapzen_route_segment *segment = (mapzen_route_segment *) segment_data->data; + + /* Set segment origin */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign segment origin"); + maps_coordinates_h origin; + maps_coordinates_create(segment->origin.latitude, segment->origin.longitude, &origin); + error = maps_route_segment_set_origin(tizen_segment, origin); + if (error != MAPS_ERROR_NONE) + MAPS_LOGD(">>>>> __mapzen_route_cb: ERROR segment maps_route_set_origin"); + maps_coordinates_destroy(origin); + + /* Set segment destination */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign segment destination"); + maps_coordinates_h destination; + maps_coordinates_create(segment->destination.latitude, segment->destination.longitude, &destination); + error = maps_route_segment_set_destination(tizen_segment, destination); + if (error != MAPS_ERROR_NONE) + MAPS_LOGD(">>>>> __mapzen_route_cb: ERROR segment maps_route_set_destination"); + maps_coordinates_destroy(destination); + + /* Create segment top left point for bounding box */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS segment top_left"); + maps_coordinates_h top_left; + maps_coordinates_create(segment->bounding_box.top_left.latitude, segment->bounding_box.top_left.longitude, &top_left); + + /* Create segment bottom right point for bounding box */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS segment bottom_right"); + maps_coordinates_h bottom_right; + maps_coordinates_create(segment->bounding_box.bottom_right.latitude, segment->bounding_box.bottom_right.longitude, &bottom_right); + + /* Set segment bounding box */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS segment maps_area_create_rectangle"); + maps_area_h bounds = NULL; + maps_area_create_rectangle(top_left, bottom_right, &bounds); + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS segment maps_route_set_bounding_box"); + maps_route_segment_set_bounding_box(tizen_segment, bounds); + maps_area_destroy(bounds); + + /* Clean up segment top left and bottom right points */ + maps_coordinates_destroy(top_left); + maps_coordinates_destroy(bottom_right); + + /* Set segment distance and time */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign segment distance and time"); + maps_route_segment_set_distance(tizen_segment, segment->distance); + maps_route_segment_set_duration(tizen_segment, segment->time); + + /* Set segment path */ + /* TODO */ + + /* Set up for maneuver list */ + GList *maneuver_data = NULL; + maneuver_data = g_list_first(segment->maneuvers); + maps_item_list_h tizen_maneuver_list = NULL; + maps_item_list_create(&tizen_maneuver_list); + + /*********************************************************************/ + /* Loop over maneuvers */ + MAPS_LOGD(">>>>> PROCESS __mapzen_route_cb: Loop over maneuvers"); + while (maneuver_data) { + + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS create maneuver"); + maps_route_maneuver_h tizen_maneuver = NULL; + maps_route_maneuver_create(&tizen_maneuver); + mapzen_route_maneuver *maneuver = (mapzen_route_maneuver *) maneuver_data->data; + + /* Set maneuver direction */ + /* TODO just set to none */ + + /* Set turn type from maneuver type */ + /* TODO transform */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign turn type"); + /* maps_route_maneuver_set_turn_type(tizen_maneuver, __convert_route_turn_type(maneuver->turn_type)); */ + + /* Set maneuver position */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign maneuver position"); + maps_coordinates_h coord; + maps_coordinates_create(maneuver->start_point.latitude, maneuver->start_point.longitude, &coord); + maps_route_maneuver_set_position(tizen_maneuver, coord); + maps_coordinates_destroy(coord); - /*maps_route_maneuver_set_turn_type(man, __convert_route_turn_type(maneuver->turn_type)); */ + /* Set maneuver instruction */ + if (maneuver->instruction) { + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign instruction: %s", maneuver->instruction); + maps_route_maneuver_set_instruction_text(tizen_maneuver, (char *) maneuver->instruction); + } - /* maneuver_set_traffic_direction(man, (traffic_direction_e)action_id); */ + /* Set maneuver street name */ + if (maneuver->street_name) { + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign street names: %s", maneuver->street_name); + maps_route_maneuver_set_road_name(tizen_maneuver, (char *) maneuver->street_name); + } else { + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign street names: NULL"); + } - /* Maneuver Instruction */ - if (maneuver->instruction) - maps_route_maneuver_set_instruction_text(man, (char *) maneuver->instruction); + /* Set maneuver locale */ + /* TODO */ - /* Maneuver Street Name */ - if (maneuver->street_name) { - MAPS_LOGD("Street Name >>>> %s", maneuver->street_name); - maps_route_maneuver_set_road_name(man, (char *) maneuver->street_name); - } else { - MAPS_LOGD("Street Name >>>> NIL"); - } + /* Set maneuver distance and time */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS assign maneuver distance and time"); + maps_route_maneuver_set_distance_to_next_instruction(tizen_maneuver, maneuver->distance); + maps_route_maneuver_set_time_to_next_instruction(tizen_maneuver, maneuver->time); - /*/ Maneuver start position */ - maps_coordinates_h coord; - maps_coordinates_create(maneuver->start_point.latitude, maneuver->start_point.longitude, &coord); + /* Append to maneuver list */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS append to maneuver list"); + maps_item_list_append(tizen_maneuver_list, (gpointer) tizen_maneuver, maps_route_maneuver_clone); + maps_route_maneuver_destroy(tizen_maneuver); - maps_route_maneuver_set_position(man, coord); - maps_coordinates_destroy(coord); + /* Fetching the next item from Maneuver list */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS Fetching the next item from Maneuver list"); + maneuver_data = g_list_next(maneuver_data); + } /* Loop over maneuvers */ + /*********************************************************************/ - maps_item_list_h maneuver_list = NULL; - maps_item_list_create(&maneuver_list); - maps_item_list_append(maneuver_list, (gpointer) man, maps_route_maneuver_clone); - maps_route_segment_set_maneuvers(segment, maneuver_list); + /* Set maneuver list */ + maps_route_segment_set_maneuvers(tizen_segment, tizen_maneuver_list); + maps_item_list_destroy(tizen_maneuver_list); - maps_item_list_destroy(maneuver_list); - maps_route_maneuver_destroy(man); + /* Append to segment list */ + maps_item_list_append(tizen_segment_list, (gpointer) tizen_segment, maps_route_segment_clone); + maps_route_segment_destroy(tizen_segment); - maps_item_list_append(segment_list, (gpointer) segment, maps_route_segment_clone); - maps_route_segment_destroy(segment); + /* Fetching the next item from Segment list */ + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS Fetching the next item from Segment list"); + segment_data = g_list_next(segment_data); - /* Fetching the next item from Maneuver/Segment list */ - maneuver_data = g_list_next(maneuver_data); - } - maps_route_set_segments(route, segment_list); - maps_item_list_destroy(segment_list); + } /* Loop over segments */ + /*********************************************************************/ - /* Shape points - path */ - maps_item_list_h path_list = NULL; - maps_item_list_create(&path_list); + /* Set segment list */ + maps_route_set_segments(tizen_route, tizen_segment_list); + maps_item_list_destroy(tizen_segment_list); + /* Set up for trip shape points/path */ + maps_item_list_h tizen_route_path_list = NULL; + maps_item_list_create(&tizen_route_path_list); GList *shapePoints = NULL; shapePoints = g_list_first(route_info->shapePoints); + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS trip shapePoints"); while (shapePoints) { coords_s *data = (coords_s *) shapePoints->data; maps_coordinates_h shapeCoords; maps_coordinates_create(data->latitude, data->longitude, &shapeCoords); + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS data->latitude: %f", data->latitude); + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS data->longitude: %f", data->longitude); - maps_item_list_append(path_list, (gpointer) shapeCoords, maps_coordinates_clone); + maps_item_list_append(tizen_route_path_list, (gpointer) shapeCoords, maps_coordinates_clone); maps_coordinates_destroy(shapeCoords); shapePoints = g_list_next(shapePoints); } - maps_route_set_path(route, path_list); - maps_item_list_destroy(path_list); - bool b = calldata_route->callback((maps_error_e)convert_mapzen_error_to_maps_error(result), calldata_route->reqID, 0, 1, route, calldata_route->data); + /* Set trip path */ + maps_route_set_path(tizen_route, tizen_route_path_list); + maps_item_list_destroy(tizen_route_path_list); + MAPS_LOGD(">>>>> __mapzen_route_cb: PROCESS shapePoints DONE"); + + MAPS_LOGD(">>>>> PROCESS __mapzen_route_cb: result=%d", result); + MAPS_LOGD(">>>>> PROCESS __mapzen_route_cb: convert_mapzen_error_to_maps_error(result)=%d", convert_mapzen_error_to_maps_error(result)); + MAPS_LOGD(">>>>> PRE calldata_route->callback"); + MAPS_LOGD(">>>>> PRE calldata_route->callback address: %p", calldata_route->callback); + bool b = calldata_route->callback((maps_error_e)convert_mapzen_error_to_maps_error(result), calldata_route->reqID, 0, 1, tizen_route, calldata_route->data); + MAPS_LOGD(">>>>> POST calldata_route->callback"); if (!b) return; } else { + MAPS_LOGD(">>>>> PRE calldata_route->callback INVALID route_info"); calldata_route->callback((maps_error_e)convert_mapzen_error_to_maps_error(result), calldata_route->reqID, 0, 0, NULL, calldata_route->data); + MAPS_LOGD(">>>>> POST calldata_route->callback INVALID route_info"); } + + MAPS_LOGD(">>>>> END __mapzen_route_cb"); } -EXPORT_API int maps_plugin_search_route(const maps_coordinates_h origin, const maps_coordinates_h destination, maps_preference_h preference, maps_service_search_route_cb callback, void *user_data, int *request_id) -{ +EXPORT_API int maps_plugin_search_route(const maps_coordinates_h origin, + const maps_coordinates_h destination, maps_preference_h preference, + maps_service_search_route_cb callback, void *user_data, int *request_id) { + MAPS_LOGD(">>>>> START maps_plugin_search_route"); + MAPS_LOGD(">>>>> maps_plugin_search_route PROCESS: callback address=%p", callback); + MAPS_LOGD(">>>>> maps_plugin_search_route PROCESS: request_id=%d", *request_id); + if (!origin || !destination || !callback || !request_id) return MAPS_ERROR_INVALID_PARAMETER; @@ -812,36 +943,34 @@ EXPORT_API int maps_plugin_search_route(const maps_coordinates_h origin, const m maps_route_transport_mode_e transport_mode; maps_preference_get_route_transport_mode(preference, &transport_mode); - if (transport_mode == MAPS_ROUTE_TRANSPORT_MODE_CAR) + switch (transport_mode) { + case MAPS_ROUTE_TRANSPORT_MODE_CAR: route_req->type = COSTING_AUTO; - else if (transport_mode == MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN) + break; + case MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN: route_req->type = COSTING_PEDESTRIAN; - else if (transport_mode == MAPS_ROUTE_TRANSPORT_MODE_BICYCLE) + break; + case MAPS_ROUTE_TRANSPORT_MODE_BICYCLE: route_req->type = COSTING_BICYCLE; - else if (transport_mode == MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT) + break; + case MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT: route_req->type = COSTING_MULTIMODAL; - else - route_req->type = COSTING_AUTO; /* Keeping it as default */ - - route_req->driving_style = DRIVING_STYLE_NORMAL; /* Keeping it as default */ + break; + default: + return MAPS_ERROR_INVALID_PARAMETER; + break; + } /* Unit */ maps_distance_unit_e unit; maps_preference_get_distance_unit(preference, &unit); switch (unit) { - case MAPS_DISTANCE_UNIT_M: - route_req->unit = UNIT_M; /*miles, not meters */ - break; case MAPS_DISTANCE_UNIT_KM: route_req->unit = UNIT_KM; break; - case MAPS_DISTANCE_UNIT_FT: - /*route_req->unit = ROUTE_UNIT_FT; */ - break; - case MAPS_DISTANCE_UNIT_YD: - /*route_req->unit = ROUTE_UNIT_YD; */ - break; + default: + return MAPS_ERROR_INVALID_PARAMETER; } route_req->avoids = PENALTY_NONE; @@ -852,25 +981,37 @@ EXPORT_API int maps_plugin_search_route(const maps_coordinates_h origin, const m maps_route_feature_e routeFeature; maps_preference_get_route_feature(preference, &routeFeature); - if (routeFeature == MAPS_ROUTE_FEATURE_TOLL) + switch (routeFeature) { + case MAPS_ROUTE_FEATURE_TOLL: route_req->avoids = PENALTY_TOLL_ROADS; - else if (routeFeature == MAPS_ROUTE_FEATURE_MOTORWAY) + break; + case MAPS_ROUTE_FEATURE_MOTORWAY: route_req->avoids = PENALTY_LIMITED_ACCESS; - else if ((routeFeature == MAPS_ROUTE_FEATURE_BOATFERRY) || (routeFeature == MAPS_ROUTE_FEATURE_RAILFERRY)) + break; + case MAPS_ROUTE_FEATURE_BOATFERRY: + case MAPS_ROUTE_FEATURE_RAILFERRY: route_req->avoids = PENALTY_USE_FERRY; - else if (routeFeature == MAPS_ROUTE_FEATURE_DIRTROAD) + break; + case MAPS_ROUTE_FEATURE_DIRTROAD: route_req->avoids = PENALTY_USE_UNPAVED; - else - route_req->avoids = PENALTY_NONE; + break; + default: + return MAPS_ERROR_INVALID_PARAMETER; + break; + } } route_req->way_points = NULL; *request_id = ++__request_id; calldata_route->reqID = __request_id; + MAPS_LOGD(">>>>> maps_plugin_search_route PROCESS: calldata_route->reqID=%d", calldata_route->reqID); + MAPS_LOGD(">>>>> PRE mapzen_start_route"); int ret = mapzen_start_route(route_req, __mapzen_route_cb, __request_id, (void *)calldata_route); + MAPS_LOGD(">>>>> POST mapzen_start_route"); + MAPS_LOGD(">>>>> END maps_plugin_search_route"); return convert_mapzen_error_to_maps_error(ret); } @@ -905,36 +1046,34 @@ EXPORT_API int maps_plugin_search_route_waypoints(const maps_coordinates_h *wayp maps_route_transport_mode_e transport_mode; maps_preference_get_route_transport_mode(preference, &transport_mode); - if (transport_mode == MAPS_ROUTE_TRANSPORT_MODE_CAR) + switch (transport_mode) { + case MAPS_ROUTE_TRANSPORT_MODE_CAR: route_req->type = COSTING_AUTO; - else if (transport_mode == MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN) + break; + case MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN: route_req->type = COSTING_PEDESTRIAN; - else if (transport_mode == MAPS_ROUTE_TRANSPORT_MODE_BICYCLE) + break; + case MAPS_ROUTE_TRANSPORT_MODE_BICYCLE: route_req->type = COSTING_BICYCLE; - else if (transport_mode == MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT) + break; + case MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT: route_req->type = COSTING_MULTIMODAL; - else - route_req->type = COSTING_AUTO; /* Keeping it as default */ - - route_req->driving_style = DRIVING_STYLE_NORMAL; /* Keeping it as default */ + break; + default: + return MAPS_ERROR_INVALID_PARAMETER; + break; + } /* Unit */ maps_distance_unit_e unit; maps_preference_get_distance_unit(preference, &unit); switch (unit) { - case MAPS_DISTANCE_UNIT_M: - route_req->unit = UNIT_M; /*miles, not meters */ - break; case MAPS_DISTANCE_UNIT_KM: route_req->unit = UNIT_KM; break; - case MAPS_DISTANCE_UNIT_FT: - /* route_req->unit = ROUTE_UNIT_FT; */ - break; - case MAPS_DISTANCE_UNIT_YD: - /* route_req->unit = ROUTE_UNIT_YD; */ - break; + default: + return MAPS_ERROR_INVALID_PARAMETER; } route_req->avoids = PENALTY_NONE; @@ -945,16 +1084,24 @@ EXPORT_API int maps_plugin_search_route_waypoints(const maps_coordinates_h *wayp maps_route_feature_e routeFeature; maps_preference_get_route_feature(preference, &routeFeature); - if (routeFeature == MAPS_ROUTE_FEATURE_TOLL) + switch (routeFeature) { + case MAPS_ROUTE_FEATURE_TOLL: route_req->avoids = PENALTY_TOLL_ROADS; - else if (routeFeature == MAPS_ROUTE_FEATURE_MOTORWAY) + break; + case MAPS_ROUTE_FEATURE_MOTORWAY: route_req->avoids = PENALTY_LIMITED_ACCESS; - else if ((routeFeature == MAPS_ROUTE_FEATURE_BOATFERRY) || (routeFeature == MAPS_ROUTE_FEATURE_RAILFERRY)) + break; + case MAPS_ROUTE_FEATURE_BOATFERRY: + case MAPS_ROUTE_FEATURE_RAILFERRY: route_req->avoids = PENALTY_USE_FERRY; - else if (routeFeature == MAPS_ROUTE_FEATURE_DIRTROAD) + break; + case MAPS_ROUTE_FEATURE_DIRTROAD: route_req->avoids = PENALTY_USE_UNPAVED; - else - route_req->avoids = PENALTY_NONE; + break; + default: + return MAPS_ERROR_INVALID_PARAMETER; + break; + } } /* Waypoints */