location/map-service/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 <glib-object.h>
  27 #include <vconf.h>
  28 #include <stdio.h>
  29 #include <string.h>
  30 #include "location-log.h"
  31 #include "location-map-pref.h"
  32
  33 #include "module-internal.h"
  34
  35 #include "map-internal.h"
  36 #include "map-service.h"
  37 #include "location-map-ielement.h"
  38
  39 #define MAP_SERVICE_PREFIX              "map-service"
  40
  41 gchar *provider_list[] = {
  42         "decarta",
  43         "osm",
  44 };
  45
  46
  47 enum {
  48         PROP_0,
  49         PROP_PROVIDER,
  50         PROP_MAX
  51 };
  52
  53 static GParamSpec *pspec[PROP_MAX] = {NULL, };
  54
  55 static void map_service_ielement_interface_init (LocationMapIElementInterface *iface);
  56 gchar *map_service_get_default_provider (GObject *obj);
  57
  58 G_DEFINE_TYPE_WITH_CODE (MapService, map_service, G_TYPE_OBJECT,
  59         G_IMPLEMENT_INTERFACE (LOCATION_MAP_TYPE_IELEMENT, map_service_ielement_interface_init));
  60
  61 static void
  62 _get_lang (gchar country_code[3], gchar lang_code[3])
  63 {
  64        if (!country_code || !lang_code) return;
  65        gchar* langset = vconf_get_str(VCONFKEY_LANGSET);
  66        LOCATION_LOGD("getenv: %s", langset);
  67
  68        if(langset == NULL){
  69               lang_code[0] = 'E';
  70               lang_code[1] = 'N';
  71               lang_code[2] = '\0';
  72               country_code[0] = 'U';
  73               country_code[1] = 'S';
  74               country_code[2] = '\0';
  75        }else{
  76               gchar* langset_upper = g_ascii_strup(langset, -1);
  77               lang_code[0] = langset_upper[0];
  78               lang_code[1] = langset_upper[1];
  79               lang_code[2] = '\0';
  80               country_code[0] = langset_upper[3];
  81               country_code[1] = langset_upper[4];
  82               country_code[2] = '\0';
  83               g_free(langset_upper);
  84        }
  85        LOCATION_LOGD("Language: %s, Country: %s", lang_code, country_code);
  86 }
  87
  88
  89 static void
  90 map_service_dispose (GObject *gobject)
  91 {
  92         LOCATION_LOGD("map_service_dispose");
  93
  94         G_OBJECT_CLASS (map_service_parent_class)->dispose (gobject);
  95 }
  96
  97 static void
  98 map_service_finalize (GObject *gobject)
  99 {
 100         LOCATION_LOGD("map_service_finalize");
 101         MapServicePrivate* priv = GET_PRIVATE(gobject);
 102         module_free(priv->mod, "map-service");
 103         priv->mod = NULL;
 104         G_OBJECT_CLASS (map_service_parent_class)->finalize (gobject);
 105 }
 106
 107 static void
 108 map_service_get_property (GObject *object,
 109         guint property_id,
 110         GValue *value,
 111         GParamSpec *pspec)
 112 {
 113         LOCATION_LOGD("Enter map_service_get_property");
 114         MapServicePrivate *priv = GET_PRIVATE (object);
 115
 116         g_return_if_fail(priv->mod);
 117         g_return_if_fail(priv->mod->handler);
 118         switch (property_id){
 119         case PROP_PROVIDER:{
 120                 char* service_name = NULL;
 121                 if(priv->mod->ops.get_service_name){
 122                         if( LOCATION_ERROR_NONE != priv->mod->ops.get_service_name(priv->mod->handler, &service_name) ){
 123                                 service_name = NULL;
 124                         }
 125                 }
 126                 LOCATION_LOGD("Get prop>> Service name: %s", service_name);
 127                 g_value_set_string(value, service_name);
 128                 g_free(service_name);
 129                 break;
 130         }
 131         default:
 132                 G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
 133                 break;
 134         }
 135 }
 136
 137 static void
 138 map_service_set_property (GObject *object,
 139         guint property_id,
 140         const GValue *value,
 141         GParamSpec *pspec)
 142 {
 143         LOCATION_LOGD("map_service_set_property");
 144         MapServicePrivate *priv = GET_PRIVATE (object);
 145
 146         switch (property_id) {
 147                 case PROP_PROVIDER: {
 148                         char buf[256] = {0, };
 149                         gchar *service = g_value_dup_string(value);
 150
 151                         if (priv->mod && priv->pref) {
 152                                 char *cur_provider = location_map_pref_get_provider_name (priv->pref);
 153                                 if (g_strcmp0 (cur_provider, MAP_SERVICE_PREFIX) == 0) {
 154                                         snprintf(buf, 255, "%s", cur_provider);
 155                                 }
 156                                 else {
 157                                         snprintf(buf, 255, "%s-%s", MAP_SERVICE_PREFIX, cur_provider);
 158                                 }
 159                                 module_free(priv->mod, buf);
 160                                 memset (buf, 256, 0x0);
 161                                 priv->mod = NULL;
 162                         }
 163
 164                         if (service == NULL) {
 165                                 snprintf (buf, 255, "%s", MAP_SERVICE_PREFIX);
 166                                 service = map_service_get_default_provider(object);
 167                         } else {
 168                                 snprintf (buf, 255, "%s-%s", MAP_SERVICE_PREFIX, service);
 169                         }
 170
 171                         priv->mod = (LocationServiceMod *)module_new (buf);
 172                         if (priv->mod == NULL) {
 173                                 priv->mod = (LocationServiceMod *) module_new (MAP_SERVICE_PREFIX);
 174                                 service = map_service_get_default_provider(object);
 175                         }
 176
 177                         if (priv->pref) {
 178                                 location_map_pref_set_provider_name (priv->pref, service);
 179                         }
 180
 181                         g_free (service);
 182                         break;
 183                 }
 184         }
 185 }
 186
 187 static void
 188 map_service_ielement_interface_init (LocationMapIElementInterface *iface)
 189 {
 190         iface->get_geocode = (TYPE_GET_GEOCODE)map_service_get_geocode;
 191         iface->get_geocode_freeform = (TYPE_GET_GEOCODE_FREEFORM)map_service_get_geocode_freeform;
 192         iface->get_reversegeocode = (TYPE_GET_REVERSEGEOCODE)map_service_get_reversegeocode;
 193         iface->get_geocode_async = (TYPE_GET_GEOCODE_ASYNC)map_service_get_geocode_async;
 194         iface->get_geocode_freeform_async = (TYPE_GET_GEOCODE_FREEFORM_ASYNC)map_service_get_geocode_freeform_async;
 195         iface->get_reversegeocode_async = (TYPE_GET_REVERSEGEOCODE_ASYNC)map_service_get_reversegeocode_async;
 196         iface->search_poi = (TYPE_SEARCH_POI) map_service_search_poi;
 197         iface->search_poi_by_area = (TYPE_SEARCH_POI_BY_AREA) map_service_search_poi_by_area;
 198         iface->search_poi_by_address = (TYPE_SEARCH_POI_BY_ADDR) map_service_search_poi_by_address;
 199         iface->search_poi_by_freeform = (TYPE_SEARCH_POI_BY_FREEFORM) map_service_search_poi_by_freeform;
 200         iface->cancel_poi_request = (TYPE_CANCEL_POI_REQUEST) map_service_cancel_poi_request;
 201         iface->request_route = (TYPE_REQUEST_ROUTE) map_service_request_route;
 202         iface->cancel_route_request = (TYPE_CANCEL_ROUTE_REQUEST) map_service_cancel_route_request;
 203         iface->is_supported_provider_capability = (TYPE_IS_SUPPORTED_PROVIDER_CAPABILITY) map_service_is_supported_provider_capability;
 204         iface->get_provider_capability_key = (TYPE_GET_PROVIDER_CAPABILITY_KEY) map_service_get_provider_capability_key;
 205
 206 }
 207
 208 static void
 209 map_service_init (MapService *self)
 210 {
 211         LOCATION_LOGD("map_service_init");
 212         MapServicePrivate* priv = GET_PRIVATE(self);
 213
 214         priv->pref = location_map_pref_new ();
 215         if(!priv->pref) LOCATION_LOGW("Service preference failed");
 216
 217         gchar country[3], lang[3];
 218         _get_lang (country, lang);
 219         location_map_pref_set_language (priv->pref, lang);
 220         location_map_pref_set_distance_unit (priv->pref, "MI");
 221         location_map_pref_set_provider_name (priv->pref, "decarta");
 222 }
 223
 224 static void
 225 map_service_class_init (MapServiceClass *klass)
 226 {
 227         LOCATION_LOGD("map_service_class_init");
 228         GObjectClass *gobject_class = G_OBJECT_CLASS (klass);
 229
 230         gobject_class->get_property = map_service_get_property;
 231         gobject_class->set_property = map_service_set_property;
 232
 233         gobject_class->dispose = map_service_dispose;
 234         gobject_class->finalize = map_service_finalize;
 235
 236         g_type_class_add_private (klass, sizeof (MapServicePrivate));
 237
 238         pspec[PROP_PROVIDER] = g_param_spec_string ("provider",
 239                                 "map service provider name prop",
 240                                 "map service provider name",
 241                                 MAP_SERVICE_PREFIX,
 242                                 G_PARAM_READWRITE);
 243         g_object_class_install_properties (gobject_class,
 244                                    PROP_MAX,
 245                                    pspec);
 246 }
 247
 248 LocationMapPref *
 249 map_service_get_pref(GObject *obj)
 250 {
 251         LOCATION_LOGD("map_service_get_pref");
 252         MapServicePrivate* priv = GET_PRIVATE(obj);
 253         if (!priv) return NULL;
 254         if (!priv->pref) return NULL;
 255
 256         LocationMapPref *pref = location_map_pref_copy(priv->pref);
 257
 258         return pref;
 259 }
 260
 261 gboolean
 262 map_service_set_pref (GObject *obj, LocationMapPref *pref)
 263 {
 264         LOCATION_LOGD("map_service_set_pref");
 265
 266         gchar *provider = NULL;
 267         MapServicePrivate* priv = GET_PRIVATE(obj);
 268         if (!priv) return FALSE;
 269         if (!priv->pref) location_map_pref_free(priv->pref);
 270
 271         priv->pref = location_map_pref_copy (pref);
 272         provider = location_map_pref_get_provider_name (pref);
 273         if (provider) {
 274                 g_object_set (obj, "provider", provider, NULL);
 275         }
 276
 277         return TRUE;
 278 }
 279
 280 GList *
 281 map_service_get_supported_providers (GObject *obj)
 282 {
 283         LOCATION_LOGD("map_service_get_supported_providers");
 284
 285         int idx;
 286         gchar buf[128] = {0, };
 287         GList *list = NULL;
 288
 289         for (idx = 0; idx < sizeof(provider_list)/sizeof(gchar*); idx++) {
 290                 memset (buf, 128, 0x0);
 291                 snprintf(buf, 127, "%s-%s", MAP_SERVICE_PREFIX, provider_list[idx]);
 292                 if (module_is_supported(buf) == TRUE) {
 293                         list = g_list_append(list, g_strdup (provider_list[idx]));
 294                 }
 295         }
 296
 297         return list;
 298 }
 299
 300 gchar *
 301 map_service_get_default_provider (GObject *obj)
 302 {
 303         LOCATION_LOGD("map_service_get_default_provider");
 304
 305         int idx = 0;
 306         gchar *path = mod_get_realpath (MAP_SERVICE_PREFIX);
 307         if (!path) return NULL;
 308
 309         for (idx = 0; idx < sizeof(provider_list)/sizeof(gchar*); idx++) {
 310                 if (strstr (path, provider_list[idx]) != NULL) {
 311                         break;
 312                 }
 313         }
 314
 315         if (idx == sizeof(provider_list)/sizeof(gchar*)) {
 316                 return NULL;
 317         }
 318
 319         g_free (path);
 320         return g_strdup (provider_list[idx]);
 321 }
 322
 323 gboolean
 324 map_service_set_provider (GObject *obj, gchar *provider)
 325 {
 326         LOCATION_LOGD("map_service_get_default_provider");
 327         gchar *set_provider = NULL;
 328
 329         g_object_set (obj, "provider", provider, NULL);
 330         g_object_get (obj, "provider", &set_provider, NULL);
 331
 332         if (set_provider && strcmp (provider, set_provider) != 0) {
 333                 LOCATION_LOGE("Requested [%s], but current provider [%s]", provider, set_provider);
 334                 g_free (set_provider);
 335                 return FALSE;
 336         }
 337
 338         g_free (set_provider);
 339         return TRUE;
 340 }