modules/osm/location-osm.c

   1 /*
   2  * location-module
   3  *
   4  * Copyright (c) 2010-2013 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Youngae Kang <youngae.kang@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
   7  *          Genie Kim <daejins.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 #include <glib.h>
  23
  24 #include <location.h>
  25 #include <location-map-service.h>
  26 #include "location-osm-geocode.h"
  27 #include "location-osm-route.h"
  28 #include "location-osm-poi.h"
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include "config.h"
  32 #endif
  33 #include "log.h"
  34
  35 static void
  36 _unref_geoclue(OsmHandle* handle)
  37 {
  38         if (handle->geocoder) {
  39                 g_object_unref (handle->geocoder);
  40                 handle->geocoder = NULL;
  41         }
  42         if (handle->rev_geocoder) {
  43                 g_object_unref (handle->rev_geocoder);
  44                 handle->rev_geocoder = NULL;
  45         }
  46         if (handle->poi) {
  47                 g_object_unref (handle->poi);
  48                 handle->poi = NULL;
  49         }
  50 }
  51
  52 static gboolean
  53 _ref_geoclue(OsmHandle* handle)
  54 {
  55         gchar *service, *path;
  56         service = g_strdup_printf ("org.freedesktop.Geoclue.Providers.Nominatim");
  57         path = g_strdup_printf ("/org/freedesktop/Geoclue/Providers/Nominatim");
  58
  59         if (!handle->geocoder) handle->geocoder = geoclue_geocode_new (service, path);
  60         if (!handle->rev_geocoder) handle->rev_geocoder = geoclue_reverse_geocode_new (service, path);
  61         if (!handle->poi) handle->poi = geoclue_poi_new (service, path);
  62
  63         if(!handle->geocoder || !handle->rev_geocoder || !handle->poi){
  64                 MOD_LOGW ("Error while creating Geoclue object.");
  65                 _unref_geoclue(handle);
  66                 return FALSE;
  67         }
  68         return TRUE;
  69 }
  70
  71 static int
  72 get_geocode (gpointer handle,
  73         const LocationAddress *addr,
  74         const LocationMapPref *svc_pref,
  75         GList **pos_list,
  76         GList **acc_list)
  77 {
  78         OsmHandle *osm = (OsmHandle *)handle;
  79         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
  80         g_return_val_if_fail(addr, LOCATION_ERROR_PARAMETER);
  81         g_return_val_if_fail(pos_list, LOCATION_ERROR_PARAMETER);
  82         g_return_val_if_fail(acc_list, LOCATION_ERROR_PARAMETER);
  83
  84         return osm_get_geocode(osm, addr, pos_list, acc_list);
  85 }
  86
  87
  88 static int
  89 get_geocode_async (gpointer handle,
  90         const LocationAddress *addr,
  91         const LocationMapPref *svc_pref,
  92         LocationPositionCB callback,
  93         gpointer userdata)
  94 {
  95         OsmHandle *osm = (OsmHandle *)handle;
  96         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
  97         g_return_val_if_fail(addr, LOCATION_ERROR_PARAMETER);
  98         g_return_val_if_fail(callback, LOCATION_ERROR_PARAMETER);
  99
 100         return osm_get_geocode_async(osm, addr, callback, userdata);
 101 }
 102
 103 static int
 104 get_geocode_freetext(gpointer handle,
 105         const gchar *addr,
 106         const LocationMapPref *svc_pref,
 107         GList **pos_list,
 108         GList **acc_list)
 109 {
 110         OsmHandle *osm = (OsmHandle *)handle;
 111         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
 112         g_return_val_if_fail(addr, LOCATION_ERROR_PARAMETER);
 113         g_return_val_if_fail(pos_list, LOCATION_ERROR_PARAMETER);
 114         g_return_val_if_fail(acc_list, LOCATION_ERROR_PARAMETER);
 115
 116         return osm_get_geocode_freetext(osm, addr, pos_list, acc_list);
 117 }
 118
 119
 120 static int
 121 get_geocode_freetext_async (gpointer handle,
 122         const gchar* addr,
 123         const LocationMapPref *svc_pref,
 124         LocationPositionCB callback,
 125         gpointer userdata)
 126 {
 127         OsmHandle *osm = (OsmHandle *)handle;
 128         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
 129         g_return_val_if_fail(addr, LOCATION_ERROR_PARAMETER);
 130         g_return_val_if_fail(callback, LOCATION_ERROR_PARAMETER);
 131
 132         return osm_get_geocode_freetext_async(osm, addr, callback, userdata);
 133 }
 134
 135 static int
 136 get_reverse_geocode(gpointer handle,
 137         const LocationPosition *pos,
 138         const LocationMapPref *svc_pref,
 139         LocationAddress **addr,
 140         LocationAccuracy **acc)
 141 {
 142         OsmHandle *osm = (OsmHandle *)handle;
 143         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
 144         g_return_val_if_fail(pos, LOCATION_ERROR_PARAMETER);
 145         g_return_val_if_fail(addr, LOCATION_ERROR_PARAMETER);
 146         g_return_val_if_fail(acc, LOCATION_ERROR_PARAMETER);
 147
 148         return osm_get_reverse_geocode(osm, pos, addr, acc);
 149 }
 150
 151 static int
 152 get_reverse_geocode_async (gpointer handle,
 153         const LocationPosition *pos,
 154         const LocationMapPref *svc_pref,
 155         LocationAddressCB callback,
 156         gpointer userdata)
 157 {
 158         OsmHandle *osm = (OsmHandle *)handle;
 159         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
 160         g_return_val_if_fail(pos, LOCATION_ERROR_PARAMETER);
 161         g_return_val_if_fail(callback, LOCATION_ERROR_PARAMETER);
 162
 163         return osm_get_reverse_geocode_async(osm, pos, callback, userdata);
 164 }
 165
 166 static int
 167 search_poi (gpointer handle,
 168         const LocationPOIFilter *filter,
 169         const LocationPosition *position,
 170         const LocationMapPref *svc_pref,
 171         const LocationPOIPreference *pref,
 172         LocationPOICB cb, const gpointer user_data, guint * req_id)
 173 {
 174         OsmHandle *osm = (OsmHandle *)handle;
 175         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
 176         g_return_val_if_fail(filter, LOCATION_ERROR_PARAMETER);
 177         g_return_val_if_fail(position, LOCATION_ERROR_PARAMETER);
 178         g_return_val_if_fail(pref, LOCATION_ERROR_PARAMETER);
 179         g_return_val_if_fail(cb, LOCATION_ERROR_PARAMETER);
 180         g_return_val_if_fail(req_id, LOCATION_ERROR_PARAMETER);
 181
 182
 183         return osm_search_poi_by_position(osm, filter, position, svc_pref, pref, cb, user_data, req_id);
 184 }
 185
 186 static int
 187 search_poi_by_area (gpointer handle,
 188         const LocationPOIFilter *filter,
 189         const LocationBoundary *boundary,
 190         const LocationMapPref *svc_pref,
 191         const LocationPOIPreference *pref,
 192         LocationPOICB cb, const gpointer user_data, guint * req_id)
 193 {
 194         OsmHandle *osm = (OsmHandle *)handle;
 195         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
 196         g_return_val_if_fail(filter, LOCATION_ERROR_PARAMETER);
 197         g_return_val_if_fail(boundary, LOCATION_ERROR_PARAMETER);
 198         g_return_val_if_fail(pref, LOCATION_ERROR_PARAMETER);
 199         g_return_val_if_fail(cb, LOCATION_ERROR_PARAMETER);
 200         g_return_val_if_fail(req_id, LOCATION_ERROR_PARAMETER);
 201         g_return_val_if_fail(boundary->type == LOCATION_BOUNDARY_RECT, LOCATION_ERROR_NOT_SUPPORTED);
 202
 203         return osm_search_poi_by_area(osm, filter, boundary, svc_pref, pref, cb, user_data, req_id);;
 204 }
 205
 206 static int
 207 search_poi_by_address (gpointer handle,
 208         const LocationPOIFilter *filter,
 209         const LocationAddress *address,
 210         const LocationMapPref *svc_pref,
 211         const LocationPOIPreference *pref,
 212         LocationPOICB cb, const gpointer user_data, guint * req_id)
 213 {
 214         return LOCATION_ERROR_NOT_SUPPORTED;
 215 }
 216
 217 static int
 218 search_poi_by_freeform (gpointer handle,
 219         const LocationPOIFilter * filter,
 220         const gchar *freeform,
 221         const LocationMapPref *svc_pref,
 222         const LocationPOIPreference *pref,
 223         LocationPOICB cb, const gpointer user_data, guint *req_id)
 224 {
 225         return LOCATION_ERROR_NOT_SUPPORTED;
 226 }
 227
 228 static int
 229 cancel_poi_request (gpointer handle, guint req_id)
 230 {
 231         return LOCATION_ERROR_NOT_SUPPORTED;
 232 }
 233
 234 static int
 235 request_route (gpointer handle,
 236                 const LocationPosition *origin,
 237                 const LocationPosition *destination,
 238                 GList *waypoint,
 239                 const LocationMapPref *svc_pref,
 240                 const LocationRoutePreference *pref,
 241                 LocationRouteCB cb, const gpointer user_data, guint * req_id)
 242 {
 243         OsmHandle *osm = (OsmHandle *)handle;
 244         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
 245
 246         return osm_request_route(origin, destination, waypoint, svc_pref, pref, cb, user_data, req_id);
 247 }
 248
 249 static int
 250 cancel_route_request (gpointer handle, guint req_id)
 251 {
 252         OsmHandle *osm = (OsmHandle *) handle;
 253         g_return_val_if_fail (osm, LOCATION_ERROR_NOT_AVAILABLE);
 254
 255         return osm_cancel_route_request (req_id);
 256 }
 257
 258 static gboolean
 259 is_supported_provider_capability (gpointer handle,
 260                 LocationMapServiceType type)
 261 {
 262         return FALSE;
 263 }
 264
 265 static int
 266 get_provider_capability_key (gpointer handle,
 267                 LocationMapServiceType type, GList **key)
 268 {
 269         g_return_val_if_fail (key, LOCATION_ERROR_PARAMETER);
 270         *key = NULL;
 271         return LOCATION_ERROR_NOT_SUPPORTED;
 272 }
 273
 274 static int
 275 get_service_name (gpointer handle,
 276         gchar **service_name)
 277 {
 278         OsmHandle *osm = (OsmHandle *)handle;
 279         g_return_val_if_fail(osm, LOCATION_ERROR_NOT_AVAILABLE);
 280         g_return_val_if_fail (service_name, LOCATION_ERROR_PARAMETER);
 281         *service_name = g_strdup (osm->service_name);
 282         return LOCATION_ERROR_NONE;
 283 }
 284
 285 LOCATION_MODULE_API gpointer
 286 init (LocModServiceOps* ops)
 287 {
 288         MOD_LOGD("init");
 289         g_return_val_if_fail(ops, NULL);
 290         OsmHandle *handle = g_new0 (OsmHandle, 1);
 291         if (!_ref_geoclue(handle)) {
 292                 g_free (handle);
 293                 return NULL;
 294         }
 295         handle->service_name = g_strdup ("osm");
 296         ops->get_service_name = get_service_name;
 297         ops->get_geocode = get_geocode;
 298         ops->get_geocode_freetext = get_geocode_freetext;
 299         ops->get_reverse_geocode = get_reverse_geocode;
 300         ops->get_geocode_async = get_geocode_async;
 301         ops->get_geocode_freetext_async = get_geocode_freetext_async;
 302         ops->get_reverse_geocode_async = get_reverse_geocode_async;
 303         ops->search_poi = search_poi;
 304         ops->search_poi_by_area = search_poi_by_area;
 305         ops->search_poi_by_address = search_poi_by_address;
 306         ops->search_poi_by_freeform = search_poi_by_freeform;
 307         ops->cancel_poi_request = cancel_poi_request;
 308         ops->request_route = request_route;
 309         ops->cancel_route_request = cancel_route_request;
 310         ops->is_supported_provider_capability = is_supported_provider_capability;
 311         ops->get_provider_capability_key = get_provider_capability_key;
 312
 313         return (gpointer)handle;
 314 }
 315
 316 LOCATION_MODULE_API void
 317 shutdown (gpointer handle)
 318 {
 319         MOD_LOGD("shutdown");
 320         g_return_if_fail(handle);
 321         OsmHandle *osm = (OsmHandle *)handle;
 322         g_free (osm->service_name);
 323         _unref_geoclue(osm);
 324         g_free (osm);
 325 }