gboolean is_started;
gboolean is_batch_invoked;
gboolean is_mock;
- guint app_type;
gboolean set_noti;
gboolean enabled;
gint signal_type;
+ guint app_type;
guint pos_updated_timestamp;
- guint pos_interval;
guint vel_updated_timestamp;
- guint vel_interval;
guint sat_updated_timestamp;
- guint sat_interval;
guint loc_updated_timestamp;
+ guint dist_updated_timestamp;
+ guint pos_interval;
+ guint vel_interval;
+ guint sat_interval;
guint loc_interval;
+ guint optimized_interval;
guint loc_timeout;
guint batch_interval;
guint batch_period;
- guint dist_updated_timestamp;
guint min_interval;
gdouble min_distance;
LocationPosition *pos;
} else if (1 == location_setting_get_key_val(key) && 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, priv->pos_interval, gps_status_cb, gps_location_cb, gps_satellite_cb, self);
+ ret = priv->mod->ops.start(priv->mod->handler, priv->optimized_interval, gps_status_cb, gps_location_cb, gps_satellite_cb, self);
if (ret != LOCATION_ERROR_NONE) {
__set_started(self, FALSE);
LOCATION_LOGI("Fail to start[%d]", ret);
return LOCATION_ACCESS_DENIED;
} else {
__set_started(self, TRUE);
- ret = priv->mod->ops.start(priv->mod->handler, priv->pos_interval, gps_status_cb, gps_location_cb, gps_satellite_cb, self);
+ ret = priv->mod->ops.start(priv->mod->handler, priv->optimized_interval, gps_status_cb, gps_location_cb, gps_satellite_cb, self);
if (ret != LOCATION_ERROR_NONE) {
LOCATION_LOGE("Fail to start gps. Error[%d]", ret);
__set_started(self, FALSE);
if (priv->app_type != CPPAPP && priv->set_noti == FALSE) {
location_setting_add_notify(VCONFKEY_LOCATION_ENABLED, location_setting_gps_cb, self);
-
location_state_add_notify(VCONFKEY_LOCATION_GPS_STATE, location_setting_search_cb, self);
priv->set_noti = TRUE;
}
G_OBJECT_CLASS(location_gps_parent_class)->finalize(gobject);
}
+static guint get_valid_interval(guint interval, int max_interval, int min_interval)
+{
+ if (interval > max_interval)
+ return (guint)max_interval;
+ else if (interval < min_interval)
+ return (guint)min_interval;
+ else
+ return interval;
+}
+
static void location_gps_set_property(GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
LocationGpsPrivate *priv = GET_PRIVATE(object);
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;
- }
+ priv->pos_interval = get_valid_interval(interval, LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_MIN);
+ priv->optimized_interval = priv->pos_interval;
if (__get_started(object) == TRUE) {
LOCATION_LOGD("[update_pos_interval]: update pos-interval while pos-tracking");
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;
- }
+ priv->vel_interval = get_valid_interval(interval, LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_MIN);
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;
- }
+ priv->sat_interval = get_valid_interval(interval, LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_MIN);
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;
+ if (interval == priv->loc_interval) break;
+
+ priv->loc_interval = get_valid_interval(interval, LOCATION_UPDATE_INTERVAL_MAX, LOCATION_UPDATE_INTERVAL_MIN);
+ priv->optimized_interval = priv->loc_interval;
+
+ if (__get_started(object) == TRUE) {
+ LOCATION_LOGD("[update_pos_interval]: update loc-interval while loc-tracking");
+ g_return_if_fail(priv->mod->ops.set_position_update_interval);
+ priv->mod->ops.set_position_update_interval(priv->mod->handler, priv->loc_interval);
}
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;
- }
+
+ priv->batch_interval = interval;
if (__get_started(object) == TRUE) {
LOCATION_LOGD("[update_batch_interval]: update batch-interval while pos-tracking");
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;
- }
+ priv->batch_period = interval;
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;
- }
+ priv->min_interval = interval;
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;
- }
-
+ priv->min_distance = distance;
break;
}
case PROP_SERVICE_STATUS: {
int ret = LOCATION_ERROR_NONE;
__set_started(self, TRUE);
- ret = priv->mod->ops.start(priv->mod->handler, priv->pos_interval, gps_status_cb, gps_single_location_cb, NULL, self);
+ ret = priv->mod->ops.start(priv->mod->handler, LOCATION_UPDATE_INTERVAL_DEFAULT, gps_status_cb, gps_single_location_cb, NULL, self);
if (ret != LOCATION_ERROR_NONE) {
LOCATION_LOGE("Fail to start request single. Error[%d]", ret);
__set_started(self, FALSE);
priv->batch_interval = LOCATION_UPDATE_INTERVAL_DEFAULT;
priv->batch_period = LOCATION_BATCH_PERIOD_DEFAULT;
priv->min_interval = LOCATION_UPDATE_INTERVAL_NONE;
+ priv->optimized_interval = LOCATION_UPDATE_INTERVAL_DEFAULT;
priv->pos_updated_timestamp = 0;
priv->vel_updated_timestamp = 0;
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);
-#endif
-
signals[SERVICE_UPDATED] =
g_signal_new("service-updated", G_TYPE_FROM_CLASS(klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
gboolean wps_enabled;
gint signal_type;
guint pos_updated_timestamp;
- guint pos_interval;
guint vel_updated_timestamp;
- guint vel_interval;
guint sat_updated_timestamp;
- guint sat_interval;
guint dist_updated_timestamp;
+ guint loc_updated_timestamp;
+ guint pos_interval;
+ guint vel_interval;
+ guint sat_interval;
guint min_interval;
gdouble min_distance;
- guint loc_updated_timestamp;
guint loc_interval;
LocationObject *gps;
LocationObject *wps;
}
-#if 0
-static void
-hybrid_status_changed(GObject *obj, guint status, gpointer self)
-{
- LOCATION_LOGD("status = %d", status);
- LocationHybridPrivate *priv = GET_PRIVATE((LocationHybrid *)self);
- g_return_if_fail(priv);
- GType g_type = G_TYPE_FROM_INSTANCE(obj);
-
-
- switch (status) {
- case LOCATION_STATUS_NO_FIX:
- 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;
-
- case LOCATION_STATUS_2D_FIX:
- case LOCATION_STATUS_3D_FIX:
- if (g_type == LOCATION_TYPE_GPS) {
- priv->gps_enabled = TRUE;
- } else if (g_type == LOCATION_TYPE_WPS) {
- priv->wps_enabled = TRUE;
- } else {
- LOCATION_LOGW("Undefined GType enabled");
- return;
- }
- hybrid_get_update_method(priv);
- break;
-
- case LOCATION_STATUS_MOCK_SET:
- break;
-
- default:
- LOCATION_LOGW("Undefined status");
- break;
- }
-}
-#endif
-
-
static int
location_hybrid_start(LocationHybrid *self)
{
if (priv->gps) {
g_signal_handlers_disconnect_by_func(priv->gps, G_CALLBACK(hybrid_service_enabled), gobject);
g_signal_handlers_disconnect_by_func(priv->gps, G_CALLBACK(hybrid_service_disabled), gobject);
- /* g_signal_handlers_disconnect_by_func(priv->gps, G_CALLBACK(hybrid_status_changed), gobject); */
g_signal_handlers_disconnect_by_func(priv->gps, G_CALLBACK(hybrid_service_updated), gobject);
g_signal_handlers_disconnect_by_func(priv->gps, G_CALLBACK(hybrid_location_updated), gobject);
- location_free(priv->gps);
+ location_free(priv->gps, TRUE);
}
if (priv->wps) {
g_signal_handlers_disconnect_by_func(priv->wps, G_CALLBACK(hybrid_service_enabled), gobject);
g_signal_handlers_disconnect_by_func(priv->wps, G_CALLBACK(hybrid_service_disabled), gobject);
- /* g_signal_handlers_disconnect_by_func(priv->wps, G_CALLBACK(hybrid_status_changed), gobject); */
g_signal_handlers_disconnect_by_func(priv->wps, G_CALLBACK(hybrid_service_updated), gobject);
g_signal_handlers_disconnect_by_func(priv->wps, G_CALLBACK(hybrid_location_updated), gobject);
- location_free(priv->wps);
+ location_free(priv->wps, TRUE);
}
if (priv->boundary_list) {
priv->pos_timer = 0;
priv->vel_timer = 0;
- 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_GPS)) priv->gps = location_new(LOCATION_METHOD_GPS, TRUE);
+ if (location_is_supported_method(LOCATION_METHOD_WPS)) priv->wps = location_new(LOCATION_METHOD_WPS, TRUE);
if (priv->gps) {
g_signal_connect(priv->gps, "service-enabled", G_CALLBACK(hybrid_service_enabled), self);
g_signal_connect(priv->gps, "service-disabled", G_CALLBACK(hybrid_service_disabled), self);
- /* g_signal_connect(priv->gps, "status-changed", G_CALLBACK(hybrid_status_changed), self); */
g_signal_connect(priv->gps, "service-updated", G_CALLBACK(hybrid_service_updated), self);
g_signal_connect(priv->gps, "location-updated", G_CALLBACK(hybrid_location_updated), self);
}
if (priv->wps) {
g_signal_connect(priv->wps, "service-enabled", G_CALLBACK(hybrid_service_enabled), self);
g_signal_connect(priv->wps, "service-disabled", G_CALLBACK(hybrid_service_disabled), self);
- /* g_signal_connect(priv->wps, "status-changed", G_CALLBACK(hybrid_status_changed), 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);
}
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);
-#endif
-
signals[SERVICE_UPDATED] =
g_signal_new("service-updated", G_TYPE_FROM_CLASS(klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
typedef int (*TYPE_GET_NMEA)(LocationIElement *self, char **nmea);
/* Tizen 3.0 */
-typedef int (*TYPE_GET_STATUS)(LocationIElement *self, int *status);
typedef int (*TYPE_SET_MOCK_LOCATION)(LocationIElement *self, const LocationPosition *position, const LocationVelocity *velocity, const LocationAccuracy *accuracy);
typedef int (*TYPE_CLEAR_MOCK_LOCATION)(LocationIElement *self);
gboolean set_noti;
gboolean enabled;
guint pos_updated_timestamp;
- guint pos_interval;
guint vel_updated_timestamp;
- guint vel_interval;
guint loc_updated_timestamp;
+ guint dist_updated_timestamp;
+ guint pos_interval;
+ guint vel_interval;
guint loc_interval;
guint loc_timeout;
- guint dist_updated_timestamp;
guint min_interval;
gdouble min_distance;
LocationPosition *pos;
G_STRUCT_OFFSET(LocationPassiveClass, 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(LocationPassiveClass, 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,
*prev_enabled = FALSE;
LOCATION_LOGD("Signal emit: SERVICE_DISABLED, status = %d", status);
g_signal_emit(obj, signals[SERVICE_DISABLED], 0, LOCATION_STATUS_NO_FIX);
- /* g_signal_emit(obj, signals[STATUS_CHANGED], 0, LOCATION_STATUS_NO_FIX); */
} else if (*prev_enabled == FALSE && enabled == TRUE) {
*prev_enabled = TRUE;
LOCATION_LOGD("Signal emit: SERVICE_ENABLED, status = %d", status);
g_signal_emit(obj, signals[SERVICE_ENABLED], 0, status);
- /* g_signal_emit(obj, signals[STATUS_CHANGED], 0, status); */
}
-#if 0
- } else if (*prev_enabled != enabled) {
- LOCATION_LOGD("Signal emit: prev_enabled = %d, enabled = %d, status = %d", *prev_enabled, enabled, status);
- /* g_signal_emit(obj, signals[STATUS_CHANGED], 0, status); */
- }
-#endif
}
void
gboolean set_noti;
gboolean enabled;
guint pos_updated_timestamp;
- guint pos_interval;
guint vel_updated_timestamp;
- guint vel_interval;
guint loc_updated_timestamp;
+ guint dist_updated_timestamp;
+ guint pos_interval;
+ guint vel_interval;
guint loc_interval;
guint loc_timeout;
- guint dist_updated_timestamp;
guint min_interval;
gdouble min_distance;
LocationPosition *pos;
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);
-#endif
-
signals[SERVICE_UPDATED] =
g_signal_new("service-updated", G_TYPE_FROM_CLASS(klass),
G_SIGNAL_RUN_FIRST | G_SIGNAL_NO_RECURSE,
#include "location-privacy.h"
#endif
-#define LOCATION_PRIVILEGE "http://tizen.org/privilege/location"
+#define LOCATION_PRIVILEGE "http://tizen.org/privilege/location"
#define LOCATION_ENABLE_PRIVILEGE "http://tizen.org/privilege/location.enable"
+#define HYBRID 2
typedef struct _LocationSetting {
LocationSettingCb callback;
void *user_data;
} LocationSetting;
+enum {
+ _METHOD_HYBRID = 0,
+ _METHOD_GPS_1,
+ _METHOD_GPS_2,
+ _METHOD_WPS_1,
+ _METHOD_WPS_2,
+ _METHOD_MAX
+};
+
static LocationSetting g_location_setting;
+static bool is_method_created[_METHOD_MAX] = {false};
static char *__convert_setting_key(LocationMethod method)
{
}
EXPORT_API LocationObject *
-location_new(LocationMethod method)
+location_new(LocationMethod method, gboolean is_internal_for_hybrid)
{
LocationObject *self = NULL;
- LOCATION_LOGD("method: %d", method);
+ LOCATION_LOGD("method : %d, is_internal_for_hybrid[%d]", method, is_internal_for_hybrid);
switch (method) {
case LOCATION_METHOD_HYBRID:
- self = g_object_new(LOCATION_TYPE_HYBRID, NULL);
+ if (is_method_created[_METHOD_HYBRID]) {
+ LOCATION_LOGE("Hybrid handle already exist.");
+ } else {
+ self = g_object_new(LOCATION_TYPE_HYBRID, NULL);
+ is_method_created[_METHOD_HYBRID] = true;
+ }
break;
case LOCATION_METHOD_GPS:
- self = g_object_new(LOCATION_TYPE_GPS, NULL);
+ if (is_internal_for_hybrid) {
+ if (is_method_created[_METHOD_GPS_2]) {
+ LOCATION_LOGD("Hybrid(GPS) handle already exist.");
+ } else {
+ is_method_created[_METHOD_GPS_2] = true;
+ self = g_object_new(LOCATION_TYPE_GPS, NULL);
+ }
+ } else {
+ if (is_method_created[_METHOD_GPS_1]) {
+ LOCATION_LOGE("GPS handle already exist.");
+ } else {
+ is_method_created[_METHOD_GPS_1] = true;
+ self = g_object_new(LOCATION_TYPE_GPS, NULL);
+ }
+ }
break;
case LOCATION_METHOD_WPS:
- self = g_object_new(LOCATION_TYPE_WPS, NULL);
+ if (is_internal_for_hybrid) {
+ if (is_method_created[_METHOD_WPS_2]) {
+ LOCATION_LOGD("Hybrid(WPS) handle already exist.");
+ } else {
+ is_method_created[_METHOD_WPS_2] = true;
+ self = g_object_new(LOCATION_TYPE_WPS, NULL);
+ }
+ } else {
+ if (is_method_created[_METHOD_WPS_1]) {
+ LOCATION_LOGE("WPS handle already exist.");
+ } else {
+ is_method_created[_METHOD_WPS_1] = true;
+ self = g_object_new(LOCATION_TYPE_WPS, NULL);
+ }
+ }
break;
case LOCATION_METHOD_PASSIVE:
self = g_object_new(LOCATION_TYPE_PASSIVE, NULL);
}
EXPORT_API int
-location_free(LocationObject *obj)
+location_free(LocationObject *obj, gboolean is_internal_for_hybrid)
{
g_return_val_if_fail(obj, LOCATION_ERROR_PARAMETER);
+ if (G_OBJECT_TYPE(obj) == LOCATION_TYPE_HYBRID) {
+ is_method_created[_METHOD_HYBRID] = false;
+ } else if (G_OBJECT_TYPE(obj) == LOCATION_TYPE_GPS) {
+ if (is_internal_for_hybrid)
+ is_method_created[_METHOD_GPS_2] = false;
+ else
+ is_method_created[_METHOD_GPS_1] = false;
+ } else if (G_OBJECT_TYPE(obj) == LOCATION_TYPE_WPS) {
+ if (is_internal_for_hybrid)
+ is_method_created[_METHOD_WPS_2] = false;
+ else
+ is_method_created[_METHOD_WPS_1] = false;
+ }
g_object_unref(obj);
return LOCATION_ERROR_NONE;
}
* @retval NULL if error occured
* @see location_free
*/
-LocationObject *location_new(LocationMethod method);
+LocationObject *location_new(LocationMethod method, gboolean is_internal_for_hybrid);
/**
* @brief Free memory of given #LocationObject.
* @retval 0 Success.
* Please refer #LocationError for more information.
*/
-int location_free(LocationObject *obj);
+int location_free(LocationObject *obj, gboolean is_internal_for_hybrid);
/**
* @brief Start the location service by using given #LocationObject.
+[Version] libslp-location_1.3.5
+[Date] 28 Oct 2016
+[Changes] Dynamic interval table for multi handle
+[Developer] Kyoungjun Sung <kj7.sung@samsung.com>
+
+================================================================================
[Version] libslp-location_1.3.4
[Date] 6 Sep 2016
[Changes] Passive location
Name: liblbs-location
Summary: Location Based Service Library
-Version: 1.3.4
+Version: 1.3.5
Release: 1
Group: Location/Libraries
License: Apache-2.0
projects / platform / core / location / lbs-location.git / commitdiff