Change tidl code to be generated at build time 97/316297/2
authorIlho Kim <ilho159.kim@samsung.com>
Tue, 23 Apr 2024 00:49:29 +0000 (09:49 +0900)
committerIlho Kim <ilho159.kim@samsung.com>
Mon, 19 Aug 2024 05:52:22 +0000 (14:52 +0900)
Change-Id: Ib1f5523ee05fe66f69cf23cda4c6d0b4391defe4
Signed-off-by: Ilho Kim <ilho159.kim@samsung.com>
client/src/PkgMgrProxy.cc [deleted file]
client/src/PkgMgrProxy.h [deleted file]
client/src/PkgSignal.cc [deleted file]
client/src/PkgSignal.h [deleted file]
installer/src/PkgSignal.cc [deleted file]
installer/src/PkgSignal.h [deleted file]
packaging/pkgmgr.spec

diff --git a/client/src/PkgMgrProxy.cc b/client/src/PkgMgrProxy.cc
deleted file mode 100644 (file)
index a0465e0..0000000
+++ /dev/null
@@ -1,3665 +0,0 @@
-/*
- * Generated by tidlc 2.0.4.
- */
-
-#include <stdlib.h>
-#include <assert.h>
-#include <dlog.h>
-
-#include "PkgMgrProxy.h"
-
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-
-#define LOG_TAG "RPC_PORT_PROXY"
-
-#ifdef _E
-#undef _E
-#endif
-
-#ifdef _W
-#undef _W
-#endif
-
-#ifdef _I
-#undef _I
-#endif
-
-#ifdef _D
-#undef _D
-#endif
-
-#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-
-#ifndef TIDL_VERSION
-#define TIDL_VERSION "2.0.4"
-#endif
-
-namespace rpc_port {
-namespace PkgMgrProxy {
-
-ResPath::ResPath() {}
-
-ResPath::ResPath(std::string From, std::string To)
-    : From_(std::move(From)), To_(std::move(To)) {}
-
-
-namespace proxy {
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const ResPath& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, ResPath& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<ResPath>& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<ResPath>& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<std::string>& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<std::string>& param);
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const ResPath& param) {
-  rpc_port_parcel_write_string(h, param.GetFrom().c_str());
-  rpc_port_parcel_write_string(h, param.GetTo().c_str());
-  return h;
-}
-
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, ResPath& param) {
-  char* From_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &From_raw);
-  std::string From(From_raw);
-  free(From_raw);
-  param.SetFrom(std::move(From));
-
-  char* To_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &To_raw);
-  std::string To(To_raw);
-  free(To_raw);
-  param.SetTo(std::move(To));
-
-  return h;
-}
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<ResPath>& param) {
-  rpc_port_parcel_write_array_count(h, param.size());
-  for (const auto& i : param) {
-    h << i;
-
-  }
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<ResPath>& param) {
-  int l = 0;
-  rpc_port_parcel_read_array_count(h, &l);
-
-  for (int i = 0; i < l; i++) {
-    ResPath v;
-    h >> v;
-
-    param.push_back(std::move(v));
-  }
-
-  return h;
-}
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<std::string>& param) {
-  rpc_port_parcel_write_array_count(h, param.size());
-  for (const auto& i : param) {
-    rpc_port_parcel_write_string(h, i.c_str());
-
-  }
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<std::string>& param) {
-  int l = 0;
-  rpc_port_parcel_read_array_count(h, &l);
-
-  for (int i = 0; i < l; i++) {
-    char* v_raw  = nullptr;
-    rpc_port_parcel_read_string(h, &v_raw);
-    std::string v(v_raw);
-    free(v_raw);
-
-    param.push_back(std::move(v));
-  }
-
-  return h;
-}
-
-std::atomic<int> PkgMgrForClearCache::CallbackBase::seq_num_ { 0 };
-
-PkgMgrForClearCache::CallbackBase::CallbackBase(int delegate_id, bool once)
-    : id_(delegate_id), once_(once) {
-  seq_id_ = seq_num_++;
-}
-
-int PkgMgrForClearCache::CallbackBase::GetId() const {
-  return id_;
-}
-
-int PkgMgrForClearCache::CallbackBase::GetSeqId() const {
-  return seq_id_;
-}
-
-bool PkgMgrForClearCache::CallbackBase::IsOnce() const {
-  return once_;
-}
-
-std::string PkgMgrForClearCache::CallbackBase::GetTag() const {
-  return std::to_string(id_) + "::" + std::to_string(seq_id_);
-}
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PkgMgrForClearCache::CallbackBase& cb) {
-  rpc_port_parcel_write_int32(h, cb.id_);
-  rpc_port_parcel_write_int32(h, cb.seq_id_);
-  rpc_port_parcel_write_bool(h, cb.once_);
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PkgMgrForClearCache::CallbackBase& cb) {
-  rpc_port_parcel_read_int32(h, &cb.id_);
-  rpc_port_parcel_read_int32(h, &cb.seq_id_);
-  rpc_port_parcel_read_bool(h, &cb.once_);
-
-  return h;
-}
-
-PkgMgrForClearCache::PkgMgrForClearCache(IEventListener* listener, const std::string& target_appid)
-    : port_(nullptr), callback_port_(nullptr), proxy_(nullptr),
-      listener_(listener), target_appid_(target_appid) {
-  int r = rpc_port_proxy_create(&proxy_);
-
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to create proxy");
-    throw InvalidIOException();
-  }
-
-  rpc_port_proxy_add_connected_event_cb(proxy_, OnConnectedCB, this);
-  rpc_port_proxy_add_disconnected_event_cb(proxy_, OnDisconnectedCB, this);
-  rpc_port_proxy_add_rejected_event_cb(proxy_, OnRejectedCB, this);
-  rpc_port_proxy_add_received_event_cb(proxy_, OnReceivedCB, this);
-}
-
-PkgMgrForClearCache::~PkgMgrForClearCache() {
-  if (proxy_)
-    rpc_port_proxy_destroy(proxy_);
-}
-
-void PkgMgrForClearCache::Connect(bool sync) {
-  int ret;
-  if (sync)
-    ret = rpc_port_proxy_connect_sync(proxy_, target_appid_.c_str(), "PkgMgrForClearCache");
-  else
-    ret = rpc_port_proxy_connect(proxy_, target_appid_.c_str(), "PkgMgrForClearCache");
-  if (ret != RPC_PORT_ERROR_NONE) {
-    _E("Failed to connect PkgMgrForClearCache");
-    switch (ret) {
-      case RPC_PORT_ERROR_INVALID_PARAMETER:
-        throw InvalidIDException();
-
-      case RPC_PORT_ERROR_IO_ERROR:
-        throw InvalidIOException();
-
-      case RPC_PORT_ERROR_PERMISSION_DENIED:
-        throw PermissionDeniedException();
-    }
-  }
-}
-
-void PkgMgrForClearCache::Disconnect() {
-  int ret = rpc_port_disconnect(port_);
-  if (ret != RPC_PORT_ERROR_NONE) {
-    _E("Failed to disconnect PkgMgrForClearCache");
-    throw InvalidIDException();
-  }
-}
-
-void PkgMgrForClearCache::DisposeCallback(const std::string& tag) {
-  for (auto& i : delegate_list_) {
-    if (i->GetTag() == tag) {
-      delegate_list_.remove(i);
-      return;
-    }
-  }
-}
-
-void PkgMgrForClearCache::ProcessReceivedEvent(rpc_port_parcel_h parcel) {
-  int id = 0;
-  int seq_id = 0;
-  bool once = false;
-
-  rpc_port_parcel_read_int32(parcel, &id);
-  rpc_port_parcel_read_int32(parcel, &seq_id);
-  rpc_port_parcel_read_bool(parcel, &once);
-
-  for (auto& i : delegate_list_) {
-    if (i->GetId() == id && i->GetSeqId() == seq_id) {
-      i->OnReceivedEvent(parcel);
-      if (i->IsOnce())
-        delegate_list_.remove(i);
-      break;
-    }
-  }
-}
-
-void PkgMgrForClearCache::ConsumeCommand(rpc_port_parcel_h* parcel, rpc_port_h port) {
-  do {
-    rpc_port_parcel_h p;
-    int ret = rpc_port_parcel_create_from_port(&p, port);
-    int cmd;
-
-    if (ret != 0)
-      break;
-    rpc_port_parcel_read_int32(p, &cmd);
-    if (cmd == static_cast<int>(MethodId::__Result)) {
-      *parcel = p;
-      return;
-    }
-
-    rpc_port_parcel_destroy(p);
-    *parcel = nullptr;
-  } while (true);
-  *parcel = nullptr;
-}
-
-void PkgMgrForClearCache::OnConnectedCB(const char *ep, const char *port_name, rpc_port_h port, void *data) {
-  PkgMgrForClearCache* l = static_cast<PkgMgrForClearCache*>(data);
-  rpc_port_h cb_port;
-
-  l->port_ = port;
-  rpc_port_proxy_get_port(l->proxy_, RPC_PORT_PORT_CALLBACK, &cb_port);
-  l->callback_port_ = cb_port;
-  l->listener_->OnConnected();
-}
-
-void PkgMgrForClearCache::OnDisconnectedCB(const char *ep, const char *port_name, void *data) {
-  PkgMgrForClearCache* l = static_cast<PkgMgrForClearCache*>(data);
-  l->delegate_list_.clear();
-  l->listener_->OnDisconnected();
-}
-
-void PkgMgrForClearCache::OnRejectedCB(const char *ep, const char *port_name, void *data) {
-  PkgMgrForClearCache* l = static_cast<PkgMgrForClearCache*>(data);
-  l->listener_->OnRejected();
-}
-
-void PkgMgrForClearCache::OnReceivedCB(const char *ep, const char *port_name, void *data) {
-  PkgMgrForClearCache* l = static_cast<PkgMgrForClearCache*>(data);
-  int cmd;
-  rpc_port_parcel_h parcel_received;
-
-  if (rpc_port_parcel_create_from_port(&parcel_received, l->callback_port_) != 0) {
-    _E("Failed to create parcel from port");
-    return;
-  }
-
-  rpc_port_parcel_read_int32(parcel_received, &cmd);
-  if (cmd != static_cast<int>(MethodId::__Callback)) {
-    rpc_port_parcel_destroy(parcel_received);
-    return;
-  }
-
-  l->ProcessReceivedEvent(parcel_received);
-  rpc_port_parcel_destroy(parcel_received);
-}
-
-
-int PkgMgrForClearCache::ClearCache(int uid, std::string pkgid) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::ClearCache));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-std::atomic<int> PkgMgr::CallbackBase::seq_num_ { 0 };
-
-PkgMgr::CallbackBase::CallbackBase(int delegate_id, bool once)
-    : id_(delegate_id), once_(once) {
-  seq_id_ = seq_num_++;
-}
-
-int PkgMgr::CallbackBase::GetId() const {
-  return id_;
-}
-
-int PkgMgr::CallbackBase::GetSeqId() const {
-  return seq_id_;
-}
-
-bool PkgMgr::CallbackBase::IsOnce() const {
-  return once_;
-}
-
-std::string PkgMgr::CallbackBase::GetTag() const {
-  return std::to_string(id_) + "::" + std::to_string(seq_id_);
-}
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PkgMgr::CallbackBase& cb) {
-  rpc_port_parcel_write_int32(h, cb.id_);
-  rpc_port_parcel_write_int32(h, cb.seq_id_);
-  rpc_port_parcel_write_bool(h, cb.once_);
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PkgMgr::CallbackBase& cb) {
-  rpc_port_parcel_read_int32(h, &cb.id_);
-  rpc_port_parcel_read_int32(h, &cb.seq_id_);
-  rpc_port_parcel_read_bool(h, &cb.once_);
-
-  return h;
-}
-
-PkgMgr::PkgMgr(IEventListener* listener, const std::string& target_appid)
-    : port_(nullptr), callback_port_(nullptr), proxy_(nullptr),
-      listener_(listener), target_appid_(target_appid) {
-  int r = rpc_port_proxy_create(&proxy_);
-
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to create proxy");
-    throw InvalidIOException();
-  }
-
-  rpc_port_proxy_add_connected_event_cb(proxy_, OnConnectedCB, this);
-  rpc_port_proxy_add_disconnected_event_cb(proxy_, OnDisconnectedCB, this);
-  rpc_port_proxy_add_rejected_event_cb(proxy_, OnRejectedCB, this);
-  rpc_port_proxy_add_received_event_cb(proxy_, OnReceivedCB, this);
-}
-
-PkgMgr::~PkgMgr() {
-  if (proxy_)
-    rpc_port_proxy_destroy(proxy_);
-}
-
-void PkgMgr::Connect(bool sync) {
-  int ret;
-  if (sync)
-    ret = rpc_port_proxy_connect_sync(proxy_, target_appid_.c_str(), "PkgMgr");
-  else
-    ret = rpc_port_proxy_connect(proxy_, target_appid_.c_str(), "PkgMgr");
-  if (ret != RPC_PORT_ERROR_NONE) {
-    _E("Failed to connect PkgMgr");
-    switch (ret) {
-      case RPC_PORT_ERROR_INVALID_PARAMETER:
-        throw InvalidIDException();
-
-      case RPC_PORT_ERROR_IO_ERROR:
-        throw InvalidIOException();
-
-      case RPC_PORT_ERROR_PERMISSION_DENIED:
-        throw PermissionDeniedException();
-    }
-  }
-}
-
-void PkgMgr::Disconnect() {
-  int ret = rpc_port_disconnect(port_);
-  if (ret != RPC_PORT_ERROR_NONE) {
-    _E("Failed to disconnect PkgMgr");
-    throw InvalidIDException();
-  }
-}
-
-void PkgMgr::DisposeCallback(const std::string& tag) {
-  for (auto& i : delegate_list_) {
-    if (i->GetTag() == tag) {
-      delegate_list_.remove(i);
-      return;
-    }
-  }
-}
-
-void PkgMgr::ProcessReceivedEvent(rpc_port_parcel_h parcel) {
-  int id = 0;
-  int seq_id = 0;
-  bool once = false;
-
-  rpc_port_parcel_read_int32(parcel, &id);
-  rpc_port_parcel_read_int32(parcel, &seq_id);
-  rpc_port_parcel_read_bool(parcel, &once);
-
-  for (auto& i : delegate_list_) {
-    if (i->GetId() == id && i->GetSeqId() == seq_id) {
-      i->OnReceivedEvent(parcel);
-      if (i->IsOnce())
-        delegate_list_.remove(i);
-      break;
-    }
-  }
-}
-
-void PkgMgr::ConsumeCommand(rpc_port_parcel_h* parcel, rpc_port_h port) {
-  do {
-    rpc_port_parcel_h p;
-    int ret = rpc_port_parcel_create_from_port(&p, port);
-    int cmd;
-
-    if (ret != 0)
-      break;
-    rpc_port_parcel_read_int32(p, &cmd);
-    if (cmd == static_cast<int>(MethodId::__Result)) {
-      *parcel = p;
-      return;
-    }
-
-    rpc_port_parcel_destroy(p);
-    *parcel = nullptr;
-  } while (true);
-  *parcel = nullptr;
-}
-
-void PkgMgr::OnConnectedCB(const char *ep, const char *port_name, rpc_port_h port, void *data) {
-  PkgMgr* l = static_cast<PkgMgr*>(data);
-  rpc_port_h cb_port;
-
-  l->port_ = port;
-  rpc_port_proxy_get_port(l->proxy_, RPC_PORT_PORT_CALLBACK, &cb_port);
-  l->callback_port_ = cb_port;
-  l->listener_->OnConnected();
-}
-
-void PkgMgr::OnDisconnectedCB(const char *ep, const char *port_name, void *data) {
-  PkgMgr* l = static_cast<PkgMgr*>(data);
-  l->delegate_list_.clear();
-  l->listener_->OnDisconnected();
-}
-
-void PkgMgr::OnRejectedCB(const char *ep, const char *port_name, void *data) {
-  PkgMgr* l = static_cast<PkgMgr*>(data);
-  l->listener_->OnRejected();
-}
-
-void PkgMgr::OnReceivedCB(const char *ep, const char *port_name, void *data) {
-  PkgMgr* l = static_cast<PkgMgr*>(data);
-  int cmd;
-  rpc_port_parcel_h parcel_received;
-
-  if (rpc_port_parcel_create_from_port(&parcel_received, l->callback_port_) != 0) {
-    _E("Failed to create parcel from port");
-    return;
-  }
-
-  rpc_port_parcel_read_int32(parcel_received, &cmd);
-  if (cmd != static_cast<int>(MethodId::__Callback)) {
-    rpc_port_parcel_destroy(parcel_received);
-    return;
-  }
-
-  l->ProcessReceivedEvent(parcel_received);
-  rpc_port_parcel_destroy(parcel_received);
-}
-
-
-int PkgMgr::GetSize(int uid, std::string pkgid, int getType, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::GetSize));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-  rpc_port_parcel_write_int32(p, getType);
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgr::GetSizeSync(int uid, std::string pkgid, int getType, std::string& ReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::GetSizeSync));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-  rpc_port_parcel_write_int32(p, getType);
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* ReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &ReqKey_raw);
-    ReqKey = ReqKey_raw;
-    free(ReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgr::GetSizeSyncResult(std::string reqKey, int& result, long long& sizeInfo) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::GetSizeSyncResult));
-  rpc_port_parcel_write_string(p, reqKey.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &result);
-    rpc_port_parcel_read_int64(parcel_received, &sizeInfo);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgr::Check(int uid, std::string pkgid, int& pid) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::Check));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &pid);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-std::atomic<int> PkgMgrAdmin::CallbackBase::seq_num_ { 0 };
-
-PkgMgrAdmin::CallbackBase::CallbackBase(int delegate_id, bool once)
-    : id_(delegate_id), once_(once) {
-  seq_id_ = seq_num_++;
-}
-
-int PkgMgrAdmin::CallbackBase::GetId() const {
-  return id_;
-}
-
-int PkgMgrAdmin::CallbackBase::GetSeqId() const {
-  return seq_id_;
-}
-
-bool PkgMgrAdmin::CallbackBase::IsOnce() const {
-  return once_;
-}
-
-std::string PkgMgrAdmin::CallbackBase::GetTag() const {
-  return std::to_string(id_) + "::" + std::to_string(seq_id_);
-}
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PkgMgrAdmin::CallbackBase& cb) {
-  rpc_port_parcel_write_int32(h, cb.id_);
-  rpc_port_parcel_write_int32(h, cb.seq_id_);
-  rpc_port_parcel_write_bool(h, cb.once_);
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PkgMgrAdmin::CallbackBase& cb) {
-  rpc_port_parcel_read_int32(h, &cb.id_);
-  rpc_port_parcel_read_int32(h, &cb.seq_id_);
-  rpc_port_parcel_read_bool(h, &cb.once_);
-
-  return h;
-}
-
-PkgMgrAdmin::PkgMgrAdmin(IEventListener* listener, const std::string& target_appid)
-    : port_(nullptr), callback_port_(nullptr), proxy_(nullptr),
-      listener_(listener), target_appid_(target_appid) {
-  int r = rpc_port_proxy_create(&proxy_);
-
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to create proxy");
-    throw InvalidIOException();
-  }
-
-  rpc_port_proxy_add_connected_event_cb(proxy_, OnConnectedCB, this);
-  rpc_port_proxy_add_disconnected_event_cb(proxy_, OnDisconnectedCB, this);
-  rpc_port_proxy_add_rejected_event_cb(proxy_, OnRejectedCB, this);
-  rpc_port_proxy_add_received_event_cb(proxy_, OnReceivedCB, this);
-}
-
-PkgMgrAdmin::~PkgMgrAdmin() {
-  if (proxy_)
-    rpc_port_proxy_destroy(proxy_);
-}
-
-void PkgMgrAdmin::Connect(bool sync) {
-  int ret;
-  if (sync)
-    ret = rpc_port_proxy_connect_sync(proxy_, target_appid_.c_str(), "PkgMgrAdmin");
-  else
-    ret = rpc_port_proxy_connect(proxy_, target_appid_.c_str(), "PkgMgrAdmin");
-  if (ret != RPC_PORT_ERROR_NONE) {
-    _E("Failed to connect PkgMgrAdmin");
-    switch (ret) {
-      case RPC_PORT_ERROR_INVALID_PARAMETER:
-        throw InvalidIDException();
-
-      case RPC_PORT_ERROR_IO_ERROR:
-        throw InvalidIOException();
-
-      case RPC_PORT_ERROR_PERMISSION_DENIED:
-        throw PermissionDeniedException();
-    }
-  }
-}
-
-void PkgMgrAdmin::Disconnect() {
-  int ret = rpc_port_disconnect(port_);
-  if (ret != RPC_PORT_ERROR_NONE) {
-    _E("Failed to disconnect PkgMgrAdmin");
-    throw InvalidIDException();
-  }
-}
-
-void PkgMgrAdmin::DisposeCallback(const std::string& tag) {
-  for (auto& i : delegate_list_) {
-    if (i->GetTag() == tag) {
-      delegate_list_.remove(i);
-      return;
-    }
-  }
-}
-
-void PkgMgrAdmin::ProcessReceivedEvent(rpc_port_parcel_h parcel) {
-  int id = 0;
-  int seq_id = 0;
-  bool once = false;
-
-  rpc_port_parcel_read_int32(parcel, &id);
-  rpc_port_parcel_read_int32(parcel, &seq_id);
-  rpc_port_parcel_read_bool(parcel, &once);
-
-  for (auto& i : delegate_list_) {
-    if (i->GetId() == id && i->GetSeqId() == seq_id) {
-      i->OnReceivedEvent(parcel);
-      if (i->IsOnce())
-        delegate_list_.remove(i);
-      break;
-    }
-  }
-}
-
-void PkgMgrAdmin::ConsumeCommand(rpc_port_parcel_h* parcel, rpc_port_h port) {
-  do {
-    rpc_port_parcel_h p;
-    int ret = rpc_port_parcel_create_from_port(&p, port);
-    int cmd;
-
-    if (ret != 0)
-      break;
-    rpc_port_parcel_read_int32(p, &cmd);
-    if (cmd == static_cast<int>(MethodId::__Result)) {
-      *parcel = p;
-      return;
-    }
-
-    rpc_port_parcel_destroy(p);
-    *parcel = nullptr;
-  } while (true);
-  *parcel = nullptr;
-}
-
-void PkgMgrAdmin::OnConnectedCB(const char *ep, const char *port_name, rpc_port_h port, void *data) {
-  PkgMgrAdmin* l = static_cast<PkgMgrAdmin*>(data);
-  rpc_port_h cb_port;
-
-  l->port_ = port;
-  rpc_port_proxy_get_port(l->proxy_, RPC_PORT_PORT_CALLBACK, &cb_port);
-  l->callback_port_ = cb_port;
-  l->listener_->OnConnected();
-}
-
-void PkgMgrAdmin::OnDisconnectedCB(const char *ep, const char *port_name, void *data) {
-  PkgMgrAdmin* l = static_cast<PkgMgrAdmin*>(data);
-  l->delegate_list_.clear();
-  l->listener_->OnDisconnected();
-}
-
-void PkgMgrAdmin::OnRejectedCB(const char *ep, const char *port_name, void *data) {
-  PkgMgrAdmin* l = static_cast<PkgMgrAdmin*>(data);
-  l->listener_->OnRejected();
-}
-
-void PkgMgrAdmin::OnReceivedCB(const char *ep, const char *port_name, void *data) {
-  PkgMgrAdmin* l = static_cast<PkgMgrAdmin*>(data);
-  int cmd;
-  rpc_port_parcel_h parcel_received;
-
-  if (rpc_port_parcel_create_from_port(&parcel_received, l->callback_port_) != 0) {
-    _E("Failed to create parcel from port");
-    return;
-  }
-
-  rpc_port_parcel_read_int32(parcel_received, &cmd);
-  if (cmd != static_cast<int>(MethodId::__Callback)) {
-    rpc_port_parcel_destroy(parcel_received);
-    return;
-  }
-
-  l->ProcessReceivedEvent(parcel_received);
-  rpc_port_parcel_destroy(parcel_received);
-}
-
-
-int PkgMgrAdmin::Install(int uid, std::string pkgType, std::string pkgPath, std::vector<std::string> args, std::string reqId, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::Install));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgType.c_str());
-  rpc_port_parcel_write_string(p, pkgPath.c_str());
-  p << args;
-  rpc_port_parcel_write_string(p, reqId.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::InstallPkgs(int uid, std::vector<std::string> pkgs, std::vector<std::string> args, std::string reqId, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::InstallPkgs));
-  rpc_port_parcel_write_int32(p, uid);
-  p << pkgs;
-  p << args;
-  rpc_port_parcel_write_string(p, reqId.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::Reinstall(int uid, std::string pkgid, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::Reinstall));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::MountInstall(int uid, std::string pkgType, std::string pkgPath, std::vector<std::string> args, std::string reqId, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::MountInstall));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgType.c_str());
-  rpc_port_parcel_write_string(p, pkgPath.c_str());
-  p << args;
-  rpc_port_parcel_write_string(p, reqId.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::MountInstallPkgs(int uid, std::vector<std::string> pkgs, std::string reqId, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::MountInstallPkgs));
-  rpc_port_parcel_write_int32(p, uid);
-  p << pkgs;
-  rpc_port_parcel_write_string(p, reqId.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::Uninstall(int uid, std::string pkgid, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::Uninstall));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::UninstallPkgs(int uid, std::vector<std::string> pkgs, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::UninstallPkgs));
-  rpc_port_parcel_write_int32(p, uid);
-  p << pkgs;
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::Move(int uid, std::string pkgId, int moveType, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::Move));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgId.c_str());
-  rpc_port_parcel_write_int32(p, moveType);
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::EnablePkgs(int uid, std::vector<std::string> pkgIds, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::EnablePkgs));
-  rpc_port_parcel_write_int32(p, uid);
-  p << pkgIds;
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::DisablePkgs(int uid, std::vector<std::string> pkgIds, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::DisablePkgs));
-  rpc_port_parcel_write_int32(p, uid);
-  p << pkgIds;
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::RegisterPkgUpdateInfo(int uid, std::string pkgid, std::string version, int type, std::string& delayedReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::RegisterPkgUpdateInfo));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-  rpc_port_parcel_write_string(p, version.c_str());
-  rpc_port_parcel_write_int32(p, type);
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* delayedReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &delayedReqKey_raw);
-    delayedReqKey = delayedReqKey_raw;
-    free(delayedReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::UnregisterPkgUpdateInfo(int uid, std::string pkgid, std::string& delayedReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::UnregisterPkgUpdateInfo));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* delayedReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &delayedReqKey_raw);
-    delayedReqKey = delayedReqKey_raw;
-    free(delayedReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::UnregisterAllPkgUpdateInfo(int uid, std::string& delayedReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::UnregisterAllPkgUpdateInfo));
-  rpc_port_parcel_write_int32(p, uid);
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* delayedReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &delayedReqKey_raw);
-    delayedReqKey = delayedReqKey_raw;
-    free(delayedReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::EnableApp(int uid, std::string appid, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::EnableApp));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, appid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::DisableApp(int uid, std::string appid, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::DisableApp));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, appid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::EnableApps(int uid, std::vector<std::string> appIds, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::EnableApps));
-  rpc_port_parcel_write_int32(p, uid);
-  p << appIds;
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::DisableApps(int uid, std::vector<std::string> appIds, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::DisableApps));
-  rpc_port_parcel_write_int32(p, uid);
-  p << appIds;
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::EnableGlobalAppForUid(int uid, std::string appid, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::EnableGlobalAppForUid));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, appid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::DisableGlobalAppForUid(int uid, std::string appid, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::DisableGlobalAppForUid));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, appid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::Kill(int uid, std::string pkgid, int& pid) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::Kill));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &pid);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::GenerateLicenseRequest(std::string respData, std::string& delayedReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::GenerateLicenseRequest));
-  rpc_port_parcel_write_string(p, respData.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* delayedReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &delayedReqKey_raw);
-    delayedReqKey = delayedReqKey_raw;
-    free(delayedReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::GetGenerateLicenseResult(std::string reqKey, int& result, std::string& reqData, std::string& licenseUrl) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::GetGenerateLicenseResult));
-  rpc_port_parcel_write_string(p, reqKey.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &result);
-    char* reqData_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqData_raw);
-    reqData = reqData_raw;
-    free(reqData_raw);
-    char* licenseUrl_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &licenseUrl_raw);
-    licenseUrl = licenseUrl_raw;
-    free(licenseUrl_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::RegisterLicense(std::string respData, std::string& delayedReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::RegisterLicense));
-  rpc_port_parcel_write_string(p, respData.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* delayedReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &delayedReqKey_raw);
-    delayedReqKey = delayedReqKey_raw;
-    free(delayedReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::DecryptPackage(std::string drmFilePath, std::string decryptedFilePath, std::string& delayedReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::DecryptPackage));
-  rpc_port_parcel_write_string(p, drmFilePath.c_str());
-  rpc_port_parcel_write_string(p, decryptedFilePath.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* delayedReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &delayedReqKey_raw);
-    delayedReqKey = delayedReqKey_raw;
-    free(delayedReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::EnableAppSplashScreen(int uid, std::string appid) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::EnableAppSplashScreen));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, appid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::DisableAppSplashScreen(int uid, std::string appid) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::DisableAppSplashScreen));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, appid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::SetAppLabel(int uid, std::string appid, std::string label, std::string& delayedReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::SetAppLabel));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, appid.c_str());
-  rpc_port_parcel_write_string(p, label.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* delayedReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &delayedReqKey_raw);
-    delayedReqKey = delayedReqKey_raw;
-    free(delayedReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::SetAppIcon(int uid, std::string appid, std::string iconPath, std::string& delayedReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::SetAppIcon));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, appid.c_str());
-  rpc_port_parcel_write_string(p, iconPath.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* delayedReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &delayedReqKey_raw);
-    delayedReqKey = delayedReqKey_raw;
-    free(delayedReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::MigrateExternalImage(int uid, std::string pkgid) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::MigrateExternalImage));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::ResCopy(std::vector<ResPath> copyPathsPair, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::ResCopy));
-  p << copyPathsPair;
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::ResCreateDir(std::vector<std::string> createDirPaths, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::ResCreateDir));
-  p << createDirPaths;
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::ResRemove(std::vector<std::string> removePaths, std::string& reqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::ResRemove));
-  p << removePaths;
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* reqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &reqKey_raw);
-    reqKey = reqKey_raw;
-    free(reqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::ResUninstall(int uid, std::string pkgid, std::string& delayedReqKey) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::ResUninstall));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    char* delayedReqKey_raw  = nullptr;
-    rpc_port_parcel_read_string(parcel_received, &delayedReqKey_raw);
-    delayedReqKey = delayedReqKey_raw;
-    free(delayedReqKey_raw);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::ClearData(int uid, std::string pkgid) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::ClearData));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-int PkgMgrAdmin::ClearDataWithPath(int uid, std::string pkgid, std::string filePath) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::ClearDataWithPath));
-  rpc_port_parcel_write_int32(p, uid);
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-  rpc_port_parcel_write_string(p, filePath.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-
-std::atomic<int> DelayedResult::CallbackBase::seq_num_ { 0 };
-
-DelayedResult::CallbackBase::CallbackBase(int delegate_id, bool once)
-    : id_(delegate_id), once_(once) {
-  seq_id_ = seq_num_++;
-}
-
-int DelayedResult::CallbackBase::GetId() const {
-  return id_;
-}
-
-int DelayedResult::CallbackBase::GetSeqId() const {
-  return seq_id_;
-}
-
-bool DelayedResult::CallbackBase::IsOnce() const {
-  return once_;
-}
-
-std::string DelayedResult::CallbackBase::GetTag() const {
-  return std::to_string(id_) + "::" + std::to_string(seq_id_);
-}
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const DelayedResult::CallbackBase& cb) {
-  rpc_port_parcel_write_int32(h, cb.id_);
-  rpc_port_parcel_write_int32(h, cb.seq_id_);
-  rpc_port_parcel_write_bool(h, cb.once_);
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, DelayedResult::CallbackBase& cb) {
-  rpc_port_parcel_read_int32(h, &cb.id_);
-  rpc_port_parcel_read_int32(h, &cb.seq_id_);
-  rpc_port_parcel_read_bool(h, &cb.once_);
-
-  return h;
-}
-
-DelayedResult::DelayedResult(IEventListener* listener, const std::string& target_appid)
-    : port_(nullptr), callback_port_(nullptr), proxy_(nullptr),
-      listener_(listener), target_appid_(target_appid) {
-  int r = rpc_port_proxy_create(&proxy_);
-
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to create proxy");
-    throw InvalidIOException();
-  }
-
-  rpc_port_proxy_add_connected_event_cb(proxy_, OnConnectedCB, this);
-  rpc_port_proxy_add_disconnected_event_cb(proxy_, OnDisconnectedCB, this);
-  rpc_port_proxy_add_rejected_event_cb(proxy_, OnRejectedCB, this);
-  rpc_port_proxy_add_received_event_cb(proxy_, OnReceivedCB, this);
-}
-
-DelayedResult::~DelayedResult() {
-  if (proxy_)
-    rpc_port_proxy_destroy(proxy_);
-}
-
-void DelayedResult::Connect(bool sync) {
-  int ret;
-  if (sync)
-    ret = rpc_port_proxy_connect_sync(proxy_, target_appid_.c_str(), "DelayedResult");
-  else
-    ret = rpc_port_proxy_connect(proxy_, target_appid_.c_str(), "DelayedResult");
-  if (ret != RPC_PORT_ERROR_NONE) {
-    _E("Failed to connect DelayedResult");
-    switch (ret) {
-      case RPC_PORT_ERROR_INVALID_PARAMETER:
-        throw InvalidIDException();
-
-      case RPC_PORT_ERROR_IO_ERROR:
-        throw InvalidIOException();
-
-      case RPC_PORT_ERROR_PERMISSION_DENIED:
-        throw PermissionDeniedException();
-    }
-  }
-}
-
-void DelayedResult::Disconnect() {
-  int ret = rpc_port_disconnect(port_);
-  if (ret != RPC_PORT_ERROR_NONE) {
-    _E("Failed to disconnect DelayedResult");
-    throw InvalidIDException();
-  }
-}
-
-void DelayedResult::DisposeCallback(const std::string& tag) {
-  for (auto& i : delegate_list_) {
-    if (i->GetTag() == tag) {
-      delegate_list_.remove(i);
-      return;
-    }
-  }
-}
-
-void DelayedResult::ProcessReceivedEvent(rpc_port_parcel_h parcel) {
-  int id = 0;
-  int seq_id = 0;
-  bool once = false;
-
-  rpc_port_parcel_read_int32(parcel, &id);
-  rpc_port_parcel_read_int32(parcel, &seq_id);
-  rpc_port_parcel_read_bool(parcel, &once);
-
-  for (auto& i : delegate_list_) {
-    if (i->GetId() == id && i->GetSeqId() == seq_id) {
-      i->OnReceivedEvent(parcel);
-      if (i->IsOnce())
-        delegate_list_.remove(i);
-      break;
-    }
-  }
-}
-
-void DelayedResult::ConsumeCommand(rpc_port_parcel_h* parcel, rpc_port_h port) {
-  do {
-    rpc_port_parcel_h p;
-    int ret = rpc_port_parcel_create_from_port(&p, port);
-    int cmd;
-
-    if (ret != 0)
-      break;
-    rpc_port_parcel_read_int32(p, &cmd);
-    if (cmd == static_cast<int>(MethodId::__Result)) {
-      *parcel = p;
-      return;
-    }
-
-    rpc_port_parcel_destroy(p);
-    *parcel = nullptr;
-  } while (true);
-  *parcel = nullptr;
-}
-
-void DelayedResult::OnConnectedCB(const char *ep, const char *port_name, rpc_port_h port, void *data) {
-  DelayedResult* l = static_cast<DelayedResult*>(data);
-  rpc_port_h cb_port;
-
-  l->port_ = port;
-  rpc_port_proxy_get_port(l->proxy_, RPC_PORT_PORT_CALLBACK, &cb_port);
-  l->callback_port_ = cb_port;
-  l->listener_->OnConnected();
-}
-
-void DelayedResult::OnDisconnectedCB(const char *ep, const char *port_name, void *data) {
-  DelayedResult* l = static_cast<DelayedResult*>(data);
-  l->delegate_list_.clear();
-  l->listener_->OnDisconnected();
-}
-
-void DelayedResult::OnRejectedCB(const char *ep, const char *port_name, void *data) {
-  DelayedResult* l = static_cast<DelayedResult*>(data);
-  l->listener_->OnRejected();
-}
-
-void DelayedResult::OnReceivedCB(const char *ep, const char *port_name, void *data) {
-  DelayedResult* l = static_cast<DelayedResult*>(data);
-  int cmd;
-  rpc_port_parcel_h parcel_received;
-
-  if (rpc_port_parcel_create_from_port(&parcel_received, l->callback_port_) != 0) {
-    _E("Failed to create parcel from port");
-    return;
-  }
-
-  rpc_port_parcel_read_int32(parcel_received, &cmd);
-  if (cmd != static_cast<int>(MethodId::__Callback)) {
-    rpc_port_parcel_destroy(parcel_received);
-    return;
-  }
-
-  l->ProcessReceivedEvent(parcel_received);
-  rpc_port_parcel_destroy(parcel_received);
-}
-
-
-int DelayedResult::GetResult(std::string reqKey, int& result) {
-  if (port_ == nullptr) {
-    _E("Not connected");
-    throw NotConnectedSocketException();
-  }
-
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::GetResult));
-  rpc_port_parcel_write_string(p, reqKey.c_str());
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-
-  // Send
-  int r = rpc_port_parcel_send(p, port_);
-  if (r != RPC_PORT_ERROR_NONE) {
-    _E("Failed to send parcel. result(%d)", r);
-    rpc_port_parcel_destroy(p);
-    throw InvalidIOException();
-  }
-
-  int ret;
-  bool done_ = false;
-  do {
-    rpc_port_parcel_h parcel_received = nullptr;
-    // Receive
-    ConsumeCommand(&parcel_received, port_);
-    if (parcel_received == nullptr) {
-      _E("Invalid protocol");
-      throw InvalidProtocolException();
-    }
-
-    rpc_port_parcel_get_header(parcel_received, &header_);
-    char* tag_ = nullptr;
-    rpc_port_parcel_header_get_tag(header_, &tag_);
-    std::unique_ptr<char, decltype(std::free)*> tag_auto_(tag_, std::free);
-    if (tag_ && tag_[0] != '\0') {
-      int seq_num_received_ = -1;
-      rpc_port_parcel_header_get_seq_num(header_, &seq_num_received_);
-      if (seq_num_received_ != seq_num_) {
-        _E("Invalid protocol. %d", seq_num_received_);
-        rpc_port_parcel_destroy(parcel_received);
-        continue;
-      }
-    }
-    done_ = true;
-
-    rpc_port_parcel_read_int32(parcel_received, &result);
-    rpc_port_parcel_read_int32(parcel_received, &ret);
-
-    rpc_port_parcel_destroy(parcel_received);
-  } while (!done_);
-
-  rpc_port_parcel_destroy(p);
-
-  return ret;
-
-}
-}  // namespace proxy
-}  // namespace PkgMgrProxy
-}  // namespace rpc_port
diff --git a/client/src/PkgMgrProxy.h b/client/src/PkgMgrProxy.h
deleted file mode 100644 (file)
index 5bcbaca..0000000
+++ /dev/null
@@ -1,668 +0,0 @@
-/*
- * Generated by tidlc 2.0.4.
- */
-
-#pragma once
-
-#include <bundle.h>
-#include <rpc-port-parcel.h>
-#include <rpc-port.h>
-
-#include <string>
-#include <vector>
-#include <memory>
-#include <mutex>
-#include <list>
-#include <atomic>
-
-namespace rpc_port {
-namespace PkgMgrProxy {
-class Bundle final {
- public:
-  Bundle() {
-    raw_ = bundle_create();
-  }
-
-  Bundle(bundle* b) {
-    raw_ = b;
-  }
-
-  ~Bundle() {
-    if (raw_)
-      bundle_free(raw_);
-  }
-
-  Bundle(Bundle&& b) : raw_(b.raw_) {
-    b.raw_ = nullptr;
-  }
-
-  Bundle& operator = (Bundle&& b) {
-    if (this != &b) {
-      if (raw_)
-        bundle_free(raw_);
-
-      raw_ = b.raw_;
-      b.raw_ = nullptr;
-    }
-    return *this;
-  }
-
-  Bundle(const Bundle& b) : raw_(bundle_dup(b.GetHandle())) {}
-
-  Bundle& operator = (const Bundle& b) {
-    if (this != &b) {
-      if (raw_)
-        bundle_free(raw_);
-
-      raw_ = bundle_dup(b.GetHandle());
-    }
-    return *this;
-  }
-
-  bundle* GetHandle() const {
-    return raw_;
-  }
-
- private:
-  bundle* raw_;
-};
-
-class File final {
- public:
-  File() {
-  }
-
-  File(std::string filename) {
-    filename_ = filename;
-  }
-
-  std::string GetFileName() const {
-    return filename_;
-  }
-
- private:
-  std::string filename_;
-};
-
-
-class ResPath final {
- public:
-  ResPath();
-  ResPath(std::string From, std::string To);
-  
-  void SetFrom(std::string From) {
-    From_ = std::move(From);
-  }
-
-  const std::string& GetFrom() const {
-    return From_;
-  }
-
-  void SetTo(std::string To) {
-    To_ = std::move(To);
-  }
-
-  const std::string& GetTo() const {
-    return To_;
-  }
-
-
- private:
-  std::string From_;
-  std::string To_;
-
-};
-
-namespace proxy {
-
-class Exception {};
-class NotConnectedSocketException : public Exception {};
-class InvalidProtocolException : public Exception {};
-class InvalidIOException : public Exception {};
-class PermissionDeniedException : public Exception {};
-class InvalidIDException : public Exception {};
-
-class PkgMgrForClearCache {
- public:
-
-  class CallbackBase {
-   public:
-    CallbackBase(int delegate_id, bool once);
-    virtual ~CallbackBase() = default;
-    virtual void OnReceivedEvent(rpc_port_parcel_h port) = 0;
-    int GetId() const;
-    int GetSeqId() const;
-    bool IsOnce() const;
-    std::string GetTag() const;
-
-   private:
-    friend rpc_port_parcel_h operator << (rpc_port_parcel_h h, const CallbackBase& cb);
-    friend rpc_port_parcel_h operator >> (rpc_port_parcel_h h, CallbackBase& cb);
-
-    static std::atomic<int> seq_num_;
-    int id_;
-    int seq_id_;
-    bool once_;
-  };
-
-  class IEventListener {
-   public:
-    /// <summary>
-    /// This method will be invoked when the client app is connected to the servicece app.
-    /// </summary>
-    virtual void OnConnected() = 0;
-
-    /// <summary>
-    /// This method will be invoked after the client app was disconnected from the servicece app.
-    /// </summary>
-    virtual void OnDisconnected() = 0;
-
-    /// <summary>
-    /// This method will be invoked when the service app rejects the client app.
-    /// </summary>
-    virtual void OnRejected() = 0;
-  };
-
-  /// <summary>
-  /// Constructor for this class
-  /// </summary>
-  /// <param name="listener">The listener for events</param>
-  /// <param name="target_appid">The service app ID to connect</param>
-  PkgMgrForClearCache(IEventListener* listener, const std::string& target_appid);
-
-  /// <summary>
-  /// Destructor for this class
-  /// </summary>
-  virtual ~PkgMgrForClearCache();
-
-  /// <summary>
-  /// Connects to the service app.
-  /// </summary>
-  /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege>
-  /// <privilege>http://tizen.org/privilege/datasharing</privilege>
-  //  <param name="sync">if true, connects to the service app synchornously</param>
-  /// <exception cref="InvalidIDException">
-  /// Thrown when the appid to connect is invalid.
-  /// </exception>
-  /// <exception cref="InvalidIOException">
-  /// Thrown when internal I/O error happen.
-  /// </exception>
-  /// <exception cref="PermissionDeniedException">
-  /// Thrown when the permission is denied.
-  /// </exception>
-  /// <remark> If you want to use this method, you must add privileges.</remark>
-  void Connect(bool sync = false);
-
-  /// <summary>
-  /// Disconnects from the service app.
-  /// </summary>
-  /// <exception cref="InvalidIDException">
-  /// Thrown when the stub port is invalid.
-  /// </exception>
-  void Disconnect();
-
-  /// <summary>
-  /// Disposes delegate objects in this interface
-  /// </summary>
-  /// <param name="tag">The tag string from delegate object</param>
-  void DisposeCallback(const std::string& tag);
-
-  int ClearCache(int uid, std::string pkgid);
-
- private:
-  enum class MethodId : int {
-    __Result = 0,
-    __Callback = 1,
-    ClearCache = 2,
-
-  };
-
-  enum class DelegateId : int {
-
-  };
-  void ProcessReceivedEvent(rpc_port_parcel_h parcel);
-  void ConsumeCommand(rpc_port_parcel_h* parcel, rpc_port_h port);
-
-  static void OnConnectedCB(const char *ep, const char *port_name,
-                            rpc_port_h port, void *data);
-  static void OnDisconnectedCB(const char *ep, const char *port_name,
-                               void *data);
-  static void OnRejectedCB(const char *ep, const char *port_name, void *data);
-  static void OnReceivedCB(const char *ep, const char *port_name, void *data);
-
-  rpc_port_h port_;
-  rpc_port_h callback_port_;
-  rpc_port_proxy_h proxy_;
-  IEventListener* listener_;
-  std::recursive_mutex mutex_;
-  std::list<std::unique_ptr<CallbackBase>> delegate_list_;
-  std::string target_appid_;
-};
-
-class PkgMgr {
- public:
-
-  class CallbackBase {
-   public:
-    CallbackBase(int delegate_id, bool once);
-    virtual ~CallbackBase() = default;
-    virtual void OnReceivedEvent(rpc_port_parcel_h port) = 0;
-    int GetId() const;
-    int GetSeqId() const;
-    bool IsOnce() const;
-    std::string GetTag() const;
-
-   private:
-    friend rpc_port_parcel_h operator << (rpc_port_parcel_h h, const CallbackBase& cb);
-    friend rpc_port_parcel_h operator >> (rpc_port_parcel_h h, CallbackBase& cb);
-
-    static std::atomic<int> seq_num_;
-    int id_;
-    int seq_id_;
-    bool once_;
-  };
-
-  class IEventListener {
-   public:
-    /// <summary>
-    /// This method will be invoked when the client app is connected to the servicece app.
-    /// </summary>
-    virtual void OnConnected() = 0;
-
-    /// <summary>
-    /// This method will be invoked after the client app was disconnected from the servicece app.
-    /// </summary>
-    virtual void OnDisconnected() = 0;
-
-    /// <summary>
-    /// This method will be invoked when the service app rejects the client app.
-    /// </summary>
-    virtual void OnRejected() = 0;
-  };
-
-  /// <summary>
-  /// Constructor for this class
-  /// </summary>
-  /// <param name="listener">The listener for events</param>
-  /// <param name="target_appid">The service app ID to connect</param>
-  PkgMgr(IEventListener* listener, const std::string& target_appid);
-
-  /// <summary>
-  /// Destructor for this class
-  /// </summary>
-  virtual ~PkgMgr();
-
-  /// <summary>
-  /// Connects to the service app.
-  /// </summary>
-  /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege>
-  /// <privilege>http://tizen.org/privilege/datasharing</privilege>
-  //  <param name="sync">if true, connects to the service app synchornously</param>
-  /// <exception cref="InvalidIDException">
-  /// Thrown when the appid to connect is invalid.
-  /// </exception>
-  /// <exception cref="InvalidIOException">
-  /// Thrown when internal I/O error happen.
-  /// </exception>
-  /// <exception cref="PermissionDeniedException">
-  /// Thrown when the permission is denied.
-  /// </exception>
-  /// <remark> If you want to use this method, you must add privileges.</remark>
-  void Connect(bool sync = false);
-
-  /// <summary>
-  /// Disconnects from the service app.
-  /// </summary>
-  /// <exception cref="InvalidIDException">
-  /// Thrown when the stub port is invalid.
-  /// </exception>
-  void Disconnect();
-
-  /// <summary>
-  /// Disposes delegate objects in this interface
-  /// </summary>
-  /// <param name="tag">The tag string from delegate object</param>
-  void DisposeCallback(const std::string& tag);
-
-  int GetSize(int uid, std::string pkgid, int getType, std::string& reqKey);
-  int GetSizeSync(int uid, std::string pkgid, int getType, std::string& ReqKey);
-  int GetSizeSyncResult(std::string reqKey, int& result, long long& sizeInfo);
-  int Check(int uid, std::string pkgid, int& pid);
-
- private:
-  enum class MethodId : int {
-    __Result = 0,
-    __Callback = 1,
-    GetSize = 2,
-    GetSizeSync = 3,
-    GetSizeSyncResult = 4,
-    Check = 5,
-
-  };
-
-  enum class DelegateId : int {
-
-  };
-  void ProcessReceivedEvent(rpc_port_parcel_h parcel);
-  void ConsumeCommand(rpc_port_parcel_h* parcel, rpc_port_h port);
-
-  static void OnConnectedCB(const char *ep, const char *port_name,
-                            rpc_port_h port, void *data);
-  static void OnDisconnectedCB(const char *ep, const char *port_name,
-                               void *data);
-  static void OnRejectedCB(const char *ep, const char *port_name, void *data);
-  static void OnReceivedCB(const char *ep, const char *port_name, void *data);
-
-  rpc_port_h port_;
-  rpc_port_h callback_port_;
-  rpc_port_proxy_h proxy_;
-  IEventListener* listener_;
-  std::recursive_mutex mutex_;
-  std::list<std::unique_ptr<CallbackBase>> delegate_list_;
-  std::string target_appid_;
-};
-
-class PkgMgrAdmin {
- public:
-
-  class CallbackBase {
-   public:
-    CallbackBase(int delegate_id, bool once);
-    virtual ~CallbackBase() = default;
-    virtual void OnReceivedEvent(rpc_port_parcel_h port) = 0;
-    int GetId() const;
-    int GetSeqId() const;
-    bool IsOnce() const;
-    std::string GetTag() const;
-
-   private:
-    friend rpc_port_parcel_h operator << (rpc_port_parcel_h h, const CallbackBase& cb);
-    friend rpc_port_parcel_h operator >> (rpc_port_parcel_h h, CallbackBase& cb);
-
-    static std::atomic<int> seq_num_;
-    int id_;
-    int seq_id_;
-    bool once_;
-  };
-
-  class IEventListener {
-   public:
-    /// <summary>
-    /// This method will be invoked when the client app is connected to the servicece app.
-    /// </summary>
-    virtual void OnConnected() = 0;
-
-    /// <summary>
-    /// This method will be invoked after the client app was disconnected from the servicece app.
-    /// </summary>
-    virtual void OnDisconnected() = 0;
-
-    /// <summary>
-    /// This method will be invoked when the service app rejects the client app.
-    /// </summary>
-    virtual void OnRejected() = 0;
-  };
-
-  /// <summary>
-  /// Constructor for this class
-  /// </summary>
-  /// <param name="listener">The listener for events</param>
-  /// <param name="target_appid">The service app ID to connect</param>
-  PkgMgrAdmin(IEventListener* listener, const std::string& target_appid);
-
-  /// <summary>
-  /// Destructor for this class
-  /// </summary>
-  virtual ~PkgMgrAdmin();
-
-  /// <summary>
-  /// Connects to the service app.
-  /// </summary>
-  /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege>
-  /// <privilege>http://tizen.org/privilege/datasharing</privilege>
-  //  <param name="sync">if true, connects to the service app synchornously</param>
-  /// <exception cref="InvalidIDException">
-  /// Thrown when the appid to connect is invalid.
-  /// </exception>
-  /// <exception cref="InvalidIOException">
-  /// Thrown when internal I/O error happen.
-  /// </exception>
-  /// <exception cref="PermissionDeniedException">
-  /// Thrown when the permission is denied.
-  /// </exception>
-  /// <remark> If you want to use this method, you must add privileges.</remark>
-  void Connect(bool sync = false);
-
-  /// <summary>
-  /// Disconnects from the service app.
-  /// </summary>
-  /// <exception cref="InvalidIDException">
-  /// Thrown when the stub port is invalid.
-  /// </exception>
-  void Disconnect();
-
-  /// <summary>
-  /// Disposes delegate objects in this interface
-  /// </summary>
-  /// <param name="tag">The tag string from delegate object</param>
-  void DisposeCallback(const std::string& tag);
-
-  int Install(int uid, std::string pkgType, std::string pkgPath, std::vector<std::string> args, std::string reqId, std::string& reqKey);
-  int InstallPkgs(int uid, std::vector<std::string> pkgs, std::vector<std::string> args, std::string reqId, std::string& reqKey);
-  int Reinstall(int uid, std::string pkgid, std::string& reqKey);
-  int MountInstall(int uid, std::string pkgType, std::string pkgPath, std::vector<std::string> args, std::string reqId, std::string& reqKey);
-  int MountInstallPkgs(int uid, std::vector<std::string> pkgs, std::string reqId, std::string& reqKey);
-  int Uninstall(int uid, std::string pkgid, std::string& reqKey);
-  int UninstallPkgs(int uid, std::vector<std::string> pkgs, std::string& reqKey);
-  int Move(int uid, std::string pkgId, int moveType, std::string& reqKey);
-  int EnablePkgs(int uid, std::vector<std::string> pkgIds, std::string& reqKey);
-  int DisablePkgs(int uid, std::vector<std::string> pkgIds, std::string& reqKey);
-  int RegisterPkgUpdateInfo(int uid, std::string pkgid, std::string version, int type, std::string& delayedReqKey);
-  int UnregisterPkgUpdateInfo(int uid, std::string pkgid, std::string& delayedReqKey);
-  int UnregisterAllPkgUpdateInfo(int uid, std::string& delayedReqKey);
-  int EnableApp(int uid, std::string appid, std::string& reqKey);
-  int DisableApp(int uid, std::string appid, std::string& reqKey);
-  int EnableApps(int uid, std::vector<std::string> appIds, std::string& reqKey);
-  int DisableApps(int uid, std::vector<std::string> appIds, std::string& reqKey);
-  int EnableGlobalAppForUid(int uid, std::string appid, std::string& reqKey);
-  int DisableGlobalAppForUid(int uid, std::string appid, std::string& reqKey);
-  int Kill(int uid, std::string pkgid, int& pid);
-  int GenerateLicenseRequest(std::string respData, std::string& delayedReqKey);
-  int GetGenerateLicenseResult(std::string reqKey, int& result, std::string& reqData, std::string& licenseUrl);
-  int RegisterLicense(std::string respData, std::string& delayedReqKey);
-  int DecryptPackage(std::string drmFilePath, std::string decryptedFilePath, std::string& delayedReqKey);
-  int EnableAppSplashScreen(int uid, std::string appid);
-  int DisableAppSplashScreen(int uid, std::string appid);
-  int SetAppLabel(int uid, std::string appid, std::string label, std::string& delayedReqKey);
-  int SetAppIcon(int uid, std::string appid, std::string iconPath, std::string& delayedReqKey);
-  int MigrateExternalImage(int uid, std::string pkgid);
-  int ResCopy(std::vector<ResPath> copyPathsPair, std::string& reqKey);
-  int ResCreateDir(std::vector<std::string> createDirPaths, std::string& reqKey);
-  int ResRemove(std::vector<std::string> removePaths, std::string& reqKey);
-  int ResUninstall(int uid, std::string pkgid, std::string& delayedReqKey);
-  int ClearData(int uid, std::string pkgid);
-  int ClearDataWithPath(int uid, std::string pkgid, std::string filePath);
-
- private:
-  enum class MethodId : int {
-    __Result = 0,
-    __Callback = 1,
-    Install = 2,
-    InstallPkgs = 3,
-    Reinstall = 4,
-    MountInstall = 5,
-    MountInstallPkgs = 6,
-    Uninstall = 7,
-    UninstallPkgs = 8,
-    Move = 9,
-    EnablePkgs = 10,
-    DisablePkgs = 11,
-    RegisterPkgUpdateInfo = 12,
-    UnregisterPkgUpdateInfo = 13,
-    UnregisterAllPkgUpdateInfo = 14,
-    EnableApp = 15,
-    DisableApp = 16,
-    EnableApps = 17,
-    DisableApps = 18,
-    EnableGlobalAppForUid = 19,
-    DisableGlobalAppForUid = 20,
-    Kill = 21,
-    GenerateLicenseRequest = 22,
-    GetGenerateLicenseResult = 23,
-    RegisterLicense = 24,
-    DecryptPackage = 25,
-    EnableAppSplashScreen = 26,
-    DisableAppSplashScreen = 27,
-    SetAppLabel = 28,
-    SetAppIcon = 29,
-    MigrateExternalImage = 30,
-    ResCopy = 31,
-    ResCreateDir = 32,
-    ResRemove = 33,
-    ResUninstall = 34,
-    ClearData = 35,
-    ClearDataWithPath = 36,
-
-  };
-
-  enum class DelegateId : int {
-
-  };
-  void ProcessReceivedEvent(rpc_port_parcel_h parcel);
-  void ConsumeCommand(rpc_port_parcel_h* parcel, rpc_port_h port);
-
-  static void OnConnectedCB(const char *ep, const char *port_name,
-                            rpc_port_h port, void *data);
-  static void OnDisconnectedCB(const char *ep, const char *port_name,
-                               void *data);
-  static void OnRejectedCB(const char *ep, const char *port_name, void *data);
-  static void OnReceivedCB(const char *ep, const char *port_name, void *data);
-
-  rpc_port_h port_;
-  rpc_port_h callback_port_;
-  rpc_port_proxy_h proxy_;
-  IEventListener* listener_;
-  std::recursive_mutex mutex_;
-  std::list<std::unique_ptr<CallbackBase>> delegate_list_;
-  std::string target_appid_;
-};
-
-class DelayedResult {
- public:
-
-  class CallbackBase {
-   public:
-    CallbackBase(int delegate_id, bool once);
-    virtual ~CallbackBase() = default;
-    virtual void OnReceivedEvent(rpc_port_parcel_h port) = 0;
-    int GetId() const;
-    int GetSeqId() const;
-    bool IsOnce() const;
-    std::string GetTag() const;
-
-   private:
-    friend rpc_port_parcel_h operator << (rpc_port_parcel_h h, const CallbackBase& cb);
-    friend rpc_port_parcel_h operator >> (rpc_port_parcel_h h, CallbackBase& cb);
-
-    static std::atomic<int> seq_num_;
-    int id_;
-    int seq_id_;
-    bool once_;
-  };
-
-  class IEventListener {
-   public:
-    /// <summary>
-    /// This method will be invoked when the client app is connected to the servicece app.
-    /// </summary>
-    virtual void OnConnected() = 0;
-
-    /// <summary>
-    /// This method will be invoked after the client app was disconnected from the servicece app.
-    /// </summary>
-    virtual void OnDisconnected() = 0;
-
-    /// <summary>
-    /// This method will be invoked when the service app rejects the client app.
-    /// </summary>
-    virtual void OnRejected() = 0;
-  };
-
-  /// <summary>
-  /// Constructor for this class
-  /// </summary>
-  /// <param name="listener">The listener for events</param>
-  /// <param name="target_appid">The service app ID to connect</param>
-  DelayedResult(IEventListener* listener, const std::string& target_appid);
-
-  /// <summary>
-  /// Destructor for this class
-  /// </summary>
-  virtual ~DelayedResult();
-
-  /// <summary>
-  /// Connects to the service app.
-  /// </summary>
-  /// <privilege>http://tizen.org/privilege/appmanager.launch</privilege>
-  /// <privilege>http://tizen.org/privilege/datasharing</privilege>
-  //  <param name="sync">if true, connects to the service app synchornously</param>
-  /// <exception cref="InvalidIDException">
-  /// Thrown when the appid to connect is invalid.
-  /// </exception>
-  /// <exception cref="InvalidIOException">
-  /// Thrown when internal I/O error happen.
-  /// </exception>
-  /// <exception cref="PermissionDeniedException">
-  /// Thrown when the permission is denied.
-  /// </exception>
-  /// <remark> If you want to use this method, you must add privileges.</remark>
-  void Connect(bool sync = false);
-
-  /// <summary>
-  /// Disconnects from the service app.
-  /// </summary>
-  /// <exception cref="InvalidIDException">
-  /// Thrown when the stub port is invalid.
-  /// </exception>
-  void Disconnect();
-
-  /// <summary>
-  /// Disposes delegate objects in this interface
-  /// </summary>
-  /// <param name="tag">The tag string from delegate object</param>
-  void DisposeCallback(const std::string& tag);
-
-  int GetResult(std::string reqKey, int& result);
-
- private:
-  enum class MethodId : int {
-    __Result = 0,
-    __Callback = 1,
-    GetResult = 2,
-
-  };
-
-  enum class DelegateId : int {
-
-  };
-  void ProcessReceivedEvent(rpc_port_parcel_h parcel);
-  void ConsumeCommand(rpc_port_parcel_h* parcel, rpc_port_h port);
-
-  static void OnConnectedCB(const char *ep, const char *port_name,
-                            rpc_port_h port, void *data);
-  static void OnDisconnectedCB(const char *ep, const char *port_name,
-                               void *data);
-  static void OnRejectedCB(const char *ep, const char *port_name, void *data);
-  static void OnReceivedCB(const char *ep, const char *port_name, void *data);
-
-  rpc_port_h port_;
-  rpc_port_h callback_port_;
-  rpc_port_proxy_h proxy_;
-  IEventListener* listener_;
-  std::recursive_mutex mutex_;
-  std::list<std::unique_ptr<CallbackBase>> delegate_list_;
-  std::string target_appid_;
-};
-}  // namespace proxy
-}  // namespace PkgMgrProxy
-}  // namespace rpc_port
diff --git a/client/src/PkgSignal.cc b/client/src/PkgSignal.cc
deleted file mode 100644 (file)
index 216a9e8..0000000
+++ /dev/null
@@ -1,475 +0,0 @@
-/*
- * Generated by tidlc 2.0.4.
- */
-
-#include <stdlib.h>
-#include <assert.h>
-#include <dlog.h>
-
-#include "PkgSignal.h"
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-
-#define LOG_TAG "RPC_PORT_GROUP"
-
-#ifdef _E
-#undef _E
-#endif
-
-#ifdef _W
-#undef _W
-#endif
-
-#ifdef _I
-#undef _I
-#endif
-
-#ifdef _D
-#undef _D
-#endif
-
-#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-
-#ifndef TIDL_VERSION
-#define TIDL_VERSION "2.0.4"
-#endif
-
-namespace rpc_port {
-namespace PkgSignal {
-
-PkgInfo::PkgInfo() {}
-
-PkgInfo::PkgInfo(std::string Pkgid, std::string Appid, std::string PkgType)
-    : Pkgid_(std::move(Pkgid)), Appid_(std::move(Appid)), PkgType_(std::move(PkgType)) {}
-
-
-PathInfo::PathInfo() {}
-
-PathInfo::PathInfo(std::string Path, int State)
-    : Path_(std::move(Path)), State_(std::move(State)) {}
-
-
-ExtraData::ExtraData() {}
-
-ExtraData::ExtraData(int ErrCode, std::vector<PathInfo> Paths)
-    : ErrCode_(std::move(ErrCode)), Paths_(std::move(Paths)) {}
-
-
-namespace group {
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PkgInfo& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PkgInfo& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PathInfo& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PathInfo& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const ExtraData& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, ExtraData& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<PathInfo>& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<PathInfo>& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<PkgInfo>& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<PkgInfo>& param);
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PkgInfo& param) {
-  rpc_port_parcel_write_string(h, param.GetPkgid().c_str());
-  rpc_port_parcel_write_string(h, param.GetAppid().c_str());
-  rpc_port_parcel_write_string(h, param.GetPkgType().c_str());
-  return h;
-}
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PathInfo& param) {
-  rpc_port_parcel_write_string(h, param.GetPath().c_str());
-  rpc_port_parcel_write_int32(h, param.GetState());
-  return h;
-}
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const ExtraData& param) {
-  rpc_port_parcel_write_int32(h, param.GetErrCode());
-  h << param.GetPaths();
-  return h;
-}
-
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PkgInfo& param) {
-  char* Pkgid_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &Pkgid_raw);
-  std::string Pkgid(Pkgid_raw);
-  free(Pkgid_raw);
-  param.SetPkgid(std::move(Pkgid));
-
-  char* Appid_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &Appid_raw);
-  std::string Appid(Appid_raw);
-  free(Appid_raw);
-  param.SetAppid(std::move(Appid));
-
-  char* PkgType_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &PkgType_raw);
-  std::string PkgType(PkgType_raw);
-  free(PkgType_raw);
-  param.SetPkgType(std::move(PkgType));
-
-  return h;
-}
-
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PathInfo& param) {
-  char* Path_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &Path_raw);
-  std::string Path(Path_raw);
-  free(Path_raw);
-  param.SetPath(std::move(Path));
-
-  int State;
-  rpc_port_parcel_read_int32(h, &State);
-  param.SetState(State);
-
-  return h;
-}
-
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, ExtraData& param) {
-  int ErrCode;
-  rpc_port_parcel_read_int32(h, &ErrCode);
-  param.SetErrCode(ErrCode);
-
-  std::vector<PathInfo> Paths;
-  h >> Paths;
-  param.SetPaths(std::move(Paths));
-
-  return h;
-}
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<PathInfo>& param) {
-  rpc_port_parcel_write_array_count(h, param.size());
-  for (const auto& i : param) {
-    h << i;
-
-  }
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<PathInfo>& param) {
-  int l = 0;
-  rpc_port_parcel_read_array_count(h, &l);
-
-  for (int i = 0; i < l; i++) {
-    PathInfo v;
-    h >> v;
-
-    param.push_back(std::move(v));
-  }
-
-  return h;
-}
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<PkgInfo>& param) {
-  rpc_port_parcel_write_array_count(h, param.size());
-  for (const auto& i : param) {
-    h << i;
-
-  }
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<PkgInfo>& param) {
-  int l = 0;
-  rpc_port_parcel_read_array_count(h, &l);
-
-  for (int i = 0; i < l; i++) {
-    PkgInfo v;
-    h >> v;
-
-    param.push_back(std::move(v));
-  }
-
-  return h;
-}
-
-PkgSignal::PkgSignal(std::string sender_appid, bool is_system)
-    : sender_appid_(std::move(sender_appid)), is_system_(is_system) {
-  Subscribe();
-}
-
-
-PkgSignal::~PkgSignal() {
-  Unsubscribe();
-}
-
-void PkgSignal::Subscribe() {
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  int ret = event_add_event_handler(GetEventName().c_str(), EventCb, this, &event_handler_);
-  if (ret != EVENT_ERROR_NONE) {
-    _E("Failed to register events. result(%d)", ret);
-    throw InvalidIOException();
-  }
-}
-
-void PkgSignal::Unsubscribe() {
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  if (event_handler_) {
-    event_remove_event_handler(event_handler_);
-    event_handler_ = nullptr;
-  }
-}
-
-bundle* PkgSignal::GetBundleFromParcel(rpc_port_parcel_h p, bundle* b) {
-  void* raw = nullptr;
-  unsigned int size = 0;
-
-  int ret = rpc_port_parcel_get_raw(p, &raw, &size);
-  if (ret != RPC_PORT_ERROR_NONE)
-    return nullptr;
-
-  ret = bundle_add_byte(b, "TIDL_RAW", raw, size);
-  if (ret != BUNDLE_ERROR_NONE)
-    return nullptr;
-
-  return b;
-}
-
-rpc_port_parcel_h PkgSignal::GetParcelFromBundle(bundle* b) {
-  void* raw = nullptr;
-  size_t size = 0;
-  rpc_port_parcel_h p;
-
-  int ret = bundle_get_byte(b, "TIDL_RAW", &raw, &size);
-  if (ret != BUNDLE_ERROR_NONE)
-    return nullptr;
-
-  ret = rpc_port_parcel_create_from_raw(&p, raw,
-      static_cast<unsigned int>(size));
-  if (ret != RPC_PORT_ERROR_NONE)
-    return nullptr;
-
-  return p;
-}
-
-std::string PkgSignal::GetEventName() {
-  if (is_system_)
-    return "tizen.system.event.tidl_iface_PkgSignal";
-  return "event." + sender_appid_ + ".tidl_iface_PkgSignal";
-}
-
-void PkgSignal::EventCb(const char* event_name, bundle* event_data, void* user_data) {
-  auto* ptr = static_cast<PkgSignal*>(user_data);
-  rpc_port_parcel_h p = ptr->GetParcelFromBundle(event_data);
-  if (p == nullptr) {
-    _E("Invalid bundle");
-    return;
-  }
-
-  std::unique_ptr<std::remove_pointer<rpc_port_parcel_h>::type,
-      decltype(rpc_port_parcel_destroy)*> p_auto(p, rpc_port_parcel_destroy);
-
-  rpc_port_parcel_h header;
-  int seq_num = -1;
-  int cmd;
-  rpc_port_parcel_get_header(p, &header);
-  rpc_port_parcel_header_get_seq_num(header, &seq_num);
-
-  _W("[Sequence] %d", seq_num);
-  rpc_port_parcel_read_int32(p, &cmd);
-  switch (cmd) {
-
-    case static_cast<int>(MethodId::AsyncResult):
-    {
-      char* param1_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param1_raw);
-      std::string param1(param1_raw);
-      free(param1_raw);
-      int param2;
-      rpc_port_parcel_read_int32(p, &param2);
-      char* param3_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param3_raw);
-      std::string param3(param3_raw);
-      free(param3_raw);
-      std::vector<PkgInfo> param4;
-      p >> param4;
-      char* param5_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param5_raw);
-      std::string param5(param5_raw);
-      free(param5_raw);
-      char* param6_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param6_raw);
-      std::string param6(param6_raw);
-      free(param6_raw);
-      ptr->OnAsyncResult(param1, param2, param3, param4, param5, param6);
-
-    }
-    break;
-
-
-    case static_cast<int>(MethodId::AsyncResultForResource):
-    {
-      char* param1_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param1_raw);
-      std::string param1(param1_raw);
-      free(param1_raw);
-      int param2;
-      rpc_port_parcel_read_int32(p, &param2);
-      char* param3_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param3_raw);
-      std::string param3(param3_raw);
-      free(param3_raw);
-      char* param4_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param4_raw);
-      std::string param4(param4_raw);
-      free(param4_raw);
-      char* param5_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param5_raw);
-      std::string param5(param5_raw);
-      free(param5_raw);
-      ExtraData param6;
-      p >> param6;
-      ptr->OnAsyncResultForResource(param1, param2, param3, param4, param5, param6);
-
-    }
-    break;
-
-
-    case static_cast<int>(MethodId::AsyncResultForPkgUpgrade):
-    {
-      char* param1_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param1_raw);
-      std::string param1(param1_raw);
-      free(param1_raw);
-      int param2;
-      rpc_port_parcel_read_int32(p, &param2);
-      ptr->OnAsyncResultForPkgUpgrade(param1, param2);
-
-    }
-    break;
-
-
-
-    default:
-      _E("Unknown command(%d)", cmd);
-  }
-}
-
-
-void PkgSignal::AsyncResult(std::string signal, int targetUid, std::string reqId, std::vector<PkgInfo> pkgs, std::string key, std::string val) {
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-  std::unique_ptr<std::remove_pointer<rpc_port_parcel_h>::type,
-      decltype(rpc_port_parcel_destroy)*> p_auto(p, rpc_port_parcel_destroy);
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::AsyncResult));
-  rpc_port_parcel_write_string(p, signal.c_str());
-  rpc_port_parcel_write_int32(p, targetUid);
-  rpc_port_parcel_write_string(p, reqId.c_str());
-  p << pkgs;
-  rpc_port_parcel_write_string(p, key.c_str());
-  rpc_port_parcel_write_string(p, val.c_str());
-
-
-  // Send
-  bundle* b = bundle_create();
-  std::unique_ptr<bundle, decltype(bundle_free)*> b_auto(b, bundle_free);
-  if (GetBundleFromParcel(p, b) == nullptr) {
-    _E("Failed to make bundle from parcel");
-    throw InvalidIOException();
-  }
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  int ret = event_publish_app_event(GetEventName().c_str(), b);
-  if (ret != EVENT_ERROR_NONE) {
-    _E("Failed to publish event. result(%d)", ret);
-    throw InvalidIOException();
-  }
-}
-
-void PkgSignal::AsyncResultForResource(std::string signal, int targetUid, std::string reqId, std::string pkgid, std::string status, ExtraData extra) {
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-  std::unique_ptr<std::remove_pointer<rpc_port_parcel_h>::type,
-      decltype(rpc_port_parcel_destroy)*> p_auto(p, rpc_port_parcel_destroy);
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::AsyncResultForResource));
-  rpc_port_parcel_write_string(p, signal.c_str());
-  rpc_port_parcel_write_int32(p, targetUid);
-  rpc_port_parcel_write_string(p, reqId.c_str());
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-  rpc_port_parcel_write_string(p, status.c_str());
-  p << extra;
-
-
-  // Send
-  bundle* b = bundle_create();
-  std::unique_ptr<bundle, decltype(bundle_free)*> b_auto(b, bundle_free);
-  if (GetBundleFromParcel(p, b) == nullptr) {
-    _E("Failed to make bundle from parcel");
-    throw InvalidIOException();
-  }
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  int ret = event_publish_app_event(GetEventName().c_str(), b);
-  if (ret != EVENT_ERROR_NONE) {
-    _E("Failed to publish event. result(%d)", ret);
-    throw InvalidIOException();
-  }
-}
-
-void PkgSignal::AsyncResultForPkgUpgrade(std::string signal, int progress) {
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-  std::unique_ptr<std::remove_pointer<rpc_port_parcel_h>::type,
-      decltype(rpc_port_parcel_destroy)*> p_auto(p, rpc_port_parcel_destroy);
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::AsyncResultForPkgUpgrade));
-  rpc_port_parcel_write_string(p, signal.c_str());
-  rpc_port_parcel_write_int32(p, progress);
-
-
-  // Send
-  bundle* b = bundle_create();
-  std::unique_ptr<bundle, decltype(bundle_free)*> b_auto(b, bundle_free);
-  if (GetBundleFromParcel(p, b) == nullptr) {
-    _E("Failed to make bundle from parcel");
-    throw InvalidIOException();
-  }
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  int ret = event_publish_app_event(GetEventName().c_str(), b);
-  if (ret != EVENT_ERROR_NONE) {
-    _E("Failed to publish event. result(%d)", ret);
-    throw InvalidIOException();
-  }
-}
-}  // namespace group
-}  // namespace PkgSignal
-}  // namespace rpc_port
diff --git a/client/src/PkgSignal.h b/client/src/PkgSignal.h
deleted file mode 100644 (file)
index 90888c8..0000000
+++ /dev/null
@@ -1,244 +0,0 @@
-/*
- * Generated by tidlc 2.0.4.
- */
-
-#pragma once
-
-#include <app_event.h>
-#include <bundle.h>
-#include <rpc-port-parcel.h>
-
-#include <string>
-#include <vector>
-#include <memory>
-#include <mutex>
-#include <list>
-#include <atomic>
-
-
-namespace rpc_port {
-namespace PkgSignal {
-
-class Bundle final {
- public:
-  Bundle() {
-    raw_ = bundle_create();
-  }
-
-  Bundle(bundle* b) {
-    raw_ = b;
-  }
-
-  ~Bundle() {
-    if (raw_)
-      bundle_free(raw_);
-  }
-
-  Bundle(Bundle&& b) : raw_(b.raw_) {
-    b.raw_ = nullptr;
-  }
-
-  Bundle& operator = (Bundle&& b) {
-    if (this != &b) {
-      if (raw_)
-        bundle_free(raw_);
-
-      raw_ = b.raw_;
-      b.raw_ = nullptr;
-    }
-    return *this;
-  }
-
-  Bundle(const Bundle& b) : raw_(bundle_dup(b.GetHandle())) {}
-
-  Bundle& operator = (const Bundle& b) {
-    if (this != &b) {
-      if (raw_)
-        bundle_free(raw_);
-
-      raw_ = bundle_dup(b.GetHandle());
-    }
-    return *this;
-  }
-
-  bundle* GetHandle() const {
-    return raw_;
-  }
-
- private:
-  bundle* raw_;
-};
-
-class File final {
- public:
-  File() {
-  }
-
-  File(std::string filename) {
-    filename_ = filename;
-  }
-
-  std::string GetFileName() const {
-    return filename_;
-  }
-
- private:
-  std::string filename_;
-};
-
-
-class PkgInfo final {
- public:
-  PkgInfo();
-  PkgInfo(std::string Pkgid, std::string Appid, std::string PkgType);
-  
-  void SetPkgid(std::string Pkgid) {
-    Pkgid_ = std::move(Pkgid);
-  }
-
-  const std::string& GetPkgid() const {
-    return Pkgid_;
-  }
-
-  void SetAppid(std::string Appid) {
-    Appid_ = std::move(Appid);
-  }
-
-  const std::string& GetAppid() const {
-    return Appid_;
-  }
-
-  void SetPkgType(std::string PkgType) {
-    PkgType_ = std::move(PkgType);
-  }
-
-  const std::string& GetPkgType() const {
-    return PkgType_;
-  }
-
-
- private:
-  std::string Pkgid_;
-  std::string Appid_;
-  std::string PkgType_;
-
-};
-
-class PathInfo final {
- public:
-  PathInfo();
-  PathInfo(std::string Path, int State);
-  
-  void SetPath(std::string Path) {
-    Path_ = std::move(Path);
-  }
-
-  const std::string& GetPath() const {
-    return Path_;
-  }
-
-  void SetState(int State) {
-    State_ = State;
-  }
-
-  int GetState() const {
-    return State_;
-  }
-
-
- private:
-  std::string Path_;
-  int State_ = 0;
-
-};
-
-class ExtraData final {
- public:
-  ExtraData();
-  ExtraData(int ErrCode, std::vector<PathInfo> Paths);
-  
-  void SetErrCode(int ErrCode) {
-    ErrCode_ = ErrCode;
-  }
-
-  int GetErrCode() const {
-    return ErrCode_;
-  }
-
-  void SetPaths(std::vector<PathInfo> Paths) {
-    Paths_ = std::move(Paths);
-  }
-
-  const std::vector<PathInfo>& GetPaths() const {
-    return Paths_;
-  }
-
-
- private:
-  int ErrCode_ = 0;
-  std::vector<PathInfo> Paths_;
-
-};
-
-namespace group {
-
-
-class Exception {};
-class NotConnectedSocketException : public Exception {};
-class InvalidProtocolException : public Exception {};
-class InvalidIOException : public Exception {};
-class PermissionDeniedException : public Exception {};
-class InvalidIDException : public Exception {};
-
-
-class PkgSignal {
- public:
-  PkgSignal(std::string sender_appid, bool is_system = false);
-  virtual ~PkgSignal();
-
-  
-  
-  void AsyncResult(std::string signal, int targetUid, std::string reqId, std::vector<PkgInfo> pkgs, std::string key, std::string val);
-
-  virtual void OnAsyncResult(std::string signal, int targetUid, std::string reqId, std::vector<PkgInfo> pkgs, std::string key, std::string val) {}
-
-  
-  void AsyncResultForResource(std::string signal, int targetUid, std::string reqId, std::string pkgid, std::string status, ExtraData extra);
-
-  virtual void OnAsyncResultForResource(std::string signal, int targetUid, std::string reqId, std::string pkgid, std::string status, ExtraData extra) {}
-
-  
-  void AsyncResultForPkgUpgrade(std::string signal, int progress);
-
-  virtual void OnAsyncResultForPkgUpgrade(std::string signal, int progress) {}
-
-
- private:
-
-  enum class MethodId : int {
-    __Result = 0,
-    __Callback = 1,
-    AsyncResult = 2,
-    AsyncResultForResource = 3,
-    AsyncResultForPkgUpgrade = 4,
-
-  };
-
-
-  bundle* GetBundleFromParcel(rpc_port_parcel_h p, bundle* b);
-  rpc_port_parcel_h GetParcelFromBundle(bundle* b);
-  std::string GetEventName();
-  void Subscribe();
-  void Unsubscribe();
-  static void EventCb(const char* event_name, bundle* event_data, void* user_data);
-
- private:
-  event_handler_h event_handler_ = nullptr;
-  std::string sender_appid_;
-  std::recursive_mutex mutex_;
-  bool is_system_;
-};
-
-}  // namespace group
-}  // namespace PkgSignal
-}  // namespace rpc_port
diff --git a/installer/src/PkgSignal.cc b/installer/src/PkgSignal.cc
deleted file mode 100644 (file)
index 216a9e8..0000000
+++ /dev/null
@@ -1,475 +0,0 @@
-/*
- * Generated by tidlc 2.0.4.
- */
-
-#include <stdlib.h>
-#include <assert.h>
-#include <dlog.h>
-
-#include "PkgSignal.h"
-
-#ifdef LOG_TAG
-#undef LOG_TAG
-#endif
-
-#define LOG_TAG "RPC_PORT_GROUP"
-
-#ifdef _E
-#undef _E
-#endif
-
-#ifdef _W
-#undef _W
-#endif
-
-#ifdef _I
-#undef _I
-#endif
-
-#ifdef _D
-#undef _D
-#endif
-
-#define _E(fmt, ...) dlog_print(DLOG_ERROR, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _W(fmt, ...) dlog_print(DLOG_WARN, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _I(fmt, ...) dlog_print(DLOG_INFO, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-#define _D(fmt, ...) dlog_print(DLOG_DEBUG, LOG_TAG, "%s: %s(%d) > " fmt, basename(const_cast<char*>(__FILE__)), __FUNCTION__, __LINE__, ##__VA_ARGS__)
-
-#ifndef TIDL_VERSION
-#define TIDL_VERSION "2.0.4"
-#endif
-
-namespace rpc_port {
-namespace PkgSignal {
-
-PkgInfo::PkgInfo() {}
-
-PkgInfo::PkgInfo(std::string Pkgid, std::string Appid, std::string PkgType)
-    : Pkgid_(std::move(Pkgid)), Appid_(std::move(Appid)), PkgType_(std::move(PkgType)) {}
-
-
-PathInfo::PathInfo() {}
-
-PathInfo::PathInfo(std::string Path, int State)
-    : Path_(std::move(Path)), State_(std::move(State)) {}
-
-
-ExtraData::ExtraData() {}
-
-ExtraData::ExtraData(int ErrCode, std::vector<PathInfo> Paths)
-    : ErrCode_(std::move(ErrCode)), Paths_(std::move(Paths)) {}
-
-
-namespace group {
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PkgInfo& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PkgInfo& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PathInfo& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PathInfo& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const ExtraData& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, ExtraData& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<PathInfo>& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<PathInfo>& param);
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<PkgInfo>& param);
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<PkgInfo>& param);
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PkgInfo& param) {
-  rpc_port_parcel_write_string(h, param.GetPkgid().c_str());
-  rpc_port_parcel_write_string(h, param.GetAppid().c_str());
-  rpc_port_parcel_write_string(h, param.GetPkgType().c_str());
-  return h;
-}
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const PathInfo& param) {
-  rpc_port_parcel_write_string(h, param.GetPath().c_str());
-  rpc_port_parcel_write_int32(h, param.GetState());
-  return h;
-}
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const ExtraData& param) {
-  rpc_port_parcel_write_int32(h, param.GetErrCode());
-  h << param.GetPaths();
-  return h;
-}
-
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PkgInfo& param) {
-  char* Pkgid_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &Pkgid_raw);
-  std::string Pkgid(Pkgid_raw);
-  free(Pkgid_raw);
-  param.SetPkgid(std::move(Pkgid));
-
-  char* Appid_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &Appid_raw);
-  std::string Appid(Appid_raw);
-  free(Appid_raw);
-  param.SetAppid(std::move(Appid));
-
-  char* PkgType_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &PkgType_raw);
-  std::string PkgType(PkgType_raw);
-  free(PkgType_raw);
-  param.SetPkgType(std::move(PkgType));
-
-  return h;
-}
-
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, PathInfo& param) {
-  char* Path_raw  = nullptr;
-  rpc_port_parcel_read_string(h, &Path_raw);
-  std::string Path(Path_raw);
-  free(Path_raw);
-  param.SetPath(std::move(Path));
-
-  int State;
-  rpc_port_parcel_read_int32(h, &State);
-  param.SetState(State);
-
-  return h;
-}
-
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, ExtraData& param) {
-  int ErrCode;
-  rpc_port_parcel_read_int32(h, &ErrCode);
-  param.SetErrCode(ErrCode);
-
-  std::vector<PathInfo> Paths;
-  h >> Paths;
-  param.SetPaths(std::move(Paths));
-
-  return h;
-}
-
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<PathInfo>& param) {
-  rpc_port_parcel_write_array_count(h, param.size());
-  for (const auto& i : param) {
-    h << i;
-
-  }
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<PathInfo>& param) {
-  int l = 0;
-  rpc_port_parcel_read_array_count(h, &l);
-
-  for (int i = 0; i < l; i++) {
-    PathInfo v;
-    h >> v;
-
-    param.push_back(std::move(v));
-  }
-
-  return h;
-}
-
-rpc_port_parcel_h operator << (rpc_port_parcel_h h, const std::vector<PkgInfo>& param) {
-  rpc_port_parcel_write_array_count(h, param.size());
-  for (const auto& i : param) {
-    h << i;
-
-  }
-
-  return h;
-}
-
-rpc_port_parcel_h operator >> (rpc_port_parcel_h h, std::vector<PkgInfo>& param) {
-  int l = 0;
-  rpc_port_parcel_read_array_count(h, &l);
-
-  for (int i = 0; i < l; i++) {
-    PkgInfo v;
-    h >> v;
-
-    param.push_back(std::move(v));
-  }
-
-  return h;
-}
-
-PkgSignal::PkgSignal(std::string sender_appid, bool is_system)
-    : sender_appid_(std::move(sender_appid)), is_system_(is_system) {
-  Subscribe();
-}
-
-
-PkgSignal::~PkgSignal() {
-  Unsubscribe();
-}
-
-void PkgSignal::Subscribe() {
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  int ret = event_add_event_handler(GetEventName().c_str(), EventCb, this, &event_handler_);
-  if (ret != EVENT_ERROR_NONE) {
-    _E("Failed to register events. result(%d)", ret);
-    throw InvalidIOException();
-  }
-}
-
-void PkgSignal::Unsubscribe() {
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  if (event_handler_) {
-    event_remove_event_handler(event_handler_);
-    event_handler_ = nullptr;
-  }
-}
-
-bundle* PkgSignal::GetBundleFromParcel(rpc_port_parcel_h p, bundle* b) {
-  void* raw = nullptr;
-  unsigned int size = 0;
-
-  int ret = rpc_port_parcel_get_raw(p, &raw, &size);
-  if (ret != RPC_PORT_ERROR_NONE)
-    return nullptr;
-
-  ret = bundle_add_byte(b, "TIDL_RAW", raw, size);
-  if (ret != BUNDLE_ERROR_NONE)
-    return nullptr;
-
-  return b;
-}
-
-rpc_port_parcel_h PkgSignal::GetParcelFromBundle(bundle* b) {
-  void* raw = nullptr;
-  size_t size = 0;
-  rpc_port_parcel_h p;
-
-  int ret = bundle_get_byte(b, "TIDL_RAW", &raw, &size);
-  if (ret != BUNDLE_ERROR_NONE)
-    return nullptr;
-
-  ret = rpc_port_parcel_create_from_raw(&p, raw,
-      static_cast<unsigned int>(size));
-  if (ret != RPC_PORT_ERROR_NONE)
-    return nullptr;
-
-  return p;
-}
-
-std::string PkgSignal::GetEventName() {
-  if (is_system_)
-    return "tizen.system.event.tidl_iface_PkgSignal";
-  return "event." + sender_appid_ + ".tidl_iface_PkgSignal";
-}
-
-void PkgSignal::EventCb(const char* event_name, bundle* event_data, void* user_data) {
-  auto* ptr = static_cast<PkgSignal*>(user_data);
-  rpc_port_parcel_h p = ptr->GetParcelFromBundle(event_data);
-  if (p == nullptr) {
-    _E("Invalid bundle");
-    return;
-  }
-
-  std::unique_ptr<std::remove_pointer<rpc_port_parcel_h>::type,
-      decltype(rpc_port_parcel_destroy)*> p_auto(p, rpc_port_parcel_destroy);
-
-  rpc_port_parcel_h header;
-  int seq_num = -1;
-  int cmd;
-  rpc_port_parcel_get_header(p, &header);
-  rpc_port_parcel_header_get_seq_num(header, &seq_num);
-
-  _W("[Sequence] %d", seq_num);
-  rpc_port_parcel_read_int32(p, &cmd);
-  switch (cmd) {
-
-    case static_cast<int>(MethodId::AsyncResult):
-    {
-      char* param1_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param1_raw);
-      std::string param1(param1_raw);
-      free(param1_raw);
-      int param2;
-      rpc_port_parcel_read_int32(p, &param2);
-      char* param3_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param3_raw);
-      std::string param3(param3_raw);
-      free(param3_raw);
-      std::vector<PkgInfo> param4;
-      p >> param4;
-      char* param5_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param5_raw);
-      std::string param5(param5_raw);
-      free(param5_raw);
-      char* param6_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param6_raw);
-      std::string param6(param6_raw);
-      free(param6_raw);
-      ptr->OnAsyncResult(param1, param2, param3, param4, param5, param6);
-
-    }
-    break;
-
-
-    case static_cast<int>(MethodId::AsyncResultForResource):
-    {
-      char* param1_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param1_raw);
-      std::string param1(param1_raw);
-      free(param1_raw);
-      int param2;
-      rpc_port_parcel_read_int32(p, &param2);
-      char* param3_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param3_raw);
-      std::string param3(param3_raw);
-      free(param3_raw);
-      char* param4_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param4_raw);
-      std::string param4(param4_raw);
-      free(param4_raw);
-      char* param5_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param5_raw);
-      std::string param5(param5_raw);
-      free(param5_raw);
-      ExtraData param6;
-      p >> param6;
-      ptr->OnAsyncResultForResource(param1, param2, param3, param4, param5, param6);
-
-    }
-    break;
-
-
-    case static_cast<int>(MethodId::AsyncResultForPkgUpgrade):
-    {
-      char* param1_raw  = nullptr;
-      rpc_port_parcel_read_string(p, &param1_raw);
-      std::string param1(param1_raw);
-      free(param1_raw);
-      int param2;
-      rpc_port_parcel_read_int32(p, &param2);
-      ptr->OnAsyncResultForPkgUpgrade(param1, param2);
-
-    }
-    break;
-
-
-
-    default:
-      _E("Unknown command(%d)", cmd);
-  }
-}
-
-
-void PkgSignal::AsyncResult(std::string signal, int targetUid, std::string reqId, std::vector<PkgInfo> pkgs, std::string key, std::string val) {
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-  std::unique_ptr<std::remove_pointer<rpc_port_parcel_h>::type,
-      decltype(rpc_port_parcel_destroy)*> p_auto(p, rpc_port_parcel_destroy);
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::AsyncResult));
-  rpc_port_parcel_write_string(p, signal.c_str());
-  rpc_port_parcel_write_int32(p, targetUid);
-  rpc_port_parcel_write_string(p, reqId.c_str());
-  p << pkgs;
-  rpc_port_parcel_write_string(p, key.c_str());
-  rpc_port_parcel_write_string(p, val.c_str());
-
-
-  // Send
-  bundle* b = bundle_create();
-  std::unique_ptr<bundle, decltype(bundle_free)*> b_auto(b, bundle_free);
-  if (GetBundleFromParcel(p, b) == nullptr) {
-    _E("Failed to make bundle from parcel");
-    throw InvalidIOException();
-  }
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  int ret = event_publish_app_event(GetEventName().c_str(), b);
-  if (ret != EVENT_ERROR_NONE) {
-    _E("Failed to publish event. result(%d)", ret);
-    throw InvalidIOException();
-  }
-}
-
-void PkgSignal::AsyncResultForResource(std::string signal, int targetUid, std::string reqId, std::string pkgid, std::string status, ExtraData extra) {
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-  std::unique_ptr<std::remove_pointer<rpc_port_parcel_h>::type,
-      decltype(rpc_port_parcel_destroy)*> p_auto(p, rpc_port_parcel_destroy);
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::AsyncResultForResource));
-  rpc_port_parcel_write_string(p, signal.c_str());
-  rpc_port_parcel_write_int32(p, targetUid);
-  rpc_port_parcel_write_string(p, reqId.c_str());
-  rpc_port_parcel_write_string(p, pkgid.c_str());
-  rpc_port_parcel_write_string(p, status.c_str());
-  p << extra;
-
-
-  // Send
-  bundle* b = bundle_create();
-  std::unique_ptr<bundle, decltype(bundle_free)*> b_auto(b, bundle_free);
-  if (GetBundleFromParcel(p, b) == nullptr) {
-    _E("Failed to make bundle from parcel");
-    throw InvalidIOException();
-  }
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  int ret = event_publish_app_event(GetEventName().c_str(), b);
-  if (ret != EVENT_ERROR_NONE) {
-    _E("Failed to publish event. result(%d)", ret);
-    throw InvalidIOException();
-  }
-}
-
-void PkgSignal::AsyncResultForPkgUpgrade(std::string signal, int progress) {
-  rpc_port_parcel_h p;
-  rpc_port_parcel_create(&p);
-  std::unique_ptr<std::remove_pointer<rpc_port_parcel_h>::type,
-      decltype(rpc_port_parcel_destroy)*> p_auto(p, rpc_port_parcel_destroy);
-  rpc_port_parcel_header_h header_;
-  rpc_port_parcel_get_header(p, &header_);
-  rpc_port_parcel_header_set_tag(header_, TIDL_VERSION);
-  int seq_num_ = -1;
-  rpc_port_parcel_header_get_seq_num(header_, &seq_num_);
-  _W("[Version] \"%s\", [Sequence] %d", TIDL_VERSION, seq_num_);
-  rpc_port_parcel_write_int32(p, static_cast<int>(MethodId::AsyncResultForPkgUpgrade));
-  rpc_port_parcel_write_string(p, signal.c_str());
-  rpc_port_parcel_write_int32(p, progress);
-
-
-  // Send
-  bundle* b = bundle_create();
-  std::unique_ptr<bundle, decltype(bundle_free)*> b_auto(b, bundle_free);
-  if (GetBundleFromParcel(p, b) == nullptr) {
-    _E("Failed to make bundle from parcel");
-    throw InvalidIOException();
-  }
-
-  std::lock_guard<std::recursive_mutex> lock(mutex_);
-  int ret = event_publish_app_event(GetEventName().c_str(), b);
-  if (ret != EVENT_ERROR_NONE) {
-    _E("Failed to publish event. result(%d)", ret);
-    throw InvalidIOException();
-  }
-}
-}  // namespace group
-}  // namespace PkgSignal
-}  // namespace rpc_port
diff --git a/installer/src/PkgSignal.h b/installer/src/PkgSignal.h
deleted file mode 100644 (file)
index 90888c8..0000000
+++ /dev/null
@@ -1,244 +0,0 @@
-/*
- * Generated by tidlc 2.0.4.
- */
-
-#pragma once
-
-#include <app_event.h>
-#include <bundle.h>
-#include <rpc-port-parcel.h>
-
-#include <string>
-#include <vector>
-#include <memory>
-#include <mutex>
-#include <list>
-#include <atomic>
-
-
-namespace rpc_port {
-namespace PkgSignal {
-
-class Bundle final {
- public:
-  Bundle() {
-    raw_ = bundle_create();
-  }
-
-  Bundle(bundle* b) {
-    raw_ = b;
-  }
-
-  ~Bundle() {
-    if (raw_)
-      bundle_free(raw_);
-  }
-
-  Bundle(Bundle&& b) : raw_(b.raw_) {
-    b.raw_ = nullptr;
-  }
-
-  Bundle& operator = (Bundle&& b) {
-    if (this != &b) {
-      if (raw_)
-        bundle_free(raw_);
-
-      raw_ = b.raw_;
-      b.raw_ = nullptr;
-    }
-    return *this;
-  }
-
-  Bundle(const Bundle& b) : raw_(bundle_dup(b.GetHandle())) {}
-
-  Bundle& operator = (const Bundle& b) {
-    if (this != &b) {
-      if (raw_)
-        bundle_free(raw_);
-
-      raw_ = bundle_dup(b.GetHandle());
-    }
-    return *this;
-  }
-
-  bundle* GetHandle() const {
-    return raw_;
-  }
-
- private:
-  bundle* raw_;
-};
-
-class File final {
- public:
-  File() {
-  }
-
-  File(std::string filename) {
-    filename_ = filename;
-  }
-
-  std::string GetFileName() const {
-    return filename_;
-  }
-
- private:
-  std::string filename_;
-};
-
-
-class PkgInfo final {
- public:
-  PkgInfo();
-  PkgInfo(std::string Pkgid, std::string Appid, std::string PkgType);
-  
-  void SetPkgid(std::string Pkgid) {
-    Pkgid_ = std::move(Pkgid);
-  }
-
-  const std::string& GetPkgid() const {
-    return Pkgid_;
-  }
-
-  void SetAppid(std::string Appid) {
-    Appid_ = std::move(Appid);
-  }
-
-  const std::string& GetAppid() const {
-    return Appid_;
-  }
-
-  void SetPkgType(std::string PkgType) {
-    PkgType_ = std::move(PkgType);
-  }
-
-  const std::string& GetPkgType() const {
-    return PkgType_;
-  }
-
-
- private:
-  std::string Pkgid_;
-  std::string Appid_;
-  std::string PkgType_;
-
-};
-
-class PathInfo final {
- public:
-  PathInfo();
-  PathInfo(std::string Path, int State);
-  
-  void SetPath(std::string Path) {
-    Path_ = std::move(Path);
-  }
-
-  const std::string& GetPath() const {
-    return Path_;
-  }
-
-  void SetState(int State) {
-    State_ = State;
-  }
-
-  int GetState() const {
-    return State_;
-  }
-
-
- private:
-  std::string Path_;
-  int State_ = 0;
-
-};
-
-class ExtraData final {
- public:
-  ExtraData();
-  ExtraData(int ErrCode, std::vector<PathInfo> Paths);
-  
-  void SetErrCode(int ErrCode) {
-    ErrCode_ = ErrCode;
-  }
-
-  int GetErrCode() const {
-    return ErrCode_;
-  }
-
-  void SetPaths(std::vector<PathInfo> Paths) {
-    Paths_ = std::move(Paths);
-  }
-
-  const std::vector<PathInfo>& GetPaths() const {
-    return Paths_;
-  }
-
-
- private:
-  int ErrCode_ = 0;
-  std::vector<PathInfo> Paths_;
-
-};
-
-namespace group {
-
-
-class Exception {};
-class NotConnectedSocketException : public Exception {};
-class InvalidProtocolException : public Exception {};
-class InvalidIOException : public Exception {};
-class PermissionDeniedException : public Exception {};
-class InvalidIDException : public Exception {};
-
-
-class PkgSignal {
- public:
-  PkgSignal(std::string sender_appid, bool is_system = false);
-  virtual ~PkgSignal();
-
-  
-  
-  void AsyncResult(std::string signal, int targetUid, std::string reqId, std::vector<PkgInfo> pkgs, std::string key, std::string val);
-
-  virtual void OnAsyncResult(std::string signal, int targetUid, std::string reqId, std::vector<PkgInfo> pkgs, std::string key, std::string val) {}
-
-  
-  void AsyncResultForResource(std::string signal, int targetUid, std::string reqId, std::string pkgid, std::string status, ExtraData extra);
-
-  virtual void OnAsyncResultForResource(std::string signal, int targetUid, std::string reqId, std::string pkgid, std::string status, ExtraData extra) {}
-
-  
-  void AsyncResultForPkgUpgrade(std::string signal, int progress);
-
-  virtual void OnAsyncResultForPkgUpgrade(std::string signal, int progress) {}
-
-
- private:
-
-  enum class MethodId : int {
-    __Result = 0,
-    __Callback = 1,
-    AsyncResult = 2,
-    AsyncResultForResource = 3,
-    AsyncResultForPkgUpgrade = 4,
-
-  };
-
-
-  bundle* GetBundleFromParcel(rpc_port_parcel_h p, bundle* b);
-  rpc_port_parcel_h GetParcelFromBundle(bundle* b);
-  std::string GetEventName();
-  void Subscribe();
-  void Unsubscribe();
-  static void EventCb(const char* event_name, bundle* event_data, void* user_data);
-
- private:
-  event_handler_h event_handler_ = nullptr;
-  std::string sender_appid_;
-  std::recursive_mutex mutex_;
-  bool is_system_;
-};
-
-}  // namespace group
-}  // namespace PkgSignal
-}  // namespace rpc_port
index b38b236..c708a80 100644 (file)
@@ -39,6 +39,7 @@ BuildRequires:  pkgconfig(gmock)
 BuildRequires:  pkgmgr-info-parser-devel
 BuildRequires:  pkgmgr-info-parser
 BuildRequires:  fdupes
+BuildRequires:  tidl
 
 %description
 Packager Manager client library package for packaging
@@ -89,6 +90,11 @@ 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
 MAJORVER=`echo %{version} | awk 'BEGIN {FS="."}{print $1}'`