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-map-ielement.h"
  32 #include "location-map-pref.h"
  33 #include "location-map-service.h"
  34 #include "map-service.h"
  35
  36 EXPORT_API LocationMapObject *
  37 location_map_new (const char * provider)
  38 {
  39
  40         LocationMapObject *self = NULL;
  41         self = g_object_new (MAP_TYPE_SERVICE, "provider", provider, NULL);
  42         return self;
  43 }
  44
  45 EXPORT_API int
  46 location_map_free (LocationMapObject *obj)
  47 {
  48         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
  49
  50         g_object_unref (obj);
  51
  52         return LOCATION_ERROR_NONE;
  53 }
  54
  55 static gboolean
  56 is_connected_network()
  57 {
  58         gboolean is_connected = TRUE;
  59         int net_state = 0;
  60
  61         net_state = location_setting_get_int(VCONFKEY_NETWORK_STATUS);
  62
  63         LOCATION_LOGW("net_state[%d]", net_state);
  64         if(net_state == VCONFKEY_NETWORK_OFF) {
  65                 is_connected = FALSE;
  66         }
  67
  68         return is_connected;
  69
  70 }
  71
  72 EXPORT_API int
  73 location_map_get_position_from_address (LocationMapObject *obj,
  74         const LocationAddress *address,
  75         GList **position_list,
  76         GList **accuracy_list)
  77 {
  78         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
  79         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
  80         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
  81
  82         int ret = LOCATION_ERROR_NONE;
  83         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
  84
  85         ret = location_map_ielement_get_geocode (LOCATION_MAP_IELEMENT(obj), address, svc_pref, position_list, accuracy_list);
  86         location_map_pref_free(svc_pref);
  87
  88         return ret;
  89 }
  90
  91 EXPORT_API int
  92 location_map_get_position_from_freeformed_address (LocationMapObject *obj,
  93         const gchar *address,
  94         GList **position_list,
  95         GList **accuracy_list)
  96 {
  97         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
  98         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
  99         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 100
 101         int ret = LOCATION_ERROR_NONE;
 102         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 103
 104         ret = location_map_ielement_get_geocode_freeform (LOCATION_MAP_IELEMENT(obj), address, svc_pref, position_list, accuracy_list);
 105         location_map_pref_free(svc_pref);
 106
 107         return ret;
 108 }
 109
 110 EXPORT_API int
 111 location_map_get_address (LocationMapObject *obj,
 112         LocationAddress **address,
 113         LocationAccuracy **accuracy)
 114 {
 115         return LOCATION_ERROR_NOT_SUPPORTED;
 116 }
 117
 118 EXPORT_API int
 119 location_map_get_address_from_position (LocationMapObject *obj,
 120         const LocationPosition *position,
 121         LocationAddress **address,
 122         LocationAccuracy **accuracy)
 123 {
 124         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 125         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 126         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 127
 128         int ret = LOCATION_ERROR_NONE;
 129         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 130
 131         ret = location_map_ielement_get_reversegeocode (LOCATION_MAP_IELEMENT(obj), position, svc_pref, address, accuracy);
 132         location_map_pref_free(svc_pref);
 133
 134         return ret;
 135 }
 136
 137 EXPORT_API int
 138 location_map_get_position_from_address_async (LocationMapObject *obj,
 139         const LocationAddress *address,
 140         LocationPositionCB callback,
 141         gpointer userdata)
 142 {
 143         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 144         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 145         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 146
 147         int ret = LOCATION_ERROR_NONE;
 148         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 149
 150         ret = location_map_ielement_get_geocode_async (LOCATION_MAP_IELEMENT(obj), address, svc_pref, callback, userdata);
 151         location_map_pref_free(svc_pref);
 152
 153         return ret;
 154 }
 155
 156
 157 EXPORT_API int
 158 location_map_get_position_from_freeformed_address_async (LocationMapObject *obj,
 159         const gchar *address,
 160         LocationPositionCB callback,
 161         gpointer userdata)
 162 {
 163         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 164         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 165         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 166
 167         int ret = LOCATION_ERROR_NONE;
 168         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 169
 170         ret = location_map_ielement_get_geocode_freeform_async (LOCATION_MAP_IELEMENT(obj), address, svc_pref, callback, userdata);
 171         location_map_pref_free(svc_pref);
 172
 173         return ret;
 174 }
 175
 176 EXPORT_API int
 177 location_map_get_address_from_position_async (LocationMapObject *obj,
 178         const LocationPosition *position,
 179         LocationAddressCB callback,
 180         gpointer userdata)
 181 {
 182         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 183         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 184         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 185
 186         int ret = LOCATION_ERROR_NONE;
 187         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 188
 189         ret = location_map_ielement_get_reversegeocode_async (LOCATION_MAP_IELEMENT(obj), position, svc_pref, callback, userdata);
 190         location_map_pref_free(svc_pref);
 191
 192         return ret;
 193 }
 194
 195 EXPORT_API int
 196 location_map_search_poi (LocationMapObject *obj,
 197                 const LocationPOIFilter *filter,
 198                 const LocationPosition *position,
 199                 const LocationPOIPreference *pref,
 200                 LocationPOICB cb, gpointer user_data, guint * req_id)
 201 {
 202         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 203         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 204         g_return_val_if_fail (filter, LOCATION_ERROR_PARAMETER);
 205         g_return_val_if_fail (position, LOCATION_ERROR_PARAMETER);
 206         g_return_val_if_fail (pref, LOCATION_ERROR_PARAMETER);
 207         g_return_val_if_fail (cb, LOCATION_ERROR_PARAMETER);
 208         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 209         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 210
 211         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 212
 213         return location_map_ielement_search_poi (LOCATION_MAP_IELEMENT(obj), filter, position, svc_pref, pref, cb, user_data, req_id);
 214 }
 215
 216 EXPORT_API int
 217 location_map_search_poi_by_area (LocationMapObject *obj,
 218                 const LocationPOIFilter *filter,
 219                 const LocationBoundary *boundary,
 220                 const LocationPOIPreference *pref,
 221                 LocationPOICB cb, gpointer user_data, guint * req_id)
 222 {
 223         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 224         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 225         g_return_val_if_fail (filter, LOCATION_ERROR_PARAMETER);
 226         g_return_val_if_fail (boundary, LOCATION_ERROR_PARAMETER);
 227         g_return_val_if_fail (pref, LOCATION_ERROR_PARAMETER);
 228         g_return_val_if_fail (cb, LOCATION_ERROR_PARAMETER);
 229         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 230         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 231
 232         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 233
 234         return location_map_ielement_search_poi_by_area (LOCATION_MAP_IELEMENT(obj), filter, boundary, svc_pref, pref, cb, user_data, req_id);
 235 }
 236
 237 EXPORT_API int
 238 location_map_search_poi_by_address (LocationMapObject *obj, const LocationPOIFilter * filter,
 239                                 const LocationAddress * address, const LocationPOIPreference * pref,
 240                                 LocationPOICB cb, gpointer user_data, guint * req_id)
 241 {
 242         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 243         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 244         g_return_val_if_fail (filter, LOCATION_ERROR_PARAMETER);
 245         g_return_val_if_fail (address, LOCATION_ERROR_PARAMETER);
 246         g_return_val_if_fail (pref, LOCATION_ERROR_PARAMETER);
 247         g_return_val_if_fail (cb, LOCATION_ERROR_PARAMETER);
 248         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 249         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 250
 251         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 252
 253         return location_map_ielement_search_poi_by_address (LOCATION_MAP_IELEMENT(obj), filter, address, svc_pref, pref, cb, user_data, req_id);
 254 }
 255
 256 EXPORT_API int
 257 location_map_search_poi_by_freeformed_address (LocationMapObject *obj,
 258                 const LocationPOIFilter *filter,
 259                 const gchar *address,
 260                 const LocationPOIPreference *pref,
 261                 LocationPOICB cb, gpointer user_data, guint *req_id)
 262 {
 263         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 264         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 265         g_return_val_if_fail (filter, LOCATION_ERROR_PARAMETER);
 266         g_return_val_if_fail (address, 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 (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 271
 272         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 273
 274         return location_map_ielement_search_poi_by_freeform (LOCATION_MAP_IELEMENT(obj), filter, address, svc_pref, pref, cb, user_data, req_id);
 275 }
 276
 277 EXPORT_API int
 278 location_map_cancel_poi_request (LocationMapObject *obj, guint req_id)
 279 {
 280         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 281         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 282         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 283         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 284
 285         return location_map_ielement_cancel_poi_request (LOCATION_MAP_IELEMENT(obj), req_id);
 286 }
 287
 288 EXPORT_API int
 289 location_map_request_route (LocationMapObject *obj, LocationPosition *origin, LocationPosition *destination,
 290                                 GList *waypoint, const LocationRoutePreference * pref,
 291                                 LocationRouteCB cb, gpointer user_data, guint * req_id)
 292 {
 293         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 294         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 295         g_return_val_if_fail (origin, LOCATION_ERROR_PARAMETER);
 296         g_return_val_if_fail (destination, LOCATION_ERROR_PARAMETER);
 297         g_return_val_if_fail (pref, LOCATION_ERROR_PARAMETER);
 298         g_return_val_if_fail (cb, LOCATION_ERROR_PARAMETER);
 299         g_return_val_if_fail (req_id, LOCATION_ERROR_PARAMETER);
 300         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 301
 302         LocationMapPref *svc_pref = location_map_get_service_pref (obj);
 303
 304         return location_map_ielement_request_route (LOCATION_MAP_IELEMENT(obj), origin, destination,
 305                                         waypoint, svc_pref, pref, cb, user_data, req_id);
 306 }
 307
 308 EXPORT_API int
 309 location_map_cancel_route_request (LocationMapObject *obj, guint req_id)
 310 {
 311         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 312         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 313         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 314
 315         return location_map_ielement_cancel_route_request (LOCATION_MAP_IELEMENT(obj), req_id);
 316 }
 317
 318 EXPORT_API gboolean
 319 location_map_is_supported_provider_capability (LocationMapObject *obj, LocationMapServiceType type)
 320 {
 321         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 322         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 323         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 324
 325         return location_map_ielement_is_supported_provider_capability (LOCATION_MAP_IELEMENT(obj), type);
 326 }
 327
 328 EXPORT_API int
 329 location_map_get_provider_capability_key (LocationMapObject *obj, LocationMapServiceType type, GList **key)
 330 {
 331         g_return_val_if_fail (obj, LOCATION_ERROR_PARAMETER);
 332         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 333         g_return_val_if_fail (key, LOCATION_ERROR_PARAMETER);
 334         g_return_val_if_fail (is_connected_network(), LOCATION_ERROR_NETWORK_NOT_CONNECTED);
 335
 336         return location_map_ielement_get_provider_capability_key (LOCATION_MAP_IELEMENT(obj), type, key);
 337 }
 338
 339 EXPORT_API LocationMapPref *
 340 location_map_get_service_pref (LocationMapObject *obj)
 341 {
 342         g_return_val_if_fail (obj, NULL);
 343         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, NULL);
 344
 345         return map_service_get_pref (obj);
 346 }
 347
 348 EXPORT_API gboolean
 349 location_map_set_service_pref (LocationMapObject *obj, LocationMapPref *pref)
 350 {
 351         g_return_val_if_fail (obj, FALSE);
 352         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 353         g_return_val_if_fail (pref, FALSE);
 354
 355         return map_service_set_pref (obj, pref);
 356 }
 357
 358 EXPORT_API GList *
 359 location_map_get_supported_providers (LocationMapObject *obj)
 360 {
 361         g_return_val_if_fail (obj, NULL);
 362         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 363
 364         return map_service_get_supported_providers (obj);
 365 }
 366
 367 EXPORT_API gchar *
 368 location_map_get_default_provider (LocationMapObject *obj)
 369 {
 370         g_return_val_if_fail (obj, NULL);
 371         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 372
 373         return map_service_get_default_provider(obj);
 374 }
 375
 376 EXPORT_API gboolean
 377 location_map_set_provider (LocationMapObject *obj, gchar *provider)
 378 {
 379         g_return_val_if_fail (obj, NULL);
 380         g_return_val_if_fail (G_OBJECT_TYPE(obj) == MAP_TYPE_SERVICE, LOCATION_ERROR_NOT_AVAILABLE);
 381
 382         return map_service_set_provider (obj, provider);
 383 }
 384