location/map-service/location-landmark.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 "location-log.h"
  27 #include "location.h"
  28 #include "location-types.h"
  29 #include "map-service.h"
  30
  31 struct _LocationLandmark {
  32
  33         guint id;                       ///< Unique identifier of the landmark
  34         guint priority;                 ///< Degree of importance of the landmark (Between HIGHEST_LANDMARK_PRIORITY and LOWEST_LANDMARK_PRIORITY)
  35         gchar *name;                    ///< Name of landmark
  36         LocationPosition *position;             ///< Positon of the landmark, may be null if not known
  37         LocationAddress *addr;          ///< Textual address information of the landmark, may be null if not
  38         LocationBoundary *bbox; ///< Coverage area of the landmark, may be null if not available
  39         guint timestamp;                ///< Time when the landmark data was last updated (updated by system and used to facilitate tracking)
  40
  41         gchar *author;                  ///< Provider of the landmark data, may be null
  42         gchar *store;                   ///< Name of landmark store that the landmark belongs to
  43         gchar *phone_number;            ///< Nhone number of the landmark, may be null
  44         GList *category;                ///< Categories to which the landmark belongs to
  45         GList  *url;                    ///< Url to additional content (Optional)
  46         gchar *desc;                    ///< Description of the landmark, may be null if not available
  47
  48         GHashTable *properties;         ///< Extra info of the landmark
  49
  50 };
  51
  52 struct _LocationLandmarkUrl {
  53         gchar *path;                    ///< Url of landmark url info
  54         gchar *desc;                    ///< Description of landmark url info
  55 };
  56
  57 EXPORT_API guint
  58 location_landmark_get_id (const LocationLandmark *landmark)
  59 {
  60         g_return_val_if_fail(landmark, 0);
  61
  62         return landmark->id;
  63 }
  64
  65
  66 EXPORT_API gchar *
  67 location_landmark_get_name (const LocationLandmark *landmark)
  68 {
  69         g_return_val_if_fail(landmark, NULL);
  70
  71         return landmark->name;
  72 }
  73
  74 EXPORT_API LocationPosition *
  75 location_landmark_get_position (const LocationLandmark *landmark)
  76 {
  77         g_return_val_if_fail(landmark, NULL);
  78
  79         return landmark->position;
  80 }
  81
  82 EXPORT_API LocationAddress *
  83 location_landmark_get_address (const LocationLandmark *landmark)
  84 {
  85         g_return_val_if_fail(landmark, NULL);
  86
  87         return landmark->addr;
  88 }
  89
  90 EXPORT_API gchar *
  91 location_landmark_get_description (const LocationLandmark *landmark)
  92 {
  93         g_return_val_if_fail(landmark, NULL);
  94
  95         return landmark->desc;
  96 }
  97
  98 EXPORT_API guint
  99 location_landmark_get_timestamp (const LocationLandmark *landmark)
 100 {
 101         g_return_val_if_fail(landmark, 0);
 102
 103         return landmark->timestamp;
 104 }
 105
 106 EXPORT_API guint
 107 location_landmark_get_priority (const LocationLandmark *landmark)
 108 {
 109         g_return_val_if_fail(landmark, 0);
 110
 111         return landmark->priority;
 112 }
 113
 114 EXPORT_API LocationBoundary *
 115 location_landmark_get_bounding_box (const LocationLandmark *landmark)
 116 {
 117         g_return_val_if_fail(landmark, NULL);
 118
 119         return landmark->bbox;
 120 }
 121
 122 EXPORT_API gchar *
 123 location_landmark_get_author (const LocationLandmark *landmark)
 124 {
 125         g_return_val_if_fail(landmark, NULL);
 126
 127         return landmark->author;
 128 }
 129
 130 EXPORT_API GList *
 131 location_landmark_get_url (const LocationLandmark *landmark)
 132 {
 133         g_return_val_if_fail(landmark, NULL);
 134
 135         return landmark->url;
 136 }
 137
 138 EXPORT_API GList *
 139 location_landmark_get_category (const LocationLandmark *landmark)
 140 {
 141         g_return_val_if_fail(landmark, NULL);
 142
 143         return landmark->category;
 144 }
 145
 146 EXPORT_API gchar *
 147 location_landmark_get_phone_number (const LocationLandmark *landmark)
 148 {
 149         g_return_val_if_fail(landmark, NULL);
 150
 151         return landmark->phone_number;
 152 }
 153
 154 EXPORT_API GList *
 155 location_landmark_get_property_key (const LocationLandmark *landmark)
 156 {
 157         g_return_val_if_fail(landmark, NULL);
 158
 159         return g_hash_table_get_keys (landmark->properties);
 160 }
 161
 162 EXPORT_API gconstpointer
 163 location_landmark_get_property (const LocationLandmark *landmark, gconstpointer key)
 164 {
 165         g_return_val_if_fail(landmark, NULL);
 166         g_return_val_if_fail(key, NULL);
 167         if (!landmark->properties) return NULL;
 168
 169         return g_hash_table_lookup (landmark->properties, key);
 170 }
 171
 172 EXPORT_API gboolean
 173 location_landmark_set_id (LocationLandmark *landmark, guint id)
 174 {
 175         g_return_val_if_fail(landmark, FALSE);
 176
 177         landmark->id = id;
 178
 179         return TRUE;
 180 }
 181
 182 EXPORT_API gboolean
 183 location_landmark_set_name (LocationLandmark *landmark, const gchar *name)
 184 {
 185         g_return_val_if_fail(landmark, FALSE);
 186
 187         if (landmark->name) {
 188                 g_free(landmark->name);
 189                 landmark->name = NULL;
 190         }
 191         if (name) landmark->name = g_strdup (name);
 192
 193         return TRUE;
 194 }
 195
 196 EXPORT_API gboolean
 197 location_landmark_set_position (LocationLandmark *landmark, const LocationPosition *position)
 198 {
 199         g_return_val_if_fail(landmark, FALSE);
 200
 201         if (landmark->position) {
 202                 location_position_free(landmark->position);
 203                 landmark->position = NULL;
 204         }
 205
 206         if (position) landmark->position = location_position_copy (position);
 207
 208         return TRUE;
 209
 210 }
 211
 212 EXPORT_API gboolean
 213 location_landmark_set_address (LocationLandmark *landmark, const LocationAddress *addr)
 214 {
 215         g_return_val_if_fail(landmark, FALSE);
 216
 217         if (landmark->addr) {
 218                 location_address_free (landmark->addr);
 219                 landmark->addr = NULL;
 220         }
 221
 222         if (addr) landmark->addr = location_address_copy (addr);
 223
 224         return TRUE;
 225
 226 }
 227
 228 EXPORT_API gboolean
 229 location_landmark_set_description (LocationLandmark *landmark, const gchar *desc)
 230 {
 231         g_return_val_if_fail(landmark, FALSE);
 232
 233         if (landmark->desc) {
 234                 g_free(landmark->desc);
 235                 landmark->desc = NULL;
 236         }
 237
 238         if (desc) landmark->desc = g_strdup (desc);
 239
 240         return TRUE;
 241 }
 242
 243 EXPORT_API gboolean
 244 location_landmark_set_timestamp (LocationLandmark *landmark, guint timestamp)
 245 {
 246         g_return_val_if_fail(landmark, FALSE);
 247
 248         landmark->timestamp = timestamp;
 249
 250         return TRUE;
 251
 252 }
 253
 254 EXPORT_API gboolean
 255 location_landmark_set_priority (LocationLandmark *landmark, guint priority)
 256 {
 257         g_return_val_if_fail(landmark, FALSE);
 258
 259         landmark->priority = priority;
 260
 261         return TRUE;
 262 }
 263
 264 EXPORT_API gboolean
 265 location_landmark_set_bounding_box (LocationLandmark *landmark, const LocationBoundary *bbox)
 266 {
 267         g_return_val_if_fail(landmark, FALSE);
 268
 269         if (landmark->bbox) {
 270                 location_boundary_free(landmark->bbox);
 271                 landmark->bbox = NULL;
 272         }
 273
 274         if (bbox) landmark->bbox = location_boundary_copy (bbox);
 275
 276         return TRUE;
 277 }
 278
 279 EXPORT_API gboolean
 280 location_landmark_set_author (LocationLandmark *landmark, const gchar *author)
 281 {
 282         g_return_val_if_fail(landmark, FALSE);
 283
 284         if (landmark->author) {
 285                 g_free(landmark->author);
 286                 landmark->author = NULL;
 287         }
 288         if (author) landmark->author = g_strdup (author);
 289
 290         return TRUE;
 291 }
 292
 293 static void landmark_url_foreach_free (gpointer data)
 294 {
 295         g_return_if_fail(data);
 296
 297         LocationLandmarkUrl *url = (LocationLandmarkUrl *)data;
 298
 299         location_landmark_url_free (url);
 300 }
 301
 302 static void landmark_foreach_url_copy (gpointer data, gpointer user_data)
 303 {
 304         g_return_if_fail(data);
 305         g_return_if_fail(user_data);
 306
 307         LocationLandmarkUrl *url = (LocationLandmarkUrl *)data;
 308         LocationLandmark *landmark = (LocationLandmark *) user_data;
 309
 310         if(!url || !landmark) return;
 311
 312         landmark->url = g_list_append(landmark->url, url);
 313 }
 314
 315 EXPORT_API gboolean
 316 location_landmark_set_url (LocationLandmark *landmark, GList *url)
 317 {
 318         g_return_val_if_fail(landmark, FALSE);
 319
 320         if (landmark->url) {
 321                 g_list_free_full(landmark->url, landmark_url_foreach_free);
 322                 landmark->url = NULL;
 323         }
 324
 325         if (url) g_list_foreach (url, landmark_foreach_url_copy, landmark);
 326
 327         return TRUE;
 328 }
 329
 330 static void landmark_foreach_copy_category (gpointer data, gpointer user_data)
 331 {
 332         g_return_if_fail (data);
 333         g_return_if_fail (user_data);
 334
 335         gchar *category_name = (gchar *)data;
 336         LocationLandmark *landmark = (LocationLandmark *) user_data;
 337
 338         landmark->category = g_list_append (landmark->category, g_strdup(category_name));
 339 }
 340
 341 static void landmark_free_category (gpointer data)
 342 {
 343         g_return_if_fail (data);
 344
 345         gchar * category_name = (gchar *)data;
 346
 347         g_free (category_name);
 348 }
 349
 350 EXPORT_API gboolean
 351 location_landmark_set_category (LocationLandmark *landmark, GList *category)
 352 {
 353         g_return_val_if_fail(landmark, FALSE);
 354
 355         if (landmark->category) {
 356                 g_list_free_full(landmark->category, landmark_free_category);
 357                 landmark->category = NULL;
 358         }
 359
 360         if (category) g_list_foreach ((GList*) category, landmark_foreach_copy_category, landmark);
 361
 362         return TRUE;
 363 }
 364
 365 EXPORT_API gboolean
 366 location_landmark_set_phone_number (LocationLandmark *landmark, const gchar *number)
 367 {
 368         g_return_val_if_fail(landmark, FALSE);
 369         g_return_val_if_fail(number, FALSE);
 370
 371         if (landmark->phone_number) {
 372                 g_free(landmark->phone_number);
 373                 landmark->phone_number = NULL;
 374         }
 375         if (number) landmark->phone_number = g_strdup (number);
 376
 377         return TRUE;
 378 }
 379
 380 EXPORT_API gboolean
 381 location_landmark_set_property(LocationLandmark *landmark, gconstpointer key, gconstpointer value)
 382 {
 383         g_return_val_if_fail(landmark, FALSE);
 384         g_return_val_if_fail(key, FALSE);
 385         if (!landmark->properties) return FALSE;
 386
 387         if (value) {
 388                 gchar *re_key = g_strdup (key);
 389                 gchar *re_val = g_strdup (value);
 390                 g_hash_table_insert(landmark->properties, re_key, re_val);
 391         }
 392         else g_hash_table_remove (landmark->properties, key);
 393
 394         return TRUE;
 395 }
 396
 397 EXPORT_API gchar *
 398 location_landmark_url_get_url_path (const LocationLandmarkUrl *url)
 399 {
 400         g_return_val_if_fail (url, NULL);
 401
 402         return url->path;
 403 }
 404
 405 EXPORT_API gchar *
 406 location_landmark_url_get_description (const LocationLandmarkUrl *url)
 407 {
 408         g_return_val_if_fail (url, NULL);
 409
 410         return url->desc;
 411 }
 412
 413 EXPORT_API gboolean
 414 location_landmark_url_set_url_path (LocationLandmarkUrl *url, const gchar *path)
 415 {
 416         g_return_val_if_fail (url, FALSE);
 417
 418         if (url->path) {
 419                 g_free(url->path);
 420                 url->path = NULL;
 421         }
 422
 423         if (path) url->path = g_strdup (path);
 424
 425         return TRUE;
 426 }
 427
 428 EXPORT_API gboolean
 429 location_landmark_url_set_description (LocationLandmarkUrl *url, const gchar *desc)
 430 {
 431         g_return_val_if_fail (url, FALSE);
 432
 433         if (url->desc) {
 434                 g_free(url->desc);
 435                 url->desc = NULL;
 436         }
 437
 438         if (desc) url->desc = g_strdup (desc);
 439
 440         return TRUE;
 441 }
 442
 443 EXPORT_API LocationLandmarkUrl *
 444 location_landmark_url_new (void)
 445 {
 446         LocationLandmarkUrl *url = g_slice_new0 (LocationLandmarkUrl);
 447         if(!url) return NULL;
 448
 449
 450         return url;
 451 }
 452
 453 EXPORT_API void
 454 location_landmark_url_free (LocationLandmarkUrl * url)
 455 {
 456         g_return_if_fail (url);
 457
 458
 459         location_landmark_url_set_url_path(url, NULL);
 460         location_landmark_url_set_description(url, NULL);
 461
 462         g_slice_free(LocationLandmarkUrl, url);
 463 }
 464
 465 EXPORT_API LocationLandmarkUrl *
 466 location_landmark_url_copy (const LocationLandmarkUrl *url)
 467 {
 468         g_return_val_if_fail(url, NULL);
 469
 470         LocationLandmarkUrl *new_url = location_landmark_url_new();
 471
 472         location_landmark_url_set_url_path(new_url, location_landmark_url_get_url_path(url));
 473         location_landmark_url_set_description(new_url, location_landmark_url_get_description(url));
 474
 475         return new_url;
 476 }
 477
 478 EXPORT_API LocationLandmark *
 479 location_landmark_new (void)
 480 {
 481         LocationLandmark *landmark = g_slice_new0 (LocationLandmark);
 482         if (!landmark) return NULL;
 483
 484         landmark->properties = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 485
 486         return landmark;
 487 }
 488
 489 EXPORT_API LocationLandmark *
 490 location_landmark_copy (const LocationLandmark *landmark)
 491 {
 492         g_return_val_if_fail (landmark, NULL);
 493
 494         LocationLandmark *new_landmark = location_landmark_new();
 495         if (!new_landmark) return NULL;
 496
 497         location_landmark_set_id(new_landmark, location_landmark_get_id(landmark));
 498         location_landmark_set_name (new_landmark, location_landmark_get_name (landmark));
 499         location_landmark_set_position (new_landmark, location_landmark_get_position(landmark));
 500         location_landmark_set_address (new_landmark, location_landmark_get_address (landmark));
 501         location_landmark_set_description (new_landmark, location_landmark_get_description(landmark));
 502         location_landmark_set_timestamp (new_landmark, location_landmark_get_timestamp(landmark));
 503         location_landmark_set_priority (new_landmark, location_landmark_get_priority(landmark));
 504         location_landmark_set_bounding_box (new_landmark, location_landmark_get_bounding_box(landmark));
 505         location_landmark_set_author (new_landmark, location_landmark_get_author(landmark));
 506         location_landmark_set_url(new_landmark, location_landmark_get_url(landmark));
 507
 508         return new_landmark;
 509 }
 510
 511 EXPORT_API void
 512 location_landmark_free (LocationLandmark *landmark)
 513 {
 514         g_return_if_fail (landmark);
 515
 516         location_landmark_set_id(landmark, 0);
 517         location_landmark_set_name (landmark, NULL);
 518         location_landmark_set_position (landmark, NULL);
 519         location_landmark_set_address (landmark, NULL);
 520         location_landmark_set_description (landmark, NULL);
 521         location_landmark_set_timestamp (landmark, 0);
 522         location_landmark_set_priority (landmark, 0);
 523         location_landmark_set_bounding_box (landmark, NULL);
 524         location_landmark_set_author (landmark, NULL);
 525         location_landmark_set_url(landmark, NULL);
 526
 527         g_slice_free (LocationLandmark, landmark);
 528 }