* This API is related with the following features:\n
* - http://tizen.org/feature/location\n
* - http://tizen.org/feature/location.gps\n
+ * - http://tizen.org/feature/location.gps.satellite\n
*
* It is recommended to design feature related codes in your application for reliability.\n
*
- * You can check if a devrice supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
*
* To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
*
*
* It is recommended to design feature related codes in your application for reliability.\n
*
- * You can check if a devrice supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
*
* To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
*
*
* It is recommended to design feature related codes in your application for reliability.\n
*
- * You can check if a devrice supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
+ * You can check if a device supports the related features for this API by using @ref CAPI_SYSTEM_SYSTEM_INFO_MODULE, thereby controlling the procedure of your application.\n
*
* To ensure your application is only running on the device with specific features, please define the features in your manifest file using the manifest editor in the SDK.\n
*
* @brief Enumeration for error code for Location manager.
*/
typedef enum {
- LOCATION_BOUNDS_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
- LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
- LOCATION_BOUNDS_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
- LOCATION_BOUNDS_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
- LOCATION_BOUNDS_ERROR_INCORRECT_TYPE = LOCATION_BOUNDS_ERROR_CLASS | 0x01, /**< Incorrect bounds type for a given call */
- LOCATION_BOUNDS_ERROR_IS_ADDED = LOCATION_BOUNDS_ERROR_CLASS | 0x02, /**< Cannot remove bounds handle from location manager */
+ LOCATION_BOUNDS_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
+ LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
+ LOCATION_BOUNDS_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
+ LOCATION_BOUNDS_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
+ LOCATION_BOUNDS_ERROR_INCORRECT_TYPE = LOCATION_BOUNDS_ERROR_CLASS | 0x01, /**< Incorrect bounds type for a given call */
+ LOCATION_BOUNDS_ERROR_IS_ADDED = LOCATION_BOUNDS_ERROR_CLASS | 0x02, /**< Cannot remove bounds handle from location manager */
} location_bound_error_e;
/**
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum {
- LOCATION_BOUNDS_RECT = 1, /**< Rectangular geographical area type. */
- LOCATION_BOUNDS_CIRCLE, /**< Circle geographical area type.. */
- LOCATION_BOUNDS_POLYGON, /**< Polygon geographical area type.. */
+ LOCATION_BOUNDS_RECT = 1, /**< Rectangular geographical area type. */
+ LOCATION_BOUNDS_CIRCLE, /**< Circle geographical area type.. */
+ LOCATION_BOUNDS_POLYGON, /**< Polygon geographical area type.. */
} location_bounds_type_e;
/**
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum {
- LOCATIONS_BOUNDARY_IN, /**< Boundary In (Zone In) */
- LOCATIONS_BOUNDARY_OUT /**< Boundary Out (Zone Out) */
+ LOCATIONS_BOUNDARY_IN, /**< Boundary In (Zone In) */
+ LOCATIONS_BOUNDARY_OUT /**< Boundary Out (Zone Out) */
} location_boundary_state_e;
/**
#define LOCATIONS_NULL_ARG_CHECK(arg) \
LOCATIONS_CHECK_CONDITION((arg != NULL),LOCATION_BOUNDS_ERROR_INVALID_PARAMETER,"LOCATION_BOUNDS_ERROR_INVALID_PARAMETER") \
-
+
#define LOCATIONS_NOT_SUPPORTED_CHECK(arg) \
LOCATIONS_CHECK_CONDITION((arg == LOCATIONS_ERROR_NONE),LOCATIONS_ERROR_NOT_SUPPORTED,"LOCATIONS_ERROR_NOT_SUPPORTED") \
-
+
typedef enum {
_LOCATIONS_EVENT_TYPE_SERVICE_STATE,
_LOCATIONS_EVENT_TYPE_POSITION,
_LOCATIONS_EVENT_TYPE_DISTANCE,
_LOCATIONS_EVENT_TYPE_POS_VEL,
_LOCATIONS_EVENT_TYPE_NUM
-}
-_location_event_e;
+} _location_event_e;
typedef enum {
- _LOCATION_SIGNAL_SERVICE_ENABLED,
- _LOCATION_SIGNAL_SERVICE_DISABLED,
- _LOCATION_SIGNAL_SERVICE_UPDATED,
- _LOCATION_SIGNAL_ZONE_IN,
- _LOCATION_SIGNAL_ZONE_OUT,
- _LOCATION_SIGNAL_LOCATION_UPDATED,
- _LOCATION_SIGNAL_BATCH_UPDATED,
- _LOCATION_SIGNAL_ERROR_EMITTED,
- _LOCATION_SIGNAL_NUM
+ _LOCATION_SIGNAL_SERVICE_ENABLED,
+ _LOCATION_SIGNAL_SERVICE_DISABLED,
+ _LOCATION_SIGNAL_SERVICE_UPDATED,
+ _LOCATION_SIGNAL_ZONE_IN,
+ _LOCATION_SIGNAL_ZONE_OUT,
+ _LOCATION_SIGNAL_LOCATION_UPDATED,
+ _LOCATION_SIGNAL_BATCH_UPDATED,
+ _LOCATION_SIGNAL_ERROR_EMITTED,
+ _LOCATION_SIGNAL_NUM
} _location_signal_e;
typedef struct _location_manager_s {
*/
int __convert_error_code(int code);
int __is_gps_supported(void);
+int __is_gps_satellite_supported(void);
int __is_wps_supported(void);
int __is_location_supported(void);
int __set_callback(_location_event_e type, location_manager_h manager, void *callback, void *user_data);
LOCATIONS_ERROR_NONE = TIZEN_ERROR_NONE, /**< Successful */
LOCATIONS_ERROR_OUT_OF_MEMORY = TIZEN_ERROR_OUT_OF_MEMORY, /**< Out of memory */
LOCATIONS_ERROR_INVALID_PARAMETER = TIZEN_ERROR_INVALID_PARAMETER, /**< Invalid parameter */
- LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
+ LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED = TIZEN_ERROR_PERMISSION_DENIED, /**< Permission denied */
LOCATIONS_ERROR_NOT_SUPPORTED = TIZEN_ERROR_NOT_SUPPORTED, /**< Not supported */
LOCATIONS_ERROR_INCORRECT_METHOD = TIZEN_ERROR_LOCATION_MANAGER | 0x01, /**< Location manager contains incorrect method for a given call */
LOCATIONS_ERROR_NETWORK_FAILED = TIZEN_ERROR_LOCATION_MANAGER | 0x02, /**< Network unavailable */
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum {
- LOCATIONS_METHOD_NONE = -1, /**< Undefined method */
- LOCATIONS_METHOD_HYBRID, /**< This method selects the best method available at the moment */
- LOCATIONS_METHOD_GPS, /**< This method uses Global Positioning System */
- LOCATIONS_METHOD_WPS, /**< This method uses WiFi Positioning System */
+ LOCATIONS_METHOD_NONE = -1, /**< Undefined method */
+ LOCATIONS_METHOD_HYBRID, /**< This method selects the best method available at the moment */
+ LOCATIONS_METHOD_GPS, /**< This method uses Global Positioning System */
+ LOCATIONS_METHOD_WPS, /**< This method uses WiFi Positioning System */
} location_method_e;
/**
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum {
- LOCATIONS_ACCURACY_NONE = 0, /**< Invalid data */
- LOCATIONS_ACCURACY_COUNTRY, /**< Country accuracy level */
- LOCATIONS_ACCURACY_REGION, /**< Regional accuracy level */
- LOCATIONS_ACCURACY_LOCALITY, /**< Local accuracy level */
- LOCATIONS_ACCURACY_POSTALCODE, /**< Postal accuracy level */
- LOCATIONS_ACCURACY_STREET, /**< Street accuracy level */
- LOCATIONS_ACCURACY_DETAILED, /**< Detailed accuracy level */
+ LOCATIONS_ACCURACY_NONE = 0, /**< Invalid data */
+ LOCATIONS_ACCURACY_COUNTRY, /**< Country accuracy level */
+ LOCATIONS_ACCURACY_REGION, /**< Regional accuracy level */
+ LOCATIONS_ACCURACY_LOCALITY, /**< Local accuracy level */
+ LOCATIONS_ACCURACY_POSTALCODE, /**< Postal accuracy level */
+ LOCATIONS_ACCURACY_STREET, /**< Street accuracy level */
+ LOCATIONS_ACCURACY_DETAILED, /**< Detailed accuracy level */
} location_accuracy_level_e;
/**
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum {
- LOCATIONS_SERVICE_DISABLED, /**< Service is disabled */
- LOCATIONS_SERVICE_ENABLED, /**< Service is enabled */
+ LOCATIONS_SERVICE_DISABLED, /**< Service is disabled */
+ LOCATIONS_SERVICE_ENABLED, /**< Service is enabled */
} location_service_state_e;
/**
* @since_tizen @if MOBILE 2.3 @elseif WEARABLE 2.3.1 @endif
*/
typedef enum {
- LOCATIONS_ACCESS_STATE_NONE, /**< Access state is not determined */
- LOCATIONS_ACCESS_STATE_DENIED, /**< Access denied */
- LOCATIONS_ACCESS_STATE_ALLOWED, /**< Access authorized */
+ LOCATIONS_ACCESS_STATE_NONE, /**< Access state is not determined */
+ LOCATIONS_ACCESS_STATE_DENIED, /**< Access denied */
+ LOCATIONS_ACCESS_STATE_ALLOWED, /**< Access authorized */
} location_accessibility_state_e;
/**
* @since_tizen 2.3.1
* @privlevel platform
* @privilege %http://tizen.org/privilege/location.enable
- * @param[in] method The location method to be checked
- * @param[in] enable The value to set
+ * @param[in] method The location method to be checked
+ * @param[in] enable The value to set
* @return 0 on success, otherwise a negative error value
* @retval #LOCATIONS_ERROR_NONE Successful
* @retval #LOCATIONS_ERROR_INCORRECT_METHOD Incorrect method
- * @retval #LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED Permission denied
+ * @retval #LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED Permission denied
* @retval #LOCATIONS_ERROR_NOT_SUPPORTED Not supported
* @see location_manager_is_enabled_method()
* @see location_manager_create()
* @return @c 0 on success, otherwise a negative error value
* @retval #LOCATIONS_ERROR_NONE Successful
* @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid argument
- * @retval #LOCATIONS_ERROR_INCORRECT_METHOD Incorrect method
* @retval #LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE Service not available
- * @retval #LOCATIONS_ERROR_OUT_OF_MEMORY Out of memory
+ * @retval #LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED The application does not have the privilege to call this method
* @retval #LOCATIONS_ERROR_NOT_SUPPORTED Not supported
* @pre The location service state must be #LOCATIONS_SERVICE_ENABLED with location_manager_start()
* @see location_manager_start()
* @return @c 0 on success, otherwise a negative error value
* @retval #LOCATIONS_ERROR_NONE Successful
* @retval #LOCATIONS_ERROR_INVALID_PARAMETER Invalid argument
- * @retval #LOCATIONS_ERROR_INCORRECT_METHOD Incorrect method
* @retval #LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE Service not available
* @retval #LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED The application does not have the privilege to call this method
* @retval #LOCATIONS_ERROR_NOT_SUPPORTED Not supported
================================================================================
-* Fri May 31 2013 Anas Nashif <anas.nashif@intel.com> accepted/tizen/20130520.100703@f7a18ab
-- Remove placeholders and cleanup spec
-
capi-location-manager (0.1.7-1) precise; urgency=low
* Change Dlog Format
* Tag: capi-location-manager_0.0.1-1
-- Kangho Hur <kangho.hur@samsung.com> Thu, 04 Aug 2011 16:51:02 +0900
-
-
-Name: capi-location-manager
-Summary: A Location Manager library in Tizen Native API
-Version: 0.6.1
-Release: 1
-Group: Location/API
-License: Apache-2.0
-Source0: %{name}-%{version}.tar.gz
+Name: capi-location-manager
+Summary: A Location Manager library in Tizen Native API
+Version: 0.6.3
+Release: 1
+Group: Location/API
+License: Apache-2.0
+Source0: %{name}-%{version}.tar.gz
Source1001: %{name}.manifest
-BuildRequires: cmake
-BuildRequires: pkgconfig(dlog)
-BuildRequires: pkgconfig(lbs-location)
-BuildRequires: pkgconfig(capi-base-common)
-BuildRequires: pkgconfig(capi-system-info)
-BuildRequires: pkgconfig(vconf)
+BuildRequires: cmake
+BuildRequires: pkgconfig(dlog)
+BuildRequires: pkgconfig(lbs-location)
+BuildRequires: pkgconfig(capi-base-common)
+BuildRequires: pkgconfig(capi-system-info)
+BuildRequires: pkgconfig(vconf)
Requires(post): /sbin/ldconfig
Requires(postun): /sbin/ldconfig
export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE"
MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
-#cmake . -DCMAKE_INSTALL_PREFIX=/usr -DFULLVER=%{version} -DMAJORVER=${MAJORVER} \
cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DLIBDIR=%{_libdir} -DINCLUDEDIR=%{_includedir} \
-DFULLVER=%{version} -DMAJORVER=${MAJORVER} \
LOCATIONS_CHECK_CONDITION(bottom_right.latitude >= -90 && bottom_right.latitude <= 90, LOCATION_BOUNDS_ERROR_INVALID_PARAMETER, "LOCATION_BOUNDS_ERROR_INVALID_PARAMETER");
LOCATIONS_CHECK_CONDITION(bottom_right.longitude >= -180 && bottom_right.longitude <= 180, LOCATION_BOUNDS_ERROR_INVALID_PARAMETER, "LOCATION_BOUNDS_ERROR_INVALID_PARAMETER");
+ if ((bottom_right.longitude - top_left.longitude) < 180 && (bottom_right.longitude - top_left.longitude) > -180) {
+ if (bottom_right.longitude <= top_left.longitude || bottom_right.latitude >= top_left.latitude) {
+ return LOCATION_BOUNDS_ERROR_INVALID_PARAMETER;
+ }
+ } else {
+ if (bottom_right.latitude >= top_left.latitude) {
+ return LOCATION_BOUNDS_ERROR_INVALID_PARAMETER;
+ }
+ }
+
LocationPosition *lt = location_position_new(0, top_left.latitude, top_left.longitude, 0, LOCATION_STATUS_2D_FIX);
if (lt == NULL) {
LOCATIONS_LOGE("LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY(0x%08x) : fail to location_position_new", LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY);
free(handle);
return LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY;
}
- handle->user_cb = NULL;
- handle->user_data = NULL;
*bounds = (location_bounds_h) handle;
return LOCATION_BOUNDS_ERROR_NONE;
{
LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported());
LOCATIONS_NULL_ARG_CHECK(bounds);
- LOCATIONS_CHECK_CONDITION(radius >= 0, LOCATION_BOUNDS_ERROR_INVALID_PARAMETER, "LOCATION_BOUNDS_ERROR_INVALID_PARAMETER");
+ LOCATIONS_CHECK_CONDITION(radius > 0, LOCATION_BOUNDS_ERROR_INVALID_PARAMETER, "LOCATION_BOUNDS_ERROR_INVALID_PARAMETER");
LOCATIONS_CHECK_CONDITION(center.latitude >= -90 && center.latitude <= 90, LOCATION_BOUNDS_ERROR_INVALID_PARAMETER, "LOCATION_BOUNDS_ERROR_INVALID_PARAMETER");
LOCATIONS_CHECK_CONDITION(center.longitude >= -180 && center.longitude <= 180, LOCATION_BOUNDS_ERROR_INVALID_PARAMETER, "LOCATION_BOUNDS_ERROR_INVALID_PARAMETER");
handle->boundary = location_boundary_new_for_circle(ct, radius);
location_position_free(ct);
if (handle->boundary == NULL) {
- int ret = get_last_result();
free(handle);
- if (ret == LOCATION_ERROR_PARAMETER) {
- LOCATIONS_LOGE("LOCATION_BOUNDS_ERROR_INVALID_PARAMETER(0x%08x) fail to location_boundary_new_for_circle", LOCATION_BOUNDS_ERROR_INVALID_PARAMETER);
- return LOCATION_BOUNDS_ERROR_INVALID_PARAMETER;
- } else {
- LOCATIONS_LOGE("LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY(0x%08x) : fail to location_boundary_new_for_circle", LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY);
- return LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY;
- }
+ LOCATIONS_LOGE("LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY(0x%08x) : fail to location_boundary_new_for_circle", LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY);
+ return LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY;
}
- handle->user_cb = NULL;
- handle->user_data = NULL;
*bounds = (location_bounds_h) handle;
return LOCATION_BOUNDS_ERROR_NONE;
}
position = location_position_new(0, coords_list[i].latitude, coords_list[i].longitude, 0.0, LOCATION_STATUS_2D_FIX);
position_list = g_list_append(position_list, position);
-
- /* We should not remove position
+ /* We should not remove position.
location_position_free(position);
*/
isValid = TRUE;
handle->is_added = FALSE;
handle->boundary = location_boundary_new_for_polygon(position_list);
if (handle->boundary == NULL) {
- int ret = get_last_result();
free(handle);
- if (ret == LOCATION_ERROR_PARAMETER) {
- LOCATIONS_LOGE("LOCATION_BOUNDS_ERROR_INVALID_PARAMETER(0x%08x) fail to location_boundary_new_for_polygon", LOCATION_BOUNDS_ERROR_INVALID_PARAMETER);
- return LOCATION_BOUNDS_ERROR_INVALID_PARAMETER;
- } else {
- LOCATIONS_LOGE("LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY(0x%08x) : fail to location_boundary_new_for_polygon", LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY);
- return LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY;
- }
+ LOCATIONS_LOGE("LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY(0x%08x) : fail to location_boundary_new_for_polygon", LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY);
+ return LOCATION_BOUNDS_ERROR_OUT_OF_MEMORY;
}
- handle->user_cb = NULL;
- handle->user_data = NULL;
-
*bounds = (location_bounds_h) handle;
return LOCATION_BOUNDS_ERROR_NONE;
}
return LOCATIONS_ERROR_NONE;
}
+int __is_gps_satellite_supported(void)
+{
+ bool is_supported = false;
+ int retval = 0;
+
+ retval = system_info_get_platform_bool("http://tizen.org/feature/location.gps.satellite", &is_supported);
+ if (retval != SYSTEM_INFO_ERROR_NONE) {
+ LOCATIONS_LOGW("system_info_get_platform_bool failed: retval = %d", retval);
+ }
+ if (is_supported == false) {
+ return LOCATIONS_ERROR_NOT_SUPPORTED;
+ }
+ return LOCATIONS_ERROR_NONE;
+}
+
int __is_wps_supported(void)
{
bool is_supported = false;
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);
+ 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]);
+ 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;
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]);
+ 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]);
+ handle->user_data[_LOCATIONS_EVENT_TYPE_POSITION]);
}
if (handle->user_cb[_LOCATIONS_EVENT_TYPE_VELOCITY] && (type & VELOCITY_UPDATED) != 0) {
- LocationVelocity *vel = (LocationVelocity *) data;
+ LocationVelocity *vel = (LocationVelocity *) velocity;
((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]);
+ handle->user_data[_LOCATIONS_EVENT_TYPE_VELOCITY]);
}
if (handle->user_cb[_LOCATIONS_EVENT_TYPE_POS_VEL] && (type & LOCATION_CHANGED) != 0) {
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]);
+ vel->speed, vel->direction, acc->horizontal_accuracy, pos->timestamp, handle->user_data[_LOCATIONS_EVENT_TYPE_POS_VEL]);
}
}
}
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]);
+ pos->timestamp, vel->speed, vel->climb, vel->direction, handle->user_data[_LOCATIONS_EVENT_TYPE_LOCATION]);
}
}
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]);
}
}
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)
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) {
+ 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);
}
ret = 0;
} else if (boundary1_next != NULL && boundary2_next != NULL &&
- location_position_equal((LocationPosition *)boundary1_next->data, (LocationPosition *)boundary2_next->data) == TRUE) {
+ 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 (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]);
+ pos->latitude, pos->longitude,
+ pos->altitude, pos->timestamp,
+ handle->user_data
+ [_LOCATIONS_EVENT_TYPE_BOUNDARY]);
}
location_bounds_s *bounds;
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]);
+ pos->latitude, pos->longitude,
+ pos->altitude, pos->timestamp,
+ handle->user_data
+ [_LOCATIONS_EVENT_TYPE_BOUNDARY]);
}
location_bounds_s *bounds;
} 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);
}
static void __setting_changed_cb(LocationMethod method, gboolean enable, void *user_data)
{
- LOCATIONS_LOGD("__setting_changed_cb method [%d]", method);
+ LOCATIONS_LOGD("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) {
return false;
}
+ if (method == LOCATIONS_METHOD_GPS) {
+ if (__is_gps_supported() == LOCATIONS_ERROR_NOT_SUPPORTED) {
+ set_last_result(LOCATIONS_ERROR_NOT_SUPPORTED);
+ return false;
+ }
+ } else if (method == LOCATIONS_METHOD_WPS) {
+ if (__is_wps_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);
return LOCATIONS_ERROR_INCORRECT_METHOD;
return __convert_error_code(ret);
}
- if (is_enabled_val == -1)
+ if (is_enabled_val == -1) {
return TIZEN_ERROR_PERMISSION_DENIED;
+ }
*enable = (is_enabled_val == 0) ? FALSE : TRUE;
return LOCATIONS_ERROR_NONE;
LOCATIONS_LOGD("method: %d, enable: %d", method, enable);
- LocationMethod _method = __convert_LocationMethod(method);
+ int ret = 0;
+ if (LOCATIONS_METHOD_HYBRID == method) {
+ if (__is_gps_supported() == LOCATIONS_ERROR_NONE) {
+ ret = location_enable_method(LOCATION_METHOD_GPS, enable);
+ if (ret != LOCATIONS_ERROR_NONE) return __convert_error_code(ret);
+ }
+ if (__is_wps_supported() == LOCATIONS_ERROR_NONE) {
+ ret = location_enable_method(LOCATION_METHOD_WPS, enable);
+ return __convert_error_code(ret);
+ }
+ return LOCATIONS_ERROR_NONE;
+
+ } else {
+ if ((LOCATIONS_METHOD_GPS == method) && (__is_gps_supported() == LOCATIONS_ERROR_NOT_SUPPORTED)) {
+ LOCATIONS_LOGE("LOCATIONS_ERROR_NOT_SUPPORTED(0x%08x)", LOCATIONS_ERROR_NOT_SUPPORTED);
+ return LOCATIONS_ERROR_NOT_SUPPORTED;
+ }
+ else if ((LOCATIONS_METHOD_WPS == method) && (__is_wps_supported() == LOCATIONS_ERROR_NOT_SUPPORTED)) {
+ LOCATIONS_LOGE("LOCATIONS_ERROR_NOT_SUPPORTED(0x%08x)", LOCATIONS_ERROR_NOT_SUPPORTED);
+ return LOCATIONS_ERROR_NOT_SUPPORTED;
+ }
+
+ LocationMethod _method = __convert_LocationMethod(method);
+
+ int ret = location_enable_method(_method, enable);
- int ret = location_enable_method(_method, enable);
- return __convert_error_code(ret);
+ 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());
+
+ if (method == LOCATIONS_METHOD_HYBRID) {
+ LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported());
+ } else if (method == LOCATIONS_METHOD_GPS) {
+ if (__is_gps_supported() == LOCATIONS_ERROR_NOT_SUPPORTED) {
+ LOCATIONS_LOGE("LOCATIONS_ERROR_NOT_SUPPORTED(0x%08x) : fail to location feature", LOCATIONS_ERROR_NOT_SUPPORTED);
+ return LOCATIONS_ERROR_NOT_SUPPORTED;
+ }
+ } else if (method == LOCATIONS_METHOD_WPS) {
+ if (__is_wps_supported() == LOCATIONS_ERROR_NOT_SUPPORTED) {
+ LOCATIONS_LOGE("LOCATIONS_ERROR_NOT_SUPPORTED(0x%08x) : fail to location feature", LOCATIONS_ERROR_NOT_SUPPORTED);
+ return LOCATIONS_ERROR_NOT_SUPPORTED;
+ }
+ }
LocationMethod _method = __convert_LocationMethod(method);
if (_method == LOCATION_METHOD_NONE) {
break;
default: {
LOCATIONS_LOGE("LOCATIONS_ERROR_INVALID_PARAMETER(0x%08x) : Out of range (location_method_e) - method : %d ",
- LOCATIONS_ERROR_INVALID_PARAMETER, method);
+ LOCATIONS_ERROR_INVALID_PARAMETER, method);
return LOCATIONS_ERROR_INVALID_PARAMETER;
}
}
}
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());
}
EXPORT_API int location_manager_get_accuracy(location_manager_h manager, location_accuracy_level_e *level, double *horizontal,
- double *vertical)
+ double *vertical)
{
LOCATIONS_LOGD("location_manager_get_accuracy");
LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported());
return LOCATIONS_ERROR_NONE;
}
-EXPORT_API int location_manager_get_last_position(location_manager_h manager, double *altitude, double *latitude, double *longitude,
- time_t *timestamp)
+EXPORT_API int location_manager_get_last_position(location_manager_h manager, double *altitude, double *latitude, double *longitude, time_t *timestamp)
{
LOCATIONS_LOGD("location_manager_get_last_position");
LOCATIONS_NOT_SUPPORTED_CHECK(__is_location_supported());
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_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");
+ 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, "pos-interval", interval, NULL);
}
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());
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_NOT_SUPPORTED_CHECK(__is_gps_satellite_supported());
LOCATIONS_NULL_ARG_CHECK(manager);
LOCATIONS_NULL_ARG_CHECK(nmea);
location_manager_s *handle = (location_manager_s *) manager;
return LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED;
}
- LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : NMEA 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;
}
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_NOT_SUPPORTED_CHECK(__is_gps_satellite_supported());
LOCATIONS_NULL_ARG_CHECK(manager);
LOCATIONS_NULL_ARG_CHECK(num_of_active);
LOCATIONS_NULL_ARG_CHECK(num_of_inview);
return LOCATIONS_ERROR_ACCESSIBILITY_NOT_ALLOWED;
}
- LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ",
- LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE);
+ LOCATIONS_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE);
return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE;
}
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_LOGD("gps_status_set_satellite_updated_cb");
- LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_supported());
+ LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_satellite_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);
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());
+ LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_satellite_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_NOT_SUPPORTED_CHECK(__is_gps_satellite_supported());
LOCATIONS_NULL_ARG_CHECK(manager);
LOCATIONS_NULL_ARG_CHECK(callback);
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_LOGE("LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", 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_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE);
return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE;
}
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_NOT_SUPPORTED_CHECK(__is_gps_satellite_supported());
LOCATIONS_NULL_ARG_CHECK(manager);
LOCATIONS_NULL_ARG_CHECK(num_of_active);
LOCATIONS_NULL_ARG_CHECK(num_of_inview);
ret = location_get_last_satellite(handle->object, &last_sat);
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_LOGE("LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", 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_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE);
return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE;
}
return LOCATIONS_ERROR_NONE;
}
-EXPORT_API int gps_status_foreach_last_satellites_in_view(location_manager_h manager, gps_status_get_satellites_cb callback,
- void *user_data)
+EXPORT_API int gps_status_foreach_last_satellites_in_view(location_manager_h manager, gps_status_get_satellites_cb callback, void *user_data)
{
LOCATIONS_LOGD("gps_status_foreach_last_satellites_in_view");
- LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_supported());
+ LOCATIONS_NOT_SUPPORTED_CHECK(__is_gps_satellite_supported());
LOCATIONS_NULL_ARG_CHECK(manager);
LOCATIONS_NULL_ARG_CHECK(callback);
location_manager_s *handle = (location_manager_s *) manager;
ret = location_get_last_satellite(handle->object, &last_sat);
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_LOGE("LOCATIONS_ERROR_INCORRECT_METHOD(0x%08x) : method - %d", 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_LOGE("LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE(0x%08x) : satellite is NULL ", LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE);
return LOCATIONS_ERROR_SERVICE_NOT_AVAILABLE;
}
static int repeat_count;
static void location_cleanup();
static int location_test();
+static guint test_timer;
static gboolean exit_program(gpointer data)
{
static gboolean wait_test()
{
+ if (test_timer) {
+ g_source_remove(test_timer);
+ test_timer = 0;
+ }
+
location_cleanup();
location_test();
repeat_count++;
if (repeat_count > 2) {
- g_timeout_add_seconds(1, wait_test, NULL);
+ test_timer = g_timeout_add_seconds(1, wait_test, NULL);
}
}
printf("location_cb: lat[%f] lon[%f] alt[%f]\n", latitude, longitude, altitude);
printf("speed[%f] climb[%f] direction[%f]\n", speed, climb, direction);
- g_timeout_add_seconds(1, wait_test, NULL);
+ test_timer = g_timeout_add_seconds(1, wait_test, NULL);
}
void _location_changed_cb(double latitude, double longitude, double altitude, double speed, double direction, double horizontal_accuracy, time_t timestamp, void *user_data)
repeat_count++;
if (repeat_count > 2) {
- g_timeout_add_seconds(1, wait_test, NULL);
+ test_timer = g_timeout_add_seconds(1, wait_test, NULL);
}
}
repeat_count++;
if (repeat_count > 1) {
- g_timeout_add_seconds(1, wait_test, NULL);
+ test_timer = g_timeout_add_seconds(1, wait_test, NULL);
}
}
static void print_location_status()
{
- printf("==== LOCATION STATUS ======\n");
+ printf("==== LOCATION Setting state =====\n");
bool is_enabled = FALSE;
location_manager_is_enabled_method(LOCATIONS_METHOD_HYBRID, &is_enabled);
printf("hybrid: %d, ", is_enabled);
static int enable_method(location_method_e method, bool enable)
{
int ret = 0;
- printf("==== LOCATION STATUS ======\n");
+ printf("==== LOCATION Setting changed =====\n");
location_manager_set_setting_changed_cb(LOCATIONS_METHOD_HYBRID, __setting_cb, NULL);
- location_manager_set_setting_changed_cb(LOCATIONS_METHOD_GPS, __setting_cb, NULL);
- location_manager_set_setting_changed_cb(LOCATIONS_METHOD_WPS, __setting_cb, NULL);
+ printf("method[%d], enable[%d]\n", method, enable);
ret = location_manager_enable_method(method, enable);
- printf("method[%d]: %d\n", method, enable);
+
+ location_manager_unset_setting_changed_cb(LOCATIONS_METHOD_HYBRID);
return ret;
}
static void print_menu()
{
- printf("==== LOCATION TEST ======\n");
+ printf("============= LOCATION TEST =============\n");
printf("[1] Get location: LOCATIONS_METHOD_HYBRID\n");
printf("[2] Get location: LOCATIONS_METHOD_GPS\n");
printf("[3] Get location: LOCATIONS_METHOD_WPS\n");
int ret = LOCATIONS_ERROR_NONE;
int basic = 0;
int interval = 1;
+ repeat_count = 0;
print_location_status();
print_menu();
switch (menu) {
case 1:
- basic = 1;
- ret = location_manager_create(LOCATIONS_METHOD_HYBRID, &manager);
- printf("LOCATIONS_METHOD_HYBRID create: %d\n", ret);
- ret = location_manager_start(manager);
- printf("start: %d\n", ret);
- break;
case 2:
+ case 3: {
basic = 1;
- ret = location_manager_create(LOCATIONS_METHOD_GPS, &manager);
- printf("LOCATIONS_METHOD_GPS create: %d\n", ret);
- ret = location_manager_start(manager);
- printf("start: %d\n", ret);
- break;
- case 3:
- basic = 1;
- ret = location_manager_create(LOCATIONS_METHOD_WPS, &manager);
+
+ int method = menu - 1;
+ ret = location_manager_create(method, &manager);
+ printf("location_manager_create (method: %d): %d\n", method, ret);
ret = location_manager_start(manager);
printf("start: %d\n", ret);
+ }
break;
case 4:
case 5:
case 11:
case 12:
case 13: {
- repeat_count = 0;
int interval = 1;
printf("\n Input position interval ==> ");
ret = scanf("%d", &interval);
- int method = menu - 4;
+ int method = menu - 11;
ret = location_manager_create(method, &manager);
printf("location_manager_create (method: %d): %d\n", method, ret);
ret = location_manager_set_position_updated_cb(manager, _position_updated_cb, interval, (void *)manager);
- printf("set position changed callback: %d\n", ret);
+ printf("set_position_updated_cb: %d\n", ret);
/*
ret = location_manager_set_velocity_updated_cb(manager, _velocity_updated_cb, interval*2, (void *)manager);
- printf("set velocity changed callback: %d\n", ret);
+ printf("set_velocity_updated_cb: %d\n", ret);
*/
ret = location_manager_set_location_changed_cb(manager, _location_changed_cb, interval * 2, (void *)manager);
- printf("set location changed callback: %d\n", ret);
+ printf("set_location_changed_cb: %d\n", ret);
ret = location_manager_start(manager);
- repeat_count = 0;
+ printf("start: %d\n", ret);
break;
}
case 21:
case 22:
case 23: {
- repeat_count = 0;
int interval = 1;
int method = menu - 21;
/*printf("set position changed callback: %d\n", ret); */
ret = location_manager_set_distance_based_location_changed_cb(manager, _location_changed_cb, interval, 30, (void *)manager);
- printf("set location changed callback: %d\n", ret);
+ printf("set_distance_based_location_changed_cb: %d\n", ret);
ret = location_manager_start(manager);
+ printf("start: %d\n", ret);
break;
}
case 31: {
- repeat_count = 0;
int interval = 1;
printf("\n Input batch interval ==> ");
ret = scanf("%d", &interval);
printf("location_manager_create (method : %d)\n", LOCATIONS_METHOD_GPS);
ret = location_manager_set_location_batch_cb(manager, _location_batch_cb, interval, period, (void *)manager);
- printf("set location batch callback: %d\n", ret);
+ printf("set_location_batch_cb: %d\n", ret);
ret = location_manager_start_batch(manager);
+ printf("start_batch: %d\n", ret);
break;
}
case 41:
ret = scanf("%d", &onoff);
ret = enable_method(method, onoff);
- printf("Enabling method[%d]: %d\n", method, ret);
+ printf("Enabling method: [%d], ret=%d\n", method, ret);
break;
}
testLocationCoordinates.longitude = 12;
location_bound_error_e nRet = location_bounds_create_polygon(location_coord_list, nPolySize, &hPolyLocationBound);
- printf("location_bounds_create_polygon= %d\n", nRet);
+ printf("location_bounds_create_polygon: %d\n", nRet);
bIsContained = location_bounds_contains_coordinates(hPolyLocationBound, testLocationCoordinates);// Target API
- printf("bIsContained : %d\n", bIsContained);
+ printf("bIsContained: %d\n", bIsContained);
location_bounds_destroy(hPolyLocationBound);
break;
}
case 0:
- g_timeout_add_seconds(0.1, exit_program, NULL);
+ g_timeout_add_seconds(1, exit_program, NULL);
return 0;
default:
printf("Exit!!! Input: %d\n", menu);
- g_timeout_add_seconds(0.1, exit_program, NULL);
+ g_timeout_add_seconds(1, exit_program, NULL);
return 0;
}
if (ret != LOCATIONS_ERROR_NONE) {
printf("Test Failed!!! [%d]\n", ret);
- g_timeout_add_seconds(0.1, exit_program, NULL);
+ g_timeout_add_seconds(1, exit_program, NULL);
return 0;
}
if (menu < 40) {
ret = location_manager_set_service_state_changed_cb(manager, _state_change_cb, (void *)manager);
- printf("set state changed callback: %d\n", ret);
+ printf("set_service_state_changed_cb: %d\n", ret);
if (basic) {
ret = location_manager_set_position_updated_cb(manager, _position_updated_cb, interval, (void *)manager);
- printf("set position changed callback: %d\n", ret);
+ printf("set_position_updated_cb: %d\n", ret);
}
}
else {
- g_timeout_add_seconds(0.1, wait_test, NULL);
+ g_timeout_add_seconds(1, wait_test, NULL);
}
return 0;
printf("stop: %d\n", ret);
ret = location_manager_unset_service_state_changed_cb(manager);
- printf("unset: %d\n", ret);
+ printf("unset_service_state_changed_cb: %d\n", ret);
ret = location_manager_unset_position_updated_cb(manager);
- printf("unset: %d\n", ret);
+ printf("unset_position_updated_cb: %d\n", ret);
ret = location_manager_destroy(manager);
printf("destroy: %d\n", ret);
manager = NULL;
}
- location_manager_unset_setting_changed_cb(LOCATIONS_METHOD_GPS);
- location_manager_unset_setting_changed_cb(LOCATIONS_METHOD_WPS);
}
int main(int argc, char **argv)
projects / platform / core / api / location-manager.git / commitdiff