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                 //LCOV_EXCL_START
  66                 MAPS_LOGE("OUT_OF_MEMORY(0x%08x)", MAPS_ERROR_OUT_OF_MEMORY);
  67                 return MAPS_ERROR_OUT_OF_MEMORY;
  68                 //LCOV_EXCL_STOP
  69         }
  70
  71         *address = (maps_address_h) a;
  72         return MAPS_ERROR_NONE;
  73 }
  74
  75 EXPORT_API int maps_address_destroy(maps_address_h address)
  76 {
  77         if (!maps_condition_check_maps_feature())
  78                 return MAPS_ERROR_NOT_SUPPORTED;
  79         if (!address)
  80                 return MAPS_ERROR_INVALID_PARAMETER;
  81
  82         maps_address_s *a = (maps_address_s *) address;
  83
  84         if (a->building_number)
  85                 g_free(a->building_number);
  86         if (a->street)
  87                 g_free(a->street);
  88         if (a->district)
  89                 g_free(a->district);
  90         if (a->city)
  91                 g_free(a->city);
  92         if (a->state)
  93                 g_free(a->state);
  94         if (a->country_code)
  95                 g_free(a->country_code);
  96         if (a->postal_code)
  97                 g_free(a->postal_code);
  98         if (a->freetext)
  99                 g_free(a->freetext);
 100         if (a->country)
 101                 g_free(a->country);
 102         if (a->county)
 103                 g_free(a->county);
 104
 105         g_free(a);
 106         address = NULL;
 107
 108         return MAPS_ERROR_NONE;
 109 }
 110
 111 EXPORT_API int maps_address_clone(const maps_address_h origin,
 112                                   maps_address_h *cloned)
 113 {
 114         if (!maps_condition_check_maps_feature())
 115                 return MAPS_ERROR_NOT_SUPPORTED;
 116         if (!cloned || !origin)
 117                 return MAPS_ERROR_INVALID_PARAMETER;
 118
 119         int error = MAPS_ERROR_NONE;
 120         do {
 121                 error = maps_address_create(cloned);
 122                 if (!(*cloned) || (error != MAPS_ERROR_NONE))
 123                         break;
 124
 125                 maps_address_s *a = (maps_address_s *) origin;
 126
 127                 if (a->building_number) {
 128                         error = maps_address_set_building_number(*cloned,
 129                                 a->building_number);
 130                         if (error != MAPS_ERROR_NONE)
 131                                 break;
 132                 }
 133
 134                 if (a->street) {
 135                         error = maps_address_set_street(*cloned, a->street);
 136                         if (error != MAPS_ERROR_NONE)
 137                                 break;
 138                 }
 139
 140                 if (a->district) {
 141                         error = maps_address_set_district(*cloned, a->district);
 142                         if (error != MAPS_ERROR_NONE)
 143                                 break;
 144                 }
 145
 146                 if (a->city) {
 147                         error = maps_address_set_city(*cloned, a->city);
 148                         if (error != MAPS_ERROR_NONE)
 149                                 break;
 150                 }
 151
 152                 if (a->state) {
 153                         error = maps_address_set_state(*cloned, a->state);
 154                         if (error != MAPS_ERROR_NONE)
 155                                 break;
 156                 }
 157
 158                 if (a->country_code) {
 159                         error = maps_address_set_country_code(*cloned,
 160                                 a->country_code);
 161                         if (error != MAPS_ERROR_NONE)
 162                                 break;
 163                 }
 164
 165                 if (a->postal_code) {
 166                         error = maps_address_set_postal_code(*cloned,
 167                                 a->postal_code);
 168                         if (error != MAPS_ERROR_NONE)
 169                                 break;
 170                 }
 171
 172                 if (a->freetext) {
 173                         error = maps_address_set_freetext(*cloned, a->freetext);
 174                         if (error != MAPS_ERROR_NONE)
 175                                 break;
 176                 }
 177
 178                 if (a->country) {
 179                         error = maps_address_set_country(*cloned, a->country);
 180                         if (error != MAPS_ERROR_NONE)
 181                                 break;
 182                 }
 183
 184                 if (a->county) {
 185                         error = maps_address_set_county(*cloned, a->county);
 186                         if (error != MAPS_ERROR_NONE)
 187                                 break;
 188                 }
 189
 190                 return MAPS_ERROR_NONE;
 191         } while (false);
 192
 193         //LCOV_EXCL_START
 194         maps_address_destroy(*cloned);
 195         *cloned = NULL;
 196         return error;
 197         //LCOV_EXCL_STOP
 198 }
 199
 200 /*----------------------------------------------------------------------------*/
 201
 202 EXPORT_API int maps_address_get_building_number(const maps_address_h address,
 203                                                 char **building_number)
 204 {
 205         if (!maps_condition_check_maps_feature())
 206                 return MAPS_ERROR_NOT_SUPPORTED;
 207         if (!address || !building_number)
 208                 return MAPS_ERROR_INVALID_PARAMETER;
 209         return maps_get_string(((maps_address_s *) address)->building_number,
 210                 _MAPS_ADDRESS_BUILDING_NUMBER_MAX_LENGTH, building_number);
 211 }
 212
 213 EXPORT_API int maps_address_get_street(const maps_address_h address,
 214                                        char **street)
 215 {
 216         if (!maps_condition_check_maps_feature())
 217                 return MAPS_ERROR_NOT_SUPPORTED;
 218         if (!address || !street)
 219                 return MAPS_ERROR_INVALID_PARAMETER;
 220         return maps_get_string(((maps_address_s *) address)->street,
 221                 _MAPS_ADDRESS_STREET_MAX_LENGTH, street);
 222 }
 223
 224 EXPORT_API int maps_address_get_district(const maps_address_h address,
 225                                          char **district)
 226 {
 227         if (!maps_condition_check_maps_feature())
 228                 return MAPS_ERROR_NOT_SUPPORTED;
 229         if (!address || !district)
 230                 return MAPS_ERROR_INVALID_PARAMETER;
 231         return maps_get_string(((maps_address_s *) address)->district,
 232                 _MAPS_ADDRESS_DISTRICT_MAX_LENGTH, district);
 233 }
 234
 235 EXPORT_API int maps_address_get_city(const maps_address_h address, char **city)
 236 {
 237         if (!maps_condition_check_maps_feature())
 238                 return MAPS_ERROR_NOT_SUPPORTED;
 239         if (!address || !city)
 240                 return MAPS_ERROR_INVALID_PARAMETER;
 241         return maps_get_string(((maps_address_s *) address)->city,
 242                 _MAPS_ADDRESS_CITY_MAX_LENGTH, city);
 243 }
 244
 245 EXPORT_API int maps_address_get_state(const maps_address_h address,
 246                                       char **state)
 247 {
 248         if (!maps_condition_check_maps_feature())
 249                 return MAPS_ERROR_NOT_SUPPORTED;
 250         if (!address || !state)
 251                 return MAPS_ERROR_INVALID_PARAMETER;
 252         return maps_get_string(((maps_address_s *) address)->state,
 253                 _MAPS_ADDRESS_STATE_MAX_LENGTH, state);
 254 }
 255
 256 EXPORT_API int maps_address_get_country(const maps_address_h address,
 257                                         char **country)
 258 {
 259         if (!maps_condition_check_maps_feature())
 260                 return MAPS_ERROR_NOT_SUPPORTED;
 261         if (!address || !country)
 262                 return MAPS_ERROR_INVALID_PARAMETER;
 263         return maps_get_string(((maps_address_s *) address)->country,
 264                 _MAPS_ADDRESS_COUNTRY_MAX_LENGTH, country);
 265 }
 266
 267 EXPORT_API int maps_address_get_country_code(const maps_address_h address,
 268                                              char **country_code)
 269 {
 270         if (!maps_condition_check_maps_feature())
 271                 return MAPS_ERROR_NOT_SUPPORTED;
 272         if (!address || !country_code)
 273                 return MAPS_ERROR_INVALID_PARAMETER;
 274         return maps_get_string(((maps_address_s *) address)->country_code,
 275                 _MAPS_ADDRESS_COUNTRY_CODE_MAX_LENGTH, country_code);
 276 }
 277
 278 EXPORT_API int maps_address_get_county(const maps_address_h address,
 279                                        char **county)
 280 {
 281         if (!maps_condition_check_maps_feature())
 282                 return MAPS_ERROR_NOT_SUPPORTED;
 283         if (!address || !county)
 284                 return MAPS_ERROR_INVALID_PARAMETER;
 285         return maps_get_string(((maps_address_s *) address)->county,
 286                 _MAPS_ADDRESS_COUNTY_MAX_LENGTH, county);
 287 }
 288
 289 EXPORT_API int maps_address_get_postal_code(const maps_address_h address,
 290                                             char **postal_code)
 291 {
 292         if (!maps_condition_check_maps_feature())
 293                 return MAPS_ERROR_NOT_SUPPORTED;
 294         if (!address || !postal_code)
 295                 return MAPS_ERROR_INVALID_PARAMETER;
 296         return maps_get_string(((maps_address_s *) address)->postal_code,
 297                 _MAPS_ADDRESS_POSTAL_CODE_MAX_LENGTH, postal_code);
 298 }
 299
 300 EXPORT_API int maps_address_get_freetext(const maps_address_h address,
 301                                          char **freetext)
 302 {
 303         if (!maps_condition_check_maps_feature())
 304                 return MAPS_ERROR_NOT_SUPPORTED;
 305         if (!address || !freetext)
 306                 return MAPS_ERROR_INVALID_PARAMETER;
 307         return maps_get_string(((maps_address_s *) address)->freetext,
 308                 _MAPS_ADDRESS_FREE_TEXT_MAX_LENGTH, freetext);
 309 }
 310
 311 /*----------------------------------------------------------------------------*/
 312
 313 EXPORT_API int maps_address_set_building_number(maps_address_h address,
 314                                                 const char *building_number)
 315 {
 316         if (!maps_condition_check_maps_feature())
 317                 return MAPS_ERROR_NOT_SUPPORTED;
 318         if (!address || !building_number)
 319                 return MAPS_ERROR_INVALID_PARAMETER;
 320         return maps_set_string(building_number,
 321                 _MAPS_ADDRESS_BUILDING_NUMBER_MAX_LENGTH,
 322                 &((maps_address_s *) address)->building_number);
 323 }
 324
 325 EXPORT_API int maps_address_set_street(maps_address_h address,
 326                                        const char *street)
 327 {
 328         if (!maps_condition_check_maps_feature())
 329                 return MAPS_ERROR_NOT_SUPPORTED;
 330         if (!address || !street)
 331                 return MAPS_ERROR_INVALID_PARAMETER;
 332         return maps_set_string(street, _MAPS_ADDRESS_STREET_MAX_LENGTH,
 333                 &((maps_address_s *) address)->street);
 334 }
 335
 336 EXPORT_API int maps_address_set_district(maps_address_h address,
 337                                          const char *district)
 338 {
 339         if (!maps_condition_check_maps_feature())
 340                 return MAPS_ERROR_NOT_SUPPORTED;
 341         if (!address || !district)
 342                 return MAPS_ERROR_INVALID_PARAMETER;
 343         return maps_set_string(district, _MAPS_ADDRESS_DISTRICT_MAX_LENGTH,
 344                 &((maps_address_s *) address)->district);
 345 }
 346
 347 EXPORT_API int maps_address_set_city(maps_address_h address, const char *city)
 348 {
 349         if (!maps_condition_check_maps_feature())
 350                 return MAPS_ERROR_NOT_SUPPORTED;
 351         if (!address || !city)
 352                 return MAPS_ERROR_INVALID_PARAMETER;
 353         return maps_set_string(city, _MAPS_ADDRESS_CITY_MAX_LENGTH,
 354                 &((maps_address_s *) address)->city);
 355 }
 356
 357 EXPORT_API int maps_address_set_state(maps_address_h address, const char *state)
 358 {
 359         if (!maps_condition_check_maps_feature())
 360                 return MAPS_ERROR_NOT_SUPPORTED;
 361         if (!address || !state)
 362                 return MAPS_ERROR_INVALID_PARAMETER;
 363         return maps_set_string(state, _MAPS_ADDRESS_STATE_MAX_LENGTH,
 364                 &((maps_address_s *) address)->state);
 365 }
 366
 367 EXPORT_API int maps_address_set_country(maps_address_h address,
 368                                         const char *country)
 369 {
 370         if (!maps_condition_check_maps_feature())
 371                 return MAPS_ERROR_NOT_SUPPORTED;
 372         if (!address || !country)
 373                 return MAPS_ERROR_INVALID_PARAMETER;
 374         return maps_set_string(country, _MAPS_ADDRESS_COUNTRY_MAX_LENGTH,
 375                 &((maps_address_s *) address)->country);
 376 }
 377
 378 EXPORT_API int maps_address_set_country_code(maps_address_h address,
 379                                              const char *country_code)
 380 {
 381         if (!maps_condition_check_maps_feature())
 382                 return MAPS_ERROR_NOT_SUPPORTED;
 383         if (!address || !country_code)
 384                 return MAPS_ERROR_INVALID_PARAMETER;
 385         return maps_set_string(country_code,
 386                 _MAPS_ADDRESS_COUNTRY_CODE_MAX_LENGTH,
 387                 &((maps_address_s *) address)->country_code);
 388 }
 389
 390 EXPORT_API int maps_address_set_county(maps_address_h address,
 391                                        const char *county)
 392 {
 393         if (!maps_condition_check_maps_feature())
 394                 return MAPS_ERROR_NOT_SUPPORTED;
 395         if (!address || !county)
 396                 return MAPS_ERROR_INVALID_PARAMETER;
 397         return maps_set_string(county, _MAPS_ADDRESS_COUNTY_MAX_LENGTH,
 398                 &((maps_address_s *) address)->county);
 399 }
 400
 401 EXPORT_API int maps_address_set_postal_code(maps_address_h address,
 402                                             const char *postal_code)
 403 {
 404         if (!maps_condition_check_maps_feature())
 405                 return MAPS_ERROR_NOT_SUPPORTED;
 406         if (!address || !postal_code)
 407                 return MAPS_ERROR_INVALID_PARAMETER;
 408         return maps_set_string(postal_code,
 409                 _MAPS_ADDRESS_POSTAL_CODE_MAX_LENGTH,
 410                 &((maps_address_s *) address)->postal_code);
 411 }
 412
 413 EXPORT_API int maps_address_set_freetext(maps_address_h address,
 414                                          const char *freetext)
 415 {
 416         if (!maps_condition_check_maps_feature())
 417                 return MAPS_ERROR_NOT_SUPPORTED;
 418         if (!address || !freetext)
 419                 return MAPS_ERROR_INVALID_PARAMETER;
 420         return maps_set_string(freetext, _MAPS_ADDRESS_FREE_TEXT_MAX_LENGTH,
 421                 &((maps_address_s *) address)->freetext);
 422 }
 423
 424 /*
 425  * Tizen 3.0
 426  */
 427
 428 EXPORT_API int maps_address_list_create(maps_address_list_h *address_list)
 429 {
 430         if (!maps_condition_check_maps_feature())
 431                 return MAPS_ERROR_NOT_SUPPORTED;
 432         if (!address_list)
 433                 return MAPS_ERROR_INVALID_PARAMETER;
 434
 435         GList *list = g_list_alloc();
 436         MAPS_CHECK_CONDITION(list, MAPS_ERROR_OUT_OF_MEMORY, "MAPS_ERROR_OUT_OF_MEMORY");
 437         *address_list = (void *) list;
 438         MAPS_LOGD("address_list: %p", list);
 439
 440         return MAPS_ERROR_NONE;
 441 }
 442
 443 EXPORT_API int maps_address_list_append(maps_address_list_h address_list, maps_address_h address)
 444 {
 445         if (!maps_condition_check_maps_feature())
 446                 return MAPS_ERROR_NOT_SUPPORTED;
 447         if (!address_list || !address)
 448                 return MAPS_ERROR_INVALID_PARAMETER;
 449
 450         GList *list = g_list_append((GList *)address_list, (gpointer) address);
 451         MAPS_CHECK_CONDITION(list, MAPS_ERROR_OUT_OF_MEMORY, "MAPS_ERROR_OUT_OF_MEMORY");
 452         address_list = list;
 453
 454         return MAPS_ERROR_NONE;
 455 }
 456
 457 EXPORT_API int maps_address_list_remove(maps_address_list_h address_list, maps_address_h address)
 458 {
 459         if (!maps_condition_check_maps_feature())
 460                 return MAPS_ERROR_NOT_SUPPORTED;
 461         if (!address_list || !address)
 462                 return MAPS_ERROR_INVALID_PARAMETER;
 463
 464         GList *list = g_list_remove((GList *) address_list, (gpointer) address);
 465         MAPS_CHECK_CONDITION(list, MAPS_ERROR_OUT_OF_MEMORY, "MAPS_ERROR_OUT_OF_MEMORY");
 466         address_list = list;
 467
 468         return MAPS_ERROR_NONE;
 469 }
 470
 471 EXPORT_API int maps_address_list_get_length(maps_address_list_h address_list, int *length)
 472 {
 473         if (!maps_condition_check_maps_feature())
 474                 return MAPS_ERROR_NOT_SUPPORTED;
 475         if (!address_list || !length)
 476                 return MAPS_ERROR_INVALID_PARAMETER;
 477
 478         *length = g_list_length((GList *)address_list) - 1;
 479
 480         return MAPS_ERROR_NONE;
 481 }
 482
 483 EXPORT_API int maps_address_list_foreach(maps_address_list_h address_list, maps_address_cb callback, void *user_data)
 484 {
 485         if (!maps_condition_check_maps_feature())
 486                 return MAPS_ERROR_NOT_SUPPORTED;
 487         if (!address_list || !callback)
 488                 return MAPS_ERROR_INVALID_PARAMETER;
 489
 490         bool ret = true;
 491         int index = 0;
 492
 493         GList *l = (GList *)address_list;
 494         l = g_list_first(l);
 495         while (l != NULL) {
 496                 GList *next = l->next;
 497                 maps_address_s *address = (maps_address_s *)l->data;
 498                 if (address) {
 499                         /*
 500                         int ret = callback(index++, address->country_code, address->country, addres->county, address->state,
 501                                                         address->city, address->district, addrss->street, address->building_number, address->freetext, user_data);
 502                         */
 503                         ret = callback(index++, address, user_data);
 504                 }
 505                 if (ret)
 506                         l = next;
 507                 else
 508                         break;
 509         }
 510
 511         return MAPS_ERROR_NONE;
 512 }
 513
 514 EXPORT_API int maps_address_list_destroy(maps_address_list_h address_list)
 515 {
 516         if (!maps_condition_check_maps_feature())
 517                 return MAPS_ERROR_NOT_SUPPORTED;
 518         if (!address_list)
 519                 return MAPS_ERROR_INVALID_PARAMETER;
 520
 521         GList *list = (GList *) address_list;
 522         MAPS_LOGD("address_list:%p, length = %d", list, g_list_length(list));
 523
 524         g_list_free_full(list, (GDestroyNotify) maps_address_destroy);
 525         address_list = NULL;
 526
 527         return MAPS_ERROR_NONE;
 528 }
 529
 530 bool maps_address_is_valid(const maps_address_h address)
 531 {
 532         if (!maps_condition_check_maps_feature())
 533                 return MAPS_ERROR_NOT_SUPPORTED;
 534         if (!address) return false;
 535
 536         bool ret = false;
 537         maps_address_s *a = (maps_address_s *) address;
 538
 539         do {
 540                 if (a->building_number && strlen(a->building_number) > _MAPS_ADDRESS_BUILDING_NUMBER_MAX_LENGTH)
 541                         break;
 542
 543                 if (a->street && strlen(a->street) > _MAPS_ADDRESS_STREET_MAX_LENGTH)
 544                         break;
 545
 546                 if (a->district && strlen(a->district) > _MAPS_ADDRESS_DISTRICT_MAX_LENGTH)
 547                         break;
 548
 549                 if (a->city && strlen(a->city) > _MAPS_ADDRESS_CITY_MAX_LENGTH)
 550                         break;
 551
 552                 if (a->state && strlen(a->state) > _MAPS_ADDRESS_STATE_MAX_LENGTH)
 553                         break;
 554
 555                 if (a->country_code && strlen(a->country_code) > _MAPS_ADDRESS_COUNTRY_CODE_MAX_LENGTH)
 556                         break;
 557
 558                 if (a->postal_code && strlen(a->postal_code) > _MAPS_ADDRESS_POSTAL_CODE_MAX_LENGTH)
 559                         break;
 560
 561                 if (a->freetext && strlen(a->freetext) > _MAPS_ADDRESS_FREE_TEXT_MAX_LENGTH)
 562                         break;
 563
 564                 if (a->country && strlen(a->country) > _MAPS_ADDRESS_COUNTRY_MAX_LENGTH)
 565                         break;
 566
 567                 if (a->county && strlen(a->county) > _MAPS_ADDRESS_COUNTY_MAX_LENGTH)
 568                         break;
 569
 570                 ret = true;
 571         } while (false);
 572
 573         return ret;
 574 }