#include "pkgmgrinfo_internal.h"
-static void __free_applications(gpointer data)
+static int __free_applications(gpointer key,
+ gpointer value, gpointer user_data)
{
- pkgmgrinfo_basic_free_application((application_x *)data);
+ pkgmgrinfo_basic_free_application((application_x *)value);
}
static void __parse_appcontrol(GList **appcontrol, char *appcontrol_str,
return PMINFO_R_EINVAL;
}
- list = g_hash_table_new_full(g_str_hash, g_str_equal, NULL,
- __free_applications);
+ list = g_hash_table_new(g_str_hash, g_str_equal);
if (list == NULL)
return PMINFO_R_ERROR;
PMINFO_APPINFO_GET_ALL, list);
if (ret != PMINFO_R_OK) {
+ g_hash_table_foreach_remove(list, __free_applications, NULL);
g_hash_table_destroy(list);
return ret;
}
AbstractDBHandler(uid_t uid);
virtual ~AbstractDBHandler();
virtual bool Execute() = 0;
+ void SetLocale(const std::string& locale);
protected:
bool Connect();
std::string GetLocale();
void SetOpType(OperationType type);
void SetDBType(DBType type);
- void SetLocale(const std::string& locale);
private:
std::string GetDBPath();
#include "pkgmgrinfo_internal.h"
-#include <list>
-
namespace {
void _move(gpointer key, gpointer value, gpointer user_data) {
application_x* appinfo = static_cast<application_x*>(value);
- std::list<application_x*>* app_list = static_cast<std::list<application_x*>*>(user_data);
+ std::vector<application_x*>* app_list = static_cast<std::vector<application_x*>*>(user_data);
app_list->emplace_back(appinfo);
}
AppInfoDBHandler::~AppInfoDBHandler() {}
-std::list<application_x*> AppInfoDBHandler::GetAppHandle() {
- return handle_list_;
+std::vector<application_x*> AppInfoDBHandler::GetAppHandle() {
+ return std::move(handle_list_);
}
void AppInfoDBHandler::SetFilter(pkgmgrinfo_filter_x* filter) {
}
g_hash_table_foreach(list, _move, &handle_list_);
+ g_hash_table_destroy(list);
return true;
}
#ifndef APPINFO_DB_HANDLER_HH_
#define APPINFO_DB_HANDLER_HH_
-#include <list>
+#include <vector>
#include <sys/types.h>
public:
AppInfoDBHandler(uid_t uid);
~AppInfoDBHandler();
- std::list<application_x*> GetAppHandle();
+ std::vector<application_x*> GetAppHandle();
void SetFilter(pkgmgrinfo_filter_x* filter);
bool Execute() override;
private:
pkgmgrinfo_filter_x* filter_ = nullptr;
- std::list<application_x*> handle_list_;
+ std::vector<application_x*> handle_list_;
uid_t uid_;
};
void _move(gpointer key, gpointer value, gpointer user_data) {
package_x* appinfo = static_cast<package_x*>(value);
- std::list<package_x*>* app_list = static_cast<std::list<package_x*>*>(user_data);
+ std::vector<package_x*>* app_list = static_cast<std::vector<package_x*>*>(user_data);
app_list->emplace_back(appinfo);
}
PkgGetDBHandler::~PkgGetDBHandler() {}
-std::list<package_x*> PkgGetDBHandler::GetPkgHandle() { return handle_list_; }
+std::vector<package_x*> PkgGetDBHandler::GetPkgHandle() {
+ return std::move(handle_list_);
+}
void PkgGetDBHandler::SetFilter(pkgmgrinfo_filter_x* filter) {
filter_ = filter;
}
g_hash_table_foreach(list, _move, &handle_list_);
+ g_hash_table_destroy(list);
+
return true;
}
#ifndef PKG_GET_DB_HANDLER_HH_
#define PKG_GET_DB_HANDLER_HH_
-#include <list>
+#include <vector>
#include <sys/types.h>
public:
PkgGetDBHandler(uid_t uid);
~PkgGetDBHandler();
- std::list<package_x*> GetPkgHandle();
+ std::vector<package_x*> GetPkgHandle();
void SetFilter(pkgmgrinfo_filter_x* filter);
bool Execute() override;
private:
pkgmgrinfo_filter_x* filter_ = nullptr;
- std::list<package_x*> handle_list_;
+ std::vector<package_x*> handle_list_;
uid_t uid_;
};
#define SERVER_ABSTRACT_REQUEST_HANDLER_HH_
#include <string>
+#include <parcel.hh>
namespace pkgmgr_server {
namespace request_handler {
class EXPORT_API AbstractRequestHandler {
public:
virtual ~AbstractRequestHandler() = default;
- virtual bool HandleRequest(std::string data, std::string locale) = 0;
+ virtual bool HandleRequest(unsigned char* data, int size, std::string locale) = 0;
- virtual std::string GetResult() = 0;
+ virtual std::vector<uint8_t> GetResult() = 0;
};
} // namespace request_handler
// Use of this source code is governed by an apache-2.0 license that can be
// found in the LICENSE file.
+#include "../common/parcel/parcelable_factory.hh"
+#include "../common/parcel/filter_parcelable.hh"
+#include "../common/database/appinfo_db_handler.hh"
#include "get_appinfo_request_handler.hh"
#include <string>
+using namespace pkgmgr_common::parcel;
+using namespace pkgmgr_common::database;
+
namespace pkgmgr_server {
namespace request_handler {
-bool GetAppinfoRequestHandler::HandleRequest(std::string data,
- std::string locale) {
+bool GetAppinfoRequestHandler::HandleRequest(unsigned char* data, int size, std::string locale) {
+ auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+
+ if (abstract_parcel->GetType() != ParcelableType::Filter)
+ return false;
+
+ auto* parcel = dynamic_cast<FilterParcelable*>(abstract_parcel.get());
+
+ AppInfoDBHandler db(parcel->GetUid());
+ db.SetLocale(locale);
+ db.SetFilter(const_cast<pkgmgrinfo_filter_x*>(parcel->GetFilter()));
+ if (db.Execute() == false)
+ return false;
+
+ result_ = std::make_shared<AppInfoParcelable>(db.GetAppHandle());
+
return true;
}
-std::string GetAppinfoRequestHandler::GetResult() {
- std::string tmp_result("tmp_result");
+std::vector<uint8_t> GetAppinfoRequestHandler::GetResult() {
+ tizen_base::Parcel parcel;
+
+ result_->WriteToParcel(&parcel);
+ std::vector<uint8_t> raw = parcel.GetRaw();
- return tmp_result;
+ return raw;
}
} // namespace request_handler
#define SERVER_GET_APPINFO_REQUEST_HANDLER_HH_
#include "abstract_request_handler.hh"
+#include "../common/parcel/appinfo_parcelable.hh"
#include <string>
class EXPORT_API GetAppinfoRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(std::string data, std::string locale) override;
+ bool HandleRequest(unsigned char* data, int size, std::string locale) override;
- std::string GetResult() override;
+ std::vector<uint8_t> GetResult() override;
+
+ private:
+ std::shared_ptr<pkgmgr_common::parcel::AppInfoParcelable> result_;
};
} // namespace request_handler
// found in the LICENSE file.
#include "get_cert_request_handler.hh"
+#include "../common/parcel/parcelable_factory.hh"
+#include "../common/database/cert_get_db_handler.hh"
#include <string>
+using namespace pkgmgr_common::parcel;
+using namespace pkgmgr_common::database;
+
namespace pkgmgr_server {
namespace request_handler {
-bool GetCertRequestHandler::HandleRequest(std::string data,
- std::string locale) {
+bool GetCertRequestHandler::HandleRequest(unsigned char* data, int size, std::string locale) {
+ auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+
+ if (abstract_parcel->GetType() != ParcelableType::CertInfo)
+ return false;
+
+ auto* parcel = dynamic_cast<CertInfoParcelable*>(abstract_parcel.get());
+
+ CertGetDBHandler db(parcel->GetUid());
+ db.SetLocale(locale);
+
+// TODO: db.SetPkgID();
+
+ if (db.Execute() == false)
+ return false;
+
+ result_ = std::make_shared<CertInfoParcelable>(parcel->GetUid(), db.GetCertHandle());
+
return true;
}
-std::string GetCertRequestHandler::GetResult() {
- std::string tmp_result("tmp_result");
+std::vector<uint8_t> GetCertRequestHandler::GetResult() {
+ tizen_base::Parcel parcel;
+
+ result_->WriteToParcel(&parcel);
+ std::vector<uint8_t> raw = parcel.GetRaw();
- return tmp_result;
+ return raw;
}
} // namespace request_handler
#define SERVER_GET_CERT_REQUEST_HANDLER_HH_
#include "abstract_request_handler.hh"
+#include "../common/parcel/certinfo_parcelable.hh"
#include <string>
class EXPORT_API GetCertRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(std::string data, std::string locale) override;
+ bool HandleRequest(unsigned char* data, int size, std::string locale) override;
- std::string GetResult() override;
+ std::vector<uint8_t> GetResult() override;
+
+ private:
+ std::shared_ptr<pkgmgr_common::parcel::CertInfoParcelable> result_;
};
} // namespace request_handler
// Use of this source code is governed by an apache-2.0 license that can be
// found in the LICENSE file.
+#include "../common/parcel/parcelable_factory.hh"
+#include "../common/parcel/filter_parcelable.hh"
+#include "../common/database/pkg_get_db_handler.hh"
#include "get_pkginfo_request_handler.hh"
#include <string>
+using namespace pkgmgr_common::parcel;
+using namespace pkgmgr_common::database;
+
namespace pkgmgr_server {
namespace request_handler {
-bool GetPkginfoRequestHandler::HandleRequest(std::string data,
- std::string locale) {
+bool GetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size, std::string locale) {
+ auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+
+ if (abstract_parcel->GetType() != ParcelableType::Filter)
+ return false;
+
+ auto* parcel = dynamic_cast<FilterParcelable*>(abstract_parcel.get());
+
+ PkgGetDBHandler db(parcel->GetUid());
+ db.SetLocale(locale);
+ db.SetFilter(const_cast<pkgmgrinfo_filter_x*>(parcel->GetFilter()));
+ if (db.Execute() == false)
+ return false;
+
+ result_ = std::make_shared<PkgInfoParcelable>(db.GetPkgHandle());
+
return true;
}
-std::string GetPkginfoRequestHandler::GetResult() {
- std::string tmp_result("tmp_result");
+std::vector<uint8_t> GetPkginfoRequestHandler::GetResult() {
+ tizen_base::Parcel parcel;
+
+ result_->WriteToParcel(&parcel);
+ std::vector<uint8_t> raw = parcel.GetRaw();
- return tmp_result;
+ return raw;
}
} // namespace request_handler
#define SERVER_GET_PKGINFO_REQUEST_HANDLER_HH_
#include "abstract_request_handler.hh"
+#include "../common/parcel/pkginfo_parcelable.hh"
#include <string>
class EXPORT_API GetPkginfoRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(std::string data, std::string locale) override;
+ bool HandleRequest(unsigned char* data, int size, std::string locale) override;
+
+ std::vector<uint8_t> GetResult() override;
+
+ private:
+ std::shared_ptr<pkgmgr_common::parcel::PkgInfoParcelable> result_;
- std::string GetResult() override;
};
} // namespace request_handler
// found in the LICENSE file.
#include "query_request_handler.hh"
+#include "../common/parcel/parcelable_factory.hh"
+#include "../common/parcel/query_parcelable.hh"
+#include "../common/database/query_handler.hh"
#include <string>
+using namespace pkgmgr_common::parcel;
+using namespace pkgmgr_common::database;
+
namespace pkgmgr_server {
namespace request_handler {
-bool QueryRequestHandler::HandleRequest(std::string data, std::string locale) {
+bool QueryRequestHandler::HandleRequest(unsigned char* data, int size, std::string locale) {
+ auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+
+ if (abstract_parcel->GetType() != ParcelableType::Query)
+ return false;
+
+ auto* parcel = dynamic_cast<QueryParcelable*>(abstract_parcel.get());
+
+ QueryHandler db(parcel->GetUid());
+ db.SetLocale(locale);
+ db.SetQuery(parcel->GetQuery());
+ if (db.Execute() == false)
+ return false;
+
+ // TODO: result_ = std::make_shared<ResultParcelable>(db.GetString());
+
return true;
}
-std::string QueryRequestHandler::GetResult() {
- std::string tmp_result("tmp_result");
+std::vector<uint8_t> QueryRequestHandler::GetResult() {
+ tizen_base::Parcel parcel;
+
+ result_->WriteToParcel(&parcel);
+ std::vector<uint8_t> raw = parcel.GetRaw();
- return tmp_result;
+ return raw;
}
} // namespace request_handler
#define SERVER_QUERY_REQUEST_HANDLER_HH_
#include "abstract_request_handler.hh"
+#include "../common/parcel/result_parcelable.hh"
+
#include <string>
class EXPORT_API QueryRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(std::string data, std::string locale) override;
+ bool HandleRequest(unsigned char* data, int size, std::string locale) override;
+
+ std::vector<uint8_t> GetResult() override;
+
+private:
+ std::shared_ptr<pkgmgr_common::parcel::ResultParcelable> result_;
- std::string GetResult() override;
};
} // namespace request_handler
// found in the LICENSE file.
#include "set_cert_request_handler.hh"
+#include "../common/parcel/parcelable_factory.hh"
+#include "../common/parcel/certinfo_parcelable.hh"
+#include "../common/database/cert_set_db_handler.hh"
#include <string>
+using namespace pkgmgr_common::parcel;
+using namespace pkgmgr_common::database;
+
namespace pkgmgr_server {
namespace request_handler {
-bool SetCertRequestHandler::HandleRequest(std::string data,
- std::string locale) {
+bool SetCertRequestHandler::HandleRequest(unsigned char* data, int size, std::string locale) {
+ auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+
+ if (abstract_parcel->GetType() != ParcelableType::CertInfo)
+ return false;
+
+ auto* parcel = dynamic_cast<CertInfoParcelable*>(abstract_parcel.get());
+
+ CertSetDBHandler db(parcel->GetUid());
+ db.SetLocale(locale);
+ db.SetCertHandle(const_cast<pkgmgr_certinfo_x*>(parcel->GetCertInfo()));
+
+ if (db.Execute() == false)
+ return false;
+
return true;
}
-std::string SetCertRequestHandler::GetResult() {
- std::string tmp_result("tmp_result");
-
- return tmp_result;
+std::vector<uint8_t> SetCertRequestHandler::GetResult() {
+ return std::vector<uint8_t>('0');
}
} // namespace request_handler
class EXPORT_API SetCertRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(std::string data, std::string locale) override;
+ bool HandleRequest(unsigned char* data, int size, std::string locale) override;
- std::string GetResult() override;
+ std::vector<uint8_t> GetResult() override;
};
} // namespace request_handler
// found in the LICENSE file.
#include "set_pkginfo_request_handler.hh"
+#include "../common/parcel/parcelable_factory.hh"
+#include "../common/parcel/pkginfo_parcelable.hh"
+#include "../common/database/pkg_set_db_handler.hh"
#include <string>
+using namespace pkgmgr_common::parcel;
+using namespace pkgmgr_common::database;
+
namespace pkgmgr_server {
namespace request_handler {
-bool SetPkginfoRequestHandler::HandleRequest(std::string data,
- std::string locale) {
+bool SetPkginfoRequestHandler::HandleRequest(unsigned char* data, int size, std::string locale) {
+ auto abstract_parcel = ParcelableFactory::GetInst().CreateParcel(data, size);
+
+ if (abstract_parcel->GetType() != ParcelableType::PkgInfo)
+ return false;
+
+ auto* parcel = dynamic_cast<PkgInfoParcelable*>(abstract_parcel.get());
+
+ PkgSetDBHandler db(parcel->GetUid());
+ db.SetLocale(locale);
+
+ for (auto& i : parcel->GetPkgInfo()) {
+ db.SetPkgInfo(i);
+ if (db.Execute() == false)
+ return false;
+ }
return true;
}
-std::string SetPkginfoRequestHandler::GetResult() {
- std::string tmp_result("tmp_result");
-
- return tmp_result;
+std::vector<uint8_t> SetPkginfoRequestHandler::GetResult() {
+ return std::vector<uint8_t>('0');
}
} // namespace request_handler
class EXPORT_API SetPkginfoRequestHandler : public AbstractRequestHandler {
public:
- bool HandleRequest(std::string data, std::string locale) override;
+ bool HandleRequest(unsigned char* data, int size, std::string locale) override;
- std::string GetResult() override;
+ std::vector<uint8_t> GetResult() override;
};
} // namespace request_handler
pkgmgr_common::ReqType type = req->GetRequestType();
LOGD("Request type(%d)", static_cast<int>(type));
- auto request_data_str =
- std::string(reinterpret_cast<char*>(req->GetData()));
- if (!handler[type]->HandleRequest(request_data_str, locale_.GetString())) {
+ if (!handler[type]->HandleRequest(req->GetData(), req->GetSize(), locale_.GetString())) {
LOGE("Failed to handle request");
continue;
}
- std::string result_data_str = handler[type]->GetResult();
- req->SendData(reinterpret_cast<unsigned char*>(
- const_cast<char*>(result_data_str.c_str())),
- result_data_str.size());
+ std::vector<uint8_t> result_data = handler[type]->GetResult();
+ req->SendData(result_data.data(), result_data.size());
}
}