src/api/maps_address.cpp

   1 /* Copyright (c) 2010-2014 Samsung Electronics Co., Ltd. All rights reserved.
   2  *
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <glib.h>
  18 #include "maps_error.h"
  19 #include "maps_plugin_types.h"
  20 #include "maps_address.h"
  21 #include "maps_util.h"
  22 #include "maps_condition.h"
  23
  24 /*
  25  * This represents address information such as building number,
  26  * street name, etc.
  27  */
  28 typedef struct _maps_address_s
  29 {
  30         char *building_number;          /**< Building number. */
  31         char *street;                   /**< Full street name. */
  32         char *district;                 /**< Municipal district name. */
  33         char *city;                     /**< City name. */
  34         char *state;                    /**< State or province region
  35                                           of a nation. */
  36         char *country_code;             /**< Country name. */
  37         char *postal_code;              /**< Postal delivery code. */
  38         char *freetext;                 /**<freeform address input */
  39         char *country;                  /**<country name */
  40         char *county;                   /**<county name */
  41 } maps_address_s;
  42
  43 const gsize _MAPS_ADDRESS_BUILDING_NUMBER_MAX_LENGTH = 32;
  44 const gsize _MAPS_ADDRESS_STREET_MAX_LENGTH = 256;
  45 const gsize _MAPS_ADDRESS_DISTRICT_MAX_LENGTH = 128;
  46 const gsize _MAPS_ADDRESS_CITY_MAX_LENGTH = 256;
  47 const gsize _MAPS_ADDRESS_STATE_MAX_LENGTH = 256;
  48 const gsize _MAPS_ADDRESS_COUNTRY_CODE_MAX_LENGTH = 32;
  49 const gsize _MAPS_ADDRESS_POSTAL_CODE_MAX_LENGTH = 32;
  50 const gsize _MAPS_ADDRESS_FREE_TEXT_MAX_LENGTH = 1024;
  51 const gsize _MAPS_ADDRESS_COUNTRY_MAX_LENGTH = 128;
  52 const gsize _MAPS_ADDRESS_COUNTY_MAX_LENGTH = 128;
  53
  54 /*----------------------------------------------------------------------------*/
  55
  56 EXPORT_API int maps_address_create(maps_address_h *address)
  57 {
  58         if (!maps_condition_check_maps_feature())
  59                 return MAPS_ERROR_NOT_SUPPORTED;
  60         if (!address)
  61                 return MAPS_ERROR_INVALID_PARAMETER;
  62
  63         maps_address_s *a = g_new0(maps_address_s, 1);
  64         if (!a) {
  65                 MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
  66                 return MAPS_ERROR_OUT_OF_MEMORY;
  67         }
  68
  69         *address = (maps_address_h) a;
  70         return MAPS_ERROR_NONE;
  71 }
  72
  73 EXPORT_API int maps_address_destroy(maps_address_h address)
  74 {
  75         if (!maps_condition_check_maps_feature())
  76                 return MAPS_ERROR_NOT_SUPPORTED;
  77         if (!address)
  78                 return MAPS_ERROR_INVALID_PARAMETER;
  79
  80         maps_address_s *a = (maps_address_s *) address;
  81
  82         if (a->building_number)
  83                 g_free(a->building_number);
  84         if (a->street)
  85                 g_free(a->street);
  86         if (a->district)
  87                 g_free(a->district);
  88         if (a->city)
  89                 g_free(a->city);
  90         if (a->state)
  91                 g_free(a->state);
  92         if (a->country_code)
  93                 g_free(a->country_code);
  94         if (a->postal_code)
  95                 g_free(a->postal_code);
  96         if (a->freetext)
  97                 g_free(a->freetext);
  98         if (a->country)
  99                 g_free(a->country);
 100         if (a->county)
 101                 g_free(a->county);
 102
 103         g_free(a);
 104         address = NULL;
 105
 106         return MAPS_ERROR_NONE;
 107 }
 108
 109 EXPORT_API int maps_address_clone(const maps_address_h origin,
 110                                   maps_address_h *cloned)
 111 {
 112         if (!maps_condition_check_maps_feature())
 113                 return MAPS_ERROR_NOT_SUPPORTED;
 114         if (!cloned || !origin)
 115                 return MAPS_ERROR_INVALID_PARAMETER;
 116
 117         int error = MAPS_ERROR_NONE;
 118         do {
 119                 error = maps_address_create(cloned);
 120                 if (!(*cloned) || (error != MAPS_ERROR_NONE))
 121                         break;
 122
 123                 maps_address_s *a = (maps_address_s *) origin;
 124
 125                 if (a->building_number) {
 126                         error = maps_address_set_building_number(*cloned,
 127                                 a->building_number);
 128                         if (error != MAPS_ERROR_NONE)
 129                                 break;
 130                 }
 131
 132                 if (a->street) {
 133                         error = maps_address_set_street(*cloned, a->street);
 134                         if (error != MAPS_ERROR_NONE)
 135                                 break;
 136                 }
 137
 138                 if (a->district) {
 139                         error = maps_address_set_district(*cloned, a->district);
 140                         if (error != MAPS_ERROR_NONE)
 141                                 break;
 142                 }
 143
 144                 if (a->city) {
 145                         error = maps_address_set_city(*cloned, a->city);
 146                         if (error != MAPS_ERROR_NONE)
 147                                 break;
 148                 }
 149
 150                 if (a->state) {
 151                         error = maps_address_set_state(*cloned, a->state);
 152                         if (error != MAPS_ERROR_NONE)
 153                                 break;
 154                 }
 155
 156                 if (a->country_code) {
 157                         error = maps_address_set_country_code(*cloned,
 158                                 a->country_code);
 159                         if (error != MAPS_ERROR_NONE)
 160                                 break;
 161                 }
 162
 163                 if (a->postal_code) {
 164                         error = maps_address_set_postal_code(*cloned,
 165                                 a->postal_code);
 166                         if (error != MAPS_ERROR_NONE)
 167                                 break;
 168                 }
 169
 170                 if (a->freetext) {
 171                         error = maps_address_set_freetext(*cloned, a->freetext);
 172                         if (error != MAPS_ERROR_NONE)
 173                                 break;
 174                 }
 175
 176                 if (a->country) {
 177                         error = maps_address_set_country(*cloned, a->country);
 178                         if (error != MAPS_ERROR_NONE)
 179                                 break;
 180                 }
 181
 182                 if (a->county) {
 183                         error = maps_address_set_county(*cloned, a->county);
 184                         if (error != MAPS_ERROR_NONE)
 185                                 break;
 186                 }
 187
 188                 return MAPS_ERROR_NONE;
 189         } while (false);
 190
 191         maps_address_destroy(*cloned);
 192         *cloned = NULL;
 193         return error;
 194 }
 195
 196 /*----------------------------------------------------------------------------*/
 197
 198 EXPORT_API int maps_address_get_building_number(const maps_address_h address,
 199                                                 char **building_number)
 200 {
 201         if (!maps_condition_check_maps_feature())
 202                 return MAPS_ERROR_NOT_SUPPORTED;
 203         if (!address || !building_number)
 204                 return MAPS_ERROR_INVALID_PARAMETER;
 205         return maps_get_string(((maps_address_s *) address)->building_number,
 206                 _MAPS_ADDRESS_BUILDING_NUMBER_MAX_LENGTH, building_number);
 207 }
 208
 209 EXPORT_API int maps_address_get_street(const maps_address_h address,
 210                                        char **street)
 211 {
 212         if (!maps_condition_check_maps_feature())
 213                 return MAPS_ERROR_NOT_SUPPORTED;
 214         if (!address || !street)
 215                 return MAPS_ERROR_INVALID_PARAMETER;
 216         return maps_get_string(((maps_address_s *) address)->street,
 217                 _MAPS_ADDRESS_STREET_MAX_LENGTH, street);
 218 }
 219
 220 EXPORT_API int maps_address_get_district(const maps_address_h address,
 221                                          char **district)
 222 {
 223         if (!maps_condition_check_maps_feature())
 224                 return MAPS_ERROR_NOT_SUPPORTED;
 225         if (!address || !district)
 226                 return MAPS_ERROR_INVALID_PARAMETER;
 227         return maps_get_string(((maps_address_s *) address)->district,
 228                 _MAPS_ADDRESS_DISTRICT_MAX_LENGTH, district);
 229 }
 230
 231 EXPORT_API int maps_address_get_city(const maps_address_h address, char **city)
 232 {
 233         if (!maps_condition_check_maps_feature())
 234                 return MAPS_ERROR_NOT_SUPPORTED;
 235         if (!address || !city)
 236                 return MAPS_ERROR_INVALID_PARAMETER;
 237         return maps_get_string(((maps_address_s *) address)->city,
 238                 _MAPS_ADDRESS_CITY_MAX_LENGTH, city);
 239 }
 240
 241 EXPORT_API int maps_address_get_state(const maps_address_h address,
 242                                       char **state)
 243 {
 244         if (!maps_condition_check_maps_feature())
 245                 return MAPS_ERROR_NOT_SUPPORTED;
 246         if (!address || !state)
 247                 return MAPS_ERROR_INVALID_PARAMETER;
 248         return maps_get_string(((maps_address_s *) address)->state,
 249                 _MAPS_ADDRESS_STATE_MAX_LENGTH, state);
 250 }
 251
 252 EXPORT_API int maps_address_get_country(const maps_address_h address,
 253                                         char **country)
 254 {
 255         if (!maps_condition_check_maps_feature())
 256                 return MAPS_ERROR_NOT_SUPPORTED;
 257         if (!address || !country)
 258                 return MAPS_ERROR_INVALID_PARAMETER;
 259         return maps_get_string(((maps_address_s *) address)->country,
 260                 _MAPS_ADDRESS_COUNTRY_MAX_LENGTH, country);
 261 }
 262
 263 EXPORT_API int maps_address_get_country_code(const maps_address_h address,
 264                                              char **country_code)
 265 {
 266         if (!maps_condition_check_maps_feature())
 267                 return MAPS_ERROR_NOT_SUPPORTED;
 268         if (!address || !country_code)
 269                 return MAPS_ERROR_INVALID_PARAMETER;
 270         return maps_get_string(((maps_address_s *) address)->country_code,
 271                 _MAPS_ADDRESS_COUNTRY_CODE_MAX_LENGTH, country_code);
 272 }
 273
 274 EXPORT_API int maps_address_get_county(const maps_address_h address,
 275                                        char **county)
 276 {
 277         if (!maps_condition_check_maps_feature())
 278                 return MAPS_ERROR_NOT_SUPPORTED;
 279         if (!address || !county)
 280                 return MAPS_ERROR_INVALID_PARAMETER;
 281         return maps_get_string(((maps_address_s *) address)->county,
 282                 _MAPS_ADDRESS_COUNTY_MAX_LENGTH, county);
 283 }
 284
 285 EXPORT_API int maps_address_get_postal_code(const maps_address_h address,
 286                                             char **postal_code)
 287 {
 288         if (!maps_condition_check_maps_feature())
 289                 return MAPS_ERROR_NOT_SUPPORTED;
 290         if (!address || !postal_code)
 291                 return MAPS_ERROR_INVALID_PARAMETER;
 292         return maps_get_string(((maps_address_s *) address)->postal_code,
 293                 _MAPS_ADDRESS_POSTAL_CODE_MAX_LENGTH, postal_code);
 294 }
 295
 296 EXPORT_API int maps_address_get_freetext(const maps_address_h address,
 297                                          char **freetext)
 298 {
 299         if (!maps_condition_check_maps_feature())
 300                 return MAPS_ERROR_NOT_SUPPORTED;
 301         if (!address || !freetext)
 302                 return MAPS_ERROR_INVALID_PARAMETER;
 303         return maps_get_string(((maps_address_s *) address)->freetext,
 304                 _MAPS_ADDRESS_FREE_TEXT_MAX_LENGTH, freetext);
 305 }
 306
 307 /*----------------------------------------------------------------------------*/
 308
 309 EXPORT_API int maps_address_set_building_number(maps_address_h address,
 310                                                 const char *building_number)
 311 {
 312         if (!maps_condition_check_maps_feature())
 313                 return MAPS_ERROR_NOT_SUPPORTED;
 314         if (!address || !building_number)
 315                 return MAPS_ERROR_INVALID_PARAMETER;
 316         return maps_set_string(building_number,
 317                 _MAPS_ADDRESS_BUILDING_NUMBER_MAX_LENGTH,
 318                 &((maps_address_s *) address)->building_number);
 319 }
 320
 321 EXPORT_API int maps_address_set_street(maps_address_h address,
 322                                        const char *street)
 323 {
 324         if (!maps_condition_check_maps_feature())
 325                 return MAPS_ERROR_NOT_SUPPORTED;
 326         if (!address || !street)
 327                 return MAPS_ERROR_INVALID_PARAMETER;
 328         return maps_set_string(street, _MAPS_ADDRESS_STREET_MAX_LENGTH,
 329                 &((maps_address_s *) address)->street);
 330 }
 331
 332 EXPORT_API int maps_address_set_district(maps_address_h address,
 333                                          const char *district)
 334 {
 335         if (!maps_condition_check_maps_feature())
 336                 return MAPS_ERROR_NOT_SUPPORTED;
 337         if (!address || !district)
 338                 return MAPS_ERROR_INVALID_PARAMETER;
 339         return maps_set_string(district, _MAPS_ADDRESS_DISTRICT_MAX_LENGTH,
 340                 &((maps_address_s *) address)->district);
 341 }
 342
 343 EXPORT_API int maps_address_set_city(maps_address_h address, const char *city)
 344 {
 345         if (!maps_condition_check_maps_feature())
 346                 return MAPS_ERROR_NOT_SUPPORTED;
 347         if (!address || !city)
 348                 return MAPS_ERROR_INVALID_PARAMETER;
 349         return maps_set_string(city, _MAPS_ADDRESS_CITY_MAX_LENGTH,
 350                 &((maps_address_s *) address)->city);
 351 }
 352
 353 EXPORT_API int maps_address_set_state(maps_address_h address, const char *state)
 354 {
 355         if (!maps_condition_check_maps_feature())
 356                 return MAPS_ERROR_NOT_SUPPORTED;
 357         if (!address || !state)
 358                 return MAPS_ERROR_INVALID_PARAMETER;
 359         return maps_set_string(state, _MAPS_ADDRESS_STATE_MAX_LENGTH,
 360                 &((maps_address_s *) address)->state);
 361 }
 362
 363 EXPORT_API int maps_address_set_country(maps_address_h address,
 364                                         const char *country)
 365 {
 366         if (!maps_condition_check_maps_feature())
 367                 return MAPS_ERROR_NOT_SUPPORTED;
 368         if (!address || !country)
 369                 return MAPS_ERROR_INVALID_PARAMETER;
 370         return maps_set_string(country, _MAPS_ADDRESS_COUNTRY_MAX_LENGTH,
 371                 &((maps_address_s *) address)->country);
 372 }
 373
 374 EXPORT_API int maps_address_set_country_code(maps_address_h address,
 375                                              const char *country_code)
 376 {
 377         if (!maps_condition_check_maps_feature())
 378                 return MAPS_ERROR_NOT_SUPPORTED;
 379         if (!address || !country_code)
 380                 return MAPS_ERROR_INVALID_PARAMETER;
 381         return maps_set_string(country_code,
 382                 _MAPS_ADDRESS_COUNTRY_CODE_MAX_LENGTH,
 383                 &((maps_address_s *) address)->country_code);
 384 }
 385
 386 EXPORT_API int maps_address_set_county(maps_address_h address,
 387                                        const char *county)
 388 {
 389         if (!maps_condition_check_maps_feature())
 390                 return MAPS_ERROR_NOT_SUPPORTED;
 391         if (!address || !county)
 392                 return MAPS_ERROR_INVALID_PARAMETER;
 393         return maps_set_string(county, _MAPS_ADDRESS_COUNTY_MAX_LENGTH,
 394                 &((maps_address_s *) address)->county);
 395 }
 396
 397 EXPORT_API int maps_address_set_postal_code(maps_address_h address,
 398                                             const char *postal_code)
 399 {
 400         if (!maps_condition_check_maps_feature())
 401                 return MAPS_ERROR_NOT_SUPPORTED;
 402         if (!address || !postal_code)
 403                 return MAPS_ERROR_INVALID_PARAMETER;
 404         return maps_set_string(postal_code,
 405                 _MAPS_ADDRESS_POSTAL_CODE_MAX_LENGTH,
 406                 &((maps_address_s *) address)->postal_code);
 407 }
 408
 409 EXPORT_API int maps_address_set_freetext(maps_address_h address,
 410                                          const char *freetext)
 411 {
 412         if (!maps_condition_check_maps_feature())
 413                 return MAPS_ERROR_NOT_SUPPORTED;
 414         if (!address || !freetext)
 415                 return MAPS_ERROR_INVALID_PARAMETER;
 416         return maps_set_string(freetext, _MAPS_ADDRESS_FREE_TEXT_MAX_LENGTH,
 417                 &((maps_address_s *) address)->freetext);
 418 }
 419
 420 /*
 421  * Tizen 3.0
 422  */
 423
 424 EXPORT_API int maps_address_list_create(maps_address_list_h *address_list)
 425 {
 426         if (!maps_condition_check_maps_feature())
 427                 return MAPS_ERROR_NOT_SUPPORTED;
 428         if (!address_list)
 429                 return MAPS_ERROR_INVALID_PARAMETER;
 430
 431         GList *list = g_list_alloc();
 432         MAPS_CHECK_CONDITION(list, MAPS_ERROR_OUT_OF_MEMORY, "MAPS_ERROR_OUT_OF_MEMORY");
 433         *address_list = (void *) list;
 434         MAPS_LOGD("address_list: %p", list);
 435
 436         return MAPS_ERROR_NONE;
 437 }
 438
 439 EXPORT_API int maps_address_list_append(maps_address_list_h address_list, maps_address_h address)
 440 {
 441         if (!maps_condition_check_maps_feature())
 442                 return MAPS_ERROR_NOT_SUPPORTED;
 443         if (!address_list || !address)
 444                 return MAPS_ERROR_INVALID_PARAMETER;
 445
 446         GList *list = g_list_append((GList *)address_list, (gpointer) address);
 447         MAPS_CHECK_CONDITION(list, MAPS_ERROR_OUT_OF_MEMORY, "MAPS_ERROR_OUT_OF_MEMORY");
 448         address_list = list;
 449
 450         return MAPS_ERROR_NONE;
 451 }
 452
 453 EXPORT_API int maps_address_list_remove(maps_address_list_h address_list, maps_address_h address)
 454 {
 455         if (!maps_condition_check_maps_feature())
 456                 return MAPS_ERROR_NOT_SUPPORTED;
 457         if (!address_list || !address)
 458                 return MAPS_ERROR_INVALID_PARAMETER;
 459
 460         GList *list = g_list_remove((GList *) address_list, (gpointer) address);
 461         MAPS_CHECK_CONDITION(list, MAPS_ERROR_OUT_OF_MEMORY, "MAPS_ERROR_OUT_OF_MEMORY");
 462         address_list = list;
 463
 464         return MAPS_ERROR_NONE;
 465 }
 466
 467 EXPORT_API int maps_address_list_get_length(maps_address_list_h address_list, int *length)
 468 {
 469         if (!maps_condition_check_maps_feature())
 470                 return MAPS_ERROR_NOT_SUPPORTED;
 471         if (!address_list || !length)
 472                 return MAPS_ERROR_INVALID_PARAMETER;
 473
 474         *length = g_list_length((GList *)address_list) - 1;
 475
 476         return MAPS_ERROR_NONE;
 477 }
 478
 479 EXPORT_API int maps_address_list_foreach(maps_address_list_h address_list, maps_address_cb callback, void *user_data)
 480 {
 481         if (!maps_condition_check_maps_feature())
 482                 return MAPS_ERROR_NOT_SUPPORTED;
 483         if (!address_list || !callback)
 484                 return MAPS_ERROR_INVALID_PARAMETER;
 485
 486         bool ret = true;
 487         int index = 0;
 488
 489         GList *l = (GList *)address_list;
 490         l = g_list_first(l);
 491         while (l != NULL) {
 492                 GList *next = l->next;
 493                 maps_address_s *address = (maps_address_s *)l->data;
 494                 if (address) {
 495                         /*
 496                         int ret = callback(index++, address->country_code, address->country, addres->county, address->state,
 497                                                         address->city, address->district, addrss->street, address->building_number, address->freetext, user_data);
 498                         */
 499                         ret = callback(index++, address, user_data);
 500                 }
 501                 if (ret)
 502                         l = next;
 503                 else
 504                         break;
 505         }
 506
 507         return MAPS_ERROR_NONE;
 508 }
 509
 510 EXPORT_API int maps_address_list_destroy(maps_address_list_h address_list)
 511 {
 512         if (!maps_condition_check_maps_feature())
 513                 return MAPS_ERROR_NOT_SUPPORTED;
 514         if (!address_list)
 515                 return MAPS_ERROR_INVALID_PARAMETER;
 516
 517         GList *list = (GList *) address_list;
 518         MAPS_LOGD("address_list:%p, length = %d", list, g_list_length(list));
 519
 520         g_list_free_full(list, (GDestroyNotify) maps_address_destroy);
 521         address_list = NULL;
 522
 523         return MAPS_ERROR_NONE;
 524 }
 525
 526 bool maps_address_is_valid(const maps_address_h address)
 527 {
 528         if (!maps_condition_check_maps_feature())
 529                 return MAPS_ERROR_NOT_SUPPORTED;
 530         if (!address) return false;
 531
 532         bool ret = false;
 533         maps_address_s *a = (maps_address_s *) address;
 534
 535         do {
 536                 if (a->building_number && strlen(a->building_number) > _MAPS_ADDRESS_BUILDING_NUMBER_MAX_LENGTH)
 537                         break;
 538
 539                 if (a->street && strlen(a->street) > _MAPS_ADDRESS_STREET_MAX_LENGTH)
 540                         break;
 541
 542                 if (a->district && strlen(a->district) > _MAPS_ADDRESS_DISTRICT_MAX_LENGTH)
 543                         break;
 544
 545                 if (a->city && strlen(a->city) > _MAPS_ADDRESS_CITY_MAX_LENGTH)
 546                         break;
 547
 548                 if (a->state && strlen(a->state) > _MAPS_ADDRESS_STATE_MAX_LENGTH)
 549                         break;
 550
 551                 if (a->country_code && strlen(a->country_code) > _MAPS_ADDRESS_COUNTRY_CODE_MAX_LENGTH)
 552                         break;
 553
 554                 if (a->postal_code && strlen(a->postal_code) > _MAPS_ADDRESS_POSTAL_CODE_MAX_LENGTH)
 555                         break;
 556
 557                 if (a->freetext && strlen(a->freetext) > _MAPS_ADDRESS_FREE_TEXT_MAX_LENGTH)
 558                         break;
 559
 560                 if (a->country && strlen(a->country) > _MAPS_ADDRESS_COUNTRY_MAX_LENGTH)
 561                         break;
 562
 563                 if (a->county && strlen(a->county) > _MAPS_ADDRESS_COUNTY_MAX_LENGTH)
 564                         break;
 565
 566                 ret = true;
 567         } while (false);
 568
 569         return ret;
 570 }