Refactor pkgmgr using TIDLrdtp

Change-Id: I8eaf77636cc56a117c42a2553846f0f61af08188
Signed-off-by: jh9216.park <jh9216.park@samsung.com>

50 files changed, 4395 insertions, 6139 deletions

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 5a6fbfa..2cbea2f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,24 +1,41 @@
-CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
-SET(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
-SET(CMAKE_SKIP_BUILD_RPATH true)
+CMAKE_MINIMUM_REQUIRED(VERSION 2.8)
 
-PROJECT(package-manager C)
-INCLUDE(TizenCommon)
+PROJECT(package-manager)
 
 SET(PREFIX ${CMAKE_INSTALL_PREFIX})
 SET(EXEC_PREFIX "\${prefix}")
 SET(LIBDIR ${LIB_INSTALL_DIR})
 SET(INCLUDEDIR "\${prefix}/include")
+SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules/")
 
 SET(PKGMGR_CLIENT "pkgmgr-client")
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wl,-zdefs -fvisibility=hidden -g -Wall -fpic ")
+SET(CMAKE_CXX_FLAGS "${CMAKE_C_FLAGS} -std=c++17 ")
+SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed")
 
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden -g -Wall")
-
+INCLUDE(TizenCommon)
 INCLUDE_DIRECTORIES(include)
-INCLUDE_DIRECTORIES(comm)
-
 INCLUDE(FindPkgConfig)
+INCLUDE(ApplyPkgConfig)
+
+PKG_CHECK_MODULES(BUNDLE_DEPS REQUIRED bundle)
+PKG_CHECK_MODULES(DLOG_DEPS REQUIRED dlog)
+PKG_CHECK_MODULES(GMOCK_DEPS REQUIRED gmock)
+PKG_CHECK_MODULES(GLIB_DEPS REQUIRED glib-2.0)
+PKG_CHECK_MODULES(GIO_DEPS REQUIRED gio-2.0)
+PKG_CHECK_MODULES(RPC_PORT_DEPS REQUIRED rpc-port)
+PKG_CHECK_MODULES(CAPI_APPFW_EVENT_DEPS REQUIRED capi-appfw-event)
+PKG_CHECK_MODULES(PKGMGR_PARSER_DEPS REQUIRED pkgmgr-parser)
+PKG_CHECK_MODULES(PKGMGR_INFO_DEPS REQUIRED pkgmgr-info)
+PKG_CHECK_MODULES(INIPARSER_DEPS REQUIRED iniparser)
+PKG_CHECK_MODULES(XDGMIME_DEPS REQUIRED xdgmime)
+PKG_CHECK_MODULES(PLATFORM_CONFIG_DEPS REQUIRED libtzplatform-config)
+PKG_CHECK_MODULES(MINIZIP_DEPS REQUIRED minizip)
 
 ADD_SUBDIRECTORY(installer)
 ADD_SUBDIRECTORY(client)
 ADD_SUBDIRECTORY(types)
+
+ENABLE_TESTING()
+SET(TARGET_PKGMGR_UNIT_TEST "pkgmgr-unit-test")
+ADD_SUBDIRECTORY(test)
diff --git a/client/CMakeLists.txt b/client/CMakeLists.txt
index a59ff50..a61df4f 100644
--- a/client/CMakeLists.txt
+++ b/client/CMakeLists.txt
@@ -2,30 +2,26 @@
 
 AUX_SOURCE_DIRECTORY(src SRCS)
 
-pkg_check_modules(CLIENT_DEPS REQUIRED
-		glib-2.0
-		gio-2.0
-		dlog
-		pkgmgr-parser
-		pkgmgr-info
-		iniparser
-		xdgmime
-		libtzplatform-config
-		minizip)
-FOREACH(CLIENT_FLAGS ${CLIENT_DEPS_CFLAGS})
-	SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${CLIENT_FLAGS}")
-ENDFOREACH(CLIENT_FLAGS)
-
 INCLUDE_DIRECTORIES(include)
 
-SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fPIC")
-
 ADD_LIBRARY(${PKGMGR_CLIENT} SHARED ${SRCS})
 SET_TARGET_PROPERTIES(${PKGMGR_CLIENT} PROPERTIES SOVERSION ${MAJORVER})
 SET_TARGET_PROPERTIES(${PKGMGR_CLIENT} PROPERTIES VERSION ${FULLVER})
-TARGET_LINK_LIBRARIES(${PKGMGR_CLIENT}
-		pkgmgr-info
-		${CLIENT_DEPS_LDFLAGS})
+
+APPLY_PKG_CONFIG(${PKGMGR_CLIENT} PUBLIC
+  GLIB_DEPS
+  GIO_DEPS
+  DLOG_DEPS
+  BUNDLE_DEPS
+  PKGMGR_PARSER_DEPS
+  PKGMGR_INFO_DEPS
+  INIPARSER_DEPS
+  XDGMIME_DEPS
+  PLATFORM_CONFIG_DEPS
+  MINIZIP_DEPS
+  RPC_PORT_DEPS
+  CAPI_APPFW_EVENT_DEPS
+)
 
 CONFIGURE_FILE(pkgmgr.pc.in pkgmgr.pc @ONLY)
 CONFIGURE_FILE(pkg_path.conf.in pkg_path.conf @ONLY)
diff --git a/client/src/api_stub.cc b/client/src/api_stub.cc
new file mode 100644
index 0000000..3aa4a73
--- /dev/null
+++ b/client/src/api_stub.cc
@@ -0,0 +1,1283 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+#include <unistd.h>
+#include <tzplatform_config.h>
+
+#include "package-manager.h"
+#include "package-manager-types.h"
+
+#include "connector.hh"
+#include "log.hh"
+
+#ifdef API
+#undef API
+#endif
+#define API __attribute__ ((visibility("default")))
+
+#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
+
+using namespace pkgmgr::client;
+
+API pkgmgr_client* pkgmgr_client_new(pkgmgr_client_type pc_type) {
+  if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
+    _E("invalid parameter");
+    return nullptr;
+  }
+
+  return new Connector();
+}
+
+API int pkgmgr_client_free(pkgmgr_client* pc) {
+  if (pc == nullptr) {
+    _E("invalid argument");
+    return PKGMGR_R_EINVAL;
+  }
+
+  Connector* con = static_cast<Connector*>(pc);
+  delete con;
+
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
+    bool tep_move) {
+  if (pc == nullptr || tep_path == nullptr) {
+    _E("invalied parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  Connector* con = static_cast<Connector*>(pc);
+  con->SetTep(tep_path, tep_move);
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_usr_install_packages(pkgmgr_client *pc,
+    const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
+    void *data, uid_t uid) {
+  if (pc == nullptr || pkg_paths == nullptr || n_pkgs < 1) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  std::vector<std::string> pkgs;
+  for (int i = 0; i < n_pkgs; i++)
+    pkgs.push_back(pkg_paths[i]);
+
+  int ret = proxy->InstallPkgs(uid, pkgs, con->GetArgv(),
+      con->GenerateRequestId(), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_install_packages(pkgmgr_client *pc,
+    const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
+    void *data) {
+  return pkgmgr_client_usr_install_packages(pc, pkg_paths, n_pkgs,
+      event_cb, data, getuid());
+}
+
+API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
+    const char *descriptor_path, const char *pkg_path,
+    const char *optional_data, pkgmgr_mode mode,
+    pkgmgr_handler event_cb, void *data) {
+  return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path, pkg_path,
+      optional_data, mode, event_cb, data, getuid());
+}
+
+API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
+    const char *descriptor_path, const char *pkg_path,
+    const char *optional_data, pkgmgr_mode mode,
+    pkgmgr_handler event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || pkg_path == nullptr || pkg_type == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->Install(uid, pkg_type, pkg_path, con->GetArgv(),
+      con->GenerateRequestId(), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, const char *optional_data, pkgmgr_mode mode,
+    pkgmgr_handler event_cb, void *data) {
+  return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
+      mode, event_cb, data, getuid());
+}
+
+API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, const char *optional_data, pkgmgr_mode mode,
+    pkgmgr_handler event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->Reinstall(uid, pkgid, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_uninstall_packages(pkgmgr_client *pc,
+    const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
+    void *data) {
+  return pkgmgr_client_usr_uninstall_packages(pc, pkgids, n_pkgs,
+      event_cb, data, getuid());
+}
+
+API int pkgmgr_client_usr_uninstall_packages(pkgmgr_client *pc,
+    const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
+    void *data, uid_t uid) {
+  if (pc == nullptr || pkgids == nullptr || n_pkgs < 1) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  std::vector<std::string> pkgs;
+  for (int i = 0; i < n_pkgs; i++)
+    pkgs.push_back(pkgids[i]);
+
+  int ret = proxy->UninstallPkgs(uid, pkgs, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
+    void *data) {
+  return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
+      data, getuid());
+}
+
+API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
+    void *data, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->Uninstall(uid, pkgid, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_listen_res_status(pkgmgr_client *pc,
+    pkgmgr_res_handler event_cb, void *data) {
+  Connector* con = static_cast<Connector*>(pc);
+
+  con->GetSignalReceiver()->AddEventHandler("", event_cb, data);
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_usr_mount_install_packages(pkgmgr_client *pc,
+    const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
+    void *data, uid_t uid) {
+  if (pc == nullptr || pkg_paths == nullptr || n_pkgs < 1) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  std::vector<std::string> pkgs;
+  for (int i = 0; i < n_pkgs; i++)
+    pkgs.push_back(pkg_paths[i]);
+
+  int ret = proxy->MountInstallPkgs(uid, pkgs, con->GenerateRequestId(),
+      req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_mount_install_packages(pkgmgr_client *pc,
+    const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
+    void *data) {
+  return pkgmgr_client_usr_mount_install_packages(pc, pkg_paths, n_pkgs,
+      event_cb, data, getuid());
+}
+
+API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
+    const char *descriptor_path, const char *pkg_path,
+    const char *optional_data, pkgmgr_mode mode,
+    pkgmgr_handler event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || pkg_path == nullptr || pkg_type == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->MountInstall(uid, pkg_type, pkg_path, con->GetArgv(),
+      con->GenerateRequestId(), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
+    const char *descriptor_path, const char *pkg_path,
+    const char *optional_data, pkgmgr_mode mode,
+    pkgmgr_handler event_cb, void *data) {
+  return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
+      pkg_path, optional_data, mode, event_cb, data,
+      getuid());
+}
+
+API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, pkgmgr_move_type move_type,
+    pkgmgr_handler event_cb, void *data) {
+  return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
+      event_cb, data, getuid());
+}
+
+API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, pkgmgr_move_type move_type,
+    pkgmgr_handler event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  if ((move_type < PM_MOVE_TO_INTERNAL) ||
+      (move_type > PM_MOVE_TO_EXTENDED))
+    return PKGMGR_R_EINVAL;
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->Move(uid, pkgid, move_type, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_usr_register_pkg_update_info(pkgmgr_client *pc,
+    pkg_update_info_t *update_info, uid_t uid) {
+  if (pc == nullptr || update_info == nullptr || update_info->pkgid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->RegisterPkgUpdateInfo(uid, update_info->pkgid,
+      update_info->pkgid, update_info->type);
+}
+
+API int pkgmgr_client_register_pkg_update_info(pkgmgr_client *pc,
+    pkg_update_info_t *update_info) {
+  return pkgmgr_client_usr_register_pkg_update_info(pc, update_info,
+      getuid());
+}
+
+API int pkgmgr_client_usr_unregister_pkg_update_info(pkgmgr_client *pc,
+    const char *pkgid, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->UnregisterPkgUpdateInfo(uid, pkgid);
+}
+
+API int pkgmgr_client_unregister_pkg_update_info(pkgmgr_client *pc,
+    const char *pkgid) {
+  return pkgmgr_client_usr_unregister_pkg_update_info(pc, pkgid, getuid());
+}
+
+API int pkgmgr_client_usr_unregister_all_pkg_update_info(pkgmgr_client *pc,
+    uid_t uid) {
+  if (pc == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->UnregisterAllPkgUpdateInfo(uid);
+}
+
+API int pkgmgr_client_unregister_all_pkg_update_info(pkgmgr_client *pc) {
+  return pkgmgr_client_usr_unregister_all_pkg_update_info(pc, getuid());
+}
+
+API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  return proxy->EnablePkgs(uid, { pkgid }, req_key);
+}
+
+API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid) {
+  return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, getuid());
+}
+
+API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
+    const char *pkg_type, const char **pkgids, int n_pkgs,
+    pkgmgr_handler event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || pkgids == nullptr || n_pkgs < 1) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  std::vector<std::string> vec;
+  for (int i = 0; i < n_pkgs; i++) {
+    vec.push_back(pkgids[i]);
+  }
+
+  int ret = proxy->EnablePkgs(uid, std::move(vec), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
+    const char *pkg_type, const char **pkgids, int n_pkgs,
+    pkgmgr_handler event_cb, void *data) {
+  return pkgmgr_client_usr_activate_packages(pc, pkg_type,
+      pkgids, n_pkgs, event_cb, data, getuid());
+}
+
+API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
+        const char *pkgid, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  return proxy->DisablePkgs(uid, { pkgid }, req_key);
+}
+
+API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
+        const char *pkgid) {
+  return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, getuid());
+}
+
+API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
+    const char *pkg_type, const char **pkgids, int n_pkgs,
+    pkgmgr_handler event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || pkgids == nullptr || n_pkgs < 1) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  std::vector<std::string> vec;
+  for (int i = 0; i < n_pkgs; i++) {
+    vec.push_back(pkgids[i]);
+  }
+
+  int ret = proxy->DisablePkgs(uid, std::move(vec), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
+    const char *pkg_type, const char **pkgids, int n_pkgs,
+    pkgmgr_handler event_cb, void *data) {
+  return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
+      pkgids, n_pkgs, event_cb, data, getuid());
+}
+
+API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
+    pkgmgr_app_handler app_event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || appid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->EnableApp(uid, appid, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, app_event_cb, data);
+}
+
+API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
+    pkgmgr_app_handler app_event_cb, void *data) {
+  return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
+      data, getuid());
+}
+
+API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids,
+    int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || appids == nullptr || n_apps < 1) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  std::vector<std::string> vec;
+  for (int i = 0; i < n_apps; i++) {
+    vec.push_back(appids[i]);
+  }
+
+  int ret = proxy->EnableApps(uid, std::move(vec), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, app_event_cb, data);
+}
+
+API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids,
+    int n_apps, pkgmgr_app_handler app_event_cb, void *data) {
+  return pkgmgr_client_usr_activate_apps(pc, appids, n_apps,
+      app_event_cb, data, getuid());
+}
+
+API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
+    const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || appid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->EnableGlobalAppForUid(uid, appid, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, app_event_cb, data);
+}
+
+API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
+    pkgmgr_app_handler app_event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || appid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->DisableApp(uid, appid, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, app_event_cb, data);
+}
+
+API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
+    pkgmgr_app_handler app_event_cb, void *data) {
+  return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data,
+      getuid());
+}
+
+API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc,
+    const char **appids, int n_apps,
+    pkgmgr_app_handler app_event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || appids == nullptr || n_apps < 1) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  std::vector<std::string> vec;
+  for (int i = 0; i < n_apps; i++) {
+    vec.push_back(appids[i]);
+  }
+
+  int ret = proxy->DisableApps(uid, std::move(vec), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, app_event_cb, data);
+}
+
+API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids,
+    int n_apps, pkgmgr_app_handler app_event_cb, void *data) {
+  return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps,
+      app_event_cb, data, getuid());
+}
+
+API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
+    const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid) {
+  if (pc == nullptr || appid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->DisableGlobalAppForUid(uid, appid, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, app_event_cb, data);
+}
+
+API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
+    const char *pkg_type, const char *pkgid, pkgmgr_mode mode,
+    uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr || uid == GLOBAL_USER) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->ClearData(uid, pkgid);
+}
+
+API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, pkgmgr_mode mode) {
+  return pkgmgr_client_usr_clear_user_data(pc, pkg_type, pkgid, mode,
+      getuid());
+}
+
+API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type) {
+  //TODO
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
+    void *data) {
+  if (pc == nullptr || event_cb == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  return con->GetSignalReceiver()->AddEventHandler("", event_cb, data);
+}
+
+API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
+    pkgmgr_app_handler app_event_cb, void *data) {
+  if (pc == nullptr || app_event_cb == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  return con->GetSignalReceiver()->AddEventHandler("", app_event_cb, data);
+}
+
+API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc) {
+  //TODO
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, const char *key, const char *val) {
+  /* client cannot broadcast signal */
+  return PKGMGR_R_OK;
+}
+
+/* TODO: deprecate(or remove) */
+API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
+    int service_mode, pkgmgr_client *pc, const char *pkg_type,
+    const char *pkgid, const char *custom_info,
+    pkgmgr_handler event_cb, void *data) {
+  return pkgmgr_client_usr_request_service(service_type, service_mode,
+      pc, pkg_type, pkgid, getuid(), custom_info, event_cb,
+      data);
+}
+
+API int pkgmgr_client_usr_request_service(
+    pkgmgr_request_service_type service_type, int service_mode,
+    pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
+    uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
+    void *data) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_client_clear_cache_dir(const char *pkgid) {
+  return pkgmgr_client_usr_clear_cache_dir(pkgid, getuid());
+}
+
+API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid) {
+  return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
+}
+
+API int pkgmgr_client_clear_all_cache_dir() {
+  return pkgmgr_client_usr_clear_cache_dir(
+      PKG_CLEAR_ALL_CACHE, getuid());
+}
+
+API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
+    pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
+    void *data) {
+  return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
+      getuid());
+}
+
+/* TODO: deprecate(or remove) */
+API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
+    pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
+    void *data, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr || event_cb == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
+    get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
+  else
+    get_type = PM_GET_PKG_SIZE_INFO;
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetInfoProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->GetSize(uid, pkgid, get_type, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, data);
+}
+
+API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
+    const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
+    void *user_data, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr || event_cb == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  int get_type;
+  if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
+    get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
+  else
+    get_type = PM_GET_PKG_SIZE_INFO;
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetInfoProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->GetSize(uid, pkgid, get_type, req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb, user_data);
+}
+
+API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
+    const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
+    void *user_data) {
+  return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
+      user_data, getuid());
+}
+
+API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
+    pkgmgr_total_pkg_size_info_receive_cb event_cb,
+    void *user_data, uid_t uid) {
+  return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
+      (pkgmgr_pkg_size_info_receive_cb)event_cb,
+      user_data, uid);
+}
+
+API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
+    pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data) {
+  return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
+      (pkgmgr_pkg_size_info_receive_cb)event_cb,
+      user_data, getuid());
+}
+
+API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
+    const char *resp_data, char **req_data, char **license_url) {
+  if (pc == nullptr || resp_data == nullptr || req_data == nullptr ||
+      license_url == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string data;
+  std::string url;
+  int ret = proxy->GenerateLicenseRequest(resp_data, data, url);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  *req_data = strdup(data.c_str());
+  *license_url = strdup(url.c_str());
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data) {
+  if (pc == nullptr || resp_data == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->RegisterLicense(resp_data);
+}
+
+API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
+    const char *drm_file_path, const char *decrypted_file_path) {
+  if (pc == nullptr || drm_file_path == nullptr ||
+      decrypted_file_path == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->DecryptPackage(drm_file_path, decrypted_file_path);
+}
+
+API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid) {
+  return pkgmgr_client_usr_enable_splash_screen(pc, appid, getuid());
+}
+
+API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
+    const char *appid, uid_t uid) {
+  if (pc == nullptr || appid == nullptr) {
+    _E("Invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->EnableAppSplashScreen(uid, appid);
+}
+
+API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
+    const char *appid) {
+  return pkgmgr_client_usr_disable_splash_screen(pc, appid,
+      getuid());
+}
+
+API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
+    const char *appid, uid_t uid) {
+  if (pc == nullptr || appid == nullptr) {
+    _E("Invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->DisableAppSplashScreen(uid, appid);
+}
+
+API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
+    const char *pkgid, int mode, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr || strlen(pkgid) == 0 || mode <= 0) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->SetRestrictionMode(uid, pkgid, mode);
+}
+
+API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
+    const char *pkgid, int mode) {
+  return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
+      getuid());
+}
+
+API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
+    const char *pkgid, int mode, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr || strlen(pkgid) == 0 || mode <= 0) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->UnsetRestrictionMode(uid, pkgid, mode);
+}
+
+API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
+    const char *pkgid, int mode) {
+  return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
+      getuid());
+}
+
+API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
+    const char *pkgid, int *mode, uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr || strlen(pkgid) == 0) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->GetRestrictionMode(uid, pkgid, *mode);
+}
+
+API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
+    const char *pkgid, int *mode) {
+  return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
+      getuid());
+}
+
+API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
+    uid_t uid) {
+  if (pc == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->SetRestrictionMode(uid, "", mode);
+}
+
+API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode) {
+  return pkgmgr_client_usr_set_restriction_mode(pc, mode, getuid());
+}
+
+API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
+    uid_t uid) {
+  if (pc == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->UnsetRestrictionMode(uid, "", mode);
+}
+
+API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode) {
+  return pkgmgr_client_usr_unset_restriction_mode(pc, mode, getuid());
+}
+
+API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
+    int *mode, uid_t uid) {
+  if (pc == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->GetRestrictionMode(uid, "", *mode);
+}
+
+API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode) {
+  return pkgmgr_client_usr_get_restriction_mode(pc, mode, getuid());
+}
+
+API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path) {
+  //TODO
+  return nullptr;
+}
+
+API int pkgmgr_client_free_pkginfo(pkgmgr_info *info) {
+  //TODO
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
+    char *label, uid_t uid) {
+  if (pc == nullptr || appid == nullptr || label == nullptr) {
+    _E("Invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->SetAppLabel(uid, appid, label);
+}
+
+API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label) {
+  return pkgmgr_client_usr_set_app_label(pc, appid, label, getuid());
+}
+
+API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid,
+    char *icon_path, uid_t uid) {
+  if (pc == nullptr || appid == nullptr || icon_path == nullptr) {
+    _E("Invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->SetAppIcon(uid, appid, icon_path);
+}
+
+API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path) {
+  return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, getuid());
+}
+
+API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode) {
+  if (pc == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  if (debug_mode)
+    con->SetDebugMode();
+
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization) {
+  if (pc == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  if (skip_optimization)
+    con->SetSkipOptimization();
+
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
+    const char *pkgid, uid_t uid) {
+  if (pc == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->MigrateExternalImage(uid, pkgid);
+}
+
+API int pkgmgr_client_add_res_copy_path(pkgmgr_client *pc,
+    const char *src_path, const char *dest_path) {
+  if (pc == nullptr || src_path == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  con->GetResCopyPath().push_back(
+      pp::ResPath(src_path, dest_path ? dest_path: ""));
+
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_res_copy(pkgmgr_client *pc,
+    pkgmgr_res_handler event_cb, void *user_data) {
+  if (pc == nullptr || event_cb == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->ResCopy(con->GetResCopyPath(), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb,
+      user_data);
+}
+
+API int pkgmgr_client_add_res_create_dir_path(pkgmgr_client *pc,
+    const char *dir_path) {
+  if (pc == nullptr || dir_path == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  con->GetResCreateDir().push_back(dir_path);
+
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_res_create_dir(pkgmgr_client *pc,
+    pkgmgr_res_handler event_cb, void *user_data) {
+  if (pc == nullptr || event_cb == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->ResCreateDir(con->GetResCreateDir(), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb,
+      user_data);
+}
+
+API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc,
+    const char *res_path) {
+  if (pc == nullptr || res_path == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  con->GetResRemovePath().push_back(res_path);
+
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_client_res_remove(pkgmgr_client *pc,
+    pkgmgr_res_handler event_cb, void *user_data) {
+  if (pc == nullptr || event_cb == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  std::string req_key;
+  int ret = proxy->ResRemove(con->GetResRemovePath(), req_key);
+  if (ret != PKGMGR_R_OK)
+    return ret;
+
+  return con->GetSignalReceiver()->AddEventHandler(req_key, event_cb,
+      user_data);
+}
+
+API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid) {
+  return pkgmgr_client_res_usr_uninstall(pc, pkgid, getuid());
+}
+
+API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid,
+    uid_t uid) {
+  if (pc == nullptr || pkgid == nullptr) {
+    _E("invalid parameter");
+    return PKGMGR_R_EINVAL;
+  }
+
+  auto* con = static_cast<Connector*>(pc);
+  auto* proxy = con->GetAdminProxy();
+  if (proxy == nullptr)
+    return PKGMGR_R_EIO;
+
+  return proxy->ResUninstall(uid, pkgid);
+}
+
+API pkgmgr_res_event_info *pkgmgr_res_event_info_new() {
+  //TODO
+  return nullptr;
+}
+
+API int pkgmgr_res_event_info_free(pkgmgr_res_event_info *info) {
+  //TODO
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_res_event_info_set_error_code(pkgmgr_res_event_info *handle, int error_code) {
+  //TODO
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_res_event_info_get_error_code(pkgmgr_res_event_info *handle, int *error_code) {
+  //TODO
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_res_event_info_add_path_state(pkgmgr_res_event_info *handle,
+    const char *path, pkgmgr_res_event_path_state state) {
+  //TODO
+  return PKGMGR_R_OK;
+}
+
+API int pkgmgr_res_event_info_foreach_path(pkgmgr_res_event_info *handle,
+    pkgmgr_res_event_path_cb callback, void *user_data) {
+  //TODO
+  return PKGMGR_R_OK;
+}
diff --git a/client/src/connection_event_listener.hh b/client/src/connection_event_listener.hh
new file mode 100644
index 0000000..35a8a5d
--- /dev/null
+++ b/client/src/connection_event_listener.hh
@@ -0,0 +1,62 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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 CLIENT_SRC_CONNECTION_EVENT_LISTENER_H_
+#define CLIENT_SRC_CONNECTION_EVENT_LISTENER_H_
+
+#include <memory>
+#include <string>
+
+#include "PkgMgrProxy.h"
+
+namespace pkgmgr {
+namespace client {
+
+enum class ConnectionState {
+  NotRequested,
+  Connected,
+  Disconnected,
+  Rejected,
+};
+
+template<class T>
+class ConnectionEventListener : public T::IEventListener {
+ public:
+  void OnConnected() override {
+    state_ = ConnectionState::Connected;
+  }
+
+  void OnDisconnected() override {
+    state_ = ConnectionState::Disconnected;
+  }
+
+  void OnRejected() override {
+    state_ = ConnectionState::Rejected;
+  }
+
+  ConnectionState GetState() const {
+    return state_;
+  }
+
+ private:
+  ConnectionState state_ = ConnectionState::NotRequested;
+};
+
+}  // namespace client
+}  // namespace pkgmgr
+
+#endif  // CLIENT_SRC_CONNECTION_EVENT_LISTENER_H_
\ No newline at end of file
diff --git a/client/src/connector.cc b/client/src/connector.cc
new file mode 100644
index 0000000..73ff285
--- /dev/null
+++ b/client/src/connector.cc
@@ -0,0 +1,155 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+#include "connector.hh"
+
+#include <time.h>
+#include <unistd.h>
+
+namespace {
+
+constexpr const char SERVER_PROC_NAME[] = "org.tizen.appfw.pkgmgr";
+
+}
+
+namespace pkgmgr {
+namespace client {
+
+Connector::~Connector() = default;
+
+std::string Connector::GenerateRequestId() const {
+  struct timeval tv;
+  gettimeofday(&tv, NULL);
+  long curtime = tv.tv_sec * 1000000 + tv.tv_usec;
+
+  return std::to_string(getpid()) + "_" + std::to_string(curtime);
+}
+
+void Connector::SetTep(std::string tep_path, bool tep_move) {
+  argv_.push_back("-e");
+  argv_.push_back(std::move(tep_path));
+  argv_.push_back("-M");
+  argv_.push_back(tep_move ? "tep_move" : "tep_copy");
+}
+
+void Connector::SetDebugMode() {
+  argv_.push_back("-G");
+}
+
+void Connector::SetSkipOptimization() {
+  argv_.push_back("-S");
+}
+
+const std::vector<std::string>& Connector::GetArgv() const {
+  return argv_;
+}
+
+pkg_proxy::PkgMgrAdmin* Connector::GetAdminProxy() {
+  if (!ConnectForAdmin())
+    return nullptr;
+
+  return admin_proxy_.get();
+}
+
+pkg_proxy::PkgMgr* Connector::GetInfoProxy() {
+  if (!ConnectForInfo())
+    return nullptr;
+
+  return info_proxy_.get();
+}
+
+pkg_proxy::PkgMgrForClearCache* Connector::GetCacheProxy() {
+  if (!ConnectForCache())
+    return nullptr;
+
+  return cache_proxy_.get();
+}
+
+bool Connector::ConnectForAdmin() {
+  if (!admin_proxy_) {
+    admin_proxy_.reset(new pkg_proxy::PkgMgrAdmin(&conn_admin_listener_,
+        SERVER_PROC_NAME));
+  }
+
+  if (conn_admin_listener_.GetState() == ConnectionState::Connected)
+    return true;
+
+  try {
+    admin_proxy_->Connect(true);
+  } catch (const pkg_proxy::Exception& e) {
+    return false;
+  }
+
+  return true;
+}
+
+bool Connector::ConnectForInfo() {
+  if (!info_proxy_) {
+    info_proxy_.reset(new pkg_proxy::PkgMgr(&conn_info_listener_,
+        SERVER_PROC_NAME));
+  }
+
+  if (conn_info_listener_.GetState() == ConnectionState::Connected)
+    return true;
+
+  try {
+    info_proxy_->Connect(true);
+  } catch (const pkg_proxy::Exception& e) {
+    return false;
+  }
+
+  return true;
+}
+
+bool Connector::ConnectForCache() {
+  if (!cache_proxy_) {
+    cache_proxy_.reset(new pkg_proxy::PkgMgrForClearCache(&conn_cache_listener_,
+        SERVER_PROC_NAME));
+  }
+
+  if (conn_cache_listener_.GetState() == ConnectionState::Connected)
+    return true;
+
+  try {
+    cache_proxy_->Connect(true);
+  } catch (const pkg_proxy::Exception& e) {
+    return false;
+  }
+
+  return true;
+}
+
+const std::unique_ptr<SignalReceiver>& Connector::GetSignalReceiver() {
+  if (!signal_receiver_)
+    signal_receiver_.reset(new SignalReceiver());
+
+  return signal_receiver_;
+}
+
+std::vector<std::string>& Connector::GetResRemovePath() {
+  return res_remove_path_;
+}
+
+std::vector<std::string>& Connector::GetResCreateDir() {
+  return res_create_dir_;
+}
+
+std::vector<pp::ResPath>& Connector::GetResCopyPath() {
+  return res_copy_path_;
+}
+
+}  // namespace client
+}  // namespace pkgmgr
diff --git a/client/src/connector.hh b/client/src/connector.hh
new file mode 100644
index 0000000..51a4706
--- /dev/null
+++ b/client/src/connector.hh
@@ -0,0 +1,76 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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 CLIENT_SRC_CONNECTOR_H_
+#define CLIENT_SRC_CONNECTOR_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "PkgMgrProxy.h"
+
+#include "connection_event_listener.hh"
+#include "signal_receiver.hh"
+
+namespace pkgmgr {
+namespace client {
+
+namespace pkg_proxy = rpc_port::PkgMgrProxy::proxy;
+namespace pp = rpc_port::PkgMgrProxy;
+
+class Connector {
+ public:
+  Connector() = default;
+  virtual ~Connector();
+
+  virtual pkg_proxy::PkgMgrAdmin* GetAdminProxy();
+  virtual pkg_proxy::PkgMgr* GetInfoProxy();
+  virtual pkg_proxy::PkgMgrForClearCache* GetCacheProxy();
+  virtual const std::unique_ptr<SignalReceiver>& GetSignalReceiver();
+  std::string GenerateRequestId() const;
+  void SetTep(std::string tep_path, bool tep_move);
+  void SetDebugMode();
+  void SetSkipOptimization();
+  const std::vector<std::string>& GetArgv() const;
+  std::vector<std::string>& GetResRemovePath();
+  std::vector<std::string>& GetResCreateDir();
+  std::vector<pp::ResPath>& GetResCopyPath();
+
+ private:
+  bool ConnectForAdmin();
+  bool ConnectForInfo();
+  bool ConnectForCache();
+
+ private:
+  std::unique_ptr<pkg_proxy::PkgMgr> info_proxy_;
+  std::unique_ptr<pkg_proxy::PkgMgrForClearCache> cache_proxy_;
+  std::unique_ptr<pkg_proxy::PkgMgrAdmin> admin_proxy_;
+  std::vector<std::string> argv_;
+  ConnectionEventListener<pkg_proxy::PkgMgrAdmin> conn_admin_listener_;
+  ConnectionEventListener<pkg_proxy::PkgMgr> conn_info_listener_;
+  ConnectionEventListener<pkg_proxy::PkgMgrForClearCache> conn_cache_listener_;
+  std::unique_ptr<SignalReceiver> signal_receiver_;
+  std::vector<std::string> res_remove_path_;
+  std::vector<std::string> res_create_dir_;
+  std::vector<pp::ResPath> res_copy_path_;
+};
+
+}  // namespace client
+}  // namespace pkgmgr
+
+#endif  // CLIENT_SRC_CONNECTOR_H_
\ No newline at end of file
diff --git a/client/src/log.hh b/client/src/log.hh
new file mode 100644
index 0000000..5668dd6
--- /dev/null
+++ b/client/src/log.hh
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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 SRC_LOG_H_
+#define SRC_LOG_H_
+
+#include <dlog.h>
+
+#ifdef LOG_TAG
+#undef LOG_TAG
+#endif /* LOG_TAG */
+#define LOG_TAG "PKGMGR_CLIENT"
+
+#undef _E
+#define _E LOGE
+
+#undef _W
+#define _W LOGW
+
+#undef _I
+#define _I LOGI
+
+#undef _D
+#define _D LOGD
+
+#endif  // SRC_LOG_H_
\ No newline at end of file
diff --git a/client/src/pkgmgr.c b/client/src/pkgmgr.c
deleted file mode 100644
index 650b2fe..0000000
--- a/client/src/pkgmgr.c
+++ /dev/null
@@ -1,3163 +0,0 @@
-/*
- * slp-pkgmgr
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@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.
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <unistd.h>
-#include <dlfcn.h>
-#include <dirent.h>
-#include <fcntl.h>
-#include <sys/wait.h>
-#include <sys/time.h>
-#include <unzip.h>
-#include <pthread.h>
-
-#include <glib.h>
-
-#include <pkgmgr-info.h>
-#include <iniparser.h>
-/* For multi-user support */
-#include <tzplatform_config.h>
-
-#include "package-manager.h"
-#include "package-manager-types.h"
-#include "pkgmgr_client_debug.h"
-#include "pkgmgr_client_internal.h"
-
-/* API export macro */
-#ifndef API
-#define API __attribute__ ((visibility("default")))
-#endif
-
-#define BINSH_NAME	"/bin/sh"
-#define BINSH_SIZE	7
-
-#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
-#define REGULAR_USER 5000
-
-static GList *jobs_to_free;
-static pthread_mutex_t __mutex = PTHREAD_MUTEX_INITIALIZER;
-
-static inline uid_t _getuid(void)
-{
-	uid_t uid = getuid();
-
-	if (uid < REGULAR_USER)
-		return GLOBAL_USER;
-	else
-		return uid;
-}
-
-static int _get_internal_request_id()
-{
-	static int internal_req_id = 1;
-
-	return internal_req_id++;
-}
-
-static char *_generate_request_id(void)
-{
-	struct timeval tv;
-	long curtime;
-	char buf[BUFMAX];
-
-	gettimeofday(&tv, NULL);
-	curtime = tv.tv_sec * 1000000 + tv.tv_usec;
-
-	snprintf(buf, sizeof(buf), "%d_%ld", getpid(), curtime);
-
-	return strdup(buf);
-}
-
-static struct cb_info *__create_event_cb_info(struct pkgmgr_client_t *client,
-		pkgmgr_handler event_cb, void *data, const char *req_key)
-{
-	struct cb_info *cb_info;
-
-	cb_info = calloc(1, sizeof(struct cb_info));
-	if (cb_info == NULL) {
-		ERR("out of memory");
-		return NULL;
-	}
-	cb_info->client = client;
-	cb_info->event_cb = event_cb;
-	cb_info->data = data;
-	cb_info->req_id = _get_internal_request_id();
-	if (req_key != NULL) {
-		cb_info->req_key = strdup(req_key);
-		if (cb_info->req_key == NULL) {
-			ERR("out of memory");
-			free(cb_info);
-			return NULL;
-		}
-	}
-
-	return cb_info;
-}
-
-static struct cb_info *__create_app_event_cb_info(
-		struct pkgmgr_client_t *client, pkgmgr_app_handler app_event_cb,
-		void *data, const char *req_key)
-{
-	struct cb_info *cb_info;
-
-	cb_info = calloc(1, sizeof(struct cb_info));
-	if (cb_info == NULL) {
-		ERR("out of memory");
-		return NULL;
-	}
-	cb_info->client = client;
-	cb_info->app_event_cb = app_event_cb;
-	cb_info->data = data;
-	cb_info->req_id = _get_internal_request_id();
-	if (req_key != NULL) {
-		cb_info->req_key = strdup(req_key);
-		if (cb_info->req_key == NULL) {
-			ERR("out of memory");
-			free(cb_info);
-			return NULL;
-		}
-	}
-
-	return cb_info;
-}
-
-static struct cb_info *__create_res_event_cb_info(
-		struct pkgmgr_client_t *client,
-		pkgmgr_res_handler res_event_cb,
-		void *data, const char *req_key)
-{
-	struct cb_info *cb_info;
-
-	cb_info = calloc(1, sizeof(struct cb_info));
-	if (cb_info == NULL) {
-		ERR("out of memory");
-		return NULL;
-	}
-
-	cb_info->client = client;
-	cb_info->res_event_cb = res_event_cb;
-	cb_info->data = data;
-	cb_info->req_id = _get_internal_request_id();
-	if (req_key == NULL)
-		return cb_info;
-
-	cb_info->req_key = strdup(req_key);
-	if (cb_info->req_key == NULL) {
-		ERR("out of memory");
-		free(cb_info);
-		return NULL;
-	}
-
-	return cb_info;
-}
-
-static struct cb_info *__create_size_info_cb_info(
-		struct pkgmgr_client_t *client,
-		pkgmgr_pkg_size_info_receive_cb size_info_cb,
-		void *data, const char *req_key)
-{
-	struct cb_info *cb_info;
-
-	cb_info = calloc(1, sizeof(struct cb_info));
-	if (cb_info == NULL) {
-		ERR("out of memory");
-		return NULL;
-	}
-	cb_info->client = client;
-	cb_info->size_info_cb = size_info_cb;
-	cb_info->data = data;
-	cb_info->req_id = _get_internal_request_id();
-	if (req_key != NULL) {
-		cb_info->req_key = strdup(req_key);
-		if (cb_info->req_key == NULL) {
-			ERR("out of memory");
-			free(cb_info);
-			return NULL;
-		}
-	}
-
-	return cb_info;
-}
-
-static int __jobs_to_free_add(gpointer data)
-{
-	pthread_mutex_lock(&__mutex);
-	if (g_list_find(jobs_to_free, data)) {
-		pthread_mutex_unlock(&__mutex);
-		return -1;
-	}
-
-	jobs_to_free = g_list_append(jobs_to_free, data);
-	pthread_mutex_unlock(&__mutex);
-	return 0;
-}
-
-static void __jobs_to_free_remove(gpointer data)
-{
-	pthread_mutex_lock(&__mutex);
-	jobs_to_free = g_list_remove(jobs_to_free, data);
-	pthread_mutex_unlock(&__mutex);
-}
-
-static void __do_free_cb_info(gpointer data)
-{
-	struct cb_info *cb_info = (struct cb_info *)data;
-
-	g_list_free(cb_info->sid_list);
-	free(cb_info->req_key);
-	free(cb_info);
-}
-
-static void __free_cb_info_cb(gpointer data)
-{
-	g_idle_remove_by_data(data);
-	__do_free_cb_info(data);
-}
-
-__attribute__((destructor)) static void __free_cb_info_at_destructor(void)
-{
-	pthread_mutex_lock(&__mutex);
-	g_list_free_full(jobs_to_free, __free_cb_info_cb);
-	pthread_mutex_unlock(&__mutex);
-}
-
-static gboolean __free_cb_info_at_idle(gpointer data)
-{
-	__jobs_to_free_remove(data);
-	__do_free_cb_info(data);
-
-	return G_SOURCE_REMOVE;
-}
-
-static void __free_cb_info(struct cb_info *cb_info)
-{
-	if (__jobs_to_free_add(cb_info) < 0)
-		return;
-
-	g_idle_add(__free_cb_info_at_idle, cb_info);
-}
-
-static int __get_size_process(pkgmgr_client *pc, const char *pkgid, uid_t uid,
-		pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
-		void *data)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	long long size_info = 0;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || pkgid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "getsize_sync",
-			g_variant_new("(usi)", uid, pkgid, get_type), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(ix)", &ret, &size_info);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request result failed: %d", ret);
-		g_variant_unref(result);
-		return ret;
-	}
-
-	if (size_info < 0) {
-		ERR("invalid size_info=(%lld)", size_info);
-		ret = -1;
-	} else {
-		ret = (int)size_info;
-		DBG("size_info(%lld), return size(%d)", size_info, ret);
-	}
-
-	g_variant_unref(result);
-
-	return ret;
-}
-
-static int __move_pkg_process(pkgmgr_client *pc, const char *pkgid,
-		const char *pkg_type, uid_t uid, pkgmgr_move_type move_type,
-		pkgmgr_handler event_cb, void *data)
-{
-	int ret;
-
-	ret = pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type, event_cb, data, uid);
-	if (ret < 0) {
-		ERR("move request failed");
-		return ret;
-	}
-
-	return ret;
-}
-
-static int __check_app_process(pkgmgr_request_service_type service_type,
-		pkgmgr_client *pc, const char *pkgid, uid_t uid, void *data)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	pkgmgrinfo_pkginfo_h handle;
-	int pid = -1;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	retvm_if(client->pc_type != PC_REQUEST, PKGMGR_R_EINVAL, "client->pc_type is not PC_REQUEST\n");
-
-	ret = pkgmgrinfo_pkginfo_get_usr_pkginfo(pkgid, uid, &handle);
-	if (ret != PMINFO_R_OK) {
-		ERR("pkgmgrinfo_pkginfo_get_pkginfo failed");
-		pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
-		return PKGMGR_R_ERROR;
-	}
-
-	if (service_type == PM_REQUEST_KILL_APP) {
-		ret = pkgmgr_client_connection_send_request(client, "kill",
-				g_variant_new("(us)", uid, pkgid), &result);
-	} else if (service_type == PM_REQUEST_CHECK_APP) {
-		ret = pkgmgr_client_connection_send_request(client, "check",
-				g_variant_new("(us)", uid, pkgid), &result);
-	} else {
-		ERR("unexpected service type: %d", service_type);
-		ret = PKGMGR_R_ERROR;
-	}
-
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
-		return ret;
-	}
-
-	g_variant_get(result, "(ii)", &ret, &pid);
-	g_variant_unref(result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed, ret=%d", ret);
-		pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
-		return ret;
-	}
-
-	*(int *)data = pid;
-
-	pkgmgrinfo_pkginfo_destroy_pkginfo(handle);
-
-	return ret;
-
-}
-
-API pkgmgr_client *pkgmgr_client_new(pkgmgr_client_type pc_type)
-{
-	struct pkgmgr_client_t *client;
-
-	if (pc_type == PC_BROADCAST) {
-		ERR("broadcast type is not supported");
-		return NULL;
-	}
-
-	if (pc_type != PC_REQUEST && pc_type != PC_LISTENING) {
-		ERR("invalid parameter");
-		return NULL;
-	}
-
-	client = calloc(1, sizeof(struct pkgmgr_client_t));
-	if (client == NULL) {
-		ERR("out of memory");
-		return NULL;
-	}
-
-	client->pc_type = pc_type;
-	client->status_type = PKGMGR_CLIENT_STATUS_ALL;
-
-	if (pkgmgr_client_connection_connect(client) != PKGMGR_R_OK) {
-		free(client);
-		return NULL;
-	}
-
-	return (pkgmgr_client *)client;
-}
-
-API int pkgmgr_client_free(pkgmgr_client *pc)
-{
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL) {
-		ERR("invalid argument");
-		return PKGMGR_R_EINVAL;
-	}
-
-	pkgmgr_client_remove_listen_status(client);
-	pkgmgr_client_connection_disconnect(client);
-	if (client->tep_path)
-		free(client->tep_path);
-	if (client->res_copy_builder)
-		g_variant_builder_unref(client->res_copy_builder);
-	if (client->res_remove_builder)
-		g_variant_builder_unref(client->res_remove_builder);
-	if (client->res_create_dir_builder)
-		g_variant_builder_unref(client->res_create_dir_builder);
-	free(client);
-
-	return PKGMGR_R_OK;
-}
-
-struct manifest_and_type type_map[] = {
-		{ "res/wgt/config.xml", "wgt" },
-		{ "config.xml", "wgt" },
-		{ "tizen-manifest.xml", "tpk" },
-		{ NULL, NULL }
-};
-
-static char *__get_type_from_path(const char *pkg_path)
-{
-	const char *type = NULL;
-	unzFile uf;
-	int i;
-
-	uf = unzOpen(pkg_path);
-	if (uf == NULL) {
-		ERR("failed to open zip file %s", pkg_path);
-		return NULL;
-	}
-
-	for (i = 0; type_map[i].manifest != NULL; i++) {
-		if (unzLocateFile(uf, type_map[i].manifest, 0) == UNZ_OK) {
-			DBG("pkgtype of %s: [%s]", pkg_path, type_map[i].type);
-			type = type_map[i].type;
-			break;
-		}
-	}
-	unzClose(uf);
-
-	return type ? strdup(type) : NULL;
-}
-
-API int pkgmgr_client_set_tep_path(pkgmgr_client *pc, const char *tep_path,
-		bool tep_move)
-{
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *) pc;
-
-	if (pc == NULL || tep_path == NULL) {
-		ERR("invalied parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->tep_path)
-		free(client->tep_path);
-
-	client->tep_path = strdup(tep_path);
-	client->tep_move = tep_move;
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_usr_install_packages(pkgmgr_client *pc,
-		const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
-		void *data, uid_t uid)
-{
-	GVariant *result;
-	GVariantBuilder *pkgs_builder;
-	GVariant *pkgs;
-	GVariantBuilder *args_builder;
-	GVariant *args;
-	int ret;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-	int i;
-	char *request_id = NULL;
-
-	if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	for (i = 0; i < n_pkgs; i++) {
-		if (access(pkg_paths[i], F_OK) != 0) {
-			ERR("failed to access: %s", pkg_paths[i]);
-			return PKGMGR_R_EINVAL;
-		}
-	}
-
-	pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	for (i = 0; i < n_pkgs; i++)
-		g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
-	pkgs = g_variant_new("as", pkgs_builder);
-	g_variant_builder_unref(pkgs_builder);
-
-	args_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	if (client->debug_mode)
-		g_variant_builder_add(args_builder, "s", "-G");
-	if (client->skip_optimization)
-		g_variant_builder_add(args_builder, "s", "-S");
-	args = g_variant_new("as", args_builder);
-	g_variant_builder_unref(args_builder);
-
-	request_id = _generate_request_id();
-	ret = pkgmgr_client_connection_send_request(client, "install_pkgs",
-			g_variant_new("(u@as@ass)", uid, pkgs, args,
-					request_id),
-			&result);
-	free(request_id);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ERROR;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_install_packages(pkgmgr_client *pc,
-		const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
-		void *data)
-{
-	return pkgmgr_client_usr_install_packages(pc, pkg_paths, n_pkgs,
-			event_cb, data, _getuid());
-}
-
-API int pkgmgr_client_usr_install(pkgmgr_client *pc, const char *pkg_type,
-		const char *descriptor_path, const char *pkg_path,
-		const char *optional_data, pkgmgr_mode mode,
-		pkgmgr_handler event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	GVariantBuilder *builder = NULL;
-	GVariant *args = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-	char *request_id = NULL;
-
-	if (pc == NULL || pkg_path == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (access(pkg_path, F_OK) != 0) {
-		ERR("failed to access: %s", pkg_path);
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
-		ERR("failed to access: %s", client->tep_path);
-		return PKGMGR_R_EINVAL;
-	}
-
-	/* build arguments */
-	builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	if (client->tep_path) {
-		g_variant_builder_add(builder, "s", "-e");
-		g_variant_builder_add(builder, "s", client->tep_path);
-		g_variant_builder_add(builder, "s", "-M");
-		/* TODO: revise tep_move */
-		g_variant_builder_add(builder, "s",
-				client->tep_move ? "tep_move" : "tep_copy");
-	}
-	if (client->debug_mode)
-		g_variant_builder_add(builder, "s", "-G");
-	if (client->skip_optimization)
-		g_variant_builder_add(builder, "s", "-S");
-
-	args = g_variant_new("as", builder);
-	g_variant_builder_unref(builder);
-
-	request_id = _generate_request_id();
-	ret = pkgmgr_client_connection_send_request(client, "install",
-			g_variant_new("(uss@ass)", uid, pkg_type ? pkg_type : "",
-				pkg_path, args, request_id),
-			&result);
-	free(request_id);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_install(pkgmgr_client *pc, const char *pkg_type,
-		const char *descriptor_path, const char *pkg_path,
-		const char *optional_data, pkgmgr_mode mode,
-		pkgmgr_handler event_cb, void *data)
-{
-	return pkgmgr_client_usr_install(pc, pkg_type, descriptor_path,
-			pkg_path, optional_data, mode, event_cb, data,
-			_getuid());
-}
-
-API int pkgmgr_client_reinstall(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, const char *optional_data, pkgmgr_mode mode,
-		pkgmgr_handler event_cb, void *data)
-{
-	return pkgmgr_client_usr_reinstall(pc, pkg_type, pkgid, optional_data,
-			mode, event_cb, data, _getuid());
-}
-
-API int pkgmgr_client_usr_reinstall(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, const char *optional_data, pkgmgr_mode mode,
-		pkgmgr_handler event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || pkgid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "reinstall",
-			g_variant_new("(us)", uid, pkgid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_usr_mount_install_packages(pkgmgr_client *pc,
-		const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
-		void *data, uid_t uid)
-{
-	GVariant *result;
-	GVariantBuilder *pkgs_builder;
-	GVariant *pkgs;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-	int i;
-	char *request_id = NULL;
-
-	if (pc == NULL || pkg_paths == NULL || n_pkgs < 1) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	for (i = 0; i < n_pkgs; i++) {
-		if (access(pkg_paths[i], F_OK) != 0) {
-			ERR("failed to access: %s", pkg_paths[i]);
-			return PKGMGR_R_EINVAL;
-		}
-	}
-
-	pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	for (i = 0; i < n_pkgs; i++)
-		g_variant_builder_add(pkgs_builder, "s", pkg_paths[i]);
-	pkgs = g_variant_new("as", pkgs_builder);
-	g_variant_builder_unref(pkgs_builder);
-
-	request_id = _generate_request_id();
-	ret = pkgmgr_client_connection_send_request(client,
-			"mount_install_pkgs",
-			g_variant_new("(u@ass)", uid, pkgs, request_id),
-			&result);
-	free(request_id);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_mount_install_packages(pkgmgr_client *pc,
-		const char **pkg_paths, int n_pkgs, pkgmgr_handler event_cb,
-		void *data)
-{
-	return pkgmgr_client_usr_mount_install_packages(pc, pkg_paths, n_pkgs,
-			event_cb, data, _getuid());
-}
-
-API int pkgmgr_client_usr_mount_install(pkgmgr_client *pc, const char *pkg_type,
-		const char *descriptor_path, const char *pkg_path,
-		const char *optional_data, pkgmgr_mode mode,
-		pkgmgr_handler event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	GVariantBuilder *builder = NULL;
-	GVariant *args = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-	char *request_id = NULL;
-
-	if (pc == NULL || pkg_path == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (access(pkg_path, F_OK) != 0) {
-		ERR("failed to access: %s", pkg_path);
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->tep_path != NULL && access(client->tep_path, F_OK) != 0) {
-		ERR("failed to access: %s", client->tep_path);
-		return PKGMGR_R_EINVAL;
-	}
-
-	/* build arguments */
-	builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	if (client->tep_path) {
-		g_variant_builder_add(builder, "s", "-e");
-		g_variant_builder_add(builder, "s", client->tep_path);
-		g_variant_builder_add(builder, "s", "-M");
-		/* TODO: revise tep_move */
-		g_variant_builder_add(builder, "s",
-				client->tep_move ? "tep_move" : "tep_copy");
-	}
-
-	args = g_variant_new("as", builder);
-	g_variant_builder_unref(builder);
-
-	request_id = _generate_request_id();
-	ret = pkgmgr_client_connection_send_request(client, "mount_install",
-			g_variant_new("(uss@ass)", uid,
-					pkg_type ? pkg_type : "", pkg_path,
-					args, request_id),
-			&result);
-	free(request_id);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_mount_install(pkgmgr_client *pc, const char *pkg_type,
-		const char *descriptor_path, const char *pkg_path,
-		const char *optional_data, pkgmgr_mode mode,
-		pkgmgr_handler event_cb, void *data)
-{
-	return pkgmgr_client_usr_mount_install(pc, pkg_type, descriptor_path,
-			pkg_path, optional_data, mode, event_cb, data,
-			_getuid());
-}
-
-API int pkgmgr_client_usr_uninstall_packages(pkgmgr_client *pc,
-		const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
-		void *data, uid_t uid)
-{
-	GVariant *result;
-	GVariantBuilder *pkgs_builder;
-	GVariant *pkgs;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-	int i;
-
-	if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	pkgs_builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	for (i = 0; i < n_pkgs; i++)
-		g_variant_builder_add(pkgs_builder, "s", pkgids[i]);
-	pkgs = g_variant_new("as", pkgs_builder);
-	g_variant_builder_unref(pkgs_builder);
-
-	ret = pkgmgr_client_connection_send_request(client, "uninstall_pkgs",
-			g_variant_new("(u@as)", uid, pkgs), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_uninstall_packages(pkgmgr_client *pc,
-		const char **pkgids, int n_pkgs, pkgmgr_handler event_cb,
-		void *data)
-{
-	return pkgmgr_client_usr_uninstall_packages(pc, pkgids, n_pkgs,
-			event_cb, data, _getuid());
-}
-
-API int pkgmgr_client_uninstall(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
-		void *data)
-{
-	return pkgmgr_client_usr_uninstall(pc, pkg_type, pkgid, mode, event_cb,
-			data, _getuid());
-}
-
-API int pkgmgr_client_usr_uninstall(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, pkgmgr_mode mode, pkgmgr_handler event_cb,
-		void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || pkgid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "uninstall",
-			g_variant_new("(us)", uid, pkgid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_move(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, pkgmgr_move_type move_type,
-		pkgmgr_handler event_cb, void *data)
-{
-	return pkgmgr_client_usr_move(pc, pkg_type, pkgid, move_type,
-			event_cb, data, _getuid());
-}
-API int pkgmgr_client_usr_move(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, pkgmgr_move_type move_type,
-		pkgmgr_handler event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || pkgid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if ((move_type < PM_MOVE_TO_INTERNAL) ||
-			(move_type > PM_MOVE_TO_EXTENDED))
-		return PKGMGR_R_EINVAL;
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "move",
-			g_variant_new("(usi)", uid, pkgid, move_type), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ERROR;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_usr_register_pkg_update_info(pkgmgr_client *pc,
-		pkg_update_info_t *update_info, uid_t uid)
-{
-	int ret;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	GVariant *result;
-
-	if (pc == NULL || update_info == NULL || update_info->pkgid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "register_pkg_update_info",
-			g_variant_new("(ussi)", uid, update_info->pkgid, update_info->version,
-			update_info->type), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-	g_variant_unref(result);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_register_pkg_update_info(pkgmgr_client *pc,
-		pkg_update_info_t *update_info)
-{
-	return pkgmgr_client_usr_register_pkg_update_info(pc, update_info,
-			_getuid());
-}
-
-API int pkgmgr_client_usr_unregister_pkg_update_info(pkgmgr_client *pc,
-		const char *pkgid, uid_t uid)
-{
-	int ret;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	GVariant *result;
-
-	if (pc == NULL || pkgid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"unregister_pkg_update_info",
-			g_variant_new("(us)", uid, pkgid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-	g_variant_unref(result);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_unregister_pkg_update_info(pkgmgr_client *pc,
-		const char *pkgid)
-{
-	return pkgmgr_client_usr_unregister_pkg_update_info(pc, pkgid, _getuid());
-}
-
-API int pkgmgr_client_usr_unregister_all_pkg_update_info(pkgmgr_client *pc,
-		uid_t uid)
-{
-	int ret;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	GVariant *result;
-
-	if (pc == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"unregister_all_pkg_update_info",
-			g_variant_new("(u)", uid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-	g_variant_unref(result);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_unregister_all_pkg_update_info(pkgmgr_client *pc)
-{
-	return pkgmgr_client_usr_unregister_all_pkg_update_info(pc, _getuid());
-}
-
-API int pkgmgr_client_usr_activate(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	GVariantBuilder *builder;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || pkgid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	g_variant_builder_add(builder, "s", pkgid);
-
-	ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
-			g_variant_new("(uas)", uid, builder), &result);
-	g_variant_builder_unref(builder);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(is)", &ret, NULL);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API int pkgmgr_client_activate(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid)
-{
-	return pkgmgr_client_usr_activate(pc, pkg_type, pkgid, _getuid());
-}
-
-API int pkgmgr_client_usr_activate_packages(pkgmgr_client *pc,
-		const char *pkg_type, const char **pkgids, int n_pkgs,
-		pkgmgr_handler event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	GVariantBuilder *builder;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-	int i;
-
-	if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	for (i = 0; i < n_pkgs; i++)
-		g_variant_builder_add(builder, "s", pkgids[i]);
-
-	ret = pkgmgr_client_connection_send_request(client, "enable_pkgs",
-			g_variant_new("(uas)", uid, builder), &result);
-	g_variant_builder_unref(builder);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ERROR;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_activate_packages(pkgmgr_client *pc,
-		const char *pkg_type, const char **pkgids, int n_pkgs,
-		pkgmgr_handler event_cb, void *data)
-{
-	return pkgmgr_client_usr_activate_packages(pc, pkg_type,
-			pkgids, n_pkgs, event_cb, data, _getuid());
-}
-
-API int pkgmgr_client_usr_deactivate(pkgmgr_client *pc, const char *pkg_type,
-				 const char *pkgid, uid_t uid)
-{
-	GVariant *result;
-	GVariantBuilder *builder;
-	int ret = PKGMGR_R_ECOMM;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || pkgid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	g_variant_builder_add(builder, "s", pkgid);
-
-	ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
-			g_variant_new("(uas)", uid, builder), &result);
-	g_variant_builder_unref(builder);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(is)", &ret, NULL);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API int pkgmgr_client_deactivate(pkgmgr_client *pc, const char *pkg_type,
-				 const char *pkgid)
-{
-	return pkgmgr_client_usr_deactivate(pc, pkg_type, pkgid, _getuid());
-}
-
-API int pkgmgr_client_usr_deactivate_packages(pkgmgr_client *pc,
-		const char *pkg_type, const char **pkgids, int n_pkgs,
-		pkgmgr_handler event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	GVariantBuilder *builder;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-	int i;
-
-	if (pc == NULL || pkgids == NULL || n_pkgs < 1) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	for (i = 0; i < n_pkgs; i++)
-		g_variant_builder_add(builder, "s", pkgids[i]);
-
-	ret = pkgmgr_client_connection_send_request(client, "disable_pkgs",
-		g_variant_new("(uas)", uid, builder), &result);
-	g_variant_builder_unref(builder);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ERROR;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_deactivate_packages(pkgmgr_client *pc,
-		const char *pkg_type, const char **pkgids, int n_pkgs,
-		pkgmgr_handler event_cb, void *data)
-{
-	return pkgmgr_client_usr_deactivate_packages(pc, pkg_type,
-			pkgids, n_pkgs, event_cb, data, _getuid());
-}
-
-API int pkgmgr_client_usr_activate_app(pkgmgr_client *pc, const char *appid,
-		pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || appid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "enable_app",
-			g_variant_new("(us)", uid, appid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_app_event_cb_info(client, app_event_cb, data,
-			req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_activate_app(pkgmgr_client *pc, const char *appid,
-		pkgmgr_app_handler app_event_cb, void *data)
-{
-	return pkgmgr_client_usr_activate_app(pc, appid, app_event_cb,
-			data, _getuid());
-}
-
-API int pkgmgr_client_usr_activate_apps(pkgmgr_client *pc, const char **appids,
-		int n_apps, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	GVariantBuilder *builder;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-	int i;
-
-	if (pc == NULL || appids == NULL || n_apps < 1) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	for (i = 0; i < n_apps; i++)
-		g_variant_builder_add(builder, "s", appids[i]);
-
-	ret = pkgmgr_client_connection_send_request(client, "enable_apps",
-		g_variant_new("(uas)", uid, builder), &result);
-	g_variant_builder_unref(builder);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ERROR;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_activate_apps(pkgmgr_client *pc, const char **appids,
-		int n_apps, pkgmgr_app_handler app_event_cb, void *data)
-{
-	return pkgmgr_client_usr_activate_apps(pc, appids, n_apps,
-			app_event_cb, data, _getuid());
-}
-
-API int pkgmgr_client_activate_global_app_for_uid(pkgmgr_client *pc,
-		const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || appid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"enable_global_app_for_uid",
-			g_variant_new("(us)", uid, appid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_app_event_cb_info(client, app_event_cb, data,
-			req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_usr_deactivate_app(pkgmgr_client *pc, const char *appid,
-		pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || appid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "disable_app",
-			g_variant_new("(us)", uid, appid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_app_event_cb_info(client, app_event_cb, data,
-			req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_deactivate_app(pkgmgr_client *pc, const char *appid,
-		pkgmgr_app_handler app_event_cb, void *data)
-{
-	return pkgmgr_client_usr_deactivate_app(pc, appid, app_event_cb, data,
-			_getuid());
-}
-
-API int pkgmgr_client_usr_deactivate_apps(pkgmgr_client *pc,
-		const char **appids, int n_apps,
-		pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	GVariantBuilder *builder;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-	int i;
-
-	if (pc == NULL || appids == NULL || n_apps < 1) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("as"));
-	for (i = 0; i < n_apps; i++)
-		g_variant_builder_add(builder, "s", appids[i]);
-
-	ret = pkgmgr_client_connection_send_request(client, "disable_apps",
-		g_variant_new("(uas)", uid, builder), &result);
-	g_variant_builder_unref(builder);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_app_event_cb_info(client, app_event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ERROR;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_deactivate_apps(pkgmgr_client *pc, const char **appids,
-		int n_apps, pkgmgr_app_handler app_event_cb, void *data)
-{
-	return pkgmgr_client_usr_deactivate_apps(pc, appids, n_apps,
-			app_event_cb, data, _getuid());
-}
-
-API int pkgmgr_client_deactivate_global_app_for_uid(pkgmgr_client *pc,
-		const char *appid, pkgmgr_app_handler app_event_cb, void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || appid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"disable_global_app_for_uid",
-			g_variant_new("(us)", uid, appid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_app_event_cb_info(client, app_event_cb, data,
-			req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_usr_clear_user_data(pkgmgr_client *pc,
-		const char *pkg_type, const char *pkgid, pkgmgr_mode mode,
-		uid_t uid)
-{
-	GVariant *result;
-	int ret;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || pkgid == NULL || uid == GLOBAL_USER) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "cleardata",
-			g_variant_new("(us)", uid, pkgid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API int pkgmgr_client_clear_user_data(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, pkgmgr_mode mode)
-{
-	return pkgmgr_client_usr_clear_user_data(pc, pkg_type, pkgid, mode,
-			_getuid());
-}
-
-API int pkgmgr_client_set_status_type(pkgmgr_client *pc, int status_type)
-{
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	client->status_type = status_type;
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_listen_status(pkgmgr_client *pc, pkgmgr_handler event_cb,
-		void *data)
-{
-	int ret;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || event_cb == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_LISTENING) {
-		ERR("client->pc_type is not PC_LISTENING");
-		return PKGMGR_R_EINVAL;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, NULL);
-	if (cb_info == NULL)
-		return PKGMGR_R_ENOMEM;
-	cb_info->status_type = client->status_type;
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_listen_app_status(pkgmgr_client *pc,
-		pkgmgr_app_handler app_event_cb, void *data)
-{
-	int ret;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || app_event_cb == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_LISTENING) {
-		ERR("client->pc_type is not PC_LISTENING");
-		return PKGMGR_R_EINVAL;
-	}
-
-	cb_info = __create_app_event_cb_info(client, app_event_cb, data, NULL);
-	if (cb_info == NULL)
-		return PKGMGR_R_ENOMEM;
-	cb_info->status_type = client->status_type;
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_listen_res_status(pkgmgr_client *pc,
-		pkgmgr_res_handler event_cb, void *data)
-{
-	int ret;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || event_cb == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_LISTENING) {
-		ERR("client->pc_type is not PC_LISTENING");
-		return PKGMGR_R_EINVAL;
-	}
-
-	cb_info = __create_res_event_cb_info(client, event_cb, data, NULL);
-	if (cb_info == NULL)
-		return PKGMGR_R_ENOMEM;
-	cb_info->status_type = client->status_type;
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_remove_listen_status(pkgmgr_client *pc)
-{
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	GList *tmp;
-	GList *next;
-	struct cb_info *cb_info;
-
-	if (pc == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	/* unset all callback */
-	tmp = client->cb_info_list;
-	while (tmp != NULL) {
-		next = tmp->next;
-		cb_info = (struct cb_info *)tmp->data;
-		pkgmgr_client_connection_unset_callback(pc, cb_info);
-		client->cb_info_list = g_list_delete_link(client->cb_info_list,
-				tmp);
-		__free_cb_info(cb_info);
-		tmp = next;
-	}
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_broadcast_status(pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, const char *key, const char *val)
-{
-	/* client cannot broadcast signal */
-	return PKGMGR_R_OK;
-}
-
-/* TODO: deprecate(or remove) */
-API int pkgmgr_client_request_service(pkgmgr_request_service_type service_type,
-		int service_mode, pkgmgr_client *pc, const char *pkg_type,
-		const char *pkgid, const char *custom_info,
-		pkgmgr_handler event_cb, void *data)
-{
-	return pkgmgr_client_usr_request_service(service_type, service_mode,
-			pc, pkg_type, pkgid, _getuid(), custom_info, event_cb,
-			data);
-}
-
-API int pkgmgr_client_usr_request_service(
-		pkgmgr_request_service_type service_type, int service_mode,
-		pkgmgr_client *pc, const char *pkg_type, const char *pkgid,
-		uid_t uid, const char *custom_info, pkgmgr_handler event_cb,
-		void *data)
-{
-	int ret = 0;
-
-	/* Check for NULL value of service type */
-	retvm_if(service_type > PM_REQUEST_MAX, PKGMGR_R_EINVAL, "service type is not defined\n");
-	retvm_if(service_type < 0, PKGMGR_R_EINVAL, "service type is error\n");
-
-	switch (service_type) {
-	case PM_REQUEST_MOVE:
-		tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
-		tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
-		tryvm_if((service_mode < PM_MOVE_TO_INTERNAL) || (service_mode > PM_MOVE_TO_EXTENDED), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
-
-		ret = __move_pkg_process(pc, pkgid, pkg_type, uid, (pkgmgr_move_type)service_mode, event_cb, data);
-		break;
-
-	case PM_REQUEST_GET_SIZE:
-		tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
-		tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
-		tryvm_if((service_mode < PM_GET_TOTAL_SIZE) || (service_mode >= PM_GET_MAX), ret = PKGMGR_R_EINVAL, "service_mode is wrong\n");
-
-		ret = __get_size_process(pc, pkgid, uid, (pkgmgr_getsize_type)service_mode, event_cb, data);
-		break;
-
-	case PM_REQUEST_KILL_APP:
-	case PM_REQUEST_CHECK_APP:
-		tryvm_if(pkgid == NULL, ret = PKGMGR_R_EINVAL, "pkgid is NULL\n");
-		tryvm_if(pc == NULL, ret = PKGMGR_R_EINVAL, "pc is NULL\n");
-
-		ret = __check_app_process(service_type, pc, pkgid, uid, data);
-		if (ret < 0)
-			ERR("__check_app_process fail \n");
-		else
-			ret = PKGMGR_R_OK;
-
-		break;
-
-	default:
-		ERR("Wrong Request\n");
-		ret = -1;
-		break;
-	}
-
-catch:
-
-	return ret;
-}
-
-API int pkgmgr_client_usr_clear_cache_dir(const char *pkgid, uid_t uid)
-{
-	GVariant *result;
-	int ret;
-	struct pkgmgr_client_t *client;
-
-	if (pkgid == NULL || uid == GLOBAL_USER) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	client = pkgmgr_client_new(PC_REQUEST);
-	if (client == NULL) {
-		ERR("out of memory");
-		return PKGMGR_R_ENOMEM;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "clearcache",
-			g_variant_new("(us)", uid, pkgid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		pkgmgr_client_free(client);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-	pkgmgr_client_free(client);
-
-	return ret;
-}
-
-API int pkgmgr_client_clear_cache_dir(const char *pkgid)
-{
-	return pkgmgr_client_usr_clear_cache_dir(pkgid, _getuid());
-}
-
-API int pkgmgr_client_clear_usr_all_cache_dir(uid_t uid)
-{
-	return pkgmgr_client_usr_clear_cache_dir(PKG_CLEAR_ALL_CACHE, uid);
-}
-
-API int pkgmgr_client_clear_all_cache_dir(void)
-{
-	return pkgmgr_client_usr_clear_cache_dir(
-			PKG_CLEAR_ALL_CACHE, _getuid());
-}
-
-API int pkgmgr_client_get_size(pkgmgr_client *pc, const char *pkgid,
-		pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
-		void *data)
-{
-	return pkgmgr_client_usr_get_size(pc, pkgid, get_type, event_cb, data,
-			_getuid());
-}
-
-/* TODO: deprecate(or remove) */
-API int pkgmgr_client_usr_get_size(pkgmgr_client *pc, const char *pkgid,
-		pkgmgr_getsize_type get_type, pkgmgr_handler event_cb,
-		void *data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || pkgid == NULL || event_cb == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	/* FIXME */
-	if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
-		get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
-	else
-		get_type = PM_GET_PKG_SIZE_INFO;
-
-	ret = pkgmgr_client_connection_send_request(client, "getsize",
-			g_variant_new("(usi)", uid, pkgid, get_type), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_event_cb_info(client, event_cb, data, req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_usr_get_package_size_info(pkgmgr_client *pc,
-		const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
-		void *user_data, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	char *req_key = NULL;
-	int get_type;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || pkgid == NULL || event_cb == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0)
-		get_type = PM_GET_TOTAL_PKG_SIZE_INFO;
-	else
-		get_type = PM_GET_PKG_SIZE_INFO;
-
-	ret = pkgmgr_client_connection_send_request(client, "getsize",
-			g_variant_new("(usi)", uid, pkgid, get_type), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_size_info_cb_info(client, event_cb, user_data,
-			req_key);
-	if (cb_info == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ENOMEM;
-	}
-	g_variant_unref(result);
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_get_package_size_info(pkgmgr_client *pc,
-		const char *pkgid, pkgmgr_pkg_size_info_receive_cb event_cb,
-		void *user_data)
-{
-	return pkgmgr_client_usr_get_package_size_info(pc, pkgid, event_cb,
-			user_data, _getuid());
-}
-
-API int pkgmgr_client_usr_get_total_package_size_info(pkgmgr_client *pc,
-		pkgmgr_total_pkg_size_info_receive_cb event_cb,
-		void *user_data, uid_t uid)
-{	/* total package size info */
-	return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
-			(pkgmgr_pkg_size_info_receive_cb)event_cb,
-			user_data, uid);
-}
-
-API int pkgmgr_client_get_total_package_size_info(pkgmgr_client *pc,
-		pkgmgr_total_pkg_size_info_receive_cb event_cb, void *user_data)
-{
-	return pkgmgr_client_usr_get_package_size_info(pc, PKG_SIZE_INFO_TOTAL,
-			(pkgmgr_pkg_size_info_receive_cb)event_cb,
-			user_data, _getuid());
-}
-
-API int pkgmgr_client_generate_license_request(pkgmgr_client *pc,
-		const char *resp_data, char **req_data, char **license_url)
-{
-	GVariant *result;
-	int ret;
-	char *data;
-	char *url;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || resp_data == NULL || req_data == NULL ||
-			license_url == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"generate_license_request",
-			g_variant_new("(s)", resp_data), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s&s)", &ret, &data, &url);
-	if (ret != PKGMGR_R_OK) {
-		ERR("generate_license_request failed: %d", ret);
-		g_variant_unref(result);
-		return ret;
-	}
-
-	*req_data = strdup(data);
-	*license_url = strdup(url);
-
-	g_variant_unref(result);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_register_license(pkgmgr_client *pc, const char *resp_data)
-{
-	GVariant *result;
-	int ret;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || resp_data == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "register_license",
-			g_variant_new("(s)", resp_data), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-	if (ret != PKGMGR_R_OK)
-		ERR("register license failed: %d", ret);
-
-	return ret;
-}
-
-API int pkgmgr_client_decrypt_package(pkgmgr_client *pc,
-		const char *drm_file_path, const char *decrypted_file_path)
-{
-	GVariant *result;
-	int ret;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || drm_file_path == NULL ||
-			decrypted_file_path == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->pc_type != PC_REQUEST) {
-		ERR("client->pc_type is not PC_REQUEST");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client, "decrypt_package",
-			g_variant_new("(ss)", drm_file_path,
-				decrypted_file_path), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-	if (ret != PKGMGR_R_OK)
-		ERR("decrypt_package failed: %d", ret);
-
-	return ret;
-}
-
-API int pkgmgr_client_enable_splash_screen(pkgmgr_client *pc, const char *appid)
-{
-	return pkgmgr_client_usr_enable_splash_screen(pc, appid, _getuid());
-}
-
-API int pkgmgr_client_usr_enable_splash_screen(pkgmgr_client *pc,
-		const char *appid, uid_t uid)
-{
-	int ret;
-	GVariant *result;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || appid == NULL) {
-		ERR("Invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"enable_app_splash_screen",
-			g_variant_new("(us)", uid, appid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-	if (ret != PKGMGR_R_OK)
-		ERR("enable splash screen failed: %d", ret);
-
-	return ret;
-}
-
-API int pkgmgr_client_disable_splash_screen(pkgmgr_client *pc,
-		const char *appid)
-{
-	return pkgmgr_client_usr_disable_splash_screen(pc, appid,
-			_getuid());
-}
-
-API int pkgmgr_client_usr_disable_splash_screen(pkgmgr_client *pc,
-		const char *appid, uid_t uid)
-{
-	int ret;
-	GVariant *result;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || appid == NULL) {
-		ERR("Invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"disable_app_splash_screen",
-			g_variant_new("(us)", uid, appid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-	if (ret != PKGMGR_R_OK)
-		ERR("disable splash screen failed: %d", ret);
-
-	return ret;
-}
-
-static int __set_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
-		int mode, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"set_restriction_mode",
-			g_variant_new("(usi)", uid, pkgid, mode), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API int pkgmgr_client_usr_set_pkg_restriction_mode(pkgmgr_client *pc,
-		const char *pkgid, int mode, uid_t uid)
-{
-	return __set_pkg_restriction_mode(pc, pkgid, mode, uid);
-}
-
-API int pkgmgr_client_set_pkg_restriction_mode(pkgmgr_client *pc,
-		const char *pkgid, int mode)
-{
-	return pkgmgr_client_usr_set_pkg_restriction_mode(pc, pkgid, mode,
-			_getuid());
-}
-
-static int __unset_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
-		int mode, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0 || mode <= 0) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"unset_restriction_mode",
-			g_variant_new("(usi)", uid, pkgid, mode), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-
-	return ret;
-
-}
-
-API int pkgmgr_client_usr_unset_pkg_restriction_mode(pkgmgr_client *pc,
-		const char *pkgid, int mode, uid_t uid)
-{
-	return __unset_pkg_restriction_mode(pc, pkgid, mode, uid);
-}
-
-API int pkgmgr_client_unset_pkg_restriction_mode(pkgmgr_client *pc,
-		const char *pkgid, int mode)
-{
-	return pkgmgr_client_usr_unset_pkg_restriction_mode(pc, pkgid, mode,
-			_getuid());
-}
-
-static int __get_pkg_restriction_mode(pkgmgr_client *pc, const char *pkgid,
-		int *mode, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	gint m;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || pkgid == NULL || strlen(pkgid) == 0) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"get_restriction_mode",
-			g_variant_new("(us)", uid, pkgid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(ii)", &m, &ret);
-	g_variant_unref(result);
-	if (ret != PKGMGR_R_OK)
-		return ret;
-
-	*mode = m;
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_usr_get_pkg_restriction_mode(pkgmgr_client *pc,
-		const char *pkgid, int *mode, uid_t uid)
-{
-	return __get_pkg_restriction_mode(pc, pkgid, mode, uid);
-}
-
-API int pkgmgr_client_get_pkg_restriction_mode(pkgmgr_client *pc,
-		const char *pkgid, int *mode)
-{
-	return pkgmgr_client_usr_get_pkg_restriction_mode(pc, pkgid, mode,
-			_getuid());
-}
-
-API int pkgmgr_client_usr_set_restriction_mode(pkgmgr_client *pc, int mode,
-		uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"set_restriction_mode",
-			g_variant_new("(usi)", uid, "", mode), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API int pkgmgr_client_set_restriction_mode(pkgmgr_client *pc, int mode)
-{
-	return pkgmgr_client_usr_set_restriction_mode(pc, mode, _getuid());
-}
-
-API int pkgmgr_client_usr_unset_restriction_mode(pkgmgr_client *pc, int mode,
-		uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"unset_restriction_mode",
-			g_variant_new("(usi)", uid, "", mode), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API int pkgmgr_client_unset_restriction_mode(pkgmgr_client *pc, int mode)
-{
-	return pkgmgr_client_usr_unset_restriction_mode(pc, mode, _getuid());
-}
-
-API int pkgmgr_client_usr_get_restriction_mode(pkgmgr_client *pc,
-		int *mode, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	gint m;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"get_restriction_mode",
-			g_variant_new("(us)", uid, ""), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(ii)", &m, &ret);
-	g_variant_unref(result);
-	if (ret != PKGMGR_R_OK)
-		return ret;
-
-	*mode = m;
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_get_restriction_mode(pkgmgr_client *pc, int *mode)
-{
-	return pkgmgr_client_usr_get_restriction_mode(pc, mode, _getuid());
-}
-
-API pkgmgr_info *pkgmgr_client_check_pkginfo_from_file(const char *pkg_path)
-{
-	int ret;
-	pkg_plugin_set *plugin_set;
-	package_manager_pkg_detail_info_t *info;
-	char *pkg_type;
-
-	if (pkg_path == NULL) {
-		ERR("invalid parameter");
-		return NULL;
-	}
-
-	pkg_type = __get_type_from_path(pkg_path);
-	if (pkg_type == NULL) {
-		ERR("cannot get pkg type");
-		return NULL;
-	}
-
-	plugin_set = _package_manager_load_library(pkg_type);
-	if (plugin_set == NULL) {
-		ERR("failed to load library for %s", pkg_type);
-		free(pkg_type);
-		return NULL;
-	}
-
-	info = calloc(1, sizeof(package_manager_pkg_detail_info_t));
-	if (info == NULL) {
-		ERR("out of memory");
-		free(pkg_type);
-		return NULL;
-	}
-
-	ret = plugin_set->get_pkg_detail_info_from_package(pkg_path, info);
-	if (ret) {
-		ERR("get_pkg_detail_info_from_package failed");
-		free(info);
-		free(pkg_type);
-		return NULL;
-	}
-
-	free(pkg_type);
-
-	return (pkgmgr_info *)info;
-}
-
-API int pkgmgr_client_free_pkginfo(pkgmgr_info *info)
-{
-	package_manager_pkg_detail_info_t *pkg_info =
-		(package_manager_pkg_detail_info_t *)info;
-
-	if (info == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	g_list_free_full(pkg_info->privilege_list, free);
-	free(pkg_info->icon_buf);
-	free(pkg_info);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_usr_set_app_label(pkgmgr_client *pc, char *appid,
-		char *label, uid_t uid)
-{
-	GVariant *result;
-	int ret = -1;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || appid == NULL || label == NULL) {
-		ERR("Invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"set_app_label",
-			g_variant_new("(uss)", uid, appid, label), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("Request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API int pkgmgr_client_set_app_label(pkgmgr_client *pc, char *appid, char *label)
-{
-	return pkgmgr_client_usr_set_app_label(pc, appid, label, _getuid());
-}
-
-API int pkgmgr_client_usr_set_app_icon(pkgmgr_client *pc, char *appid,
-		char *icon_path, uid_t uid)
-{
-	GVariant *result;
-	int ret = -1;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || appid == NULL || icon_path == NULL) {
-		ERR("Invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (access(icon_path, F_OK) != 0) {
-		ERR("failed to access: %s", icon_path);
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"set_app_icon",
-			g_variant_new("(uss)", uid, appid, icon_path), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("Request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API int pkgmgr_client_set_app_icon(pkgmgr_client *pc, char *appid, char *icon_path)
-{
-	return pkgmgr_client_usr_set_app_icon(pc, appid, icon_path, _getuid());
-}
-
-API int pkgmgr_client_set_debug_mode(pkgmgr_client *pc, bool debug_mode)
-{
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	client->debug_mode = debug_mode;
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_set_skip_optimization(pkgmgr_client *pc, bool skip_optimization)
-{
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	client->skip_optimization = skip_optimization;
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_usr_migrate_external_image(pkgmgr_client *pc,
-		const char *pkgid, uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"migrate_external_image",
-			g_variant_new("(us)", uid, pkgid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API int pkgmgr_client_add_res_copy_path(pkgmgr_client *pc,
-		const char *src_path, const char *dest_path)
-{
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || src_path == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->res_copy_builder == NULL) {
-		client->res_copy_builder =
-				g_variant_builder_new(G_VARIANT_TYPE("a(ss)"));
-		if (client->res_copy_builder == NULL) {
-			ERR("out of memory");
-			return PKGMGR_R_ENOMEM;
-		}
-	}
-
-	g_variant_builder_add(client->res_copy_builder, "(ss)",
-			src_path, dest_path ? dest_path : "");
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_res_copy(pkgmgr_client *pc,
-		pkgmgr_res_handler event_cb, void *user_data)
-{
-	GVariant *result;
-	int ret;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || event_cb == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"res_copy",
-			g_variant_new("(a(ss))",
-			client->res_copy_builder), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_res_event_cb_info(client,
-			event_cb, user_data, req_key);
-	g_variant_unref(result);
-	if (cb_info == NULL)
-		return PKGMGR_R_ENOMEM;
-
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_add_res_create_dir_path(pkgmgr_client *pc,
-		const char *dir_path)
-{
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || dir_path == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->res_create_dir_builder == NULL) {
-		client->res_create_dir_builder =
-				g_variant_builder_new(G_VARIANT_TYPE("as"));
-		if (client->res_create_dir_builder == NULL) {
-			ERR("out of memory");
-			return PKGMGR_R_ENOMEM;
-		}
-	}
-
-	g_variant_builder_add(client->res_create_dir_builder, "s", dir_path);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_res_create_dir(pkgmgr_client *pc,
-		pkgmgr_res_handler event_cb, void *user_data)
-{
-	GVariant *result;
-	int ret;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || event_cb == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"res_create_dir",
-			g_variant_new("(as)",
-			client->res_create_dir_builder), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_res_event_cb_info(client,
-			event_cb, user_data, req_key);
-	g_variant_unref(result);
-	if (cb_info == NULL)
-		return PKGMGR_R_ENOMEM;
-
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_add_res_remove_path(pkgmgr_client *pc,
-		const char *res_path)
-{
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || res_path == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (client->res_remove_builder == NULL) {
-		client->res_remove_builder =
-				g_variant_builder_new(G_VARIANT_TYPE("as"));
-		if (client->res_remove_builder == NULL) {
-			ERR("out of memory");
-			return PKGMGR_R_ENOMEM;
-		}
-	}
-
-	g_variant_builder_add(client->res_remove_builder, "s", res_path);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_client_res_remove(pkgmgr_client *pc,
-		pkgmgr_res_handler event_cb, void *user_data)
-{
-	GVariant *result;
-	int ret;
-	char *req_key = NULL;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-	struct cb_info *cb_info;
-
-	if (pc == NULL || event_cb == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"res_remove",
-			g_variant_new("(as)",
-			client->res_remove_builder), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i&s)", &ret, &req_key);
-	if (req_key == NULL) {
-		g_variant_unref(result);
-		return PKGMGR_R_ECOMM;
-	}
-	if (ret != PKGMGR_R_OK) {
-		g_variant_unref(result);
-		return ret;
-	}
-
-	cb_info = __create_res_event_cb_info(client,
-			event_cb, user_data, req_key);
-	g_variant_unref(result);
-	if (cb_info == NULL)
-		return PKGMGR_R_ENOMEM;
-
-	ret = pkgmgr_client_connection_set_callback(client, cb_info);
-	if (ret != PKGMGR_R_OK) {
-		__free_cb_info(cb_info);
-		return ret;
-	}
-	client->cb_info_list = g_list_append(client->cb_info_list, cb_info);
-
-	return cb_info->req_id;
-}
-
-API int pkgmgr_client_res_uninstall(pkgmgr_client *pc, const char *pkgid)
-{
-	return pkgmgr_client_res_usr_uninstall(pc, pkgid, _getuid());
-}
-
-API int pkgmgr_client_res_usr_uninstall(pkgmgr_client *pc, const char *pkgid,
-		uid_t uid)
-{
-	GVariant *result;
-	int ret = PKGMGR_R_ECOMM;
-	struct pkgmgr_client_t *client = (struct pkgmgr_client_t *)pc;
-
-	if (pc == NULL || pkgid == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	ret = pkgmgr_client_connection_send_request(client,
-			"res_uninstall",
-			g_variant_new("(us)", uid, pkgid), &result);
-	if (ret != PKGMGR_R_OK) {
-		ERR("request failed: %d", ret);
-		return ret;
-	}
-
-	g_variant_get(result, "(i)", &ret);
-	g_variant_unref(result);
-
-	return ret;
-}
-
-API pkgmgr_res_event_info *pkgmgr_res_event_info_new()
-{
-	pkgmgr_res_event_info_t *info;
-
-	info = calloc(1, sizeof(pkgmgr_res_event_info_t));
-	if (info == NULL) {
-		ERR("out of memory");
-		return NULL;
-	}
-
-	return (pkgmgr_res_event_info *)info;
-}
-
-static void __free_path_states(gpointer data)
-{
-	res_event_path_state_t *path_state = (res_event_path_state_t *)data;
-
-	if (path_state == NULL)
-		return;
-	if (path_state->path)
-		free(path_state->path);
-	free(path_state);
-}
-
-API int pkgmgr_res_event_info_free(pkgmgr_res_event_info *info)
-{
-	pkgmgr_res_event_info_t *event_info =
-			(pkgmgr_res_event_info_t *)info;
-
-	if (event_info == NULL) {
-		ERR("invalid argument");
-		return PKGMGR_R_EINVAL;
-	}
-
-	if (event_info->path_states)
-		g_list_free_full(event_info->path_states, __free_path_states);
-	free(event_info);
-
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_res_event_info_set_error_code(pkgmgr_res_event_info *handle, int error_code)
-{
-	pkgmgr_res_event_info_t *info = handle;
-	if (info == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	info->error_code = error_code;
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_res_event_info_get_error_code(pkgmgr_res_event_info *handle, int *error_code)
-{
-	pkgmgr_res_event_info_t *info = handle;
-	if (info == NULL || error_code == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	*error_code = info->error_code;
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_res_event_info_add_path_state(pkgmgr_res_event_info *handle,
-		const char *path, pkgmgr_res_event_path_state state)
-{
-	pkgmgr_res_event_info_t *info = handle;
-	res_event_path_state_t *path_state;
-
-	if (info == NULL || path == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	path_state = calloc(1, sizeof(res_event_path_state_t));
-	if (path_state == NULL) {
-		ERR("out of memory");
-		return PKGMGR_R_ENOMEM;
-	}
-
-	path_state->path = strdup(path);
-	if (path_state->path == NULL) {
-		ERR("out of memory");
-		free(path_state);
-		return PKGMGR_R_ENOMEM;
-	}
-	path_state->state = state;
-
-	info->path_states = g_list_prepend(info->path_states , path_state);
-	return PKGMGR_R_OK;
-}
-
-API int pkgmgr_res_event_info_foreach_path(pkgmgr_res_event_info *handle,
-		pkgmgr_res_event_path_cb callback, void *user_data)
-{
-	pkgmgr_res_event_info_t *info = handle;
-	GList *list;
-	res_event_path_state_t *path_state;
-
-	if (info == NULL) {
-		ERR("invalid parameter");
-		return PKGMGR_R_EINVAL;
-	}
-
-	for (list = info->path_states; list != NULL; list = list->next) {
-		path_state = (res_event_path_state_t *)list->data;
-		if (callback(path_state->path, path_state->state,
-				user_data) < 0)
-			return PKGMGR_R_OK;
-	}
-
-	return PKGMGR_R_OK;
-}
diff --git a/client/src/pkgmgr_client_connection.c b/client/src/pkgmgr_client_connection.c
deleted file mode 100644
index 4600907..0000000
--- a/client/src/pkgmgr_client_connection.c
+++ /dev/null
@@ -1,447 +0,0 @@
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * 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.
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <sys/types.h>
-#include <unistd.h>
-
-#include <glib.h>
-#include <gio/gio.h>
-
-#include "package-manager.h"
-#include "pkgmgr_client_debug.h"
-#include "pkgmgr_client_internal.h"
-#include "../../installer/pkgmgr_installer.h"
-#include "../../installer/pkgmgr_installer_config.h"
-
-#define CONNECTION_RETRY_MAX 5
-#define CONNECTION_WAIT_USEC (1000000 / 2) /* 0.5 sec */
-#define CONNECTION_TIMEOUT_MSEC 5000 /* 5 sec */
-#define REGULAR_USER 5000
-
-static int _is_system_user(void)
-{
-	uid_t uid = getuid();
-
-	if (uid < REGULAR_USER)
-		return 1;
-	else
-		return 0;
-}
-
-static GBusType __get_bus_type(pkgmgr_client_type type)
-{
-	if (type == PC_REQUEST || _is_system_user())
-		return G_BUS_TYPE_SYSTEM;
-	else
-		return G_BUS_TYPE_SESSION;
-}
-
-int pkgmgr_client_connection_connect(struct pkgmgr_client_t *pc)
-{
-	GError *error = NULL;
-	GBusType bus_type;
-
-#if !GLIB_CHECK_VERSION(2, 35, 0)
-	g_type_init();
-#endif
-	bus_type = __get_bus_type(pc->pc_type);
-	pc->conn = g_bus_get_sync(bus_type, NULL, &error);
-	if (error) {
-		ERR("gdbus connection error (%s)", error->message);
-		g_error_free(error);
-		return PKGMGR_R_ECOMM;
-	}
-
-	return PKGMGR_R_OK;
-}
-
-void pkgmgr_client_connection_disconnect(struct pkgmgr_client_t *pc)
-{
-	/* flush remaining buffer: blocking mode */
-	g_dbus_connection_flush_sync(pc->conn, NULL, NULL);
-	g_object_unref(pc->conn);
-	pc->conn = NULL;
-}
-
-struct signal_map {
-	const char *signal_str;
-	int signal_type;
-};
-
-struct signal_map map[] = {
-	{PKGMGR_INSTALLER_INSTALL_EVENT_STR, PKGMGR_CLIENT_STATUS_INSTALL},
-	{PKGMGR_INSTALLER_UNINSTALL_EVENT_STR, PKGMGR_CLIENT_STATUS_UNINSTALL},
-	{PKGMGR_INSTALLER_UPGRADE_EVENT_STR, PKGMGR_CLIENT_STATUS_UPGRADE},
-	{PKGMGR_INSTALLER_CLEAR_EVENT_STR, PKGMGR_CLIENT_STATUS_CLEAR_DATA},
-	{PKGMGR_INSTALLER_MOVE_EVENT_STR, PKGMGR_CLIENT_STATUS_MOVE},
-	{PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR,
-		PKGMGR_CLIENT_STATUS_INSTALL_PROGRESS},
-	{PKGMGR_INSTALLER_GET_SIZE_KEY_STR, PKGMGR_CLIENT_STATUS_GET_SIZE},
-	{PKGMGR_INSTALLER_CLEAR_CACHE_KEY_STR,
-		PKGMGR_CLIENT_STATUS_CLEAR_CACHE},
-	{PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR,
-		PKGMGR_CLIENT_STATUS_ENABLE_APP},
-	{PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR,
-		PKGMGR_CLIENT_STATUS_DISABLE_APP},
-	{PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR,
-		PKGMGR_CLIENT_STATUS_ENABLE_APP_SPLASH_SCREEN},
-	{PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR,
-		PKGMGR_CLIENT_STATUS_DISABLE_APP_SPLASH_SCREEN},
-	{PKGMGR_INSTALLER_RES_COPY_EVENT_STR, PKGMGR_CLIENT_STATUS_RES_COPY},
-	{PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR,
-		PKGMGR_CLIENT_STATUS_RES_CREATE_DIR},
-	{PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR,
-		PKGMGR_CLIENT_STATUS_RES_REMOVE},
-	{PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR,
-		PKGMGR_CLIENT_STATUS_RES_UNINSTALL},
-	{NULL, -1}
-};
-
-static int __get_signal_type(const char *name)
-{
-	int i;
-
-	if (name == NULL)
-		return -1;
-
-	for (i = 0; map[i].signal_str != NULL; i++) {
-		if (strcmp(map[i].signal_str, name) == 0)
-			return map[i].signal_type;
-	}
-
-	return -1;
-}
-
-static void __handle_size_info_callback(struct cb_info *cb_info,
-		const char *pkgid, const char *val)
-{
-	pkg_size_info_t size_info;
-	char buf[BUFMAX];
-	char *saveptr;
-	char *token;
-	pkgmgr_total_pkg_size_info_receive_cb callback;
-
-	snprintf(buf, sizeof(buf), "%s", val);
-
-	DBG("%s, %s", pkgid, val);
-
-	token = strtok_r(buf, ":", &saveptr);
-	if (token == NULL) {
-		ERR("failed to parse size info");
-		return;
-	}
-	size_info.data_size = atoll(token);
-	token = strtok_r(NULL, ":", &saveptr);
-	if (token == NULL) {
-		ERR("failed to parse size info");
-		return;
-	}
-	size_info.cache_size = atoll(token);
-	token = strtok_r(NULL, ":", &saveptr);
-	if (token == NULL) {
-		ERR("failed to parse size info");
-		return;
-	}
-	size_info.app_size = atoll(token);
-	token = strtok_r(NULL, ":", &saveptr);
-	if (token == NULL) {
-		ERR("failed to parse size info");
-		return;
-	}
-	size_info.ext_data_size = atoll(token);
-	token = strtok_r(NULL, ":", &saveptr);
-	if (token == NULL) {
-		ERR("failed to parse size info");
-		return;
-	}
-	size_info.ext_cache_size = atoll(token);
-	token = strtok_r(NULL, ":", &saveptr);
-	if (token == NULL) {
-		ERR("failed to parse size info");
-		return;
-	}
-	size_info.ext_app_size = atoll(token);
-
-	DBG("data: %lld, cache: %lld, app: %lld, ext_data: %lld, "
-			"ext_cache: %lld, ext_app: %lld",
-			size_info.data_size, size_info.cache_size,
-			size_info.app_size, size_info.ext_data_size,
-			size_info.ext_cache_size, size_info.ext_app_size);
-
-	if (strcmp(pkgid, PKG_SIZE_INFO_TOTAL) == 0) {
-		callback = (pkgmgr_total_pkg_size_info_receive_cb)
-			cb_info->size_info_cb;
-		callback(cb_info->client, &size_info, cb_info->data);
-	} else {
-		cb_info->size_info_cb(cb_info->client, pkgid, &size_info,
-				cb_info->data);
-	}
-}
-
-static void __handle_pkg_signal(const gchar *signal_name,
-		GVariant *parameters, gpointer user_data)
-{
-	uid_t target_uid;
-	char *req_id;
-	char *pkg_type = NULL;
-	char *appid = NULL;
-	char *pkgid = NULL;
-	char *key = NULL;
-	char *val = NULL;
-	struct cb_info *cb_info = (struct cb_info *)user_data;
-	GVariantIter *iter = NULL;
-	int signal_type;
-
-	g_variant_get(parameters, "(u&sa(sss)&s&s)", &target_uid, &req_id, &iter,
-			&key, &val);
-	while (g_variant_iter_loop(iter, "(&s&s&s)", &pkgid, &appid, &pkg_type)) {
-		if (cb_info->req_key) {
-			if (strcmp(cb_info->req_key, req_id) != 0)
-				continue;
-		} else {
-			signal_type = __get_signal_type(signal_name);
-			if (signal_type < 0 || !(cb_info->status_type & signal_type)) {
-				g_variant_iter_free(iter);
-				return;
-			}
-		}
-
-		/* each cb_data can only has one callback */
-		if (cb_info->event_cb) {
-			cb_info->event_cb(target_uid, cb_info->req_id,
-					pkg_type, pkgid, key, val, NULL, cb_info->data);
-		} else if (cb_info->app_event_cb && strcmp(appid, "") != 0) {
-			cb_info->app_event_cb(target_uid, cb_info->req_id,
-					pkg_type, pkgid, appid, key, val, NULL,
-					cb_info->data);
-		} else if (cb_info->size_info_cb) {
-			__handle_size_info_callback(cb_info, pkgid, val);
-		}
-
-		/* TODO: unsubscribe request callback */
-	}
-	g_variant_iter_free(iter);
-}
-
-static void __handle_res_event_signal(const gchar *signal_name,
-		GVariant *parameters, gpointer user_data)
-{
-	uid_t target_uid;
-	char *req_id;
-	char *pkgid = NULL;
-	char *status = NULL;
-	char *path = NULL;
-	pkgmgr_res_event_path_state state;
-	struct cb_info *cb_info = (struct cb_info *)user_data;
-	int signal_type;
-	GVariant *extra_param = NULL;
-	pkgmgr_res_event_info_t *event_info;
-	GVariantIter *iter;
-
-	if (!cb_info->res_event_cb)
-		return;
-
-	g_variant_get(parameters, "(u&s&s&sv)", &target_uid, &req_id, &pkgid, &status, &extra_param);
-	if (!g_variant_type_equal(G_VARIANT_TYPE("(ia(si))"),
-			g_variant_get_type(extra_param))) {
-		ERR("invalid extra parameter");
-		g_variant_unref(extra_param);
-		return;
-	}
-	if (cb_info->req_key) {
-		if (strcmp(cb_info->req_key, req_id) != 0) {
-			g_variant_unref(extra_param);
-			return;
-		}
-	} else {
-		signal_type = __get_signal_type(signal_name);
-		if (signal_type < 0 || !(cb_info->status_type & signal_type)) {
-			g_variant_unref(extra_param);
-			return;
-		}
-	}
-
-	event_info = pkgmgr_res_event_info_new();
-	if (event_info == NULL) {
-		ERR("out of memory");
-		g_variant_unref(extra_param);
-		return;
-	}
-
-	g_variant_get(extra_param, "(ia(si))", &event_info->error_code, &iter);
-
-	while (g_variant_iter_loop(iter, "(&si)", &path, &state)) {
-		if (pkgmgr_res_event_info_add_path_state(event_info,
-				path, state) != PKGMGR_R_OK) {
-			ERR("Fail to add path state");
-			g_variant_unref(extra_param);
-			g_variant_iter_free(iter);
-			pkgmgr_res_event_info_free(event_info);
-			return;
-		}
-	}
-	cb_info->res_event_cb(target_uid, cb_info->req_id, pkgid, signal_name,
-			status, event_info, cb_info->data);
-	g_variant_unref(extra_param);
-	g_variant_iter_free(iter);
-	pkgmgr_res_event_info_free(event_info);
-}
-
-static void __signal_handler(GDBusConnection *conn, const gchar *sender_name,
-		const gchar *object_path, const gchar *interface_name,
-		const gchar *signal_name, GVariant *parameters,
-		gpointer user_data)
-{
-	if (g_variant_type_equal(G_VARIANT_TYPE("(usa(sss)ss)"),
-			g_variant_get_type(parameters))) {
-		__handle_pkg_signal(signal_name, parameters, user_data);
-	} else if (!strcmp(signal_name, PKGMGR_INSTALLER_RES_COPY_EVENT_STR) ||
-			!strcmp(signal_name, PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR) ||
-			!strcmp(signal_name, PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR) ||
-			!strcmp(signal_name, PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR)) {
-		__handle_res_event_signal(signal_name, parameters, user_data);
-	}
-}
-
-static void __set_signal_list(int event, GList **signal_list)
-{
-	int i;
-	if (event == PKGMGR_CLIENT_STATUS_ALL)
-		return;
-
-	for (i = 0; map[i].signal_str != NULL; i++) {
-		if (event & map[i].signal_type)
-			*signal_list = g_list_append(*signal_list,
-					(char *)map[i].signal_str);
-	}
-}
-
-static int __subscribe_signal(struct pkgmgr_client_t *pc,
-		struct cb_info *cb_info, const char *signal)
-{
-	guint sid = g_dbus_connection_signal_subscribe(pc->conn, NULL,
-			PKGMGR_INSTALLER_DBUS_INTERFACE, signal,
-			PKGMGR_INSTALLER_DBUS_OBJECT_PATH, NULL,
-			G_DBUS_SIGNAL_FLAGS_NONE, __signal_handler,
-			(gpointer)cb_info, NULL);
-	if (!sid) {
-		ERR("failed to subscribe singal");
-		return PKGMGR_R_ERROR;
-	}
-	cb_info->sid_list = g_list_append(cb_info->sid_list,
-			GUINT_TO_POINTER(sid));
-
-	return PKGMGR_R_OK;
-}
-
-int pkgmgr_client_connection_set_callback(struct pkgmgr_client_t *pc,
-		struct cb_info *cb_info)
-{
-	GList *signal_list = NULL;
-	GList *tmp_list = NULL;
-	int ret;
-	char *signal_type;
-	__set_signal_list(pc->status_type, &signal_list);
-
-	if (g_list_length(signal_list) == 0)
-		return __subscribe_signal(pc, cb_info, NULL);
-
-	for (tmp_list = signal_list; tmp_list != NULL;
-			tmp_list = g_list_next(tmp_list)) {
-		signal_type = (char *)tmp_list->data;
-		ret = __subscribe_signal(pc, cb_info, signal_type);
-		if (ret != 0) {
-			g_list_free(signal_list);
-			return PKGMGR_R_ERROR;
-		}
-	}
-
-	g_list_free(signal_list);
-	return PKGMGR_R_OK;
-}
-
-void pkgmgr_client_connection_unset_callback(struct pkgmgr_client_t *pc,
-		struct cb_info *cb_info)
-{
-	GList *tmp = NULL;
-	guint tmp_sid;
-	for (tmp = cb_info->sid_list; tmp != NULL; tmp = g_list_next(tmp)) {
-		tmp_sid = GPOINTER_TO_UINT(tmp->data);
-		g_dbus_connection_signal_unsubscribe(pc->conn, tmp_sid);
-	}
-}
-
-int pkgmgr_client_connection_send_request(struct pkgmgr_client_t *pc,
-		const char *method, GVariant *params, GVariant **result)
-{
-	GError *error = NULL;
-	GDBusProxy *proxy;
-	GVariant *r = NULL;
-	int retry_cnt = 0;
-	int ret = PKGMGR_R_ECOMM;
-
-	/* convert floating ref into normal ref */
-	g_variant_ref_sink(params);
-
-	do {
-		proxy = g_dbus_proxy_new_sync(pc->conn,
-				G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES,
-				NULL, PKGMGR_DBUS_SERVICE,
-				PKGMGR_DBUS_OBJECT_PATH,
-				PKGMGR_DBUS_INTERFACE, NULL, &error);
-		if (proxy == NULL) {
-			ERR("failed to get proxy object, sleep and retry[%s]",
-					error->message);
-			g_error_free(error);
-			error = NULL;
-			usleep(CONNECTION_WAIT_USEC);
-			retry_cnt++;
-			continue;
-		}
-
-		r = g_dbus_proxy_call_sync(proxy, method, params,
-				G_DBUS_CALL_FLAGS_NONE,
-				CONNECTION_TIMEOUT_MSEC, NULL, &error);
-		g_object_unref(proxy);
-		if (error && error->code == G_DBUS_ERROR_ACCESS_DENIED) {
-			ERR("failed to send request, privilege denied[%s]",
-					error->message);
-			g_error_free(error);
-			ret = PKGMGR_R_EPRIV;
-			break;
-		}
-		if (r) {
-			*result = r;
-			ret = PKGMGR_R_OK;
-			break;
-		}
-
-		ERR("failed to send request, sleep and retry[%s]",
-				error->message);
-		g_error_free(error);
-		error = NULL;
-		usleep(CONNECTION_WAIT_USEC);
-		retry_cnt++;
-	} while (retry_cnt <= CONNECTION_RETRY_MAX);
-
-	/* decrease ref count to 0 to free resource */
-	g_variant_unref(params);
-
-	return ret;
-}
diff --git a/client/src/pkgmgr_client_debug.h b/client/src/pkgmgr_client_debug.h
deleted file mode 100644
index b81f948..0000000
--- a/client/src/pkgmgr_client_debug.h
+++ /dev/null
@@ -1,91 +0,0 @@
-/*
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
-  * Contact: junsuk. oh <junsuk77.oh@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 __PKGMGR_CLIENT_DEBUG_H__
-#define __PKGMGR_CLIENT_DEBUG_H__
-
-#include <dlog.h>
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif /* LOG_TAG */
-#define LOG_TAG "PKGMGR"
-
-#ifndef ERR
-#define ERR(fmt, args...) LOGE("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
-#endif
-
-#ifndef DBG
-#define DBG(fmt, args...) LOGD("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
-#endif
-
-#ifndef INFO
-#define INFO(fmt, args...) LOGI("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
-#endif
-
-#define ret_if(expr) \
-	do { \
-		if (expr) { \
-			ERR("(%s) ", #expr); \
-			return; \
-		} \
-	} while (0)
-
-#define retm_if(expr, fmt, arg...) \
-	do { \
-		if (expr) { \
-			ERR("(%s) "fmt, #expr, ##arg); \
-			return; \
-		} \
-	} while (0)
-
-#define retv_if(expr, val) \
-	do { \
-		if (expr) { \
-			ERR("(%s) ", #expr); \
-			return (val); \
-		} \
-	} while (0)
-
-#define retvm_if(expr, val, fmt, arg...) \
-	do { \
-		if (expr) { \
-			ERR("(%s) "fmt, #expr, ##arg); \
-			return (val); \
-		} \
-	} while (0)
-
-#define trym_if(expr, fmt, arg...) \
-	do { \
-		if (expr) { \
-			ERR("(%s) "fmt, #expr, ##arg); \
-			goto catch; \
-		} \
-	} while (0)
-
-#define tryvm_if(expr, val, fmt, arg...) \
-	do { \
-		if (expr) { \
-			ERR("(%s) "fmt, #expr, ##arg); \
-			val; \
-			goto catch; \
-		} \
-	} while (0)
-
-#endif  /* __PKGMGR_CLIENT_DEBUG_H__ */
diff --git a/client/src/pkgmgr_client_internal.c b/client/src/pkgmgr_client_internal.c
deleted file mode 100644
index 1c303f9..0000000
--- a/client/src/pkgmgr_client_internal.c
+++ /dev/null
@@ -1,419 +0,0 @@
-/*
- * slp-pkgmgr
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@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.
- *
- */
-
-
-
-
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#include <stdbool.h>
-#include <ctype.h>
-#include <xdgmime.h>
-
-#include <unistd.h>
-#include <dlfcn.h>
-#include <sys/time.h>
-#include <tzplatform_config.h>
-#include <pkgmgr-info.h>
-
-#include "package-manager.h"
-#include "pkgmgr_client_debug.h"
-#include "pkgmgr_client_internal.h"
-
-#define GLOBAL_USER tzplatform_getuid(TZ_SYS_GLOBALAPP_USER)
-
-#define IS_WHITESPACE(CHAR) \
-	((CHAR == ' ' || CHAR == '\t' || CHAR == '\r' || CHAR == '\n') ? \
-	true : false)
-
-void _app_str_trim(char *input)
-{
-	char *trim_str = input;
-
-	if (input == NULL)
-		return;
-
-	while (*input != 0) {
-		if (!IS_WHITESPACE(*input)) {
-			*trim_str = *input;
-			trim_str++;
-		}
-		input++;
-	}
-
-	*trim_str = 0;
-	return;
-}
-
-int _get_mime_from_file(const char *filename, char *mimetype, int len)
-{
-	const char *mime;
-	if (filename == NULL)
-		return -1;
-
-	if (access(filename, F_OK) != 0)
-		return -1;
-
-	mime = xdg_mime_get_mime_type_for_file(filename, 0);
-	if (strcmp(mime, "application/octet-stream") == 0)
-		mime = xdg_mime_get_mime_type_from_file_name(filename);
-
-	snprintf(mimetype, len, "%s", mime);
-	return 0;
-}
-
-int _get_mime_extension(const char *mimetype, char *ext, int len)
-{
-	const char **extlist;
-	int totlen = 0;
-	const char *unaliased_mimetype;
-
-	if (mimetype == NULL || ext == NULL || len <= 0)
-		return -1;
-
-	unaliased_mimetype = xdg_mime_unalias_mime_type(mimetype);
-	if (unaliased_mimetype == NULL)
-		return -1;
-
-	extlist = xdg_mime_get_file_names_from_mime_type(unaliased_mimetype);
-	if (extlist == NULL)
-		return -1;
-
-	if (extlist[0] == NULL)
-		return -1;
-
-	ext[0] = 0;
-	while (*extlist != NULL) {
-		if (*(extlist + 1) == NULL) {
-			snprintf(&ext[totlen], len - totlen, "%s", *extlist);
-			break;
-		} else {
-			snprintf(&ext[totlen], len - totlen, "%s,", *extlist);
-			if (strlen(*extlist) > len - totlen - 1)
-				break;
-			totlen += strlen(*extlist) + 1;
-			extlist++;
-		}
-	}
-
-	return 0;
-}
-
-package_manager_pkg_info_t *_pkg_malloc_appinfo(int num)
-{
-	package_manager_app_info_t *app_info = NULL;
-	package_manager_app_info_t *first = NULL;
-	package_manager_app_info_t *last = NULL;
-	int i = 0;
-
-	for (i = 0; i < num; i++) {
-		app_info = (package_manager_app_info_t *)
-		    malloc(sizeof(package_manager_app_info_t));
-		if (app_info == NULL) {
-			package_manager_app_info_t *temp_info;
-			package_manager_app_info_t *next;
-
-			for (temp_info = first; temp_info != NULL;
-			     temp_info = next) {
-				next = temp_info->next;
-				free(temp_info);
-				temp_info = NULL;
-			}
-
-			return NULL;
-		}
-
-		memset(app_info, 0x00, sizeof(package_manager_app_info_t));
-
-		if (first == NULL)
-			first = app_info;
-
-		if (last == NULL)
-			last = app_info;
-		else {
-			last->next = app_info;
-			last = app_info;
-		}
-	}
-
-	return first;
-
-}
-
-static pkg_plugin_set *plugin_set_list[24] = { 0, };
-
-pkg_plugin_set *_pkg_plugin_load_library(const char *pkg_type,
-		const char *library_path)
-{
-	void *library_handle;
-	int i;
-	bool (*on_load)(pkg_plugin_set *plugin);
-
-	if (library_path == NULL || pkg_type == NULL) {
-		ERR("invalid parameter");
-		return NULL;
-	}
-
-	for (i = 0; plugin_set_list[i]; i++) {
-		if (strcmp(plugin_set_list[i]->pkg_type, pkg_type) == 0) {
-			DBG("already loaded [%s]", library_path);
-			return plugin_set_list[i];
-		}
-	}
-
-	if ((library_handle = dlopen(library_path, RTLD_LAZY)) == NULL) {
-		ERR("dlopen is failed library_path[%s]", library_path);
-		return NULL;
-	}
-
-	if ((on_load = dlsym(library_handle, "pkg_plugin_on_load")) == NULL ||
-			dlerror() != NULL) {
-		ERR("can not find symbol");
-		dlclose(library_handle);
-		return NULL;
-	}
-
-	plugin_set_list[i] = (pkg_plugin_set *)calloc(1, sizeof(pkg_plugin_set));
-	if (plugin_set_list[i] == NULL) {
-		ERR("malloc of the plugin_set_list element is failed");
-		dlclose(library_handle);
-		return NULL;
-	}
-
-	if (on_load(plugin_set_list[i]) != 0) {
-		ERR("pkg_plugin_on_load failed");
-		free(plugin_set_list[i]);
-		dlclose(library_handle);
-		plugin_set_list[i] = NULL;
-		return NULL;
-	}
-
-	plugin_set_list[i]->plugin_handle = library_handle;
-	snprintf(plugin_set_list[i]->pkg_type,
-			sizeof(plugin_set_list[i]->pkg_type), "%s", pkg_type);
-
-	DBG("library [%s] is loaded", library_path);
-
-	return plugin_set_list[i];
-}
-
-int _pkg_plugin_get_library_path(const char *pkg_type, char *library_path)
-{
-	FILE *fp = NULL;
-	char buffer[1024] = { 0 };
-
-	if (pkg_type == NULL || library_path == NULL) {
-		ERR("invalid argument\n");
-		return -1;
-	}
-
-	fp = fopen(PKG_CONF_PATH, "r");
-	if (fp == NULL) {
-		ERR("no matching backendlib\n");
-		return PKGMGR_R_ERROR;
-	}
-
-	char *path = NULL;
-	while (fgets(buffer, 1024, fp) != NULL) {
-		if (buffer[0] == '#')
-			continue;
-
-		_app_str_trim(buffer);
-
-		if ((path = strstr(buffer, PKG_BACKENDLIB)) != NULL) {
-			DBG("[%s]\n", buffer);
-			DBG("[%s]\n", path);
-			path = path + strlen(PKG_BACKENDLIB);
-			DBG("[%s]\n", path);
-
-			break;
-		}
-
-		memset(buffer, 0x00, 1024);
-	}
-
-	if (fp != NULL)
-		fclose(fp);
-
-	if (path == NULL) {
-		ERR("no matching backendlib\n");
-		return PKGMGR_R_ERROR;
-	}
-
-	snprintf(library_path, 1024, "%slib%s.so", path, pkg_type);
-
-	return PKGMGR_R_OK;
-
-}
-
-pkg_plugin_set *_package_manager_load_library(const char *pkg_type)
-{
-	char package_path[1024] = { 0, };
-	pkg_plugin_set *plugin_set;
-
-	if (pkg_type == NULL) {
-		ERR("cannot load library - pkg_type is null");
-		return NULL;
-	}
-
-	if (_pkg_plugin_get_library_path(pkg_type, package_path) !=
-			PKGMGR_R_OK) {
-		ERR("cannot find path");
-		return NULL;
-	}
-
-	plugin_set = _pkg_plugin_load_library(pkg_type, package_path);
-	if (plugin_set == NULL) {
-		ERR("cannot load library");
-		return NULL;
-	}
-
-	return plugin_set;
-}
-
-typedef struct _detail_info_map_t {
-	char *name;
-	void *field;
-	char *type;
-} detail_info_map_t;
-
-/*
-	typedef struct _package_manager_pkg_detail_info_t {
-		char pkg_type[PKG_TYPE_STRING_LEN_MAX];
-		char pkgid[PKG_NAME_STRING_LEN_MAX];
-		char version[PKG_VERSION_STRING_LEN_MAX];
-		char pkg_description[PKG_VALUE_STRING_LEN_MAX];
-		char min_platform_version[PKG_VERSION_STRING_LEN_MAX];
-		time_t installed_time;
-		int installed_size;
-		int app_size;
-		int data_size;
-		char optional_id[PKG_NAME_STRING_LEN_MAX];
-		void *pkg_optional_info;
-	} package_manager_pkg_detail_info_t;
-*/
-
-static package_manager_pkg_detail_info_t tmp_pkg_detail_info;
-
-static detail_info_map_t info_map[] = {
-	{"pkg_type", tmp_pkg_detail_info.pkg_type, "string"},
-	{"pkgid", tmp_pkg_detail_info.pkgid, "string"},
-	{"version", tmp_pkg_detail_info.version, "string"},
-	{"pkg_description", tmp_pkg_detail_info.pkg_description, "string"},
-	{"min_platform_version", tmp_pkg_detail_info.min_platform_version,
-	 "string"},
-	{"installed_time", &tmp_pkg_detail_info.installed_time, "time_t"},
-	{"installed_size", &tmp_pkg_detail_info.installed_size, "int"},
-	{"app_size", &tmp_pkg_detail_info.app_size, "int"},
-	{"data_size", &tmp_pkg_detail_info.data_size, "int"},
-	{"optional_id", tmp_pkg_detail_info.optional_id, "string"}
-};
-
-char *_get_info_string(const char *key,
-		       const package_manager_pkg_detail_info_t *
-		       pkg_detail_info)
-{
-	detail_info_map_t *tmp;
-	int i = 0;
-
-	if (pkg_detail_info == NULL)
-		return NULL;
-
-	memcpy(&tmp_pkg_detail_info, pkg_detail_info,
-	       sizeof(package_manager_pkg_detail_info_t));
-
-	for (i = 0; i < sizeof(info_map) / sizeof(detail_info_map_t); i++) {
-		tmp = &info_map[i];
-		if (strcmp(key, tmp->name) == 0) {
-			if (strcmp(tmp->type, "string") == 0) {
-				return strdup((char *)(tmp->field));
-			} else if (strcmp(tmp->type, "bool") == 0) {
-				char temp[PKG_VALUE_STRING_LEN_MAX];
-				snprintf(temp, PKG_VALUE_STRING_LEN_MAX - 1,
-					"%d", (int)*(bool *) (tmp->field));
-				return strdup(temp);
-			} else if (strcmp(tmp->type, "int") == 0) {
-				char temp[PKG_VALUE_STRING_LEN_MAX];
-				snprintf(temp, PKG_VALUE_STRING_LEN_MAX - 1,
-					"%d", (int)*(int *)(tmp->field));
-				return strdup(temp);
-			} else if (strcmp(tmp->type, "time_t") == 0) {
-				char temp[PKG_VALUE_STRING_LEN_MAX];
-				snprintf(temp, PKG_VALUE_STRING_LEN_MAX - 1,
-					"%d", (int)*(time_t *) (tmp->field));
-				return strdup(temp);
-			} else
-				return NULL;
-		}
-	}
-	return NULL;
-}
-
-int _get_info_int(const char *key,
-		  const package_manager_pkg_detail_info_t *pkg_detail_info)
-{
-	detail_info_map_t *tmp;
-	int i = 0;
-
-	if (pkg_detail_info == NULL)
-		return -1;
-
-	memcpy(&tmp_pkg_detail_info, pkg_detail_info,
-	       sizeof(package_manager_pkg_detail_info_t));
-	for (i = 0; i < sizeof(info_map) / sizeof(detail_info_map_t); i++) {
-		tmp = &info_map[i];
-		if (strcmp(key, tmp->name) == 0) {
-			if (strcmp(tmp->type, "int") == 0)
-				return (int)*(int *)(tmp->field);
-			else
-				return -1;
-		}
-	}
-	return -1;
-}
-
-time_t _get_info_time(const char *key,
-		      const package_manager_pkg_detail_info_t *pkg_detail_info)
-{
-	detail_info_map_t *tmp;
-	int i = 0;
-
-	if (pkg_detail_info == NULL)
-		return -1;
-
-	memcpy(&tmp_pkg_detail_info, pkg_detail_info,
-	       sizeof(package_manager_pkg_detail_info_t));
-	for (i = 0; i < sizeof(info_map) / sizeof(detail_info_map_t); i++) {
-		tmp = &info_map[i];
-		if (strcmp(key, tmp->name) == 0) {
-			if (strcmp(tmp->type, "time_t") == 0)
-				return (time_t) *(time_t *) (tmp->field);
-			else
-				return (time_t) -1;
-		}
-	}
-	return (time_t) -1;
-}
-
-
diff --git a/client/src/pkgmgr_client_internal.h b/client/src/pkgmgr_client_internal.h
deleted file mode 100644
index 02c4205..0000000
--- a/client/src/pkgmgr_client_internal.h
+++ /dev/null
@@ -1,120 +0,0 @@
-/*
- * slp-pkgmgr
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@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 __PKGMGR_CLIENT_INTERNAL_H__
-#define __PKGMGR_CLIENT_INTERNAL_H__
-
-#include <unistd.h>
-#include <ctype.h>
-
-#include <glib.h>
-#include <gio/gio.h>
-
-#include "package-manager-plugin.h"
-#include "package-manager.h"
-
-#define BUFMAX 4096
-
-struct cb_info {
-	int req_id;
-	char *req_key;
-	int status_type;
-	pkgmgr_handler event_cb;
-	pkgmgr_app_handler app_event_cb;
-	pkgmgr_pkg_size_info_receive_cb size_info_cb;
-	pkgmgr_res_handler res_event_cb;
-	void *data;
-	struct pkgmgr_client_t *client;
-	GList *sid_list;
-};
-
-struct pkgmgr_client_t {
-	pkgmgr_client_type pc_type;
-	int status_type;
-	GDBusConnection *conn;
-	GList *cb_info_list;
-	GVariantBuilder *res_copy_builder;
-	GVariantBuilder *res_remove_builder;
-	GVariantBuilder *res_create_dir_builder;
-	char *tep_path;
-	bool tep_move;
-	bool debug_mode;
-	bool skip_optimization;
-};
-
-struct manifest_and_type {
-	const char *manifest;
-	const char *type;
-};
-
-int pkgmgr_client_connection_connect(struct pkgmgr_client_t *pc);
-void pkgmgr_client_connection_disconnect(struct pkgmgr_client_t *pc);
-int pkgmgr_client_connection_set_callback(struct pkgmgr_client_t *pc,
-		struct cb_info *cb_info);
-void pkgmgr_client_connection_unset_callback(struct pkgmgr_client_t *pc,
-		struct cb_info *cb_info);
-int pkgmgr_client_connection_send_request(struct pkgmgr_client_t *pc,
-		const char *method, GVariant *params, GVariant **result);
-
-
-typedef package_manager_pkg_info_t package_manager_app_info_t;
-
-
-package_manager_pkg_info_t *_pkg_malloc_appinfo(int num);
-
-pkg_plugin_set *_pkg_plugin_load_library(const char *pkg_type,
-					 const char *library_path);
-
-int _pkg_plugin_get_library_path(const char *pkg_type, char *library_path);
-
-pkg_plugin_set *_package_manager_load_library(const char *pkg_type);
-
-char *_get_info_string(const char *key,
-		       const package_manager_pkg_detail_info_t *
-		       pkg_detail_info);
-
-int _get_info_int(const char *key,
-		  const package_manager_pkg_detail_info_t *pkg_detail_info);
-
-time_t _get_info_time(const char *key,
-		      const package_manager_pkg_detail_info_t *
-		      pkg_detail_info);
-
-
-#define PKG_FRONTEND	"frontend:"
-#define PKG_BACKEND		"backend:"
-#define PKG_BACKENDLIB	"backendlib:"
-#define PKG_PARSERLIB	"parserlib:"
-#define PKG_CONF_PATH	"/etc/package-manager/pkg_path.conf"
-
-#define PKG_STATUS		"STATUS"
-
-#define PKG_STRING_LEN_MAX 1024
-#define PKG_EXT_LEN_MAX		 20
-#define PKG_ARGC_MAX		 16
-
-void _app_str_trim(char *input);
-
-int _get_mime_from_file(const char *filename, char *mimetype, int len);
-int _get_mime_extension(const char *mimetype, char *ext, int len);
-
-#endif				/* __PKGMGR_CLIENT_INTERNAL_H__ */
diff --git a/client/src/signal_receiver.cc b/client/src/signal_receiver.cc
new file mode 100644
index 0000000..ca20d9a
--- /dev/null
+++ b/client/src/signal_receiver.cc
@@ -0,0 +1,86 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+#include "signal_receiver.hh"
+
+namespace pkgmgr {
+namespace client {
+
+SignalReceiver::SignalReceiver() : PkgSignal("", true) {
+}
+
+SignalReceiver::~SignalReceiver() {
+}
+
+void SignalReceiver::OnAsyncResult(int targetUid, std::string reqId,
+    std::vector<pkg_signal::PkgInfo> pkgs, std::string key, std::string val) {
+  if (handlers_.find(reqId) == handlers_.end())
+    return;
+  auto [id, cb, app_cb, data] = handlers_[reqId];
+
+  for (auto& i : pkgs) {
+    if (cb) {
+      cb(targetUid, id, i.GetPkgType().c_str(), i.GetPkgid().c_str(),
+          key.c_str(), val.c_str(), nullptr, data);
+    } else {
+      app_cb(targetUid, id, i.GetPkgType().c_str(), i.GetPkgid().c_str(),
+          i.GetAppid().c_str(), key.c_str(), val.c_str(), nullptr, data);
+    }
+  }
+
+  //TODO: dispatch using global_handlers_
+}
+
+void SignalReceiver::OnAsyncResultForResource(int targetUid, std::string reqId,
+    std::string pkgid, std::string status, pkg_signal::ExtraData extra) {
+  //TODO
+}
+
+int SignalReceiver::AddEventHandler(std::string req_key,
+    pkgmgr_handler event_cb, void* data) {
+  return AddEventHandler(std::move(req_key), event_cb, nullptr, data);
+}
+
+int SignalReceiver::AddEventHandler(std::string req_key,
+    pkgmgr_app_handler app_event_cb, void* data) {
+  return AddEventHandler(std::move(req_key), nullptr, app_event_cb, data);
+}
+
+int SignalReceiver::AddEventHandler(std::string req_key,
+      pkgmgr_pkg_size_info_receive_cb event_cb, void* data) {
+  //TODO
+  return 1;
+}
+
+int SignalReceiver::AddEventHandler(std::string req_key,
+    pkgmgr_handler event_cb, pkgmgr_app_handler app_event_cb, void* data) {
+  static int sId = 1;
+  if (req_key.empty())
+    global_handlers_.push_back({ sId, event_cb, app_event_cb, data });
+  else
+    handlers_[req_key] = { sId, event_cb, app_event_cb, data };
+  return sId++;
+}
+
+int SignalReceiver::AddEventHandler(std::string req_key,
+    pkgmgr_res_handler event_cb, void* data) {
+  //TODO
+  return 1;
+}
+
+}  // namespace client
+}  // namespace pkgmgr
+
diff --git a/client/src/signal_receiver.hh b/client/src/signal_receiver.hh
new file mode 100644
index 0000000..8d4e8f4
--- /dev/null
+++ b/client/src/signal_receiver.hh
@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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 CLIENT_SRC_SIGNAL_RECEIVER_H_
+#define CLIENT_SRC_SIGNAL_RECEIVER_H_
+
+#include "package-manager.h"
+
+#include <map>
+#include <memory>
+#include <string>
+#include <tuple>
+
+#include "PkgSignal.h"
+
+
+namespace pkgmgr {
+namespace client {
+
+namespace pkg_group = rpc_port::PkgSignal::group;
+namespace pkg_signal = rpc_port::PkgSignal;
+
+class SignalReceiver : public pkg_group::PkgSignal {
+ public:
+  SignalReceiver();
+  virtual ~SignalReceiver();
+
+  void OnAsyncResult(int targetUid, std::string reqId,
+      std::vector<pkg_signal::PkgInfo> pkgs, std::string key,
+      std::string val) override;
+
+  void OnAsyncResultForResource(int targetUid, std::string reqId,
+      std::string pkgid, std::string status,
+      pkg_signal::ExtraData extra) override;
+
+  int AddEventHandler(std::string req_key, pkgmgr_handler event_cb, void* data);
+  int AddEventHandler(std::string req_key, pkgmgr_app_handler app_event_cb,
+      void* data);
+  int AddEventHandler(std::string req_key,
+      pkgmgr_pkg_size_info_receive_cb event_cb, void* data);
+  int AddEventHandler(std::string req_key, pkgmgr_res_handler event_cb,
+      void* data);
+
+ private:
+  int AddEventHandler(std::string req_key, pkgmgr_handler event_cb,
+      pkgmgr_app_handler app_event_cb, void* data);
+
+ private:
+  std::map<std::string, std::tuple<int, pkgmgr_handler, pkgmgr_app_handler,
+      void*>> handlers_;
+  std::list<std::tuple<int, pkgmgr_handler, pkgmgr_app_handler, void*>> global_handlers_;
+};
+
+}  // namespace client
+}  // namespace pkgmgr
+
+#endif  // CLIENT_SRC_CONNECTOR_H_
\ No newline at end of file
diff --git a/cmake/Modules/ApplyPkgConfig.cmake b/cmake/Modules/ApplyPkgConfig.cmake
new file mode 100644
index 0000000..97679d7
--- /dev/null
+++ b/cmake/Modules/ApplyPkgConfig.cmake
@@ -0,0 +1,35 @@
+# Copyright (c) 2014 Samsung Electronics Co., Ltd All Rights Reserved
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+#
+# This function applies external (out of source tree) dependencies
+# to given target. Arguments are:
+#   TARGET - valid cmake target
+#   PRIVACY - dependency can be inherited by dependent targets or not:
+#     PUBLIC - this should be used by default, cause compile/link flags passing
+#     PRIVATE - do not passes any settings to dependent targets,
+#               may be usefull for static libraries from the inside of the project
+# Argument ARGV2 and following are supposed to be names of checked pkg config
+# packages. This function will use variables created by check_pkg_modules().
+#  - ${DEP_NAME}_LIBRARIES
+#  - ${DEP_NAME}_INCLUDE_DIRS
+#  - ${DEP_NAME}_CFLAGS
+#
+FUNCTION(APPLY_PKG_CONFIG TARGET PRIVACY)
+  MATH(EXPR DEST_INDEX "${ARGC}-1")
+  FOREACH(I RANGE 2 ${DEST_INDEX})
+    IF(NOT ${ARGV${I}}_FOUND)
+      MESSAGE(FATAL_ERROR "Not found dependency - ${ARGV${I}}_FOUND")
+    ENDIF(NOT ${ARGV${I}}_FOUND)
+    TARGET_LINK_LIBRARIES(${TARGET} ${PRIVACY} "${${ARGV${I}}_LIBRARIES}")
+    TARGET_INCLUDE_DIRECTORIES(${TARGET} ${PRIVACY} SYSTEM "${${ARGV${I}}_INCLUDE_DIRS}")
+    STRING(REPLACE ";" " " CFLAGS_STR "${${ARGV${I}}_CFLAGS}")
+    SET(CFLAGS_LIST ${CFLAGS_STR})
+    SEPARATE_ARGUMENTS(CFLAGS_LIST)
+    FOREACH(OPTION ${CFLAGS_LIST})
+      TARGET_COMPILE_OPTIONS(${TARGET} ${PRIVACY} ${OPTION})
+    ENDFOREACH(OPTION)
+    SET_TARGET_PROPERTIES(${TARGET} PROPERTIES SKIP_BUILD_RPATH true)
+  ENDFOREACH(I RANGE 2 ${DEST_INDEX})
+ENDFUNCTION(APPLY_PKG_CONFIG TARGET PRIVACY)
diff --git a/installer/CMakeLists.txt b/installer/CMakeLists.txt
index 9c734d0..e5e9553 100644
--- a/installer/CMakeLists.txt
+++ b/installer/CMakeLists.txt
@@ -1,32 +1,30 @@
-### Description
-# Communication modules for pkg-mgr client lib and server process
-# By Youmin Ha <youmin.ha@samsung.com>
+include(FindPkgConfig)
 
-cmake_minimum_required(VERSION 2.6)
-#set(CMAKE_SKIP_BUILD_RPATH true)
-set(CMAKE_ALLOW_LOOSE_LOOP_CONSTRUCTS true)
+AUX_SOURCE_DIRECTORY(src SRCS)
 
-### Get required CFLAGS, LDFLAGS from pkg-config
+PKG_CHECK_MODULES(INSTALLER_DEPS REQUIRED
+  glib-2.0
+  gio-2.0
+  dlog
+  pkgmgr-info
+  libtzplatform-config
+  rpc-port
+  capi-appfw-event
+)
 
-include(FindPkgConfig)
-pkg_check_modules(installer_pkgs REQUIRED glib-2.0 gio-2.0 dlog pkgmgr-info libtzplatform-config)
-foreach(flag ${installer_pkgs_CFLAGS})
-	set(installer_pkgs_CFLAGS_str "${installer_pkgs_CFLAGS_str} ${flag}")
-endforeach()
+FOREACH(FLAGS ${INSTALLER_DEPS_CFLAGS})
+  SET(INSTALLER_CFLAGS "${INSTALLER_CFLAGS} ${FLAGS}")
+ENDFOREACH(FLAGS)
 
-PKG_CHECK_MODULES(AGENT_DEPS REQUIRED glib-2.0 gio-2.0 dlog libsystemd)
-FOREACH(FLAG ${AGENT_DEPS_CFLAGS})
-	SET(AGENT_CFLAGS "${AGENT_CFLAGS} ${FLAG}")
-ENDFOREACH()
+SET(CMAKE_C_FLAGS "${INSTALLER_CFLAGS}")
+SET(CMAKE_CXX_FLAGS "${INSTALLER_CFLAGS} -std=c++17 -fPIC")
 
-### Build modules
+INCLUDE_DIRECTORIES(include)
 
-## pkgmgr_installer object (by youmin.ha)
-# This library is for installer backend
-add_library(pkgmgr_installer SHARED pkgmgr_installer.c)
+### Build modules
+add_library(pkgmgr_installer SHARED ${SRCS})
 set_target_properties(pkgmgr_installer PROPERTIES SOVERSION ${MAJORVER})
 set_target_properties(pkgmgr_installer PROPERTIES VERSION ${FULLVER})
-set_target_properties(pkgmgr_installer PROPERTIES COMPILE_FLAGS "${installer_pkgs_CFLAGS_str} -fPIC")
 target_link_libraries(pkgmgr_installer ${installer_pkgs_LDFLAGS})
 
 ### Create pc file
@@ -34,15 +32,8 @@ configure_file(pkgmgr-installer.pc.in ${CMAKE_CURRENT_BINARY_DIR}/pkgmgr-install
 
 ## Install
 INSTALL(TARGETS pkgmgr_installer DESTINATION ${LIB_INSTALL_DIR} COMPONENT RuntimeLibraries)
-INSTALL(FILES pkgmgr_installer.h DESTINATION include/pkgmgr)
-INSTALL(FILES pkgmgr_installer_info.h DESTINATION include/pkgmgr)
-INSTALL(FILES pkgmgr_installer_error.h DESTINATION include/pkgmgr)
-INSTALL(FILES pkgmgr_installer_type.h DESTINATION include/pkgmgr)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/pkgmgr_installer.h DESTINATION include/pkgmgr)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/pkgmgr_installer_info.h DESTINATION include/pkgmgr)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/pkgmgr_installer_error.h DESTINATION include/pkgmgr)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/src/pkgmgr_installer_type.h DESTINATION include/pkgmgr)
 INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/pkgmgr-installer.pc DESTINATION ${LIB_INSTALL_DIR}/pkgconfig)
-
-## pkgmgr_installer_signal_agent
-ADD_EXECUTABLE(pkgmgr-installer-signal-agent pkgmgr_installer_signal_agent.c)
-SET_TARGET_PROPERTIES(pkgmgr-installer-signal-agent PROPERTIES COMPILE_FLAGS "${AGENT_CFLAGS} -fPIE")
-TARGET_LINK_LIBRARIES(pkgmgr-installer-signal-agent ${AGENT_DEPS_LDFLAGS} "-pie")
-
-INSTALL(TARGETS pkgmgr-installer-signal-agent DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
diff --git a/installer/pkgmgr-installer.pc.in b/installer/pkgmgr-installer.pc.in
index f812a3b..fe02345 100644
--- a/installer/pkgmgr-installer.pc.in
+++ b/installer/pkgmgr-installer.pc.in
@@ -11,6 +11,6 @@ includedir=@INCLUDEDIR@
 Name: package manager installer library
 Description: SLP package manager's installer lib for each backends
 Version: @FULLVER@
-Requires:
+Requires: capi-appfw-event
 Libs: -L${libdir} -lpkgmgr_installer
 Cflags: -I${includedir}/pkgmgr
diff --git a/installer/pkgmgr_installer.c b/installer/pkgmgr_installer.c
deleted file mode 100644
index 82285e0..0000000
--- a/installer/pkgmgr_installer.c
+++ /dev/null
@@ -1,1418 +0,0 @@
-/*
- * slp-pkgmgr
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@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.
- *
- */
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <string.h>
-#include <errno.h>
-#include <getopt.h>
-#include <sys/types.h>
-#include <sys/socket.h>
-#include <sys/un.h>
-
-#include <glib.h>
-#include <gio/gio.h>
-#include <tzplatform_config.h>
-
-#include "package-manager.h"
-#include "pkgmgr_installer.h"
-#include "pkgmgr_installer_config.h"
-#include "pkgmgr_installer_debug.h"
-#include "pkgmgr_installer_info.h"
-#include "pkgmgr_installer_error.h"
-#include "package-manager-types.h"
-
-#include <pkgmgr-info.h>
-
-/* API export macro */
-#ifndef API
-#define API __attribute__ ((visibility("default")))
-#endif
-
-#define MAX_STRLEN 1024
-#define MAX_QUERY_LEN	4096
-
-#define CHK_PI_RET(r) \
-	do { if (NULL == pi) return (r); } while (0)
-
-#define OPTVAL_PRELOAD 1000
-#define OPTVAL_FORCE_REMOVAL 1001
-#define OPTVAL_PRELOAD_RW 1002
-#define OPTVAL_NO_REMOVAL 1003
-#define OPTVAL_KEEP_RWDATA 1004
-#define OPTVAL_PARTIAL_RW 1005
-#define OPTVAL_MIGRATE_EXTIMG 1006
-#define OPTVAL_SKIP_CHECK_REFERENCE 1007
-#define OPTVAL_RECOVER_DB 1008
-#define OPTVAL_RECOVERY_CLEANUP 1009
-
-/* Supported options */
-const char *short_opts = "k:l:i:d:c:m:t:o:r:p:s:b:e:M:y:u:w:D:A:qGS";
-const struct option long_opts[] = {
-	{ "session-id", 1, NULL, 'k' },
-	{ "license-path", 1, NULL, 'l' },
-	{ "install", 1, NULL, 'i' },
-	{ "uninstall", 1, NULL, 'd' },
-	{ "clear", 1, NULL, 'c' },
-	{ "move", 1, NULL, 'm' },
-	{ "move-type", 1, NULL, 't' },
-	{ "optional-data", 0, NULL, 'o' },
-	{ "reinstall", 0, NULL, 'r' },
-	{ "caller-pkgid", 1, NULL, 'p' },
-	{ "tep-path", 1, NULL, 'e' },
-	{ "tep-move", 1, NULL, 'M' },
-	{ "smack", 1, NULL, 's' },
-	{ "manifest-direct-install", 1, NULL, 'y' },
-	{ "mount-install", 1, NULL, 'w' },
-	{ "recovery", 1, NULL, 'b' },
-	{ "debug-mode", 0, NULL, 'G' },
-	{ "skip-optimization", 0, NULL, 'S' },
-	{ "preload", 0, NULL, OPTVAL_PRELOAD }, /* for preload RO */
-	{ "force-remove", 0, NULL, OPTVAL_FORCE_REMOVAL }, /* for preload RO/RW */
-	{ "preload-rw", 0, NULL, OPTVAL_PRELOAD_RW }, /* for preload RW */
-	{ "no-remove", 0, NULL, OPTVAL_NO_REMOVAL }, /* for preload RW */
-	{ "keep-rwdata", 0, NULL, OPTVAL_KEEP_RWDATA }, /* for preload RW */
-	{ "partial-rw", 0, NULL, OPTVAL_PARTIAL_RW }, /* for preload RO */
-	{ "migrate-extimg", 1, NULL, OPTVAL_MIGRATE_EXTIMG },
-	{ "skip-check-reference", 0, NULL, OPTVAL_SKIP_CHECK_REFERENCE },
-	{ "recover-db", 1, NULL, OPTVAL_RECOVER_DB },
-	{ "recovery-cleanup", 0, NULL, OPTVAL_RECOVERY_CLEANUP },
-	{ 0, 0, 0, 0 }	/* sentinel */
-};
-
-struct pkgmgr_installer {
-	int request_type;
-	int move_type;
-	int is_upgrade;
-	char *pkgmgr_info;
-	char *session_id;
-	char *license_path;
-	char *optional_data;
-	char *caller_pkgid;
-	uid_t target_uid;
-	char *tep_path;
-	int tep_move;
-	int is_tep_included;
-	int is_preload;
-	int force_removal;
-	int is_preload_rw;
-	int no_removal;
-	int keep_rwdata;
-	int partial_rw;
-	int debug_mode;
-	int skip_check_reference;
-	int skip_optimization;
-	int recovery_cleanup;
-	GDBusConnection *conn;
-	GHashTable *pkg_list;
-	GList *pkgs;
-};
-
-typedef struct pkg_signal_info {
-	char *pkgid;
-	char *pkg_type;
-} pkg_signal_info;
-
-static uid_t g_target_uid;
-static int g_debug_mode;
-static int g_skip_optimization;
-static pkgmgr_privilege_level g_privilege_level = PM_PRIVILEGE_UNKNOWN;
-
-static const char *__get_signal_name(pkgmgr_installer *pi, const char *key,
-		const char *pkg_type)
-{
-	if (strcmp(key, PKGMGR_INSTALLER_INSTALL_PERCENT_KEY_STR) == 0)
-		return key;
-	else if (strcmp(key, PKGMGR_INSTALLER_GET_SIZE_KEY_STR) == 0)
-		return key;
-	else if (strcmp(key, PKGMGR_INSTALLER_APPID_KEY_STR) == 0)
-		return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR;
-	else if (strcmp(pkg_type, PKGMGR_INSTALLER_CLEAR_CACHE_KEY_STR) == 0)
-		return pkg_type;
-	else if (pi->is_upgrade)
-		return PKGMGR_INSTALLER_UPGRADE_EVENT_STR;
-
-
-	switch (pi->request_type) {
-	case PKGMGR_REQ_INSTALL:
-	case PKGMGR_REQ_MANIFEST_DIRECT_INSTALL:
-	case PKGMGR_REQ_MOUNT_INSTALL:
-	case PKGMGR_REQ_REINSTALL:
-	case PKGMGR_REQ_ENABLE_PKG:
-	case PKGMGR_REQ_RECOVER:
-		return PKGMGR_INSTALLER_INSTALL_EVENT_STR;
-	case PKGMGR_REQ_UNINSTALL:
-	case PKGMGR_REQ_DISABLE_PKG:
-		return PKGMGR_INSTALLER_UNINSTALL_EVENT_STR;
-	case PKGMGR_REQ_UPGRADE:
-		return PKGMGR_INSTALLER_UPGRADE_EVENT_STR;
-	case PKGMGR_REQ_MOVE:
-		return PKGMGR_INSTALLER_MOVE_EVENT_STR;
-	case PKGMGR_REQ_ENABLE_APP:
-		return PKGMGR_INSTALLER_APP_ENABLE_EVENT_STR;
-	case PKGMGR_REQ_DISABLE_APP:
-		return PKGMGR_INSTALLER_APP_DISABLE_EVENT_STR;
-	case PKGMGR_REQ_ENABLE_APP_SPLASH_SCREEN:
-		return PKGMGR_INSTALLER_APP_ENABLE_SPLASH_SCREEN_EVENT_STR;
-	case PKGMGR_REQ_DISABLE_APP_SPLASH_SCREEN:
-		return PKGMGR_INSTALLER_APP_DISABLE_SPLASH_SCREEN_EVENT_STR;
-	case PKGMGR_REQ_CLEAR:
-		return PKGMGR_INSTALLER_CLEAR_EVENT_STR;
-	case PKGMGR_REQ_GETSIZE:
-		return PKGMGR_INSTALLER_GET_SIZE_KEY_STR;
-	case PKGMGR_REQ_RES_COPY:
-		return PKGMGR_INSTALLER_RES_COPY_EVENT_STR;
-	case PKGMGR_REQ_RES_CREATE_DIR:
-		return PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR;
-	case PKGMGR_REQ_RES_REMOVE:
-		return PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR;
-	case PKGMGR_REQ_RES_UNINSTALL:
-		return PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR;
-	}
-
-	ERR("cannot find type");
-
-	return NULL;
-}
-
-static int __send_signal_for_event(pkgmgr_installer *pi, const char *pkg_type,
-		const char *pkgid, const char *appid, const char *key,
-		const char *val)
-{
-	char *sid;
-	const char *tmp_appid = appid;
-	const char *signal_name;
-	GVariant *v;
-	GVariantBuilder *builder;
-	GError *err = NULL;
-
-	if (!pi || pi->conn == NULL)
-		return -1;
-
-	sid = pi->session_id;
-	if (!sid)
-		sid = "";
-
-	signal_name = __get_signal_name(pi, key, pkg_type);
-	if (!signal_name) {
-		ERR("unknown signal type");
-		return -1;
-	}
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
-	g_variant_builder_add(builder, "(sss)", pkgid,
-			(tmp_appid ? tmp_appid : ""), pkg_type);
-	v = g_variant_new("(usa(sss)ss)",
-			pi->target_uid, sid, builder, key, val);
-	g_variant_builder_unref(builder);
-	if (g_dbus_connection_emit_signal(pi->conn, NULL,
-				PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
-				PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name,
-				v, &err) != TRUE) {
-		ERR("failed to send dbus signal");
-		if (err) {
-			ERR("err: %s", err->message);
-			g_error_free(err);
-		}
-		return -1;
-	}
-
-	return 0;
-}
-
-static int __send_signal_to_agent(uid_t uid, void *data, size_t len)
-{
-	int fd;
-	struct sockaddr_un sa;
-	int r;
-
-	fd = socket(AF_UNIX, SOCK_STREAM | SOCK_NONBLOCK, 0);
-	if (fd == -1) {
-		ERR("failed to create socket: %d", errno);
-		return -1;
-	}
-
-	sa.sun_family = AF_UNIX;
-	snprintf(sa.sun_path, sizeof(sa.sun_path), "/run/pkgmgr/agent/%d", uid);
-
-	r = connect(fd, (struct sockaddr *)&sa, sizeof(sa));
-	if (r == -1) {
-		ERR("failed to connect socket(%s): %d", sa.sun_path, errno);
-		close(fd);
-		return -1;
-	}
-
-	r = send(fd, data, len, MSG_NOSIGNAL);
-	if (r < 0) {
-		ERR("failed to send data: %d", errno);
-		close(fd);
-		return -1;
-	}
-
-	close(fd);
-
-	return 0;
-}
-
-static int __send_signal_for_event_for_uid(pkgmgr_installer *pi, uid_t uid,
-		const char *pkg_type, const char *pkgid, const char *appid,
-		const char *key, const char *val)
-{
-	char *sid;
-	const char *signal_name;
-	const char *tmp_appid = appid;
-	size_t name_size;
-	GVariantBuilder *builder;
-	GVariant *gv;
-	gsize gv_len;
-	gpointer gv_data;
-	void *data;
-	void *ptr;
-	size_t data_len;
-
-	if (!pi || pi->conn == NULL)
-		return -1;
-
-	sid = pi->session_id;
-	if (!sid)
-		sid = "";
-
-	data_len = sizeof(size_t) + sizeof(gsize);
-
-	signal_name = __get_signal_name(pi, key, pkg_type);
-	if (!signal_name) {
-		ERR("unknown signal name");
-		return -1;
-	}
-
-	/* including null byte */
-	name_size = strlen(signal_name) + 1;
-	data_len += name_size;
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
-	g_variant_builder_add(builder, "(sss)", pkgid,
-			(tmp_appid ? tmp_appid : ""), pkg_type);
-	gv = g_variant_new("(usa(sss)ss)", pi->target_uid, sid,
-			builder, key, val);
-	g_variant_builder_unref(builder);
-	if (gv == NULL) {
-		ERR("failed to create GVariant instance");
-		return -1;
-	}
-	gv_len = g_variant_get_size(gv);
-	gv_data = g_malloc(gv_len);
-	g_variant_store(gv, gv_data);
-	g_variant_unref(gv);
-	data_len += gv_len;
-
-	data = malloc(data_len);
-	if (data == NULL) {
-		ERR("out of memory");
-		g_free(gv_data);
-		return -1;
-	}
-	ptr = data;
-	memcpy(ptr, &name_size, sizeof(size_t));
-	ptr += sizeof(size_t);
-	memcpy(ptr, &gv_len, sizeof(gsize));
-	ptr += sizeof(gsize);
-	memcpy(ptr, signal_name, name_size);
-	ptr += name_size;
-	memcpy(ptr, gv_data, gv_len);
-	g_free(gv_data);
-
-	if (__send_signal_to_agent(uid, data, data_len)) {
-		ERR("failed to send signal to agent");
-		free(data);
-		return -1;
-	}
-
-	free(data);
-
-	return 0;
-}
-
-static void __free_pkg_list(gpointer data)
-{
-	pkg_signal_info *info = (pkg_signal_info *)data;
-	free(info->pkgid);
-	free(info->pkg_type);
-	free(info);
-}
-
-API pkgmgr_installer *pkgmgr_installer_new(void)
-{
-	pkgmgr_installer *pi;
-	GError *err = NULL;
-
-	pi = calloc(1, sizeof(struct pkgmgr_installer));
-	if (pi == NULL)
-		return NULL;
-
-	pi->conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
-	if (pi->conn == NULL) {
-		ERR("failed to get bus: %s", err->message);
-		g_error_free(err);
-		free(pi);
-		return NULL;
-	}
-
-	pi->tep_path = NULL;
-	pi->tep_move = 0;
-	pi->request_type = PKGMGR_REQ_INVALID;
-	pi->pkg_list = g_hash_table_new_full(
-			g_str_hash, g_str_equal, NULL, __free_pkg_list);
-	return pi;
-}
-
-API pkgmgr_installer *pkgmgr_installer_offline_new(void)
-{
-	pkgmgr_installer *pi;
-
-	pi = calloc(1, sizeof(struct pkgmgr_installer));
-	if (pi == NULL)
-		return NULL;
-
-	pi->tep_path = NULL;
-	pi->tep_move = 0;
-	pi->request_type = PKGMGR_REQ_INVALID;
-
-	return pi;
-}
-
-API int pkgmgr_installer_free(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(-EINVAL);
-
-	/* free members */
-	if (pi->pkgmgr_info)
-		free(pi->pkgmgr_info);
-	if (pi->session_id)
-		free(pi->session_id);
-	if (pi->optional_data)
-		free(pi->optional_data);
-	if (pi->caller_pkgid)
-		free(pi->caller_pkgid);
-	if (pi->tep_path)
-		free(pi->tep_path);
-
-	if (pi->conn) {
-		g_dbus_connection_flush_sync(pi->conn, NULL, NULL);
-		g_object_unref(pi->conn);
-	}
-
-	if (pi->pkgs)
-		g_list_free_full(pi->pkgs, free);
-
-	if (pi->pkg_list)
-		g_hash_table_destroy(pi->pkg_list);
-
-	free(pi);
-
-	return 0;
-}
-
-static void __parse_multiple_pkgs(pkgmgr_installer *pi, int argc, char **argv)
-{
-	while ((optind <= argc) && (*argv[optind - 1] != '-')) {
-		pi->pkgs = g_list_append(pi->pkgs, strdup(argv[optind - 1]));
-		optind++;
-	}
-	optind--;
-}
-
-API int
-pkgmgr_installer_receive_request(pkgmgr_installer *pi,
-				 const int argc, char **argv)
-{
-	CHK_PI_RET(-EINVAL);
-
-	int r = 0;
-
-	/* Parse argv */
-	optind = 1;		/* Initialize optind to clear prev. index */
-	int opt_idx = 0;
-	int c;
-	int mode = 0;
-
-	pi->target_uid = getuid();
-	g_target_uid = pi->target_uid;
-	g_debug_mode = 0;
-	g_skip_optimization = 0;
-
-	if (pi->pkgs) {
-		g_list_free_full(pi->pkgs, free);
-		pi->pkgs = NULL;
-	}
-
-	while (1) {
-		c = getopt_long(argc, argv, short_opts, long_opts, &opt_idx);
-		/* printf("c=%d %c\n", c, c); //debug */
-		if (-1 == c)
-			break;	/* Parse is end */
-		switch (c) {
-		case OPTVAL_PRELOAD:	/* request for preload app */
-			pi->is_preload = 1;
-			DBG("preload request [%d]", pi->is_preload);
-			break;
-		case OPTVAL_FORCE_REMOVAL:	/* request for force-remove */
-			pi->force_removal = 1;
-			DBG("force-remove request [%d]", pi->force_removal);
-			break;
-		case OPTVAL_PRELOAD_RW:	/* request for preload-rw app */
-			pi->is_preload_rw = 1;
-			DBG("preload-rw request [%d]", pi->is_preload_rw);
-			break;
-		case OPTVAL_NO_REMOVAL:	/* request for no-remove */
-			pi->no_removal = 1;
-			DBG("no-remove request [%d]", pi->no_removal);
-			break;
-		case OPTVAL_KEEP_RWDATA:	/* request for keep-rwdata */
-			pi->keep_rwdata = 1;
-			DBG("keep-rwdata request [%d]", pi->keep_rwdata);
-			break;
-		case OPTVAL_PARTIAL_RW:	/* request for partial-rw */
-			pi->partial_rw = 1;
-			DBG("partial-rw request [%d]", pi->partial_rw);
-			break;
-		case OPTVAL_MIGRATE_EXTIMG:
-			/* request for legacy extimg migration */
-			if (mode) {
-				r = -EINVAL;
-				goto RET;
-			}
-			mode = OPTVAL_MIGRATE_EXTIMG;
-			pi->request_type = PKGMGR_REQ_MIGRATE_EXTIMG;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			DBG("legacy extimg migration requested");
-			break;
-		case OPTVAL_SKIP_CHECK_REFERENCE:
-			pi->skip_check_reference = 1;
-			break;
-		case OPTVAL_RECOVER_DB:
-			pi->request_type = PKGMGR_REQ_RECOVER_DB;
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-		case OPTVAL_RECOVERY_CLEANUP:
-			pi->recovery_cleanup = 1;
-			break;
-		case 'k':	/* session id */
-			if (pi->session_id)
-				free(pi->session_id);
-			pi->session_id = strndup(optarg, MAX_STRLEN);
-			break;
-
-		case 'l':	/* license path */
-			if (pi->license_path)
-				free(pi->license_path);
-			pi->license_path = strndup(optarg, MAX_STRLEN);
-			break;
-
-		case 'i':	/* install */
-			if (mode) {
-				r = -EINVAL;
-				goto RET;
-			}
-			mode = 'i';
-			pi->request_type = PKGMGR_REQ_INSTALL;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			DBG("option is [i] pkgid[%s]", pi->pkgmgr_info);
-			if (pi->pkgmgr_info && strlen(pi->pkgmgr_info) == 0) {
-				free(pi->pkgmgr_info);
-				pi->pkgmgr_info = NULL;
-			} else {
-				mode = 'i';
-			}
-			break;
-
-		case 'e':	/* install */
-			if (pi->tep_path)
-				free(pi->tep_path);
-			pi->tep_path = strndup(optarg, MAX_STRLEN);
-			pi->is_tep_included = 1;
-			DBG("option is [e] tep_path[%s]", pi->tep_path);
-			break;
-
-		case 'M':	/* install */
-			if (strcmp(optarg, "tep_move") == 0)
-				pi->tep_move = 1;
-			else
-				pi->tep_move = 0;
-			DBG("option is [M] tep_move[%d]", pi->tep_move);
-			break;
-
-		case 'd':	/* uninstall */
-			if (mode) {
-				r = -EINVAL;
-				goto RET;
-			}
-			mode = 'd';
-			pi->request_type = PKGMGR_REQ_UNINSTALL;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-
-		case 'c':	/* clear */
-			if (mode) {
-				r = -EINVAL;
-				goto RET;
-			}
-			mode = 'c';
-			pi->request_type = PKGMGR_REQ_CLEAR;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-		case 'm':	/* move */
-			if (mode) {
-				r = -EINVAL;
-				goto RET;
-			}
-			mode = 'm';
-			pi->request_type = PKGMGR_REQ_MOVE;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-		case 'r':	/* reinstall */
-			if (mode) {
-				r = -EINVAL;
-				goto RET;
-			}
-			mode = 'r';
-			pi->request_type = PKGMGR_REQ_REINSTALL;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-		case 't': /* move type*/
-			pi->move_type = atoi(optarg);
-			break;
-
-		case 'p': /* caller pkgid*/
-			if (pi->caller_pkgid)
-				free(pi->caller_pkgid);
-			pi->caller_pkgid = strndup(optarg, MAX_STRLEN);
-
-			break;
-
-		case 's':	/* smack */
-			if (mode) {
-				r = -EINVAL;
-				goto RET;
-			}
-			mode = 's';
-			pi->request_type = PKGMGR_REQ_SMACK;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-		case 'o': /* optional data*/
-			pi->optional_data = strndup(optarg, MAX_STRLEN);
-			break;
-
-		case 'y': /* pkgid for direct manifest installation */
-			mode = 'y';
-			pi->request_type = PKGMGR_REQ_MANIFEST_DIRECT_INSTALL;
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-		case 'w': /* pkgid for mount installation */
-			mode = 'w';
-			pi->request_type = PKGMGR_REQ_MOUNT_INSTALL;
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-		case 'b': /* recovery */
-			if (mode) {
-				r = -EINVAL;
-				goto RET;
-			}
-			mode = 'b';
-			pi->request_type = PKGMGR_REQ_RECOVER;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-		case 'D': /* disable pkg */
-			pi->request_type = PKGMGR_REQ_DISABLE_PKG;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-		case 'A': /* enable pkg */
-			pi->request_type = PKGMGR_REQ_ENABLE_PKG;
-			if (pi->pkgmgr_info)
-				free(pi->pkgmgr_info);
-			pi->pkgmgr_info = strndup(optarg, MAX_STRLEN);
-			__parse_multiple_pkgs(pi, argc, argv);
-			break;
-
-		case 'u': /* uid */
-			g_target_uid = (uid_t)atoi(optarg);
-			pi->target_uid = (uid_t)atoi(optarg);
-			break;
-
-		case 'G': /* debug mode */
-			pi->debug_mode = 1;
-			g_debug_mode = 1;
-			break;
-
-		case 'S': /* skip optimization */
-			pi->skip_optimization = 1;
-			g_skip_optimization = 1;
-			break;
-
-			/* Otherwise */
-		case '?':	/* Not an option */
-			break;
-
-		case ':':	/* */
-			break;
-
-		}
-	}
-
-	/* if target user is not set, set as tizenglobalapp user */
-	if (pi->target_uid == 0) {
-		pi->target_uid = tzplatform_getuid(TZ_SYS_GLOBALAPP_USER);
-		g_target_uid = pi->target_uid;
-	}
- RET:
-	return r;
-}
-
-API int pkgmgr_installer_get_request_type(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->request_type;
-}
-
-API uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->target_uid;
-}
-
-API const char *pkgmgr_installer_get_request_info(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->pkgmgr_info;
-}
-
-API const char *pkgmgr_installer_get_request_info_at(pkgmgr_installer *pi,
-		int at)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return (const char *)g_list_nth_data(pi->pkgs, at);
-}
-
-API int pkgmgr_installer_get_request_info_count(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return g_list_length(pi->pkgs);
-}
-
-API const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->tep_path;
-}
-
-API int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->tep_move;
-}
-
-API const char *pkgmgr_installer_get_session_id(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->session_id;
-}
-
-API const char *pkgmgr_installer_get_license_path(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->license_path;
-}
-
-API const char *pkgmgr_installer_get_optional_data(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->optional_data;
-}
-
-API int pkgmgr_installer_is_quiet(pkgmgr_installer *pi)
-{
-	return 1;
-}
-
-API int pkgmgr_installer_get_move_type(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->move_type;
-}
-
-API const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->caller_pkgid;
-}
-
-API int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->is_preload;
-}
-
-API int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->force_removal;
-}
-
-API int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->is_preload_rw;
-}
-
-API int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->no_removal;
-}
-
-API int pkgmgr_installer_get_keep_rwdata(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->keep_rwdata;
-}
-
-API int pkgmgr_installer_get_partial_rw(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->partial_rw;
-}
-
-API int pkgmgr_installer_get_debug_mode(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->debug_mode;
-}
-
-API int pkgmgr_installer_get_skip_check_reference(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->skip_check_reference;
-}
-
-API int pkgmgr_installer_get_skip_optimization(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->skip_optimization;
-}
-
-API int pkgmgr_installer_get_recovery_cleanup(pkgmgr_installer *pi)
-{
-	CHK_PI_RET(PKGMGR_REQ_INVALID);
-	return pi->recovery_cleanup;
-}
-
-API int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi,
-			     const char *pkg_type,
-			     const char *pkgid,
-			     const char *val)
-{
-	int ret = 0;
-	ret = __send_signal_for_event(pi, pkg_type, pkgid, NULL,
-			PKGMGR_INSTALLER_APPID_KEY_STR, val);
-	return ret;
-}
-
-API int pkgmgr_installer_send_app_uninstall_signal_for_uid(
-		pkgmgr_installer *pi, uid_t uid, const char *pkg_type,
-		const char *pkgid, const char *val)
-{
-	int ret = 0;
-	ret = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL,
-			PKGMGR_INSTALLER_APPID_KEY_STR, val);
-	return ret;
-}
-
-API int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid)
-{
-	if (pi == NULL)
-		return -1;
-
-	pi->target_uid = uid;
-	g_target_uid = pi->target_uid;
-
-	return 0;
-}
-
-API int
-pkgmgr_installer_send_app_signal(pkgmgr_installer *pi,
-			     const char *pkg_type,
-			     const char *pkgid,
-			     const char *appid,
-			     const char *key, const char *val)
-{
-	int r = 0;
-
-	if (!pi->conn) {
-		ERR("connection is NULL");
-		return -1;
-	}
-
-	r = __send_signal_for_event(pi, pkg_type, pkgid, appid, key, val);
-
-	return r;
-}
-
-API int
-pkgmgr_installer_send_signal(pkgmgr_installer *pi,
-			     const char *pkg_type,
-			     const char *pkgid,
-			     const char *key, const char *val)
-{
-	int r = 0;
-
-	if (!pi->conn) {
-		ERR("connection is NULL");
-		return -1;
-	}
-
-	r = __send_signal_for_event(pi, pkg_type, pkgid, NULL, key, val);
-
-	return r;
-}
-
-API int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi,
-		uid_t uid, const char *pkg_type, const char *pkgid,
-		const char *appid, const char *key, const char *val)
-{
-	int r = 0;
-
-	if (!pi->conn) {
-		ERR("connection is NULL");
-		return -1;
-	}
-
-	r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, appid,
-			key, val);
-
-	return r;
-}
-
-API int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi,
-		uid_t uid, const char *pkg_type, const char *pkgid,
-		const char *key, const char *val)
-{
-	int r = 0;
-
-	if (!pi->conn) {
-		ERR("connection is NULL");
-		return -1;
-	}
-
-	r = __send_signal_for_event_for_uid(pi, uid, pkg_type, pkgid, NULL,
-			key, val);
-
-	return r;
-}
-
-API int pkgmgr_installer_set_request_type(pkgmgr_installer *pi, int request_type)
-{
-	if (pi == NULL)
-		return -1;
-
-	pi->request_type = request_type;
-	return 0;
-}
-
-API int pkgmgr_installer_set_session_id(pkgmgr_installer *pi, const char *session_id)
-{
-	if (pi == NULL || session_id == NULL)
-		return -1;
-
-	pi->session_id = strndup(session_id, MAX_STRLEN);
-	return 0;
-}
-
-API int pkgmgr_installer_create_certinfo_set_handle(pkgmgr_instcertinfo_h *handle)
-{
-	int ret = 0;
-	ret = pkgmgrinfo_create_certinfo_set_handle(handle);
-	return ret;
-}
-
-API int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle, pkgmgr_instcert_type cert_type, char *cert_value)
-{
-	int ret = 0;
-	ret = pkgmgrinfo_set_cert_value(handle, cert_type, cert_value);
-	return ret;
-}
-
-API int pkgmgr_installer_save_certinfo(const char *pkgid, pkgmgr_instcertinfo_h handle, uid_t uid)
-{
-	int ret = 0;
-	ret = pkgmgrinfo_save_certinfo(pkgid, handle, uid);
-	return ret;
-}
-
-API int pkgmgr_installer_destroy_certinfo_set_handle(pkgmgr_instcertinfo_h handle)
-{
-	int ret = 0;
-	ret = pkgmgrinfo_destroy_certinfo_set_handle(handle);
-	return ret;
-}
-
-API int pkgmgr_installer_delete_certinfo(const char *pkgid)
-{
-	int ret = 0;
-	ret = pkgmgrinfo_delete_certinfo(pkgid);
-	return ret;
-}
-
-API int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level)
-{
-	g_privilege_level = level;
-
-	return 0;
-}
-
-API int pkgmgr_installer_info_get_target_uid(uid_t *uid)
-{
-	*uid = g_target_uid;
-
-	return 0;
-}
-
-API int pkgmgr_installer_info_get_privilege_level(pkgmgr_privilege_level *level)
-{
-	*level = g_privilege_level;
-
-	return 0;
-}
-
-API int pkgmgr_installer_info_get_debug_mode(int *debug_mode)
-{
-	*debug_mode = g_debug_mode;
-	return 0;
-}
-
-API int pkgmgr_installer_info_get_skip_optimization(int *skip_optimization)
-{
-	*skip_optimization = g_skip_optimization;
-	return 0;
-}
-
-#define CASE_TO_STR(ERRCODE) case ERRCODE: return ERRCODE##_STR
-API const char *pkgmgr_installer_error_to_string(int error_code)
-{
-	switch (error_code) {
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GLOBALSYMLINK_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GRANT_PERMISSION_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_IMAGE_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNZIP_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_REGISTER_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PRIVILEGE_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PARSE_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_RECOVERY_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_DELTA_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_APP_DIR_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CONFIG_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_INVALID);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CERT_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_MATCH);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_FOUND);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_NOT_FOUND);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_NOT_FOUND);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OPERATION_NOT_ALLOWED);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ERROR);
-	CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OK);
-	default:
-		return PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR_STR;
-	}
-}
-
-API int pkgmgr_installer_add_pkg(pkgmgr_installer *pi,
-		const char *pkgid, const char *pkg_type)
-{
-	pkg_signal_info *info;
-	if (!pi || !pkgid || !pkg_type) {
-		ERR("invalid argument");
-		return -1;
-	}
-
-	info = calloc(1, sizeof(pkg_signal_info));
-	if (!info) {
-		ERR("out of memory");
-		return -1;
-	}
-
-	info->pkgid = strdup(pkgid);
-	info->pkg_type = strdup(pkg_type);
-	if (!info->pkgid || !info->pkg_type) {
-		ERR("out of memory");
-		free(info->pkgid);
-		free(info->pkg_type);
-		free(info);
-		return -1;
-	}
-	g_hash_table_insert(pi->pkg_list, (gpointer)info->pkgid, (gpointer)info);
-
-	return 0;
-}
-
-static void __build_multi_signal(gpointer key, gpointer value,
-		gpointer user_data)
-{
-	GVariantBuilder *builder = (GVariantBuilder *)user_data;
-	pkg_signal_info *info = (pkg_signal_info *)value;
-
-	g_variant_builder_add(builder, "(sss)", info->pkgid, "", info->pkg_type);
-}
-
-API int pkgmgr_installer_send_signals(pkgmgr_installer *pi,
-		const char *key, const char *val)
-{
-	char *sid;
-	const char *signal_name;
-	GError *err = NULL;
-	GVariantBuilder *builder;
-
-	if (!pi || !key || !val) {
-		ERR("invalid argument");
-		return -1;
-	}
-
-	sid = pi->session_id;
-	if (!sid)
-		sid = "";
-
-	signal_name = __get_signal_name(pi, key, "");
-	if (!signal_name) {
-		ERR("unknown signal type");
-		return -1;
-	}
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
-	g_hash_table_foreach(pi->pkg_list, __build_multi_signal, builder);
-	if (g_dbus_connection_emit_signal(pi->conn, NULL,
-				PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
-				PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name,
-				g_variant_new("(usa(sss)ss)",
-						pi->target_uid, sid, builder, key,
-						val), &err) != TRUE) {
-		ERR("failed to send dbus signal");
-		if (err) {
-			ERR("err: %s", err->message);
-			g_error_free(err);
-		}
-		g_variant_builder_unref(builder);
-		return -1;
-	}
-	g_variant_builder_unref(builder);
-
-	return 0;
-}
-
-API int pkgmgr_installer_send_signals_for_uid(pkgmgr_installer *pi, uid_t uid,
-		const char *key, const char *val)
-{
-	char *sid;
-	size_t data_len;
-	size_t name_size;
-	GVariant *gv;
-	GVariantBuilder *builder;
-	gsize gv_len;
-	gpointer gv_data;
-	void *data;
-	void *ptr;
-	const char *signal_name;
-
-	if (!pi || !pi->conn) {
-		ERR("connection is NULL");
-		return -1;
-	}
-
-	sid = pi->session_id;
-	if (!sid)
-		sid = "";
-
-	data_len = sizeof(size_t) + sizeof(gsize);
-
-	/* including null byte */
-	signal_name = __get_signal_name(pi, key, "");
-	if (!signal_name) {
-		ERR("unknown signal type");
-		return -1;
-	}
-	name_size = strlen(signal_name) + 1;
-	data_len += name_size;
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("a(sss)"));
-	g_hash_table_foreach(pi->pkg_list, __build_multi_signal, builder);
-
-	gv = g_variant_new("(usa(sss)ss)", uid, sid, builder, key, val);
-	g_variant_builder_unref(builder);
-	if (gv == NULL) {
-		ERR("failed to create GVariant instance");
-		return -1;
-	}
-
-	gv_len = g_variant_get_size(gv);
-	gv_data = g_malloc(gv_len);
-	g_variant_store(gv, gv_data);
-	g_variant_unref(gv);
-	data_len += gv_len;
-
-	data = malloc(data_len);
-	if (data == NULL) {
-		ERR("out of memory");
-		g_free(gv_data);
-		return -1;
-	}
-	ptr = data;
-	memcpy(ptr, &name_size, sizeof(size_t));
-	ptr += sizeof(size_t);
-	memcpy(ptr, &gv_len, sizeof(gsize));
-	ptr += sizeof(gsize);
-	memcpy(ptr, signal_name, name_size);
-	ptr += name_size;
-	memcpy(ptr, gv_data, gv_len);
-	g_free(gv_data);
-
-	if (__send_signal_to_agent(uid, data, data_len)) {
-		ERR("failed to send signal to agent");
-		free(data);
-		return -1;
-	}
-
-	free(data);
-
-	return 0;
-}
-
-API int pkgmgr_installer_set_is_upgrade(pkgmgr_installer *pi, int is_upgrade) {
-	if (pi == NULL)
-		return -1;
-
-	pi->is_upgrade = is_upgrade;
-	return 0;
-}
-
-static GVariant *__get_gvariant_from_event_info(pkgmgr_res_event_info *event_info)
-{
-	pkgmgr_res_event_info_t *info = event_info;
-	GVariantBuilder *builder;
-	GVariant *result;
-	GList *path_states;
-	res_event_path_state_t *path_state;
-
-	builder = g_variant_builder_new(G_VARIANT_TYPE("a(si)"));
-	if (builder == NULL) {
-		ERR("out of memory");
-		return NULL;
-	}
-
-	for (path_states = info->path_states; path_states != NULL;
-			path_states = path_states->next) {
-		path_state = (res_event_path_state_t *)path_states->data;
-		g_variant_builder_add(builder, "(si)",
-				path_state->path, path_state->state);
-	}
-
-	result = g_variant_new("(ia(si))", info->error_code, builder);
-	g_variant_builder_unref(builder);
-
-	if (result == NULL) {
-		ERR("Fail to create extra data");
-		return NULL;
-	}
-
-	return result;
-}
-
-API int pkgmgr_installer_send_res_signal(pkgmgr_installer *pi,
-		const char *pkgid, const char *status,
-		pkgmgr_res_event_info *event_info)
-{
-	char *sid;
-	const char *signal_name;
-	GError *err = NULL;
-	GVariant *extra_param;
-
-	if (!pi || !pkgid || !status) {
-		ERR("invalid argument");
-		return -1;
-	}
-
-	sid = pi->session_id;
-	if (!sid)
-		sid = "";
-
-	signal_name = __get_signal_name(pi, "", "");
-	if (!signal_name) {
-		ERR("unknown signal type");
-		return -1;
-	}
-
-	extra_param = __get_gvariant_from_event_info(event_info);
-	if (extra_param == NULL) {
-		ERR("Fail to get extra parameter");
-		return -1;
-	}
-
-	if (g_dbus_connection_emit_signal(pi->conn, NULL,
-				PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
-				PKGMGR_INSTALLER_DBUS_INTERFACE, signal_name,
-				g_variant_new("(usssv)", pi->target_uid, sid,
-						pkgid, status, extra_param),
-				&err) != TRUE) {
-		ERR("failed to send dbus signal");
-		if (err) {
-			ERR("err: %s", err->message);
-			g_error_free(err);
-		}
-		return -1;
-	}
-
-	return 0;
-}
-
-API int pkgmgr_installer_send_res_signal_for_uid(pkgmgr_installer *pi,
-		uid_t uid, const char *pkgid, const char *status,
-		pkgmgr_res_event_info *event_info)
-{
-	char *sid;
-	size_t data_len;
-	size_t name_size;
-	GVariant *gv;
-	gsize gv_len;
-	gpointer gv_data;
-	void *data;
-	void *ptr;
-	const char *signal_name;
-	GVariant *extra_param;
-
-	if (!pi || !pi->conn) {
-		ERR("connection is NULL");
-		return -1;
-	}
-
-	sid = pi->session_id;
-	if (!sid)
-		sid = "";
-
-	data_len = sizeof(size_t) + sizeof(gsize);
-
-	/* including null byte */
-	signal_name = __get_signal_name(pi, "", "");
-	if (!signal_name) {
-		ERR("unknown signal type");
-		return -1;
-	}
-	name_size = strlen(signal_name) + 1;
-	data_len += name_size;
-
-	extra_param = __get_gvariant_from_event_info(event_info);
-	if (extra_param == NULL) {
-		ERR("Fail to get extra parameter");
-		return -1;
-	}
-
-	gv = g_variant_new("(usssv)", pi->target_uid, sid,
-			pkgid, status, extra_param);
-	if (gv == NULL) {
-		ERR("failed to create GVariant instance");
-		return -1;
-	}
-
-	gv_len = g_variant_get_size(gv);
-	gv_data = g_malloc(gv_len);
-	g_variant_store(gv, gv_data);
-	g_variant_unref(gv);
-	data_len += gv_len;
-
-	data = malloc(data_len);
-	if (data == NULL) {
-		ERR("out of memory");
-		g_free(gv_data);
-		return -1;
-	}
-	ptr = data;
-	memcpy(ptr, &name_size, sizeof(size_t));
-	ptr += sizeof(size_t);
-	memcpy(ptr, &gv_len, sizeof(gsize));
-	ptr += sizeof(gsize);
-	memcpy(ptr, signal_name, name_size);
-	ptr += name_size;
-	memcpy(ptr, gv_data, gv_len);
-	g_free(gv_data);
-
-	if (__send_signal_to_agent(uid, data, data_len)) {
-		ERR("failed to send signal to agent");
-		free(data);
-		return -1;
-	}
-
-	free(data);
-
-	return 0;
-}
diff --git a/installer/pkgmgr_installer_config.h b/installer/pkgmgr_installer_config.h
deleted file mode 100644
index 320620b..0000000
--- a/installer/pkgmgr_installer_config.h
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * slp-pkgmgr
- *
- * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * Contact: Jayoun Lee <airjany@samsung.com>, Sewook Park <sewook7.park@samsung.com>,
- * Jaeho Lee <jaeho81.lee@samsung.com>, Shobhit Srivastava <shobhit.s@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 __PACKAGE_INSTALLER_CONFIG_H__
-#define __PACKAGE_INSTALLER_CONFIG_H__
-
-#define PKGMGR_DBUS_SERVICE "org.tizen.pkgmgr"
-#define PKGMGR_DBUS_INTERFACE "org.tizen.pkgmgr"
-#define PKGMGR_DBUS_OBJECT_PATH "/org/tizen/pkgmgr"
-
-#define PKGMGR_INSTALLER_DBUS_INTERFACE "org.tizen.pkgmgr.signal"
-#define PKGMGR_INSTALLER_DBUS_OBJECT_PATH "/org/tizen/pkgmgr/signal"
-
-#endif				/* __PACKAGE_INSTALLER_CONFIG_H__ */
diff --git a/installer/pkgmgr_installer_signal_agent.c b/installer/pkgmgr_installer_signal_agent.c
deleted file mode 100644
index 19c5b44..0000000
--- a/installer/pkgmgr_installer_signal_agent.c
+++ /dev/null
@@ -1,337 +0,0 @@
-/*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd. All rights reserved.
- *
- * 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.
- *
- */
-
-#define _GNU_SOURCE
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-#include <errno.h>
-#include <sys/stat.h>
-#include <sys/socket.h>
-#include <sys/types.h>
-#include <sys/un.h>
-#include <linux/limits.h>
-#include <pwd.h>
-
-#include <glib.h>
-#include <glib-unix.h>
-#include <gio/gio.h>
-#include <systemd/sd-daemon.h>
-
-#include <dlog.h>
-
-#include "pkgmgr_installer_config.h"
-#include "pkgmgr_installer_type.h"
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-#define LOG_TAG "PKGMGR_INSTALLER_SIGNAL_AGENT"
-
-#define BUFMAX 4096
-#define PWBUFSIZE sysconf(_SC_GETPW_R_SIZE_MAX)
-#define APPFW_USERNAME "app_fw"
-
-static int server_fd = -1;
-static GMainLoop *loop;
-static guint sid;
-static guint tid;
-static GDBusConnection *conn;
-
-static int __create_server_socket(const char *path)
-{
-	int r;
-	int fd;
-	struct sockaddr_un sa;
-
-	fd = socket(AF_UNIX, SOCK_STREAM, 0);
-	if (fd == -1) {
-		LOGE("socket create failed: %d", errno);
-		return -1;
-	}
-
-	memset(&sa, 0, sizeof(sa));
-	sa.sun_family = AF_UNIX;
-	snprintf(sa.sun_path, sizeof(sa.sun_path), "%s", path);
-
-	r = unlink(sa.sun_path);
-	if (r == -1 && errno != ENOENT) {
-		LOGE("unlink(%s) failed: %d", sa.sun_path, errno);
-		close(fd);
-		return -1;
-	}
-
-	r = bind(fd, (struct sockaddr *)&sa, sizeof(sa));
-	if (r == -1) {
-		LOGE("bind(%s) failed: %d", sa.sun_path, errno);
-		close(fd);
-		return -1;
-	}
-
-	r = chmod(sa.sun_path, 0660);
-	if (r == -1)
-		LOGW("chmod(%s) failed: %d", sa.sun_path, errno);
-
-	r = listen(fd, SOMAXCONN);
-	if (r == -1) {
-		LOGE("listen(%s) failed: %d", sa.sun_path, errno);
-		close(fd);
-		return -1;
-	}
-
-	return fd;
-}
-
-static int __get_server_socket(const char *path)
-{
-	int i;
-	int n;
-	int r;
-	int fd = -1;
-
-	n = sd_listen_fds(0);
-	if (n < 0) {
-		LOGE("sd_listen_fds: %d", n);
-		return -1;
-	} else if (n == 0) {
-		return __create_server_socket(path);
-	}
-
-	for (i = SD_LISTEN_FDS_START; i < SD_LISTEN_FDS_START + n; i++) {
-		r = sd_is_socket_unix(i, SOCK_STREAM, -1, path, 0);
-		if (r > 0) {
-			fd = i;
-			break;
-		}
-	}
-
-	if (fd == -1) {
-		LOGE("socket is not passed, create server socket");
-		return __create_server_socket(path);
-	}
-
-	return fd;
-}
-
-static void __emit_signal(const char *name, GVariant *gv)
-{
-	GError *err = NULL;
-
-	if (g_dbus_connection_emit_signal(conn, NULL,
-				PKGMGR_INSTALLER_DBUS_OBJECT_PATH,
-				PKGMGR_INSTALLER_DBUS_INTERFACE,
-				name, gv, &err) != TRUE) {
-		LOGE("g_dbus_connection_emit_signal failed: %s", err->message);
-		g_error_free(err);
-	}
-}
-
-static gboolean __quit(gpointer user_data)
-{
-	g_main_loop_quit(loop);
-	return FALSE;
-}
-
-static int __check_authority(int fd)
-{
-	int r;
-	struct ucred cr;
-	socklen_t len;
-	struct passwd pwd;
-	struct passwd *pwd_r;
-	char buf[PWBUFSIZE];
-
-	len = sizeof(struct ucred);
-	r = getsockopt(fd, SOL_SOCKET, SO_PEERCRED, &cr, &len);
-	if (r != 0) {
-		LOGE("getsockopt failed: %d", errno);
-		return -1;
-	}
-
-	/* allow root user */
-	if (cr.uid == 0)
-		return 0;
-
-	r = getpwuid_r(cr.uid, &pwd, buf, sizeof(buf), &pwd_r);
-	if (r != 0 || pwd_r == NULL) {
-		LOGE("getpwuid failed: %d", r);
-		return -1;
-	}
-
-	/* only app_fw user can send signal to agent */
-	if (strcmp(pwd_r->pw_name, APPFW_USERNAME) != 0) {
-		LOGE("unauthorized client");
-		return -1;
-	}
-
-	return 0;
-}
-
-/**
- * packet format:
- * +----------------+-------------+-----------+-------------------+
- * |signal name size|GVariant size|signal name|serialized GVariant|
- * +----------------+-------------+-----------+-------------------+
- */
-static gboolean __handle_signal(gint fd, GIOCondition cond, gpointer user_data)
-{
-	int r;
-	unsigned char buf[BUFMAX];
-	int clifd;
-	struct sockaddr_un sa;
-	socklen_t s = sizeof(sa);
-	size_t type_len;
-	char *type_name;
-	gsize data_len;
-	gpointer data;
-	GVariant *gv;
-
-	clifd = accept(fd, (struct sockaddr *)&sa, &s);
-	if (clifd == -1) {
-		LOGE("accept failed: %d", errno);
-		return FALSE;
-	}
-
-	if (__check_authority(clifd)) {
-		close(clifd);
-		return TRUE;
-	}
-
-	r = recv(clifd, buf, sizeof(size_t) + sizeof(gsize), 0);
-	if (r < 0) {
-		LOGE("recv failed: %d", errno);
-		close(clifd);
-		return FALSE;
-	} else if (r == 0) {
-		LOGE("client fd already closed");
-		close(clifd);
-		return FALSE;
-	}
-
-	memcpy(&type_len, buf, sizeof(size_t));
-	memcpy(&data_len, buf + sizeof(size_t), sizeof(gsize));
-
-	if (type_len > BUFMAX || data_len > BUFMAX ||
-			(type_len + data_len) > BUFMAX) {
-		LOGE("received size is too large: %zu %zu", type_len, data_len);
-		close(clifd);
-		return FALSE;
-	}
-
-	r = recv(clifd, buf, type_len + data_len, 0);
-	if (r < 0) {
-		LOGE("recv failed: %d", errno);
-		close(clifd);
-		return FALSE;
-	} else if (r == 0) {
-		LOGE("client fd already closed");
-		close(clifd);
-		return FALSE;
-	}
-
-	if (type_len == 0) {
-		LOGE("invalid type_len");
-		close(clifd);
-		return FALSE;
-	}
-
-	/* get signal name (including terminating null byte) */
-	type_name = malloc(type_len);
-	memcpy(type_name, buf, type_len);
-
-	/* get data */
-	data = malloc(data_len);
-	memcpy(data, buf + type_len, data_len);
-
-	/* floating type GVariant instance */
-	if (!strcmp(type_name, PKGMGR_INSTALLER_RES_COPY_EVENT_STR) ||
-		!strcmp(type_name, PKGMGR_INSTALLER_RES_CREATE_DIR_EVENT_STR) ||
-		!strcmp(type_name, PKGMGR_INSTALLER_RES_REMOVE_EVENT_STR) ||
-		!strcmp(type_name, PKGMGR_INSTALLER_RES_UNINSTALL_EVENT_STR)) {
-		gv = g_variant_new_from_data(G_VARIANT_TYPE("(usssv)"),
-				data, data_len, TRUE, NULL, NULL);
-	} else {
-		gv = g_variant_new_from_data(G_VARIANT_TYPE("(usa(sss)ss)"),
-				data, data_len, TRUE, NULL, NULL);
-	}
-	__emit_signal(type_name, gv);
-
-	free(data);
-	free(type_name);
-	close(clifd);
-
-	/* renew timeout */
-	g_source_remove(tid);
-	tid = g_timeout_add_seconds(10, __quit, NULL);
-
-	return TRUE;
-}
-
-static int __init(void)
-{
-	char path[PATH_MAX];
-	GError *err = NULL;
-
-	snprintf(path, sizeof(path), "/run/pkgmgr/agent/%d", getuid());
-	server_fd = __get_server_socket(path);
-	if (server_fd < 0) {
-		LOGE("server init failed");
-		return -1;
-	}
-
-	conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, &err);
-	if (conn == NULL) {
-		LOGE("g_bus_get_sync failed: %s", err->message);
-		g_error_free(err);
-		close(server_fd);
-		return -1;
-	}
-
-	loop = g_main_loop_new(NULL, FALSE);
-	sid = g_unix_fd_add(server_fd, G_IO_IN, __handle_signal, NULL);
-	tid = g_timeout_add_seconds(10, __quit, NULL);
-
-	return 0;
-}
-
-static void __fini(void)
-{
-	if (sid > 0)
-		g_source_remove(sid);
-	if (loop)
-		g_main_loop_unref(loop);
-	if (conn)
-		g_object_unref(conn);
-	if (server_fd > 0)
-		close(server_fd);
-}
-
-int main(int argc, char *argv[])
-{
-	int r;
-
-	r = __init();
-	if (r < 0)
-		return -1;
-
-	g_main_loop_run(loop);
-
-	__fini();
-
-	return 0;
-}
diff --git a/installer/src/api_stub.cc b/installer/src/api_stub.cc
new file mode 100644
index 0000000..d975965
--- /dev/null
+++ b/installer/src/api_stub.cc
@@ -0,0 +1,364 @@
+/*
+* Copyright (c) 2022 Samsung Electronics Co., Ltd.
+*
+* 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.
+*/
+
+
+#include "pkgmgr_installer.h"
+
+#include <unistd.h>
+
+#include "control.hh"
+
+#ifdef API
+#undef API
+#endif
+#define API __attribute__ ((visibility("default")))
+
+API pkgmgr_installer* pkgmgr_installer_new() {
+  return new pkgmgr::installer::Control();
+}
+
+API pkgmgr_installer* pkgmgr_installer_offline_new() {
+  return new pkgmgr::installer::Control(true);
+}
+
+API int pkgmgr_installer_free(pkgmgr_installer* pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  delete cls;
+  return 0;
+}
+
+API int pkgmgr_installer_receive_request(pkgmgr_installer *pi,
+    const int argc, char **argv) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  return cls->SetRequestFromArgv(argc, argv);
+}
+
+API int pkgmgr_installer_get_request_type(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->GetRequestType();
+}
+
+API uid_t pkgmgr_installer_get_uid(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->GetUid();
+}
+
+API const char* pkgmgr_installer_get_request_info(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return nullptr;
+  return cls->GetRequest()->GetRequestInfo().c_str();
+}
+
+API const char* pkgmgr_installer_get_request_info_at(pkgmgr_installer *pi,
+    int at) {
+  //TODO
+  return nullptr;
+}
+
+API int pkgmgr_installer_get_request_info_count(pkgmgr_installer *pi) {
+  //TODO
+  return 0;
+}
+
+API const char *pkgmgr_installer_get_tep_path(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return nullptr;
+  return cls->GetRequest()->GetTepPath().c_str();
+}
+
+API int pkgmgr_installer_get_tep_move_type(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsTepMove() ? 1 : 0;
+}
+
+API const char* pkgmgr_installer_get_session_id(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return nullptr;
+  return cls->GetRequest()->GetSessionId().c_str();
+}
+
+API const char* pkgmgr_installer_get_license_path(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return nullptr;
+  return cls->GetRequest()->GetLicensePath().c_str();
+}
+
+API const char* pkgmgr_installer_get_optional_data(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return nullptr;
+  return cls->GetRequest()->GetOptionalData().c_str();
+}
+
+API int pkgmgr_installer_is_quiet(pkgmgr_installer *pi) {
+  return 1;
+}
+
+API int pkgmgr_installer_get_move_type(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->GetMoveType();
+}
+
+API const char *pkgmgr_installer_get_caller_pkgid(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return nullptr;
+  return cls->GetRequest()->GetCallerPkgid().c_str();
+}
+
+API int pkgmgr_installer_get_is_preload(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsPreload() ? 1 : 0;
+}
+
+API int pkgmgr_installer_get_force_removal(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsForceRemoval() ? 1 : 0;
+}
+
+API int pkgmgr_installer_get_is_preload_rw(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsPreloadRw() ? 1 : 0;
+}
+
+API int pkgmgr_installer_get_no_removal(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsNoRemoval() ? 1 : 0;
+}
+
+API int pkgmgr_installer_get_keep_rwdata(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsKeepRwData() ? 1 : 0;
+}
+
+API int pkgmgr_installer_get_partial_rw(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsPartialRw() ? 1 : 0;
+}
+
+API int pkgmgr_installer_get_debug_mode(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsDebugMode() ? 1 : 0;
+}
+
+API int pkgmgr_installer_get_skip_check_reference(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsSkipCheckReference() ? 1 : 0;
+}
+
+API int pkgmgr_installer_get_skip_optimization(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsSkipOptimization() ? 1 : 0;
+}
+
+API int pkgmgr_installer_get_recovery_cleanup(pkgmgr_installer *pi) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return PKGMGR_REQ_INVALID;
+  return cls->GetRequest()->IsRecoveryCleanup() ? 1 : 0;
+}
+
+API int pkgmgr_installer_send_app_uninstall_signal(pkgmgr_installer *pi,
+    const char *pkg_type, const char *pkgid, const char *val) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_send_app_uninstall_signal_for_uid(
+    pkgmgr_installer *pi, uid_t uid, const char *pkg_type,
+    const char *pkgid, const char *val) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_set_uid(pkgmgr_installer *pi, uid_t uid) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return -1;
+  cls->GetRequest()->SetUid(uid);
+  return 0;
+}
+
+API int pkgmgr_installer_send_app_signal(pkgmgr_installer *pi,
+    const char *pkg_type, const char *pkgid, const char *appid,
+    const char *key, const char *val) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return -1;
+  return cls->SendSignal(pkg_type, pkgid, appid, key, val);
+}
+
+API int pkgmgr_installer_send_signal(pkgmgr_installer *pi,
+    const char *pkg_type, const char *pkgid, const char *key,
+    const char *val) {
+  auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+  if (!cls->GetRequest())
+    return -1;
+  return cls->SendSignal(pkg_type, pkgid, "", key, val);
+}
+
+API int pkgmgr_installer_send_app_signal_for_uid(pkgmgr_installer *pi,
+    uid_t uid, const char *pkg_type, const char *pkgid,
+    const char *appid, const char *key, const char *val) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_send_signal_for_uid(pkgmgr_installer *pi,
+    uid_t uid, const char *pkg_type, const char *pkgid,
+    const char *key, const char *val) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_set_request_type(pkgmgr_installer *pi,
+    int request_type) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_set_session_id(pkgmgr_installer *pi,
+    const char *session_id) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_create_certinfo_set_handle(
+    pkgmgr_instcertinfo_h *handle) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_set_cert_value(pkgmgr_instcertinfo_h handle,
+    pkgmgr_instcert_type cert_type, char *cert_value) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_save_certinfo(const char *pkgid,
+    pkgmgr_instcertinfo_h handle, uid_t uid) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_destroy_certinfo_set_handle(
+    pkgmgr_instcertinfo_h handle) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_delete_certinfo(const char *pkgid) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_info_get_target_uid(uid_t *uid) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_info_get_privilege_level(
+    pkgmgr_privilege_level *level) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_info_get_debug_mode(int *debug_mode) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_info_get_skip_optimization(int *skip_optimization) {
+  //TODO
+  return 0;
+}
+
+API const char* pkgmgr_installer_error_to_string(int error_code) {
+  //TODO
+  return nullptr;
+}
+
+API int pkgmgr_installer_add_pkg(pkgmgr_installer *pi,
+    const char *pkgid, const char *pkg_type) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_send_signals(pkgmgr_installer *pi,
+    const char *key, const char *val) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_send_signals_for_uid(pkgmgr_installer *pi, uid_t uid,
+    const char *key, const char *val) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_set_is_upgrade(pkgmgr_installer *pi, int is_upgrade) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_send_res_signal(pkgmgr_installer *pi,
+    const char *pkgid, const char *status,
+    pkgmgr_res_event_info *event_info) {
+  //TODO
+  return 0;
+}
+
+API int pkgmgr_installer_send_res_signal_for_uid(pkgmgr_installer *pi,
+    uid_t uid, const char *pkgid, const char *status,
+    pkgmgr_res_event_info *event_info) {
+  //TODO
+  return 0;
+}
diff --git a/installer/src/control.cc b/installer/src/control.cc
new file mode 100644
index 0000000..d094c6a
--- /dev/null
+++ b/installer/src/control.cc
@@ -0,0 +1,354 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+
+#include "control.hh"
+
+#include <getopt.h>
+
+#include "pkgmgr_installer.h"
+#include "pkgmgr_installer_debug.h"
+
+namespace {
+
+constexpr int OPTVAL_PRELOAD = 1000;
+constexpr int OPTVAL_FORCE_REMOVAL = 1001;
+constexpr int OPTVAL_PRELOAD_RW = 1002;
+constexpr int OPTVAL_NO_REMOVAL = 1003;
+constexpr int OPTVAL_KEEP_RWDATA = 1004;
+constexpr int OPTVAL_PARTIAL_RW = 1005;
+constexpr int OPTVAL_MIGRATE_EXTIMG = 1006;
+constexpr int OPTVAL_SKIP_CHECK_REFERENCE = 1007;
+constexpr int OPTVAL_RECOVER_DB = 1008;
+constexpr int OPTVAL_RECOVERY_CLEANUP = 1009;
+
+constexpr const char short_opts[] = "k:l:i:d:c:m:t:o:r:p:s:b:e:M:y:u:w:D:A:qGS";
+constexpr const struct option long_opts[] = {
+	{ "session-id", 1, nullptr, 'k' },
+	{ "license-path", 1, nullptr, 'l' },
+	{ "install", 1, nullptr, 'i' },
+	{ "uninstall", 1, nullptr, 'd' },
+	{ "clear", 1, nullptr, 'c' },
+	{ "move", 1, nullptr, 'm' },
+	{ "move-type", 1, nullptr, 't' },
+	{ "optional-data", 0, nullptr, 'o' },
+	{ "reinstall", 0, nullptr, 'r' },
+	{ "caller-pkgid", 1, nullptr, 'p' },
+	{ "tep-path", 1, nullptr, 'e' },
+	{ "tep-move", 1, nullptr, 'M' },
+	{ "smack", 1, nullptr, 's' },
+	{ "manifest-direct-install", 1, nullptr, 'y' },
+	{ "mount-install", 1, nullptr, 'w' },
+	{ "recovery", 1, nullptr, 'b' },
+	{ "debug-mode", 0, nullptr, 'G' },
+	{ "skip-optimization", 0, nullptr, 'S' },
+	{ "preload", 0, nullptr, OPTVAL_PRELOAD },
+	{ "force-remove", 0, nullptr, OPTVAL_FORCE_REMOVAL },
+	{ "preload-rw", 0, nullptr, OPTVAL_PRELOAD_RW },
+	{ "no-remove", 0, nullptr, OPTVAL_NO_REMOVAL },
+	{ "keep-rwdata", 0, nullptr, OPTVAL_KEEP_RWDATA },
+	{ "partial-rw", 0, nullptr, OPTVAL_PARTIAL_RW },
+	{ "migrate-extimg", 1, nullptr, OPTVAL_MIGRATE_EXTIMG },
+	{ "skip-check-reference", 0, nullptr, OPTVAL_SKIP_CHECK_REFERENCE },
+	{ "recover-db", 1, nullptr, OPTVAL_RECOVER_DB },
+	{ "recovery-cleanup", 0, nullptr, OPTVAL_RECOVERY_CLEANUP },
+	{ 0, 0, 0, 0 }
+};
+
+}
+
+namespace pkgmgr {
+namespace installer {
+
+Control::Control(bool offline) {
+  if (!offline) {
+    signal_.reset(new pkg_group::PkgSignal("", true));
+  }
+
+  option_map_[OPTVAL_PRELOAD] = [](const std::unique_ptr<Request>& req) {
+    req->is_preload_ = true;
+    _D("preload request [%d]", req->is_preload_);
+    return 0;
+  };
+
+  option_map_[OPTVAL_FORCE_REMOVAL] = [](const std::unique_ptr<Request>& req) {
+    req->force_removal_ = true;
+    _D("force-remove request [%d]", req->force_removal_);
+    return 0;
+  };
+
+  option_map_[OPTVAL_PRELOAD_RW] = [](const std::unique_ptr<Request>& req) {
+    req->is_preload_rw_ = true;
+    _D("preload-rw request [%d]", req->is_preload_rw_);
+    return 0;
+  };
+
+  option_map_[OPTVAL_NO_REMOVAL] = [](const std::unique_ptr<Request>& req) {
+    req->no_removal_ = true;
+    _D("no-remove request [%d]", req->no_removal_);
+    return 0;
+  };
+
+  option_map_[OPTVAL_KEEP_RWDATA] = [](const std::unique_ptr<Request>& req) {
+    req->keep_rwdata_ = true;
+    _D("keep-rwdata request [%d]", req->keep_rwdata_);
+    return 0;
+  };
+
+  option_map_[OPTVAL_PARTIAL_RW] = [](const std::unique_ptr<Request>& req) {
+    req->partial_rw_ = true;
+    _D("partial-rw request [%d]", req->partial_rw_);
+    return 0;
+  };
+
+  option_map_[OPTVAL_MIGRATE_EXTIMG] = [this](const std::unique_ptr<Request>& req) {
+    if (mode_)
+      return -EINVAL;
+    mode_ = OPTVAL_MIGRATE_EXTIMG;
+    req->request_type_ = PKGMGR_REQ_MIGRATE_EXTIMG;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    _D("legacy extimg migration requested");
+    return 0;
+  };
+
+  option_map_[OPTVAL_SKIP_CHECK_REFERENCE] = [](const std::unique_ptr<Request>& req) {
+    req->skip_check_reference_ = true;
+    return 0;
+  };
+
+  option_map_[OPTVAL_RECOVER_DB] = [this](const std::unique_ptr<Request>& req) {
+    req->request_type_ = PKGMGR_REQ_RECOVER_DB;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_[OPTVAL_RECOVERY_CLEANUP] = [](const std::unique_ptr<Request>& req) {
+    req->recovery_cleanup_ = true;
+    return 0;
+  };
+
+  option_map_['k'] = [](const std::unique_ptr<Request>& req) {
+    req->session_id_ = optarg;
+    return 0;
+  };
+
+  option_map_['l'] = [](const std::unique_ptr<Request>& req) {
+    req->license_path_ = optarg;
+    return 0;
+  };
+
+  option_map_['i'] = [this](const std::unique_ptr<Request>& req) {
+    if (mode_)
+      return -EINVAL;
+    mode_ = 'i';
+    req->request_type_ = PKGMGR_REQ_INSTALL;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    _D("option is [i] pkgid[%s]", req->pkgmgr_info_.c_str());
+    return 0;
+  };
+
+  option_map_['e'] = [](const std::unique_ptr<Request>& req) {
+    req->tep_path_ = optarg;
+    _D("option is [e] tep_path[%s]", req->tep_path_.c_str());
+    return 0;
+  };
+
+  option_map_['M'] = [](const std::unique_ptr<Request>& req) {
+    if (strcmp(optarg, "tep_move") == 0)
+      req->tep_move_ = true;
+    else
+      req->tep_move_ = false;
+    _D("option is [M] tep_move[%d]", req->tep_move_);
+    return 0;
+  };
+
+  option_map_['d'] = [this](const std::unique_ptr<Request>& req) {
+    if (mode_)
+      return -EINVAL;
+    mode_ = 'd';
+    req->request_type_ = PKGMGR_REQ_UNINSTALL;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['c'] = [this](const std::unique_ptr<Request>& req) {
+    if (mode_)
+      return -EINVAL;
+    mode_ = 'c';
+    req->request_type_ = PKGMGR_REQ_CLEAR;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['m'] = [this](const std::unique_ptr<Request>& req) {
+    if (mode_)
+      return -EINVAL;
+    mode_ = 'm';
+    req->request_type_ = PKGMGR_REQ_MOVE;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['r'] = [this](const std::unique_ptr<Request>& req) {
+    if (mode_)
+      return -EINVAL;
+    mode_ = 'r';
+    req->request_type_ = PKGMGR_REQ_REINSTALL;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['t'] = [](const std::unique_ptr<Request>& req) {
+    req->move_type_ = atoi(optarg);
+    return 0;
+  };
+
+  option_map_['p'] = [](const std::unique_ptr<Request>& req) {
+    req->caller_pkgid_ = optarg;
+    return 0;
+  };
+
+  option_map_['s'] = [this](const std::unique_ptr<Request>& req) {
+    if (mode_)
+      return -EINVAL;
+    mode_ = 's';
+    req->request_type_ = PKGMGR_REQ_SMACK;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['o'] = [](const std::unique_ptr<Request>& req) {
+    req->optional_data_ = optarg;
+    return 0;
+  };
+
+  option_map_['y'] = [this](const std::unique_ptr<Request>& req) {
+    req->request_type_ = PKGMGR_REQ_MANIFEST_DIRECT_INSTALL;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['w'] = [this](const std::unique_ptr<Request>& req) {
+    req->request_type_ = PKGMGR_REQ_MOUNT_INSTALL;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['b'] = [this](const std::unique_ptr<Request>& req) {
+    if (mode_)
+      return -EINVAL;
+    mode_ = 'b';
+    req->request_type_ = PKGMGR_REQ_RECOVER;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['D'] = [this](const std::unique_ptr<Request>& req) {
+    req->request_type_ = PKGMGR_REQ_DISABLE_PKG;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['A'] = [this](const std::unique_ptr<Request>& req) {
+    req->request_type_ = PKGMGR_REQ_ENABLE_PKG;
+    req->pkgmgr_info_ = optarg;
+    ParseMultiplePkgs(req);
+    return 0;
+  };
+
+  option_map_['u'] = [](const std::unique_ptr<Request>& req) {
+    req->target_uid_ = (uid_t)atoi(optarg);
+    return 0;
+  };
+
+  option_map_['G'] = [](const std::unique_ptr<Request>& req) {
+    req->debug_mode_ = true;
+    return 0;
+  };
+
+  option_map_['S'] = [](const std::unique_ptr<Request>& req) {
+    req->skip_optimization_ = true;
+    return 0;
+  };
+}
+
+Control::~Control() = default;
+
+void Control::ParseMultiplePkgs(const std::unique_ptr<Request>& req) {
+  while ((optind <= argc_) && (*argv_[optind - 1] != '-')) {
+    req->pkgs_.push_back(argv_[optind - 1]);
+    optind++;
+  }
+  optind--;
+}
+
+const std::unique_ptr<Request>& Control::GetRequest() const {
+  return request_;
+}
+
+int Control::SendSignal(std::string pkg_type, std::string pkgid,
+    std::string appid, std::string key, std::string val) {
+  if (!signal_) {
+    _E("offline mode");
+    return -1;
+  }
+  auto& req = GetRequest();
+  std::vector<rpc_port::PkgSignal::PkgInfo> pkgs;
+  pkgs.push_back(rpc_port::PkgSignal::PkgInfo(std::move(pkgid),
+      std::move(appid), std::move(pkg_type)));
+  signal_->AsyncResult(req->GetUid(), req->GetSessionId(), std::move(pkgs),
+      key, val);
+  return 0;
+}
+
+int Control::SetRequestFromArgv(const int argc, char** argv) {
+  auto req = std::make_unique<Request>();
+  int opt_idx = 0;
+  optind = 1;
+  argc_ = argc;
+  argv_ = argv;
+  mode_ = 0;
+
+  while (true) {
+    int c = getopt_long(argc, argv, short_opts, long_opts, &opt_idx);
+    if (c == -1)
+      break;
+
+    if (option_map_.find(c) != option_map_.end()) {
+      int ret = option_map_[c](req);
+      if (ret < 0)
+        return ret;
+    }
+  }
+
+  request_ = std::move(req);
+  return 0;
+}
+
+}  // namespace installer
+}  // namespace pkgmgr
diff --git a/installer/src/control.hh b/installer/src/control.hh
new file mode 100644
index 0000000..de80856
--- /dev/null
+++ b/installer/src/control.hh
@@ -0,0 +1,60 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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 INSTALLER_SRC_CONTROL_H_
+#define INSTALLER_SRC_CONTROL_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <list>
+#include <functional>
+
+#include "PkgSignal.h"
+#include "request.hh"
+
+namespace pkgmgr {
+namespace installer {
+
+namespace pkg_group = rpc_port::PkgSignal::group;
+
+class Control {
+ public:
+  Control(bool offline = false);
+  virtual ~Control();
+  int SetRequestFromArgv(const int argc, char** argv);
+  const std::unique_ptr<Request>& GetRequest() const;
+  int SendSignal(std::string pkg_type, std::string pkgid,
+      std::string appid, std::string key, std::string val);
+
+ private:
+  void ParseMultiplePkgs(const std::unique_ptr<Request>& req);
+
+ private:
+  std::unique_ptr<Request> request_;
+  std::unique_ptr<pkg_group::PkgSignal> signal_;
+  std::map<int, std::function<int(const std::unique_ptr<Request>&)>>
+      option_map_;
+  int argc_ = 0;
+  char** argv_ = nullptr;
+  int mode_ = 0;
+};
+
+}  // namespace installer
+}  // namespace pkgmgr
+
+#endif  // INSTALLER_SRC_CONTROL_H_
\ No newline at end of file
diff --git a/installer/pkgmgr_installer.h b/installer/src/pkgmgr_installer.h
index a6848f5..7ecbabe 100644
--- a/installer/pkgmgr_installer.h
+++ b/installer/src/pkgmgr_installer.h
@@ -43,7 +43,7 @@ extern "C" {
 /**
  * pkgmgr_installer is an opaque type for an object
  */
-typedef struct pkgmgr_installer pkgmgr_installer;
+typedef void pkgmgr_installer;
 typedef void *pkgmgr_instcertinfo_h;
 
 /**
diff --git a/installer/pkgmgr_installer_debug.h b/installer/src/pkgmgr_installer_debug.h
index 26df677..a92a883 100644
--- a/installer/pkgmgr_installer_debug.h
+++ b/installer/src/pkgmgr_installer_debug.h
@@ -25,16 +25,16 @@
 #endif /* LOG_TAG */
 #define LOG_TAG "PKGMGR_INSTALLER"
 
-#ifndef ERR
-#define ERR(fmt, args...) LOGE("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
+#ifndef _E
+#define _E LOGE
 #endif
 
-#ifndef DBG
-#define DBG(fmt, args...) LOGD("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
+#ifndef _D
+#define _D LOGD
 #endif
 
-#ifndef INFO
-#define INFO(fmt, args...) LOGI("[%s:%d] "fmt"\n", __func__, __LINE__, ##args)
+#ifndef _I
+#define _I LOGI
 #endif
 
 #endif  /* __PKGMGR_INSTALLER_DEBUG_H__ */
diff --git a/installer/pkgmgr_installer_error.h b/installer/src/pkgmgr_installer_error.h
index 7f60c03..7f60c03 100644
--- a/installer/pkgmgr_installer_error.h
+++ b/installer/src/pkgmgr_installer_error.h
diff --git a/installer/pkgmgr_installer_info.h b/installer/src/pkgmgr_installer_info.h
index 2d32446..2d32446 100644
--- a/installer/pkgmgr_installer_info.h
+++ b/installer/src/pkgmgr_installer_info.h
diff --git a/installer/pkgmgr_installer_type.h b/installer/src/pkgmgr_installer_type.h
index 9463fce..9463fce 100644
--- a/installer/pkgmgr_installer_type.h
+++ b/installer/src/pkgmgr_installer_type.h
diff --git a/installer/src/request.cc b/installer/src/request.cc
new file mode 100644
index 0000000..0593291
--- /dev/null
+++ b/installer/src/request.cc
@@ -0,0 +1,120 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+
+#include "request.hh"
+
+#include <unistd.h>
+
+namespace pkgmgr {
+namespace installer {
+
+Request::Request() {
+  target_uid_ = getuid();
+}
+
+Request::~Request() = default;
+
+int Request::GetRequestType() const {
+  return request_type_;
+}
+
+int Request::GetMoveType() const {
+  return move_type_;
+}
+
+void Request::SetUpgrade(bool is_upgrade) {
+  is_upgrade_ = is_upgrade;
+}
+
+const std::string& Request::GetRequestInfo() const {
+  return pkgmgr_info_;
+}
+
+const std::string& Request::GetSessionId() const {
+  return session_id_;
+}
+
+const std::string& Request::GetLicensePath() const {
+  return license_path_;
+}
+
+const std::string& Request::GetOptionalData() const {
+  return optional_data_;
+}
+
+const std::string& Request::GetCallerPkgid() const {
+  return caller_pkgid_;
+}
+
+void Request::SetUid(uid_t uid) {
+  target_uid_ = uid;
+}
+
+uid_t Request::GetUid() const {
+  return target_uid_;
+}
+
+const std::string& Request::GetTepPath() const {
+  return tep_path_;
+}
+
+bool Request::IsTepMove() const {
+  return tep_move_;
+}
+
+bool Request::IsPreload() const {
+  return is_preload_;
+}
+
+bool Request::IsForceRemoval() const {
+  return force_removal_;
+}
+
+bool Request::IsPreloadRw() const {
+  return is_preload_rw_;
+}
+
+bool Request::IsNoRemoval() const {
+  return no_removal_;
+}
+
+bool Request::IsKeepRwData() const {
+  return keep_rwdata_;
+}
+
+bool Request::IsPartialRw() const {
+  return partial_rw_;
+}
+
+bool Request::IsDebugMode() const {
+  return debug_mode_;
+}
+
+bool Request::IsSkipCheckReference() const {
+  return skip_check_reference_;
+}
+
+bool Request::IsSkipOptimization() const {
+  return skip_optimization_;
+}
+
+bool Request::IsRecoveryCleanup() const {
+  return recovery_cleanup_;
+}
+
+}  // namespace installer
+}  // namespace pkgmgr
diff --git a/installer/src/request.hh b/installer/src/request.hh
new file mode 100644
index 0000000..217f561
--- /dev/null
+++ b/installer/src/request.hh
@@ -0,0 +1,90 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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 INSTALLER_SRC_REQUEST_H_
+#define INSTALLER_SRC_REQUEST_H_
+
+#include <map>
+#include <memory>
+#include <string>
+#include <list>
+#include <vector>
+
+#include "PkgSignal.h"
+
+namespace pkgmgr {
+namespace installer {
+
+class Control;
+class Request {
+ public:
+  Request();
+  virtual ~Request();
+
+  int GetRequestType() const;
+  int GetMoveType() const;
+  void SetUpgrade(bool is_upgrade);
+  const std::string& GetRequestInfo() const;
+  const std::string& GetSessionId() const;
+  const std::string& GetLicensePath() const;
+  const std::string& GetOptionalData() const;
+  const std::string& GetCallerPkgid() const;
+  void SetUid(uid_t uid);
+  uid_t GetUid() const;
+  const std::string& GetTepPath() const;
+  bool IsTepMove() const;
+  bool IsPreload() const;
+  bool IsForceRemoval() const;
+  bool IsPreloadRw() const;
+  bool IsNoRemoval() const;
+  bool IsKeepRwData() const;
+  bool IsPartialRw() const;
+  bool IsDebugMode() const;
+  bool IsSkipCheckReference() const;
+  bool IsSkipOptimization() const;
+  bool IsRecoveryCleanup() const;
+
+ private:
+  friend class Control;
+  int request_type_ = 0;
+  int move_type_ = 0;
+  bool is_upgrade_ = false;
+  std::string pkgmgr_info_;
+  std::string session_id_;
+  std::string license_path_;
+  std::string optional_data_;
+  std::string caller_pkgid_;
+  uid_t target_uid_ = 0;
+  std::string tep_path_;
+  bool tep_move_ = false;
+  bool is_preload_ = false;
+  bool force_removal_ = false;
+  bool is_preload_rw_ = false;
+  bool no_removal_ = false;
+  bool keep_rwdata_ = false;
+  bool partial_rw_ = false;
+  bool debug_mode_ = false;
+  bool skip_check_reference_ = false;
+  bool skip_optimization_ = false;
+  bool recovery_cleanup_ = false;
+  std::vector<std::string> pkgs_;
+};
+
+}  // namespace installer
+}  // namespace pkgmgr
+
+#endif  // INSTALLER_SRC_REQUEST_H_
\ No newline at end of file
diff --git a/packaging/pkgmgr-installer-signal-agent.service b/packaging/pkgmgr-installer-signal-agent.service
deleted file mode 100644
index 545ff4a..0000000
--- a/packaging/pkgmgr-installer-signal-agent.service
+++ /dev/null
@@ -1,6 +0,0 @@
-[Unit]
-Description=Package Manager Installer Signal Agent on User Session
-
-[Service]
-Type=oneshot
-ExecStart=/usr/bin/pkgmgr-installer-signal-agent
diff --git a/packaging/pkgmgr-installer-signal-agent.socket b/packaging/pkgmgr-installer-signal-agent.socket
deleted file mode 100644
index 2e767cd..0000000
--- a/packaging/pkgmgr-installer-signal-agent.socket
+++ /dev/null
@@ -1,7 +0,0 @@
-[Socket]
-ListenStream=/run/pkgmgr/agent/%U
-SocketMode=0777
-DirectoryMode=0777
-
-[Install]
-WantedBy=sockets.target
diff --git a/packaging/pkgmgr.changes b/packaging/pkgmgr.changes
deleted file mode 100644
index 101d179..0000000
--- a/packaging/pkgmgr.changes
+++ /dev/null
@@ -1,18 +0,0 @@
-* Tue Jul 02 2013 Junfeng Dong <junfeng.dong@intel.com> accepted/tizen/20130603.181624@c6b4eaa
-- Link pkgmgr-info after pkgmgr-parse to fix the build error in mobile.
-
-* Thu Jun 27 2013 Anas Nashif <anas.nashif@intel.com> accepted/tizen/20130603.181624@3e413f3
-- Spec file clean up, install configs in /etc
-
-* Mon Jun 03 2013 Anas Nashif <anas.nashif@intel.com> submit/tizen/20130601.183631@fff80e8
-- Fixed build on 64 bit systems
-
-* Sat Jun 01 2013 Anas Nashif <anas.nashif@intel.com> submit/tizen/20130517.185027@a8c5788
-- Remove license/group placeholders
-
-* Mon May 20 2013 Rusty Lynch <rusty.lynch@intel.com> accepted/tizen/20130520.103548@a8c5788
-- Fix install of package in a buildroot environment
-
-* Fri May 17 2013 Anas Nashif <anas.nashif@intel.com> submit/tizen/20130517.044823@933748f
-- do not exclude binaries, just delete them
-
diff --git a/packaging/pkgmgr.conf b/packaging/pkgmgr.conf
index c92c823..642a6f1 100644
--- a/packaging/pkgmgr.conf
+++ b/packaging/pkgmgr.conf
@@ -1,4 +1,4 @@
 d	/tmp/pkgmgr	1777	root	users
 t	/tmp/pkgmgr	-	-	-	-	security.SMACK64="User::App::Shared"
 t	/tmp/pkgmgr	-	-	-	-	security.SMACK64TRANSMUTE="TRUE"
-d	/run/pkgmgr/agent	0777	root	users	-
+
diff --git a/packaging/pkgmgr.spec b/packaging/pkgmgr.spec
index 8a55db3..847c11f 100644
--- a/packaging/pkgmgr.spec
+++ b/packaging/pkgmgr.spec
@@ -12,8 +12,6 @@ Source1004: %{name}-installer.manifest
 Source1005: %{name}-installer-devel.manifest
 Source1006: %{name}-types-devel.manifest
 Source1007: %{name}.conf
-Source1008: %{name}-installer-signal-agent.service
-Source1009: %{name}-installer-signal-agent.socket
 Requires(post): /usr/sbin/useradd
 Requires(post): capi-system-info
 
@@ -32,13 +30,29 @@ BuildRequires:  pkgconfig(db-util)
 BuildRequires:  pkgconfig(libsmack)
 BuildRequires:  pkgconfig(libsystemd)
 BuildRequires:  pkgconfig(minizip)
+BuildRequires:  pkgconfig(rpc-port)
+BuildRequires:  pkgconfig(capi-appfw-event)
+BuildRequires:  pkgconfig(gmock)
 BuildRequires:  pkgmgr-info-parser-devel
 BuildRequires:  pkgmgr-info-parser
 BuildRequires:  fdupes
+BuildRequires:  tidl
+
+%if 0%{?gcov:1}
+BuildRequires:  lcov
+%endif
 
 %description
 Packager Manager client library package for packaging
 
+%if 0%{?gcov:1}
+%package gcov
+Summary:    Packager Manager library (gcov)
+Group:      Application Framework/Testing
+
+%description gcov
+Packager Manager library gcov objects
+%endif
 
 %package client
 Summary:    Package Manager client library develpoment package
@@ -86,15 +100,37 @@ Package Manager client types develpoment package for packaging
 %prep
 %setup -q
 cp %{SOURCE1001} %{SOURCE1002} %{SOURCE1003} %{SOURCE1004} %{SOURCE1005} %{SOURCE1006} .
+tidlc -p -l C++ -i ./tidl/PkgMgr.tidl -o PkgMgrProxy
+mv PkgMgrProxy.* ./client/src/
+tidlc -g -l C++ -i ./tidl/PkgSignal.tidl -o PkgSignal
+cp PkgSignal.* ./client/src/
+mv PkgSignal.* ./installer/src/
 
 %build
+%if 0%{?gcov:1}
+export CFLAGS+=" -fprofile-arcs -ftest-coverage"
+export CXXFLAGS+=" -fprofile-arcs -ftest-coverage"
+export FFLAGS+=" -fprofile-arcs -ftest-coverage"
+export LDFLAGS+=" -lgcov"
+%endif
 MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`
 %cmake . -DFULLVER=%{version} -DMAJORVER=${MAJORVER}
 
 %__make %{?_smp_mflags}
 
+%if 0%{?gcov:1}
+mkdir -p gcov-obj
+find . -name '*.gcno' -exec cp '{}' gcov-obj ';'
+%endif
+
 %install
 %make_install
+
+%if 0%{?gcov:1}
+mkdir -p %{buildroot}%{_datadir}/gcov/obj/%{name}
+install -m 0644 gcov-obj/* %{buildroot}%{_datadir}/gcov/obj/%{name}
+%endif
+
 rm -f  %{buildroot}%{_bindir}/pkgmgr_backend_sample
 rm -f %{buildroot}%{_libdir}/libpkgmgr_backend_lib_sample.so
 rm -f %{buildroot}%{_libdir}/libpkgmgr_parser_lib_sample.so
@@ -102,11 +138,6 @@ rm -f %{buildroot}%{_libdir}/libpkgmgr_parser_lib_sample.so
 mkdir -p %{buildroot}%{_tmpfilesdir}/
 install -m 0644 %{SOURCE1007} %{buildroot}%{_tmpfilesdir}/pkgmgr.conf
 
-mkdir -p %{buildroot}%{_unitdir_user}/sockets.target.wants
-install -m 0644 %{SOURCE1008} %{buildroot}%{_unitdir_user}/pkgmgr-installer-signal-agent.service
-install -m 0644 %{SOURCE1009} %{buildroot}%{_unitdir_user}/pkgmgr-installer-signal-agent.socket
-ln -sf ../pkgmgr-installer-signal-agent.socket %{buildroot}%{_unitdir_user}/sockets.target.wants/pkgmgr-installer-signal-agent.socket
-
 mkdir -p %{buildroot}%{_sysconfdir}/package-manager/backend
 mkdir -p %{buildroot}%{_sysconfdir}/package-manager/backendlib
 mkdir -p %{buildroot}%{_sysconfdir}/opt/upgrade
@@ -118,6 +149,14 @@ chmod 755 %{buildroot}%{_sysconfdir}/package-manager/backend/pkgmgr
 touch  %{buildroot}%{_sysconfdir}/package-manager/backend/pkgtool
 chmod 755 %{buildroot}%{_sysconfdir}/package-manager/backend/pkgtool
 
+%check
+export LD_LIBRARY_PATH=../../client
+ctest -V
+
+%if 0%{?gcov:1}
+lcov -c --ignore-errors graph --no-external -b . -d . -o %{name}.info
+genhtml %{name}.info -o out --legend --show-details
+%endif
 
 %fdupes %{buildroot}
 
@@ -196,10 +235,6 @@ rm -rf %{_sysconfdir}/package-manager/pkgmgr-label-initial-image.sh
 %license LICENSE
 %defattr(-,root,root,-)
 %{_libdir}/libpkgmgr_installer.so.*
-%{_bindir}/pkgmgr-installer-signal-agent
-%{_unitdir_user}/pkgmgr-installer-signal-agent.service
-%{_unitdir_user}/pkgmgr-installer-signal-agent.socket
-%{_unitdir_user}/sockets.target.wants/pkgmgr-installer-signal-agent.socket
 
 %files installer-devel
 %manifest %{name}-installer-devel.manifest
@@ -215,3 +250,8 @@ rm -rf %{_sysconfdir}/package-manager/pkgmgr-label-initial-image.sh
 %defattr(-,root,root,-)
 %{_includedir}/package-manager-*.h
 %{_libdir}/pkgconfig/pkgmgr-types.pc
+
+%if 0%{?gcov:1}
+%files gcov
+%{_datadir}/gcov/*
+%endif
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
new file mode 100644
index 0000000..c90fac8
--- /dev/null
+++ b/test/CMakeLists.txt
@@ -0,0 +1 @@
+ADD_SUBDIRECTORY(unit_tests)
diff --git a/test/unit_tests/CMakeLists.txt b/test/unit_tests/CMakeLists.txt
new file mode 100644
index 0000000..d328392
--- /dev/null
+++ b/test/unit_tests/CMakeLists.txt
@@ -0,0 +1,33 @@
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/ UNIT_TESTS_SRCS)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/mock UNIT_TESTS_MOCK_SRCS)
+AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR}/../../client/src CLIENT_SRCS)
+ADD_EXECUTABLE(${TARGET_PKGMGR_UNIT_TEST}
+  ${UNIT_TESTS_SRCS}
+  ${UNIT_TESTS_MOCK_SRCS}
+  ${CLIENT_SRCS}
+)
+
+TARGET_INCLUDE_DIRECTORIES(${TARGET_PKGMGR_UNIT_TEST} PUBLIC
+  "${CMAKE_CURRENT_SOURCE_DIR}/../../client/src/"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../../clinet/include/"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../../"
+)
+
+APPLY_PKG_CONFIG(${TARGET_PKGMGR_UNIT_TEST} PUBLIC
+  GMOCK_DEPS
+  GLIB_DEPS
+  RPC_PORT_DEPS
+  CAPI_APPFW_EVENT_DEPS
+  DLOG_DEPS
+  BUNDLE_DEPS
+)
+
+TARGET_LINK_LIBRARIES(${TARGET_PKGMGR_UNIT_TEST} PUBLIC ${PKGMGR_CLIENT})
+SET_TARGET_PROPERTIES(${TARGET_PKGMGR_UNIT_TEST} PROPERTIES COMPILE_FLAGS "-fPIE")
+SET_TARGET_PROPERTIES(${TARGET_PKGMGR_UNIT_TEST} PROPERTIES LINK_FLAGS "-pie")
+
+ADD_TEST(
+  NAME ${TARGET_PKGMGR_UNIT_TEST}
+  COMMAND ${TARGET_PKGMGR_UNIT_TEST}
+)
diff --git a/test/unit_tests/main.cc b/test/unit_tests/main.cc
new file mode 100644
index 0000000..5f340cd
--- /dev/null
+++ b/test/unit_tests/main.cc
@@ -0,0 +1,25 @@
+// Copyright (c) 2020 Samsung Electronics Co., Ltd All Rights Reserved
+// Use of this source code is governed by a apache 2.0 license that can be
+// found in the LICENSE file.
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+int main(int argc, char** argv) {
+  int ret = -1;
+  try {
+    testing::InitGoogleTest(&argc, argv);
+  } catch(...) {
+    std::cout << "Exception occurred" << std::endl;
+  }
+
+  try {
+    ret = RUN_ALL_TESTS();
+  } catch (const ::testing::internal::GoogleTestFailureException& e) {
+    ret = -1;
+    std::cout << "GoogleTestFailureException was thrown:" << e.what()
+              << std::endl;
+  }
+
+  return ret;
+}
diff --git a/test/unit_tests/mock/app_event_mock.cc b/test/unit_tests/mock/app_event_mock.cc
new file mode 100644
index 0000000..165caa3
--- /dev/null
+++ b/test/unit_tests/mock/app_event_mock.cc
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+
+#include "mock/app_event_mock.hh"
+#include "mock/mock_hook.hh"
+#include "mock/test_fixture.hh"
+
+extern "C" int event_add_event_handler(const char *event_name,
+    event_cb callback, void *user_data, event_handler_h *event_handler) {
+  return MOCK_HOOK_P4(AppEventMock, event_add_event_handler,
+      event_name, callback, user_data, event_handler);
+}
+
+extern "C" int event_remove_event_handler(event_handler_h event_handler) {
+  return MOCK_HOOK_P1(AppEventMock, event_remove_event_handler,
+      event_handler);
+}
+
+extern "C" int event_publish_app_event(const char *event_name,
+    bundle *event_data) {
+  return MOCK_HOOK_P2(AppEventMock, event_publish_app_event,
+      event_name, event_data);
+}
diff --git a/test/unit_tests/mock/app_event_mock.hh b/test/unit_tests/mock/app_event_mock.hh
new file mode 100644
index 0000000..fe6af4b
--- /dev/null
+++ b/test/unit_tests/mock/app_event_mock.hh
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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 UNIT_TESTS_MOCK_APP_EVENT_MOCK_HH_
+#define UNIT_TESTS_MOCK_APP_EVENT_MOCK_HH_
+
+#include <app_event.h>
+#include <gmock/gmock.h>
+
+#include "mock/module_mock.hh"
+
+class AppEventMock : public virtual ModuleMock {
+ public:
+  AppEventMock() {}
+  virtual ~AppEventMock() {}
+
+  MOCK_METHOD(int, event_add_event_handler, (const char*,
+      event_cb, void*, event_handler_h*));
+  MOCK_METHOD(int, event_remove_event_handler, (event_handler_h));
+  MOCK_METHOD(int, event_publish_app_event, (const char*, bundle*));
+};
+
+#endif  // UNIT_TESTS_MOCK_APP_EVENT_MOCK_HH_
diff --git a/test/unit_tests/mock/mock_hook.hh b/test/unit_tests/mock/mock_hook.hh
new file mode 100644
index 0000000..2980460
--- /dev/null
+++ b/test/unit_tests/mock/mock_hook.hh
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * 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 UNIT_TESTS_MOCK_MOCK_HOOK_HH_
+#define UNIT_TESTS_MOCK_MOCK_HOOK_HH_
+
+#define MOCK_HOOK_P0(MOCK_CLASS, f)                                            \
+    TestFixture::GetMock<MOCK_CLASS>().f()
+#define MOCK_HOOK_P1(MOCK_CLASS, f, p1)                                        \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1)
+#define MOCK_HOOK_P2(MOCK_CLASS, f, p1, p2)                                    \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2)
+#define MOCK_HOOK_P3(MOCK_CLASS, f, p1, p2, p3)                                \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3)
+#define MOCK_HOOK_P4(MOCK_CLASS, f, p1, p2, p3, p4)                            \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3, p4)
+#define MOCK_HOOK_P5(MOCK_CLASS, f, p1, p2, p3, p4, p5)                        \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3, p4, p5)
+#define MOCK_HOOK_P6(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6)                    \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3, p4, p5, p6)
+#define MOCK_HOOK_P7(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7)                \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3, p4, p5, p6, p7)
+#define MOCK_HOOK_P8(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7, p8)            \
+    TestFixture::GetMock<MOCK_CLASS>().f(p1, p2, p3, p4, p5, p6, p7, p8)
+#define MOCK_HOOK_P10(MOCK_CLASS, f, p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)  \
+    TestFixture::GetMock<MOCK_CLASS>().f(                                      \
+        p1, p2, p3, p4, p5, p6, p7, p8, p9, p10)
+
+#endif  // UNIT_TESTS_MOCK_MOCK_HOOK_HH_
diff --git a/test/unit_tests/mock/module_mock.hh b/test/unit_tests/mock/module_mock.hh
new file mode 100644
index 0000000..a79584e
--- /dev/null
+++ b/test/unit_tests/mock/module_mock.hh
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * 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 UNIT_TESTS_MOCK_MODULE_MOCK_HH_
+#define UNIT_TESTS_MOCK_MODULE_MOCK_HH_
+
+class ModuleMock {
+ public:
+  virtual ~ModuleMock() {}
+};
+
+#endif  // UNIT_TESTS_MOCK_MODULE_MOCK_HH_
diff --git a/test/unit_tests/mock/rpc_port_mock.cc b/test/unit_tests/mock/rpc_port_mock.cc
new file mode 100644
index 0000000..5295674
--- /dev/null
+++ b/test/unit_tests/mock/rpc_port_mock.cc
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+#include "mock/rpc_port_mock.hh"
+#include "mock/mock_hook.hh"
+#include "mock/test_fixture.hh"
+
+RpcPortMock::~RpcPortMock() = default;
+
+extern "C" int rpc_port_proxy_connect_sync(rpc_port_proxy_h h,
+    const char *appid, const char *port_name) {
+  return MOCK_HOOK_P3(RpcPortMock, rpc_port_proxy_connect_sync,
+      h, appid, port_name);
+}
+
+extern "C" int rpc_port_read(rpc_port_h h, void *buf, unsigned int size) {
+  return MOCK_HOOK_P3(RpcPortMock, rpc_port_read,
+      h, buf, size);
+}
+
+extern "C" int rpc_port_write(rpc_port_h h, const void *buf, unsigned int size) {
+  return MOCK_HOOK_P3(RpcPortMock, rpc_port_write,
+      h, buf, size);
+}
+
+extern "C" int rpc_port_proxy_add_connected_event_cb(rpc_port_proxy_h h,
+    rpc_port_proxy_connected_event_cb cb, void *user_data) {
+  return MOCK_HOOK_P3(RpcPortMock, rpc_port_proxy_add_connected_event_cb,
+      h, cb, user_data);
+}
+
+extern "C" int rpc_port_parcel_create_from_port(rpc_port_parcel_h* h,
+    rpc_port_h port) {
+  return MOCK_HOOK_P2(RpcPortMock, rpc_port_parcel_create_from_port,
+      h, port);
+}
+
+extern "C" int rpc_port_parcel_send(rpc_port_parcel_h h, rpc_port_h port) {
+  return MOCK_HOOK_P2(RpcPortMock, rpc_port_parcel_send,
+      h, port);
+}
diff --git a/test/unit_tests/mock/rpc_port_mock.hh b/test/unit_tests/mock/rpc_port_mock.hh
new file mode 100644
index 0000000..2536d5a
--- /dev/null
+++ b/test/unit_tests/mock/rpc_port_mock.hh
@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) 2022 Samsung Electronics Co., Ltd.
+ *
+ * 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 UNIT_TESTS_MOCK_RPC_PORT_MOCK_HH_
+#define UNIT_TESTS_MOCK_RPC_PORT_MOCK_HH_
+
+#include <rpc-port.h>
+#include <rpc-port-parcel.h>
+#include <gmock/gmock.h>
+
+#include "mock/module_mock.hh"
+
+class RpcPortMock : public virtual ModuleMock {
+ public:
+  RpcPortMock() {
+    using ::testing::_;
+    using ::testing::Invoke;
+
+    ON_CALL(*this, rpc_port_proxy_add_connected_event_cb(_, _, _))
+        .WillByDefault(Invoke([&](rpc_port_proxy_h h,
+            rpc_port_proxy_connected_event_cb cb, void* data) {
+          connected_event_cb_ = cb;
+          connected_event_data_ = data;
+          return 0;
+        }));
+    ON_CALL(*this, rpc_port_proxy_connect_sync(_, _, _))
+        .WillByDefault(Invoke([&](rpc_port_proxy_h, const char*, const char*) {
+          if (connected_event_cb_) {
+            static int dummy;
+            rpc_port_h port = (rpc_port_h)&dummy;
+            connected_event_cb_("pkgmgr-server", "mockport", port,
+                connected_event_data_);
+          }
+          return 0;
+        }));
+  }
+
+  virtual ~RpcPortMock();
+
+  MOCK_METHOD(int, rpc_port_proxy_connect_sync, (rpc_port_proxy_h,
+      const char*, const char*));
+  MOCK_METHOD(int, rpc_port_read, (rpc_port_h, void*, unsigned int));
+  MOCK_METHOD(int, rpc_port_write, (rpc_port_h, const void*, unsigned int));
+  MOCK_METHOD(int, rpc_port_proxy_add_connected_event_cb,
+      (rpc_port_proxy_h, rpc_port_proxy_connected_event_cb, void*));
+  MOCK_METHOD(int, rpc_port_parcel_create_from_port,
+      (rpc_port_parcel_h*, rpc_port_h));
+  MOCK_METHOD(int, rpc_port_parcel_send, (rpc_port_parcel_h, rpc_port_h));
+
+ private:
+  rpc_port_proxy_connected_event_cb connected_event_cb_ = nullptr;
+  void* connected_event_data_ = nullptr;
+};
+
+#endif  // UNIT_TESTS_MOCK_RPC_PORT_MOCK_HH_
diff --git a/test/unit_tests/mock/test_fixture.cc b/test/unit_tests/mock/test_fixture.cc
new file mode 100644
index 0000000..23f907d
--- /dev/null
+++ b/test/unit_tests/mock/test_fixture.cc
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * 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.
+ */
+
+#include <memory>
+
+#include "unit_tests/mock/test_fixture.hh"
+
+std::unique_ptr<ModuleMock> TestFixture::mock_;
diff --git a/test/unit_tests/mock/test_fixture.hh b/test/unit_tests/mock/test_fixture.hh
new file mode 100644
index 0000000..8351374
--- /dev/null
+++ b/test/unit_tests/mock/test_fixture.hh
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2021 Samsung Electronics Co., Ltd.
+ *
+ * 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 UNIT_TESTS_MOCK_TEST_FIXTURE_HH_
+#define UNIT_TESTS_MOCK_TEST_FIXTURE_HH_
+
+#include <gtest/gtest.h>
+
+#include <memory>
+#include <stdexcept>
+#include <string>
+#include <utility>
+
+#include "unit_tests/mock/module_mock.hh"
+
+class TestFixture : public ::testing::Test {
+ public:
+  explicit TestFixture(std::unique_ptr<ModuleMock> mock) {
+    mock_ = std::move(mock);
+  }
+
+  virtual ~TestFixture() {}
+
+  virtual void SetUp() {}
+  virtual void TearDown() {}
+
+  template <typename T>
+  static T& GetMock() {
+    auto ptr = dynamic_cast<T*>(mock_.get());
+    if (ptr == nullptr) {
+      throw std::invalid_argument("The test does not provide mock of \"" +
+          std::string(typeid(T).name()) + "\"");
+    }
+
+    return *ptr;
+  }
+
+  static std::unique_ptr<ModuleMock> mock_;
+};
+
+#endif  // UNIT_TESTS_MOCK_TEST_FIXTURE_HH_
diff --git a/test/unit_tests/test_client.cc b/test/unit_tests/test_client.cc
new file mode 100644
index 0000000..36a0edb
--- /dev/null
+++ b/test/unit_tests/test_client.cc
@@ -0,0 +1,975 @@
+#include "package-manager.h"
+
+#include <gtest/gtest.h>
+#include <gmock/gmock.h>
+
+#include "unit_tests/mock/rpc_port_mock.hh"
+#include "unit_tests/mock/app_event_mock.hh"
+#include "unit_tests/mock/test_fixture.hh"
+
+using ::testing::_;
+using ::testing::Invoke;
+
+namespace {
+class Mocks : public ::testing::NiceMock<RpcPortMock>,
+    virtual public ::testing::NiceMock<AppEventMock> {};
+
+}  // namespace
+
+class ClientTest : public TestFixture {
+ public:
+  ClientTest() : TestFixture(std::make_unique<::Mocks>()) {}
+
+  virtual void SetUp() {
+    handle_ = pkgmgr_client_new(PC_REQUEST);
+    handler_ = [](uid_t target_uid, int req_id,
+          const char* pkg_type, const char* pkgid, const char* key,
+          const char* val, const void* pmsg, void* data) {
+            return 0;
+        };
+    app_handler_ = [](uid_t target_uid, int req_id, const char *pkg_type,
+          const char *pkgid, const char *appid, const char *key,
+          const char *val, const void *pmsg, void *data) {
+            return 0;
+        };
+    pkg_size_handler_ = [](pkgmgr_client *pc, const char *pkgid,
+		      const pkg_size_info_t *size_info, void *user_data) {
+    };
+
+    ON_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .WillByDefault(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_string(parcel, "req_key");
+        rpc_port_parcel_write_int32(parcel, 0);
+        *h = parcel;
+        return 0;
+      }));
+  }
+
+  virtual void TearDown() {
+    if (handle_)
+      pkgmgr_client_free(handle_);
+  }
+
+  pkgmgr_client* GetHandle() {
+    return handle_;
+  }
+
+  pkgmgr_handler GetDefaultHandler() {
+    return handler_;
+  }
+
+  pkgmgr_app_handler GetDefaultAppHandler() {
+    return app_handler_;
+  }
+
+  pkgmgr_pkg_size_info_receive_cb GetDefaultPkgSizeHandler() {
+    return pkg_size_handler_;
+  }
+
+ private:
+  pkgmgr_client* handle_ = nullptr;
+  pkgmgr_handler handler_ = nullptr;
+  pkgmgr_app_handler app_handler_ = nullptr;
+  pkgmgr_pkg_size_info_receive_cb pkg_size_handler_ = nullptr;
+};
+
+TEST_F(ClientTest, pkgmgr_client_set_tep_path) {
+  int ret = pkgmgr_client_set_tep_path(GetHandle(), "/tmp/test.tep", true);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_set_tep_path_n) {
+  int ret = pkgmgr_client_set_tep_path(GetHandle(), nullptr, true);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_install_packages) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  const char* paths[3] = { "/tmp/a.tpk", "/tmp/b.tpk", "/tmp/c.tpk" };
+  int ret = pkgmgr_client_install_packages(GetHandle(), paths, 3,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_install_packages_n) {
+  int ret = pkgmgr_client_install_packages(GetHandle(), nullptr, 0,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_install) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_install(GetHandle(), "tpk", "/tmp/desc"
+      , "/tmp/test.tpk", "", PM_DEFAULT, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_install_n) {
+  int ret = pkgmgr_client_install(GetHandle(), "tpk", "/tmp/desc"
+      , nullptr, "", PM_DEFAULT, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_reinstall) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_reinstall(GetHandle(), "tpk", "org.tizen.test"
+      ,"", PM_DEFAULT, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+
+TEST_F(ClientTest, pkgmgr_client_reinstall_n) {
+  int ret = pkgmgr_client_reinstall(GetHandle(), "tpk", nullptr,
+      "", PM_DEFAULT, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_uninstall_packages) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  const char* pkgs[3] = { "/tmp/a.tpk", "/tmp/b.tpk", "/tmp/c.tpk" };
+  int ret = pkgmgr_client_uninstall_packages(GetHandle(), pkgs, 3,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_uninstall_packages_n) {
+  int ret = pkgmgr_client_uninstall_packages(GetHandle(), nullptr, 0,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_uninstall) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_uninstall(GetHandle(), "tpk", "org.tizen.test",
+      PM_DEFAULT, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_uninstall_n) {
+  int ret = pkgmgr_client_uninstall(GetHandle(), "tpk", nullptr,
+      PM_DEFAULT, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_move) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_move(GetHandle(), "tpk", "org.tizen.test",
+      PM_MOVE_TO_SDCARD, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_move_n) {
+  int ret = pkgmgr_client_move(GetHandle(), "tpk", nullptr,
+      PM_MOVE_TO_SDCARD, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_mount_install) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_mount_install(GetHandle(), "tpk", "/tmp",
+      "/tmp/test.tpk", "", PM_DEFAULT, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_mount_install_n) {
+  int ret = pkgmgr_client_mount_install(GetHandle(), "tpk", "/tmp",
+      nullptr, "", PM_DEFAULT, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_mount_install_packages) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  const char* paths[3] = { "/tmp/a.tpk", "/tmp/b.tpk", "/tmp/c.tpk" };
+  int ret = pkgmgr_client_mount_install_packages(GetHandle(), paths, 3,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_mount_install_packages_n) {
+  int ret = pkgmgr_client_mount_install_packages(GetHandle(), nullptr, 0,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_register_pkg_update_info) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  pkg_update_info_t info = {
+    .pkgid = const_cast<char*>("org.tizen.test"),
+    .version = const_cast<char*>("1.0.0"),
+    .type = PM_UPDATEINFO_TYPE_FORCE
+  };
+  int ret = pkgmgr_client_register_pkg_update_info(GetHandle(), &info);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_register_pkg_update_info_n) {
+  int ret = pkgmgr_client_register_pkg_update_info(GetHandle(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_unregister_pkg_update_info) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_unregister_pkg_update_info(GetHandle(),
+      "org.tizen.test");
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_unregister_pkg_update_info_n) {
+  int ret = pkgmgr_client_unregister_pkg_update_info(GetHandle(),
+      nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_unregister_all_pkg_update_info) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_unregister_all_pkg_update_info(GetHandle());
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_unregister_all_pkg_update_info_n) {
+  int ret = pkgmgr_client_unregister_all_pkg_update_info(nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_activate(GetHandle(), "tpk", "org.tizen.test");
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate_n) {
+  int ret = pkgmgr_client_activate(GetHandle(), "tpk", nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate_packages) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  const char* pkgs[3] = { "org.tizen.test1", "org.tizen.test2",
+      "org.tizen.test3" };
+  int ret = pkgmgr_client_activate_packages(GetHandle(), "tpk", pkgs, 3,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate_packages_n) {
+  int ret = pkgmgr_client_activate_packages(GetHandle(), "tpk", nullptr, 3,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_deactivate(GetHandle(), "tpk", "org.tizen.test1");
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate_n) {
+  int ret = pkgmgr_client_deactivate(GetHandle(), "tpk", nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate_packages) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  const char* pkgs[3] = { "org.tizen.test1", "org.tizen.test2",
+      "org.tizen.test3" };
+  int ret = pkgmgr_client_deactivate_packages(GetHandle(), "tpk", pkgs, 3,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate_packages_n) {
+  int ret = pkgmgr_client_deactivate_packages(GetHandle(), "tpk", nullptr, 3,
+      GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate_app) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_activate_app(GetHandle(), "org.tizen.test",
+      GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate_app_n) {
+  int ret = pkgmgr_client_activate_app(GetHandle(), nullptr,
+      GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate_apps) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  const char* apps[3] = { "org.tizen.test1", "org.tizen.test2",
+      "org.tizen.test3" };
+  int ret = pkgmgr_client_activate_apps(GetHandle(), apps, 3,
+      GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate_apps_n) {
+  int ret = pkgmgr_client_activate_apps(GetHandle(), nullptr, 3,
+      GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate_global_app_for_uid) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_activate_global_app_for_uid(GetHandle(),
+      "org.tizen.test1", GetDefaultAppHandler(), nullptr, 0);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_activate_global_app_for_uid_n) {
+  int ret = pkgmgr_client_activate_global_app_for_uid(GetHandle(), nullptr,
+      GetDefaultAppHandler(), nullptr, 0);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate_app) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_deactivate_app(GetHandle(), "org.tizen.test",
+      GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate_app_n) {
+  int ret = pkgmgr_client_deactivate_app(GetHandle(), nullptr,
+      GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate_apps) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  const char* apps[3] = { "org.tizen.test1", "org.tizen.test2",
+      "org.tizen.test3" };
+  int ret = pkgmgr_client_deactivate_apps(GetHandle(), apps, 3,
+      GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate_apps_n) {
+  int ret = pkgmgr_client_deactivate_apps(GetHandle(), nullptr, 3,
+      GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate_global_app_for_uid) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_deactivate_global_app_for_uid(GetHandle(),
+      "org.tizen.test1", GetDefaultAppHandler(), nullptr, 0);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_deactivate_global_app_for_uid_n) {
+  int ret = pkgmgr_client_deactivate_global_app_for_uid(GetHandle(), nullptr,
+      GetDefaultAppHandler(), nullptr, 0);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_clear_user_data) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_clear_user_data(GetHandle(), "tpk",
+      "org.tizen.test1", PM_DEFAULT);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_clear_user_data_n) {
+  int ret = pkgmgr_client_clear_user_data(GetHandle(), "tpk",
+      nullptr, PM_DEFAULT);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_listen_status) {
+  int ret = pkgmgr_client_listen_status(GetHandle(), GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_listen_status_n) {
+  int ret = pkgmgr_client_listen_status(nullptr, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_listen_app_status) {
+  int ret = pkgmgr_client_listen_app_status(GetHandle(), GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_listen_app_status_n) {
+  int ret = pkgmgr_client_listen_app_status(nullptr, GetDefaultAppHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_get_size) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_get_size(GetHandle(), "org.tizen.test",
+      PM_GET_PKG_SIZE_INFO, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_get_size_n) {
+  int ret = pkgmgr_client_get_size(GetHandle(), nullptr,
+      PM_GET_PKG_SIZE_INFO, GetDefaultHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_get_package_size_info) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1);
+
+  int ret = pkgmgr_client_get_package_size_info(GetHandle(), "org.tizen.test",
+      GetDefaultPkgSizeHandler(), nullptr);
+  EXPECT_TRUE(ret > 0);
+}
+
+TEST_F(ClientTest, pkgmgr_client_get_package_size_info_n) {
+  int ret = pkgmgr_client_get_package_size_info(GetHandle(), nullptr,
+      GetDefaultPkgSizeHandler(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_generate_license_request) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, 0);
+        rpc_port_parcel_write_int32(parcel, 0);
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  char* req_data = nullptr;
+  char* license_url = nullptr;
+  int ret = pkgmgr_client_generate_license_request(GetHandle(), "data",
+      &req_data, &license_url);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+  free(req_data);
+  free(license_url);
+}
+
+TEST_F(ClientTest, pkgmgr_client_generate_license_request_n) {
+  int ret = pkgmgr_client_generate_license_request(GetHandle(), nullptr,
+      nullptr, nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_register_license) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_register_license(GetHandle(), "data");
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_register_license_n) {
+  int ret = pkgmgr_client_register_license(GetHandle(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_decrypt_package) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_decrypt_package(GetHandle(), "path1", "path2");
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_decrypt_package_n) {
+  int ret = pkgmgr_client_decrypt_package(GetHandle(), nullptr, nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_enable_splash_screen) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_enable_splash_screen(GetHandle(), "org.tizen.test1");
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_enable_splash_screen_n) {
+  int ret = pkgmgr_client_enable_splash_screen(GetHandle(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_disable_splash_screen) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_disable_splash_screen(GetHandle(), "org.tizen.test1");
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_disable_splash_screen_n) {
+  int ret = pkgmgr_client_disable_splash_screen(GetHandle(), nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_set_pkg_restriction_mode) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_set_pkg_restriction_mode(GetHandle(), "org.tizen.test1", 1);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_set_pkg_restriction_mode_n) {
+  int ret = pkgmgr_client_set_pkg_restriction_mode(GetHandle(), nullptr, 0);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_unset_pkg_restriction_mode) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_unset_pkg_restriction_mode(GetHandle(), "org.tizen.test1", 1);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_unset_pkg_restriction_mode_n) {
+  int ret = pkgmgr_client_unset_pkg_restriction_mode(GetHandle(), nullptr, 0);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_get_pkg_restriction_mode) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, 1); // mode
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int mode = 0;
+  int ret = pkgmgr_client_get_pkg_restriction_mode(GetHandle(),
+      "org.tizen.test1", &mode);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+  EXPECT_TRUE(mode == 1);
+}
+
+TEST_F(ClientTest, pkgmgr_client_get_pkg_restriction_mode_n) {
+  int mode;
+  int ret = pkgmgr_client_get_pkg_restriction_mode(GetHandle(), nullptr, &mode);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_set_restriction_mode) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_set_restriction_mode(GetHandle(), 2);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_set_restriction_mode_n) {
+  int ret = pkgmgr_client_set_restriction_mode(nullptr, 2);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_unset_restriction_mode) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_unset_restriction_mode(GetHandle(), 2);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_unset_restriction_mode_n) {
+  int ret = pkgmgr_client_unset_restriction_mode(nullptr, 2);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_get_restriction_mode) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, 2); // mode
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int mode = 0;
+  int ret = pkgmgr_client_get_restriction_mode(GetHandle(), &mode);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+  EXPECT_TRUE(mode == 2);
+}
+
+TEST_F(ClientTest, pkgmgr_client_get_restriction_mode_n) {
+  int mode = 0;
+  int ret = pkgmgr_client_get_restriction_mode(nullptr, &mode);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_set_app_label) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_set_app_label(GetHandle(),
+      const_cast<char*>("org.tizen.test1"), const_cast<char*>("test1"));
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_set_app_label_n) {
+  int ret = pkgmgr_client_set_app_label(nullptr, nullptr, nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_set_app_icon) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_set_app_icon(GetHandle(),
+      const_cast<char*>("org.tizen.test1"), const_cast<char*>("path"));
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_set_app_icon_n) {
+  int ret = pkgmgr_client_set_app_icon(nullptr, nullptr, nullptr);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
+
+TEST_F(ClientTest, pkgmgr_client_usr_migrate_external_image) {
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_proxy_connect_sync(_, _, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_send(_, _))
+      .Times(1);
+  EXPECT_CALL(GetMock<RpcPortMock>(), rpc_port_parcel_create_from_port(_, _))
+      .Times(1)
+      .WillOnce(Invoke([&](rpc_port_parcel_h* h, rpc_port_h port) {
+        rpc_port_parcel_h parcel;
+        rpc_port_parcel_create(&parcel);
+        rpc_port_parcel_write_int32(parcel, 0); // __Result
+        rpc_port_parcel_write_int32(parcel, PKGMGR_R_OK);
+        *h = parcel;
+        return 0;
+      }));
+
+  int ret = pkgmgr_client_usr_migrate_external_image(GetHandle(),
+      "org.tizen.test1", 0);
+  EXPECT_TRUE(ret == PKGMGR_R_OK);
+}
+
+TEST_F(ClientTest, pkgmgr_client_usr_migrate_external_image_n) {
+  int ret = pkgmgr_client_usr_migrate_external_image(nullptr,
+      "org.tizen.test1", 0);
+  EXPECT_TRUE(ret == PKGMGR_R_EINVAL);
+}
diff --git a/tidl/PkgMgr.tidl b/tidl/PkgMgr.tidl
new file mode 100755
index 0000000..f87e0bf
--- /dev/null
+++ b/tidl/PkgMgr.tidl
@@ -0,0 +1,71 @@
+// tidlc -s -l C++ -i PkgMgr.tidl -o PkgMgrStub

+// tidlc -p -l C++ -i PkgMgr.tidl -o PkgMgrProxy

+

+struct ResPath

+{

+  string From;

+  string To;

+}

+

+[privilege="http://tizen.org/privilege/packagemanager.clearcache"]

+interface PkgMgrForClearCache

+{

+  int ClearCache(int uid, string pkgid);

+}

+

+[privilege="http://tizen.org/privilege/packagemanager.info"]

+interface PkgMgr

+{

+  int GetSize(int uid, string pkgid, int getType, out string reqKey);

+  int GetSizeSync(int uid, string pkgid, int getType, out long sizeInfo);

+  int Check(int uid, string pkgid, out int pid);

+}

+

+[privilege = "http://tizen.org/privilege/packagemanager.admin"]

+interface PkgMgrAdmin

+{

+  int Install(int uid, string pkgType, string pkgPath, array<string> args, string reqId, out string reqKey);

+  int InstallPkgs(int uid, array<string> pkgs, array<string> args, string reqId, out string reqKey);

+  int Reinstall(int uid, string pkgid, out string reqKey);

+  int MountInstall(int uid, string pkgType, string pkgPath, array<string> args, string reqId, out string reqKey);

+  int MountInstallPkgs(int uid, array<string> pkgs, string reqId, out string reqKey);

+  int Uninstall(int uid, string pkgid, out string reqKey);

+  int UninstallPkgs(int uid, array<string> pkgs, out string reqKey);

+  int Move(int uid, string pkgId, int moveType, out string reqKey);

+  int EnablePkgs(int uid, array<string> pkgIds, out string reqKey);

+  int DisablePkgs(int uid, array<string> pkgIds, out string reqKey);

+  int RegisterPkgUpdateInfo(int uid, string pkgid, string version, int type);

+  int UnregisterPkgUpdateInfo(int uid, string pkgid);

+  int UnregisterAllPkgUpdateInfo(int uid);

+  int EnableApp(int uid, string appid, out string reqKey);

+  int DisableApp(int uid, string appid, out string reqKey);

+  int EnableApps(int uid, array<string> appIds, out string reqKey);

+  int DisableApps(int uid, array<string> appIds, out string reqKey);

+  int EnableGlobalAppForUid(int uid, string appid, out string reqKey);

+  int DisableGlobalAppForUid(int uid, string appid, out string reqKey);

+  int Kill(int uid, string pkgid, out int pid);

+  int GenerateLicenseRequest(string respData, out string reqData, out string licenseUrl);

+  int RegisterLicense(string respData);

+  int DecryptPackage(string drmFilePath, string decryptedFilePath);

+  int EnableAppSplashScreen(int uid, string appid);

+  int DisableAppSplashScreen(int uid, string appid);

+  int SetRestrictionMode(int uid, string pkgid, int mode);

+  int UnsetRestrictionMode(int uid, string pkgid, int mode);

+  int GetRestrictionMode(int uid, string pkgid, out int result);

+  int SetAppLabel(int uid, string appid, string label);

+  int SetAppIcon(int uid, string appid, string iconPath);

+  int MigrateExternalImage(int uid, string pkgid);

+  int ResCopy(array<ResPath> copyPathsPair, out string reqKey);

+  int ResCreateDir(array<string> createDirPaths, out string reqKey);

+  int ResRemove(array<string> removePaths, out string reqKey);

+  int ResUninstall(int uid, string pkgid);

+  int ClearData(int uid, string pkgid);

+}

+

+

+

+

+

+

+

+

diff --git a/tidl/PkgSignal.tidl b/tidl/PkgSignal.tidl
new file mode 100644
index 0000000..0470b16
--- /dev/null
+++ b/tidl/PkgSignal.tidl
@@ -0,0 +1,28 @@
+// tidlc -g -l C++ -i PkgSignal.tidl -o PkgSignal

+

+struct PkgInfo

+{

+  string Pkgid;

+  string Appid;

+  string PkgType;

+}

+

+struct PathInfo

+{

+  string Path;

+  int State;

+}

+

+struct ExtraData

+{

+  int ErrCode;

+  array<PathInfo> Paths;

+}

+

+interface PkgSignal

+{

+  void AsyncResult(int targetUid, string reqId, array<PkgInfo> pkgs, string key, string val) async;

+  void AsyncResultForResource(int targetUid, string reqId, string pkgid, string status, ExtraData extra) async;

+}

+

+

diff --git a/tidl/prebuild.sh b/tidl/prebuild.sh
new file mode 100755
index 0000000..2670821
--- /dev/null
+++ b/tidl/prebuild.sh
@@ -0,0 +1,5 @@
+#!/bin/bash
+tidlc -p -l C++ -i PkgMgr.tidl -o PkgMgrProxy
+tidlc -g -l C++ -i PkgSignal.tidl -o PkgSignal
+
+