${MANAGER_DIR}/location-common-util.c
${MANAGER_DIR}/location-gps.c
${MANAGER_DIR}/location-wps.c
- ${MANAGER_DIR}/location-mock.c
${PRIVACY_SRC}
${MODULE_DIR}/module-internal.c
LOCATION_METHOD_HYBRID = 0, /*/< This method selects best method. */
LOCATION_METHOD_GPS, /*/< This method uses Global Positioning System. */
LOCATION_METHOD_WPS, /*/< This method uses Wifi Positioning System. */
- LOCATION_METHOD_MOCK, /* < This method is for mock location */
- LOCATION_METHOD_MOCK_GPS, /* < This method is for mock location */
- LOCATION_METHOD_MOCK_WPS, /* < This method is for mock location */
- LOCATION_METHOD_MAX, /*/< The numer of methods */
+ INTERNAL_METHOD_MOCK, /*/< This method uses mock location. */
+ LOCATION_METHOD_MAX, /*/< The numer of methods */
} LocationMethod;
/**
LocationBoundary *location_boundary_copy(const LocationBoundary *boundary);
/**
- * @brief
- * Add Boundary on LocationFW.
- * You should call this fuction when you want to receive a crossing signal(zone-in/zone-out) from #LocationBoundary.
- * @remarks It supports multi-boundaries. \n
- However a duplicated boundary would not be allowed.
- * @pre
- * #location_new should be called before.\n
+ * @brief Add Boundary on LocationFW. You should call this fuction when you want to receive a crossing signal(zone-in/zone-out) from #LocationBoundary.
+ * @remarks It supports multi-boundaries. However a duplicated boundary would not be allowed.
+ * @pre #location_new should be called before.\n
* @post None.
* @param [in] obj - a #LocationObject
* @param [in] boundary - a #LocationBoundary
* @return int
- * @retval 0 Success
- * Please refer #LocationError for more information.
- * @par Example
- * @code
-#include <location.h>
-
-static void cb_zone_in (GObject *self, gpointer boundary, gpointer position, gpointer accuracy, gpointer user_data)
-{
- g_printf ("[zone-in] position - lat: %f, long: %f", position->latitude, position->longitude);
-}
-
-static void cb_zone_out (GObject *self, gpointer boundary, gpointer position, gpointer accuracy, gpointer user_data)
-{
- g_printf ("[zone-out] position - lat: %f, long: %f", position->latitude, position->longitude);
-}
-
-void location_test_boundary_add(LocationObject *loc)
-{
- LocationPosition* rb = location_position_new (0, 37.300, -121.86, 0, LOCATION_STATUS_2D_FIX);
- LocationPosition* lt = location_position_new (0, 37.360, -121.92, 0, LOCATION_STATUS_2D_FIX);
-
- LoationBoundary *boundary = location_boundary_new_for_rect (lt, rb);
-
- ret = location_boundary_add(loc, boundary);
-
- g_signal_connect(loc, "zone-in", G_CALLBACK(cb_zone_in), NULL);
- g_siganl_connect(loc, "zone-out", G_CALLBACK(cb_zone_out), NULL);
-
- location_position_free(rb);
- location_position_free(lt);
-}
- * @endcode
+ * @retval 0 Success
*/
int location_boundary_add(const LocationObject *obj, const LocationBoundary *boundary);
/**
- * @brief
- * Remove Boundary on LocationFW.
+ * @brief Remove Boundary on LocationFW.
* You should call this function when you don't want to receive a crossing signal(zone-in/zone-out) from #LocationBoundary any more.
* @remarks It supports multi-boundaries.
- * @pre
- * #location_init should be called before.\n
+ * @pre #location_init should be called before.\n
* @post None.
* @param [in] obj - a #LocationObject
* @param [in] boundary - a #LocationBoundary
* @return int
- * @retval 0 Success
- *
- * Please refer #LocationError for more information.
- * @par Example
- * @code
-#include <location.h>
-
-void location_test_boundary_remove(LocationObject *loc)
-{
- int ret = 0;
- LocationPosition* rb = location_position_new (0, 37.300, -121.86, 0, LOCATION_STATUS_2D_FIX);
- LocationPosition* lt = location_position_new (0, 37.360, -121.92, 0, LOCATION_STATUS_2D_FIX);
-
- LoationBoundary *boundary = location_boundary_new_for_rect (lt, rb);
-
- ret = location_boundary_remove(loc, boundary);
-
- location_position_free(rb);
- location_position_free(lt);
-
-}
- * @endcode
+ * @retval 0 Success
*/
int location_boundary_remove(const LocationObject *obj, const LocationBoundary *boundary);
/**
- * @brief
- * Call a function for each element of a Boundary list.
+ * @brief Call a function for each element of a Boundary list.
* @remarks None.
- * @pre
- * #location_init should be called before.\n
+ * @pre #location_init should be called before.\n
* @post None.
* @param [in] obj - a #LocationObject
* @param [in] func - a #LocationBoundaryFunc
* @param [in] user_data - a #void
* @return int
- * @retval 0 Success
- *
- * Please refer #LocationError for more information.
- * @par Example
- * @code
-#include <location.h>
-
-static void remove_boundary(LocationBoundary *boundary, void *user_data)
-{
- LocationBoundary *loc = (LocationBoundary *) user_data;
- if (loc == NULL || boundary == NULL) return;
-
- location_boundary_remove(loc, boundary);
-}
-
-void location_test_boundary_foreach(LocationObject *loc)
-{
- int ret = location_boundary_foreach(loc, remove_boundary, loc);
-}
- * @endcode
+ * @retval 0 Success
*/
int location_boundary_foreach(const LocationObject *obj, LocationBoundaryFunc func, gpointer user_data);
* @post None.* @param [in] boundary - a #LocationBoundary
* @param [in] position - a #LocationPosition
* @return gboolean
- * @retval\n
- * TRUE - if inside\n
- * FALSE - if outside\n
- * @par Example
- * @code
-#include <location.h>
-
-void location_test_boundary_if_inside(LocationObject *loc, LocationBoundary *boundary)
-{
- gboolean is_inside = FALSE;
- LocationPosition* position = location_position_new (0, 37.300, -121.86, 0, LOCATION_STATUS_2D_FIX);
- is_inside = location_boundary_if_inside(boundary, position);
- if (is_inside == TRUE) g_printf("The position is inside of the boundary\n");
- else g_printf("The position is outside of the boundary\n");
-
-}
- * @endcode
-
+ * @retval\n TRUE - if inside\n FALSE - if outside\n
*/
gboolean location_boundary_if_inside(LocationBoundary *boundary, LocationPosition *position);
const char* err_msg(int err);
-#define LOCATION_IF_POS_FAIL(path) {\
- int state = 0; \
+#define LOCATION_IF_POS_FAIL(path) { \
+ int state = 0, mock; \
+ vconf_get_int(VCONFKEY_LOCATION_MOCK_ENABLED, &mock); \
vconf_get_int(path, &state); \
- if (state != 2){\
- return LOCATION_ERROR_NOT_AVAILABLE;\
- }\
+ if (state != 2 && mock != 1) { \
+ return LOCATION_ERROR_NOT_AVAILABLE; \
+ } \
}
#define LOCATION_IF_HYBRID_FAIL(gpath, wpath) { \
int gps = 0; vconf_get_int(gpath, &gps); \
int wps = 0; vconf_get_int(wpath, &wps); \
- if (gps != 2 && wps != 2) {\
- return LOCATION_ERROR_NOT_AVAILABLE;\
- }\
+ int mock = 0; vconf_get_int(VCONFKEY_LOCATION_MOCK_ENABLED, &mock); \
+ if (gps != 2 && wps != 2 && mock != 1) { \
+ return LOCATION_ERROR_NOT_AVAILABLE; \
+ } \
}
G_END_DECLS
GMutex mutex;
gboolean is_started;
gboolean is_batch_invoked;
+ gboolean is_mock;
guint app_type;
gboolean set_noti;
gboolean enabled;
if (priv->min_interval != LOCATION_UPDATE_INTERVAL_NONE) {
distance_based_position_signaling(self, signals, enabled, pos, vel, acc,
priv->min_interval, priv->min_distance, &(priv->enabled),
- &(priv->dist_updated_timestamp),&(priv->pos), &(priv->vel), &(priv->acc));
+ &(priv->dist_updated_timestamp), &(priv->pos), &(priv->vel), &(priv->acc));
}
location_signaling(self, signals, enabled, priv->boundary_list, pos, vel, acc,
priv->pos_interval, priv->vel_interval, priv->loc_interval, &(priv->enabled),
g_return_if_fail(priv);
if (location_setting_get_key_val(key) == VCONFKEY_LOCATION_GPS_SEARCHING) {
- LOCATION_LOGD("enable_signaling : SERVICE_DISABLED");
- enable_signaling(self, signals, &(priv->enabled), FALSE, LOCATION_STATUS_NO_FIX);
+ if (!location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED)) {
+ LOCATION_LOGD("enable_signaling : SERVICE_DISABLED");
+ enable_signaling(self, signals, &(priv->enabled), FALSE, LOCATION_STATUS_NO_FIX);
+ }
}
}
#endif
static void location_gps_dispose(GObject *gobject)
{
LOC_FUNC_LOG
-
LocationGpsPrivate *priv = GET_PRIVATE(gobject);
g_return_if_fail(priv);
g_mutex_clear(&priv->mutex);
if (priv->loc_timeout) g_source_remove(priv->loc_timeout);
priv->loc_timeout = 0;
+ if (priv->is_mock) {
+ priv->mod->ops.clear_mock_location(priv->mod->handler, NULL, gobject);
+ priv->is_mock = FALSE;
+ }
+
if (priv->app_type != CPPAPP && priv->set_noti == TRUE) {
location_setting_ignore_notify(VCONFKEY_LOCATION_ENABLED, location_setting_gps_cb);
#ifdef TIZEN_PROFILE_MOBILE
int ret = 0;
switch (property_id) {
case PROP_BOUNDARY: {
- GList *boundary_list = g_list_copy(g_value_get_pointer(value));
- ret = set_prop_boundary(&priv->boundary_list, boundary_list);
- LOC_IF_FAIL_LOG(ret, _E, "Set boundary. Error[%s]", err_msg(ret));
- if (boundary_list) g_list_free(boundary_list);
- break;
- }
+ GList *boundary_list = g_list_copy(g_value_get_pointer(value));
+ ret = set_prop_boundary(&priv->boundary_list, boundary_list);
+ LOC_IF_FAIL_LOG(ret, _E, "Set boundary. Error[%s]", err_msg(ret));
+ if (boundary_list) g_list_free(boundary_list);
+ break;
+ }
case PROP_REMOVAL_BOUNDARY: {
- LocationBoundary *req_boundary = (LocationBoundary *) g_value_dup_boxed(value);
- ret = set_prop_removal_boundary(&priv->boundary_list, req_boundary);
- LOC_IF_FAIL_LOG(ret, _E, "Removal boundary. Error[%s]", err_msg(ret));
- break;
- }
+ LocationBoundary *req_boundary = (LocationBoundary *) g_value_dup_boxed(value);
+ ret = set_prop_removal_boundary(&priv->boundary_list, req_boundary);
+ LOC_IF_FAIL_LOG(ret, _E, "Removal boundary. Error[%s]", err_msg(ret));
+ break;
+ }
case PROP_POS_INTERVAL: {
- guint interval = g_value_get_uint(value);
- LOCATION_LOGD("Set prop>> PROP_POS_INTERVAL: %u", interval);
- /* We don't need to set interval when new one is same as the previous one */
- if (interval == priv->pos_interval) break;
-
- if (interval > 0) {
- if (interval < LOCATION_UPDATE_INTERVAL_MAX)
- priv->pos_interval = interval;
- else
- priv->pos_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
- } else {
- priv->pos_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
- }
-
- if (__get_started(object) == TRUE) {
- LOCATION_LOGD("[update_pos_interval]: update pos-interval while pos-tracking");
- g_return_if_fail(priv->mod->ops.set_position_update_interval);
- priv->mod->ops.set_position_update_interval(priv->mod->handler, priv->pos_interval);
- }
-
- break;
- }
+ guint interval = g_value_get_uint(value);
+ LOCATION_LOGD("Set prop>> PROP_POS_INTERVAL: %u", interval);
+ /* We don't need to set interval when new one is same as the previous one */
+ if (interval == priv->pos_interval) break;
+
+ if (interval > 0) {
+ if (interval < LOCATION_UPDATE_INTERVAL_MAX)
+ priv->pos_interval = interval;
+ else
+ priv->pos_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
+ } else {
+ priv->pos_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
+ }
+
+ if (__get_started(object) == TRUE) {
+ LOCATION_LOGD("[update_pos_interval]: update pos-interval while pos-tracking");
+ g_return_if_fail(priv->mod->ops.set_position_update_interval);
+ priv->mod->ops.set_position_update_interval(priv->mod->handler, priv->pos_interval);
+ }
+ break;
+ }
case PROP_VEL_INTERVAL: {
- guint interval = g_value_get_uint(value);
- LOCATION_LOGD("Set prop>> PROP_VEL_INTERVAL: %u", interval);
- if (interval == priv->vel_interval) break;
-
- if (interval > 0) {
- if (interval < LOCATION_UPDATE_INTERVAL_MAX)
- priv->vel_interval = interval;
- else
- priv->vel_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
- } else
- priv->vel_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
-
- break;
- }
+ guint interval = g_value_get_uint(value);
+ LOCATION_LOGD("Set prop>> PROP_VEL_INTERVAL: %u", interval);
+ if (interval == priv->vel_interval) break;
+
+ if (interval > 0) {
+ if (interval < LOCATION_UPDATE_INTERVAL_MAX)
+ priv->vel_interval = interval;
+ else
+ priv->vel_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
+ } else {
+ priv->vel_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
+ }
+ break;
+ }
case PROP_SAT_INTERVAL: {
- guint interval = g_value_get_uint(value);
- LOCATION_LOGD("Set prop>> PROP_SAT_INTERVAL: %u", interval);
- if (interval > 0) {
- if (interval < LOCATION_UPDATE_INTERVAL_MAX)
- priv->sat_interval = interval;
- else
- priv->sat_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
- } else
- priv->sat_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
-
- break;
- }
+ guint interval = g_value_get_uint(value);
+ LOCATION_LOGD("Set prop>> PROP_SAT_INTERVAL: %u", interval);
+ if (interval > 0) {
+ if (interval < LOCATION_UPDATE_INTERVAL_MAX)
+ priv->sat_interval = interval;
+ else
+ priv->sat_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
+ } else {
+ priv->sat_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
+ }
+ break;
+ }
case PROP_LOC_INTERVAL: {
- guint interval = g_value_get_uint(value);
- LOCATION_LOGD("Set prop>> PROP_LOC_INTERVAL: %u", interval);
- if (interval > 0) {
- if (interval < LOCATION_UPDATE_INTERVAL_MAX)
- priv->loc_interval = interval;
- else
- priv->loc_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
- } else
- priv->loc_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
-
- break;
- }
+ guint interval = g_value_get_uint(value);
+ LOCATION_LOGD("Set prop>> PROP_LOC_INTERVAL: %u", interval);
+ if (interval > 0) {
+ if (interval < LOCATION_UPDATE_INTERVAL_MAX)
+ priv->loc_interval = interval;
+ else
+ priv->loc_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
+ } else {
+ priv->loc_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
+ }
+ break;
+ }
case PROP_BATCH_INTERVAL: {
- guint interval = g_value_get_uint(value);
- LOCATION_LOGD("Set prop>> PROP_BATCH_INTERVAL: %u", interval);
- if (interval > 0) {
- if (interval < LOCATION_BATCH_INTERVAL_MAX)
- priv->batch_interval = interval;
- else
- priv->batch_interval = (guint)LOCATION_BATCH_INTERVAL_MAX;
- } else
- priv->batch_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
-
- if (__get_started(object) == TRUE) {
- LOCATION_LOGD("[update_batch_interval]: update batch-interval while pos-tracking");
- g_return_if_fail(priv->mod->ops.set_position_update_interval);
- priv->mod->ops.set_position_update_interval(priv->mod->handler, priv->batch_interval);
- }
- break;
- }
+ guint interval = g_value_get_uint(value);
+ LOCATION_LOGD("Set prop>> PROP_BATCH_INTERVAL: %u", interval);
+ if (interval > 0) {
+ if (interval < LOCATION_BATCH_INTERVAL_MAX)
+ priv->batch_interval = interval;
+ else
+ priv->batch_interval = (guint)LOCATION_BATCH_INTERVAL_MAX;
+ } else {
+ priv->batch_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
+ }
+
+ if (__get_started(object) == TRUE) {
+ LOCATION_LOGD("[update_batch_interval]: update batch-interval while pos-tracking");
+ g_return_if_fail(priv->mod->ops.set_position_update_interval);
+ priv->mod->ops.set_position_update_interval(priv->mod->handler, priv->batch_interval);
+ }
+ break;
+ }
case PROP_BATCH_PERIOD: {
- guint interval = g_value_get_uint(value);
- LOCATION_LOGD("Set prop>> PROP_BATCH_PERIOD: %u", interval);
- if (interval > 0) {
- if (interval < LOCATION_BATCH_PERIOD_MAX)
- priv->batch_period = interval;
- else
- priv->batch_period = (guint)LOCATION_BATCH_PERIOD_MAX;
- } else
- priv->batch_period = (guint)LOCATION_BATCH_PERIOD_DEFAULT;
-
- break;
- }
+ guint interval = g_value_get_uint(value);
+ LOCATION_LOGD("Set prop>> PROP_BATCH_PERIOD: %u", interval);
+ if (interval > 0) {
+ if (interval < LOCATION_BATCH_PERIOD_MAX)
+ priv->batch_period = interval;
+ else
+ priv->batch_period = (guint)LOCATION_BATCH_PERIOD_MAX;
+ } else {
+ priv->batch_period = (guint)LOCATION_BATCH_PERIOD_DEFAULT;
+ }
+ break;
+ }
case PROP_MIN_INTERVAL: {
- guint interval = g_value_get_uint(value);
- LOCATION_LOGD("Set prop>> PROP_MIN_INTERVAL: %u", interval);
- if (interval > 0) {
- if (interval < LOCATION_MIN_INTERVAL_MAX)
- priv->min_interval = interval;
- else
- priv->min_interval = (guint)LOCATION_MIN_INTERVAL_MAX;
- } else
- priv->min_interval = (guint)LOCATION_MIN_INTERVAL_DEFAULT;
-
- break;
- }
+ guint interval = g_value_get_uint(value);
+ LOCATION_LOGD("Set prop>> PROP_MIN_INTERVAL: %u", interval);
+ if (interval > 0) {
+ if (interval < LOCATION_MIN_INTERVAL_MAX)
+ priv->min_interval = interval;
+ else
+ priv->min_interval = (guint)LOCATION_MIN_INTERVAL_MAX;
+ } else {
+ priv->min_interval = (guint)LOCATION_MIN_INTERVAL_DEFAULT;
+ }
+ break;
+ }
case PROP_MIN_DISTANCE: {
- gdouble distance = g_value_get_double(value);
- LOCATION_LOGD("Set prop>> PROP_MIN_DISTANCE: %u", distance);
- if (distance > 0) {
- if (distance < LOCATION_MIN_DISTANCE_MAX)
- priv->min_distance = distance;
- else
- priv->min_distance = (gdouble)LOCATION_MIN_DISTANCE_MAX;
- } else
- priv->min_distance = (gdouble)LOCATION_MIN_DISTANCE_DEFAULT;
-
- break;
- }
+ gdouble distance = g_value_get_double(value);
+ LOCATION_LOGD("Set prop>> PROP_MIN_DISTANCE: %u", distance);
+ if (distance > 0) {
+ if (distance < LOCATION_MIN_DISTANCE_MAX)
+ priv->min_distance = distance;
+ else
+ priv->min_distance = (gdouble)LOCATION_MIN_DISTANCE_MAX;
+ } else {
+ priv->min_distance = (gdouble)LOCATION_MIN_DISTANCE_DEFAULT;
+ }
+
+ break;
+ }
case PROP_SERVICE_STATUS: {
- gint enabled = g_value_get_int(value);
- LOCATION_LOGD("Set prop>> PROP_SERVICE_STATUS: %u", enabled);
- priv->enabled = enabled;
- break;
- }
+ gint enabled = g_value_get_int(value);
+ LOCATION_LOGD("Set prop>> PROP_SERVICE_STATUS: %u", enabled);
+ priv->enabled = enabled;
+ break;
+ }
default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
- break;
+ G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
+ break;
}
}
g_value_set_pointer(value, g_list_first(priv->boundary_list));
break;
case PROP_NMEA: {
- char *nmea_data = NULL;
- if (ops.get_nmea && LOCATION_ERROR_NONE == ops.get_nmea(priv->mod->handler, &nmea_data) && nmea_data) {
- LOCATION_SECLOG("Get prop>> Lastest nmea: \n%s", nmea_data);
- g_value_set_string(value, nmea_data);
- g_free(nmea_data);
- } else {
- LOCATION_LOGW("Get prop>> Lastest nmea: failed");
- g_value_set_string(value, NULL);
- }
- break;
+ char *nmea_data = NULL;
+ if (ops.get_nmea && LOCATION_ERROR_NONE == ops.get_nmea(priv->mod->handler, &nmea_data) && nmea_data) {
+ LOCATION_SECLOG("Get prop>> Lastest nmea: \n%s", nmea_data);
+ g_value_set_string(value, nmea_data);
+ g_free(nmea_data);
+ } else {
+ LOCATION_LOGW("Get prop>> Lastest nmea: failed");
+ g_value_set_string(value, NULL);
}
+ break;
+ }
case PROP_SATELLITE: {
- LocationSatellite *satellite = NULL;
- if (ops.get_satellite && priv->mod->handler && LOCATION_ERROR_NONE == ops.get_satellite(priv->mod->handler, &satellite) && satellite) {
- LOCATION_LOGD("Get prop>> Last sat: num_used(%d) num_view(%d)", satellite->num_of_sat_used, satellite->num_of_sat_inview);
- g_value_set_boxed(value, satellite);
- location_satellite_free(satellite);
- } else {
- LOCATION_LOGW("Get prop>> Last sat: failed");
- g_value_set_boxed(value, NULL);
- }
- break;
+ LocationSatellite *satellite = NULL;
+ if (ops.get_satellite && priv->mod->handler && LOCATION_ERROR_NONE == ops.get_satellite(priv->mod->handler, &satellite) && satellite) {
+ LOCATION_LOGD("Get prop>> Last sat: num_used(%d) num_view(%d)", satellite->num_of_sat_used, satellite->num_of_sat_inview);
+ g_value_set_boxed(value, satellite);
+ location_satellite_free(satellite);
+ } else {
+ LOCATION_LOGW("Get prop>> Last sat: failed");
+ g_value_set_boxed(value, NULL);
}
+ break;
+ }
case PROP_SERVICE_STATUS:
g_value_set_int(value, priv->enabled);
break;
return ret;
}
+static int
+location_gps_set_mock_location(LocationGps *self, LocationPosition *position, LocationVelocity *velocity, LocationAccuracy *accuracy)
+{
+ LOC_FUNC_LOG
+ LocationGpsPrivate *priv = GET_PRIVATE(self);
+ g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
+ g_return_val_if_fail(priv->mod->ops.set_mock_location, LOCATION_ERROR_NOT_AVAILABLE);
+
+ int ret = LOCATION_ERROR_NONE;
+ if (!location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED)) {
+ ret = LOCATION_ERROR_SETTING_OFF;
+ } else {
+ ret = priv->mod->ops.set_mock_location(priv->mod->handler, position, velocity, accuracy, NULL, self);
+ LOC_IF_FAIL_LOG(ret, _E, "Failed to set_mock_location [%s]", err_msg(ret));
+ priv->is_mock = TRUE;
+ }
+
+ return ret;
+}
+
+static int
+location_gps_clear_mock_location(LocationGps *self)
+{
+ LOC_FUNC_LOG
+ LocationGpsPrivate *priv = GET_PRIVATE(self);
+ g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
+ g_return_val_if_fail(priv->mod->ops.clear_mock_location, LOCATION_ERROR_NOT_AVAILABLE);
+
+ int ret = LOCATION_ERROR_NONE;
+ if (!location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED)) {
+ ret = LOCATION_ERROR_SETTING_OFF;
+ } else {
+ ret = priv->mod->ops.clear_mock_location(priv->mod->handler, NULL, self);
+ LOC_IF_FAIL_LOG(ret, _E, "Failed to clear_mock_location [%s]", err_msg(ret));
+ priv->is_mock = FALSE;
+ }
+
+ return ret;
+}
+
static void location_ielement_interface_init(LocationIElementInterface *iface)
{
iface->start = (TYPE_START_FUNC)location_gps_start;
iface->get_batch = (TYPE_GET_BATCH)location_gps_get_batch;
iface->start_batch = (TYPE_START_BATCH)location_gps_start_batch;
iface->stop_batch = (TYPE_STOP_BATCH)location_gps_stop_batch;
-
iface->request_single_location = (TYPE_REQUEST_SINGLE_LOCATION)location_gps_request_single_location;
iface->get_nmea = (TYPE_GET_NMEA)location_gps_get_nmea;
-
+ iface->set_mock_location = (TYPE_SET_MOCK_LOCATION) location_gps_set_mock_location;
+ iface->clear_mock_location = (TYPE_CLEAR_MOCK_LOCATION) location_gps_clear_mock_location;
}
static void location_gps_init(LocationGps *self)
g_mutex_init(&priv->mutex);
priv->is_started = FALSE;
priv->is_batch_invoked = FALSE;
+ priv->is_mock = FALSE;
priv->set_noti = FALSE;
priv->enabled = FALSE;
priv->signal_type = 0;
g_type_class_add_private(klass, sizeof(LocationGpsPrivate));
- signals[SERVICE_ENABLED] = g_signal_new("service-enabled",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationGpsClass, enabled),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
-
- signals[SERVICE_DISABLED] = g_signal_new("service-disabled",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationGpsClass, disabled),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
+ signals[SERVICE_ENABLED] =
+ g_signal_new("service-enabled", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationGpsClass, enabled),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
+
+ signals[SERVICE_DISABLED] =
+ g_signal_new("service-disabled", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationGpsClass, disabled),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
#if 0 /* TODO: STATUS_CHANGED will aggregate SERVICE_ENABLED and SERVICE_DISABLED */
- signals[STATUS_CHANGED] = g_signal_new("status-changed",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationGpsClass, status_changed),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
+ signals[STATUS_CHANGED] =
+ g_signal_new("status-changed", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationGpsClass, status_changed),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
#endif
- signals[SERVICE_UPDATED] = g_signal_new("service-updated",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationGpsClass, service_updated),
- NULL, NULL,
- location_VOID__INT_POINTER_POINTER_POINTER,
- G_TYPE_NONE, 4,
- G_TYPE_INT,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[LOCATION_UPDATED] = g_signal_new("location-updated",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationGpsClass, location_updated),
- NULL, NULL,
- location_VOID__INT_POINTER_POINTER_POINTER,
- G_TYPE_NONE, 4,
- G_TYPE_INT,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[BATCH_UPDATED] = g_signal_new("batch-updated",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationGpsClass, batch_updated),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
-
- signals[ZONE_IN] = g_signal_new("zone-in",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationGpsClass, zone_in),
- NULL, NULL,
- location_VOID__POINTER_POINTER_POINTER,
- G_TYPE_NONE, 3,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[ZONE_OUT] = g_signal_new("zone-out",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationGpsClass, zone_out),
- NULL, NULL,
- location_VOID__POINTER_POINTER_POINTER,
- G_TYPE_NONE, 3,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- properties[PROP_METHOD_TYPE] = g_param_spec_int("method",
- "method type",
- "location method type name",
- LOCATION_METHOD_GPS,
- LOCATION_METHOD_GPS,
- LOCATION_METHOD_GPS,
- G_PARAM_READABLE);
-
- properties[PROP_IS_STARTED] = g_param_spec_boolean("is_started",
- "gps is started prop",
- "gps is started status",
- FALSE,
- G_PARAM_READWRITE);
-
- properties[PROP_LAST_POSITION] = g_param_spec_boxed("last-position",
- "gps last position prop",
- "gps last position data",
- LOCATION_TYPE_POSITION,
- G_PARAM_READABLE);
-
- properties[PROP_POS_INTERVAL] = g_param_spec_uint("pos-interval",
- "gps position interval prop",
- "gps position interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_VEL_INTERVAL] = g_param_spec_uint("vel-interval",
- "gps velocity interval prop",
- "gps velocity interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_SAT_INTERVAL] = g_param_spec_uint("sat-interval",
- "gps satellite interval prop",
- "gps satellite interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_LOC_INTERVAL] = g_param_spec_uint("loc-interval",
- "gps location interval prop",
- "gps location interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_BATCH_INTERVAL] = g_param_spec_uint("batch-interval",
- "gps batch interval interval prop",
- "gps batch interval interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_BATCH_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_BATCH_PERIOD] = g_param_spec_uint("batch-period",
- "gps batch period prop",
- "gps batch period data",
- LOCATION_BATCH_PERIOD_MIN,
- LOCATION_BATCH_PERIOD_MAX,
- LOCATION_BATCH_PERIOD_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_MIN_INTERVAL] = g_param_spec_uint("min-interval",
- "gps distance-based interval prop",
- "gps distance-based interval data",
- LOCATION_MIN_INTERVAL_MIN,
- LOCATION_MIN_INTERVAL_MAX,
- LOCATION_MIN_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_MIN_DISTANCE] = g_param_spec_double("min-distance",
- "gps distance-based distance prop",
- "gps distance-based distance data",
- LOCATION_MIN_DISTANCE_MIN,
- LOCATION_MIN_DISTANCE_MAX,
- LOCATION_MIN_DISTANCE_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_BOUNDARY] = g_param_spec_pointer("boundary",
- "gps boundary prop",
- "gps boundary data",
- G_PARAM_READWRITE);
-
- properties[PROP_REMOVAL_BOUNDARY] = g_param_spec_boxed("removal-boundary",
- "gps removal boundary prop",
- "gps removal boundary data",
- LOCATION_TYPE_BOUNDARY,
- G_PARAM_READWRITE);
-
-
- properties[PROP_NMEA] = g_param_spec_string("nmea",
- "gps NMEA name prop",
- "gps NMEA",
- NULL,
- G_PARAM_READABLE);
-
- properties[PROP_SATELLITE] = g_param_spec_boxed("satellite",
- "gps satellite prop",
- "gps satellite data",
- LOCATION_TYPE_SATELLITE,
- G_PARAM_READABLE);
-
- /* Tizen 3.0 */
- properties[PROP_SERVICE_STATUS] = g_param_spec_int("service-status",
- "location service status prop",
- "location service status data",
- LOCATION_STATUS_NO_FIX,
- LOCATION_STATUS_3D_FIX,
- LOCATION_STATUS_NO_FIX,
- G_PARAM_READABLE);
+ signals[SERVICE_UPDATED] =
+ g_signal_new("service-updated", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationGpsClass, service_updated),
+ NULL, NULL, location_VOID__INT_POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 4, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ signals[LOCATION_UPDATED] =
+ g_signal_new("location-updated", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationGpsClass, location_updated),
+ NULL, NULL, location_VOID__INT_POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 4, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ signals[BATCH_UPDATED] =
+ g_signal_new("batch-updated", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationGpsClass, batch_updated),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
+
+ signals[ZONE_IN] =
+ g_signal_new("zone-in", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationGpsClass, zone_in),
+ NULL, NULL, location_VOID__POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ signals[ZONE_OUT] =
+ g_signal_new("zone-out", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationGpsClass, zone_out),
+ NULL, NULL, location_VOID__POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ properties[PROP_METHOD_TYPE] =
+ g_param_spec_int("method", "method type", "location method type name",
+ LOCATION_METHOD_GPS, LOCATION_METHOD_GPS, LOCATION_METHOD_GPS, G_PARAM_READABLE);
+
+ properties[PROP_IS_STARTED] =
+ g_param_spec_boolean("is_started", "gps is started prop",
+ "gps is started status", FALSE, G_PARAM_READWRITE);
+
+ properties[PROP_LAST_POSITION] =
+ g_param_spec_boxed("last-position", "gps last position prop",
+ "gps last position data", LOCATION_TYPE_POSITION, G_PARAM_READABLE);
+
+ properties[PROP_POS_INTERVAL] =
+ g_param_spec_uint("pos-interval", "gps position interval prop",
+ "gps position interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_VEL_INTERVAL] =
+ g_param_spec_uint("vel-interval", "gps velocity interval prop",
+ "gps velocity interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_SAT_INTERVAL] =
+ g_param_spec_uint("sat-interval", "gps satellite interval prop",
+ "gps satellite interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_LOC_INTERVAL] =
+ g_param_spec_uint("loc-interval", "gps location interval prop",
+ "gps location interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_BATCH_INTERVAL] =
+ g_param_spec_uint("batch-interval", "gps batch interval interval prop",
+ "gps batch interval interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_BATCH_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_BATCH_PERIOD] =
+ g_param_spec_uint("batch-period", "gps batch period prop",
+ "gps batch period data", LOCATION_BATCH_PERIOD_MIN,
+ LOCATION_BATCH_PERIOD_MAX, LOCATION_BATCH_PERIOD_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_MIN_INTERVAL] =
+ g_param_spec_uint("min-interval", "gps distance-based interval prop",
+ "gps distance-based interval data", LOCATION_MIN_INTERVAL_MIN,
+ LOCATION_MIN_INTERVAL_MAX, LOCATION_MIN_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_MIN_DISTANCE] =
+ g_param_spec_double("min-distance", "gps distance-based distance prop",
+ "gps distance-based distance data", LOCATION_MIN_DISTANCE_MIN,
+ LOCATION_MIN_DISTANCE_MAX, LOCATION_MIN_DISTANCE_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_BOUNDARY] =
+ g_param_spec_pointer("boundary", "gps boundary prop",
+ "gps boundary data", G_PARAM_READWRITE);
+
+ properties[PROP_REMOVAL_BOUNDARY] =
+ g_param_spec_boxed("removal-boundary", "gps removal boundary prop",
+ "gps removal boundary data", LOCATION_TYPE_BOUNDARY, G_PARAM_READWRITE);
+
+ properties[PROP_NMEA] =
+ g_param_spec_string("nmea", "gps NMEA name prop", "gps NMEA",
+ NULL, G_PARAM_READABLE);
+
+ properties[PROP_SATELLITE] =
+ g_param_spec_boxed("satellite", "gps satellite prop",
+ "gps satellite data", LOCATION_TYPE_SATELLITE, G_PARAM_READABLE);
+
+ properties[PROP_SERVICE_STATUS] =
+ g_param_spec_int("service-status", "location service status prop",
+ "location service status data", LOCATION_STATUS_NO_FIX,
+ LOCATION_STATUS_3D_FIX, LOCATION_STATUS_NO_FIX, G_PARAM_READABLE);
+
g_object_class_install_properties(gobject_class, PROP_MAX, properties);
}
#include "location-gps.h"
#include "location-wps.h"
-/* Tizen 3.0 */
-#include "location-mock.h"
typedef struct _LocationHybridPrivate {
gboolean gps_enabled;
gboolean set_noti;
guint pos_timer;
guint vel_timer;
-
- /* Tizen 3.0 */
- gboolean mock_enabled;
- LocationObject *mock;
} LocationHybridPrivate;
enum {
priv->current_method = LOCATION_METHOD_GPS;
else if (g_type == LOCATION_TYPE_WPS)
priv->current_method = LOCATION_METHOD_WPS;
- else if (g_type == LOCATION_TYPE_MOCK)
- priv->current_method = LOCATION_METHOD_MOCK;
else if (g_type == LOCATION_TYPE_HYBRID)
priv->current_method = LOCATION_METHOD_HYBRID;
else
static int
hybrid_get_update_method(LocationHybridPrivate *priv)
{
- if (!priv->gps && !priv->wps & !priv->mock)
+ if (!priv->gps && !priv->wps)
return -1;
if (priv->gps_enabled)
hybrid_set_current_method(priv, LOCATION_TYPE_GPS);
else if (priv->wps_enabled)
hybrid_set_current_method(priv, LOCATION_TYPE_WPS);
- else if (priv->mock_enabled)
- hybrid_set_current_method(priv, LOCATION_TYPE_MOCK);
else
hybrid_set_current_method(priv, LOCATION_TYPE_HYBRID);
static gboolean /* True : Receive more accurate info. False : Receive less accurate info */
hybrid_compare_g_type_method(LocationHybridPrivate *priv, GType g_type)
{
- if (location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED) == 1 &&
- location_setting_get_int(VCONFKEY_LOCATION_MOCK_STATE) == VCONFKEY_LOCATION_POSITION_CONNECTED) {
- if (g_type == LOCATION_TYPE_MOCK) {
- hybrid_set_current_method(priv, LOCATION_TYPE_MOCK);
- return TRUE;
- }
- } else {
- if (g_type == LOCATION_TYPE_GPS) {
- hybrid_set_current_method(priv, LOCATION_TYPE_GPS);
- return TRUE;
- } else if (g_type == LOCATION_TYPE_WPS &&
- (hybrid_get_current_method(priv) == LOCATION_METHOD_WPS || hybrid_get_current_method(priv) == LOCATION_METHOD_MOCK)) {
- hybrid_set_current_method(priv, LOCATION_TYPE_WPS);
- return TRUE;
- }
+ if (g_type == LOCATION_TYPE_GPS) {
+ hybrid_set_current_method(priv, LOCATION_TYPE_GPS);
+ return TRUE;
+ } else if (g_type == LOCATION_TYPE_WPS && hybrid_get_current_method(priv) == LOCATION_METHOD_WPS) {
+ hybrid_set_current_method(priv, LOCATION_TYPE_WPS);
+ return TRUE;
}
return FALSE;
}
int ret = LOCATION_ERROR_NONE;
if (type == SATELLITE_UPDATED) {
- sat = (LocationSatellite *)data;
+ sat = (LocationSatellite *) data;
if (!sat->timestamp) return;
} else {
- pos = (LocationPosition *)data;
- vel = (LocationVelocity *)velocity;
- acc = (LocationAccuracy *)accuracy;
+ pos = (LocationPosition *) data;
+ vel = (LocationVelocity *) velocity;
+ acc = (LocationAccuracy *) accuracy;
if (!pos->timestamp) return;
if (!vel->timestamp) return;
}
if (type == SATELLITE_UPDATED) {
satellite_signaling(self, signals, &(priv->enabled), priv->sat_interval, TRUE, &(priv->sat_updated_timestamp), &(priv->sat), sat);
return;
- } else if (location_setting_get_int(VCONFKEY_LOCATION_GPS_STATE) == VCONFKEY_LOCATION_GPS_SEARCHING) {
+ } else if (location_setting_get_int(VCONFKEY_LOCATION_GPS_STATE) == VCONFKEY_LOCATION_GPS_SEARCHING
+ && location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED) == 0) {
LOCATION_LOGD("Searching GPS");
/* restart WPS when GPS not available */
priv->gps_enabled = TRUE;
} else if (g_type == LOCATION_TYPE_WPS) {
priv->wps_enabled = TRUE;
- } else if (g_type == LOCATION_TYPE_MOCK) {
- priv->mock_enabled = TRUE;
} else {
LOCATION_LOGW("Undefined GType enabled");
return;
priv->gps_enabled = FALSE;
} else if (g_type == LOCATION_TYPE_WPS) {
priv->wps_enabled = FALSE;
- } else if (g_type == LOCATION_TYPE_MOCK) {
- priv->mock_enabled = FALSE;
} else {
LOCATION_LOGW("Undefined GType disabled");
return;
}
hybrid_get_update_method(priv);
+ if (!priv->gps_enabled && !priv->wps_enabled)
+ enable_signaling(self, signals, &(priv->enabled), FALSE, status);
- if (location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED) == 1) {
- if (!priv->gps_enabled && !priv->wps_enabled && !priv->mock_enabled)
- enable_signaling(self, signals, &(priv->enabled), FALSE, status);
- } else {
- if (!priv->gps_enabled && !priv->wps_enabled)
- enable_signaling(self, signals, &(priv->enabled), FALSE, status);
- }
}
#if 0
priv->gps_enabled = FALSE;
} else if (g_type == LOCATION_TYPE_WPS) {
priv->wps_enabled = FALSE;
- } else if (g_type == LOCATION_TYPE_MOCK) {
- priv->mock_enabled = FALSE;
} else {
LOCATION_LOGW("Undefined GType disabled");
return;
priv->gps_enabled = TRUE;
} else if (g_type == LOCATION_TYPE_WPS) {
priv->wps_enabled = TRUE;
- } else if (g_type == LOCATION_TYPE_MOCK) {
- priv->mock_enabled = TRUE;
} else {
LOCATION_LOGW("Undefined GType enabled");
return;
break;
case LOCATION_STATUS_MOCK_SET:
- LOCATION_LOGD("Succeeded set mock location!!!");
- break;
-
- case LOCATION_STATUS_MOCK_FAIL:
- if (g_type == LOCATION_TYPE_GPS) {
- priv->gps_enabled = FALSE;
- } else if (g_type == LOCATION_TYPE_WPS) {
- priv->wps_enabled = FALSE;
- } else {
- LOCATION_LOGW("Undefined GType disabled");
- return;
- }
- hybrid_get_update_method(priv);
- if (!priv->gps_enabled && !priv->wps_enabled)
- enable_signaling(self, signals, &(priv->enabled), FALSE, status);
break;
default:
int ret_gps = LOCATION_ERROR_NONE;
int ret_wps = LOCATION_ERROR_NONE;
- int ret_mock = LOCATION_ERROR_NONE;
gboolean gps_started = FALSE;
gboolean wps_started = FALSE;
- gboolean mock_started = FALSE;
LocationHybridPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
if (priv->gps) g_object_get(priv->gps, "is_started", &gps_started, NULL);
if (priv->wps) g_object_get(priv->wps, "is_started", &wps_started, NULL);
- if (priv->mock) g_object_get(priv->mock, "is_started", &mock_started, NULL);
- if ((gps_started == TRUE) || (wps_started == TRUE) || (mock_started == TRUE)) {
+ if ((gps_started == TRUE) || (wps_started == TRUE)) {
LOCATION_LOGD("Already started");
return LOCATION_ERROR_NONE;
}
if (priv->gps) ret_gps = location_start(priv->gps);
if (priv->wps) ret_wps = location_start(priv->wps);
- if (priv->mock) ret_mock = location_start(priv->mock);
- if (ret_gps != LOCATION_ERROR_NONE && ret_wps != LOCATION_ERROR_NONE && ret_mock != LOCATION_ERROR_NONE) {
- LOCATION_LOGD("ret_gps = %d, ret_wps = %d, ret_mock = %d", ret_gps, ret_wps, ret_mock);
- if (ret_gps == LOCATION_ERROR_SECURITY_DENIED || ret_wps == LOCATION_ERROR_SECURITY_DENIED || ret_mock == LOCATION_ERROR_SECURITY_DENIED)
+ if (ret_gps != LOCATION_ERROR_NONE && ret_wps != LOCATION_ERROR_NONE) {
+ LOCATION_LOGD("ret_gps = %d, ret_wps = %d", ret_gps, ret_wps);
+ if (ret_gps == LOCATION_ERROR_SECURITY_DENIED || ret_wps == LOCATION_ERROR_SECURITY_DENIED)
return LOCATION_ERROR_SECURITY_DENIED;
- else if (ret_gps == LOCATION_ERROR_SETTING_OFF || ret_wps == LOCATION_ERROR_SETTING_OFF || ret_mock == LOCATION_ERROR_SETTING_OFF)
+ else if (ret_gps == LOCATION_ERROR_SETTING_OFF || ret_wps == LOCATION_ERROR_SETTING_OFF)
return LOCATION_ERROR_SETTING_OFF;
- else if (ret_gps == LOCATION_ERROR_NOT_ALLOWED || ret_wps == LOCATION_ERROR_NOT_ALLOWED || ret_mock == LOCATION_ERROR_NOT_ALLOWED)
+ else if (ret_gps == LOCATION_ERROR_NOT_ALLOWED || ret_wps == LOCATION_ERROR_NOT_ALLOWED)
return LOCATION_ERROR_NOT_ALLOWED;
else
return LOCATION_ERROR_NOT_AVAILABLE;
int ret_gps = LOCATION_ERROR_NOT_AVAILABLE;
int ret_wps = LOCATION_ERROR_NOT_AVAILABLE;
- int ret_mock = LOCATION_ERROR_NOT_AVAILABLE;
gboolean gps_started = FALSE;
gboolean wps_started = FALSE;
- gboolean mock_started = FALSE;
if (priv->gps) g_object_get(priv->gps, "is_started", &gps_started, NULL);
if (priv->wps) g_object_get(priv->wps, "is_started", &wps_started, NULL);
- if (priv->mock) g_object_get(priv->mock, "is_started", &mock_started, NULL);
- if ((gps_started == FALSE) && (wps_started == FALSE) && (mock_started == FALSE))
+ if ((gps_started == FALSE) && (wps_started == FALSE))
return LOCATION_ERROR_NONE;
if (priv->gps) ret_gps = location_stop(priv->gps);
if (priv->wps) ret_wps = location_stop(priv->wps);
- if (priv->mock) ret_mock = location_stop(priv->mock);
- if (ret_gps != LOCATION_ERROR_NONE && ret_wps != LOCATION_ERROR_NONE && ret_mock != LOCATION_ERROR_NONE)
+ if (ret_gps != LOCATION_ERROR_NONE && ret_wps != LOCATION_ERROR_NONE)
return LOCATION_ERROR_NOT_AVAILABLE;
if (priv->pos_timer) g_source_remove(priv->pos_timer);
priv->gps_enabled = FALSE;
priv->wps_enabled = FALSE;
- priv->mock_enabled = FALSE;
return LOCATION_ERROR_NONE;
}
location_free(priv->wps);
}
- if (priv->mock) {
- g_signal_handlers_disconnect_by_func(priv->mock, G_CALLBACK(hybrid_service_enabled), gobject);
- g_signal_handlers_disconnect_by_func(priv->mock, G_CALLBACK(hybrid_service_disabled), gobject);
- /* g_signal_handlers_disconnect_by_func(priv->mock, G_CALLBACK(hybrid_status_changed), gobject); */
- g_signal_handlers_disconnect_by_func(priv->mock, G_CALLBACK(hybrid_service_updated), gobject);
- g_signal_handlers_disconnect_by_func(priv->mock, G_CALLBACK(hybrid_location_updated), gobject);
- location_free(priv->mock);
- }
-
if (priv->boundary_list) {
g_list_free_full(priv->boundary_list, free_boundary_list);
priv->boundary_list = NULL;
LOC_FUNC_LOG
int ret = LOCATION_ERROR_NONE;
- LocationPosition *gps_pos = NULL, *wps_pos = NULL, *mock_pos = NULL;
- LocationVelocity *gps_vel = NULL, *wps_vel = NULL, *mock_vel = NULL;
- LocationAccuracy *gps_acc = NULL, *wps_acc = NULL, *mock_acc = NULL;
+ LocationPosition *gps_pos = NULL, *wps_pos = NULL;
+ LocationVelocity *gps_vel = NULL, *wps_vel = NULL;
+ LocationAccuracy *gps_acc = NULL, *wps_acc = NULL;
LocationHybridPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
if (priv->gps) location_get_last_position_ext(priv->gps, &gps_pos, &gps_vel, &gps_acc);
if (priv->wps) location_get_last_position_ext(priv->wps, &wps_pos, &wps_vel, &wps_acc);
- if (priv->mock) location_get_last_position_ext(priv->mock, &mock_pos, &mock_vel, &mock_acc);
if (gps_pos && wps_pos && gps_vel && wps_vel) {
- if (mock_pos && mock_vel && mock_pos->timestamp > gps_pos->timestamp) {
- *position = mock_pos;
- *velocity = mock_vel;
- *accuracy = mock_acc;
- location_position_free(mock_pos);
- location_velocity_free(mock_vel);
- location_accuracy_free(mock_acc);
- } else if (wps_pos->timestamp > gps_pos->timestamp) {
+ if (wps_pos->timestamp > gps_pos->timestamp) {
*position = wps_pos;
*velocity = wps_vel;
*accuracy = wps_acc;
*velocity = gps_vel;
*accuracy = gps_acc;
} else if (wps_pos && wps_vel) {
- *position = mock_pos;
- *velocity = mock_vel;
- *accuracy = mock_acc;
+ *position = wps_pos;
+ *velocity = wps_vel;
+ *accuracy = wps_acc;
} else {
ret = LOCATION_ERROR_NOT_AVAILABLE;
}
int ret = LOCATION_ERROR_NONE;
LocationHybridPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- LocationVelocity *gps_vel = NULL, *wps_vel = NULL, *mock_vel = NULL;
- LocationAccuracy *gps_acc = NULL, *wps_acc = NULL, *mock_acc = NULL;
+ LocationVelocity *gps_vel = NULL, *wps_vel = NULL;
+ LocationAccuracy *gps_acc = NULL, *wps_acc = NULL;
if (priv->gps) location_get_last_velocity(priv->gps, &gps_vel, &gps_acc);
if (priv->wps) location_get_last_velocity(priv->wps, &wps_vel, &wps_acc);
- if (priv->mock) location_get_last_velocity(priv->mock, &mock_vel, &mock_acc);
if (gps_vel && wps_vel) {
- if (mock_vel && mock_vel->timestamp > gps_vel->timestamp) {
- *velocity = mock_vel;
- *accuracy = mock_acc;
- location_velocity_free(mock_vel);
- location_accuracy_free(mock_acc);
- } else if (wps_vel->timestamp > gps_vel->timestamp) {
+ if (wps_vel->timestamp > gps_vel->timestamp) {
*velocity = wps_vel;
*accuracy = wps_acc;
location_velocity_free(gps_vel);
} else if (wps_vel) {
*velocity = wps_vel;
*accuracy = wps_acc;
- } else if (mock_vel) {
- *velocity = mock_vel;
- *accuracy = mock_acc;
} else {
*velocity = NULL;
*accuracy = NULL;
if (priv->gps)
ret = location_request_single_location(priv->gps, timeout);
- else if (priv->wps)
+ else
ret = location_request_single_location(priv->wps, timeout);
- else if (priv->mock)
- ret = location_request_single_location(priv->mock, timeout);
return ret;
}
return LOCATION_ERROR_NONE;
}
-/*
- * Tizen 3.0
- */
static int
-location_hybrid_set_mock_location(LocationMock *self, LocationPosition *position, LocationVelocity *velocity, LocationAccuracy *accuracy)
+location_hybrid_set_mock_location(LocationHybrid *self, LocationPosition *position, LocationVelocity *velocity, LocationAccuracy *accuracy)
{
+ LOC_FUNC_LOG
LocationHybridPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
-
int ret = LOCATION_ERROR_NONE;
- LOC_COND_RET(!priv->mock, LOCATION_ERROR_NOT_AVAILABLE, _E, "MOCK Object is not created [%s]", err_msg(LOCATION_ERROR_NOT_AVAILABLE));
-
- if (priv->mock)
- ret = location_set_mock_location(priv->mock, position, velocity, accuracy);
- LOC_IF_FAIL_LOG(ret, _E, "set_mock_location [%s]", err_msg(ret));
+ if (priv->gps)
+ ret = location_set_mock_location(priv->gps, position, velocity, accuracy);
+ else if (priv->wps)
+ ret = location_set_mock_location(priv->wps, position, velocity, accuracy);
+ else
+ ret = LOCATION_ERROR_NOT_AVAILABLE;
return ret;
}
static int
-location_hybrid_clear_mock_location(LocationMock *self)
+location_hybrid_clear_mock_location(LocationHybrid *self)
{
+ LOC_FUNC_LOG
LocationHybridPrivate *priv = GET_PRIVATE(self);
g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
-
int ret = LOCATION_ERROR_NONE;
- LOC_COND_RET(!priv->mock, LOCATION_ERROR_NOT_AVAILABLE, _E, "MOCK Object is not created [%s]", err_msg(LOCATION_ERROR_NOT_AVAILABLE));
-
- if (priv->mock)
- ret = location_clear_mock_location(priv->mock);
- LOC_IF_FAIL_LOG(ret, _E, "clear_mock_location [%s]", err_msg(ret));
+ if (priv->gps)
+ ret = location_clear_mock_location(priv->gps);
+ else if (priv->wps)
+ ret = location_clear_mock_location(priv->wps);
+ else
+ ret = LOCATION_ERROR_NOT_AVAILABLE;
return ret;
}
if (location_is_supported_method(LOCATION_METHOD_GPS)) priv->gps = location_new(LOCATION_METHOD_GPS);
if (location_is_supported_method(LOCATION_METHOD_WPS)) priv->wps = location_new(LOCATION_METHOD_WPS);
- if (location_is_supported_method(LOCATION_METHOD_MOCK)) priv->mock = location_new(LOCATION_METHOD_MOCK);
if (priv->gps) {
g_signal_connect(priv->gps, "service-enabled", G_CALLBACK(hybrid_service_enabled), self);
g_signal_connect(priv->wps, "service-updated", G_CALLBACK(hybrid_service_updated), self);
g_signal_connect(priv->wps, "location-updated", G_CALLBACK(hybrid_location_updated), self);
}
- if (priv->mock) {
- g_signal_connect(priv->mock, "service-enabled", G_CALLBACK(hybrid_service_enabled), self);
- g_signal_connect(priv->mock, "service-disabled", G_CALLBACK(hybrid_service_disabled), self);
- /* g_signal_connect(priv->mock, "status-changed", G_CALLBACK(hybrid_status_changed), self); */
- g_signal_connect(priv->mock, "service-updated", G_CALLBACK(hybrid_service_updated), self);
- g_signal_connect(priv->mock, "location-updated", G_CALLBACK(hybrid_location_updated), self);
- }
hybrid_set_current_method(priv, LOCATION_TYPE_HYBRID);
priv->enabled = FALSE;
g_type_class_add_private(klass, sizeof(LocationHybridPrivate));
- signals[SERVICE_ENABLED] = g_signal_new("service-enabled",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationHybridClass, enabled),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
-
- signals[SERVICE_DISABLED] = g_signal_new("service-disabled",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationHybridClass, disabled),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
+ signals[SERVICE_ENABLED] =
+ g_signal_new("service-enabled", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationHybridClass, enabled),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
+
+ signals[SERVICE_DISABLED] =
+ g_signal_new("service-disabled", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationHybridClass, disabled),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
#if 0 /* TODO: STATUS_CHANGED will aggregate SERVICE_ENABLED and SERVICE_DISABLED */
- signals[STATUS_CHANGED] = g_signal_new("status-changed",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationHybridClass, status_changed),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
+ signals[STATUS_CHANGED] =
+ g_signal_new("status-changed", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationHybridClass, status_changed),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
#endif
- signals[SERVICE_UPDATED] = g_signal_new("service-updated",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationHybridClass, service_updated),
- NULL, NULL,
- location_VOID__INT_POINTER_POINTER_POINTER,
- G_TYPE_NONE, 4,
- G_TYPE_INT,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[LOCATION_UPDATED] = g_signal_new("location-updated",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationHybridClass, location_updated),
- NULL, NULL,
- location_VOID__INT_POINTER_POINTER_POINTER,
- G_TYPE_NONE, 4,
- G_TYPE_INT,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[ZONE_IN] = g_signal_new("zone-in",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationHybridClass, zone_in),
- NULL, NULL,
- location_VOID__POINTER_POINTER_POINTER,
- G_TYPE_NONE, 3,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[ZONE_OUT] = g_signal_new("zone-out",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationHybridClass, zone_out),
- NULL, NULL,
- location_VOID__POINTER_POINTER_POINTER,
- G_TYPE_NONE, 3,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- properties[PROP_METHOD_TYPE] = g_param_spec_int("method",
- "method type",
- "location method type name",
- LOCATION_METHOD_HYBRID,
- LOCATION_METHOD_HYBRID,
- LOCATION_METHOD_HYBRID,
- G_PARAM_READABLE);
-
- properties[PROP_LAST_POSITION] = g_param_spec_boxed("last-position",
- "hybrid last position prop",
- "hybrid last position data",
- LOCATION_TYPE_POSITION,
- G_PARAM_READABLE);
-
- properties[PROP_POS_INTERVAL] = g_param_spec_uint("pos-interval",
- "position interval prop",
- "position interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
- properties[PROP_VEL_INTERVAL] = g_param_spec_uint("vel-interval",
- "velocity interval prop",
- "velocity interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
- properties[PROP_SAT_INTERVAL] = g_param_spec_uint("sat-interval",
- "satellite interval prop",
- "satellite interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_LOC_INTERVAL] = g_param_spec_uint("loc-interval",
- "gps location interval prop",
- "gps location interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_MIN_INTERVAL] = g_param_spec_uint("min-interval",
- "gps distance-based interval prop",
- "gps distance-based interval data",
- LOCATION_MIN_INTERVAL_MIN,
- LOCATION_MIN_INTERVAL_MAX,
- LOCATION_MIN_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_MIN_DISTANCE] = g_param_spec_double("min-distance",
- "gps distance-based distance prop",
- "gps distance-based distance data",
- LOCATION_MIN_DISTANCE_MIN,
- LOCATION_MIN_DISTANCE_MAX,
- LOCATION_MIN_DISTANCE_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_BOUNDARY] = g_param_spec_pointer("boundary",
- "hybrid boundary prop",
- "hybrid boundary data",
- G_PARAM_READWRITE);
-
- properties[PROP_REMOVAL_BOUNDARY] = g_param_spec_boxed("removal-boundary",
- "hybrid removal boundary prop",
- "hybrid removal boundary data",
- LOCATION_TYPE_BOUNDARY,
- G_PARAM_READWRITE);
+ signals[SERVICE_UPDATED] =
+ g_signal_new("service-updated", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationHybridClass, service_updated),
+ NULL, NULL, location_VOID__INT_POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 4, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ signals[LOCATION_UPDATED] =
+ g_signal_new("location-updated", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationHybridClass, location_updated),
+ NULL, NULL, location_VOID__INT_POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 4, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ signals[ZONE_IN] =
+ g_signal_new("zone-in", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationHybridClass, zone_in),
+ NULL, NULL, location_VOID__POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ signals[ZONE_OUT] =
+ g_signal_new("zone-out", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationHybridClass, zone_out),
+ NULL, NULL, location_VOID__POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ properties[PROP_METHOD_TYPE] =
+ g_param_spec_int("method", "method type",
+ "location method type name", LOCATION_METHOD_HYBRID,
+ LOCATION_METHOD_HYBRID, LOCATION_METHOD_HYBRID, G_PARAM_READABLE);
+
+ properties[PROP_LAST_POSITION] =
+ g_param_spec_boxed("last-position", "hybrid last position prop",
+ "hybrid last position data", LOCATION_TYPE_POSITION, G_PARAM_READABLE);
+
+ properties[PROP_POS_INTERVAL] =
+ g_param_spec_uint("pos-interval", "position interval prop",
+ "position interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_VEL_INTERVAL] =
+ g_param_spec_uint("vel-interval", "velocity interval prop",
+ "velocity interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_SAT_INTERVAL] =
+ g_param_spec_uint("sat-interval", "satellite interval prop",
+ "satellite interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_LOC_INTERVAL] =
+ g_param_spec_uint("loc-interval", "gps location interval prop",
+ "gps location interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_MIN_INTERVAL] =
+ g_param_spec_uint("min-interval", "gps distance-based interval prop",
+ "gps distance-based interval data", LOCATION_MIN_INTERVAL_MIN,
+ LOCATION_MIN_INTERVAL_MAX, LOCATION_MIN_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_MIN_DISTANCE] =
+ g_param_spec_double("min-distance", "gps distance-based distance prop",
+ "gps distance-based distance data", LOCATION_MIN_DISTANCE_MIN,
+ LOCATION_MIN_DISTANCE_MAX, LOCATION_MIN_DISTANCE_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_BOUNDARY] =
+ g_param_spec_pointer("boundary", "hybrid boundary prop",
+ "hybrid boundary data", G_PARAM_READWRITE);
+
+ properties[PROP_REMOVAL_BOUNDARY] =
+ g_param_spec_boxed("removal-boundary", "hybrid removal boundary prop",
+ "hybrid removal boundary data", LOCATION_TYPE_BOUNDARY, G_PARAM_READWRITE);
/* Tizen 3.0 */
- properties[PROP_SERVICE_STATUS] = g_param_spec_int("service-status",
- "location service status prop",
- "location service status data",
- LOCATION_STATUS_NO_FIX,
- LOCATION_STATUS_3D_FIX,
- LOCATION_STATUS_NO_FIX,
- G_PARAM_READABLE);
+ properties[PROP_SERVICE_STATUS] =
+ g_param_spec_int("service-status", "location service status prop",
+ "location service status data", LOCATION_STATUS_NO_FIX,
+ LOCATION_STATUS_3D_FIX, LOCATION_STATUS_NO_FIX, G_PARAM_READABLE);
g_object_class_install_properties(gobject_class, PROP_MAX, properties);
}
/* Tizen 3.0 */
-
-int location_ielement_get_status(LocationIElement *self, int *state)
-{
- g_return_val_if_fail(LOCATION_IS_IELEMENT(self), LOCATION_ERROR_PARAMETER);
- g_return_val_if_fail(LOCATION_IELEMENT_GET_INTERFACE(self), LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(LOCATION_IELEMENT_GET_INTERFACE(self)->get_status, LOCATION_ERROR_NOT_AVAILABLE);
-
- return LOCATION_IELEMENT_GET_INTERFACE(self)->get_status(self, state);
-}
-
int location_ielement_set_mock_location(LocationIElement *self, const LocationPosition *position, const LocationVelocity *velocity, const LocationAccuracy *accuracy)
{
g_return_val_if_fail(LOCATION_IS_IELEMENT(self), LOCATION_ERROR_PARAMETER);
ZONE_OUT,
LOCATION_UPDATED,
BATCH_UPDATED,
- MOCK_LOCATION_SET,
- MOCK_LOCATION_FAIL,
STATUS_CHANGED,
LAST_SIGNAL,
};
TYPE_GET_NMEA get_nmea;
/* Tizen 3.0 */
- TYPE_GET_STATUS get_status;
TYPE_SET_MOCK_LOCATION set_mock_location;
TYPE_CLEAR_MOCK_LOCATION clear_mock_location;
};
int location_ielement_get_nmea(LocationIElement *self, char **nmea);
/* Tizen 3.0 */
-int location_ielement_get_status(LocationIElement *self, int *state);
int location_ielement_set_mock_location(LocationIElement *self, const LocationPosition *position, const LocationVelocity *velocity, const LocationAccuracy *accuracy);
int location_ielement_clear_mock_location(LocationIElement *self);
+++ /dev/null
-/*
- * libslp-location
- *
- * Copyright (c) 2010-2013 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Youngae Kang <youngae.kang@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
- * Genie Kim <daejins.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifdef HAVE_CONFIG_H
-#include "config.h"
-#endif
-
-#include "location-setting.h"
-#include "location-log.h"
-
-#include "module-internal.h"
-
-#include "location-mock.h"
-#include "location-marshal.h"
-#include "location-ielement.h"
-#include "location-signaling-util.h"
-#include "location-common-util.h"
-#include "location-privacy.h"
-
-#include <vconf-internal-location-keys.h>
-
-/*
- * forward definitions
- */
-
-typedef struct _LocationMockPrivate {
- LocationMockMod *mod;
- GMutex mutex;
- gboolean is_started;
- guint app_type;
- gboolean set_noti;
- gboolean enabled;
- guint pos_updated_timestamp;
- guint pos_interval;
- guint vel_updated_timestamp;
- guint vel_interval;
- guint loc_updated_timestamp;
- guint loc_interval;
- guint loc_timeout;
- guint dist_updated_timestamp;
- guint min_interval;
- gdouble min_distance;
- LocationPosition *pos;
- LocationVelocity *vel;
- LocationAccuracy *acc;
- GList *boundary_list;
-} LocationMockPrivate;
-
-enum {
- PROP_0,
- PROP_METHOD_TYPE,
- PROP_IS_STARTED,
- PROP_LAST_POSITION,
- PROP_POS_INTERVAL,
- PROP_VEL_INTERVAL,
- PROP_LOC_INTERVAL,
- PROP_BOUNDARY,
- PROP_REMOVAL_BOUNDARY,
- PROP_MIN_INTERVAL,
- PROP_MIN_DISTANCE,
- PROP_SERVICE_STATUS,
- PROP_MAX
-};
-
-static guint32 signals[LAST_SIGNAL] = {0, };
-static GParamSpec *properties[PROP_MAX] = {NULL, };
-
-#define GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE((o), LOCATION_TYPE_MOCK, LocationMockPrivate))
-
-static void location_ielement_interface_init(LocationIElementInterface *iface);
-G_DEFINE_TYPE_WITH_CODE(LocationMock, location_mock, G_TYPE_OBJECT, G_IMPLEMENT_INTERFACE(LOCATION_TYPE_IELEMENT, location_ielement_interface_init));
-
-static void
-__reset_pos_data_from_priv(LocationMockPrivate *priv)
-{
- LOC_FUNC_LOG
- g_return_if_fail(priv);
-
- if (priv->pos) {
- location_position_free(priv->pos);
- priv->pos = NULL;
- }
- if (priv->vel) {
- location_velocity_free(priv->vel);
- priv->vel = NULL;
- }
- if (priv->acc) {
- location_accuracy_free(priv->acc);
- priv->acc = NULL;
- }
- priv->pos_updated_timestamp = 0;
- priv->vel_updated_timestamp = 0;
-}
-
-static gboolean
-__get_started(gpointer self)
-{
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, FALSE);
-
- return priv->is_started;
-}
-
-static int
-__set_started(gpointer self, gboolean started)
-{
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, -1);
-
- if (priv->is_started != started) {
- g_mutex_lock(&priv->mutex);
- priv->is_started = started;
- g_mutex_unlock(&priv->mutex);
- }
-
- return 0;
-}
-
-static void
-mock_status_cb(gboolean enabled, LocationStatus status, gpointer self)
-{
- LOC_FUNC_LOG
- g_return_if_fail(self);
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_if_fail(priv);
- if (priv->enabled == TRUE && enabled == FALSE) {
- __set_started(self, FALSE);
- enable_signaling(self, signals, &(priv->enabled), enabled, status);
- }
-}
-
-static void
-mock_location_cb(gboolean enabled, LocationPosition *pos, LocationVelocity *vel, LocationAccuracy *acc, gpointer self)
-{
- g_return_if_fail(self);
- g_return_if_fail(pos);
- g_return_if_fail(vel);
- g_return_if_fail(acc);
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_if_fail(priv);
-
- if (priv->min_interval != LOCATION_UPDATE_INTERVAL_NONE) {
- distance_based_position_signaling(self, signals, enabled,
- pos, vel, acc, priv->min_interval, priv->min_distance, &(priv->enabled),
- &(priv->dist_updated_timestamp), &(priv->pos), &(priv->vel), &(priv->acc));
- }
-
- LOCATION_LOGD("Calling location_signaling, status =%d", pos->status);
-
- location_signaling(self, signals, enabled, priv->boundary_list, pos, vel, acc,
- priv->pos_interval, priv->vel_interval, priv->loc_interval, &(priv->enabled),
- &(priv->pos_updated_timestamp), &(priv->vel_updated_timestamp), &(priv->loc_updated_timestamp),
- &(priv->pos), &(priv->vel), &(priv->acc));
-}
-
-static void
-location_setting_mock_cb(keynode_t *key, gpointer self)
-{
- LOC_FUNC_LOG
- g_return_if_fail(key);
- g_return_if_fail(self);
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_if_fail(priv);
- g_return_if_fail(priv->mod);
- g_return_if_fail(priv->mod->handler);
-
- int ret = LOCATION_ERROR_NONE;
-
- if (location_setting_get_key_val(key) == 0) {
- if (priv->mod->ops.stop && __get_started(self)) {
- __set_started(self, FALSE);
- ret = priv->mod->ops.stop(priv->mod->handler);
- if (ret == LOCATION_ERROR_NONE)
- __reset_pos_data_from_priv(priv);
- }
- } else {
- if (location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED) == 1 && priv->mod->ops.start && !__get_started(self)) {
- LOCATION_LOGD("location resumed by setting");
- __set_started(self, TRUE);
- ret = priv->mod->ops.start(priv->mod->handler, mock_status_cb, mock_location_cb, self);
- if (ret != LOCATION_ERROR_NONE) {
- __set_started(self, FALSE);
- LOCATION_LOGD("Fail to start. Error[%d]", ret);
- }
- }
- }
-
-}
-
-static int
-location_mock_start(LocationMock *self)
-{
- LOC_FUNC_LOG
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->ops.start, LOCATION_ERROR_NOT_AVAILABLE);
-
- if (__get_started(self) == TRUE) return LOCATION_ERROR_NONE;
-
- int ret = LOCATION_ERROR_NONE;
-
- if (!location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED)) {
- ret = LOCATION_ERROR_SETTING_OFF;
- } else {
- __set_started(self, TRUE);
- ret = priv->mod->ops.start(priv->mod->handler, mock_status_cb, mock_location_cb, self);
- if (ret != LOCATION_ERROR_NONE) {
- __set_started(self, FALSE);
- LOCATION_LOGE("Failed to start mock. Error[%d]", ret);
- return ret;
- }
- }
-
- if (priv->app_type != CPPAPP && priv->set_noti == FALSE) {
- location_setting_add_notify(VCONFKEY_LOCATION_MOCK_ENABLED, location_setting_mock_cb, self);
- priv->set_noti = TRUE;
- }
- LOCATION_LOGD("EXIT <<<, ret = %d", ret);
-
- return ret;
-}
-
-static int
-location_mock_stop(LocationMock *self)
-{
- LOC_FUNC_LOG
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->ops.stop, LOCATION_ERROR_NOT_AVAILABLE);
-
- int ret = LOCATION_ERROR_NONE;
-
- if (__get_started(self) == TRUE) {
- __set_started(self, FALSE);
- ret = priv->mod->ops.stop(priv->mod->handler);
- LOC_IF_FAIL_LOG(ret, _E, "Failed to stop [%s]", err_msg(ret));
- }
-
- if (priv->app_type != CPPAPP && priv->set_noti == TRUE) {
- location_setting_ignore_notify(VCONFKEY_LOCATION_MOCK_ENABLED, location_setting_mock_cb);
- priv->set_noti = FALSE;
- }
-
- __reset_pos_data_from_priv(priv);
-
- return ret;
-}
-
-static void
-location_mock_dispose(GObject *gobject)
-{
- LOC_FUNC_LOG
- LocationMockPrivate *priv = GET_PRIVATE(gobject);
- g_return_if_fail(priv);
-
- g_mutex_clear(&priv->mutex);
- if (priv->app_type != CPPAPP && priv->set_noti == TRUE) {
- location_setting_ignore_notify(VCONFKEY_LOCATION_MOCK_ENABLED, location_setting_mock_cb);
- priv->set_noti = FALSE;
- }
-
- G_OBJECT_CLASS(location_mock_parent_class)->dispose(gobject);
-}
-
-static void
-location_mock_finalize(GObject *gobject)
-{
- LOC_FUNC_LOG
- LocationMockPrivate *priv = GET_PRIVATE(gobject);
- g_return_if_fail(priv);
- module_free(priv->mod, "mock");
-
- if (priv->boundary_list) {
- g_list_free_full(priv->boundary_list, free_boundary_list);
- priv->boundary_list = NULL;
- }
-
- if (priv->pos) {
- location_position_free(priv->pos);
- priv->pos = NULL;
- }
-
- if (priv->vel) {
- location_velocity_free(priv->vel);
- priv->vel = NULL;
- }
-
- if (priv->acc) {
- location_accuracy_free(priv->acc);
- priv->acc = NULL;
- }
-
- G_OBJECT_CLASS(location_mock_parent_class)->finalize(gobject);
-}
-
-static void
-location_mock_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
-{
- LocationMockPrivate *priv = GET_PRIVATE(object);
- g_return_if_fail(priv);
- int ret = 0;
-
- switch (property_id) {
- case PROP_BOUNDARY: {
- GList *boundary_list = (GList *)g_list_copy(g_value_get_pointer(value));
- ret = set_prop_boundary(&priv->boundary_list, boundary_list);
- LOC_IF_FAIL_LOG(ret, _E, "Set boundary. Error[%s]", err_msg(ret));
- if (boundary_list) g_list_free(boundary_list);
- break;
- }
- case PROP_REMOVAL_BOUNDARY: {
- LocationBoundary *req_boundary = (LocationBoundary *) g_value_dup_boxed(value);
- ret = set_prop_removal_boundary(&priv->boundary_list, req_boundary);
- LOC_IF_FAIL_LOG(ret, _E, "Set removal boundary. Error[%s]", err_msg(ret));
- break;
- }
- case PROP_POS_INTERVAL: {
- guint interval = g_value_get_uint(value);
- if (interval > 0) {
- if (interval < LOCATION_UPDATE_INTERVAL_MAX)
- priv->pos_interval = interval;
- else
- priv->pos_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
- } else
- priv->pos_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
-
- break;
- }
- case PROP_VEL_INTERVAL: {
- guint interval = g_value_get_uint(value);
- if (interval > 0) {
- if (interval < LOCATION_UPDATE_INTERVAL_MAX)
- priv->vel_interval = interval;
- else
- priv->vel_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
- } else {
- priv->vel_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
- }
- break;
- }
- case PROP_LOC_INTERVAL: {
- guint interval = g_value_get_uint(value);
- LOCATION_LOGD("Set prop>> PROP_LOC_INTERVAL: %u", interval);
- if (interval > 0) {
- if (interval < LOCATION_UPDATE_INTERVAL_MAX)
- priv->loc_interval = interval;
- else
- priv->loc_interval = (guint)LOCATION_UPDATE_INTERVAL_MAX;
- } else
- priv->loc_interval = (guint)LOCATION_UPDATE_INTERVAL_DEFAULT;
-
- break;
- }
- case PROP_MIN_INTERVAL: {
- guint interval = g_value_get_uint(value);
- LOCATION_LOGD("Set prop>> update-min-interval: %u", interval);
- if (interval > 0) {
- if (interval < LOCATION_MIN_INTERVAL_MAX)
- priv->min_interval = interval;
- else
- priv->min_interval = (guint)LOCATION_MIN_INTERVAL_MAX;
- } else
- priv->min_interval = (guint)LOCATION_MIN_INTERVAL_DEFAULT;
-
- break;
- }
- case PROP_MIN_DISTANCE: {
- gdouble distance = g_value_get_double(value);
- LOCATION_LOGD("Set prop>> update-min-distance: %u", distance);
- if (distance > 0) {
- if (distance < LOCATION_MIN_DISTANCE_MAX)
- priv->min_distance = distance;
- else
- priv->min_distance = (gdouble)LOCATION_MIN_DISTANCE_MAX;
- } else
- priv->min_distance = (gdouble)LOCATION_MIN_DISTANCE_DEFAULT;
-
- break;
- }
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
- break;
- }
-}
-
-static void
-location_mock_get_property(GObject *object, guint property_id, GValue *value, GParamSpec *pspec)
-{
- LocationMockPrivate *priv = GET_PRIVATE(object);
- g_return_if_fail(priv);
-
- switch (property_id) {
- case PROP_METHOD_TYPE:
- g_value_set_int(value, LOCATION_METHOD_MOCK);
- break;
- case PROP_IS_STARTED:
- g_value_set_boolean(value, __get_started(object));
- break;
- case PROP_LAST_POSITION:
- g_value_set_boxed(value, priv->pos);
- break;
- case PROP_BOUNDARY:
- g_value_set_pointer(value, g_list_first(priv->boundary_list));
- break;
- case PROP_POS_INTERVAL:
- g_value_set_uint(value, priv->pos_interval);
- break;
- case PROP_VEL_INTERVAL:
- g_value_set_uint(value, priv->vel_interval);
- break;
- case PROP_LOC_INTERVAL:
- g_value_set_uint(value, priv->loc_interval);
- break;
- case PROP_MIN_INTERVAL:
- g_value_set_uint(value, priv->min_interval);
- break;
- case PROP_MIN_DISTANCE:
- g_value_set_double(value, priv->min_distance);
- break;
- case PROP_SERVICE_STATUS:
- g_value_set_int(value, priv->enabled);
- break;
- default:
- G_OBJECT_WARN_INVALID_PROPERTY_ID(object, property_id, pspec);
- break;
- }
-}
-
-static int
-location_mock_get_position(LocationMock *self, LocationPosition **position, LocationAccuracy **accuracy)
-{
- int ret = LOCATION_ERROR_NOT_AVAILABLE;
-
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- setting_retval_if_fail(VCONFKEY_LOCATION_MOCK_ENABLED);
-
- LOC_COND_RET(__get_started(self) != TRUE, LOCATION_ERROR_NOT_AVAILABLE, _E, "location is not started [%s]", err_msg(LOCATION_ERROR_NOT_AVAILABLE));
-
- if (priv->pos) {
- *position = location_position_copy(priv->pos);
- if (priv->acc) *accuracy = location_accuracy_copy(priv->acc);
- else *accuracy = location_accuracy_new(LOCATION_ACCURACY_LEVEL_NONE, 0.0, 0.0);
- ret = LOCATION_ERROR_NONE;
- }
-
- return ret;
-}
-
-static int
-location_mock_get_position_ext(LocationMock *self, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy)
-{
- int ret = LOCATION_ERROR_NOT_AVAILABLE;
-
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- setting_retval_if_fail(VCONFKEY_LOCATION_MOCK_ENABLED);
-
- LOC_COND_RET(__get_started(self) != TRUE, LOCATION_ERROR_NOT_AVAILABLE, _E, "location is not started [%s]", err_msg(LOCATION_ERROR_NOT_AVAILABLE));
-
- if (priv->pos && priv->vel) {
- *position = location_position_copy(priv->pos);
- *velocity = location_velocity_copy(priv->vel);
- if (priv->acc)
- *accuracy = location_accuracy_copy(priv->acc);
- else
- *accuracy = location_accuracy_new(LOCATION_ACCURACY_LEVEL_NONE, 0.0, 0.0);
-
- ret = LOCATION_ERROR_NONE;
- }
-
- return ret;
-}
-
-
-static int
-location_mock_get_last_position(LocationMock *self, LocationPosition **position, LocationAccuracy **accuracy)
-{
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- setting_retval_if_fail(VCONFKEY_LOCATION_MOCK_ENABLED);
-
- int ret = LOCATION_ERROR_NONE;
- LocationVelocity *_velocity = NULL;
-
- LocModMockOps ops = priv->mod->ops;
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(ops.get_last_position, LOCATION_ERROR_NOT_AVAILABLE);
-
- ret = ops.get_last_position(priv->mod->handler, position, &_velocity, accuracy);
- if (_velocity) location_velocity_free(_velocity);
-
- return ret;
-}
-
-static int
-location_mock_get_last_position_ext(LocationMock *self, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy)
-{
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- setting_retval_if_fail(VCONFKEY_LOCATION_MOCK_ENABLED);
-
- LocModMockOps ops = priv->mod->ops;
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(ops.get_last_position, LOCATION_ERROR_NOT_AVAILABLE);
-
- return ops.get_last_position(priv->mod->handler, position, velocity, accuracy);
-}
-
-
-static int
-location_mock_get_velocity(LocationMock *self, LocationVelocity **velocity, LocationAccuracy **accuracy)
-{
- int ret = LOCATION_ERROR_NOT_AVAILABLE;
-
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- setting_retval_if_fail(VCONFKEY_LOCATION_MOCK_ENABLED);
-
- LOC_COND_RET(__get_started(self) != TRUE, LOCATION_ERROR_NOT_AVAILABLE, _E, "location is not started [%s]", err_msg(LOCATION_ERROR_NOT_AVAILABLE));
-
- if (priv->vel) {
- *velocity = location_velocity_copy(priv->vel);
- if (priv->acc) *accuracy = location_accuracy_copy(priv->acc);
- else *accuracy = location_accuracy_new(LOCATION_ACCURACY_LEVEL_NONE, 0.0, 0.0);
- ret = LOCATION_ERROR_NONE;
- }
-
- return ret;
-}
-
-static int
-location_mock_get_last_velocity(LocationMock *self, LocationVelocity **velocity, LocationAccuracy **accuracy)
-{
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- setting_retval_if_fail(VCONFKEY_LOCATION_MOCK_ENABLED);
-
- int ret = LOCATION_ERROR_NONE;
- LocationPosition *_position = NULL;
-
- LocModMockOps ops = priv->mod->ops;
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
- ret = ops.get_last_position(priv->mod->handler, &_position, velocity, accuracy);
- if (!_position) location_position_free(_position);
-
- return ret;
-}
-
-static gboolean
-__single_location_timeout_cb(void *data)
-{
- LOC_FUNC_LOG
- LocationMock *self = (LocationMock *)data;
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, FALSE);
-
- LocationPosition *pos = location_position_new(0, 0.0, 0.0, 0.0, LOCATION_STATUS_NO_FIX);
- LocationVelocity *vel = location_velocity_new(0, 0.0, 0.0, 0.0);
- LocationAccuracy *acc = location_accuracy_new(LOCATION_ACCURACY_LEVEL_NONE, 0.0, 0.0);
-
- if (priv->loc_timeout) g_source_remove(priv->loc_timeout);
- priv->loc_timeout = 0;
-
- g_signal_emit(self, signals[LOCATION_UPDATED], 0, LOCATION_ERROR_NOT_AVAILABLE, pos, vel, acc);
- location_mock_stop(self);
-
- return FALSE;
-}
-
-
-static void
-mock_single_location_cb(gboolean enabled, LocationPosition *pos, LocationVelocity *vel, LocationAccuracy *acc, gpointer self)
-{
- LOC_FUNC_LOG
- g_return_if_fail(self);
- g_return_if_fail(pos);
- g_return_if_fail(vel);
- g_return_if_fail(acc);
-
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_if_fail(priv);
-
- g_signal_emit(self, signals[LOCATION_UPDATED], 0, LOCATION_ERROR_NONE, pos, vel, acc);
- if (priv->loc_timeout) {
- g_source_remove(priv->loc_timeout);
- priv->loc_timeout = 0;
- }
- location_mock_stop(self);
-}
-
-static int
-location_mock_request_single_location(LocationMock *self, int timeout)
-{
- LOC_FUNC_LOG
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->ops.start, LOCATION_ERROR_NOT_AVAILABLE);
-
- if (__get_started(self) == TRUE) return LOCATION_ERROR_NONE;
-
- int ret = LOCATION_ERROR_NONE;
-
- __set_started(self, TRUE);
- ret = priv->mod->ops.start(priv->mod->handler, mock_status_cb, mock_single_location_cb, self);
- if (ret != LOCATION_ERROR_NONE) {
- LOCATION_LOGE("Fail to start request single. Error[%d]", ret);
- __set_started(self, FALSE);
- return ret;
- } else {
- if (priv->loc_timeout != 0)
- g_source_remove(priv->loc_timeout);
-
- priv->loc_timeout = g_timeout_add_seconds(timeout, __single_location_timeout_cb, self);
- }
-
- return ret;
-}
-
-static int
-location_mock_get_satellite(LocationMock *self, LocationSatellite **satellite)
-{
- return LOCATION_ERROR_NOT_SUPPORTED;
-}
-
-static int
-location_mock_get_last_satellite(LocationMock *self, LocationSatellite **satellite)
-{
- return LOCATION_ERROR_NOT_SUPPORTED;
-}
-
-static int
-location_mock_set_option(LocationMock *self, const char *option)
-{
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->ops.start, LOCATION_ERROR_NOT_AVAILABLE);
-
- int ret = LOCATION_ERROR_NONE;
-
- ret = priv->mod->ops.set_option(priv->mod->handler, option);
- LOC_IF_FAIL_LOG(ret, _E, "Failed to set_option. Error[%d]", ret);
-
- return ret;
-}
-
-static int
-location_mock_get_nmea(LocationMock *self, char **nmea_data)
-{
- return LOCATION_ERROR_NOT_SUPPORTED;
-}
-
-
-/* Tizen 3.0 */
-
-static int
-location_mock_get_status(LocationMock *self, int *status)
-{
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
-
- if (__get_started(self) == TRUE)
- *status = 1;
- else
- *status = 0;
-
- return LOCATION_ERROR_NONE;
-}
-
-
-static void
-__set_mock_location_cb(gboolean enabled, LocationStatus status, gpointer self)
-{
- g_return_if_fail(self);
- LocationObject *obj = (LocationObject *) self;
- LocationMockPrivate *priv = GET_PRIVATE(obj);
- g_return_if_fail(priv);
-
- LOCATION_LOGD("ENTER >>>");
- LOCATION_LOGD("Mock status = %d");
- if (status == LOCATION_STATUS_MOCK_FAIL) {
- /*
- if (priv->enabled == TRUE && status == LOCATION_STATUS_MOCK_FAIL) {
- __set_started(self, FALSE); */
- g_signal_emit(obj, signals[SERVICE_DISABLED], 0, LOCATION_STATUS_NO_FIX);
- /* g_signal_emit(obj, signals[STATUS_CHANGED], 0, LOCATION_STATUS_MOCK_FAIL); */
- }
-
- LOCATION_LOGD("EXIT <<<");
-}
-
-static int
-location_mock_set_mock_location(LocationMock *self, LocationPosition *position, LocationVelocity *velocity, LocationAccuracy *accuracy)
-{
- LOC_FUNC_LOG
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->ops.set_mock_location, LOCATION_ERROR_NOT_AVAILABLE);
-
- int ret = LOCATION_ERROR_NONE;
- if (!location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED)) {
- ret = LOCATION_ERROR_SETTING_OFF;
- } else {
- ret = priv->mod->ops.set_mock_location(priv->mod->handler, position, velocity, accuracy, __set_mock_location_cb, self);
- LOC_IF_FAIL_LOG(ret, _E, "Failed to set_mock_location [%s]", err_msg(ret));
- }
-
- return ret;
-}
-
-static int
-location_mock_clear_mock_location(LocationMock *self)
-{
- LOC_FUNC_LOG
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
- g_return_val_if_fail(priv->mod->ops.set_mock_location, LOCATION_ERROR_NOT_AVAILABLE);
-
- int ret = LOCATION_ERROR_NONE;
- if (!location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED)) {
- ret = LOCATION_ERROR_SETTING_OFF;
- } else {
- ret = priv->mod->ops.clear_mock_location(priv->mod->handler, __set_mock_location_cb, self);
- LOC_IF_FAIL_LOG(ret, _E, "Failed to clear_mock_location [%s]", err_msg(ret));
- }
-
- return ret;
-}
-
-static void _glib_log(const gchar *log_domain, GLogLevelFlags log_level, const gchar *msg, gpointer user_data)
-{
- LOCATION_LOGD("GLIB[%d]: %s", log_level, msg);
-}
-
-
-static void
-location_ielement_interface_init(LocationIElementInterface *iface)
-{
- iface->start = (TYPE_START_FUNC)location_mock_start;
- iface->stop = (TYPE_STOP_FUNC)location_mock_stop;
- iface->get_position = (TYPE_GET_POSITION)location_mock_get_position;
- iface->get_position_ext = (TYPE_GET_POSITION_EXT)location_mock_get_position_ext;
- iface->get_last_position = (TYPE_GET_POSITION)location_mock_get_last_position;
- iface->get_last_position_ext = (TYPE_GET_POSITION_EXT)location_mock_get_last_position_ext;
- iface->get_velocity = (TYPE_GET_VELOCITY)location_mock_get_velocity;
- iface->get_last_velocity = (TYPE_GET_VELOCITY)location_mock_get_last_velocity;
- iface->get_satellite = (TYPE_GET_SATELLITE)location_mock_get_satellite;
- iface->get_last_satellite = (TYPE_GET_SATELLITE)location_mock_get_last_satellite;
- iface->set_option = (TYPE_SET_OPTION)location_mock_set_option;
- iface->request_single_location = (TYPE_REQUEST_SINGLE_LOCATION)location_mock_request_single_location;
- iface->get_nmea = (TYPE_GET_NMEA)location_mock_get_nmea;
-
- iface->get_status = (TYPE_GET_STATUS) location_mock_get_status;
- iface->set_mock_location = (TYPE_SET_MOCK_LOCATION) location_mock_set_mock_location;
- iface->clear_mock_location = (TYPE_CLEAR_MOCK_LOCATION) location_mock_clear_mock_location;
-}
-
-static void
-location_mock_init(LocationMock *self)
-{
- LOC_FUNC_LOG
- LocationMockPrivate *priv = GET_PRIVATE(self);
- g_return_if_fail(priv);
-
- priv->mod = (LocationMockMod *)module_new("mock");
- LOC_COND_LOG(!priv->mod, _E, "Module loading failed");
-
- g_mutex_init(&priv->mutex);
- priv->is_started = FALSE;
- priv->set_noti = FALSE;
- priv->enabled = FALSE;
-
- priv->pos_interval = LOCATION_UPDATE_INTERVAL_DEFAULT;
- priv->vel_interval = LOCATION_UPDATE_INTERVAL_DEFAULT;
- priv->loc_interval = LOCATION_UPDATE_INTERVAL_DEFAULT;
- priv->min_interval = LOCATION_UPDATE_INTERVAL_NONE;
-
- priv->pos_updated_timestamp = 0;
- priv->vel_updated_timestamp = 0;
- priv->loc_updated_timestamp = 0;
-
- priv->pos = NULL;
- priv->vel = NULL;
- priv->acc = NULL;
- priv->boundary_list = NULL;
-
- priv->loc_timeout = 0;
-
- priv->app_type = location_get_app_type(NULL);
- LOC_COND_LOG(priv->app_type == 0, _E, "Fail to get app_type");
-}
-
-static void
-location_mock_class_init(LocationMockClass *klass)
-{
- LOC_FUNC_LOG
-
- GObjectClass *gobject_class = G_OBJECT_CLASS(klass);
-
- g_log_set_default_handler(_glib_log, NULL);
-
-
- gobject_class->set_property = location_mock_set_property;
- gobject_class->get_property = location_mock_get_property;
-
- gobject_class->dispose = location_mock_dispose;
- gobject_class->finalize = location_mock_finalize;
-
- g_type_class_add_private(klass, sizeof(LocationMockPrivate));
-
-
-
- signals[SERVICE_ENABLED] = g_signal_new("service-enabled",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationMockClass, enabled),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
-
-
-
- signals[SERVICE_DISABLED] = g_signal_new("service-disabled",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationMockClass, disabled),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
-
-#if 0 /* TODO: STATUS_CHANGED will aggregate SERVICE_ENABLED and SERVICE_DISABLED */
- signals[STATUS_CHANGED] = g_signal_new("status-changed",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationMockClass, status_changed),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
-#endif
-
- signals[SERVICE_UPDATED] = g_signal_new("service-updated",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationMockClass, service_updated),
- NULL, NULL,
- location_VOID__INT_POINTER_POINTER_POINTER,
- G_TYPE_NONE, 4,
- G_TYPE_INT,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[LOCATION_UPDATED] = g_signal_new("location-updated",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationMockClass, location_updated),
- NULL, NULL,
- location_VOID__INT_POINTER_POINTER_POINTER,
- G_TYPE_NONE, 4,
- G_TYPE_INT,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[ZONE_IN] = g_signal_new("zone-in",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationMockClass, zone_in),
- NULL, NULL,
- location_VOID__POINTER_POINTER_POINTER,
- G_TYPE_NONE, 3,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[ZONE_OUT] = g_signal_new("zone-out",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationMockClass, zone_out),
- NULL, NULL,
- location_VOID__POINTER_POINTER_POINTER,
- G_TYPE_NONE, 3,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- properties[PROP_METHOD_TYPE] = g_param_spec_int("method",
- "method type",
- "location method type name",
- LOCATION_METHOD_MOCK,
- LOCATION_METHOD_MOCK,
- LOCATION_METHOD_MOCK,
- G_PARAM_READABLE);
-
- properties[PROP_IS_STARTED] = g_param_spec_boolean("is_started",
- "mock is started prop",
- "mock is started status",
- FALSE,
- G_PARAM_READWRITE);
-
- properties[PROP_LAST_POSITION] = g_param_spec_boxed("last-position",
- "mock last position prop",
- "mock last position data",
- LOCATION_TYPE_POSITION,
- G_PARAM_READABLE);
-
- properties[PROP_POS_INTERVAL] = g_param_spec_uint("pos-interval",
- "mock position interval prop",
- "mock position interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_VEL_INTERVAL] = g_param_spec_uint("vel-interval",
- "mock velocity interval prop",
- "mock velocity interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_LOC_INTERVAL] = g_param_spec_uint("loc-interval",
- "gps location interval prop",
- "gps location interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_MIN_INTERVAL] = g_param_spec_uint("min-interval",
- "mock distance-based interval prop",
- "mock distance-based interval data",
- LOCATION_MIN_INTERVAL_MIN,
- LOCATION_MIN_INTERVAL_MAX,
- LOCATION_MIN_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_MIN_DISTANCE] = g_param_spec_double("min-distance",
- "mock distance-based distance prop",
- "mock distance-based distance data",
- LOCATION_MIN_DISTANCE_MIN,
- LOCATION_MIN_DISTANCE_MAX,
- LOCATION_MIN_DISTANCE_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_BOUNDARY] = g_param_spec_pointer("boundary",
- "mock boundary prop",
- "mock boundary data",
- G_PARAM_READWRITE);
-
- properties[PROP_REMOVAL_BOUNDARY] = g_param_spec_boxed("removal-boundary",
- "mock removal boundary prop",
- "mock removal boundary data",
- LOCATION_TYPE_BOUNDARY,
- G_PARAM_READWRITE);
-
- /* Tizen 3.0 */
- properties[PROP_SERVICE_STATUS] = g_param_spec_int("service-status",
- "location service status prop",
- "location service status data",
- LOCATION_STATUS_NO_FIX,
- LOCATION_STATUS_3D_FIX,
- LOCATION_STATUS_NO_FIX,
- G_PARAM_READABLE);
-
- g_object_class_install_properties(gobject_class, PROP_MAX, properties);
-}
-
+++ /dev/null
-/*
- * libslp-location
- *
- * Copyright (c) 2010-2013 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Youngae Kang <youngae.kang@samsung.com>, Minjune Kim <sena06.kim@samsung.com>
- * Genie Kim <daejins.kim@samsung.com>
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#ifndef __LOCATION_MOCK_H__
-#define __LOCATION_MOCK_H__
-
-#include <glib-object.h>
-
-/**
- * @file location-mock.h
- * @brief This file contains the internal definitions and structures related to MOCK.
- */
-
-G_BEGIN_DECLS
-
-#define LOCATION_TYPE_MOCK (location_mock_get_type())
-#define LOCATION_MOCK(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), LOCATION_TYPE_MOCK, LocationMock))
-#define LOCATION_IS_MOCK(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), LOCATION_TYPE_MOCK))
-#define LOCATION_MOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), LOCATION_TYPE_MOCK, LocationMockClass))
-#define LOCATION_IS_MOCK_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), LOCATION_TYPE_MOCK))
-#define LOCATION_MOCK_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), LOCATION_TYPE_MOCK, LocationMockClass))
-
-typedef struct _LocationMock LocationMock;
-typedef struct _LocationMockClass LocationMockClass;
-
-struct _LocationMock {
- GObject parent_instance;
-};
-
-struct _LocationMockClass {
- GObjectClass parent_class;
-
- void (*enabled)(guint type);
- void (*disabled)(guint type);
- void (*service_updated)(gint type, gpointer data, gpointer velocity, gpointer accuracy);
- void (*location_updated)(gint error, gpointer position, gpointer velocity, gpointer accuracy);
- void (*zone_in)(gpointer boundary, gpointer position, gpointer accuracy);
- void (*zone_out)(gpointer boundary, gpointer position, gpointer accuracy);
- void (*status_changed)(guint type);
-};
-
-GType location_mock_get_type(void);
-
-G_END_DECLS
-
-#endif
LOCATION_STATUS_NO_FIX = 0, /*/< No fix status. */
LOCATION_STATUS_2D_FIX, /*/< 2D fix status (latitude/longitude/speed/direction). */
LOCATION_STATUS_3D_FIX, /*/< 3D fix status (altitude/climb as well). */
- LOCATION_STATUS_MOCK_SET, /**< MOCK Location set*/
- LOCATION_STATUS_MOCK_FAIL, /**< MOACK Location failed */
} LocationStatus;
/**
const char *event_name = NULL;
event_name = __convert_event_from_vconf(path);
- if (eventsystem_register_event(event_name, &g_event_req_id, (eventsystem_handler) __event_handler, NULL) != ES_R_OK) {
-
+ if (eventsystem_register_event(event_name, &g_event_req_id, (eventsystem_handler) __event_handler, NULL) != ES_R_OK)
LOCATION_SECLOG("eventsystem_register_event failed");
- }
if (vconf_notify_key_changed(path, setting_cb, self)) {
LOCATION_SECLOG("vconf notify add failed [%s]", path);
g_return_val_if_fail(path, -1);
g_return_val_if_fail(setting_cb, -1);
- if (eventsystem_unregister_event(g_event_req_id) != ES_R_OK) {
+ if (eventsystem_unregister_event(g_event_req_id) != ES_R_OK)
LOCATION_SECLOG("eventsystem_unregister_event failed");
- }
if (vconf_ignore_key_changed(path, setting_cb)) {
LOCATION_SECLOG("vconf notify remove failed [%s]", path);
} \
}
-/* For test
-#define VCONFKEY_LOCATION_MOCK_ENABLED "db/location/setting/MockEnabled"
-#define VCONFKEY_LOCATION_MOCK_STATE "memory/location/mock/state"
-*/
-
#endif /* __LOCATION_SETTING_H__ */
*prev_vel = location_velocity_copy(cur_vel);
*prev_acc = location_accuracy_copy(cur_acc);
- LOCATION_LOGD("cur_pos->status = %d", cur_pos->status);
enable_signaling(obj, signals, prev_enabled, enabled, cur_pos->status);
position_velocity_signaling(obj, signals, pos_interval, vel_interval, loc_interval, prev_pos_timestamp, prev_vel_timestamp, prev_loc_timestamp, boundary_list, cur_pos, cur_vel, cur_acc);
}
LocationWpsMod *mod;
GMutex mutex;
gboolean is_started;
+ gboolean is_mock;
guint app_type;
gboolean set_noti;
gboolean enabled;
g_return_if_fail(priv);
if (location_setting_get_key_val(key) == VCONFKEY_LOCATION_WPS_SEARCHING) {
- LOCATION_LOGD("enable_signaling : SERVICE_DISABLED");
- enable_signaling(self, signals, &(priv->enabled), FALSE, LOCATION_STATUS_NO_FIX);
+ if (!location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED)) {
+ LOCATION_LOGD("enable_signaling : SERVICE_DISABLED");
+ enable_signaling(self, signals, &(priv->enabled), FALSE, LOCATION_STATUS_NO_FIX);
+ }
}
}
g_return_if_fail(priv);
g_mutex_clear(&priv->mutex);
+
+ if (priv->is_mock) {
+ priv->mod->ops.clear_mock_location(priv->mod->handler, NULL, gobject);
+ priv->is_mock = FALSE;
+ }
+
if (priv->app_type != CPPAPP && priv->set_noti == TRUE) {
location_setting_ignore_notify(VCONFKEY_LOCATION_NETWORK_ENABLED, location_setting_wps_cb);
location_state_ignore_notify(VCONFKEY_LOCATION_WPS_STATE, location_setting_search_cb);
return LOCATION_ERROR_NOT_SUPPORTED;
}
+static int
+location_wps_set_mock_location(LocationWps *self, LocationPosition *position, LocationVelocity *velocity, LocationAccuracy *accuracy)
+{
+ LOC_FUNC_LOG
+ LocationWpsPrivate *priv = GET_PRIVATE(self);
+ g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
+ g_return_val_if_fail(priv->mod->ops.set_mock_location, LOCATION_ERROR_NOT_AVAILABLE);
+
+ int ret = LOCATION_ERROR_NONE;
+ if (!location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED)) {
+ ret = LOCATION_ERROR_SETTING_OFF;
+ } else {
+ ret = priv->mod->ops.set_mock_location(priv->mod->handler, position, velocity, accuracy, NULL, self);
+ LOC_IF_FAIL_LOG(ret, _E, "Failed to set_mock_location [%s]", err_msg(ret));
+ priv->is_mock = TRUE;
+ }
+
+ return ret;
+}
+
+static int
+location_wps_clear_mock_location(LocationWps *self)
+{
+ LOC_FUNC_LOG
+ LocationWpsPrivate *priv = GET_PRIVATE(self);
+ g_return_val_if_fail(priv->mod->handler, LOCATION_ERROR_NOT_AVAILABLE);
+ g_return_val_if_fail(priv->mod->ops.clear_mock_location, LOCATION_ERROR_NOT_AVAILABLE);
+
+ int ret = LOCATION_ERROR_NONE;
+ if (!location_setting_get_int(VCONFKEY_LOCATION_MOCK_ENABLED)) {
+ ret = LOCATION_ERROR_SETTING_OFF;
+ } else {
+ ret = priv->mod->ops.clear_mock_location(priv->mod->handler, NULL, self);
+ LOC_IF_FAIL_LOG(ret, _E, "Failed to clear_mock_location [%s]", err_msg(ret));
+ priv->is_mock = FALSE;
+ }
+
+ return ret;
+}
+
static void
location_ielement_interface_init(LocationIElementInterface *iface)
{
iface->set_option = (TYPE_SET_OPTION)location_wps_set_option;
iface->request_single_location = (TYPE_REQUEST_SINGLE_LOCATION)location_wps_request_single_location;
iface->get_nmea = (TYPE_GET_NMEA)location_wps_get_nmea;
+ iface->set_mock_location = (TYPE_SET_MOCK_LOCATION) location_wps_set_mock_location;
+ iface->clear_mock_location = (TYPE_CLEAR_MOCK_LOCATION) location_wps_clear_mock_location;
}
static void
g_mutex_init(&priv->mutex);
priv->is_started = FALSE;
+ priv->is_mock = FALSE;
priv->set_noti = FALSE;
priv->enabled = FALSE;
g_type_class_add_private(klass, sizeof(LocationWpsPrivate));
- signals[SERVICE_ENABLED] = g_signal_new("service-enabled",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationWpsClass, enabled),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
-
- signals[SERVICE_DISABLED] = g_signal_new("service-disabled",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationWpsClass, disabled),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
+ signals[SERVICE_ENABLED] =
+ g_signal_new("service-enabled", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationWpsClass, enabled),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
+
+ signals[SERVICE_DISABLED] =
+ g_signal_new("service-disabled", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationWpsClass, disabled),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
#if 0 /* TODO: STATUS_CHANGED will aggregate SERVICE_ENABLED and SERVICE_DISABLED */
- signals[STATUS_CHANGED] = g_signal_new("status-changed",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationWpsClass, status_changed),
- NULL, NULL,
- location_VOID__UINT,
- G_TYPE_NONE, 1,
- G_TYPE_UINT);
+ signals[STATUS_CHANGED] =
+ g_signal_new("status-changed", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationWpsClass, status_changed),
+ NULL, NULL, location_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
#endif
- signals[SERVICE_UPDATED] = g_signal_new("service-updated",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationWpsClass, service_updated),
- NULL, NULL,
- location_VOID__INT_POINTER_POINTER_POINTER,
- G_TYPE_NONE, 4,
- G_TYPE_INT,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[LOCATION_UPDATED] = g_signal_new("location-updated",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationWpsClass, location_updated),
- NULL, NULL,
- location_VOID__INT_POINTER_POINTER_POINTER,
- G_TYPE_NONE, 4,
- G_TYPE_INT,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[ZONE_IN] = g_signal_new("zone-in",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationWpsClass, zone_in),
- NULL, NULL,
- location_VOID__POINTER_POINTER_POINTER,
- G_TYPE_NONE, 3,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- signals[ZONE_OUT] = g_signal_new("zone-out",
- G_TYPE_FROM_CLASS(klass),
- G_SIGNAL_RUN_FIRST |
- G_SIGNAL_NO_RECURSE,
- G_STRUCT_OFFSET(LocationWpsClass, zone_out),
- NULL, NULL,
- location_VOID__POINTER_POINTER_POINTER,
- G_TYPE_NONE, 3,
- G_TYPE_POINTER,
- G_TYPE_POINTER,
- G_TYPE_POINTER);
-
- properties[PROP_METHOD_TYPE] = g_param_spec_int("method",
- "method type",
- "location method type name",
- LOCATION_METHOD_WPS,
- LOCATION_METHOD_WPS,
- LOCATION_METHOD_WPS,
- G_PARAM_READABLE);
-
- properties[PROP_IS_STARTED] = g_param_spec_boolean("is_started",
- "wps is started prop",
- "wps is started status",
- FALSE,
- G_PARAM_READWRITE);
-
- properties[PROP_LAST_POSITION] = g_param_spec_boxed("last-position",
- "wps last position prop",
- "wps last position data",
- LOCATION_TYPE_POSITION,
- G_PARAM_READABLE);
-
- properties[PROP_POS_INTERVAL] = g_param_spec_uint("pos-interval",
- "wps position interval prop",
- "wps position interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_VEL_INTERVAL] = g_param_spec_uint("vel-interval",
- "wps velocity interval prop",
- "wps velocity interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_LOC_INTERVAL] = g_param_spec_uint("loc-interval",
- "gps location interval prop",
- "gps location interval data",
- LOCATION_UPDATE_INTERVAL_MIN,
- LOCATION_UPDATE_INTERVAL_MAX,
- LOCATION_UPDATE_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_MIN_INTERVAL] = g_param_spec_uint("min-interval",
- "wps distance-based interval prop",
- "wps distance-based interval data",
- LOCATION_MIN_INTERVAL_MIN,
- LOCATION_MIN_INTERVAL_MAX,
- LOCATION_MIN_INTERVAL_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_MIN_DISTANCE] = g_param_spec_double("min-distance",
- "wps distance-based distance prop",
- "wps distance-based distance data",
- LOCATION_MIN_DISTANCE_MIN,
- LOCATION_MIN_DISTANCE_MAX,
- LOCATION_MIN_DISTANCE_DEFAULT,
- G_PARAM_READWRITE);
-
- properties[PROP_BOUNDARY] = g_param_spec_pointer("boundary",
- "wps boundary prop",
- "wps boundary data",
- G_PARAM_READWRITE);
-
- properties[PROP_REMOVAL_BOUNDARY] = g_param_spec_boxed("removal-boundary",
- "wps removal boundary prop",
- "wps removal boundary data",
- LOCATION_TYPE_BOUNDARY,
- G_PARAM_READWRITE);
+ signals[SERVICE_UPDATED] =
+ g_signal_new("service-updated", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationWpsClass, service_updated),
+ NULL, NULL, location_VOID__INT_POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 4, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ signals[LOCATION_UPDATED] =
+ g_signal_new("location-updated", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationWpsClass, location_updated),
+ NULL, NULL, location_VOID__INT_POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 4, G_TYPE_INT, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ signals[ZONE_IN] =
+ g_signal_new("zone-in", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationWpsClass, zone_in),
+ NULL, NULL, location_VOID__POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ signals[ZONE_OUT] =
+ g_signal_new("zone-out", G_TYPE_FROM_CLASS(klass),
+ G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
+ G_STRUCT_OFFSET(LocationWpsClass, zone_out),
+ NULL, NULL, location_VOID__POINTER_POINTER_POINTER,
+ G_TYPE_NONE, 3, G_TYPE_POINTER, G_TYPE_POINTER, G_TYPE_POINTER);
+
+ properties[PROP_METHOD_TYPE] =
+ g_param_spec_int("method", "method type", "location method type name",
+ LOCATION_METHOD_WPS, LOCATION_METHOD_WPS, LOCATION_METHOD_WPS, G_PARAM_READABLE);
+
+ properties[PROP_IS_STARTED] =
+ g_param_spec_boolean("is_started", "wps is started prop",
+ "wps is started status", FALSE, G_PARAM_READWRITE);
+
+ properties[PROP_LAST_POSITION] =
+ g_param_spec_boxed("last-position", "wps last position prop",
+ "wps last position data", LOCATION_TYPE_POSITION, G_PARAM_READABLE);
+
+ properties[PROP_POS_INTERVAL] =
+ g_param_spec_uint("pos-interval", "wps position interval prop",
+ "wps position interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_VEL_INTERVAL] =
+ g_param_spec_uint("vel-interval", "wps velocity interval prop",
+ "wps velocity interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_LOC_INTERVAL] =
+ g_param_spec_uint("loc-interval", "gps location interval prop",
+ "gps location interval data", LOCATION_UPDATE_INTERVAL_MIN,
+ LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_MIN_INTERVAL] =
+ g_param_spec_uint("min-interval", "wps distance-based interval prop",
+ "wps distance-based interval data", LOCATION_MIN_INTERVAL_MIN,
+ LOCATION_MIN_INTERVAL_MAX, LOCATION_MIN_INTERVAL_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_MIN_DISTANCE] =
+ g_param_spec_double("min-distance", "wps distance-based distance prop",
+ "wps distance-based distance data", LOCATION_MIN_DISTANCE_MIN,
+ LOCATION_MIN_DISTANCE_MAX, LOCATION_MIN_DISTANCE_DEFAULT, G_PARAM_READWRITE);
+
+ properties[PROP_BOUNDARY] =
+ g_param_spec_pointer("boundary", "wps boundary prop",
+ "wps boundary data", G_PARAM_READWRITE);
+
+ properties[PROP_REMOVAL_BOUNDARY] =
+ g_param_spec_boxed("removal-boundary", "wps removal boundary prop",
+ "wps removal boundary data", LOCATION_TYPE_BOUNDARY, G_PARAM_READWRITE);
/* Tizen 3.0 */
- properties[PROP_SERVICE_STATUS] = g_param_spec_int("service-status",
- "location service status prop",
- "location service status data",
- LOCATION_STATUS_NO_FIX,
- LOCATION_STATUS_3D_FIX,
- LOCATION_STATUS_NO_FIX,
- G_PARAM_READABLE);
-
- g_object_class_install_properties(gobject_class,
- PROP_MAX,
- properties);
+ properties[PROP_SERVICE_STATUS] =
+ g_param_spec_int("service-status", "location service status prop",
+ "location service status data", LOCATION_STATUS_NO_FIX,
+ LOCATION_STATUS_3D_FIX, LOCATION_STATUS_NO_FIX, G_PARAM_READABLE);
+
+ g_object_class_install_properties(gobject_class, PROP_MAX, properties);
}
#include "location-hybrid.h"
#include "location-gps.h"
#include "location-wps.h"
-#include "location-mock.h"
#include "location-position.h"
#include "module-internal.h"
#include "location-common-util.h"
case LOCATION_METHOD_WPS:
key = g_strdup(VCONFKEY_LOCATION_NETWORK_ENABLED);
break;
- case LOCATION_METHOD_MOCK:
+ case INTERNAL_METHOD_MOCK:
key = g_strdup(VCONFKEY_LOCATION_MOCK_ENABLED);
break;
default:
_method = LOCATION_METHOD_GPS;
else if (g_strcmp0(key, VCONFKEY_LOCATION_NETWORK_ENABLED) == 0)
_method = LOCATION_METHOD_WPS;
- else if (g_strcmp0(key, VCONFKEY_LOCATION_MOCK_ENABLED) == 0)
- _method = LOCATION_METHOD_MOCK;
return _method;
}
case LOCATION_METHOD_WPS:
self = g_object_new(LOCATION_TYPE_WPS, NULL);
break;
- case LOCATION_METHOD_MOCK:
- self = g_object_new(LOCATION_TYPE_MOCK, NULL);
default:
break;
}
switch (method) {
case LOCATION_METHOD_HYBRID:
- if (module_is_supported("gps") || module_is_supported("wps") || module_is_supported("mock"))
- is_supported = TRUE;
- break;
+ if (module_is_supported("gps") || module_is_supported("wps"))
+ is_supported = TRUE;
+ break;
case LOCATION_METHOD_GPS:
- is_supported = module_is_supported("gps");
- break;
+ is_supported = module_is_supported("gps");
+ break;
case LOCATION_METHOD_WPS:
- is_supported = module_is_supported("wps");
- break;
- case LOCATION_METHOD_MOCK:
- is_supported = module_is_supported("mock");
- break;
+ is_supported = module_is_supported("wps");
+ break;
default:
break;
}
/*
* Tizen 3.0
*/
-
EXPORT_API int
-location_get_service_state(LocationObject *obj, int *state)
+location_enable_mock(const int enable)
{
- g_return_val_if_fail(obj, LOCATION_ERROR_PARAMETER);
- g_return_val_if_fail(state, LOCATION_ERROR_PARAMETER);
-
int ret = LOCATION_ERROR_NONE;
- ret = location_ielement_get_status(LOCATION_IELEMENT(obj), state);
- LOC_IF_FAIL(ret, _E, "Fail to get_position [%s]", err_msg(ret));
-
- return ret;
-}
-
-
-EXPORT_API int
-location_enable_mock(const LocationMethod method, const int enable)
-{
- int ret = 0;
- char *_key = NULL;
-
- LOC_COND_RET(method != LOCATION_METHOD_MOCK, LOCATION_ERROR_PARAMETER, _E, "Method is not mock [%s]", err_msg(LOCATION_ERROR_PARAMETER));
#ifndef TIZEN_PROFILE_TV
ret = location_check_cynara(LOCATION_PRIVILEGE);
LOC_COND_RET(!developer_option, LOCATION_ERROR_NOT_ALLOWED, _E, "Cannot enable mock location because developer option is not turned on", ret);
#endif
- _key = __convert_setting_key(method);
- LOC_COND_RET(!_key, LOCATION_ERROR_NOT_SUPPORTED, _E, "Invalid method = %d [%s]", method, err_msg(LOCATION_ERROR_NOT_SUPPORTED));
-
- ret = vconf_set_int(_key, enable);
+ ret = vconf_set_int(VCONFKEY_LOCATION_MOCK_ENABLED, enable);
if (ret != VCONF_OK) {
- LOCATION_SECLOG("vconf_set_int failed [%s], ret=[%d]", _key, ret);
- g_free(_key);
+ LOCATION_SECLOG("vconf_set_int failed [MOCK_ENABLED], ret=[%d]", ret);
return LOCATION_ERROR_NOT_ALLOWED;
}
- g_free(_key);
-
return ret;
}
-#if 0
-static char *__convert_mock_setting_key(LocationMethod method)
-{
- char *key = NULL;
- switch (method) {
- case LOCATION_METHOD_MOCK_GPS:
- key = g_strdup(VCONFKEY_LOCATION_MOCK_GPS_ENABLED);
- break;
- case LOCATION_METHOD_MOCK_WPS:
- key = g_strdup(VCONFKEY_LOCATION_MOCK_NETWORK_ENABLED);
- break;
- default:
- break;
- }
- return key;
-}
-
-EXPORT_API int
-location_set_mock_method_enabled(const LocationMethod method, const int enable)
-{
- int ret = 0;
- char *_key = NULL;
- int vconf_val = 0;
-
- _key = __convert_setting_key(method);
- LOC_COND_RET(!_key, LOCATION_ERROR_NOT_SUPPORTED, _E, "Invalid method = %d [%s]", method, err_msg(LOCATION_ERROR_NOT_SUPPORTED));
-
- ret = vconf_get_int(_key, &vconf_val);
- if (ret != VCONF_OK) {
- LOCATION_SECLOG("failed [%s], error [%d]", _key, ret);
- g_free(_key);
- return LOCATION_ERROR_NOT_ALLOWED;
- }
-
- if (vconf_val) {
- _key = __convert_mock_setting_key(method);
- LOC_COND_RET(!_key, LOCATION_ERROR_NOT_SUPPORTED, _E, "Invalid method[%d]", method);
- ret = vconf_set_int(_key, enable);
- if (ret != VCONF_OK) {
- LOCATION_SECLOG("vconf_set_int failed [%s], ret=[%d]", _key, ret);
- g_free(_key);
- return LOCATION_ERROR_NOT_ALLOWED;
- }
- g_free(_key);
- }
-
- return ret;
-}
-#endif
-
-
EXPORT_API int
location_set_mock_location(LocationObject *obj, const LocationPosition *position, const LocationVelocity *velocity, const LocationAccuracy *accuracy)
{
/* Tizen 3.0 */
-int location_get_service_state(LocationObject *obj, int *state);
-int location_enable_mock(const LocationMethod method, const int enable);
-int location_set_mock_method_enabled(const LocationMethod method, const int enable);
+int location_enable_mock(const int enable);
+
int location_set_mock_location(LocationObject *obj, const LocationPosition *position, const LocationVelocity *velocity, const LocationAccuracy *accuracy);
+
int location_clear_mock_location(LocationObject *obj);
int location_enable_restriction(const int enable);
int (*get_last_satellite)(gpointer handle, LocationSatellite **satellite); /*/< This is used for getting a last satellite information from a plug-in. */
int (*set_option)(gpointer handle, const char *option);
int (*set_position_update_interval)(gpointer handle, guint interval);
+ int (*set_mock_location)(gpointer handle, LocationPosition *position, LocationVelocity *velocity, LocationAccuracy *accuracy, LocModStatusCB status_cb, gpointer userdata);
+ int (*clear_mock_location)(gpointer handle, LocModStatusCB status_cb, gpointer userdata);
} LocModGpsOps;
/**
int (*get_position)(gpointer handle, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy); /*/< This is used for getting a position from a plug-in. */
int (*get_last_position)(gpointer handle, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy); /*/< This is used for getting a last position from a plug-in. */
int (*set_option)(gpointer handle, const char *option);
+ int (*set_mock_location)(gpointer handle, LocationPosition *position, LocationVelocity *velocity, LocationAccuracy *accuracy, LocModStatusCB status_cb, gpointer userdata);
+ int (*clear_mock_location)(gpointer handle, LocModStatusCB status_cb, gpointer userdata);
} LocModWpsOps;
-typedef struct {
- int (*start)(gpointer handle, LocModStatusCB status_cb, LocModPositionExtCB pos_ext_cb, gpointer userdata); /*/< This is used for starting a GPS device from a plug-in. #LocModStatusCB, #LocModPositionExtCB are given from a location framework to a plug-in for asynchronous signaling. */
- int (*stop)(gpointer handle); /*/< This is used for stopping a GPS device name from a plug-in. */
-#if 0 /* Mock doesn't support batch */
- int (*start_batch)(gpointer handle, LocModBatchExtCB batch_ext_cb, guint batch_interval, guint batch_period, gpointer userdata); /*/< This is used for starting a GPS batch mode from a plug-in. #LocModBatchExtCB are given from a location framework to a plug-in for asynchronous signaling. */
- int (*stop_batch)(gpointer handle); /*/< This is used for stopping a GPS batch mode from a plug-in. */
-#endif
- int (*get_position)(gpointer handle, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy); /*/< This is used for getting a position from a plug-in. */
- int (*get_last_position)(gpointer handle, LocationPosition **position, LocationVelocity **velocity, LocationAccuracy **accuracy); /*/< This is used for getting a last position from a plug-in. */
- int (*set_option)(gpointer handle, const char *option);
- /* int (*set_position_update_interval)(gpointer handle, guint interval); */
- int (*set_mock_location)(gpointer handle, LocationPosition *position, LocationVelocity *velocity, LocationAccuracy *accuracy, LocModStatusCB status_cb, gpointer userdata); /*/< This is used for getting a position from a plug-in. */
- int (*clear_mock_location)(gpointer handle, LocModStatusCB status_cb, gpointer userdata); /*/< This is used for getting a position from a plug-in. */
-} LocModMockOps;
-
/**
* @brief This is used for exported APIs in a plug-in for a location framework.
*/
ret_mod = NULL;
} else
ret_mod = (gpointer) _mod;
- } else if (g_str_has_prefix(module_name, "mock")) {
- LocationMockMod *_mod = g_new0(LocationMockMod, 1);
- _mod->gmod = gmod;
- _mod->init = init;
- _mod->shutdown = shutdown;
- _mod->handler = _mod->init(&(_mod->ops));
- if (!_mod->handler) {
- LOCATION_LOGW("module init failed");
- gmod_free(_mod->gmod);
- ret_mod = NULL;
- } else
- ret_mod = (gpointer) _mod;
} else {
LOCATION_LOGW("module name (%s) is wrong", module_name);
ret_mod = NULL;
_mod->shutdown = NULL;
gmod_free(_mod->gmod);
_mod->gmod = NULL;
- } else if (0 == g_strcmp0(module_name, "mock")) {
- LocationMockMod *_mod = (LocationMockMod *) mod;
- if (_mod->shutdown && _mod->handler)
- _mod->shutdown(_mod->handler);
-
- _mod->handler = NULL;
- _mod->init = NULL;
- _mod->shutdown = NULL;
- gmod_free(_mod->gmod);
- _mod->gmod = NULL;
} else {
LOCATION_LOGW("module name (%s) is wrong", module_name);
}
LocModWpsOps ops;
} LocationWpsMod;
-typedef struct {
- GMod *gmod;
- gpointer handler;
- gpointer(*init)(LocModMockOps *ops);
- void (*shutdown)(gpointer handle);
- LocModMockOps ops;
-} LocationMockMod;
-
gboolean module_init(void);
gpointer module_new(const char *module_name);
void module_free(gpointer mod, const char *module_name);
+[Version] libslp-location_1.3.2
+[Date] 18 Aug 2016
+[Changes] Change mock location behavior
+[Developer] Kyoungjun Sung <kj7.sung@samsung.com>
+
+================================================================================
[Version] libslp-location_1.3.1
[Date] 3 Jun 2016
[Changes] Change service state behavior when GPS/WPS searching mode
Name: liblbs-location
Summary: Location Based Service Library
-Version: 1.3.1
+Version: 1.3.2
Release: 1
Group: Location/Libraries
License: Apache-2.0
projects / platform / core / location / lbs-location.git / commitdiff