Fixed batch behavior in emulator mode

Change-Id: I7f7a9206f648cde3316fdfd376f364c502fd6989
Signed-off-by: kj7.sung <kj7.sung@samsung.com>

9 files changed, 255 insertions, 121 deletions

diff --git a/lbs-server/CMakeLists.txt b/lbs-server/CMakeLists.txt
index 173f3e9..dd2ce64 100644
--- a/lbs-server/CMakeLists.txt
+++ b/lbs-server/CMakeLists.txt
@@ -38,4 +38,4 @@ SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie")
 
 INSTALL(DIRECTORY include/ DESTINATION ${INCLUDE_DIR}/lbs-server-plugin FILES_MATCHING PATTERN "*.h")
 
-INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${BIN_DIR})
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION ${BIN_DIR})
\ No newline at end of file
diff --git a/lbs-server/include/gps_plugin_intf.h b/lbs-server/include/gps_plugin_intf.h
index c871906..b0700fa 100644
--- a/lbs-server/include/gps_plugin_intf.h
+++ b/lbs-server/include/gps_plugin_intf.h
@@ -394,7 +394,8 @@ typedef struct {
 
 typedef struct {
 	int interval;
-	int period;
+	int period;				/**< Emulator */
+	int session_status;		/**< Emulator */
 } gps_action_start_data_t;
 
 typedef struct {
diff --git a/lbs-server/src/gps_plugin_module.c b/lbs-server/src/gps_plugin_module.c
index 471d45a..5339444 100644
--- a/lbs-server/src/gps_plugin_module.c
+++ b/lbs-server/src/gps_plugin_module.c
@@ -50,7 +50,8 @@ int load_plugin_module(char *specific_name, void **plugin_handle)
 
 		if (stat(plugin_path, &st) != 0) {
 			strncpy(plugin_path, GPS_PLUGIN_PATH, sizeof(plugin_path));
-			/* To support real GPS when additional plugin is added*/
+
+			/* Comment out to support real GPS when GPS plugin is installed*/
 			/* setting_set_int(VCONFKEY_LOCATION_REPLAY_ENABLED, 1); */
 		}
 	}
diff --git a/lbs-server/src/lbs_server.c b/lbs-server/src/lbs_server.c
index 3e3b549..0fceeac 100755
--- a/lbs-server/src/lbs_server.c
+++ b/lbs-server/src/lbs_server.c
@@ -83,6 +83,10 @@ typedef struct {
 	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;
 
@@ -102,6 +106,14 @@ typedef struct {
 	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);
@@ -403,36 +415,33 @@ static void __nps_cancel_callback(void *arg)
 	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 == TRUE) {
-		LOG_GPS(DBG_LOW, "Batch: gps is already running");
-		return;
+	if (lbs_server->is_gps_running == FALSE) {
+		LOG_GPS(DBG_LOW, "Batch: start_tracking GPS");
+		lbs_server->status = LBS_STATUS_ACQUIRING;
 	}
-	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)
+static void stop_batch_tracking(lbs_server_s *lbs_server, int batch_interval, int batch_period)
 {
-	LOG_GPS(DBG_LOW, "ENTER >>>");
+	LOG_GPS(DBG_LOW, "Batch: stop_tracking GPS");
 
 	g_mutex_lock(&lbs_server->mutex);
 	lbs_server->gps_client_count--;
@@ -443,22 +452,28 @@ static void stop_batch_tracking(lbs_server_s *lbs_server)
 		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 */
+	}
 
-		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);
-		}
+	/* 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);
 	}
 
 	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)
 {
@@ -711,77 +726,77 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
 	/* 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);
+			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));
 				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));
-					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);
+					/* LOG_GPS(DBG_ERR, "interval_array is NULL"); */
+					g_free(client_cpy);
+					return FALSE;
 				}
-				interval_array[method] = interval;
-				lbs_server->temp_minimum_interval = interval;
-				/* LOG_GPS(DBG_LOW, "ADD done"); */
-				break;
+				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;
+		}
 
 		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);
+			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;
 				}
-				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.");
-				}
-				break;
+				LOG_GPS(DBG_LOW, "REMOVE done.");
 			}
+			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);
-					break;
-				}
-				interval_array[method] = interval;
-				lbs_server->temp_minimum_interval = interval;
-				LOG_GPS(DBG_LOW, "UPDATE done.");
+			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;
+		}
 
 		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 */
@@ -793,8 +808,6 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
 
 		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;
@@ -815,7 +828,6 @@ static gboolean update_pos_tracking_interval(lbs_server_interval_manipulation_ty
 		else
 			ret_val = FALSE;
 	}
-	LOG_GPS(DBG_LOW, "update_pos_tracking_interval done.");
 	return ret_val;
 }
 
@@ -844,6 +856,10 @@ static void get_nmea(int *timestamp, gchar **nmea_data, gpointer userdata)
 	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 >>>");
@@ -938,43 +954,38 @@ static void set_options(GVariant *options, const gchar *client, gpointer userdat
 				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), "START_BATCH")) {
+		}
+#ifndef TIZEN_DEVICE
+		else if (!g_strcmp0(g_variant_get_string(value, &length), "START_BATCH")) {
 
-			int batch_interval = 0;
-			int batch_period = 0;
+			gint b_interval = 0, b_period = 0;
 			while (g_variant_iter_next(&iter, "{&sv}", &key, &value)) {
 
 				if (!g_strcmp0(key, "BATCH_INTERVAL")) {
-					batch_interval = g_variant_get_int32(value);
-					LOG_GPS(DBG_LOW, "BATCH_INTERVAL [%d]", batch_interval);
+					b_interval = g_variant_get_int32(value);
 				} else if (!g_strcmp0(key, "BATCH_PERIOD")) {
-					batch_period = g_variant_get_int32(value);
-					LOG_GPS(DBG_LOW, "BATCH_PERIOD [%d]", batch_period);
+					b_period = g_variant_get_int32(value);
 				}
 			}
+			LOG_GPS(DBG_LOW, "BATCH_INTERVAL [%d], BATCH_PERIOD [%d]", b_interval, b_period);
 
 			if (client)
-				update_pos_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, method, batch_interval, lbs_server);
+				update_batch_tracking_interval(LBS_SERVER_INTERVAL_ADD, client, b_interval, b_period, lbs_server);
 
-			start_batch_tracking(lbs_server, batch_interval, batch_period);
+			start_batch_tracking(lbs_server, lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL],
+											lbs_server->optimized_batch_array[LBS_BATCH_PERIOD]);
 
-			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")) {
+		}
+		else if (!g_strcmp0(g_variant_get_string(value, &length), "STOP_BATCH")) {
 
 			if (client)
-				update_pos_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, method, interval, lbs_server);
+				update_batch_tracking_interval(LBS_SERVER_INTERVAL_REMOVE, client, 0, 0, lbs_server);
 
-			stop_batch_tracking(lbs_server);
+			stop_batch_tracking(lbs_server, lbs_server->optimized_batch_array[LBS_BATCH_INTERVAL],
+											lbs_server->optimized_batch_array[LBS_BATCH_PERIOD]);
 
-			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)) {
@@ -1100,7 +1111,6 @@ static void shutdown(gpointer userdata, gboolean *shutdown_arr)
 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;
 
@@ -1125,7 +1135,7 @@ static void gps_update_position_cb(pos_data_t *pos, gps_error_t error, void *use
 
 static void gps_update_batch_cb(batch_data_t *batch, void *user_data)
 {
-	LOG_GPS(DBG_LOW, "ENTER >>>");
+	/* LOG_GPS(DBG_LOW, "gps_update_batch_cb"); */
 	lbs_server_s *lbs_server = (lbs_server_s *)(user_data);
 	memcpy(&lbs_server->batch, batch, sizeof(batch_data_t));
 
@@ -1141,7 +1151,7 @@ static void gps_update_satellite_cb(sv_data_t *sv, void *user_data)
 {
 	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;
 	}
 
@@ -1265,6 +1275,13 @@ static void lbs_server_init(lbs_server_s *lbs_server)
 	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)
@@ -1466,6 +1483,7 @@ int main(int argc, char **argv)
 		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);
@@ -1478,7 +1496,10 @@ int main(int argc, char **argv)
 	/* 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);
 
@@ -1695,3 +1716,91 @@ static void __setting_mock_cb(keynode_t *key, gpointer user_data)
 			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
diff --git a/lbs-server/src/server.c b/lbs-server/src/server.c
index d7835aa..78bf24a 100644
--- a/lbs-server/src/server.c
+++ b/lbs-server/src/server.c
@@ -306,6 +306,7 @@ int request_stop_session()
 	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);
@@ -315,10 +316,10 @@ int request_start_batch_session(int batch_interval, int batch_period)
 	gps_server_t *server = g_gps_server;
 	gps_action_start_data_t gps_start_data;
 
-	if (server->session_state != GPS_SESSION_STOPPED && server->session_state != GPS_SESSION_STOPPING) {
-		LOG_GPS(DBG_WARN, "Batch: GPS Session Already Started!");
-		return TRUE;
-	}
+	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;
 
 	server->session_state = GPS_SESSION_STARTING;
 	LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
@@ -338,17 +339,22 @@ int request_start_batch_session(int batch_interval, int batch_period)
 	return TRUE;
 }
 
-int request_stop_batch_session()
+int request_stop_batch_session(int batch_interval, int batch_period, int session_status)
 {
 	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) {
-		status = get_plugin_module()->request(GPS_ACTION_STOP_BATCH, NULL, &reason_code);
-		if (status) {
+		/* 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) {
 			server->session_state = GPS_SESSION_STOPPING;
 			LOG_GPS(DBG_LOW, "==GPSSessionState[%d]", server->session_state);
 			cur_replay_enabled = get_replay_enabled();
@@ -358,14 +364,15 @@ int request_stop_batch_session()
 			}
 			setting_notify_key_changed(VCONFKEY_LOCATION_REPLAY_ENABLED, _gps_replay_changed_cb, (void *)server);
 		} else {
-			LOG_GPS(DBG_ERR, "plugin->request to LBS_GPS_STOP_SESSION Failed, reasonCode =%d", reason_code);
+			LOG_GPS(DBG_ERR, "  Client exists. plugin->request to LBS_GPS_STOP_SESSION passed");
+			status = FALSE;
 		}
 	} else {
-		/* 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 ");
+		LOG_GPS(DBG_LOW, " Keep the client status because the GPS state is not started");
 	}
 	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)
 {
@@ -382,8 +389,8 @@ int request_add_geofence(int fence_id, double latitude, double longitude, int ra
 	/* 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);
@@ -1086,14 +1093,14 @@ void check_plugin_module(char *module_name)
 	} 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)
diff --git a/lbs-server/src/server.h b/lbs-server/src/server.h
index 3584020..1c8cea0 100644
--- a/lbs-server/src/server.h
+++ b/lbs-server/src/server.h
@@ -70,8 +70,12 @@ int initialize_server(int argc, char **argv);
 int deinitialize_server();
 
 int request_change_pos_update_interval_standalone_gps(unsigned int interval);
+
+#ifndef TIZEN_DEVICE
 int request_start_batch_session(int batch_interval, int batch_period);
-int request_stop_batch_session(void);
+int request_stop_batch_session(int batch_interval, int batch_period, int session_status);
+#endif
+
 int request_start_session(int interval);
 int request_stop_session(void);
 #ifndef _TIZEN_PUBLIC_
diff --git a/module/gps_module.c b/module/gps_module.c
index f642efb..fb0540b 100644
--- a/module/gps_module.c
+++ b/module/gps_module.c
@@ -156,7 +156,7 @@ static void position_callback(GVariant *param, void *user_data)
 
 	g_variant_get(param, "(iiidddddd@(idd))", &method, &fields, &timestamp, &latitude, &longitude, &altitude, &speed, &direction, &climb, &accuracy);
 
-	MOD_LOGD("position_callback [method: %d, field: %d]", method, fields);
+	/* MOD_LOGD("position_callback [method: %d, field: %d]", method, fields); */
 	if (method != LBS_CLIENT_METHOD_GPS) {
 		MOD_LOGD("Method is not LBS_CLIENT_METHOD_GPS: %d", method);
 		return;
diff --git a/packaging/lbs-server.changes b/packaging/lbs-server.changes
index e5e1386..22138cb 100644
--- a/packaging/lbs-server.changes
+++ b/packaging/lbs-server.changes
@@ -1,3 +1,9 @@
+[Version]	lbs-server_1.0.5
+[Date]		7 Jul 2016
+[Changes]	Change batch behavior about HW batching in emulator mode.
+[Developer]	Kyoungjun Sung <kj7.sung@samsung.com>
+
+================================================================================
 [Version]	lbs-server_1.0.4
 [Date]		30 Jun 2016
 [Changes]	Change to non-root daemon.
diff --git a/packaging/lbs-server.spec b/packaging/lbs-server.spec
index be31328..0c85185 100644
--- a/packaging/lbs-server.spec
+++ b/packaging/lbs-server.spec
@@ -1,6 +1,6 @@
 Name:    lbs-server
 Summary: LBS Server for Tizen
-Version: 1.0.4
+Version: 1.0.5
 Release: 1
 Group:   Location/Service
 License: Apache-2.0
@@ -62,6 +62,12 @@ export CFLAGS="$CFLAGS -DTIZEN_DEBUG_ENABLE"
 export CXXFLAGS="$CXXFLAGS -DTIZEN_DEBUG_ENABLE"
 export FFLAGS="$FFLAGS -DTIZEN_DEBUG_ENABLE"
 
+%ifarch %arm aarch64
+export CFLAGS="$CFLAGS -DTIZEN_DEVICE"
+export CXXFLAGS="$CXXFLAGS -DTIZEN_DEVICE"
+export FFLAGS="$FFLAGS -DTIZEN_DEVICE"
+%endif
+
 MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
 cmake . -DCMAKE_INSTALL_PREFIX=%{_prefix} -DFULLVER=%{version} -DMAJORVER=${MAJORVER} \
         -DLIB_DIR=%{_libdir} -DINCLUDE_DIR=%{_includedir} -DSYSCONF_DIR=%{_sysconfdir} \