Modify install/uninstall functionjjoggoba_3

Change-Id: I334a5cbbe2f3c8cbc7f033b05ad2f1a7f21c28ab

3 files changed, 99 insertions, 136 deletions

diff --git a/inc/package_worker_pkgmgr.h b/inc/package_worker_pkgmgr.h
index 5f7a3ac..52d5020 100644
--- a/inc/package_worker_pkgmgr.h
+++ b/inc/package_worker_pkgmgr.h
@@ -17,12 +17,20 @@
 #ifndef __PACKAGE_WORKER_PKGMGR_H__
 #define __PACKAGE_WORKER_PKGMGR_H__
 
-typedef void (*pm_installer_res_cb)(const char *package, int result, void *user_data);
+typedef enum {
+	PKGMGR_INSTALL = 0,
+	PKGMGR_REMOVE,
+	PKGMGR_MANAGE_MAX,
+} pkgmgr_manage_type_e;
 
-int pm_installer_install(const char *path, pm_installer_res_cb result_cb, void *cb_data);
+typedef enum {
+	REQUEST_SUCCESS = 0,
+	REQUEST_FAIL,
+} request_result_e;
 
-typedef void (*pm_uninstaller_res_cb)(const char *package, int result, void *user_data);
+typedef void (*request_result_cb)(const char *package, pkgmgr_manage_type_e type, request_result_e result, void *user_data);
 
-int pm_uninstaller_uninstall(const char *name, pm_uninstaller_res_cb result_cb, void *cb_data);
+int package_worker_pkgmgr_manage_package_by_type(const char *package,
+		pkgmgr_manage_type_e type, request_result_cb result_cb, void *cb_data);
 
 #endif /* __PACKAGE_WORKER_PKGMGR_H__ */
diff --git a/src/package_worker.c b/src/package_worker.c
index 69ad617..358c5c4 100644
--- a/src/package_worker.c
+++ b/src/package_worker.c
@@ -51,34 +51,29 @@ void pm_worker_report_result(const char *report)
 	/* TODO : report result to daemon, and notify it */
 }
 
-static void
-__pkg_install_result_callback(const char *package, int result, void *user_data)
-{
-	char *result_str = NULL;
-
-	if (result)
-		result_str = pm_result_get_install(package, false, "INSTALL_PKG_FAILED");
-	else
-		result_str = pm_result_get_install(package, true, "INSTALL_PKG_SUCCESS");
-
-	pm_worker_report_result(result_str);
-	free(result_str);
-
-	service_app_exit();
-}
-
-static void
-__pkg_uninstall_result_callback(const char *package, int result, void *user_data)
+static void __request_result_cb(const char *package, pkgmgr_manage_type_e type,
+		request_result_e result, void *user_data)
 {
-	char *result_str = NULL;
+	/* Submit report with result */
+	const char *report = NULL;
+
+	ret_if(type >= PKGMGR_MAX);
+
+	if (type == PKGMGR_INSTALL) {
+		if (result == REQUEST_SUCCESS)
+			report = "Install Successed";
+		else
+			report = "Install Failed";
+	} else
+		if (result == REQUEST_SUCCESS)
+			report = "Uninstall Successed";
+		else
+			report = "Uninstall Failed";
+	}
 
-	if (result)
-		result_str = pm_result_get_uninstall(package, false, "UNINSTALL_PKG_FAILED");
-	else
-		result_str = pm_result_get_uninstall(package, true, "UNINSTALL_PKG_SUCCESS");
+	_D("Request result[%s]", report);
 
-	pm_worker_report_result(result_str);
-	free(result_str);
+	/* Submit Report here */
 
 	service_app_exit();
 }
@@ -137,19 +132,20 @@ static void service_app_control(app_control_h app_control, void *data)
 			goto DONE;
 		}
 
-		ret = pm_installer_install(package_worker_metadata_get_file_path(metadata),
-				__pkg_install_result_callback, NULL);
-		if (ret) {
-			_D("Installing is succeeded.");
+		ret = package_worker_pkgmgr_manage_package_by_type(package_worker_metadata_get_file_path(metadata),
+				PKGMGR_INSTALL, __request_result_cb, NULL);
+		if (ret < 0) {
+			_D("Install Request is failed");
 			/* Submit result as report */
 		}
 	} else if (!strcmp(operation, "uninstall")) {
 		/*Todo: pkg_name */
 		char * pkg_name = "org.tizen.example.CustomRenderer.Tizen.Mobile";
 
-		ret = pm_uninstaller_uninstall(pkg_name, __pkg_uninstall_result_callback, NULL);
-		if (ret) {
-			_E("Failed to uninstall[%s]", pkg_name);
+		ret = package_worker_pkgmgr_manage_package_by_type(pkg_name, PKGMGR_REMOVE,
+				__request_result_cb, NULL);
+		if (ret < 0) {
+			_E("Uninstall Request is failed");
 			/* Submit result as report */
 		}
 	} else if(!strcmp(operation, "package")) {
diff --git a/src/package_worker_pkgmgr.c b/src/package_worker_pkgmgr.c
index 4d5120c..c3a8a34 100644
--- a/src/package_worker_pkgmgr.c
+++ b/src/package_worker_pkgmgr.c
@@ -20,131 +20,90 @@
 #include "log.h"
 #include "package_worker_pkgmgr.h"
 
-typedef struct __pm_installer_s {
-	package_manager_request_h handle;
-	int request_id;
-	pm_installer_res_cb result_cb;
+typedef struct _request_h {
+	package_manager_request_h pkgmgr_h;
+	request_result_cb result_cb;
 	void * cb_data;
-} pm_installer_s;
+} request_h;
 
-static void _install_cb(int id, const char *type, const char *package,
+static void _request_cb(int id, const char *type, const char *package,
 	package_manager_event_type_e event_type,
 	package_manager_event_state_e event_state, int progress,
 	package_manager_error_e error, void *user_data)
 {
-	pm_installer_s *pmi_d = user_data;
+	pkgmgr_manage_type_e request_type = PKGMGR_INSTALL;
+	request_result_e result = REQUEST_SUCCESS;
+	request_h *handle = user_data;
+	ret_if(!handle);
 
 	if (event_type == PACKAGE_MANAGER_EVENT_TYPE_INSTALL ||
-		event_type == PACKAGE_MANAGER_EVENT_TYPE_UPDATE) {
-		if (event_state == PACKAGE_MANAGER_EVENT_STATE_COMPLETED) {
-			_D("Install Success");
-			if (pmi_d->result_cb)
-				pmi_d->result_cb(package, 0, pmi_d->cb_data);
-			package_manager_request_destroy(pmi_d->handle);
-			g_free(pmi_d);
-
-		} else if (event_state == PACKAGE_MANAGER_EVENT_STATE_FAILED) {
-			_E("Install Fail (%d)", error);
-			if (pmi_d->result_cb)
-				pmi_d->result_cb(package, -1, pmi_d->cb_data); /* TODO : set error code from result value */
-			package_manager_request_destroy(pmi_d->handle);
-			g_free(pmi_d);
+			event_type == PACKAGE_MANAGER_EVENT_TYPE_UPDATE) {
+		if (event_state == PACKAGE_MANAGER_EVENT_STATE_COMPLETED)
+			_D("Install Successed");
+		else if (event_state == PACKAGE_MANAGER_EVENT_STATE_FAILED) {
+			_E("Install Failed (%d)", error);
+			result = REQUEST_FAIL;
+		}
+		/* Should we deal the progress state until finished? like 10% 20%.. */
+	} else if (event_type == PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL) {
+		request_type = PKGMGR_REMOVE;
+
+		if (event_state == PACKAGE_MANAGER_EVENT_STATE_COMPLETED)
+			_D("Uninstall Successed");
+		else if (event_state == PACKAGE_MANAGER_EVENT_STATE_FAILED) {
+			_E("Uninstall Failed (%d)", error);
+			result = REQUEST_FAIL;
 		}
-	}
-}
-
-int pm_installer_install(const char *path, pm_installer_res_cb result_cb, void *cb_data)
-{
-	_D("Install Start");
-	int ret = 0;
-	int request_id = 0;
-	pm_installer_s *pmi_d = NULL;
-
-	pmi_d = g_malloc0(sizeof(pm_installer_s));
-	pmi_d->result_cb = result_cb;
-	pmi_d->cb_data = cb_data;
-
-	ret = package_manager_request_create(&pmi_d->handle);
-	if (ret != PACKAGE_MANAGER_ERROR_NONE) {
-		_E("Fail create package manager request handle : %d(%s)", ret,
-		get_error_message(ret));
-		g_free(pmi_d);
-		return -1;
 	}
 
-	ret = package_manager_request_install_with_cb(pmi_d->handle, path, _install_cb,
-		pmi_d, &request_id);
+	if (handle->result_cb)
+		handle->result_cb(package, request_type, result, handle->cb_data);
 
-	if (ret != PACKAGE_MANAGER_ERROR_NONE) {
-		_E("Fail request package manager install : %d(%s)", ret,
-		get_error_message(ret));
-		g_free(pmi_d);
-		return -1;
-	}
+	package_manager_request_destroy(handle->pkgmgr_h);
+	g_free(handle);
 
-	return 0;
 }
 
-typedef struct __pm_uninstaller_s {
-	package_manager_request_h handle;
-	int request_id;
-	pm_uninstaller_res_cb result_cb;
-	void * cb_data;
-} pm_uninstaller_s;
-
-static void _uninstall_cb(int id, const char *type, const char *package,
-	package_manager_event_type_e event_type,
-	package_manager_event_state_e event_state, int progress,
-	package_manager_error_e error, void *user_data)
+int package_worker_pkgmgr_manage_package_by_type(const char *package, pkgmgr_manage_type_e type,
+		request_result_cb result_cb, void *cb_data)
 {
-	pm_uninstaller_s *pmu_d = user_data;
-
-	if (event_type == PACKAGE_MANAGER_EVENT_TYPE_UNINSTALL) {
-		if (event_state == PACKAGE_MANAGER_EVENT_STATE_COMPLETED) {
-			_D("Unnstall Success");
-			if (pmu_d->result_cb)
-				pmu_d->result_cb(package, 0, pmu_d->cb_data);
-			package_manager_request_destroy(pmu_d->handle);
-			g_free(pmu_d);
-
-		} else if (event_state == PACKAGE_MANAGER_EVENT_STATE_FAILED) {
-			_E("Uninstall Fail (%d)", error);
-			if (pmu_d->result_cb)
-				pmu_d->result_cb(package, -1, pmu_d->cb_data); /* TODO : set error code from result value */
-			package_manager_request_destroy(pmu_d->handle);
-			g_free(pmu_d);
-		}
-	}
-}
+	int ret = PACKAGE_MANAGER_ERROR_NONE;
+	package_manager_request_h pkgmgr_h;
+	request_h *handle;
 
-int pm_uninstaller_uninstall(const char *name, pm_uninstaller_res_cb result_cb, void *cb_data)
-{
-	_D("Uninstall Start");
-	int ret = 0;
-	int request_id = 0;
-	pm_uninstaller_s *pmu_d = NULL;
+	retv_if(!package, -1);
+	retv_if(type >= PKGMGR_MANAGE_MAX, -1);
 
-	pmu_d = g_malloc0(sizeof(pm_uninstaller_s));
-	pmu_d->result_cb = result_cb;
-	pmu_d->cb_data = cb_data;
+	handle = g_try_malloc0(sizeof(request_h));
+	retv_if(!handle, -1);
 
-	ret = package_manager_request_create(&pmu_d->handle);
+	ret = package_manager_request_create(&pkgmgr_h);
 	if (ret != PACKAGE_MANAGER_ERROR_NONE) {
-		_E("Fail create package manager request handle : %d(%s)", ret,
-		get_error_message(ret));
-		g_free(pmu_d);
-		return -1;
+		_E("Failed to create package manager request handle");
+		goto ERROR;
 	}
 
-	ret = package_manager_request_uninstall_with_cb(pmu_d->handle, name, _uninstall_cb,
-		pmu_d, &request_id);
+	handle->pkgmgr_h = pkgmgr_h;
+	handle->result_cb = result_cb;
+	handle->cb_data = cb_data;
+
+	if (type == PKGMGR_INSTALL)
+		ret = package_manager_request_install_with_cb(pkgmgr_h, package,
+				_request_cb, handle, NULL);
+	else
+		ret = package_manager_request_uninstall_with_cb(pkgmgr_h, package,
+				_request_cb, handle, NULL);
 
 	if (ret != PACKAGE_MANAGER_ERROR_NONE) {
-		_E("Fail request package manager install : %d(%s)", ret,
-		get_error_message(ret));
-		g_free(pmu_d);
-		return -1;
+		_E("Failed to request [%d]", type);
+		package_manager_request_destroy(pkgmgr_h);
+		goto ERROR;
 	}
 
 	return 0;
+
+ERROR:
+	g_free(handle);
+
+	return -1;
 }