break;
+ case static_cast<int>(MethodId::AsyncResultForPkgUpgrade):
+ {
+ char* param1_raw = nullptr;
+ rpc_port_parcel_read_string(p, ¶m1_raw);
+ std::string param1(param1_raw);
+ free(param1_raw);
+ int param2;
+ rpc_port_parcel_read_int32(p, ¶m2);
+ ptr->OnAsyncResultForPkgUpgrade(param1, param2);
+
+ }
+ break;
+
+
default:
_E("Unknown command(%d)", cmd);
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
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:
__Callback = 1,
AsyncResult = 2,
AsyncResultForResource = 3,
+ AsyncResultForPkgUpgrade = 4,
};
API int pkgmgr_client_listen_pkg_upgrade_status(pkgmgr_client *pc,
pkgmgr_pkg_upgrade_handler event_cb, void *data) {
- //TODO
- return PKGMGR_R_OK;
+ Connector* con = static_cast<Connector*>(pc);
+ if (con->GetPcType() != PC_LISTENING) {
+ _E("client->pc_type is not PC_LISTENING");
+ return PKGMGR_R_EINVAL;
+ }
+
+ try {
+ const auto& receiver = con->GetSignalReceiver();
+ return receiver->AddEventHandler(event_cb, data);
+ } catch (...) {
+ _E("Exception occured");
+ return PKGMGR_R_ERROR;
+ }
}
API int pkgmgr_client_usr_mount_install_packages(pkgmgr_client *pc,
HandleGlobalResHandler(signal, targetUid, reqId, pkgid, status, extra);
}
+void SignalReceiver::OnAsyncResultForPkgUpgrade(
+ std::string signal, int progress) {
+ for (const auto& [id, cb, data] : global_pkg_upgrade_handlers_) {
+ cb(progress, data);
+ }
+}
+
void SignalReceiver::HandleResHandler(const std::string& signal,
int targetUid, const std::string& reqId, const std::string& pkgid,
const std::string& status, pkg_signal::ExtraData& extra) const {
return sId;
}
+int SignalReceiver::AddEventHandler(pkgmgr_pkg_upgrade_handler event_cb,
+ void* data) {
+ int sId = SignalReceiver::GetRequestId();
+ global_pkg_upgrade_handlers_.emplace_back(sId, event_cb, data);
+ return sId;
+}
+
int SignalReceiver::GetRequestId() {
return ++request_id_;
std::string reqId, std::string pkgid, std::string status,
pkg_signal::ExtraData extra) override;
+ void OnAsyncResultForPkgUpgrade(std::string signal, int progress) override;
+
int AddEventHandler(std::string req_key, pkgmgr_handler event_cb, void* data);
int AddEventHandler(std::string req_key, pkgmgr_app_handler app_event_cb,
void* data);
pkgmgr_pkg_size_info_receive_cb event_cb, void* pc, void* data);
int AddEventHandler(std::string req_key, pkgmgr_res_handler event_cb,
void* data);
+ int AddEventHandler(pkgmgr_pkg_upgrade_handler event_cb, void* data);
private:
static int GetRequestId();
std::map<std::string,
std::tuple<int, pkgmgr_pkg_size_info_receive_cb, void*, void*>> size_info_handlers_;
std::list<std::tuple<int, pkgmgr_pkg_size_info_receive_cb, void*, void*>> global_size_info_handlers_;
+ std::list<std::tuple<int, pkgmgr_pkg_upgrade_handler, void*>> global_pkg_upgrade_handlers_;
};
} // namespace client
break;
+ case static_cast<int>(MethodId::AsyncResultForPkgUpgrade):
+ {
+ char* param1_raw = nullptr;
+ rpc_port_parcel_read_string(p, ¶m1_raw);
+ std::string param1(param1_raw);
+ free(param1_raw);
+ int param2;
+ rpc_port_parcel_read_int32(p, ¶m2);
+ ptr->OnAsyncResultForPkgUpgrade(param1, param2);
+
+ }
+ break;
+
+
default:
_E("Unknown command(%d)", cmd);
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
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:
__Callback = 1,
AsyncResult = 2,
AsyncResultForResource = 3,
+ AsyncResultForPkgUpgrade = 4,
};
#include "pkgmgr_installer.h"
#include "pkgmgr_installer_debug.h"
+#include "pkgmgr_installer_error.h"
#include "pkgmgr_installer_info.h"
#include <tzplatform_config.h>
do { if (nullptr == pi) return (r); } while (0)
static uid_t g_target_uid;
+static int g_debug_mode;
+static int g_skip_optimization;
+static pkgmgr_privilege_level g_privilege_level = PM_PRIVILEGE_UNKNOWN;
API pkgmgr_installer* pkgmgr_installer_new() {
try {
cls->GetRequest()->SetUid(tzplatform_getuid(TZ_SYS_GLOBALAPP_USER));
g_target_uid = cls->GetRequest()->GetUid();
+ g_debug_mode = cls->GetRequest()->IsDebugMode() ? 1 : 0;
+ g_skip_optimization = cls->GetRequest()->IsSkipOptimization() ? 1 : 0;
return 0;
}
}
API int pkgmgr_installer_set_privilege_level(pkgmgr_privilege_level level) {
- //TODO
+ g_privilege_level = level;
+
return 0;
}
API int pkgmgr_installer_info_get_privilege_level(
pkgmgr_privilege_level *level) {
- //TODO
+ *level = g_privilege_level;
+
return 0;
}
API int pkgmgr_installer_info_get_debug_mode(int *debug_mode) {
- //TODO
+ *debug_mode = g_debug_mode;
+
return 0;
}
API int pkgmgr_installer_info_get_skip_optimization(int *skip_optimization) {
- //TODO
+ *skip_optimization = g_skip_optimization;
+
return 0;
}
+#define CASE_TO_STR(ERRCODE) case ERRCODE: return ERRCODE##_STR
API const char* pkgmgr_installer_error_to_string(int error_code) {
- //TODO
- return nullptr;
+ switch (error_code) {
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GLOBALSYMLINK_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_GRANT_PERMISSION_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_IMAGE_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_UNZIP_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SECURITY_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_REGISTER_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PRIVILEGE_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PARSE_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_RECOVERY_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_DELTA_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_APP_DIR_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CONFIG_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_SIGNATURE_INVALID);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_CERT_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_MATCH);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_AUTHOR_CERT_NOT_FOUND);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ICON_NOT_FOUND);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_MANIFEST_NOT_FOUND);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_PACKAGE_NOT_FOUND);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OPERATION_NOT_ALLOWED);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OUT_OF_SPACE);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_INVALID_VALUE);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_ERROR);
+ CASE_TO_STR(PKGMGR_INSTALLER_ERRCODE_OK);
+ default:
+ return PKGMGR_INSTALLER_ERRCODE_UNDEFINED_ERROR_STR;
+ }
}
API int pkgmgr_installer_add_pkg(pkgmgr_installer *pi,
}
API int pkgmgr_installer_set_is_upgrade(pkgmgr_installer *pi, int is_upgrade) {
- //TODO
+ if (pi == NULL)
+ return -1;
+
+ auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+ if (!cls->GetRequest())
+ return -1;
+
+ cls->GetRequest()->SetUpgrade(is_upgrade);
return 0;
}
API int pkgmgr_installer_send_pkg_upgrade_signal(pkgmgr_installer *pi,
unsigned int progress) {
- //TODO
- return 0;
+ if (!pi) {
+ _E("invalid argument");
+ return -1;
+ }
+
+ auto* cls = static_cast<pkgmgr::installer::Control*>(pi);
+ if (!cls->GetRequest())
+ return -1;
+
+ return cls->SendSignalForPkgUpgrade(progress);
}
}
}
+int Control::SendSignalForPkgUpgrade(int progress) {
+ if (!signal_) {
+ _E("offline mode");
+ return -1;
+ }
+
+ try {
+ signal_->AsyncResultForPkgUpgrade(
+ PKGMGR_INSTALLER_PKG_UPGRADE_EVENT_STR, progress);
+ return 0;
+ } catch (...) {
+ _E("Exception occured");
+ return -1;
+ }
+}
+
static int __send_signal_to_agent(uid_t uid, void* data, size_t len) {
int fd;
struct sockaddr_un sa;
int SendSignals(std::string key, std::string val);
int SendSignalForResource(std::string pkgid, std::string status,
rpc_port::PkgSignal::ExtraData* event_info);
+ int SendSignalForPkgUpgrade(int progress);
int SendSignalForUid(uid_t uid, std::string pkg_type, std::string pkgid,
std::string appid, std::string key, std::string val);
int SendSignalsForUid(uid_t uid, std::string key, std::string val);
{
void AsyncResult(string signal, int targetUid, string reqId, array<PkgInfo> pkgs, string key, string val) async;
void AsyncResultForResource(string signal, int targetUid, string reqId, string pkgid, string status, ExtraData extra) async;
+ void AsyncResultForPkgUpgrade(string signal, int progress) async;
}
projects / platform / core / appfw / slp-pkgmgr.git / commitdiff