src/location_preference.c

   1 /*
   2  * Copyright (c) 2011-2013 Samsung Electronics Co., Ltd All Rights Reserved
   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 <location_preference.h>
  18 #include <location-map-service.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <locations_private.h>
  22
  23 #define LOCATION_PREFERENCE_NULL_ARG_CHECK(arg)  \
  24     LOCATIONS_CHECK_CONDITION((arg != NULL), LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER")
  25
  26 #define LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service) *((LocationMapObject**)service)
  27
  28 /*
  29 * Internal Implementation
  30 */
  31
  32 static int __convert_error_code(int code)
  33 {
  34         int ret = LOCATION_PREFERENCE_ERROR_NONE;
  35         char* msg = "LOCATION_PREFERENCE_ERROR_NONE";
  36         switch(code)
  37         {
  38                 case LOCATION_ERROR_NONE:
  39                         ret = LOCATION_PREFERENCE_ERROR_NONE;
  40                         msg = "LOCATION_PREFERENCE_ERROR_NONE";
  41                         break;
  42                 case LOCATION_ERROR_NETWORK_NOT_CONNECTED:
  43                         ret = LOCATION_PREFERENCE_ERROR_NETWORK_FAILED;
  44                         msg = "LOCATION_PREFERENCE_ERROR_NETWORK_FAILED";
  45                         break;
  46                 case LOCATION_ERROR_PARAMETER:
  47                         ret = LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER;
  48                         msg = "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER";
  49                         break;
  50                 case LOCATION_ERROR_NOT_AVAILABLE:
  51                         msg = "LOCATION_PREFERENCE_ERROR_RESULT_NOT_FOUND";
  52                         ret = LOCATION_PREFERENCE_ERROR_RESULT_NOT_FOUND;
  53         }
  54         LOCATIONS_LOGE("%s(0x%08x)", msg, ret);
  55         return ret;
  56 }
  57
  58
  59 /*
  60  * Public Implementation
  61  */
  62 EXPORT_API int location_preference_foreach_available_property_keys(location_service_h service, location_preference_available_property_key_cb callback, void* user_data)
  63 {
  64         LocationMapObject* object = NULL;
  65         GList* keys = NULL;
  66         char* key = NULL;
  67         int ret = 0;
  68
  69         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
  70         LOCATION_PREFERENCE_NULL_ARG_CHECK(callback);
  71
  72         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
  73         ret = location_map_get_provider_capability_key(object, MAP_SERVICE_PREF_PROPERTY, &keys);
  74         if(ret != LOCATION_ERROR_NONE)
  75         {
  76                 return __convert_error_code(ret);
  77         }
  78         else
  79         {
  80                 while(keys) {
  81                         key = keys->data;
  82                         if(!callback(key, user_data))
  83                                 break;
  84                         keys = keys->next;
  85                 }
  86
  87                 return LOCATION_PREFERENCE_ERROR_NONE;
  88         }
  89 }
  90
  91 EXPORT_API int location_preference_foreach_available_property_values(location_service_h service, const char* key, location_preference_available_property_value_cb callback, void* user_data)
  92 {
  93         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
  94         LOCATION_PREFERENCE_NULL_ARG_CHECK(key);
  95         LOCATION_PREFERENCE_NULL_ARG_CHECK(callback);
  96         return LOCATION_PREFERENCE_ERROR_RESULT_NOT_FOUND;
  97 }
  98
  99 EXPORT_API int location_preference_foreach_available_languages(location_service_h service, location_preference_available_language_cb callback, void* user_data)
 100 {
 101         LocationMapObject* object = NULL;
 102         GList* keys = NULL;
 103         char* key = NULL;
 104         int ret = 0;
 105
 106         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 107         LOCATION_PREFERENCE_NULL_ARG_CHECK(callback);
 108
 109         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 110         ret = location_map_get_provider_capability_key(object, MAP_SERVICE_PREF_LANGUAGE, &keys);
 111         if(ret != LOCATION_ERROR_NONE)
 112         {
 113                 return __convert_error_code(ret);
 114         }
 115         else
 116         {
 117                 while(keys) {
 118                         key = keys->data;
 119                         if(!callback(key, user_data))
 120                                 break;
 121                         keys = keys->next;
 122                 }
 123
 124                 return LOCATION_PREFERENCE_ERROR_NONE;
 125         }
 126 }
 127
 128 EXPORT_API int location_preference_foreach_available_country_codes(location_service_h service, location_preference_available_country_code_cb callback, void* user_data)
 129 {
 130         LocationMapObject* object = NULL;
 131         GList* keys = NULL;
 132         char* key = NULL;
 133         int ret = 0;
 134
 135         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 136         LOCATION_PREFERENCE_NULL_ARG_CHECK(callback);
 137
 138         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 139         ret = location_map_get_provider_capability_key(object, MAP_SERVICE_PREF_COUNTRY, &keys);
 140         if(ret != LOCATION_ERROR_NONE)
 141         {
 142                 return __convert_error_code(ret);
 143         }
 144         else
 145         {
 146                 while(keys) {
 147                         key = keys->data;
 148                         if(!callback(key, user_data))
 149                                 break;
 150                         keys = keys->next;
 151                 }
 152         }
 153
 154         return LOCATION_PREFERENCE_ERROR_NONE;
 155 }
 156
 157 EXPORT_API int location_preference_foreach_properties(location_service_h service, location_preference_property_cb callback, void* user_data)
 158 {
 159         LocationMapPref* pref = NULL;
 160         LocationMapObject* object = NULL;
 161         GList* keys = NULL;
 162         char* key = NULL;
 163         char* value = NULL;
 164
 165         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 166         LOCATION_PREFERENCE_NULL_ARG_CHECK(callback);
 167
 168         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 169         pref = location_map_get_service_pref(object);
 170         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 171
 172         keys = location_map_pref_get_property_key(pref);
 173         while(keys) {
 174                 key = keys->data;
 175                 value = (char*)location_map_pref_get_property(pref, key);
 176                 if(!callback(key, value, user_data))
 177                         break;
 178                 keys = keys->next;
 179         }
 180
 181         location_map_pref_free(pref);
 182         return LOCATION_PREFERENCE_ERROR_NONE;
 183 }
 184
 185 EXPORT_API int location_preference_set(location_service_h service, const char* key, const char* value)
 186 {
 187         LocationMapPref* pref = NULL;
 188         LocationMapObject* object = NULL;
 189
 190         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 191         LOCATION_PREFERENCE_NULL_ARG_CHECK(key);
 192         LOCATION_PREFERENCE_NULL_ARG_CHECK(value);
 193
 194         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 195         pref = location_map_get_service_pref(object);
 196         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 197
 198         location_map_pref_set_property(pref, (gconstpointer)key, (gconstpointer)value);
 199         location_map_set_service_pref(object, pref);
 200         location_map_pref_free(pref);
 201
 202         return LOCATION_PREFERENCE_ERROR_NONE;
 203 }
 204
 205 EXPORT_API int location_preference_get(location_service_h service, const char* key, char** value)
 206 {
 207         LocationMapPref* pref = NULL;
 208         LocationMapObject* object = NULL;
 209         char* ret = NULL;
 210
 211         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 212         LOCATION_PREFERENCE_NULL_ARG_CHECK(key);
 213         LOCATION_PREFERENCE_NULL_ARG_CHECK(value);
 214
 215         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 216         pref = location_map_get_service_pref(object);
 217         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 218
 219         ret = (char*)location_map_pref_get_property(pref, (gconstpointer)key);
 220         if(ret != NULL)
 221         {
 222                 *value = strdup(ret);
 223                 location_map_pref_free(pref);
 224         }
 225         else
 226         {
 227                 *value = NULL;
 228                 location_map_pref_free(pref);
 229                 LOCATIONS_PRINT_ERROR_CODE(LOCATION_PREFERENCE_ERROR_INVALID_KEY, "LOCATION_PREFERENCE_ERROR_INVALID_KEY");
 230         }
 231
 232         return LOCATION_PREFERENCE_ERROR_NONE;
 233 }
 234
 235 EXPORT_API int location_preference_set_provider(location_service_h service, char* provider)
 236 {
 237         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 238         LOCATION_PREFERENCE_NULL_ARG_CHECK(provider);
 239
 240         LocationMapObject *object = NULL;
 241         LocationMapPref *pref = NULL;
 242         gboolean ret = FALSE;
 243
 244         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 245         pref = location_map_get_service_pref(object);
 246         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 247
 248         ret = location_map_pref_set_provider_name(pref, provider);
 249         if (!ret) {
 250                 location_map_pref_free(pref);
 251                 LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_KEY, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 252         }
 253         ret = location_map_set_service_pref(object, pref);
 254         if (!ret) {
 255                 location_map_pref_free(pref);
 256                 LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_KEY, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 257         }
 258
 259         location_map_pref_free(pref);
 260         return LOCATION_PREFERENCE_ERROR_NONE;
 261 }
 262
 263 EXPORT_API int location_preference_get_provider(location_service_h service, char** provider)
 264 {
 265         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 266         LOCATION_PREFERENCE_NULL_ARG_CHECK(provider);
 267
 268         LocationMapObject *object = NULL;
 269         LocationMapPref *pref = NULL;
 270         gchar* current_provider = NULL;
 271
 272         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 273         pref = location_map_get_service_pref(object);
 274         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 275
 276         current_provider = location_map_pref_get_provider_name(pref);
 277         if (!current_provider) {
 278                 location_map_pref_free(pref);
 279                 LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_KEY, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 280         }
 281
 282         *provider = g_strdup (current_provider);
 283         location_map_pref_free(pref);
 284
 285         return LOCATION_PREFERENCE_ERROR_NONE;
 286 }
 287
 288 EXPORT_API int location_preference_get_default_provider(location_service_h service, char** provider)
 289 {
 290         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 291         LOCATION_PREFERENCE_NULL_ARG_CHECK(provider);
 292
 293         LocationMapObject *object = NULL;
 294         gchar *current_provider = NULL;
 295         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 296         current_provider = location_map_get_default_provider(object);
 297         LOCATIONS_CHECK_CONDITION(current_provider != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 298
 299         *provider = g_strdup(current_provider);
 300         g_free(current_provider);
 301
 302         return LOCATION_PREFERENCE_ERROR_NONE;
 303 }
 304
 305 EXPORT_API int location_preference_foreach_supported_provider(location_service_h service, location_preference_supported_provider_cb callback , void *user_data)
 306 {
 307         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 308         LOCATION_PREFERENCE_NULL_ARG_CHECK(callback);
 309
 310         LocationMapObject *object = NULL;
 311         GList *providers = NULL;
 312         gchar *provider = NULL;
 313
 314         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 315         providers = location_map_get_supported_providers(object);
 316         LOCATIONS_CHECK_CONDITION(providers != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 317         while(providers) {
 318                 provider = providers->data;
 319                 if(!callback(provider, user_data))
 320                         break;
 321                 providers = providers->next;
 322         }
 323
 324         return LOCATION_PREFERENCE_ERROR_NONE;
 325 }
 326
 327 EXPORT_API int location_preference_get_provider_name(location_service_h service, char** provider)
 328 {
 329         LocationMapPref* pref = NULL;
 330         LocationMapObject* object = NULL;
 331         char* ret = NULL;
 332
 333         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 334         LOCATION_PREFERENCE_NULL_ARG_CHECK(provider);
 335
 336         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 337         pref = location_map_get_service_pref(object);
 338         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 339
 340         ret = location_map_pref_get_provider_name(pref);
 341         if(ret != NULL)
 342                 *provider = strdup(ret);
 343         else
 344                 *provider = NULL;
 345
 346         location_map_pref_free(pref);
 347         return LOCATION_PREFERENCE_ERROR_NONE;
 348 }
 349
 350 EXPORT_API int location_preference_get_distance_unit(location_service_h service, location_preference_distance_unit_e* unit)
 351 {
 352         LocationMapPref* pref = NULL;
 353         LocationMapObject* object = NULL;
 354         char* ret = NULL;
 355
 356         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 357         LOCATION_PREFERENCE_NULL_ARG_CHECK(unit);
 358
 359         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 360         pref = location_map_get_service_pref(object);
 361         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 362
 363         ret = location_map_pref_get_distance_unit(pref);
 364         if(ret != NULL)
 365         {
 366                 switch(ret[0]) {
 367                         case 'F' :
 368                                 *unit = LOCATION_PREFERENCE_DISTANCE_UNIT_FT;
 369                                 break;
 370                         case 'K' :
 371                                 *unit = LOCATION_PREFERENCE_DISTANCE_UNIT_KM;
 372                                 break;
 373                         case 'Y' :
 374                                 *unit = LOCATION_PREFERENCE_DISTANCE_UNIT_YD;
 375                                 break;
 376                         case 'M' :
 377                                 if(ret[1] == 'I')
 378                                         *unit = LOCATION_PREFERENCE_DISTANCE_UNIT_MI;
 379                                 else
 380                                         *unit = LOCATION_PREFERENCE_DISTANCE_UNIT_M;
 381                                 break;
 382                 }
 383                 location_map_pref_free(pref);
 384                 return LOCATION_PREFERENCE_ERROR_NONE;
 385         }
 386         else
 387         {
 388                 location_map_pref_free(pref);
 389                 LOCATIONS_PRINT_ERROR_CODE(LOCATION_PREFERENCE_ERROR_RESULT_NOT_FOUND, "LOCATION_PREFERENCE_ERROR_RESULT_NOT_FOUND");
 390         }
 391 }
 392
 393 EXPORT_API int location_preference_set_distance_unit(location_service_h service, location_preference_distance_unit_e unit)
 394 {
 395         LocationMapPref* pref = NULL;
 396         LocationMapObject* object = NULL;
 397         char* distance = NULL;
 398
 399         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 400         switch(unit) {
 401                 case LOCATION_PREFERENCE_DISTANCE_UNIT_FT :
 402                         distance = "FT";
 403                         break;
 404                 case LOCATION_PREFERENCE_DISTANCE_UNIT_KM :
 405                         distance = "KM";
 406                         break;
 407                 case LOCATION_PREFERENCE_DISTANCE_UNIT_YD :
 408                         distance = "YD";
 409                         break;
 410                 case LOCATION_PREFERENCE_DISTANCE_UNIT_MI :
 411                         distance = "MI";
 412                         break;
 413                 case LOCATION_PREFERENCE_DISTANCE_UNIT_M :
 414                         distance = "M";
 415                         break;
 416                 default :
 417                         LOCATIONS_PRINT_ERROR_CODE(LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 418         }
 419
 420         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 421         pref = location_map_get_service_pref(object);
 422         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 423
 424         location_map_pref_set_distance_unit(pref, distance);
 425         location_map_set_service_pref(object, pref);
 426         location_map_pref_free(pref);
 427
 428         return LOCATION_PREFERENCE_ERROR_NONE;
 429 }
 430
 431 EXPORT_API int location_preference_get_language(location_service_h service, char** language)
 432 {
 433         LocationMapPref* pref = NULL;
 434         LocationMapObject* object = NULL;
 435         char* ret = NULL;
 436
 437         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 438         LOCATION_PREFERENCE_NULL_ARG_CHECK(language);
 439
 440         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 441         pref = location_map_get_service_pref(object);
 442         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 443
 444         ret = location_map_pref_get_language(pref);
 445         if(ret != NULL)
 446                 *language = strdup(ret);
 447         else
 448                 *language = NULL;
 449
 450         location_map_pref_free(pref);
 451         return LOCATION_PREFERENCE_ERROR_NONE;
 452 }
 453
 454 EXPORT_API int location_preference_set_language(location_service_h service, const char* language)
 455 {
 456         LocationMapPref* pref = NULL;
 457         LocationMapObject* object = NULL;
 458
 459         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 460         LOCATION_PREFERENCE_NULL_ARG_CHECK(language);
 461
 462         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 463         pref = location_map_get_service_pref(object);
 464         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 465
 466         location_map_pref_set_language(pref, language);
 467         location_map_set_service_pref(object, pref);
 468         location_map_pref_free(pref);
 469
 470         return LOCATION_PREFERENCE_ERROR_NONE;
 471 }
 472
 473
 474 EXPORT_API int location_preference_get_country_code(location_service_h service, char** country_code)
 475 {
 476         LocationMapPref* pref = NULL;
 477         LocationMapObject* object = NULL;
 478         char* ret = NULL;
 479
 480         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 481         LOCATION_PREFERENCE_NULL_ARG_CHECK(country_code);
 482
 483         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 484         pref = location_map_get_service_pref(object);
 485         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 486
 487         ret = location_map_pref_get_country(pref);
 488         if(ret != NULL)
 489                 *country_code = strdup(ret);
 490         else
 491                 *country_code = NULL;
 492
 493         location_map_pref_free(pref);
 494         return LOCATION_PREFERENCE_ERROR_NONE;
 495 }
 496
 497 EXPORT_API int location_preference_set_country_code(location_service_h service, const char* country_code)
 498 {
 499         LocationMapPref* pref = NULL;
 500         LocationMapObject* object = NULL;
 501
 502         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 503         LOCATION_PREFERENCE_NULL_ARG_CHECK(country_code);
 504
 505         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 506         pref = location_map_get_service_pref(object);
 507         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 508
 509         location_map_pref_set_country(pref, country_code);
 510         location_map_set_service_pref(object, pref);
 511         location_map_pref_free(pref);
 512
 513         return LOCATION_PREFERENCE_ERROR_NONE;
 514 }
 515
 516 EXPORT_API int location_preference_set_maps_key (location_service_h service, const char* maps_key)
 517 {
 518         LocationMapPref* pref = NULL;
 519         LocationMapObject* object = NULL;
 520
 521         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 522         LOCATION_PREFERENCE_NULL_ARG_CHECK(maps_key);
 523
 524         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 525         pref = location_map_get_service_pref(object);
 526         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 527
 528         location_map_pref_set_maps_key(pref, maps_key);
 529         location_map_set_service_pref(object, pref);
 530         location_map_pref_free(pref);
 531
 532         return LOCATION_PREFERENCE_ERROR_NONE;
 533 }
 534
 535 EXPORT_API int location_preference_get_maps_key (location_service_h service, char** maps_key)
 536 {
 537         LocationMapPref* pref = NULL;
 538         LocationMapObject* object = NULL;
 539         char* ret = NULL;
 540
 541         LOCATION_PREFERENCE_NULL_ARG_CHECK(service);
 542         LOCATION_PREFERENCE_NULL_ARG_CHECK(maps_key);
 543
 544         object = LOCATION_PREFERENCE_GET_LOCATION_OBJECT(service);
 545         pref = location_map_get_service_pref(object);
 546         LOCATIONS_CHECK_CONDITION(pref != NULL, LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER, "LOCATION_PREFERENCE_ERROR_INVALID_PARAMETER");
 547
 548         ret = location_map_pref_get_maps_key(pref);
 549         if(ret != NULL)
 550                 *maps_key = strdup(ret);
 551         else
 552                 *maps_key = NULL;
 553
 554         location_map_pref_free(pref);
 555         return LOCATION_PREFERENCE_ERROR_NONE;
 556
 557 }