X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Flocations.c;h=1f2951a2ba927f2719884c4b72a57070899af240;hb=refs%2Ftags%2Fsubmit%2Ftizen_3.0.2015.q2_common%2F20150615.075539;hp=c87116526dbfd19c2759b835f71a979b7208799f;hpb=43decd22f1ae4fe02710e029e3f73b97b4b1778f;p=platform%2Fcore%2Fapi%2Flocation-manager.git diff --git a/src/locations.c b/src/locations.c index c871165..1f2951a 100755 --- a/src/locations.c +++ b/src/locations.c @@ -17,192 +17,218 @@ #include #include #include -#include -#include +#include +#include "locations.h" +#include "location_internal.h" +static location_setting_changed_s g_location_setting[LOCATIONS_METHOD_WPS + 1]; -#define LOCATIONS_NULL_ARG_CHECK(arg) \ - LOCATIONS_CHECK_CONDITION((arg != NULL),LOCATIONS_ERROR_INVALID_PARAMETER,"LOCATIONS_ERROR_INVALID_PARAMETER") \ - -/* -* Internal Implementation -*/ +static location_method_e __convert_location_method_e(LocationMethod method) +{ + location_method_e _method = LOCATIONS_METHOD_NONE; + switch (method) { + case LOCATION_METHOD_HYBRID: + _method = LOCATIONS_METHOD_HYBRID; + break; + case LOCATION_METHOD_GPS: + _method = LOCATIONS_METHOD_GPS; + break; + case LOCATION_METHOD_WPS: + _method = LOCATIONS_METHOD_WPS; + break; + case LOCATION_METHOD_NONE: + default: + break; + } + return _method; +} -static int __convert_error_code(int code) +static LocationMethod __convert_LocationMethod(location_method_e method) { - int ret; - char *msg = "LOCATIONS_ERROR_NONE"; - switch (code) { - case LOCATION_ERROR_NONE: - ret = LOCATIONS_ERROR_NONE; - msg = "LOCATIONS_ERROR_NONE"; - break; - case LOCATION_ERROR_NETWORK_FAILED: - case LOCATION_ERROR_NETWORK_NOT_CONNECTED: - ret = LOCATIONS_ERROR_NETWORK_FAILED; - msg = "LOCATIONS_ERROR_NETWORK_FAILED"; - break; - case LOCATION_ERROR_NOT_ALLOWED: - ret = LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED; - msg = "LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED"; - break; - case LOCATION_ERROR_SETTING_OFF: - ret = LOCATIONS_ERROR_GPS_SETTING_OFF; - msg = "LOCATIONS_ERROR_GPS_SETTING_OFF"; - break; - case LOCATION_ERROR_SECURITY_DENIED: - ret = LOCATIONS_ERROR_SECURITY_RESTRICTED; - msg = "LOCATIONS_ERROR_SECURITY_RESTRICTED"; - break; - case LOCATION_ERROR_NOT_AVAILABLE: - case LOCATION_ERROR_CONFIGURATION: - case LOCATION_ERROR_PARAMETER: - case LOCATION_ERROR_UNKNOWN: - default: - msg = "LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE"; - ret = LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; - } - LOCATIONS_LOGE("%s(0x%08x) : core fw error(0x%x)", msg, ret, code); - return ret; + LocationMethod _method = LOCATION_METHOD_NONE; + switch (method) { + case LOCATIONS_METHOD_HYBRID: + _method = LOCATION_METHOD_HYBRID; + break; + case LOCATIONS_METHOD_GPS: + _method = LOCATION_METHOD_GPS; + break; + case LOCATIONS_METHOD_WPS: + _method = LOCATION_METHOD_WPS; + break; + case LOCATIONS_METHOD_NONE: + default: + _method = LOCATION_METHOD_NONE; + break; + } + return _method; } -static void __cb_service_updated(GObject * self, guint type, gpointer data, gpointer accuracy, gpointer userdata) +static void __cb_service_updated(GObject *self, guint type, gpointer data, gpointer velocity, gpointer accuracy, gpointer userdata) { - LOCATIONS_LOGI("Callback function has been invoked. "); + LOCATIONS_LOGD("Callback function has been invoked. "); location_manager_s *handle = (location_manager_s *) userdata; - if (type == VELOCITY_UPDATED && handle->user_cb[_LOCATIONS_EVENT_TYPE_VELOCITY]) { - LocationVelocity *vel = (LocationVelocity *) data; - LOCATIONS_LOGI("Current velocity: timestamp : %d", vel->timestamp); - ((location_velocity_updated_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_VELOCITY]) (vel->speed, vel->direction, - vel->climb, vel->timestamp, - handle->user_data - [_LOCATIONS_EVENT_TYPE_VELOCITY]); - } - else if (type == POSITION_UPDATED && handle->user_cb[_LOCATIONS_EVENT_TYPE_POSITION]) { + + if (type == SATELLITE_UPDATED && handle->user_cb[_LOCATIONS_EVENT_TYPE_SATELLITE]) { + LocationSatellite *sat = (LocationSatellite *)data; + LOCATIONS_LOGD("Current satellite information: timestamp : %d, number of active : %d, number of inview : %d", + sat->timestamp, sat->num_of_sat_used, sat->num_of_sat_inview); + ((gps_status_satellite_updated_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_SATELLITE])(sat->num_of_sat_used, sat->num_of_sat_inview, + sat->timestamp, handle->user_data[_LOCATIONS_EVENT_TYPE_SATELLITE]); + } else if (type == DISTANCE_UPDATED && handle->user_cb[_LOCATIONS_EVENT_TYPE_DISTANCE]) { LocationPosition *pos = (LocationPosition *) data; - LOCATIONS_LOGI("Current position: timestamp : %d", pos->timestamp); - ((location_position_updated_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_POSITION]) (pos->latitude, pos->longitude, - pos->altitude, pos->timestamp, - handle->user_data - [_LOCATIONS_EVENT_TYPE_POSITION]); + LocationVelocity *vel = (LocationVelocity *) velocity; /* current velocity */ + ((location_changed_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_DISTANCE])(0, pos->latitude, pos->longitude, pos->altitude, + vel->speed, vel->direction, pos->timestamp, handle->user_data[_LOCATIONS_EVENT_TYPE_DISTANCE]); + } else { + + if (handle->user_cb[_LOCATIONS_EVENT_TYPE_POSITION] && (type & POSITION_UPDATED) != 0) { + LocationPosition *pos = (LocationPosition *) data; + ((location_position_updated_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_POSITION])(pos->latitude, pos->longitude, pos->altitude, pos->timestamp, + handle->user_data[_LOCATIONS_EVENT_TYPE_POSITION]); + } + + if (handle->user_cb[_LOCATIONS_EVENT_TYPE_VELOCITY] && (type & VELOCITY_UPDATED) != 0) { + LocationVelocity *vel = (LocationVelocity *) data; + ((location_velocity_updated_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_VELOCITY])(vel->speed, vel->direction, vel->climb, vel->timestamp, + handle->user_data[_LOCATIONS_EVENT_TYPE_VELOCITY]); + } + + if (handle->user_cb[_LOCATIONS_EVENT_TYPE_POS_VEL] && (type & LOCATION_CHANGED) != 0) { + LocationPosition *pos = (LocationPosition *) data; + LocationVelocity *vel = (LocationVelocity *) velocity; + LocationAccuracy *acc = (LocationAccuracy *) accuracy; + ((location_changed_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_POS_VEL])(pos->latitude, pos->longitude, pos->altitude, + vel->speed, vel->direction, acc->horizontal_accuracy, pos->timestamp, handle->user_data[_LOCATIONS_EVENT_TYPE_POS_VEL]); + } } - else if (type == SATELLITE_UPDATED && handle->user_cb[_LOCATIONS_EVENT_TYPE_SATELLITE]) { - LocationSatellite *sat = (LocationSatellite *)data; - LOCATIONS_LOGI("Current satellite information: timestamp : %d, number of active : %d, number of inview : %d", - sat->timestamp, sat->num_of_sat_used, sat->num_of_sat_inview); - ((gps_status_satellite_updated_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_SATELLITE]) (sat->num_of_sat_used, sat->num_of_sat_inview, - sat->timestamp, handle->user_data[_LOCATIONS_EVENT_TYPE_SATELLITE]); +} + +static void __cb_location_updated(GObject *self, int error, gpointer position, gpointer velocity, gpointer accuracy, gpointer userdata) +{ + LOCATIONS_LOGD("Callback function has been invoked. "); + int converted_err = __convert_error_code(error); + location_manager_s *handle = (location_manager_s *) userdata; + LocationPosition *pos = (LocationPosition *) position; + LocationVelocity *vel = (LocationVelocity *) velocity; + + LOCATIONS_LOGD("Current position: timestamp : %d", pos->timestamp); + if (handle->user_cb[_LOCATIONS_EVENT_TYPE_LOCATION]) { + ((location_updated_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_LOCATION])(converted_err, pos->latitude, pos->longitude, pos->altitude, + pos->timestamp, vel->speed, vel->climb, vel->direction, handle->user_data[_LOCATIONS_EVENT_TYPE_LOCATION]); } } -static void __cb_service_enabled(GObject * self, guint status, gpointer userdata) +static void __cb_service_enabled(GObject *self, guint status, gpointer userdata) { - LOCATIONS_LOGI("Callback function has been invoked. "); + LOCATIONS_LOGD("Callback function has been invoked. "); location_manager_s *handle = (location_manager_s *) userdata; if (handle->user_cb[_LOCATIONS_EVENT_TYPE_SERVICE_STATE]) { ((location_service_state_changed_cb) - handle->user_cb[_LOCATIONS_EVENT_TYPE_SERVICE_STATE]) (LOCATIONS_SERVICE_ENABLED, - handle->user_data[_LOCATIONS_EVENT_TYPE_SERVICE_STATE]); + handle->user_cb[_LOCATIONS_EVENT_TYPE_SERVICE_STATE])(LOCATIONS_SERVICE_ENABLED, + handle->user_data[_LOCATIONS_EVENT_TYPE_SERVICE_STATE]); } } -static void __cb_service_disabled(GObject * self, guint status, gpointer userdata) +static void __cb_service_disabled(GObject *self, guint status, gpointer userdata) { - LOCATIONS_LOGI("Callback function has been invoked. "); + LOCATIONS_LOGD("Callback function has been invoked. "); location_manager_s *handle = (location_manager_s *) userdata; if (handle->user_cb[_LOCATIONS_EVENT_TYPE_SERVICE_STATE]) ((location_service_state_changed_cb) - handle->user_cb[_LOCATIONS_EVENT_TYPE_SERVICE_STATE]) (LOCATIONS_SERVICE_DISABLED, - handle->user_data[_LOCATIONS_EVENT_TYPE_SERVICE_STATE]); + handle->user_cb[_LOCATIONS_EVENT_TYPE_SERVICE_STATE])(LOCATIONS_SERVICE_DISABLED, + handle->user_data[_LOCATIONS_EVENT_TYPE_SERVICE_STATE]); } -static int __compare_position (gconstpointer a, gconstpointer b) +static int __compare_position(gconstpointer a, gconstpointer b) { - if(location_position_equal((LocationPosition*) a, (LocationPosition *)b) == TRUE) { + if (location_position_equal((LocationPosition *) a, (LocationPosition *)b) == TRUE) { return 0; } return -1; } -static int __boundary_compare(LocationBoundary * bound1, LocationBoundary * bound2) +static int __boundary_compare(LocationBoundary *bound1, LocationBoundary *bound2) { int ret = -1; if (bound1->type == bound2->type) { switch (bound1->type) { - case LOCATION_BOUNDARY_CIRCLE: - if (location_position_equal(bound1->circle.center, bound2->circle.center) && bound1->circle.radius == bound2->circle.radius) { - ret = 0; - } - break; - case LOCATION_BOUNDARY_RECT: - if (location_position_equal(bound1->rect.left_top, bound2->rect.left_top) && location_position_equal(bound1->rect.right_bottom, bound2->rect.right_bottom)) { - ret = 0; - } - break; - case LOCATION_BOUNDARY_POLYGON: { - GList *boundary1_next = NULL; - GList *boundary2_start = NULL, *boundary2_prev = NULL, *boundary2_next = NULL; - if (g_list_length(bound1->polygon.position_list) != g_list_length(bound2->polygon.position_list)) { - return -1; - } - - boundary2_start = g_list_find_custom(bound2->polygon.position_list, g_list_nth_data(bound1->polygon.position_list, 0), (GCompareFunc) __compare_position); - if (boundary2_start == NULL) return -1; + case LOCATION_BOUNDARY_CIRCLE: + if (location_position_equal(bound1->circle.center, bound2->circle.center) && bound1->circle.radius == bound2->circle.radius) { + ret = 0; + } + break; + case LOCATION_BOUNDARY_RECT: + if (location_position_equal(bound1->rect.left_top, bound2->rect.left_top) && location_position_equal(bound1->rect.right_bottom, bound2->rect.right_bottom)) { + ret = 0; + } + break; + case LOCATION_BOUNDARY_POLYGON: { + GList *boundary1_next = NULL; + GList *boundary2_start = NULL, *boundary2_prev = NULL, *boundary2_next = NULL; + if (g_list_length(bound1->polygon.position_list) != g_list_length(bound2->polygon.position_list)) { + return -1; + } - boundary2_prev = g_list_previous(boundary2_start); - boundary2_next = g_list_next(boundary2_start); + boundary2_start = g_list_find_custom(bound2->polygon.position_list, g_list_nth_data(bound1->polygon.position_list, 0), (GCompareFunc) __compare_position); + if (boundary2_start == NULL) return -1; - if (boundary2_prev == NULL) boundary2_prev = g_list_last(bound2->polygon.position_list); - if (boundary2_next == NULL) boundary2_next = g_list_first(bound2->polygon.position_list); + boundary2_prev = g_list_previous(boundary2_start); + boundary2_next = g_list_next(boundary2_start); - boundary1_next = g_list_next(bound1->polygon.position_list); - if (location_position_equal((LocationPosition*)boundary1_next->data, (LocationPosition*)boundary2_prev->data) == TRUE) { - boundary1_next = g_list_next(boundary1_next); - while (boundary1_next) { - boundary2_prev = g_list_previous(boundary2_prev); if (boundary2_prev == NULL) boundary2_prev = g_list_last(bound2->polygon.position_list); - if (location_position_equal((LocationPosition*)boundary1_next->data, (LocationPosition*) boundary2_prev->data) == FALSE) { - return -1; - } - boundary1_next = g_list_next(boundary1_next); - } - ret = 0; - } else if (location_position_equal((LocationPosition*)boundary1_next->data, (LocationPosition*)boundary2_next->data) == TRUE) { - boundary1_next = g_list_next(boundary1_next); - while(boundary1_next) { - boundary2_next = g_list_next(boundary2_next); if (boundary2_next == NULL) boundary2_next = g_list_first(bound2->polygon.position_list); - if (location_position_equal((LocationPosition*)boundary1_next->data, (LocationPosition*) boundary2_next->data) == FALSE) { + + boundary1_next = g_list_next(bound1->polygon.position_list); + if (boundary1_next != NULL && boundary2_prev != NULL && + location_position_equal((LocationPosition *)boundary1_next->data, (LocationPosition *)boundary2_prev->data) == TRUE) { + boundary1_next = g_list_next(boundary1_next); + while (boundary1_next) { + boundary2_prev = g_list_previous(boundary2_prev); + if (boundary2_prev == NULL) boundary2_prev = g_list_last(bound2->polygon.position_list); + if (location_position_equal((LocationPosition *)boundary1_next->data, (LocationPosition *) boundary2_prev->data) == FALSE) { + return -1; + } + boundary1_next = g_list_next(boundary1_next); + } + ret = 0; + } else if (boundary1_next != NULL && boundary2_next != NULL && + location_position_equal((LocationPosition *)boundary1_next->data, (LocationPosition *)boundary2_next->data) == TRUE) { + boundary1_next = g_list_next(boundary1_next); + while (boundary1_next) { + boundary2_next = g_list_next(boundary2_next); + if (boundary2_next == NULL) boundary2_next = g_list_first(bound2->polygon.position_list); + if (location_position_equal((LocationPosition *)boundary1_next->data, (LocationPosition *) boundary2_next->data) == FALSE) { + return -1; + } + boundary1_next = g_list_next(boundary1_next); + } + ret = 0; + } else { return -1; } - boundary1_next = g_list_next(boundary1_next); + break; } - ret = 0; - } else { - return -1; - } - break; - } - default: - break; + default: + break; } } return ret; } -static void __cb_zone_in(GObject * self, gpointer boundary, gpointer position, gpointer accuracy, gpointer userdata) +static void __cb_zone_in(GObject *self, gpointer boundary, gpointer position, gpointer accuracy, gpointer userdata) { - LOCATIONS_LOGI("Callback function has been invoked."); + LOCATIONS_LOGD("ENTER >>>"); location_manager_s *handle = (location_manager_s *) userdata; if (handle->user_cb[_LOCATIONS_EVENT_TYPE_BOUNDARY]) { LocationPosition *pos = (LocationPosition *) position; - ((location_zone_changed_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_BOUNDARY]) (LOCATIONS_BOUNDARY_IN, - pos->latitude, pos->longitude, - pos->altitude, pos->timestamp, - handle->user_data - [_LOCATIONS_EVENT_TYPE_BOUNDARY]); + ((location_zone_changed_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_BOUNDARY])(LOCATIONS_BOUNDARY_IN, + pos->latitude, pos->longitude, + pos->altitude, pos->timestamp, + handle->user_data + [_LOCATIONS_EVENT_TYPE_BOUNDARY]); } location_bounds_s *bounds; @@ -210,25 +236,28 @@ static void __cb_zone_in(GObject * self, gpointer boundary, gpointer position, g while (bounds_list) { bounds = (location_bounds_s *)bounds_list->data; if (__boundary_compare(boundary, bounds->boundary) == 0) { - LOCATIONS_LOGI("Find zone in boundary"); - ((location_bounds_state_changed_cb) bounds->user_cb) (LOCATIONS_BOUNDARY_IN, bounds->user_data); + LOCATIONS_LOGD("Find zone in boundary"); + if (bounds->user_cb) { + ((location_bounds_state_changed_cb) bounds->user_cb)(LOCATIONS_BOUNDARY_IN, bounds->user_data); + } break; } bounds_list = g_list_next(bounds_list); } + LOCATIONS_LOGD("EXIT <<<"); } -static void __cb_zone_out(GObject * self, gpointer boundary, gpointer position, gpointer accuracy, gpointer userdata) +static void __cb_zone_out(GObject *self, gpointer boundary, gpointer position, gpointer accuracy, gpointer userdata) { - LOCATIONS_LOGI("Callback function has been invoked."); + LOCATIONS_LOGD("ENTER >>>"); location_manager_s *handle = (location_manager_s *) userdata; if (handle->user_cb[_LOCATIONS_EVENT_TYPE_BOUNDARY]) { LocationPosition *pos = (LocationPosition *) position; - ((location_zone_changed_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_BOUNDARY]) (LOCATIONS_BOUNDARY_OUT, - pos->latitude, pos->longitude, - pos->altitude, pos->timestamp, - handle->user_data - [_LOCATIONS_EVENT_TYPE_BOUNDARY]); + ((location_zone_changed_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_BOUNDARY])(LOCATIONS_BOUNDARY_OUT, + pos->latitude, pos->longitude, + pos->altitude, pos->timestamp, + handle->user_data + [_LOCATIONS_EVENT_TYPE_BOUNDARY]); } location_bounds_s *bounds; @@ -236,36 +265,18 @@ static void __cb_zone_out(GObject * self, gpointer boundary, gpointer position, while (bounds_list) { bounds = (location_bounds_s *)bounds_list->data; if (__boundary_compare(boundary, bounds->boundary) == 0) { - LOCATIONS_LOGI("Find zone out boundary"); - ((location_bounds_state_changed_cb) bounds->user_cb) (LOCATIONS_BOUNDARY_OUT, bounds->user_data); + LOCATIONS_LOGD("Find zone out boundary"); + if (bounds->user_cb) { + ((location_bounds_state_changed_cb) bounds->user_cb)(LOCATIONS_BOUNDARY_OUT, bounds->user_data); + } break; } bounds_list = g_list_next(bounds_list); } + LOCATIONS_LOGD("EXIT <<<"); } -static int __set_callback(_location_event_e type, location_manager_h manager, void *callback, void *user_data) -{ - LOCATIONS_NULL_ARG_CHECK(manager); - LOCATIONS_NULL_ARG_CHECK(callback); - location_manager_s *handle = (location_manager_s *) manager; - handle->user_cb[type] = callback; - handle->user_data[type] = user_data; - LOCATIONS_LOGI("event type : %d. ", type); - return LOCATIONS_ERROR_NONE; -} - -static int __unset_callback(_location_event_e type, location_manager_h manager) -{ - LOCATIONS_NULL_ARG_CHECK(manager); - location_manager_s *handle = (location_manager_s *) manager; - handle->user_cb[type] = NULL; - handle->user_data[type] = NULL; - LOCATIONS_LOGI("event type : %d. ", type); - return LOCATIONS_ERROR_NONE; -} - -static void __foreach_boundary(LocationBoundary * boundary, void *user_data) +static void __foreach_boundary(LocationBoundary *boundary, void *user_data) { location_manager_s *handle = (location_manager_s *) user_data; @@ -309,77 +320,121 @@ static void __foreach_boundary(LocationBoundary * boundary, void *user_data) } else { if (handle->is_continue_foreach_bounds) { handle->is_continue_foreach_bounds = - ((location_bounds_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_FOREACH_BOUNDS]) (bounds, - handle-> - user_data - [_LOCATIONS_EVENT_TYPE_FOREACH_BOUNDS]); + ((location_bounds_cb) handle->user_cb[_LOCATIONS_EVENT_TYPE_FOREACH_BOUNDS])(bounds, + handle-> + user_data + [_LOCATIONS_EVENT_TYPE_FOREACH_BOUNDS]); } location_bounds_destroy(bounds); } } else { - LOCATIONS_LOGI("__foreach_boundary() has been failed"); + LOCATIONS_LOGD("__foreach_boundary() has been failed"); } } -///////////////////////////////////////// -// Location Manager -//////////////////////////////////////// +static void __setting_changed_cb(LocationMethod method, gboolean enable, void *user_data) +{ + LOCATIONS_LOGD("__setting_changed_cb method [%d]", method); + location_method_e _method = __convert_location_method_e(method); + location_setting_changed_s *_setting_changed = (location_setting_changed_s *)user_data; + if (_setting_changed == NULL) { + LOCATIONS_LOGE("Invaild userdata\n"); + return; + } -/* -* Public Implementation -*/ + if (_setting_changed[_method].callback != NULL) { + _setting_changed[_method].callback(_method, enable, _setting_changed[_method].user_data); + } +} + +/*/////////////////////////////////////// */ +/* Location Manager */ +/*////////////////////////////////////// */ EXPORT_API bool location_manager_is_supported_method(location_method_e method) { - LocationMethod _method = LOCATION_METHOD_NONE; - switch (method) { - case LOCATIONS_METHOD_HYBRID: - _method = LOCATION_METHOD_HYBRID; - break; - case LOCATIONS_METHOD_GPS: - _method = LOCATION_METHOD_GPS; - break; - case LOCATIONS_METHOD_WPS: - _method = LOCATION_METHOD_WPS; - break; - case LOCATIONS_METHOD_CPS: - _method = LOCATION_METHOD_CPS; - break; - default: - _method = LOCATION_METHOD_NONE; - break; + LOCATIONS_LOGD("location_manager_is_supported_method %d", method); + if (__is_location_supported() == LOCATIONS_ERROR_NOT_SUPPORTED) { + set_last_result(LOCATIONS_ERROR_NOT_SUPPORTED); + return false; + } + + LocationMethod _method = __convert_LocationMethod(method); + if (_method == LOCATION_METHOD_NONE) { + LOCATIONS_LOGE("Not supported method [%d]", method); + set_last_result(LOCATIONS_ERROR_INCORRECT_METHOD); + return false; } + + set_last_result(LOCATIONS_ERROR_NONE); return location_is_supported_method(_method); } -EXPORT_API int location_manager_create(location_method_e method, location_manager_h * manager) +EXPORT_API int location_manager_is_enabled_method(location_method_e method, bool *enable) { + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + + if (LOCATIONS_METHOD_HYBRID > method || LOCATIONS_METHOD_WPS < method) { + LOCATIONS_LOGE("Not supported method [%d]", method); + return LOCATIONS_ERROR_INCORRECT_METHOD; + } + + LOCATIONS_LOGD("location_manager_is_enabled_method %d", method); + LOCATIONS_NULL_ARG_CHECK(enable); + int is_enabled_val = -1; + LocationMethod _method = __convert_LocationMethod(method); + int ret = location_is_enabled_method(_method, &is_enabled_val); + if (ret != LOCATION_ERROR_NONE) { + if (ret == LOCATION_ERROR_NOT_SUPPORTED) + return LOCATIONS_ERROR_INCORRECT_METHOD; + return __convert_error_code(ret); + } + if (is_enabled_val == -1) + return TIZEN_ERROR_PERMISSION_DENIED; + + *enable = (is_enabled_val == 0) ? FALSE : TRUE; + return LOCATIONS_ERROR_NONE; +} + +EXPORT_API int location_manager_enable_method(const location_method_e method, const bool enable) +{ + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + + if (LOCATIONS_METHOD_HYBRID > method || LOCATIONS_METHOD_WPS < method) { + LOCATIONS_LOGE("Not supported method [%d]", method); + return LOCATIONS_ERROR_INCORRECT_METHOD; + } + + LOCATIONS_LOGD("method: %d, enable: %d", method, enable); + + LocationMethod _method = __convert_LocationMethod(method); + + int ret = location_enable_method(_method, enable); + return __convert_error_code(ret); +} + + +EXPORT_API int location_manager_create(location_method_e method, location_manager_h *manager) +{ + LOCATIONS_LOGD("location_manager_create (method : %d)", method); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + + LocationMethod _method = __convert_LocationMethod(method); + if (_method == LOCATION_METHOD_NONE) { + LOCATIONS_LOGE("LOCATIONS_ERROR_NOT_SUPPORTED(0x%08x) : fail to location_init", LOCATIONS_ERROR_NOT_SUPPORTED); + return LOCATIONS_ERROR_NOT_SUPPORTED; + } + if (!location_is_supported_method(_method)) { + LOCATIONS_LOGE("LOCATIONS_ERROR_NOT_SUPPORTED(0x%08x) : fail to location_is_supported_method", LOCATIONS_ERROR_NOT_SUPPORTED); + return LOCATIONS_ERROR_NOT_SUPPORTED; + } + + /*It is moved here becasue of TCS. */ LOCATIONS_NULL_ARG_CHECK(manager); - if (location_init() != LOCATION_ERROR_NONE) - return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; - LocationMethod _method = LOCATION_METHOD_NONE; - switch (method) { - case LOCATIONS_METHOD_HYBRID: - _method = LOCATION_METHOD_HYBRID; - break; - case LOCATIONS_METHOD_GPS: - _method = LOCATION_METHOD_GPS; - break; - case LOCATIONS_METHOD_WPS: - _method = LOCATION_METHOD_WPS; - break; - case LOCATIONS_METHOD_CPS: - _method = LOCATION_METHOD_CPS; - break; - case LOCATIONS_METHOD_NONE: + if (location_init() != LOCATION_ERROR_NONE) { + LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : fail to location_init", LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; - default: - { - LOCATIONS_LOGE("LOCATIONS_ERROR_INVALID_PARAMETER(0x%08x) : Out of range (location_method_e) - method : %d ", - LOCATIONS_ERROR_INVALID_PARAMETER, method); - return LOCATIONS_ERROR_INVALID_PARAMETER; - } } location_manager_s *handle = (location_manager_s *) malloc(sizeof(location_manager_s)); @@ -392,8 +447,7 @@ EXPORT_API int location_manager_create(location_method_e method, location_manage handle->object = location_new(_method); if (handle->object == NULL) { - LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : fail to location_new", - LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); + LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : fail to location_new", LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); free(handle); return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } @@ -401,8 +455,11 @@ EXPORT_API int location_manager_create(location_method_e method, location_manage handle->is_continue_foreach_bounds = TRUE; handle->bounds_list = NULL; - handle->sig_id[_LOCATION_SIGNAL_SERVICE_ENABLED] = g_signal_connect(handle->object, "service-enabled", G_CALLBACK(__cb_service_enabled), handle); - handle->sig_id[_LOCATION_SIGNAL_SERVICE_DISABLED] = g_signal_connect(handle->object, "service-disabled", G_CALLBACK(__cb_service_disabled), handle); + if (!handle->sig_id[_LOCATION_SIGNAL_SERVICE_ENABLED]) + handle->sig_id[_LOCATION_SIGNAL_SERVICE_ENABLED] = g_signal_connect(handle->object, "service-enabled", G_CALLBACK(__cb_service_enabled), handle); + + if (!handle->sig_id[_LOCATION_SIGNAL_SERVICE_DISABLED]) + handle->sig_id[_LOCATION_SIGNAL_SERVICE_DISABLED] = g_signal_connect(handle->object, "service-disabled", G_CALLBACK(__cb_service_disabled), handle); *manager = (location_manager_h) handle; return LOCATIONS_ERROR_NONE; @@ -410,11 +467,20 @@ EXPORT_API int location_manager_create(location_method_e method, location_manage EXPORT_API int location_manager_destroy(location_manager_h manager) { + LOCATIONS_LOGD("location_manager_destroy"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); location_manager_s *handle = (location_manager_s *) manager; - g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_SERVICE_ENABLED]); - g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_SERVICE_DISABLED]); + if (handle->sig_id[_LOCATION_SIGNAL_SERVICE_ENABLED]) { + g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_SERVICE_ENABLED]); + handle->sig_id[_LOCATION_SIGNAL_SERVICE_ENABLED] = 0; + } + + if (handle->sig_id[_LOCATION_SIGNAL_SERVICE_DISABLED]) { + g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_SERVICE_DISABLED]); + handle->sig_id[_LOCATION_SIGNAL_SERVICE_DISABLED] = 0; + } int ret = location_free(handle->object); if (ret != LOCATIONS_ERROR_NONE) { @@ -426,12 +492,28 @@ EXPORT_API int location_manager_destroy(location_manager_h manager) EXPORT_API int location_manager_start(location_manager_h manager) { + LOCATIONS_LOGD("location_manager_start"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); location_manager_s *handle = (location_manager_s *) manager; - handle->sig_id[_LOCATION_SIGNAL_SERVICE_UPDATED] = g_signal_connect(handle->object, "service-updated", G_CALLBACK(__cb_service_updated), handle); - handle->sig_id[_LOCATION_SIGNAL_ZONE_IN] = g_signal_connect(handle->object, "zone-in", G_CALLBACK(__cb_zone_in), handle); - handle->sig_id[_LOCATION_SIGNAL_ZONE_OUT] = g_signal_connect(handle->object, "zone-out", G_CALLBACK(__cb_zone_out), handle); + if (!handle->sig_id[_LOCATION_SIGNAL_SERVICE_UPDATED]) + handle->sig_id[_LOCATION_SIGNAL_SERVICE_UPDATED] = g_signal_connect(handle->object, "service-updated", G_CALLBACK(__cb_service_updated), handle); + + if (LOCATIONS_METHOD_HYBRID <= handle->method && LOCATIONS_METHOD_WPS >= handle->method) { + if (!handle->sig_id[_LOCATION_SIGNAL_ZONE_IN]) + handle->sig_id[_LOCATION_SIGNAL_ZONE_IN] = g_signal_connect(handle->object, "zone-in", G_CALLBACK(__cb_zone_in), handle); + + if (!handle->sig_id[_LOCATION_SIGNAL_ZONE_OUT]) + handle->sig_id[_LOCATION_SIGNAL_ZONE_OUT] = g_signal_connect(handle->object, "zone-out", G_CALLBACK(__cb_zone_out), handle); + } else { + LOCATIONS_LOGI("This method [%d] is not supported zone-in, zone-out signal.", handle->method); + } + + if (handle->user_cb[_LOCATIONS_EVENT_TYPE_SATELLITE] != NULL) { + LOCATIONS_LOGI("Satellite update_cb is set"); + location_set_option(handle->object, "USE_SV"); + } int ret = location_start(handle->object); if (ret != LOCATION_ERROR_NONE) { @@ -440,14 +522,59 @@ EXPORT_API int location_manager_start(location_manager_h manager) return LOCATIONS_ERROR_NONE; } +EXPORT_API int location_manager_request_single_location(location_manager_h manager, int timeout, location_updated_cb callback, void *user_data) +{ + LOCATIONS_LOGD("location_manager_request_single_location"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + LOCATIONS_NULL_ARG_CHECK(manager); + LOCATIONS_NULL_ARG_CHECK(callback); + if (timeout <= 0 || timeout > 120) { + LOCATIONS_LOGE("timeout scope is incorrect(1~120) [%d]", timeout); + return LOCATIONS_ERROR_INVALID_PARAMETER; + } + + location_manager_s *handle = (location_manager_s *) manager; + int ret = LOCATIONS_ERROR_NONE; + + if (!handle->sig_id[_LOCATION_SIGNAL_LOCATION_UPDATED]) + handle->sig_id[_LOCATION_SIGNAL_LOCATION_UPDATED] = g_signal_connect(handle->object, "location-updated", G_CALLBACK(__cb_location_updated), handle); + + ret = __set_callback(_LOCATIONS_EVENT_TYPE_LOCATION, manager, callback, user_data); + if (ret != LOCATIONS_ERROR_NONE) { + return ret; + } + + ret = location_request_single_location(handle->object, timeout); + if (ret != LOCATION_ERROR_NONE) { + return __convert_error_code(ret); + } + return LOCATIONS_ERROR_NONE; +} + EXPORT_API int location_manager_stop(location_manager_h manager) { + LOCATIONS_LOGD("location_manager_stop"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); + location_manager_s *handle = (location_manager_s *) manager; - g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_SERVICE_UPDATED]); - g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_ZONE_IN]); - g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_ZONE_OUT]); + if (handle->sig_id[_LOCATION_SIGNAL_SERVICE_UPDATED]) { + g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_SERVICE_UPDATED]); + handle->sig_id[_LOCATION_SIGNAL_SERVICE_UPDATED] = 0; + } + + if (LOCATIONS_METHOD_HYBRID <= handle->method && LOCATIONS_METHOD_WPS >= handle->method) { + if (handle->sig_id[_LOCATION_SIGNAL_ZONE_IN]) { + g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_ZONE_IN]); + handle->sig_id[_LOCATION_SIGNAL_ZONE_IN] = 0; + } + + if (handle->sig_id[_LOCATION_SIGNAL_ZONE_OUT]) { + g_signal_handler_disconnect(handle->object, handle->sig_id[_LOCATION_SIGNAL_ZONE_OUT]); + handle->sig_id[_LOCATION_SIGNAL_ZONE_OUT] = 0; + } + } int ret = location_stop(handle->object); if (ret != LOCATION_ERROR_NONE) { @@ -458,6 +585,8 @@ EXPORT_API int location_manager_stop(location_manager_h manager) EXPORT_API int location_manager_add_boundary(location_manager_h manager, location_bounds_h bounds) { + LOCATIONS_LOGD("location_manager_add_boundary"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(bounds); @@ -474,6 +603,8 @@ EXPORT_API int location_manager_add_boundary(location_manager_h manager, locatio EXPORT_API int location_manager_remove_boundary(location_manager_h manager, location_bounds_h bounds) { + LOCATIONS_LOGD("location_manager_remove_boundary"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(bounds); @@ -490,6 +621,8 @@ EXPORT_API int location_manager_remove_boundary(location_manager_h manager, loca EXPORT_API int location_manager_foreach_boundary(location_manager_h manager, location_bounds_cb callback, void *user_data) { + LOCATIONS_LOGD("location_manager_foreach_boundary"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(callback); @@ -504,43 +637,44 @@ EXPORT_API int location_manager_foreach_boundary(location_manager_h manager, loc return LOCATIONS_ERROR_NONE; } -EXPORT_API int location_manager_get_method(location_manager_h manager, location_method_e * method) +EXPORT_API int location_manager_get_method(location_manager_h manager, location_method_e *method) { + LOCATIONS_LOGD("location_manager_get_method %d", method); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(method); + location_manager_s *handle = (location_manager_s *) manager; LocationMethod _method = LOCATION_METHOD_NONE; g_object_get(handle->object, "method", &_method, NULL); switch (_method) { - case LOCATION_METHOD_NONE: - *method = LOCATIONS_METHOD_NONE; - break; - case LOCATION_METHOD_HYBRID: - *method = LOCATIONS_METHOD_HYBRID; - break; - case LOCATION_METHOD_GPS: - *method = LOCATIONS_METHOD_GPS; - break; - case LOCATION_METHOD_WPS: - *method = LOCATIONS_METHOD_WPS; - break; - case LOCATION_METHOD_CPS: - *method = LOCATIONS_METHOD_CPS; - break; - default: - { - LOCATIONS_LOGE("LOCATIONS_ERROR_INVALID_PARAMETER(0x%08x) : Out of range (location_method_e) - method : %d ", - LOCATIONS_ERROR_INVALID_PARAMETER, method); - return LOCATIONS_ERROR_INVALID_PARAMETER; - } + case LOCATION_METHOD_NONE: + *method = LOCATIONS_METHOD_NONE; + break; + case LOCATION_METHOD_HYBRID: + *method = LOCATIONS_METHOD_HYBRID; + break; + case LOCATION_METHOD_GPS: + *method = LOCATIONS_METHOD_GPS; + break; + case LOCATION_METHOD_WPS: + *method = LOCATIONS_METHOD_WPS; + break; + default: { + LOCATIONS_LOGE("LOCATIONS_ERROR_INVALID_PARAMETER(0x%08x) : Out of range (location_method_e) - method : %d ", + LOCATIONS_ERROR_INVALID_PARAMETER, method); + return LOCATIONS_ERROR_INVALID_PARAMETER; + } } - //*method = handle->method; + /**method = handle->method; */ return LOCATIONS_ERROR_NONE; } EXPORT_API int location_manager_get_position(location_manager_h manager, double *altitude, double *latitude, double *longitude, - time_t * timestamp) + time_t *timestamp) { + LOCATIONS_LOGD("location_manager_get_position"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(altitude); LOCATIONS_NULL_ARG_CHECK(latitude); @@ -557,17 +691,11 @@ EXPORT_API int location_manager_get_position(location_manager_h manager, double } if (pos->status == LOCATION_STATUS_NO_FIX) { - *altitude = -1; - *latitude = -1; - *longitude = -1; + return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } else { - if (pos->status == LOCATION_STATUS_3D_FIX) { - *altitude = pos->altitude; - } else { - *altitude = -1; - } *latitude = pos->latitude; *longitude = pos->longitude; + *altitude = pos->altitude; } *timestamp = pos->timestamp; location_position_free(pos); @@ -577,6 +705,8 @@ EXPORT_API int location_manager_get_position(location_manager_h manager, double EXPORT_API int location_manager_get_location(location_manager_h manager, double *altitude, double *latitude, double *longitude, double *climb, double *direction, double *speed, location_accuracy_level_e *level, double *horizontal, double *vertical, time_t *timestamp) { + LOCATIONS_LOGD("location_manager_get_location"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(altitude); LOCATIONS_NULL_ARG_CHECK(latitude); @@ -600,17 +730,11 @@ EXPORT_API int location_manager_get_location(location_manager_h manager, double } if (pos->status == LOCATION_STATUS_NO_FIX) { - *altitude = -1; - *latitude = -1; - *longitude = -1; + return __convert_error_code(LOCATION_ERROR_NOT_AVAILABLE); } else { - if (pos->status == LOCATION_STATUS_3D_FIX) { - *altitude = pos->altitude; - } else { - *altitude = -1; - } *latitude = pos->latitude; *longitude = pos->longitude; + *altitude = pos->altitude; } *timestamp = pos->timestamp; *climb = vel->climb; @@ -626,8 +750,10 @@ EXPORT_API int location_manager_get_location(location_manager_h manager, double return LOCATIONS_ERROR_NONE; } -EXPORT_API int location_manager_get_velocity(location_manager_h manager, double *climb, double *direction, double *speed, time_t * timestamp) +EXPORT_API int location_manager_get_velocity(location_manager_h manager, double *climb, double *direction, double *speed, time_t *timestamp) { + LOCATIONS_LOGD("location_manager_get_velocity"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(climb); LOCATIONS_NULL_ARG_CHECK(direction); @@ -652,9 +778,11 @@ EXPORT_API int location_manager_get_velocity(location_manager_h manager, double return LOCATIONS_ERROR_NONE; } -EXPORT_API int location_manager_get_accuracy(location_manager_h manager, location_accuracy_level_e * level, double *horizontal, - double *vertical) +EXPORT_API int location_manager_get_accuracy(location_manager_h manager, location_accuracy_level_e *level, double *horizontal, + double *vertical) { + LOCATIONS_LOGD("location_manager_get_accuracy"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(level); LOCATIONS_NULL_ARG_CHECK(horizontal); @@ -682,8 +810,10 @@ EXPORT_API int location_manager_get_accuracy(location_manager_h manager, locatio } EXPORT_API int location_manager_get_last_position(location_manager_h manager, double *altitude, double *latitude, double *longitude, - time_t * timestamp) + time_t *timestamp) { + LOCATIONS_LOGD("location_manager_get_last_position"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(altitude); LOCATIONS_NULL_ARG_CHECK(latitude); @@ -701,17 +831,11 @@ EXPORT_API int location_manager_get_last_position(location_manager_h manager, do } if (last_pos->status == LOCATION_STATUS_NO_FIX) { - *altitude = -1; - *latitude = -1; - *longitude = -1; + return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } else { - if (last_pos->status == LOCATION_STATUS_3D_FIX) { - *altitude = last_pos->altitude; - } else { - *altitude = -1; - } *latitude = last_pos->latitude; *longitude = last_pos->longitude; + *altitude = last_pos->altitude; } *timestamp = last_pos->timestamp; location_position_free(last_pos); @@ -719,8 +843,10 @@ EXPORT_API int location_manager_get_last_position(location_manager_h manager, do return LOCATIONS_ERROR_NONE; } -EXPORT_API int location_manager_get_last_location(location_manager_h manager, double *altitude, double *latitude, double *longitude, double *climb, double *direction, double *speed, location_accuracy_level_e * level, double *horizontal, double *vertical, time_t * timestamp) +EXPORT_API int location_manager_get_last_location(location_manager_h manager, double *altitude, double *latitude, double *longitude, double *climb, double *direction, double *speed, location_accuracy_level_e *level, double *horizontal, double *vertical, time_t *timestamp) { + LOCATIONS_LOGD("location_manager_get_last_location"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(altitude); LOCATIONS_NULL_ARG_CHECK(latitude); @@ -745,17 +871,11 @@ EXPORT_API int location_manager_get_last_location(location_manager_h manager, do } if (last_pos->status == LOCATION_STATUS_NO_FIX) { - *altitude = -1; - *latitude = -1; - *longitude = -1; + return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } else { - if (last_pos->status == LOCATION_STATUS_3D_FIX) { - *altitude = last_pos->altitude; - } else { - *altitude = -1; - } *latitude = last_pos->latitude; *longitude = last_pos->longitude; + *altitude = last_pos->altitude; } *timestamp = last_pos->timestamp; *climb = last_vel->climb; @@ -770,8 +890,10 @@ EXPORT_API int location_manager_get_last_location(location_manager_h manager, do return LOCATIONS_ERROR_NONE; } -EXPORT_API int location_manager_get_last_velocity(location_manager_h manager, double *climb, double *direction, double *speed, time_t * timestamp) +EXPORT_API int location_manager_get_last_velocity(location_manager_h manager, double *climb, double *direction, double *speed, time_t *timestamp) { + LOCATIONS_LOGD("location_manager_get_last_velocity"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(climb); LOCATIONS_NULL_ARG_CHECK(direction); @@ -797,9 +919,11 @@ EXPORT_API int location_manager_get_last_velocity(location_manager_h manager, do return LOCATIONS_ERROR_NONE; } -EXPORT_API int location_manager_get_last_accuracy(location_manager_h manager, location_accuracy_level_e * level, double *horizontal, - double *vertical) +EXPORT_API int location_manager_get_last_accuracy(location_manager_h manager, location_accuracy_level_e *level, double *horizontal, + double *vertical) { + LOCATIONS_LOGD("location_manager_get_last_accuracy"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(level); LOCATIONS_NULL_ARG_CHECK(horizontal); @@ -822,13 +946,15 @@ EXPORT_API int location_manager_get_last_accuracy(location_manager_h manager, lo return LOCATIONS_ERROR_NONE; } -EXPORT_API int location_manager_get_accessibility_state(location_accessibility_state_e* state) +EXPORT_API int location_manager_get_accessibility_state(location_accessibility_state_e *state) { + LOCATIONS_LOGD("location_manager_get_accessibility_state"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_NULL_ARG_CHECK(state); int ret = LOCATION_ERROR_NONE; LocationAccessState auth = LOCATION_ACCESS_NONE; - ret = location_get_accessibility_state (&auth); + ret = location_get_accessibility_state(&auth); if (ret != LOCATION_ERROR_NONE) { *state = LOCATIONS_ACCESS_STATE_NONE; return __convert_error_code(ret); @@ -850,10 +976,54 @@ EXPORT_API int location_manager_get_accessibility_state(location_accessibility_s return LOCATIONS_ERROR_NONE; } +EXPORT_API int location_manager_set_distance_based_location_changed_cb(location_manager_h manager, location_changed_cb callback, int interval, double distance, void *user_data) +{ + LOCATIONS_LOGD("location_manager_set_distance_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + LOCATIONS_CHECK_CONDITION(interval >= 1 && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_CHECK_CONDITION(distance > 0 && distance <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_NULL_ARG_CHECK(manager); + location_manager_s *handle = (location_manager_s *) manager; + g_object_set(handle->object, "min-interval", interval, NULL); + g_object_set(handle->object, "min-distance", distance, NULL); + return __set_callback(_LOCATIONS_EVENT_TYPE_DISTANCE, manager, callback, user_data); +} + +EXPORT_API int location_manager_unset_distance_based_location_changed_cb(location_manager_h manager) +{ + LOCATIONS_LOGD("location_manager_unset_distance_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + LOCATIONS_NULL_ARG_CHECK(manager); + location_manager_s *handle = (location_manager_s *) manager; + g_object_set(handle->object, "min-interval", 0, NULL); + g_object_set(handle->object, "min-distance", 0, NULL); + return __unset_callback(_LOCATIONS_EVENT_TYPE_DISTANCE, manager); +} + +EXPORT_API int location_manager_set_location_changed_cb(location_manager_h manager, location_changed_cb callback, int interval, void *user_data) +{ + LOCATIONS_LOGD("location_manager_set_location_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + LOCATIONS_CHECK_CONDITION(interval >= 1 && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_NULL_ARG_CHECK(manager); + location_manager_s *handle = (location_manager_s *) manager; + g_object_set(handle->object, "loc-interval", interval, NULL); + return __set_callback(_LOCATIONS_EVENT_TYPE_POS_VEL, manager, callback, user_data); +} + +EXPORT_API int location_manager_unset_location_changed_cb(location_manager_h manager) +{ + LOCATIONS_LOGD("location_manager_unset_position_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + return __unset_callback(_LOCATIONS_EVENT_TYPE_POS_VEL, manager); +} + EXPORT_API int location_manager_set_position_updated_cb(location_manager_h manager, location_position_updated_cb callback, int interval, void *user_data) { + LOCATIONS_LOGD("location_manager_set_position_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); LOCATIONS_CHECK_CONDITION(interval >= 1 - && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); LOCATIONS_NULL_ARG_CHECK(manager); location_manager_s *handle = (location_manager_s *) manager; g_object_set(handle->object, "pos-interval", interval, NULL); @@ -862,13 +1032,16 @@ EXPORT_API int location_manager_set_position_updated_cb(location_manager_h manag EXPORT_API int location_manager_unset_position_updated_cb(location_manager_h manager) { + LOCATIONS_LOGD("location_manager_unset_position_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); return __unset_callback(_LOCATIONS_EVENT_TYPE_POSITION, manager); } EXPORT_API int location_manager_set_velocity_updated_cb(location_manager_h manager, location_velocity_updated_cb callback, int interval, void *user_data) { - LOCATIONS_CHECK_CONDITION(interval >= 1 - && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_LOGD("location_manager_set_velocity_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + LOCATIONS_CHECK_CONDITION(interval >= 1 && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); LOCATIONS_NULL_ARG_CHECK(manager); location_manager_s *handle = (location_manager_s *) manager; g_object_set(handle->object, "vel-interval", interval, NULL); @@ -877,126 +1050,163 @@ EXPORT_API int location_manager_set_velocity_updated_cb(location_manager_h manag EXPORT_API int location_manager_unset_velocity_updated_cb(location_manager_h manager) { + LOCATIONS_LOGD("location_manager_unset_velocity_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); return __unset_callback(_LOCATIONS_EVENT_TYPE_VELOCITY, manager); } EXPORT_API int location_manager_set_service_state_changed_cb(location_manager_h manager, location_service_state_changed_cb callback, - void *user_data) + void *user_data) { + LOCATIONS_LOGD("location_manager_set_service_state_changed_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); return __set_callback(_LOCATIONS_EVENT_TYPE_SERVICE_STATE, manager, callback, user_data); } EXPORT_API int location_manager_unset_service_state_changed_cb(location_manager_h manager) { + LOCATIONS_LOGD("location_manager_unset_service_state_changed_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); return __unset_callback(_LOCATIONS_EVENT_TYPE_SERVICE_STATE, manager); } EXPORT_API int location_manager_set_zone_changed_cb(location_manager_h manager, location_zone_changed_cb callback, void *user_data) { + LOCATIONS_LOGD("location_manager_set_zone_changed_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); return __set_callback(_LOCATIONS_EVENT_TYPE_BOUNDARY, manager, callback, user_data); } EXPORT_API int location_manager_unset_zone_changed_cb(location_manager_h manager) { + LOCATIONS_LOGD("location_manager_unset_zone_changed_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); return __unset_callback(_LOCATIONS_EVENT_TYPE_BOUNDARY, manager); } -EXPORT_API int location_manager_get_distance(double start_latitude, double start_longitude, double end_latitude, double end_longitude, double *distance) +EXPORT_API int location_manager_set_setting_changed_cb(location_method_e method, location_setting_changed_cb callback, void *user_data) { - LOCATIONS_NULL_ARG_CHECK(distance); - LOCATIONS_CHECK_CONDITION(start_latitude>=-90 && start_latitude<=90,LOCATIONS_ERROR_INVALID_PARAMETER,"LOCATIONS_ERROR_INVALID_PARAMETER"); - LOCATIONS_CHECK_CONDITION(start_longitude>=-180 && start_longitude<=180,LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); - LOCATIONS_CHECK_CONDITION(end_latitude>=-90 && end_latitude<=90,LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); - LOCATIONS_CHECK_CONDITION(end_longitude>=-180 && end_longitude<=180,LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_LOGD("location_manager_set_setting_changed_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + LOCATIONS_NULL_ARG_CHECK(callback); + LocationMethod _method = __convert_LocationMethod(method); int ret = LOCATION_ERROR_NONE; - ulong u_distance; - LocationPosition *start = location_position_new (0, start_latitude, start_longitude, 0, LOCATION_STATUS_2D_FIX); - LocationPosition *end = location_position_new (0, end_latitude, end_longitude, 0, LOCATION_STATUS_2D_FIX); + if (_method == LOCATION_METHOD_NONE) { + return __convert_error_code(LOCATION_ERROR_PARAMETER); + } + + g_location_setting[_method].callback = callback; + g_location_setting[_method].user_data = user_data; - ret = location_get_distance (start, end, &u_distance); + ret = location_add_setting_notify(_method, __setting_changed_cb, &g_location_setting); if (ret != LOCATION_ERROR_NONE) { return __convert_error_code(ret); } - *distance = (double)u_distance; + return LOCATIONS_ERROR_NONE; +} + +EXPORT_API int location_manager_unset_setting_changed_cb(location_method_e method) +{ + LOCATIONS_LOGD("location_manager_unset_setting_changed_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + LocationMethod _method = __convert_LocationMethod(method); + int ret = LOCATION_ERROR_NONE; + + if (_method == LOCATION_METHOD_NONE) { + return __convert_error_code(LOCATION_ERROR_PARAMETER); + } + + ret = location_ignore_setting_notify(_method, __setting_changed_cb); + if (ret != LOCATION_ERROR_NONE) { + LOCATIONS_LOGE("Fail to ignore notify. Error[%d]", ret); + ret = __convert_error_code(ret); + } + + g_location_setting[method].callback = NULL; + g_location_setting[method].user_data = NULL; return LOCATIONS_ERROR_NONE; } -EXPORT_API int location_manager_send_command(const char *cmd) +EXPORT_API int location_manager_get_distance(double start_latitude, double start_longitude, double end_latitude, double end_longitude, double *distance) { - LOCATIONS_NULL_ARG_CHECK(cmd); + LOCATIONS_LOGD("location_manager_get_distance"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported()); + LOCATIONS_NULL_ARG_CHECK(distance); + LOCATIONS_CHECK_CONDITION(start_latitude >= -90 && start_latitude <= 90, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_CHECK_CONDITION(start_longitude >= -180 && start_longitude <= 180, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_CHECK_CONDITION(end_latitude >= -90 && end_latitude <= 90, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_CHECK_CONDITION(end_longitude >= -180 && end_longitude <= 180, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); - int ret; - ret = location_send_command(cmd); + int ret = LOCATION_ERROR_NONE; + ulong u_distance; + + LocationPosition *start = location_position_new(0, start_latitude, start_longitude, 0, LOCATION_STATUS_2D_FIX); + LocationPosition *end = location_position_new(0, end_latitude, end_longitude, 0, LOCATION_STATUS_2D_FIX); + + ret = location_get_distance(start, end, &u_distance); if (ret != LOCATION_ERROR_NONE) { return __convert_error_code(ret); } + *distance = (double)u_distance; + return LOCATIONS_ERROR_NONE; } -///////////////////////////////////////// -// GPS Status & Satellites -//////////////////////////////////////// +/*/////////////////////////////////////// */ +/* GPS Status & Satellites */ +/*////////////////////////////////////// */ EXPORT_API int gps_status_get_nmea(location_manager_h manager, char **nmea) { + LOCATIONS_LOGD("gps_status_get_nmea"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(nmea); location_manager_s *handle = (location_manager_s *) manager; + char *nmea_data; - if (handle->method == LOCATIONS_METHOD_HYBRID) { - LocationMethod _method = LOCATION_METHOD_NONE; - g_object_get(handle->object, "method", &_method, NULL); - if (_method != LOCATION_METHOD_GPS) { - LOCATIONS_LOGE("LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); - return LOCATIONS_ERROR_INCORRECT_METHOD; + int ret = location_get_nmea(handle->object, &nmea_data); + if (ret != LOCATION_ERROR_NONE || nmea == NULL) { + if (ret == LOCATION_ERROR_NOT_ALLOWED) { + LOCATIONS_LOGE("LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED"); + return LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED; } - } else if (handle->method != LOCATIONS_METHOD_GPS) { - LOCATIONS_LOGE("LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); - return LOCATIONS_ERROR_INCORRECT_METHOD; - } - gchar *nmea_data = NULL; - g_object_get(handle->object, "nmea", &nmea_data, NULL); - if (nmea_data == NULL) { - LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : nmea data is NULL ", - LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); + + LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : NMEA is NULL ", + LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } - *nmea = NULL; - *nmea = strdup(nmea_data); - if (*nmea == NULL) { - LOCATIONS_LOGE("LOCATIONS_ERROR_OUT_OF_MEMORY(0x%08x) : fail to strdup ", - LOCATIONS_ERROR_OUT_OF_MEMORY); - return LOCATIONS_ERROR_OUT_OF_MEMORY; - } + + *nmea = g_strdup(nmea_data); g_free(nmea_data); + return LOCATIONS_ERROR_NONE; } EXPORT_API int gps_status_get_satellite(location_manager_h manager, int *num_of_active, int *num_of_inview, time_t *timestamp) { + LOCATIONS_LOGD("gps_status_get_satellite"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(num_of_active); LOCATIONS_NULL_ARG_CHECK(num_of_inview); LOCATIONS_NULL_ARG_CHECK(timestamp); location_manager_s *handle = (location_manager_s *) manager; LocationSatellite *sat = NULL; - int ret = location_get_satellite (handle->object, &sat); + int ret = location_get_satellite(handle->object, &sat); if (ret != LOCATION_ERROR_NONE || sat == NULL) { - if (ret == LOCATION_ERROR_NOT_SUPPORTED) { - LOCATIONS_LOGE("LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); - return LOCATIONS_ERROR_INCORRECT_METHOD; + if (ret == LOCATION_ERROR_NOT_ALLOWED) { + LOCATIONS_LOGE("LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED"); + return LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED; } LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", - LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); + LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } @@ -1010,36 +1220,47 @@ EXPORT_API int gps_status_get_satellite(location_manager_h manager, int *num_of_ EXPORT_API int gps_status_set_satellite_updated_cb(location_manager_h manager, gps_status_satellite_updated_cb callback, int interval, void *user_data) { - LOCATIONS_CHECK_CONDITION(interval >= 1 - && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); + LOCATIONS_LOGD("gps_status_set_satellite_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_supported()); + LOCATIONS_CHECK_CONDITION(interval >= 1 && interval <= 120, LOCATIONS_ERROR_INVALID_PARAMETER, "LOCATIONS_ERROR_INVALID_PARAMETER"); LOCATIONS_NULL_ARG_CHECK(manager); + LOCATIONS_NULL_ARG_CHECK(callback); + location_manager_s *handle = (location_manager_s *) manager; + location_set_option(handle->object, "USE_SV"); g_object_set(handle->object, "sat-interval", interval, NULL); return __set_callback(_LOCATIONS_EVENT_TYPE_SATELLITE, manager, callback, user_data); } EXPORT_API int gps_status_unset_satellite_updated_cb(location_manager_h manager) { + LOCATIONS_LOGD("gps_status_unset_satellite_updated_cb"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_supported()); return __unset_callback(_LOCATIONS_EVENT_TYPE_SATELLITE, manager); } - EXPORT_API int gps_status_foreach_satellites_in_view(location_manager_h manager, gps_status_get_satellites_cb callback, void *user_data) { + LOCATIONS_LOGD("gps_status_foreach_satellites_in_view"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(callback); + location_manager_s *handle = (location_manager_s *) manager; LocationSatellite *sat = NULL; - int ret = location_get_satellite (handle->object, &sat); + int ret = location_get_satellite(handle->object, &sat); if (ret != LOCATION_ERROR_NONE || sat == NULL) { if (ret == LOCATION_ERROR_NOT_SUPPORTED) { LOCATIONS_LOGE("LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); + LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); return LOCATIONS_ERROR_INCORRECT_METHOD; + } else if (ret == LOCATION_ERROR_NOT_ALLOWED) { + LOCATIONS_LOGE("LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED"); + return LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED; } LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", - LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); + LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } @@ -1061,10 +1282,13 @@ EXPORT_API int gps_status_foreach_satellites_in_view(location_manager_h manager, EXPORT_API int gps_status_get_last_satellite(location_manager_h manager, int *num_of_active, int *num_of_inview, time_t *timestamp) { + LOCATIONS_LOGD("gps_status_get_last_satellite"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(num_of_active); LOCATIONS_NULL_ARG_CHECK(num_of_inview); LOCATIONS_NULL_ARG_CHECK(timestamp); + location_manager_s *handle = (location_manager_s *) manager; int ret = LOCATION_ERROR_NONE; LocationSatellite *last_sat = NULL; @@ -1072,12 +1296,15 @@ EXPORT_API int gps_status_get_last_satellite(location_manager_h manager, int *nu if (ret != LOCATION_ERROR_NONE || last_sat == NULL) { if (ret == LOCATION_ERROR_NOT_SUPPORTED) { LOCATIONS_LOGE("LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); + LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); return LOCATIONS_ERROR_INCORRECT_METHOD; + } else if (ret == LOCATION_ERROR_NOT_ALLOWED) { + LOCATIONS_LOGE("LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED"); + return LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED; } LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", - LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); + LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; } @@ -1089,8 +1316,10 @@ EXPORT_API int gps_status_get_last_satellite(location_manager_h manager, int *nu } EXPORT_API int gps_status_foreach_last_satellites_in_view(location_manager_h manager, gps_status_get_satellites_cb callback, - void *user_data) + void *user_data) { + LOCATIONS_LOGD("gps_status_foreach_last_satellites_in_view"); + LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_supported()); LOCATIONS_NULL_ARG_CHECK(manager); LOCATIONS_NULL_ARG_CHECK(callback); location_manager_s *handle = (location_manager_s *) manager; @@ -1100,12 +1329,12 @@ EXPORT_API int gps_status_foreach_last_satellites_in_view(location_manager_h man if (ret != LOCATION_ERROR_NONE || last_sat == NULL) { if (ret == LOCATION_ERROR_NOT_SUPPORTED) { LOCATIONS_LOGE("LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", - LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); + LOCATIONS_ERROR_INCORRECT_METHOD, handle->method); return LOCATIONS_ERROR_INCORRECT_METHOD; } LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", - LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); + LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE); return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE; }