src/here/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
  19
  20 static const double LATITUDE_RANGE = 85.05113;
  21 static const double LONGITUDE_RANGE = 180.0;
  22
  23
  24 extern "C"
  25 {
  26 int ConvertToMapsError(int nErr)
  27 {
  28         switch (nErr)
  29         {
  30                 case HERE_ERROR_NONE:                  return MAPS_ERROR_NONE;
  31                 case HERE_ERROR_PERMISSION_DENIED:     return MAPS_ERROR_PERMISSION_DENIED;
  32                 case HERE_ERROR_OUT_OF_MEMORY:         return MAPS_ERROR_OUT_OF_MEMORY;
  33                 case HERE_ERROR_INVALID_PARAMETER:     return MAPS_ERROR_INVALID_PARAMETER;
  34                 case HERE_ERROR_NOT_SUPPORTED:         return MAPS_ERROR_NOT_SUPPORTED;
  35                 case HERE_ERROR_CONNECTION_TIME_OUT:   return MAPS_ERROR_CONNECTION_TIME_OUT;
  36                 case HERE_ERROR_NETWORK_UNREACHABLE:   return MAPS_ERROR_NETWORK_UNREACHABLE;
  37                 case HERE_ERROR_INVALID_OPERATION:     return MAPS_ERROR_INVALID_OPERATION;
  38                 case HERE_ERROR_KEY_NOT_AVAILABLE:     return MAPS_ERROR_KEY_NOT_AVAILABLE;
  39                 case HERE_ERROR_RESOURCE_BUSY:         return MAPS_ERROR_RESOURCE_BUSY;
  40                 case HERE_ERROR_CANCELED:              return MAPS_ERROR_CANCELED;
  41                 case HERE_ERROR_UNKNOWN:               return MAPS_ERROR_UNKNOWN;
  42                 case HERE_ERROR_SERVICE_NOT_AVAILABLE: return MAPS_ERROR_SERVICE_NOT_AVAILABLE;
  43                 case HERE_ERROR_NOT_FOUND:             return MAPS_ERROR_NOT_FOUND;
  44         }
  45         return MAPS_ERROR_UNKNOWN;
  46 }
  47
  48 int ConvertToHereError(int nErr)
  49 {
  50         switch (nErr)
  51         {
  52                 case MAPS_ERROR_NONE:                  return HERE_ERROR_NONE;
  53                 case MAPS_ERROR_PERMISSION_DENIED:     return HERE_ERROR_PERMISSION_DENIED;
  54                 case MAPS_ERROR_OUT_OF_MEMORY:         return HERE_ERROR_OUT_OF_MEMORY;
  55                 case MAPS_ERROR_INVALID_PARAMETER:     return HERE_ERROR_INVALID_PARAMETER;
  56                 case MAPS_ERROR_NOT_SUPPORTED:         return HERE_ERROR_NOT_SUPPORTED;
  57                 case MAPS_ERROR_CONNECTION_TIME_OUT:   return HERE_ERROR_CONNECTION_TIME_OUT;
  58                 case MAPS_ERROR_NETWORK_UNREACHABLE:   return HERE_ERROR_NETWORK_UNREACHABLE;
  59                 case MAPS_ERROR_INVALID_OPERATION:     return HERE_ERROR_INVALID_OPERATION;
  60                 case MAPS_ERROR_KEY_NOT_AVAILABLE:     return HERE_ERROR_KEY_NOT_AVAILABLE;
  61                 case MAPS_ERROR_RESOURCE_BUSY:         return HERE_ERROR_RESOURCE_BUSY;
  62                 case MAPS_ERROR_CANCELED:              return HERE_ERROR_CANCELED;
  63                 case MAPS_ERROR_UNKNOWN:               return HERE_ERROR_UNKNOWN;
  64                 case MAPS_ERROR_SERVICE_NOT_AVAILABLE: return HERE_ERROR_SERVICE_NOT_AVAILABLE;
  65                 case MAPS_ERROR_NOT_FOUND:             return HERE_ERROR_NOT_FOUND;
  66         }
  67         return HERE_ERROR_UNKNOWN;
  68 }
  69 }
  70
  71
  72 HERE_PLUGIN_BEGIN_NAMESPACE
  73
  74 HereUtils::HereUtils()
  75 {
  76 }
  77
  78 HereUtils::~HereUtils()
  79 {
  80 }
  81
  82 GeoRouteQuery::TravelMode HereUtils::Convert(maps_route_transport_mode_e nVal)
  83 {
  84         switch (nVal)
  85         {
  86                 case MAPS_ROUTE_TRANSPORT_MODE_CAR:           return GeoRouteQuery::TM_CarTravel;
  87                 case MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN:    return GeoRouteQuery::TM_PedestrianTravel;
  88                 case MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT: return GeoRouteQuery::TM_PublicTransitTravel;
  89                 default: break;
  90         }
  91         return GeoRouteQuery::TM_CarTravel;
  92 }
  93
  94 maps_route_transport_mode_e HereUtils::Convert(GeoRouteQuery::TravelMode nVal)
  95 {
  96         switch (nVal)
  97         {
  98                 case GeoRouteQuery::TM_CarTravel:           return MAPS_ROUTE_TRANSPORT_MODE_CAR;
  99                 case GeoRouteQuery::TM_PedestrianTravel:    return MAPS_ROUTE_TRANSPORT_MODE_PEDESTRIAN;
 100                 case GeoRouteQuery::TM_PublicTransitTravel: return MAPS_ROUTE_TRANSPORT_MODE_PUBLICTRANSIT;
 101                 default: break;
 102         }
 103         return MAPS_ROUTE_TRANSPORT_MODE_CAR;
 104 }
 105
 106 GeoRouteQuery::FeatureType HereUtils::Convert(maps_route_feature_e nVal)
 107 {
 108         switch (nVal)
 109         {
 110                 case MAPS_ROUTE_FEATURE_NO:             return GeoRouteQuery::FT_NoFeature;
 111                 case MAPS_ROUTE_FEATURE_TOLL:           return GeoRouteQuery::FT_TollFeature;
 112                 case MAPS_ROUTE_FEATURE_MOTORWAY:       return GeoRouteQuery::FT_MotorwayFeature;
 113                 case MAPS_ROUTE_FEATURE_BOATFERRY:      return GeoRouteQuery::FT_BoatFerryFeature;
 114                 case MAPS_ROUTE_FEATURE_RAILFERRY:      return GeoRouteQuery::FT_RailFerryFeature;
 115                 case MAPS_ROUTE_FEATURE_PUBLICTTRANSIT: return GeoRouteQuery::FT_PublicTransitFeature;
 116                 case MAPS_ROUTE_FEATURE_TUNNEL:         return GeoRouteQuery::FT_TunnelFeature;
 117                 case MAPS_ROUTE_FEATURE_DIRTROAD:       return GeoRouteQuery::FT_DirtRoadFeature;
 118                 case MAPS_ROUTE_FEATURE_PARKS:          return GeoRouteQuery::FT_ParksFeature;
 119                 case MAPS_ROUTE_FEATURE_HOVLANE:        return GeoRouteQuery::FT_HOVLane;
 120                 case MAPS_ROUTE_FEATURE_STAIRS:         return GeoRouteQuery::FT_Stairs;
 121                 default: break;
 122         }
 123         return GeoRouteQuery::FT_NoFeature;
 124 }
 125
 126 GeoRouteQuery::FeatureWeight HereUtils::Convert(maps_route_feature_weight_e nVal)
 127 {
 128         switch (nVal)
 129         {
 130                 case MAPS_ROUTE_FEATURE_WEIGHT_NORMAL:        return GeoRouteQuery::FW_NormalFeatureWeight;
 131                 case MAPS_ROUTE_FEATURE_WEIGHT_PREFER:        return GeoRouteQuery::FW_PreferFeatureWeight;
 132                 case MAPS_ROUTE_FEATURE_WEIGHT_AVOID:         return GeoRouteQuery::FW_AvoidFeatureWeight;
 133                 case MAPS_ROUTE_FEATURE_WEIGHT_SOFTEXCLUDE:   return GeoRouteQuery::FW_SoftExcludeFeatureWeight;
 134                 case MAPS_ROUTE_FEATURE_WEIGHT_STRICTEXCLUDE: return GeoRouteQuery::FW_StrictExcludeFeatureWeight;
 135                 default: break;
 136         }
 137         return GeoRouteQuery::FW_NormalFeatureWeight;
 138 }
 139
 140 maps_route_turn_type_e HereUtils::Convert(Maneuver::InstructionDirection nVal)
 141 {
 142         switch (nVal)
 143         {
 144                 case Maneuver::ID_NoDirection:          return MAPS_ROUTE_TURN_TYPE_NONE;
 145                 case Maneuver::ID_DirectionForward:     return MAPS_ROUTE_TURN_TYPE_STRAIGHT;
 146                 case Maneuver::ID_DirectionBearRight:   return MAPS_ROUTE_TURN_TYPE_BEAR_RIGHT;
 147                 case Maneuver::ID_DirectionLightRight:  return MAPS_ROUTE_TURN_TYPE_LIGHT_RIGHT;
 148                 case Maneuver::ID_DirectionRight:       return MAPS_ROUTE_TURN_TYPE_RIGHT;
 149                 case Maneuver::ID_DirectionHardRight:   return MAPS_ROUTE_TURN_TYPE_HARD_RIGHT;
 150                 case Maneuver::ID_DirectionUTurnRight:  return MAPS_ROUTE_TURN_TYPE_UTURN_RIGHT;
 151                 case Maneuver::ID_DirectionUTurnLeft:   return MAPS_ROUTE_TURN_TYPE_UTURN_LEFT;
 152                 case Maneuver::ID_DirectionHardLeft:    return MAPS_ROUTE_TURN_TYPE_HARD_LEFT;
 153                 case Maneuver::ID_DirectionLeft:        return MAPS_ROUTE_TURN_TYPE_LEFT;
 154                 case Maneuver::ID_DirectionLightLeft:   return MAPS_ROUTE_TURN_TYPE_LIGHT_LEFT;
 155                 case Maneuver::ID_DirectionBearLeft:    return MAPS_ROUTE_TURN_TYPE_BEAR_LEFT;
 156                 default: break;
 157         }
 158         return MAPS_ROUTE_TURN_TYPE_NONE;
 159 }
 160
 161 Maneuver::InstructionDirection HereUtils::Convert(maps_route_turn_type_e nVal)
 162 {
 163         switch (nVal)
 164         {
 165                 case MAPS_ROUTE_TURN_TYPE_NONE:         return Maneuver::ID_NoDirection;
 166                 case MAPS_ROUTE_TURN_TYPE_STRAIGHT:     return Maneuver::ID_DirectionForward;
 167                 case MAPS_ROUTE_TURN_TYPE_BEAR_RIGHT:   return Maneuver::ID_DirectionBearRight;
 168                 case MAPS_ROUTE_TURN_TYPE_LIGHT_RIGHT:  return Maneuver::ID_DirectionLightRight;
 169                 case MAPS_ROUTE_TURN_TYPE_RIGHT:        return Maneuver::ID_DirectionRight;
 170                 case MAPS_ROUTE_TURN_TYPE_HARD_RIGHT:   return Maneuver::ID_DirectionHardRight;
 171                 case MAPS_ROUTE_TURN_TYPE_UTURN_RIGHT:  return Maneuver::ID_DirectionUTurnRight;
 172                 case MAPS_ROUTE_TURN_TYPE_UTURN_LEFT:   return Maneuver::ID_DirectionUTurnLeft;
 173                 case MAPS_ROUTE_TURN_TYPE_HARD_LEFT:    return Maneuver::ID_DirectionHardLeft;
 174                 case MAPS_ROUTE_TURN_TYPE_LEFT:         return Maneuver::ID_DirectionLeft;
 175                 case MAPS_ROUTE_TURN_TYPE_LIGHT_LEFT:   return Maneuver::ID_DirectionLightLeft;
 176                 case MAPS_ROUTE_TURN_TYPE_BEAR_LEFT:    return Maneuver::ID_DirectionBearLeft;
 177                 default: break;
 178         }
 179         return Maneuver::ID_NoDirection;
 180 }
 181
 182 GeoBoundingBox& HereUtils::Convert(maps_area_h hArea, GeoBoundingBox& Box)
 183 {
 184         maps_area_s* area_s = (maps_area_s*)hArea;
 185
 186         if (!area_s || area_s->type != MAPS_AREA_RECTANGLE) return Box;
 187
 188         GeoCoordinates hereCoordLT(area_s->rect.top_left.latitude, area_s->rect.top_left.longitude);
 189         GeoCoordinates hereCoordRB(area_s->rect.bottom_right.latitude, area_s->rect.bottom_right.longitude);
 190
 191         Box.SetTopLeft(hereCoordLT);
 192         Box.SetBottomRight(hereCoordRB);
 193
 194         return Box;
 195 }
 196
 197 maps_area_h& HereUtils::Convert(GeoBoundingBox Box, maps_area_h& hArea)
 198 {
 199         maps_coordinates_h mapsCoordLT, mapsCoordRB;
 200         GeoCoordinates hereCoordLT, hereCoordRB;
 201
 202         hereCoordLT = Box.GetTopLeft();
 203         hereCoordRB = Box.GetBottomRight();
 204
 205         maps_coordinates_create(hereCoordLT.GetLatitude(), hereCoordLT.GetLongitude(), &mapsCoordLT);
 206         maps_coordinates_create(hereCoordRB.GetLatitude(), hereCoordRB.GetLongitude(), &mapsCoordRB);
 207
 208         maps_area_create_rectangle(mapsCoordLT, mapsCoordRB, &hArea);
 209
 210         maps_coordinates_destroy(mapsCoordLT);
 211         maps_coordinates_destroy(mapsCoordRB);
 212
 213         return hArea;
 214 }
 215
 216 void HereUtils::Convert(String strUtf8, WString& strUtf16)
 217 {
 218         strUtf16.assign(strUtf8.begin(), strUtf8.end());
 219 }
 220
 221 void HereUtils::Convert(WString strUtf16, String& strUtf8)
 222 {
 223         strUtf8.assign(strUtf16.begin(), strUtf16.end());
 224 }
 225
 226 GeoBoundingBox& HereUtils::Convert(const char *src, GeoBoundingBox &box)
 227 {
 228         int i = 0;
 229         char *token, *next;
 230         double coord[4] = { 0.0, };
 231
 232         token = strtok_r((char*)src, ",;", &next);
 233         while (token && i < 4)
 234         {
 235                 coord[i++] = atof(token);
 236                 token = strtok_r(NULL, ",;", &next);
 237         }
 238         box.SetTopLeft(GeoCoordinates(coord[0], coord[1]));
 239         box.SetBottomRight(GeoCoordinates(coord[2], coord[3]));
 240         return box;
 241 }
 242
 243 bool HereUtils::IsValid(GeoCoordinates geoCoord)
 244 {
 245         return IsValidCoord(geoCoord.GetLatitude(), geoCoord.GetLongitude());
 246 }
 247
 248 bool HereUtils::IsValid(maps_coordinates_s geoCoord)
 249 {
 250         return IsValidCoord(geoCoord.latitude, geoCoord.longitude);
 251 }
 252
 253 bool HereUtils::IsValidCoord(double dLat, double dLng)
 254 {
 255         return ((dLat <= LATITUDE_RANGE && dLat >= -LATITUDE_RANGE) &&
 256                 (dLng <= LONGITUDE_RANGE && dLng >= -LONGITUDE_RANGE));
 257 }
 258
 259 bool HereUtils::IsValid(maps_area_s hArea)
 260 {
 261         if (hArea.type == MAPS_AREA_RECTANGLE)
 262         {
 263                 return (HereUtils::IsValid(hArea.rect.top_left) &&
 264                         HereUtils::IsValid(hArea.rect.bottom_right));
 265         }
 266         else if(hArea.type == MAPS_AREA_CIRCLE)
 267         {
 268                 return HereUtils::IsValid(hArea.circle.center);
 269         }
 270         else
 271                 return false;
 272 }
 273
 274
 275 HERE_PLUGIN_END_NAMESPACE