2 * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
18 #include <location_preference.h>
20 #include "GeoAddress.h"
21 #include "DefaultGeocoderProvider.h"
24 #define LOG_TAG "TIZEN_W_GEOCODER"
42 GeocodeResultArrayCallback callback;
43 GeocodeOptions option;
44 std::vector<double> list;
45 }geocoder_geocode_cb_data;
50 ReverseGeocodeResultArrayCallback callback;
51 ReverseGeocodeOptions option;
52 std::vector<std::string> strAddrList;
53 std::vector<GeoAddress> geoAddrList;
54 }geocoder_reverse_geocode_cb_data;
56 bool DefaultGeocoderProvider::preference_init_cb(const char *key, void *user_data)
59 DefaultGeocoderProvider *obj = (DefaultGeocoderProvider *)user_data;
61 char* value_str = NULL;
62 ret = location_preference_get(obj->nativeHandle, key, &value_str);
63 if( ret == LOCATION_PREFERENCE_ERROR_NONE && value_str != NULL )
65 string value(value_str);
66 obj->metadata.push_back(make_pair(pref,value));
68 obj->supportedOptions.push_back(pref);
72 int DefaultGeocoderProvider::setOption_cb(void* user_data)
74 callback_data *data = (callback_data*)user_data;
78 data->callback( data->ret , data->user_data);
85 DefaultGeocoderProvider::DefaultGeocoderProvider():GeocoderProvider("default"), nativeHandle(NULL)
87 int ret = geocoder_create(&nativeHandle);
88 if( ret != GEOCODER_ERROR_NONE )
90 LOGE("Error create Geocoder");
94 char *provider_name = NULL;
95 ret = location_preference_get_provider (GET_LOCATION_SERVICE(nativeHandle) , &provider_name);
96 if( ret == LOCATION_PREFERENCE_ERROR_NONE && provider_name != NULL)
98 string providerName(provider_name);
99 setName(providerName);
104 supportedOptions.clear();
105 location_preference_foreach_available_property_keys(GET_LOCATION_SERVICE(nativeHandle) , preference_init_cb,this);
108 DefaultGeocoderProvider::~DefaultGeocoderProvider()
110 LOGD("%s - Destroy the DefaultGeocoderProvider",__func__);
112 geocoder_destroy(nativeHandle);
116 vector<string> DefaultGeocoderProvider::getSupportedOptions()
118 return supportedOptions;
122 vector<pair<string, string>> DefaultGeocoderProvider::getMetadata()
127 int DefaultGeocoderProvider::setOption( std::vector<std::pair<std::string, std::string>> options, setOptionCb callback, void *user_data, LBSPending **pending)
129 std::vector<std::pair<std::string, std::string>>::iterator pos;
130 for( pos = options.begin() ; pos != options.end() ; ++pos)
132 vector<string>::iterator check;
133 bool isvalid = false;
134 for ( check = supportedOptions.begin() ; check != supportedOptions.end() ; ++check )
136 if( *check == pos->first )
139 if( isvalid == false )
143 for( pos = options.begin() ; pos != options.end() ; ++pos)
145 std::vector<std::pair<std::string, std::string>>::iterator target;
147 for( target = metadata.begin() ; target != metadata.end() ; ++target)
149 if ( target->first == pos->first )
152 target->second = pos->second;
157 metadata.push_back(*pos);
161 vector<pair<string, string>>::iterator key;
162 vector<pair<string, string>> newMetadata;
163 for( key = metadata.begin(); key != metadata.end() ; ++key)
165 if( 0 == location_preference_set(nativeHandle, key->first.c_str() , key->second.c_str()))
166 newMetadata.push_back(*key);
168 metadata = newMetadata;
170 callback_data *data = new callback_data();
171 data->user_data = user_data;
172 data->callback = callback;
174 g_idle_add_full(G_PRIORITY_HIGH_IDLE, setOption_cb, data, NULL);
179 string DefaultGeocoderProvider::getConnectivity()
181 return string("ONLINE");
184 bool DefaultGeocoderProvider::isUsedExternalNetwork()
189 bool DefaultGeocoderProvider::get_position_cb(geocoder_error_e result, double latitude, double longitude, void *user_data)
191 LOGE("%s - start", __func__);
192 geocoder_geocode_cb_data *calldata = (geocoder_geocode_cb_data*)user_data;
193 if( calldata == NULL )
196 if( result != GEOCODER_ERROR_NONE )
201 case GEOCODER_ERROR_NETWORK_FAILED:
202 ret = GEOCODER_ERROR::NETWORK_FAILED;
204 case GEOCODER_ERROR_TIMED_OUT:
205 ret = GEOCODER_ERROR::TIMEOUT;
207 case GEOCODER_ERROR_NOT_FOUND:
208 ret =GEOCODER_ERROR::NONE;
210 case GEOCODER_ERROR_SERVICE_NOT_AVAILABLE:
212 ret = GEOCODER_ERROR::SERVICE_NOT_AVAILABLE;
215 calldata->callback( ret, calldata->list, calldata->user_data );
221 //calldata->option.maxResult
222 LOGE("%s - latitude : %lf, longitude : %lf",__func__, latitude, longitude);
224 calldata->list.push_back(latitude);
225 calldata->list.push_back(longitude);
227 //TODO: Only for last result
230 calldata->callback(0 , calldata->list, calldata->user_data);
234 LOGE("%s - end", __func__);
235 //TODO: Need to consider multiple result
239 void DefaultGeocoderProvider::get_address_cb(geocoder_error_e result, const char *building_number, const char *postal_code, const char *street, const char *city, const char *district, const char *state, const char *country_code, void *user_data)
241 LOGE("%s - start", __func__);
242 geocoder_reverse_geocode_cb_data *calldata = (geocoder_reverse_geocode_cb_data*)user_data;
243 if( calldata == NULL )
246 if( result != GEOCODER_ERROR_NONE )
251 case GEOCODER_ERROR_NETWORK_FAILED:
252 ret = GEOCODER_ERROR::NETWORK_FAILED;
254 case GEOCODER_ERROR_TIMED_OUT:
255 ret = GEOCODER_ERROR::TIMEOUT;
257 case GEOCODER_ERROR_SERVICE_NOT_AVAILABLE:
259 ret = GEOCODER_ERROR::SERVICE_NOT_AVAILABLE;
262 calldata->callback( ret, calldata->strAddrList, calldata->geoAddrList, calldata->user_data);
267 if (calldata->option.addressType == ReverseGeocodeOptions::AddressType::FORMATTED)
269 LOGE("AddressType::FORMATTED");
270 std::string simpleAddr;
273 simpleAddr+=building_number;
278 simpleAddr+=postal_code;
293 simpleAddr+=district;
302 simpleAddr+=country_code;
304 LOGE("%s - AddressType::FORMATTED - Address: %s", __func__,simpleAddr.c_str());
305 calldata->strAddrList.push_back(simpleAddr);
307 else // for ReverseGeocodeOptions::AddressType::STRUCTURED
309 LOGE("AddressType::STRUCTURED");
310 GeoAddress structedAddress;
312 structedAddress.country = string(country_code);
314 structedAddress.region = string(state);
316 structedAddress.county = string(district);
318 structedAddress.city = string(city);
320 structedAddress.street = string(street);
322 structedAddress.premises = string(building_number);
324 structedAddress.postalCode = string(postal_code);
326 LOGE("%s - AddressType::STRUCTURED - contry_code:%s, state:%s, district:%s, city:%s, street:%s , premises:%s , postalCode:%s ", __func__,country_code, state, district, city, street, building_number, postal_code);
327 calldata->geoAddrList.push_back(structedAddress);
329 calldata->callback(0 , calldata->strAddrList, calldata->geoAddrList, calldata->user_data);
330 LOGE("%s - end", __func__);
334 int DefaultGeocoderProvider::geocode(GeoAddress address, GeocodeOptions& option, GeocodeResultArrayCallback callback, void *user_data)
336 LOGE("%s - geocode with GeoAddress", __func__);
338 geocoder_geocode_cb_data * calldata = NULL;
339 int retval = GEOCODER_ERROR::NONE;
340 int ret = GEOCODER_ERROR_NONE;
342 //TODO: Geocoder Preference
343 //if( option.maxResult != 0 )
344 // geocoder_preference_set_max_result(preference, option.maxResult);
345 //if( option.sortAttributeName != "" )
347 // geocoder_preference_set_sort(preference , option.sortAttributeName.c_str(), option.sortOrder == RequestOptions::SortOrder::ASC ? GEOCODER_SORTORDER_ASC : GEOCODER_SORTORDER_DESC);
350 calldata = new geocoder_geocode_cb_data();
353 retval = GEOCODER_ERROR::OUT_OF_MEMORY;
357 calldata->user_data = user_data;
358 calldata->callback = callback;
359 calldata->option = option;
361 ret = geocoder_foreach_positions_from_address(nativeHandle, address.toSimpleAddress().c_str(), get_position_cb, calldata);
365 case GEOCODER_ERROR_NONE:
368 case GEOCODER_ERROR_OUT_OF_MEMORY:
369 retval = GEOCODER_ERROR::OUT_OF_MEMORY;
371 case GEOCODER_ERROR_INVALID_PARAMETER:
372 retval = GEOCODER_ERROR::INVALID_PARAMETER;
374 case GEOCODER_ERROR_NETWORK_FAILED :
375 retval = GEOCODER_ERROR::NETWORK_FAILED;
377 case GEOCODER_ERROR_TIMED_OUT:
378 retval = GEOCODER_ERROR::TIMEOUT;
380 case GEOCODER_ERROR_SERVICE_NOT_AVAILABLE :
382 retval = GEOCODER_ERROR::SERVICE_NOT_AVAILABLE;
392 int DefaultGeocoderProvider::geocode(std::string& address, GeocodeOptions & option, GeocodeResultArrayCallback callback, void *user_data)
394 LOGE("%s - geocode with Freeformed address", __func__);
396 geocoder_geocode_cb_data * calldata = NULL;
397 int retval = GEOCODER_ERROR::NONE;
398 int ret = GEOCODER_ERROR_NONE;
400 //TODO: Geocoder Preference
401 //if( option.maxResult != 0 )
402 // geocoder_preference_set_max_result(preference, option.maxResult);
403 //if( option.sortAttributeName != "" )
405 // geocoder_preference_set_sort(preference , option.sortAttributeName.c_str(), option.sortOrder == RequestOptions::SortOrder::ASC ? GEOCODER_SORTORDER_ASC : GEOCODER_SORTORDER_DESC);
408 calldata = new geocoder_geocode_cb_data();
411 retval = GEOCODER_ERROR::OUT_OF_MEMORY;
415 calldata->user_data = user_data;
416 calldata->callback = callback;
417 calldata->option = option;
419 ret = geocoder_foreach_positions_from_address(nativeHandle, address.c_str(), get_position_cb, calldata);
423 case GEOCODER_ERROR_NONE:
426 case GEOCODER_ERROR_OUT_OF_MEMORY:
427 retval = GEOCODER_ERROR::OUT_OF_MEMORY;
429 case GEOCODER_ERROR_INVALID_PARAMETER:
430 retval = GEOCODER_ERROR::INVALID_PARAMETER;
432 case GEOCODER_ERROR_NETWORK_FAILED :
433 retval = GEOCODER_ERROR::NETWORK_FAILED;
435 case GEOCODER_ERROR_TIMED_OUT:
436 retval = GEOCODER_ERROR::TIMEOUT;
438 case GEOCODER_ERROR_SERVICE_NOT_AVAILABLE :
440 retval = GEOCODER_ERROR::SERVICE_NOT_AVAILABLE;
451 int DefaultGeocoderProvider::reverseGeocode(double latitude, double longitude, ReverseGeocodeOptions& option, ReverseGeocodeResultArrayCallback callback, void *user_data)
453 LOGE("%s - reverseGeocode", __func__);
455 geocoder_reverse_geocode_cb_data * calldata = NULL;
457 int ret = GEOCODER_ERROR_NONE;
459 //TODO: Geocoder Preference
460 //if( option.maxResult != 0 )
461 // geocoder_preference_set_max_result(preference, option.maxResult);
462 //if( option.sortAttributeName != "" )
464 // geocoder_preference_set_sort(preference , option.sortAttributeName.c_str(), option.sortOrder == RequestOptions::SortOrder::ASC ? GEOCODER_SORTORDER_ASC : GEOCODER_SORTORDER_DESC);
467 calldata = new geocoder_reverse_geocode_cb_data();
468 if( calldata == NULL)
470 retval = GEOCODER_ERROR::OUT_OF_MEMORY;
474 calldata->user_data = user_data;
475 calldata->callback = callback;
476 calldata->option = option;
478 ret = geocoder_get_address_from_position(nativeHandle, latitude, longitude, get_address_cb, calldata);
482 case GEOCODER_ERROR_NONE:
485 case GEOCODER_ERROR_OUT_OF_MEMORY:
486 retval = GEOCODER_ERROR::OUT_OF_MEMORY;
488 case GEOCODER_ERROR_INVALID_PARAMETER:
489 retval = GEOCODER_ERROR::INVALID_PARAMETER;
491 case GEOCODER_ERROR_NETWORK_FAILED :
492 retval = GEOCODER_ERROR::NETWORK_FAILED;
494 case GEOCODER_ERROR_TIMED_OUT:
495 retval = GEOCODER_ERROR::TIMEOUT;
497 case GEOCODER_ERROR_SERVICE_NOT_AVAILABLE :
499 retval = GEOCODER_ERROR::SERVICE_NOT_AVAILABLE;