src/here_utils.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "here_utils.h"
  18 #include <common/CommunicationError.h>
  19
  20
  21 static const double LATITUDE_RANGE = 85.05113;
  22 static const double LONGITUDE_RANGE = 180.0;
  23
  24
  25 extern "C"
  26 {
  27 int ConvertToMapsError(int nErr)
  28 {
  29         switch (nErr)
  30         {
  31                 case HERE_ERROR_NONE:                  return MAPS_ERROR_NONE;
  32                 case HERE_ERROR_PERMISSION_DENIED:     return MAPS_ERROR_PERMISSION_DENIED;
  33                 case HERE_ERROR_OUT_OF_MEMORY:         return MAPS_ERROR_OUT_OF_MEMORY;
  34                 case HERE_ERROR_INVALID_PARAMETER:     return MAPS_ERROR_INVALID_PARAMETER;
  35                 case HERE_ERROR_NOT_SUPPORTED:         return MAPS_ERROR_NOT_SUPPORTED;
  36                 case HERE_ERROR_CONNECTION_TIME_OUT:   return MAPS_ERROR_CONNECTION_TIME_OUT;
  37                 case HERE_ERROR_NETWORK_UNREACHABLE:   return MAPS_ERROR_NETWORK_UNREACHABLE;
  38                 case HERE_ERROR_INVALID_OPERATION:     return MAPS_ERROR_INVALID_OPERATION;
  39                 case HERE_ERROR_KEY_NOT_AVAILABLE:     return MAPS_ERROR_KEY_NOT_AVAILABLE;
  40                 case HERE_ERROR_RESOURCE_BUSY:         return MAPS_ERROR_RESOURCE_BUSY;
  41                 case HERE_ERROR_CANCELED:              return MAPS_ERROR_CANCELED;
  42                 case HERE_ERROR_UNKNOWN:               return MAPS_ERROR_UNKNOWN;
  43                 case HERE_ERROR_SERVICE_NOT_AVAILABLE: return MAPS_ERROR_SERVICE_NOT_AVAILABLE;
  44                 case HERE_ERROR_NOT_FOUND:             return MAPS_ERROR_NOT_FOUND;
  45         }
  46         return MAPS_ERROR_UNKNOWN;
  47 }
  48
  49 int ConvertToHereError(int nErr)
  50 {
  51         switch (nErr)
  52         {
  53                 case MAPS_ERROR_NONE:                  return HERE_ERROR_NONE;
  54                 case MAPS_ERROR_PERMISSION_DENIED:     return HERE_ERROR_PERMISSION_DENIED;
  55                 case MAPS_ERROR_OUT_OF_MEMORY:         return HERE_ERROR_OUT_OF_MEMORY;
  56                 case MAPS_ERROR_INVALID_PARAMETER:     return HERE_ERROR_INVALID_PARAMETER;
  57                 case MAPS_ERROR_NOT_SUPPORTED:         return HERE_ERROR_NOT_SUPPORTED;
  58                 case MAPS_ERROR_CONNECTION_TIME_OUT:   return HERE_ERROR_CONNECTION_TIME_OUT;
  59                 case MAPS_ERROR_NETWORK_UNREACHABLE:   return HERE_ERROR_NETWORK_UNREACHABLE;
  60                 case MAPS_ERROR_INVALID_OPERATION:     return HERE_ERROR_INVALID_OPERATION;
  61                 case MAPS_ERROR_KEY_NOT_AVAILABLE:     return HERE_ERROR_KEY_NOT_AVAILABLE;
  62                 case MAPS_ERROR_RESOURCE_BUSY:         return HERE_ERROR_RESOURCE_BUSY;
  63                 case MAPS_ERROR_CANCELED:              return HERE_ERROR_CANCELED;
  64                 case MAPS_ERROR_UNKNOWN:               return HERE_ERROR_UNKNOWN;
  65                 case MAPS_ERROR_SERVICE_NOT_AVAILABLE: return HERE_ERROR_SERVICE_NOT_AVAILABLE;
  66                 case MAPS_ERROR_NOT_FOUND:             return HERE_ERROR_NOT_FOUND;
  67         }
  68         return HERE_ERROR_UNKNOWN;
  69 }
  70
  71 const char* ConverHereErrorToString(int nErr)
  72 {
  73         switch (nErr)
  74         {
  75                 case HERE_ERROR_NONE:                  return "No errors";
  76                 case HERE_ERROR_PERMISSION_DENIED:     return "Permission denied";
  77                 case HERE_ERROR_OUT_OF_MEMORY:         return "Out of memory";
  78                 case HERE_ERROR_INVALID_PARAMETER:     return "Invalid Parameter";
  79                 case HERE_ERROR_NOT_SUPPORTED:         return "Not suppoerted";
  80                 case HERE_ERROR_CONNECTION_TIME_OUT:   return "Connection time out";
  81                 case HERE_ERROR_NETWORK_UNREACHABLE:   return "Network unreachable";
  82                 case HERE_ERROR_INVALID_OPERATION:     return "Invalid operation";
  83                 case HERE_ERROR_KEY_NOT_AVAILABLE:     return "Key not available";
  84                 case HERE_ERROR_RESOURCE_BUSY:         return "Resource busy";
  85                 case HERE_ERROR_CANCELED:              return "Canceled";
  86                 case HERE_ERROR_UNKNOWN:               return "Unknown";
  87                 case HERE_ERROR_SERVICE_NOT_AVAILABLE: return "Service not available";
  88                 case HERE_ERROR_NOT_FOUND:             return "Not found";
  89         }
  90         return "Unknown";
  91 }
  92
  93 const char* ConvertMapsErrorToChar(int nErr)
  94 {
  95         switch (nErr)
  96         {
  97                 case MAPS_ERROR_NONE:                  return "MAPS_ERROR_NONE";
  98                 case MAPS_ERROR_PERMISSION_DENIED:     return "MAPS_ERROR_PERMISSION_DENIED";
  99                 case MAPS_ERROR_OUT_OF_MEMORY:         return "MAPS_ERROR_OUT_OF_MEMORY";
 100                 case MAPS_ERROR_INVALID_PARAMETER:     return "MAPS_ERROR_INVALID_PARAMETER";
 101                 case MAPS_ERROR_NOT_SUPPORTED:         return "MAPS_ERROR_NOT_SUPPORTED";
 102                 case MAPS_ERROR_CONNECTION_TIME_OUT:   return "MAPS_ERROR_CONNECTION_TIME_OUT";
 103                 case MAPS_ERROR_NETWORK_UNREACHABLE:   return "MAPS_ERROR_NETWORK_UNREACHABLE";
 104                 case MAPS_ERROR_INVALID_OPERATION:     return "MAPS_ERROR_INVALID_OPERATION";
 105                 case MAPS_ERROR_KEY_NOT_AVAILABLE:     return "MAPS_ERROR_KEY_NOT_AVAILABLE";
 106                 case MAPS_ERROR_RESOURCE_BUSY:         return "MAPS_ERROR_RESOURCE_BUSY";
 107                 case MAPS_ERROR_CANCELED:              return "MAPS_ERROR_CANCELED";
 108                 case MAPS_ERROR_UNKNOWN:               return "MAPS_ERROR_UNKNOWN";
 109                 case MAPS_ERROR_SERVICE_NOT_AVAILABLE: return "MAPS_ERROR_SERVICE_NOT_AVAILABLE";
 110                 case MAPS_ERROR_NOT_FOUND:             return "MAPS_ERROR_NOT_FOUND";
 111         }
 112         return "MAPS_ERROR_UNKNOWN";
 113 }
 114 }
 115
 116
 117 HERE_PLUGIN_BEGIN_NAMESPACE
 118
 119 HereUtils::HereUtils()
 120 {
 121 }
 122
 123 HereUtils::~HereUtils()
 124 {
 125 }
 126
 127 GeoRouteQuery::TravelMode HereUtils::Convert(maps_route_transport_mode_e nVal)
 128 {
 129         switch (nVal)
 130         {
 131                 case MAPS_ROUTE_TRANSPORT_MODE_CAR:           return GeoRouteQuery::TM_CarTravel;
 132                 case MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN:    return GeoRouteQuery::TM_PedestrianTravel;
 133                 case MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT: return GeoRouteQuery::TM_PublicTransitTravel;
 134                 default: break;
 135         }
 136         return GeoRouteQuery::TM_CarTravel;
 137 }
 138
 139 maps_route_transport_mode_e HereUtils::Convert(GeoRouteQuery::TravelMode nVal)
 140 {
 141         switch (nVal)
 142         {
 143                 case GeoRouteQuery::TM_CarTravel:           return MAPS_ROUTE_TRANSPORT_MODE_CAR;
 144                 case GeoRouteQuery::TM_PedestrianTravel:    return MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN;
 145                 case GeoRouteQuery::TM_PublicTransitTravel: return MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT;
 146                 default: break;
 147         }
 148         return MAPS_ROUTE_TRANSPORT_MODE_CAR;
 149 }
 150
 151 GeoRouteQuery::FeatureType HereUtils::Convert(maps_route_feature_e nVal)
 152 {
 153         switch (nVal)
 154         {
 155                 case MAPS_ROUTE_FEATURE_NO:             return GeoRouteQuery::FT_NoFeature;
 156                 case MAPS_ROUTE_FEATURE_TOLL:           return GeoRouteQuery::FT_TollFeature;
 157                 case MAPS_ROUTE_FEATURE_MOTORWAY:       return GeoRouteQuery::FT_MotorwayFeature;
 158                 case MAPS_ROUTE_FEATURE_BOATFERRY:      return GeoRouteQuery::FT_BoatFerryFeature;
 159                 case MAPS_ROUTE_FEATURE_RAILFERRY:      return GeoRouteQuery::FT_RailFerryFeature;
 160                 case MAPS_ROUTE_FEATURE_PUBLICTTRANSIT: return GeoRouteQuery::FT_PublicTransitFeature;
 161                 case MAPS_ROUTE_FEATURE_TUNNEL:         return GeoRouteQuery::FT_TunnelFeature;
 162                 case MAPS_ROUTE_FEATURE_DIRTROAD:       return GeoRouteQuery::FT_DirtRoadFeature;
 163                 case MAPS_ROUTE_FEATURE_PARKS:          return GeoRouteQuery::FT_ParksFeature;
 164                 case MAPS_ROUTE_FEATURE_HOVLANE:        return GeoRouteQuery::FT_HOVLane;
 165                 case MAPS_ROUTE_FEATURE_STAIRS:         return GeoRouteQuery::FT_Stairs;
 166                 default: break;
 167         }
 168         return GeoRouteQuery::FT_NoFeature;
 169 }
 170
 171 GeoRouteQuery::FeatureWeight HereUtils::Convert(maps_route_feature_weight_e nVal)
 172 {
 173         switch (nVal)
 174         {
 175                 case MAPS_ROUTE_FEATURE_WEIGHT_NORMAL:        return GeoRouteQuery::FW_NormalFeatureWeight;
 176                 case MAPS_ROUTE_FEATURE_WEIGHT_PREFER:        return GeoRouteQuery::FW_PreferFeatureWeight;
 177                 case MAPS_ROUTE_FEATURE_WEIGHT_AVOID:         return GeoRouteQuery::FW_AvoidFeatureWeight;
 178                 case MAPS_ROUTE_FEATURE_WEIGHT_SOFTEXCLUDE:   return GeoRouteQuery::FW_SoftExcludeFeatureWeight;
 179                 case MAPS_ROUTE_FEATURE_WEIGHT_STRICTEXCLUDE: return GeoRouteQuery::FW_StrictExcludeFeatureWeight;
 180                 default: break;
 181         }
 182         return GeoRouteQuery::FW_NormalFeatureWeight;
 183 }
 184
 185 maps_route_turn_type_e HereUtils::Convert(Maneuver::InstructionDirection nVal)
 186 {
 187         switch (nVal)
 188         {
 189                 case Maneuver::ID_NoDirection:          return MAPS_ROUTE_TURN_TYPE_NONE;
 190                 case Maneuver::ID_DirectionForward:     return MAPS_ROUTE_TURN_TYPE_STRAIGHT;
 191                 case Maneuver::ID_DirectionBearRight:   return MAPS_ROUTE_TURN_TYPE_BEAR_RIGHT;
 192                 case Maneuver::ID_DirectionLightRight:  return MAPS_ROUTE_TURN_TYPE_LIGHT_RIGHT;
 193                 case Maneuver::ID_DirectionRight:       return MAPS_ROUTE_TURN_TYPE_RIGHT;
 194                 case Maneuver::ID_DirectionHardRight:   return MAPS_ROUTE_TURN_TYPE_HARD_RIGHT;
 195                 case Maneuver::ID_DirectionUTurnRight:  return MAPS_ROUTE_TURN_TYPE_UTURN_RIGHT;
 196                 case Maneuver::ID_DirectionUTurnLeft:   return MAPS_ROUTE_TURN_TYPE_UTURN_LEFT;
 197                 case Maneuver::ID_DirectionHardLeft:    return MAPS_ROUTE_TURN_TYPE_HARD_LEFT;
 198                 case Maneuver::ID_DirectionLeft:        return MAPS_ROUTE_TURN_TYPE_LEFT;
 199                 case Maneuver::ID_DirectionLightLeft:   return MAPS_ROUTE_TURN_TYPE_LIGHT_LEFT;
 200                 case Maneuver::ID_DirectionBearLeft:    return MAPS_ROUTE_TURN_TYPE_BEAR_LEFT;
 201                 default: break;
 202         }
 203         return MAPS_ROUTE_TURN_TYPE_NONE;
 204 }
 205
 206 Maneuver::InstructionDirection HereUtils::Convert(maps_route_turn_type_e nVal)
 207 {
 208         switch (nVal)
 209         {
 210                 case MAPS_ROUTE_TURN_TYPE_NONE:         return Maneuver::ID_NoDirection;
 211                 case MAPS_ROUTE_TURN_TYPE_STRAIGHT:     return Maneuver::ID_DirectionForward;
 212                 case MAPS_ROUTE_TURN_TYPE_BEAR_RIGHT:   return Maneuver::ID_DirectionBearRight;
 213                 case MAPS_ROUTE_TURN_TYPE_LIGHT_RIGHT:  return Maneuver::ID_DirectionLightRight;
 214                 case MAPS_ROUTE_TURN_TYPE_RIGHT:        return Maneuver::ID_DirectionRight;
 215                 case MAPS_ROUTE_TURN_TYPE_HARD_RIGHT:   return Maneuver::ID_DirectionHardRight;
 216                 case MAPS_ROUTE_TURN_TYPE_UTURN_RIGHT:  return Maneuver::ID_DirectionUTurnRight;
 217                 case MAPS_ROUTE_TURN_TYPE_UTURN_LEFT:   return Maneuver::ID_DirectionUTurnLeft;
 218                 case MAPS_ROUTE_TURN_TYPE_HARD_LEFT:    return Maneuver::ID_DirectionHardLeft;
 219                 case MAPS_ROUTE_TURN_TYPE_LEFT:         return Maneuver::ID_DirectionLeft;
 220                 case MAPS_ROUTE_TURN_TYPE_LIGHT_LEFT:   return Maneuver::ID_DirectionLightLeft;
 221                 case MAPS_ROUTE_TURN_TYPE_BEAR_LEFT:    return Maneuver::ID_DirectionBearLeft;
 222                 default: break;
 223         }
 224         return Maneuver::ID_NoDirection;
 225 }
 226
 227 maps_error_e HereUtils::ConvertHttpCodeToMapsError(int nVal)
 228 {
 229         switch (nVal)
 230         {
 231                 case 200:/*Ok*/                         return MAPS_ERROR_NONE;
 232                 case 408:/*Request timeout*/
 233                 case 504:/*Gateway timeout*/
 234                 case 598:/*Network reading timeout*/
 235                 case 599:/*Network connection timeout*/ return MAPS_ERROR_CONNECTION_TIME_OUT;
 236
 237                 case 404:/*Not found*/
 238                 case 407:/*Proxy auth. required*/
 239                 case 502:/*Bad gateway*/                return MAPS_ERROR_NETWORK_UNREACHABLE;
 240
 241                 case 401:/*Unauthorized*/
 242                 case 402:/*Payment required*/           return MAPS_ERROR_KEY_NOT_AVAILABLE;
 243
 244                 case 405:/*Method not allowed*/
 245                 case 413:/*Request entity too larget*/
 246                 case 414:/*Request uri too large*/      return MAPS_ERROR_INVALID_OPERATION;
 247
 248                 case 403:/*Forbidden*/
 249                 case 500:/*Server internal error*/
 250                 case 501:/*Not implemented*/
 251                 case 503:/*Service unavailable*/        return MAPS_ERROR_SERVICE_NOT_AVAILABLE;
 252         }
 253
 254         if (nVal > 0 && nVal < 100) // curl error code
 255                 return MAPS_ERROR_NETWORK_UNREACHABLE;
 256
 257         if (nVal >= 400 && nVal < 500) // http code 4xx (client-side error)
 258                 return MAPS_ERROR_INVALID_OPERATION;
 259
 260         if (nVal >= 500 && nVal < 600) // http code 5xx (server-side error)
 261                 return MAPS_ERROR_SERVICE_NOT_AVAILABLE;
 262
 263         return MAPS_ERROR_UNKNOWN;
 264 }
 265
 266 GeoBoundingBox& HereUtils::Convert(maps_area_h hArea, GeoBoundingBox& Box)
 267 {
 268         maps_area_s* area_s = (maps_area_s*)hArea;
 269
 270         if (!area_s || area_s->type != MAPS_AREA_RECTANGLE) return Box;
 271
 272         GeoCoordinates hereCoordLT(area_s->rect.top_left.latitude, area_s->rect.top_left.longitude);
 273         GeoCoordinates hereCoordRB(area_s->rect.bottom_right.latitude, area_s->rect.bottom_right.longitude);
 274
 275         Box.SetTopLeft(hereCoordLT);
 276         Box.SetBottomRight(hereCoordRB);
 277
 278         return Box;
 279 }
 280
 281 maps_area_h& HereUtils::Convert(GeoBoundingBox Box, maps_area_h& hArea)
 282 {
 283         maps_coordinates_h mapsCoordLT, mapsCoordRB;
 284         GeoCoordinates hereCoordLT, hereCoordRB;
 285
 286         hereCoordLT = Box.GetTopLeft();
 287         hereCoordRB = Box.GetBottomRight();
 288
 289         maps_coordinates_create(hereCoordLT.GetLatitude(), hereCoordLT.GetLongitude(), &mapsCoordLT);
 290         maps_coordinates_create(hereCoordRB.GetLatitude(), hereCoordRB.GetLongitude(), &mapsCoordRB);
 291
 292         maps_area_create_rectangle(mapsCoordLT, mapsCoordRB, &hArea);
 293
 294         maps_coordinates_destroy(mapsCoordLT);
 295         maps_coordinates_destroy(mapsCoordRB);
 296
 297         return hArea;
 298 }
 299
 300 void HereUtils::Convert(String strUtf8, WString& strUtf16)
 301 {
 302         strUtf16.assign(strUtf8.begin(), strUtf8.end());
 303 }
 304
 305 void HereUtils::Convert(WString strUtf16, String& strUtf8)
 306 {
 307         strUtf8.assign(strUtf16.begin(), strUtf16.end());
 308 }
 309
 310 GeoBoundingBox& HereUtils::Convert(const char *src, GeoBoundingBox &box)
 311 {
 312         int i = 0;
 313         char *token, *next;
 314         double coord[4] = { 0.0, };
 315
 316         token = strtok_r((char*)src, ",;", &next);
 317         while (token && i < 4)
 318         {
 319                 coord[i++] = atof(token);
 320                 token = strtok_r(NULL, ",;", &next);
 321         }
 322         box.SetTopLeft(GeoCoordinates(coord[0], coord[1]));
 323         box.SetBottomRight(GeoCoordinates(coord[2], coord[3]));
 324         return box;
 325 }
 326
 327 bool HereUtils::IsValid(GeoCoordinates geoCoord)
 328 {
 329         return IsValidCoord(geoCoord.GetLatitude(), geoCoord.GetLongitude());
 330 }
 331
 332 bool HereUtils::IsValid(maps_coordinates_s geoCoord)
 333 {
 334         return IsValidCoord(geoCoord.latitude, geoCoord.longitude);
 335 }
 336
 337 bool HereUtils::IsValidCoord(double dLat, double dLng)
 338 {
 339         return ((dLat <= LATITUDE_RANGE && dLat >= -LATITUDE_RANGE) &&
 340                 (dLng <= LONGITUDE_RANGE && dLng >= -LONGITUDE_RANGE));
 341 }
 342
 343 bool HereUtils::IsValid(maps_area_s hArea)
 344 {
 345         if (hArea.type == MAPS_AREA_RECTANGLE)
 346         {
 347                 return (HereUtils::IsValid(hArea.rect.top_left) &&
 348                         HereUtils::IsValid(hArea.rect.bottom_right));
 349         }
 350         else if(hArea.type == MAPS_AREA_CIRCLE)
 351         {
 352                 return HereUtils::IsValid(hArea.circle.center);
 353         }
 354         else
 355                 return false;
 356 }
 357
 358
 359 HERE_PLUGIN_END_NAMESPACE