.project
+.tproject
.cproject
.settings/*
extern "C" {
#include "mapzen_queue.h"
#include "mapzen_debug.h"
+#include "mapzen_types.h"
#include "mapzen_util.h"
}
#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<maps_coordinates_s>& output)
-{
+void decode_shape(const std::string& encoded, std::vector<coords_s>& output) {
// what byte are we looking at
size_t i = 0;
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<double>(lat) * kInvPolylinePrecision;
ll.longitude = static_cast<double>(lon) * kInvPolylinePrecision;
output.emplace_back(std::move(ll));
/********************* ROUTE RESPONSE ***********************/
-static void __parse_route_response(char *response, int size, int *status, mapzen_route_resp_s **routeResp)
+static void __process_shape(std::vector<coords_s>& 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<coords_s>& 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<coords_s>& 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<coords_s> 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<coords_s> 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)
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..");
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()
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<rapidjson::StringBuffer> writer(buffer);
//{"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);
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");
}
writer.EndArray();
} else {
+ MAP_DEBUG(">>>>> query_route: PROCESS two route locations");
writer.Key("locations");
writer.StartArray();
writer.EndArray();
}
+ MAP_DEBUG(">>>>> query_route: PROCESS type");
std::string costing_str;
switch (type) {
case COSTING_AUTO:
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) {
// 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);
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
} route_type;
typedef enum {
- UNIT_M = 0, /* for miles */
UNIT_KM /* for kilometers */
} route_unit;
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_ */
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;
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;
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);
}
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;
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 */
projects / platform / core / location / maps-plugin-mapzen.git / commitdiff