guint *optimized_interval_array;
guint temp_minimum_interval;
gboolean is_needed_changing_interval;
-#ifndef TIZEN_DEVICE
- GHashTable *batch_interval_table;
- guint *optimized_batch_array;
-#endif
lbs_server_dbus_h lbs_dbus_server;
int method;
} dynamic_interval_updator_user_data;
-#ifndef TIZEN_DEVICE
-typedef enum {
- LBS_BATCH_INTERVAL = 0,
- LBS_BATCH_PERIOD,
- LBS_BATCH_SIZE,
-} lbs_batch_interval;
-#endif
-
static gboolean gps_remove_all_clients(lbs_server_s *lbs_server);
static NpsManagerPositionExt g_mock_position;
static void set_mock_location_cb(gint method, gdouble latitude, gdouble longitude, gdouble altitude, gdouble speed, gdouble direction, gdouble accuracy, gpointer userdata);
g_mutex_unlock(&lbs_server->mutex);
}
-#ifndef TIZEN_DEVICE
static void start_batch_tracking(lbs_server_s *lbs_server, int batch_interval, int batch_period)
{
- LOG_GPS(DBG_LOW, "start_batch_tracking");
g_mutex_lock(&lbs_server->mutex);
lbs_server->gps_client_count++;
g_mutex_unlock(&lbs_server->mutex);
- if (lbs_server->is_gps_running == FALSE) {
- LOG_GPS(DBG_LOW, "Batch: start_tracking GPS");
- lbs_server->status = LBS_STATUS_ACQUIRING;
+ if (lbs_server->is_gps_running == TRUE) {
+ LOG_GPS(DBG_LOW, "Batch: gps is already running");
+ return;
}
+ LOG_GPS(DBG_LOW, "Batch: start_tracking GPS");
+ lbs_server->status = LBS_STATUS_ACQUIRING;
if (request_start_batch_session(batch_interval, batch_period) == TRUE) {
g_mutex_lock(&lbs_server->mutex);
lbs_server->is_gps_running = TRUE;
g_mutex_unlock(&lbs_server->mutex);
+ lbs_server->is_needed_changing_interval = FALSE;
+
+ /* ADD notify */
setting_notify_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb, lbs_server);
} else {
LOG_GPS(DBG_ERR, "Batch: Fail to request_start_batch_session");
}
}
-static void stop_batch_tracking(lbs_server_s *lbs_server, int batch_interval, int batch_period)
+static void stop_batch_tracking(lbs_server_s *lbs_server)
{
- LOG_GPS(DBG_LOW, "Batch: stop_tracking GPS");
+ LOG_GPS(DBG_LOW, "ENTER >>>");
g_mutex_lock(&lbs_server->mutex);
lbs_server->gps_client_count--;
return;
}
- int session_status = 1; /* Keep current status */
if (lbs_server->gps_client_count <= 0) {
g_mutex_lock(&lbs_server->mutex);
lbs_server->gps_client_count = 0;
- g_mutex_unlock(&lbs_server->mutex);
- session_status = 0; /* stop */
- }
- /* TURE: All clients stopped, FALSE: Some clients are running with GPS or BATCH */
- if (request_stop_batch_session(batch_interval, batch_period, session_status) == TRUE) {
- g_mutex_lock(&lbs_server->mutex);
- lbs_server->is_gps_running = FALSE;
- lbs_server->sv_used = FALSE;
- g_mutex_unlock(&lbs_server->mutex);
-
- setting_ignore_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb);
+ if (request_stop_batch_session() == TRUE) {
+ lbs_server->is_gps_running = FALSE;
+ lbs_server->sv_used = FALSE;
+ /* remove notify */
+ setting_ignore_key_changed(VCONFKEY_LOCATION_ENABLED, __setting_gps_cb);
+ g_mutex_unlock(&lbs_server->mutex);
+ }
}
lbs_server->status = LBS_STATUS_UNAVAILABLE;
lbs_server_emit_status_changed(lbs_server->lbs_dbus_server, LBS_SERVER_METHOD_GPS, LBS_STATUS_UNAVAILABLE);
}
-#endif
static void start_tracking(lbs_server_s *lbs_server, lbs_server_method_e method)
{
/* manipulate logic for dynamic-interval hash table */
switch (type) {
case LBS_SERVER_INTERVAL_ADD: {
- LOG_GPS(DBG_LOW, "ADD, client[%s], method[%d], interval[%u]", client, method, interval);
- gchar *client_cpy = NULL;
- client_cpy = g_strdup(client);
-
- guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client_cpy);
- if (!interval_array) {
- /* LOG_GPS(DBG_LOW, "first add key[%s] to interval-table", client); */
- interval_array = (guint *)g_malloc0(LBS_SERVER_METHOD_SIZE * sizeof(guint));
+ LOG_GPS(DBG_LOW, "ADD, client[%s], method[%d], interval[%u]", client, method, interval);
+ gchar *client_cpy = NULL;
+ client_cpy = g_strdup(client);
+
+ guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client_cpy);
if (!interval_array) {
- /* LOG_GPS(DBG_ERR, "interval_array is NULL"); */
- g_free(client_cpy);
- return FALSE;
+ /* LOG_GPS(DBG_LOW, "first add key[%s] to interval-table", client); */
+ interval_array = (guint *)g_malloc0(LBS_SERVER_METHOD_SIZE * sizeof(guint));
+ if (!interval_array) {
+ /* LOG_GPS(DBG_ERR, "interval_array is NULL"); */
+ g_free(client_cpy);
+ return FALSE;
+ }
+ g_hash_table_insert(lbs_server->dynamic_interval_table, (gpointer)client_cpy, (gpointer)interval_array);
}
- g_hash_table_insert(lbs_server->dynamic_interval_table, (gpointer)client_cpy, (gpointer)interval_array);
+ interval_array[method] = interval;
+ lbs_server->temp_minimum_interval = interval;
+ /* LOG_GPS(DBG_LOW, "ADD done"); */
+ break;
}
- interval_array[method] = interval;
- lbs_server->temp_minimum_interval = interval;
- /* LOG_GPS(DBG_LOW, "ADD done"); */
- break;
- }
case LBS_SERVER_INTERVAL_REMOVE: {
- LOG_GPS(DBG_LOW, "REMOVE, client[%s], method[%d]", client, method);
- lbs_server->temp_minimum_interval = 120; /* interval max value */
- guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client);
- if (!interval_array) {
- LOG_GPS(DBG_INFO, "Client[%s] Method[%d] is already removed from interval-table", client, method);
- break;
- }
- LOG_GPS(DBG_LOW, "Found interval_array[%d](%p):[%u] from interval-table", method, interval_array, interval_array[method]);
- interval_array[method] = 0;
-
- int i = 0;
- guint interval_each = 0;
- gboolean is_need_remove_client_from_table = TRUE;
- for (i = 0; i < LBS_SERVER_METHOD_SIZE; i++) {
- interval_each = interval_array[i];
- if (interval_each != 0) {
- LOG_GPS(DBG_LOW, "[%s] method[%d]'s interval is not zero - interval: %d. It will not be removed.", client, i, interval_each);
- is_need_remove_client_from_table = FALSE;
+ LOG_GPS(DBG_LOW, "REMOVE, client[%s], method[%d]", client, method);
+ lbs_server->temp_minimum_interval = 120; /* interval max value */
+ guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client);
+ if (!interval_array) {
+ LOG_GPS(DBG_INFO, "Client[%s] Method[%d] is already removed from interval-table", client, method);
break;
}
- }
+ LOG_GPS(DBG_LOW, "Found interval_array[%d](%p):[%u] from interval-table", method, interval_array, interval_array[method]);
+ interval_array[method] = 0;
+
+ int i = 0;
+ guint interval_each = 0;
+ gboolean is_need_remove_client_from_table = TRUE;
+ for (i = 0; i < LBS_SERVER_METHOD_SIZE; i++) {
+ interval_each = interval_array[i];
+ if (interval_each != 0) {
+ LOG_GPS(DBG_LOW, "[%s] method[%d]'s interval is not zero - interval: %d. It will not be removed.", client, i, interval_each);
+ is_need_remove_client_from_table = FALSE;
+ break;
+ }
+ }
- if (is_need_remove_client_from_table) {
- LOG_GPS(DBG_LOW, "is_need_remove_client_from_table is TRUE");
- if (!g_hash_table_remove(lbs_server->dynamic_interval_table, client))
- LOG_GPS(DBG_ERR, "g_hash_table_remove is failed.");
+ if (is_need_remove_client_from_table) {
+ LOG_GPS(DBG_LOW, "is_need_remove_client_from_table is TRUE");
+ if (!g_hash_table_remove(lbs_server->dynamic_interval_table, client))
+ LOG_GPS(DBG_ERR, "g_hash_table_remove is failed.");
- LOG_GPS(DBG_LOW, "REMOVE done.");
+ LOG_GPS(DBG_LOW, "REMOVE done.");
+ }
+ break;
}
- break;
- }
case LBS_SERVER_INTERVAL_UPDATE: {
- LOG_GPS(DBG_LOW, "UPDATE client[%s], method[%d], interval[%u]", client, method, interval);
- guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client);
- if (!interval_array) {
- LOG_GPS(DBG_LOW, "Client[%s] is not exist in interval-table", client, method);
+ LOG_GPS(DBG_LOW, "UPDATE client[%s], method[%d], interval[%u]", client, method, interval);
+ guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->dynamic_interval_table, client);
+ if (!interval_array) {
+ LOG_GPS(DBG_LOW, "Client[%s] is not exist in interval-table", client, method);
+ break;
+ }
+ interval_array[method] = interval;
+ lbs_server->temp_minimum_interval = interval;
+ LOG_GPS(DBG_LOW, "UPDATE done.");
break;
}
- interval_array[method] = interval;
- lbs_server->temp_minimum_interval = interval;
- LOG_GPS(DBG_LOW, "UPDATE done.");
- break;
- }
default: {
- LOG_GPS(DBG_ERR, "unhandled interval-update type");
- return FALSE;
- }
+ LOG_GPS(DBG_ERR, "unhandled interval-update type");
+ return FALSE;
+ }
}
/* update logic for optimized-interval value */
ret_val = FALSE;
} else {
+ LOG_GPS(DBG_LOW, "dynamic_interval_table size is not zero.");
+
dynamic_interval_updator_user_data updator_user_data;
updator_user_data.lbs_server = lbs_server;
updator_user_data.method = method;
else
ret_val = FALSE;
}
+ LOG_GPS(DBG_LOW, "update_pos_tracking_interval done.");
return ret_val;
}
LOG_GPS(DBG_LOW, "timestmap: %d, nmea_data: %s", *timestamp, *nmea_data);
}
-#ifndef TIZEN_DEVICE
-static gboolean update_batch_tracking_interval(lbs_server_interval_manipulation_type type, const gchar *client, guint interval, guint period, gpointer userdata);
-#endif
-
static void set_options(GVariant *options, const gchar *client, gpointer userdata)
{
LOG_GPS(DBG_LOW, "ENTER >>>");
lbs_server->is_needed_changing_interval = FALSE;
request_change_pos_update_interval(method, (gpointer)lbs_server);
}
- }
-#ifndef TIZEN_DEVICE
- else if (!g_strcmp0(g_variant_get_string(value, &length), "START_BATCH")) {
+ } else if (!g_strcmp0(g_variant_get_string(value, &length), "START_BATCH")) {
- gint b_interval = 0, b_period = 0;
+ int batch_interval = 0;
+ int batch_period = 0;
while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
if (!g_strcmp0(key, "BATCH_INTERVAL")) {
- b_interval = g_variant_get_int32(value);
+ batch_interval = g_variant_get_int32(value);
+ LOG_GPS(DBG_LOW, "BATCH_INTERVAL [%d]", batch_interval);
} else if (!g_strcmp0(key, "BATCH_PERIOD")) {
- b_period = g_variant_get_int32(value);
+ batch_period = g_variant_get_int32(value);
+ LOG_GPS(DBG_LOW, "BATCH_PERIOD [%d]", batch_period);
}
}
- LOG_GPS(DBG_LOW, "BATCH_INTERVAL [%d], BATCH_PERIOD [%d]", b_interval, b_period);
if (client)
- update_batch_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, b_interval, b_period, lbs_server);
+ update_pos_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, method, batch_interval, lbs_server);
- start_batch_tracking(lbs_server, lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL],
- lbs_server->optimized_batch_array[LBS_BATCH_PERIOD]);
+ start_batch_tracking(lbs_server, batch_interval, batch_period);
- }
- else if (!g_strcmp0(g_variant_get_string(value, &length), "STOP_BATCH")) {
+ if (lbs_server->is_needed_changing_interval) {
+ lbs_server->is_needed_changing_interval = FALSE;
+ request_change_pos_update_interval(method, (gpointer)lbs_server);
+ }
+
+ } else if (!g_strcmp0(g_variant_get_string(value, &length), "STOP_BATCH")) {
if (client)
- update_batch_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, 0, 0, lbs_server);
+ update_pos_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, method, interval, lbs_server);
- stop_batch_tracking(lbs_server, lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL],
- lbs_server->optimized_batch_array[LBS_BATCH_PERIOD]);
+ stop_batch_tracking(lbs_server);
+ if (lbs_server->is_needed_changing_interval) {
+ lbs_server->is_needed_changing_interval = FALSE;
+ request_change_pos_update_interval(method, (gpointer)lbs_server);
+ }
}
-#endif
#ifdef _TIZEN_PUBLIC_
else if (!g_strcmp0(g_variant_get_string(value, &length), "SUPLNI")) {
while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
static void gps_update_position_cb(pos_data_t *pos, gps_error_t error, void *user_data)
{
/* LOG_GPS(DBG_LOW, "ENTER >>>"); */
+
GVariant *accuracy = NULL;
LbsPositionExtFields fields;
static void gps_update_batch_cb(batch_data_t *batch, void *user_data)
{
- /* LOG_GPS(DBG_LOW, "gps_update_batch_cb"); */
+ LOG_GPS(DBG_LOW, "ENTER >>>");
lbs_server_s *lbs_server = (lbs_server_s *)(user_data);
memcpy(&lbs_server->batch, batch, sizeof(batch_data_t));
{
lbs_server_s *lbs_server = (lbs_server_s *)(user_data);
if (lbs_server->sv_used == FALSE) {
- /* LOG_GPS(DBG_LOW, "sv_used is FALSE"); */
+ /*LOG_GPS(DBG_LOW, "sv_used is FALSE"); */
return;
}
lbs_server->is_mock_running = FALSE;
lbs_server->gps_client_count = 0;
lbs_server->mock_timer = 0;
-
-#ifndef TIZEN_DEVICE
- lbs_server->batch_interval_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
- lbs_server->optimized_batch_array = (guint *)g_malloc0(LBS_BATCH_SIZE * sizeof(guint));
- lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] = 150;
- lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] = 60000;
-#endif
}
static void nps_get_last_position(lbs_server_s *lbs_server_nps)
LOG_GPS(DBG_ERR, "lbs_server_create failed");
return 1;
}
-
LOG_GPS(DBG_LOW, "lbs_server_create called");
lbs_server->loop = g_main_loop_new(NULL, TRUE);
/* destroy resource for dynamic-interval */
g_free(lbs_server->optimized_interval_array);
g_hash_table_destroy(lbs_server->dynamic_interval_table);
-#ifndef TIZEN_DEVICE
- g_free(lbs_server->optimized_batch_array);
- g_hash_table_destroy(lbs_server->batch_interval_table);
-#endif
+
/* free dbus callback */
g_free(lbs_dbus_callback);
LOG_MOCK(DBG_LOW, "already removed.");
}
}
-
-#ifndef TIZEN_DEVICE
-static void update_batch_interval_table_foreach_cb(gpointer key, gpointer value, gpointer userdata)
-{
- guint *interval_array = (guint *)value;
- dynamic_interval_updator_user_data *updator_ud = (dynamic_interval_updator_user_data *)userdata;
- lbs_server_s *lbs_server = updator_ud->lbs_server;
-
- if (lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] > interval_array[LBS_BATCH_INTERVAL])
- lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] = interval_array[LBS_BATCH_INTERVAL];
-
- if (lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] > interval_array[LBS_BATCH_PERIOD])
- lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] = interval_array[LBS_BATCH_PERIOD];
-
- LOG_GPS(DBG_LOW, "foreach dynamic-batch. key:[%s]-batch[interval:%u, period:%u], optimized [%u, %u]", (char *)key, interval_array[LBS_BATCH_INTERVAL], interval_array[LBS_BATCH_PERIOD], lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL], lbs_server->optimized_batch_array[LBS_BATCH_PERIOD]);
-}
-
-static gboolean update_batch_tracking_interval(lbs_server_interval_manipulation_type type, const gchar *client, guint interval, guint period, gpointer userdata)
-{
- LOG_GPS(DBG_INFO, "update_batch_tracking_interval");
- if (userdata == NULL) return FALSE;
- if (client == NULL) {
- LOG_GPS(DBG_ERR, "client is NULL");
- return FALSE;
- }
-
- lbs_server_s *lbs_server = (lbs_server_s *)userdata;
-
- switch (type) {
- case LBS_SERVER_INTERVAL_ADD: {
- LOG_GPS(DBG_LOW, "ADD, client[%s], interval[%u], period[%u]", client, interval, period);
- gchar *client_cpy = NULL;
- client_cpy = g_strdup(client);
-
- guint* interval_array = (guint *) g_hash_table_lookup(lbs_server->batch_interval_table, client_cpy);
- if (!interval_array) {
- LOG_GPS(DBG_LOW, "first add key[%s] to batch-table", client);
- interval_array = (guint *)g_malloc0(LBS_BATCH_SIZE * sizeof(guint));
- if (!interval_array) {
- LOG_GPS(DBG_ERR, "interval_array is NULL");
- g_free(client_cpy);
- return FALSE;
- }
- g_hash_table_insert(lbs_server->batch_interval_table, (gpointer)client_cpy, (gpointer)interval_array);
- }
- interval_array[LBS_BATCH_INTERVAL] = interval;
- interval_array[LBS_BATCH_PERIOD] = period;
- break;
- }
-
- case LBS_SERVER_INTERVAL_REMOVE: {
- LOG_GPS(DBG_LOW, "REMOVE, client[%s]", client);
- guint *interval_array = (guint *) g_hash_table_lookup(lbs_server->batch_interval_table, client);
- if(!interval_array) {
- LOG_GPS(DBG_INFO, "Client[%s] is already removed from batch-table", client);
- break;
- }
- LOG_GPS(DBG_LOW, "Remove interval_array(%p):[%u, %u] from batch-table", interval_array, interval_array[LBS_BATCH_INTERVAL], interval_array[LBS_BATCH_PERIOD]);
-
- if (!g_hash_table_remove(lbs_server->batch_interval_table, client)) {
- LOG_GPS(DBG_ERR, "g_hash_table_remove is failed.");
- }
- break;
- }
-
- default: {
- LOG_GPS(DBG_ERR, "unhandled interval-update type");
- return FALSE;
- }
- }
-
- lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL] = 151;
- lbs_server->optimized_batch_array[LBS_BATCH_PERIOD] = 60001;
-
- if (g_hash_table_size(lbs_server->batch_interval_table) == 0) {
- return FALSE;
- } else {
- LOG_GPS(DBG_LOW, "updates optimized-batch-interval.");
- dynamic_interval_updator_user_data updator_user_data; // temporary struct
- updator_user_data.lbs_server = lbs_server;
-
- g_hash_table_foreach(lbs_server->batch_interval_table,
- (GHFunc) update_batch_interval_table_foreach_cb, (gpointer) &updator_user_data);
- }
- LOG_GPS(DBG_LOW, "Updates_batch_tracking_interval done.");
- return TRUE;
-}
-#endif
return status;
}
-#ifndef TIZEN_DEVICE
int request_start_batch_session(int batch_interval, int batch_period)
{
LOG_GPS(DBG_INFO, "Batch: GPS start with interval[%d]", batch_interval);
gps_server_t *server = g_gps_server;
gps_action_start_data_t gps_start_data;
- if (server->session_state == GPS_SESSION_STARTING || server->session_state == GPS_SESSION_STARTED)
- gps_start_data.session_status = 1; /* 1:Already running, 0:need to start*/
- else
- gps_start_data.session_status = 0;
+ if (server->session_state != GPS_SESSION_STOPPED && server->session_state != GPS_SESSION_STOPPING) {
+ LOG_GPS(DBG_WARN, "Batch: GPS Session Already Started!");
+ return TRUE;
+ }
server->session_state = GPS_SESSION_STARTING;
LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
return TRUE;
}
-int request_stop_batch_session(int batch_interval, int batch_period, int session_status)
+int request_stop_batch_session()
{
gboolean status = TRUE;
gboolean cur_replay_enabled = FALSE;
gps_failure_reason_t reason_code = GPS_FAILURE_CAUSE_NORMAL;
gps_server_t *server = g_gps_server;
- gps_action_start_data_t gps_start_data;
- gps_start_data.interval = batch_interval;
- gps_start_data.period = batch_period;
- gps_start_data.session_status = session_status; /* 0:need to stop, 1:keep status */
LOG_GPS(DBG_LOW, "Batch: Stop GPS Session, ==GPSSessionState[%d]", server->session_state);
if (server->session_state == GPS_SESSION_STARTED || server->session_state == GPS_SESSION_STARTING) {
- /* TURE: All clients stopped, FALSE: Some clients are running with GPS or BATCH */
- status = get_plugin_module()->request(GPS_ACTION_STOP_BATCH, &gps_start_data, &reason_code);
- if (status == TRUE && session_status == 0) {
+ status = get_plugin_module()->request(GPS_ACTION_STOP_BATCH, NULL, &reason_code);
+ if (status) {
server->session_state = GPS_SESSION_STOPPING;
LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
cur_replay_enabled = get_replay_enabled();
}
setting_notify_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb, (void *)server);
} else {
- LOG_GPS(DBG_ERR, " Client exists. plugin->request to LBS_GPS_STOP_SESSION passed");
- status = FALSE;
+ LOG_GPS(DBG_ERR, "plugin->request to LBS_GPS_STOP_SESSION Failed, reasonCode =%d", reason_code);
}
} else {
- LOG_GPS(DBG_LOW, " Keep the client status because the GPS state is not started");
+ /* If request is not sent, keep the client registed */
+ LOG_GPS(DBG_LOW, " LBS_GPS_STOP_SESSION is not sent because the GPS state is not started, keep the client registed ");
}
return status;
}
-#endif
int request_add_geofence(int fence_id, double latitude, double longitude, int radius, int last_state, int monitor_states, int notification_responsiveness, int unknown_timer)
{
/* Default value : temp */
action_data.notification_responsiveness_ms = 5000;
action_data.unknown_timer_ms = 30000;
- /* action_data.notification_responsiveness_ms = notification_responsiveness; */
- /* action_data.unknown_timer_ms = unknown_timer; */
+ /*action_data.notification_responsiveness_ms = notification_responsiveness; */
+ /*action_data.unknown_timer_ms = unknown_timer; */
LOG_GPS(DBG_LOW, "request_add_geofence with geofence_id [%d]", fence_id);
status = get_plugin_module()->request(GPS_ACTION_ADD_GEOFENCE, &action_data, &reason_code);
} else if (access(CSR_PATH, F_OK) == 0) {
g_strlcpy(module_name, "csr", strlen("csr") + 1);
} else if (access(QCOM8x30_PATH, F_OK) == 0 || access(QCOM9x15_PATH, F_OK) == 0 ||
- access(QCOM8974_PATH, F_OK) == 0 || access(QCOM8210_PATH, F_OK) == 0 ||
- access(QCOM8226_PATH, F_OK) == 0 || access(QCOM8916_PATH, F_OK) == 0) {
+ access(QCOM8974_PATH, F_OK) == 0 || access(QCOM8210_PATH, F_OK) == 0 ||
+ access(QCOM8226_PATH, F_OK) == 0 || access(QCOM8916_PATH, F_OK) == 0) {
g_strlcpy(module_name, "qcom", strlen("qcom") + 1);
} else {
g_strlcpy(module_name, "replay", strlen("replay") + 1);
}
- LOG_GPS(DBG_LOW, ">> module name : %s", module_name);
+ LOG_GPS(DBG_LOW, "module name : %s", module_name);
}
static gps_server_t *_initialize_gps_data(void)