location/map-service/location-map-service.c

   1 /*
   2  * libslp-location
   3  *
   4  * Copyright (c) 2010-2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Youngae Kang <youngae.kang@samsung.com>, Yunhan Kim <yhan.kim@samsung.com>,
   7  *          Genie Kim <daejins.kim@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
   8  *
   9  * Licensed under the Apache License, Version 2.0 (the "License");
  10  * you may not use this file except in compliance with the License.
  11  * You may obtain a copy of the License at
  12  *
  13  * http://www.apache.org/licenses/LICENSE-2.0
  14  *
  15  * Unless required by applicable law or agreed to in writing, software
  16  * distributed under the License is distributed on an "AS IS" BASIS,
  17  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  18  * See the License for the specific language governing permissions and
  19  * limitations under the License.
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include "config.h"
  24 #endif
  25
  26 #include <stdio.h>
  27
  28 #include "location.h"
  29 #include "location-log.h"
  30 #include "location-setting.h"
  31 #include "location-ielement.h"
  32 #include "location-pref.h"
  33 #include "map-service.h"
  34
  35 LocationObject *g_map_service = NULL;
  36
  37 //static LocationObject *poi = NULL;
  38
  39 static gboolean
  40 is_connected_network()
  41 {
  42         gboolean is_connected = TRUE;
  43         int net_state = 0;
  44
  45         net_state = location_setting_get_int(VCONFKEY_NETWORK_STATUS);
  46
  47         LOCATION_LOGW("net_state[%d]", net_state);
  48         if(net_state == VCONFKEY_NETWORK_OFF) {
  49                 is_connected = FALSE;
  50         }
  51
  52         return is_connected;
  53
  54 }
  55
  56 EXPORT_API int
  57 location_get_position_from_address (LocationObject *obj,
  58         const LocationAddress *address,
  59         GList **position_list,
  60         GList **accuracy_list)
  61 {
  62         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
  63         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
  64         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
  65         return location_ielement_get_geocode (LOCATION_IELEMENT(g_map_service), address, position_list, accuracy_list);
  66 }
  67
  68 EXPORT_API int
  69 location_get_position_from_freeformed_address (LocationObject *obj,
  70         const gchar *address,
  71         GList **position_list,
  72         GList **accuracy_list)
  73 {
  74         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
  75         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
  76         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
  77
  78         return location_ielement_get_geocode_freeform (LOCATION_IELEMENT(g_map_service), address, position_list, accuracy_list);
  79 }
  80
  81 EXPORT_API int
  82 location_get_address (LocationObject *obj,
  83         LocationAddress **address,
  84         LocationAccuracy **accuracy)
  85 {
  86         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
  87         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
  88         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
  89
  90         LocationPosition *position = NULL;
  91         int ret = location_ielement_get_position(LOCATION_IELEMENT (obj), &position, accuracy);
  92         if (LOCATION_ERROR_NONE != ret) return ret;
  93         ret = location_ielement_get_reversegeocode (LOCATION_IELEMENT(g_map_service), position, address, accuracy);
  94         location_position_free (position);
  95         return ret;
  96 }
  97
  98 EXPORT_API int
  99 location_get_address_from_position (LocationObject *obj,
 100         const LocationPosition *position,
 101         LocationAddress **address,
 102         LocationAccuracy **accuracy)
 103 {
 104         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 105         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 106         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 107         return location_ielement_get_reversegeocode (LOCATION_IELEMENT(g_map_service), position, address, accuracy);
 108 }
 109
 110 EXPORT_API int
 111 location_get_position_from_address_async (LocationObject *obj,
 112         const LocationAddress *address,
 113         LocationPositionCB callback,
 114         gpointer userdata)
 115 {
 116         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 117         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 118         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 119         return location_ielement_get_geocode_async (LOCATION_IELEMENT(g_map_service), address, callback, userdata);
 120 }
 121
 122
 123 EXPORT_API int
 124 location_get_position_from_freeformed_address_async (LocationObject *obj,
 125         const gchar *address,
 126         LocationPositionCB callback,
 127         gpointer userdata)
 128 {
 129         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 130         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 131         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 132         return location_ielement_get_geocode_freeform_async (LOCATION_IELEMENT(g_map_service), address, callback, userdata);
 133 }
 134
 135 EXPORT_API int
 136 location_get_address_async (LocationObject *obj,
 137         LocationAddressCB callback,
 138         gpointer userdata)
 139 {
 140         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 141         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 142         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 143
 144         LocationPosition *position = NULL;
 145         LocationAccuracy *acc = NULL;
 146         int ret = location_ielement_get_position(LOCATION_IELEMENT(obj), &position, &acc);
 147         if (LOCATION_ERROR_NONE != ret) return ret;
 148         ret = location_ielement_get_reversegeocode_async (LOCATION_IELEMENT(g_map_service), position, callback, userdata);
 149         location_position_free (position);
 150         return ret;
 151 }
 152
 153 EXPORT_API int
 154 location_get_address_from_position_async (LocationObject *obj,
 155         const LocationPosition *position,
 156         LocationAddressCB callback,
 157         gpointer userdata)
 158 {
 159         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 160         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 161         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 162
 163         return location_ielement_get_reversegeocode_async (LOCATION_IELEMENT(g_map_service), position, callback, userdata);
 164 }
 165
 166 EXPORT_API int
 167 location_search_poi (LocationObject *obj,
 168                 const LocationPOIFilter * filter,
 169                 const LocationPosition *position,
 170                 const LocationPOIPreference * pref,
 171                 LocationPOICB cb, gpointer user_data, guint * req_id)
 172 {
 173         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 174         g_return_val_if_fail (filter, LOCATION_ERROR_PARAMETER);
 175         g_return_val_if_fail (position, LOCATION_ERROR_PARAMETER);
 176         g_return_val_if_fail (pref, LOCATION_ERROR_PARAMETER);
 177         g_return_val_if_fail (cb, LOCATION_ERROR_PARAMETER);
 178         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 179         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 180         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 181
 182         LocationPreference *svc_pref = location_get_map_service_pref (g_map_service);
 183
 184         return location_ielement_search_poi (LOCATION_IELEMENT(g_map_service), filter, position, svc_pref, pref, cb, user_data, req_id);
 185 }
 186
 187 EXPORT_API int
 188 location_search_poi_by_area (LocationObject *obj,
 189                 const LocationPOIFilter * filter,
 190                 const LocationBoundary * boundary,
 191                 const LocationPOIPreference * pref,
 192                 LocationPOICB cb, gpointer user_data, guint * req_id)
 193 {
 194         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 195         g_return_val_if_fail (filter, LOCATION_ERROR_PARAMETER);
 196         g_return_val_if_fail (boundary, LOCATION_ERROR_PARAMETER);
 197         g_return_val_if_fail (pref, LOCATION_ERROR_PARAMETER);
 198         g_return_val_if_fail (cb, LOCATION_ERROR_PARAMETER);
 199         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 200         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 201         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 202
 203         LocationPreference *svc_pref = location_get_map_service_pref (g_map_service);
 204
 205         return location_ielement_search_poi_by_area (LOCATION_IELEMENT(g_map_service), filter, boundary, svc_pref, pref, cb, user_data, req_id);
 206 }
 207
 208 EXPORT_API int
 209 location_search_poi_by_address (LocationObject *obj, const LocationPOIFilter * filter,
 210                                 const LocationAddress * address, const LocationPOIPreference * pref,
 211                                 LocationPOICB cb, gpointer user_data, guint * req_id)
 212 {
 213         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 214         g_return_val_if_fail (filter, LOCATION_ERROR_PARAMETER);
 215         g_return_val_if_fail (address, LOCATION_ERROR_PARAMETER);
 216         g_return_val_if_fail (pref, LOCATION_ERROR_PARAMETER);
 217         g_return_val_if_fail (cb, LOCATION_ERROR_PARAMETER);
 218         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 219         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 220         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 221
 222         LocationPreference *svc_pref = location_get_map_service_pref (g_map_service);
 223
 224         return location_ielement_search_poi_by_address (LOCATION_IELEMENT(g_map_service), filter, address, svc_pref, pref, cb, user_data, req_id);
 225 }
 226
 227 EXPORT_API int
 228 location_search_poi_by_freeformed_address (LocationObject *obj,
 229                 const LocationPOIFilter * filter,
 230                 const gchar * address,
 231                 const LocationPOIPreference * pref,
 232                 LocationPOICB cb, gpointer user_data, guint * req_id)
 233 {
 234         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 235         g_return_val_if_fail (filter, LOCATION_ERROR_PARAMETER);
 236         g_return_val_if_fail (address, LOCATION_ERROR_PARAMETER);
 237         g_return_val_if_fail (pref, LOCATION_ERROR_PARAMETER);
 238         g_return_val_if_fail (cb, LOCATION_ERROR_PARAMETER);
 239         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 240         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 241         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 242
 243         LocationPreference *svc_pref = location_get_map_service_pref (g_map_service);
 244
 245         return location_ielement_search_poi_by_freeform (LOCATION_IELEMENT(g_map_service), filter, address, svc_pref, pref, cb, user_data, req_id);
 246 }
 247
 248 EXPORT_API int
 249 location_cancel_poi_request (LocationObject *obj, guint req_id)
 250 {
 251         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 252         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 253         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 254         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 255
 256         return location_ielement_cancel_poi_request (LOCATION_IELEMENT(g_map_service), req_id);
 257 }
 258
 259 EXPORT_API int
 260 location_request_route (LocationObject *obj, LocationPosition *origin, LocationPosition *destination,
 261                                 GList *waypoint, const LocationRoutePreference * pref,
 262                                 LocationRouteCB cb, gpointer user_data, guint * req_id)
 263 {
 264         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 265         g_return_val_if_fail (origin, LOCATION_ERROR_PARAMETER);
 266         g_return_val_if_fail (destination, LOCATION_ERROR_PARAMETER);
 267         g_return_val_if_fail (pref, LOCATION_ERROR_PARAMETER);
 268         g_return_val_if_fail (cb, LOCATION_ERROR_PARAMETER);
 269         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 270         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 271         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 272
 273         LocationPreference *svc_pref = location_get_map_service_pref (g_map_service);
 274
 275         return location_ielement_request_route (LOCATION_IELEMENT(g_map_service), origin, destination,
 276                                         waypoint, svc_pref, pref, cb, user_data, req_id);
 277 }
 278
 279 EXPORT_API int
 280 location_cancel_route_request (LocationObject *obj, guint req_id)
 281 {
 282         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 283         g_return_val_if_fail (g_map_service, LOCATION_ERROR_NOT_AVAILABLE);
 284         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 285
 286         return location_ielement_cancel_route_request (LOCATION_IELEMENT(g_map_service), req_id);
 287 }
 288
 289 EXPORT_API gboolean
 290 location_is_supported_map_provider_capability (LocationObject *obj, LocationMapServiceType type)
 291 {
 292         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 293         g_return_val_if_fail (g_map_service, LOCATION_ERROR_PARAMETER);
 294         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 295
 296         return location_ielement_is_supported_map_provider_capability (LOCATION_IELEMENT(g_map_service), type);
 297 }
 298
 299 EXPORT_API int
 300 location_get_map_provider_capability_key (LocationObject *obj, LocationMapServiceType type, GList **key)
 301 {
 302         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 303         g_return_val_if_fail (key, LOCATION_ERROR_PARAMETER);
 304         g_return_val_if_fail (g_map_service, LOCATION_ERROR_PARAMETER);
 305         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 306
 307         return location_ielement_get_map_provider_capability_key (LOCATION_IELEMENT(g_map_service), type, key);
 308 }
 309
 310 EXPORT_API LocationPreference *
 311 location_get_map_service_pref (LocationObject *obj)
 312 {
 313         g_return_val_if_fail (obj, NULL);
 314         g_return_val_if_fail (g_map_service, NULL);
 315
 316         return map_service_get_pref (g_map_service);
 317 }
 318
 319 EXPORT_API gboolean
 320 location_set_map_service_pref (LocationObject *obj, LocationPreference *pref)
 321 {
 322         g_return_val_if_fail (obj, FALSE);
 323         g_return_val_if_fail (pref, FALSE);
 324         g_return_val_if_fail (g_map_service, FALSE);
 325
 326         return map_service_set_pref (g_map_service, pref);
 327 }