- Change codes for coding rule.
- Add some empty lines for readability.
- Remove unnecessary function variable declaration.
- Remove certinfo remove function which is no longer used.
Change-Id: If7d8206982d4989f34ab024caa6e52ea5a42b9da
Signed-off-by: Junghyun Yeon <jungh.yeon@samsung.com>
result_parcel_.reset(
reinterpret_cast<pkgmgr_common::parcel::AbstractParcelable *>(
dl_func(req_type_, &raw[0], raw.size(),
- pkgmgr_common::SystemLocale::GetInst().Get().c_str())));
+ pkgmgr_common::SystemLocale::GetInst().Get().c_str())));
return true;
}
AbstractParcelable::~AbstractParcelable() {}
-bool AbstractParcelable::ReadInt(tizen_base::Parcel* parcel, int *val) {
+bool AbstractParcelable::ReadInt(tizen_base::Parcel* parcel, int* val) {
return parcel->ReadInt32(val);
}
-bool AbstractParcelable::ReadString(tizen_base::Parcel* parcel, char **val) {
+bool AbstractParcelable::ReadString(tizen_base::Parcel* parcel, char** val) {
bool is_null;
if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE)
return false;
std::optional<std::string> AbstractParcelable::ReadString(
tizen_base::Parcel* parcel) {
bool is_null;
+
if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE)
return std::nullopt;
parcel->WriteBool(true);
return;
}
+
parcel->WriteBool(false);
parcel->WriteCString(str);
}
parcel->WriteBool(true);
return;
}
+
parcel->WriteBool(false);
parcel->WriteString(*str);
}
ret_ = ret;
}
-uid_t AbstractParcelable::GetUid() { return uid_; }
+uid_t AbstractParcelable::GetUid() {
+ return uid_;
+}
-void AbstractParcelable::SetUid(uid_t uid) { uid_ = uid; }
+void AbstractParcelable::SetUid(uid_t uid) {
+ uid_ = uid;
+}
-ParcelableType AbstractParcelable::GetType() { return type_; }
+ParcelableType AbstractParcelable::GetType() {
+ return type_;
+}
-int AbstractParcelable::GetRequestResult() { return ret_; }
+int AbstractParcelable::GetRequestResult() {
+ return ret_;
+}
} // namespace parcel
} // namespace pkgmgr_common
class EXPORT_API AbstractParcelable : public tizen_base::Parcelable {
public:
AbstractParcelable() : uid_(0), type_(ParcelableType::Unknown), ret_(0) {}
- AbstractParcelable(uid_t uid, ParcelableType type, int ret = 0) : uid_(uid), type_(type), ret_(ret) {}
+ AbstractParcelable(uid_t uid, ParcelableType type, int ret = 0)
+ : uid_(uid), type_(type), ret_(ret) {}
virtual ~AbstractParcelable();
uid_t GetUid();
void ReadFromParcel(tizen_base::Parcel* parcel) override;
protected:
- bool ReadString(tizen_base::Parcel* parcel, char **val);
+ bool ReadString(tizen_base::Parcel* parcel, char** val);
std::optional<std::string> ReadString(tizen_base::Parcel* parcel);
- bool ReadInt(tizen_base::Parcel* parcel, int *val);
+ bool ReadInt(tizen_base::Parcel* parcel, int* val);
void WriteString(tizen_base::Parcel* parcel, const char* str) const;
void WriteString(tizen_base::Parcel* parcel,
const std::optional<std::string>& str) const;
void AppInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
GList* label) const {
- int size = g_list_length(label);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(label));
for (GList* tmp = label; tmp; tmp = tmp->next) {
label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
void AppInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
GList* icon) const {
- int size = g_list_length(icon);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(icon));
for (GList* tmp = icon; tmp; tmp = tmp->next) {
icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
}
void AppInfoParcelable::WriteImage(tizen_base::Parcel* parcel,
GList* image) const {
- int size = g_list_length(image);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(image));
for (GList* tmp = image; tmp; tmp = tmp->next) {
image_x* ptr = reinterpret_cast<image_x*>(tmp->data);
}
void AppInfoParcelable::WriteCategory(tizen_base::Parcel* parcel,
GList* category) const {
- int size = g_list_length(category);
- WriteInt(parcel, size);
- for (GList* tmp = category; tmp; tmp = tmp->next) {
- WriteString(parcel, reinterpret_cast<char *>(tmp->data));
- }
+ WriteInt(parcel, g_list_length(category));
+
+ for (GList* tmp = category; tmp; tmp = tmp->next)
+ WriteString(parcel, reinterpret_cast<char*>(tmp->data));
}
void AppInfoParcelable::WriteMetadata(tizen_base::Parcel* parcel,
GList* metadata) const {
- int size = g_list_length(metadata);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(metadata));
for (GList* tmp = metadata; tmp; tmp = tmp->next) {
metadata_x* ptr = reinterpret_cast<metadata_x*>(tmp->data);
void AppInfoParcelable::WriteDatacontrol(tizen_base::Parcel* parcel,
GList* datacontrol) const {
- int size = g_list_length(datacontrol);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(datacontrol));
for (GList* tmp = datacontrol; tmp; tmp = tmp->next) {
datacontrol_x* ptr = reinterpret_cast<datacontrol_x*>(tmp->data);
WriteString(parcel, ptr->trusted);
WriteInt(parcel, g_list_length(ptr->privileges));
for (GList* tmp = ptr->privileges; tmp; tmp = tmp->next)
- WriteString(parcel, reinterpret_cast<char *>(tmp->data));
+ WriteString(parcel, reinterpret_cast<char*>(tmp->data));
}
}
void AppInfoParcelable::WriteBackgroundCategory(tizen_base::Parcel* parcel,
GList* backgroundcategory) const {
- int size = g_list_length(backgroundcategory);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(backgroundcategory));
+
for (GList* tmp = backgroundcategory; tmp; tmp = tmp->next)
- WriteString(parcel, reinterpret_cast<char *>(tmp->data));
+ WriteString(parcel, reinterpret_cast<char*>(tmp->data));
}
void AppInfoParcelable::WriteAppcontrol(tizen_base::Parcel* parcel,
GList* appcontrol) const {
- int size = g_list_length(appcontrol);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(appcontrol));
for (GList* tmp = appcontrol; tmp; tmp = tmp->next) {
appcontrol_x* ptr = reinterpret_cast<appcontrol_x*>(tmp->data);
WriteString(parcel, ptr->id);
WriteInt(parcel, g_list_length(ptr->privileges));
for (GList* tmp = ptr->privileges; tmp; tmp = tmp->next)
- WriteString(parcel, reinterpret_cast<char *>(tmp->data));
+ WriteString(parcel, reinterpret_cast<char*>(tmp->data));
}
}
void AppInfoParcelable::WriteSplashscreens(tizen_base::Parcel* parcel,
GList* splashscreens) const {
- int size = g_list_length(splashscreens);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(splashscreens));
for (GList* tmp = splashscreens; tmp; tmp = tmp->next) {
splashscreen_x* ptr = reinterpret_cast<splashscreen_x*>(tmp->data);
void AppInfoParcelable::WriteResControl(tizen_base::Parcel* parcel,
GList* res_control) const {
- int size = g_list_length(res_control);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(res_control));
for (GList* tmp = res_control; tmp; tmp = tmp->next) {
res_control_x* ptr = reinterpret_cast<res_control_x*>(tmp->data);
ReadInt(parcel, &size);
for (int i = 0; i < size; ++i) {
- char *category = nullptr;
+ char* category = nullptr;
ReadString(parcel, &category);
*list = g_list_append(*list, category);
}
int privilege_size = 0;
ReadInt(parcel, &privilege_size);
for (int i = 0; i < privilege_size; ++i) {
- char *privilege = nullptr;
+ char* privilege = nullptr;
ReadString(parcel, &privilege);
datacontrol->privileges =
g_list_append(datacontrol->privileges, privilege);
ReadInt(parcel, &size);
for (int i = 0; i < size; ++i) {
- char *category = nullptr;
+ char* category = nullptr;
ReadString(parcel, &category);
*list = g_list_append(*list, category);
}
int privilege_len = 0;
ReadInt(parcel, &privilege_len);
for (int i = 0; i < privilege_len; ++i) {
- char *privilege = nullptr;
+ char* privilege = nullptr;
ReadString(parcel, &privilege);
appcontrol->privileges =
g_list_append(appcontrol->privileges, privilege);
: AbstractParcelable(0, ParcelableType::AppInfo), auto_release_(true) {}
AppInfoParcelable::AppInfoParcelable(int ret,
- std::vector<application_x *>&& app_list, bool auto_release)
+ std::vector<application_x*>&& app_list, bool auto_release)
: AbstractParcelable(0, ParcelableType::AppInfo, ret),
app_list_(std::move(app_list)), auto_release_(auto_release) {}
if (!auto_release_)
return;
- for (auto app : app_list_) {
+ for (auto app : app_list_)
pkgmgrinfo_basic_free_application(app);
- }
}
-const std::vector<application_x *>& AppInfoParcelable::GetAppInfo() {
+const std::vector<application_x*>& AppInfoParcelable::GetAppInfo() {
return app_list_;
}
-std::vector<application_x *> AppInfoParcelable::ExtractAppInfo() {
+std::vector<application_x*> AppInfoParcelable::ExtractAppInfo() {
return std::move(app_list_);
}
-application_x *AppInfoParcelable::ReadApplication(tizen_base::Parcel* parcel) {
+application_x* AppInfoParcelable::ReadApplication(tizen_base::Parcel* parcel) {
application_x* application =
reinterpret_cast<application_x*>(calloc(1, sizeof(application_x)));
}
bool AppInfoParcelable::WriteApplication(tizen_base::Parcel* parcel,
- application_x *application) const {
+ application_x* application) const {
WriteString(parcel, application->appid);
WriteString(parcel, application->exec);
WriteString(parcel, application->nodisplay);
class EXPORT_API AppInfoParcelable : public AbstractParcelable {
public:
AppInfoParcelable();
- AppInfoParcelable(int ret, std::vector<application_x *>&& app_list, bool auto_release = true);
+ AppInfoParcelable(int ret, std::vector<application_x*>&& app_list,
+ bool auto_release = true);
~AppInfoParcelable();
- const std::vector<application_x *>& GetAppInfo();
- std::vector<application_x *> ExtractAppInfo();
+ const std::vector<application_x*>& GetAppInfo();
+ std::vector<application_x*> ExtractAppInfo();
void WriteToParcel(tizen_base::Parcel* parcel) const override;
void ReadFromParcel(tizen_base::Parcel* parcel) override;
void WriteCategory(tizen_base::Parcel* parcel, GList* category) const;
void WriteMetadata(tizen_base::Parcel* parcel, GList* metadata) const;
void WritePermission(tizen_base::Parcel* parcel, GList* permission) const;
- void WriteLaunchConditions(tizen_base::Parcel* parcel, GList* launchconditions) const;
- void WriteNotification(tizen_base::Parcel* parcel, GList* notification) const;
+ void WriteLaunchConditions(tizen_base::Parcel* parcel,
+ GList* launchconditions) const;
+ void WriteNotification(tizen_base::Parcel* parcel,
+ GList* notification) const;
void WriteDatashare(tizen_base::Parcel* parcel, GList* datashare) const;
void WriteDatacontrol(tizen_base::Parcel* parcel, GList* datacontrol) const;
- void WriteBackgroundCategory(tizen_base::Parcel* parcel, GList* backgroundcategory) const;
+ void WriteBackgroundCategory(tizen_base::Parcel* parcel,
+ GList* backgroundcategory) const;
void WriteAppcontrol(tizen_base::Parcel* parcel, GList* appcontrol) const;
- void WriteSplashscreens(tizen_base::Parcel* parcel, GList* splashscreens) const;
+ void WriteSplashscreens(tizen_base::Parcel* parcel,
+ GList* splashscreens) const;
void WriteResControl(tizen_base::Parcel* parcel, GList* splashscreens) const;
- bool WriteApplication(tizen_base::Parcel* parcel, application_x *application) const;
+ bool WriteApplication(tizen_base::Parcel* parcel,
+ application_x* application) const;
void ReadLabel(tizen_base::Parcel* parcel, GList** list);
void ReadIcon(tizen_base::Parcel* parcel, GList** list);
void ReadImage(tizen_base::Parcel* parcel, GList** list);
void ReadAppcontrol(tizen_base::Parcel* parcel, GList** list);
void ReadSplashscreens(tizen_base::Parcel* parcel, GList** list);
void ReadResControl(tizen_base::Parcel* parcel, GList** list);
- application_x *ReadApplication(tizen_base::Parcel* parcel);
+ application_x* ReadApplication(tizen_base::Parcel* parcel);
- std::vector<application_x *> app_list_;
+ std::vector<application_x*> app_list_;
bool auto_release_;
};
pkgmgr_certinfo_x* CertInfoParcelable::ExtractCertInfo() {
pkgmgr_certinfo_x* cert = cert_info_;
- cert_info_ = nullptr;
+ cert_info_ = nullptr;
return cert;
}
-const std::string& CertInfoParcelable::GetPkgId() { return pkgid_; }
+const std::string& CertInfoParcelable::GetPkgId() {
+ return pkgid_;
+}
void CertInfoParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
AbstractParcelable::WriteToParcel(parcel);
parcel->WriteBool(true);
return true;
}
+
parcel->WriteBool(false);
WriteInt(parcel, cert_info_->for_all_users);
WriteString(parcel, cert_info_->pkgid);
WriteString(parcel, cert_info_->cert_value);
for (int i = 0; i < MAX_CERT_TYPE; ++i)
WriteString(parcel, cert_info_->cert_info[i]);
+
for (int i = 0; i < MAX_CERT_TYPE; ++i)
WriteInt(parcel, cert_info_->cert_id[i]);
void CertInfoParcelable::ReadCertInfo(tizen_base::Parcel* parcel) {
bool is_null = false;
- if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE) return;
- if (is_null) return;
+ if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE || is_null)
+ return;
cert_info_ = reinterpret_cast<pkgmgr_certinfo_x*>(
calloc(1, sizeof(pkgmgr_certinfo_x)));
+
ReadInt(parcel, &cert_info_->for_all_users);
ReadString(parcel, &cert_info_->pkgid);
ReadString(parcel, &cert_info_->cert_value);
+
for (int i = 0; i < MAX_CERT_TYPE; ++i)
ReadString(parcel, &cert_info_->cert_info[i]);
+
for (int i = 0; i < MAX_CERT_TYPE; ++i)
ReadInt(parcel, &cert_info_->cert_id[i]);
}
public:
CertInfoParcelable();
CertInfoParcelable(uid_t uid, std::string pkgid);
- CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x *cert_info, bool auto_release = true);
- CertInfoParcelable(int ret, pkgmgr_certinfo_x *cert_info, bool auto_release = true);
+ CertInfoParcelable(uid_t uid, pkgmgr_certinfo_x* cert_info,
+ bool auto_release = true);
+ CertInfoParcelable(int ret, pkgmgr_certinfo_x* cert_info,
+ bool auto_release = true);
CertInfoParcelable(uid_t uid,
- pkgmgr_certinfo_x *cert_info, std::string pkgid, bool auto_release = true);
+ pkgmgr_certinfo_x* cert_info, std::string pkgid,
+ bool auto_release = true);
~CertInfoParcelable();
- const pkgmgr_certinfo_x *GetCertInfo();
- pkgmgr_certinfo_x *ExtractCertInfo();
+ const pkgmgr_certinfo_x* GetCertInfo();
+ pkgmgr_certinfo_x* ExtractCertInfo();
const std::string& GetPkgId();
void WriteToParcel(tizen_base::Parcel* parcel) const override;
void ReadCertInfo(tizen_base::Parcel* parcel);
void ReadPkgId(tizen_base::Parcel* parcel);
- pkgmgr_certinfo_x *cert_info_;
+ pkgmgr_certinfo_x* cert_info_;
std::string pkgid_;
bool auto_release_;
};
void DepInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
int len = 0;
+
AbstractParcelable::ReadFromParcel(parcel);
pkgid_ = parcel->ReadString();
ReadInt(parcel, &len);
}
void DepInfoParcelable::WriteDependency(tizen_base::Parcel* parcel,
- dependency_x *dependency) const {
+ dependency_x* dependency) const {
WriteString(parcel, dependency->pkgid);
WriteString(parcel, dependency->depends_on);
WriteString(parcel, dependency->type);
WriteString(parcel, dependency->required_version);
}
-dependency_x *DepInfoParcelable::ReadDependency(tizen_base::Parcel* parcel) {
+dependency_x* DepInfoParcelable::ReadDependency(tizen_base::Parcel* parcel) {
dependency_x* dep =
reinterpret_cast<dependency_x*>(calloc(1, sizeof(dependency_x)));
ReadString(parcel, &dep->pkgid);
class EXPORT_API DepInfoParcelable : public AbstractParcelable {
public:
DepInfoParcelable();
- DepInfoParcelable(int ret, std::vector<dependency_x *>&& dependency_list, bool auto_release = true);
+ DepInfoParcelable(int ret, std::vector<dependency_x*>&& dependency_list,
+ bool auto_release = true);
DepInfoParcelable(const std::string& pkgid);
~DepInfoParcelable();
- const std::vector<dependency_x *>& GetDependencyInfo();
- std::vector<dependency_x *> ExtractDependencyInfo();
+ const std::vector<dependency_x*>& GetDependencyInfo();
+ std::vector<dependency_x*> ExtractDependencyInfo();
const std::string& GetPkgID();
void WriteToParcel(tizen_base::Parcel* parcel) const override;
private:
void WriteDependency(tizen_base::Parcel* parcel,
- dependency_x *dependency) const;
- dependency_x *ReadDependency(tizen_base::Parcel* parcel);
+ dependency_x* dependency) const;
+ dependency_x* ReadDependency(tizen_base::Parcel* parcel);
std::string pkgid_;
- std::vector<dependency_x *> dependency_list_;
+ std::vector<dependency_x*> dependency_list_;
bool auto_release_;
};
filter_(nullptr),
flag_(0), auto_release_(true) {}
-FilterParcelable::FilterParcelable(uid_t uid, pkgmgrinfo_filter_x *filter,
+FilterParcelable::FilterParcelable(uid_t uid, pkgmgrinfo_filter_x* filter,
int flag, bool auto_release)
: AbstractParcelable(uid, ParcelableType::Filter),
filter_(filter),
pkgmgrinfo_pkginfo_filter_destroy(filter_);
}
-const pkgmgrinfo_filter_x *FilterParcelable::GetFilter() { return filter_; }
+const pkgmgrinfo_filter_x* FilterParcelable::GetFilter() {
+ return filter_;
+}
-int FilterParcelable::GetFlag() { return flag_; }
+int FilterParcelable::GetFlag() {
+ return flag_;
+}
-void FilterParcelable::WriteToParcel(tizen_base::Parcel *parcel) const {
+void FilterParcelable::WriteToParcel(tizen_base::Parcel* parcel) const {
AbstractParcelable::WriteToParcel(parcel);
WriteInt(parcel, flag_);
WriteFilter(parcel, filter_);
}
-void FilterParcelable::ReadFromParcel(tizen_base::Parcel *parcel) {
+void FilterParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
AbstractParcelable::ReadFromParcel(parcel);
ReadInt(parcel, &flag_);
ReadFilter(parcel);
}
-bool FilterParcelable::WriteFilter(tizen_base::Parcel *parcel,
- pkgmgrinfo_filter_x *filter) const {
+bool FilterParcelable::WriteFilter(tizen_base::Parcel* parcel,
+ pkgmgrinfo_filter_x* filter) const {
if (filter == nullptr) {
parcel->WriteBool(true);
return true;
WriteInt(parcel, filter->uid);
WriteInt(parcel, g_slist_length(filter->list));
- for (GSList *list = filter->list; list; list = list->next)
+ for (GSList* list = filter->list; list; list = list->next)
WritePkgmgrInfoNode(parcel,
- reinterpret_cast<pkgmgrinfo_node_x *>(list->data));
+ reinterpret_cast<pkgmgrinfo_node_x*>(list->data));
WriteInt(parcel, g_slist_length(filter->list_metadata));
- for (GSList *list = filter->list_metadata; list; list = list->next)
+ for (GSList* list = filter->list_metadata; list; list = list->next)
WritePkgmgrInfoMetadataNode(
- parcel, reinterpret_cast<pkgmgrinfo_metadata_node_x *>(list->data));
+ parcel, reinterpret_cast<pkgmgrinfo_metadata_node_x*>(list->data));
return true;
}
-void FilterParcelable::ReadFilter(tizen_base::Parcel *parcel) {
+void FilterParcelable::ReadFilter(tizen_base::Parcel* parcel) {
bool is_null = false;
int val = 0;
- if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE) return;
- if (is_null) return;
+ if (parcel->ReadBool(&is_null) != TIZEN_ERROR_NONE || is_null)
+ return;
- filter_ = reinterpret_cast<pkgmgrinfo_filter_x *>(
+ filter_ = reinterpret_cast<pkgmgrinfo_filter_x*>(
calloc(1, sizeof(pkgmgrinfo_filter_x)));
+
ReadInt(parcel, &val);
filter_->uid = val;
ReadPkgmgrInfoMetadataNode(parcel));
}
-bool FilterParcelable::WritePkgmgrInfoNode(tizen_base::Parcel *parcel,
- pkgmgrinfo_node_x *node) const {
+bool FilterParcelable::WritePkgmgrInfoNode(tizen_base::Parcel* parcel,
+ pkgmgrinfo_node_x* node) const {
WriteInt(parcel, node->prop);
WriteString(parcel, node->key);
WriteString(parcel, node->value);
return true;
}
-pkgmgrinfo_node_x *FilterParcelable::ReadPkgmgrInfoNode(
- tizen_base::Parcel *parcel) {
- pkgmgrinfo_node_x *node = reinterpret_cast<pkgmgrinfo_node_x *>(
+pkgmgrinfo_node_x* FilterParcelable::ReadPkgmgrInfoNode(
+ tizen_base::Parcel* parcel) {
+ pkgmgrinfo_node_x* node = reinterpret_cast<pkgmgrinfo_node_x*>(
calloc(1, sizeof(pkgmgrinfo_node_x)));
ReadInt(parcel, &node->prop);
ReadString(parcel, &node->key);
}
bool FilterParcelable::WritePkgmgrInfoMetadataNode(
- tizen_base::Parcel *parcel, pkgmgrinfo_metadata_node_x *node) const {
+ tizen_base::Parcel* parcel, pkgmgrinfo_metadata_node_x* node) const {
WriteString(parcel, node->key);
WriteString(parcel, node->value);
return true;
}
-pkgmgrinfo_metadata_node_x *FilterParcelable::ReadPkgmgrInfoMetadataNode(
- tizen_base::Parcel *parcel) {
- pkgmgrinfo_metadata_node_x *node =
- reinterpret_cast<pkgmgrinfo_metadata_node_x *>(
+pkgmgrinfo_metadata_node_x* FilterParcelable::ReadPkgmgrInfoMetadataNode(
+ tizen_base::Parcel* parcel) {
+ pkgmgrinfo_metadata_node_x* node =
+ reinterpret_cast<pkgmgrinfo_metadata_node_x*>(
calloc(1, sizeof(pkgmgrinfo_metadata_node_x)));
ReadString(parcel, &node->key);
ReadString(parcel, &node->value);
class EXPORT_API FilterParcelable : public AbstractParcelable {
public:
FilterParcelable();
- FilterParcelable(uid_t uid, pkgmgrinfo_filter_x *filter, int flag, bool auto_release = true);
+ FilterParcelable(uid_t uid, pkgmgrinfo_filter_x* filter,
+ int flag, bool auto_release = true);
~FilterParcelable();
const pkgmgrinfo_filter_x* GetFilter();
int GetFlag();
void ReadFromParcel(tizen_base::Parcel* parcel) override;
private:
- bool WriteFilter(tizen_base::Parcel* parcel, pkgmgrinfo_filter_x *filter) const;
- bool WritePkgmgrInfoNode(tizen_base::Parcel* parcel, pkgmgrinfo_node_x *node) const;
- bool WritePkgmgrInfoMetadataNode(tizen_base::Parcel* parcel, pkgmgrinfo_metadata_node_x *node) const;
+ bool WriteFilter(tizen_base::Parcel* parcel,
+ pkgmgrinfo_filter_x* filter) const;
+ bool WritePkgmgrInfoNode(tizen_base::Parcel* parcel,
+ pkgmgrinfo_node_x* node) const;
+ bool WritePkgmgrInfoMetadataNode(tizen_base::Parcel* parcel,
+ pkgmgrinfo_metadata_node_x* node) const;
void ReadFilter(tizen_base::Parcel* parcel);
- pkgmgrinfo_node_x *ReadPkgmgrInfoNode(tizen_base::Parcel *parcel);
- pkgmgrinfo_metadata_node_x *ReadPkgmgrInfoMetadataNode(tizen_base::Parcel* parcel);
+ pkgmgrinfo_node_x* ReadPkgmgrInfoNode(tizen_base::Parcel* parcel);
+ pkgmgrinfo_metadata_node_x* ReadPkgmgrInfoMetadataNode(tizen_base::Parcel* parcel);
- pkgmgrinfo_filter_x *filter_;
+ pkgmgrinfo_filter_x* filter_;
int flag_;
bool auto_release_;
};
const unsigned char* data, int size) {
int tmp;
std::unique_ptr<AbstractParcelable> res = nullptr;
- tizen_base::Parcel parcel(data, size);
+ tizen_base::Parcel parcel(data, size);
parcel.ReadInt32(&tmp);
parcel.ResetReader();
ParcelableType type = static_cast<ParcelableType>(tmp);
class EXPORT_API ParcelableFactory {
public:
static ParcelableFactory& GetInst();
- std::unique_ptr<AbstractParcelable> CreateParcel(const unsigned char* data, int size);
+ std::unique_ptr<AbstractParcelable> CreateParcel(
+ const unsigned char* data, int size);
private:
ParcelableFactory();
void PkgInfoParcelable::WriteIcon(tizen_base::Parcel* parcel,
GList* icon) const {
- int size = g_list_length(icon);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(icon));
for (GList* tmp = icon; tmp; tmp = tmp->next) {
icon_x* ptr = reinterpret_cast<icon_x*>(tmp->data);
void PkgInfoParcelable::WriteLabel(tizen_base::Parcel* parcel,
GList* label) const {
- int size = g_list_length(label);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(label));
for (GList* tmp = label; tmp; tmp = tmp->next) {
label_x* ptr = reinterpret_cast<label_x*>(tmp->data);
void PkgInfoParcelable::WriteAuthor(tizen_base::Parcel* parcel,
GList* author) const {
- int size = g_list_length(author);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(author));
for (GList* tmp = author; tmp; tmp = tmp->next) {
author_x* ptr = reinterpret_cast<author_x*>(tmp->data);
void PkgInfoParcelable::WriteDescription(tizen_base::Parcel* parcel,
GList* description) const {
- int size = g_list_length(description);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(description));
for (GList* tmp = description; tmp; tmp = tmp->next) {
description_x* ptr = reinterpret_cast<description_x*>(tmp->data);
void PkgInfoParcelable::WritePrivileges(tizen_base::Parcel* parcel,
GList* privileges) const {
- int size = g_list_length(privileges);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(privileges));
for (GList* tmp = privileges; tmp; tmp = tmp->next) {
privilege_x* ptr = reinterpret_cast<privilege_x*>(tmp->data);
void PkgInfoParcelable::WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
GList* appdefined_privileges) const {
- int size = g_list_length(appdefined_privileges);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(appdefined_privileges));
for (GList* tmp = appdefined_privileges; tmp; tmp = tmp->next) {
appdefined_privilege_x* ptr =
void PkgInfoParcelable::WriteProvidesAppdefinedPrivileges(
tizen_base::Parcel* parcel, GList* provides_appdefined_privileges) const {
- int size = g_list_length(provides_appdefined_privileges);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(provides_appdefined_privileges));
for (GList* tmp = provides_appdefined_privileges; tmp; tmp = tmp->next) {
appdefined_privilege_x* ptr =
void PkgInfoParcelable::WriteApplication(tizen_base::Parcel* parcel,
GList* application) const {
- std::vector<application_x *> app_vt;
+ std::vector<application_x*> app_vt;
for (GList* tmp = application; tmp; tmp = tmp->next) {
application_x* ptr = reinterpret_cast<application_x*>(tmp->data);
void PkgInfoParcelable::WriteDeviceprofile(tizen_base::Parcel* parcel,
GList* deviceprofile) const {
- int size = g_list_length(deviceprofile);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(deviceprofile));
for (GList* tmp = deviceprofile; tmp; tmp = tmp->next)
- WriteString(parcel, reinterpret_cast<char *>(tmp->data));
+ WriteString(parcel, reinterpret_cast<char*>(tmp->data));
}
void PkgInfoParcelable::WriteDependencies(tizen_base::Parcel* parcel,
GList* dependencies) const {
- int size = g_list_length(dependencies);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(dependencies));
for (GList* tmp = dependencies; tmp; tmp = tmp->next) {
dependency_x* ptr = reinterpret_cast<dependency_x*>(tmp->data);
void PkgInfoParcelable::WritePlugin(tizen_base::Parcel* parcel,
GList* plugin) const {
- int size = g_list_length(plugin);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(plugin));
for (GList* tmp = plugin; tmp; tmp = tmp->next) {
plugin_x* ptr = reinterpret_cast<plugin_x*>(tmp->data);
void PkgInfoParcelable::WriteResAllowedPackages(tizen_base::Parcel* parcel,
GList* res_allowed_packages) const {
- int size = g_list_length(res_allowed_packages);
- WriteInt(parcel, size);
+ WriteInt(parcel, g_list_length(res_allowed_packages));
for (GList* tmp = res_allowed_packages; tmp; tmp = tmp->next) {
res_allowed_package_x* ptr =
WriteString(parcel, ptr->allowed_package);
WriteInt(parcel, g_list_length(ptr->required_privileges));
- for (GList *priv = ptr->required_privileges; priv; priv = priv->next)
- WriteString(parcel, reinterpret_cast<char *>(priv->data));
+ for (GList* priv = ptr->required_privileges; priv; priv = priv->next)
+ WriteString(parcel, reinterpret_cast<char*>(priv->data));
}
}
void PkgInfoParcelable::WritePackage(tizen_base::Parcel* parcel,
- package_x *package) const {
+ package_x* package) const {
WriteString(parcel, package->for_all_users);
WriteString(parcel, package->package);
WriteString(parcel, package->version);
AppInfoParcelable apps;
parcel->ReadParcelable(&apps);
- std::vector<application_x *> vt = apps.ExtractAppInfo();
+ std::vector<application_x*> vt = apps.ExtractAppInfo();
- for (application_x *application : vt)
+ for (application_x* application : vt)
*list = g_list_append(*list, application);
}
ReadInt(parcel, &size);
for (int i = 0; i < size; ++i) {
- char *device_profile = nullptr;
+ char* device_profile = nullptr;
ReadString(parcel, &device_profile);
*list = g_list_append(*list, device_profile);
}
ReadString(parcel, &res_allowed_package->allowed_package);
int priv_len;
- GList *priv_list = nullptr;
+ GList* priv_list = nullptr;
ReadInt(parcel, &priv_len);
for (int i = 0; i < priv_len; ++i) {
- char *priv = nullptr;
+ char* priv = nullptr;
ReadString(parcel, &priv);
priv_list = g_list_prepend(priv_list, priv);
}
}
}
-package_x *PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
+package_x* PkgInfoParcelable::ReadPackage(tizen_base::Parcel* parcel) {
package_x* package =
reinterpret_cast<package_x*>(calloc(1, sizeof(package_x)));
write_type_(PkgWriteType::None), auto_release_(true) {}
PkgInfoParcelable::PkgInfoParcelable(
- uid_t uid, std::vector<package_x *>&& pkg_list,
+ uid_t uid, std::vector<package_x*>&& pkg_list,
PkgWriteType write_type, bool auto_release)
: AbstractParcelable(uid, ParcelableType::PkgInfo),
pkg_list_(std::move(pkg_list)), write_type_(write_type),
auto_release_(auto_release) {}
PkgInfoParcelable::PkgInfoParcelable(
- int ret, std::vector<package_x *>&& pkg_list, bool auto_release)
+ int ret, std::vector<package_x*>&& pkg_list, bool auto_release)
: AbstractParcelable(0, ParcelableType::PkgInfo, ret),
pkg_list_(std::move(pkg_list)), write_type_(PkgWriteType::None),
auto_release_(auto_release) {}
if (!auto_release_)
return;
- for (auto pkg : pkg_list_) {
+ for (auto pkg : pkg_list_)
pkgmgrinfo_basic_free_package(pkg);
- }
}
-const std::vector<package_x *>& PkgInfoParcelable::GetPkgInfo() {
+const std::vector<package_x*>& PkgInfoParcelable::GetPkgInfo() {
return pkg_list_;
}
-std::vector<package_x *> PkgInfoParcelable::ExtractPkgInfo() {
+std::vector<package_x*> PkgInfoParcelable::ExtractPkgInfo() {
return std::move(pkg_list_);
}
WriteInt(parcel, pkg_list_.size());
- for (auto pkg : pkg_list_) {
+ for (auto pkg : pkg_list_)
WritePackage(parcel, pkg);
- }
}
void PkgInfoParcelable::ReadFromParcel(tizen_base::Parcel* parcel) {
ReadInt(parcel, &len);
- for (int i = 0; i < len ; ++i) {
+ for (int i = 0; i < len ; ++i)
pkg_list_.emplace_back(ReadPackage(parcel));
- }
}
} // namespace parcel
class EXPORT_API PkgInfoParcelable : public AbstractParcelable {
public:
PkgInfoParcelable();
- PkgInfoParcelable(uid_t uid, std::vector<package_x *>&& pkg_list, PkgWriteType write_type, bool auto_release = true);
- PkgInfoParcelable(int ret, std::vector<package_x *>&& pkg_list, bool auto_release = true);
+ PkgInfoParcelable(uid_t uid, std::vector<package_x*>&& pkg_list,
+ PkgWriteType write_type, bool auto_release = true);
+ PkgInfoParcelable(int ret, std::vector<package_x*>&& pkg_list,
+ bool auto_release = true);
~PkgInfoParcelable();
- const std::vector<package_x *>& GetPkgInfo();
- std::vector<package_x *> ExtractPkgInfo();
+ const std::vector<package_x*>& GetPkgInfo();
+ std::vector<package_x*> ExtractPkgInfo();
PkgWriteType GetWriteType();
void WriteToParcel(tizen_base::Parcel* parcel) const override;
void WriteDescription(tizen_base::Parcel* parcel, GList* description) const;
void WriteLicense(tizen_base::Parcel* parcel, GList* license) const;
void WritePrivileges(tizen_base::Parcel* parcel, GList* privileges) const;
- void WriteAppdefinedPrivileges(tizen_base::Parcel* parcel, GList* appdefined_privileges) const;
- void WriteProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel, GList* provides_appdefined_privileges) const;
+ void WriteAppdefinedPrivileges(tizen_base::Parcel* parcel,
+ GList* appdefined_privileges) const;
+ void WriteProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
+ GList* provides_appdefined_privileges) const;
void WriteApplication(tizen_base::Parcel* parcel, GList* application) const;
- void WriteCompatibility(tizen_base::Parcel* parcel, GList* compatibility) const;
- void WriteDeviceprofile(tizen_base::Parcel* parcel, GList* deviceprofile) const;
- void WriteDependencies(tizen_base::Parcel* parcel, GList* dependencies) const;
+ void WriteCompatibility(tizen_base::Parcel* parcel,
+ GList* compatibility) const;
+ void WriteDeviceprofile(tizen_base::Parcel* parcel,
+ GList* deviceprofile) const;
+ void WriteDependencies(tizen_base::Parcel* parcel,
+ GList* dependencies) const;
void WritePlugin(tizen_base::Parcel* parcel, GList* plugin) const;
- void WriteResAllowedPackages(tizen_base::Parcel* parcel, GList* plugin) const;
- void WritePackage(tizen_base::Parcel* parcel, package_x *package) const;
+ void WriteResAllowedPackages(tizen_base::Parcel* parcel,
+ GList* plugin) const;
+ void WritePackage(tizen_base::Parcel* parcel, package_x* package) const;
void ReadIcon(tizen_base::Parcel* parcel, GList** list);
void ReadLabel(tizen_base::Parcel* parcel, GList** list);
void ReadAuthor(tizen_base::Parcel* parcel, GList** list);
void ReadLicense(tizen_base::Parcel* parcel, GList** list);
void ReadPrivileges(tizen_base::Parcel* parcel, GList** list);
void ReadAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list);
- void ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel, GList** list);
+ void ReadProvidesAppdefinedPrivileges(tizen_base::Parcel* parcel,
+ GList** list);
void ReadApplication(tizen_base::Parcel* parcel, GList** list);
void ReadCompatibility(tizen_base::Parcel* parcel, GList** list);
void ReadDeviceprofile(tizen_base::Parcel* parcel, GList** list);
void ReadDependencies(tizen_base::Parcel* parcel, GList** list);
void ReadPlugin(tizen_base::Parcel* parcel, GList** list);
void ReadResAllowedPackages(tizen_base::Parcel* parcel, GList** list);
- package_x *ReadPackage(tizen_base::Parcel* parcel);
+ package_x* ReadPackage(tizen_base::Parcel* parcel);
- std::vector<package_x *> pkg_list_;
+ std::vector<package_x*> pkg_list_;
PkgWriteType write_type_;
bool auto_release_;
};
AbstractParcelable::ReadFromParcel(parcel);
ReadInt(parcel, &query_size);
+
for (int i = 0; i < query_size; ++i) {
StrArgs args;
int index = -1;
int arg_cnt = 0;
+
ReadInt(parcel, &index);
ReadInt(parcel, &arg_cnt);
query_args_.push_back(QueryArgs(index, std::move(args)));
}
+
ReadInt(parcel, &db_type);
db_type_ = static_cast<DBType>(db_type);
+
ReadInt(parcel, &op_type);
op_type_ = static_cast<DBOperationType>(op_type);
}
if (nptr > buf + len)
break;
- if (event->len) {
- if (event->mask & IN_CREATE &&
- ready_checker->ready_file_ == event->name) {
- _LOGI("server is ready (%s)", ready_checker->ready_file_.c_str());
- ready_checker->ready_ = true;
- ready_checker->Dispose();
- return G_SOURCE_CONTINUE;
- }
- }
+ if (!event->len)
+ continue;
+
+ if (!(event->mask & IN_CREATE) ||
+ ready_checker->ready_file_ != event->name)
+ continue;
+
+ _LOGI("server is ready (%s)", ready_checker->ready_file_.c_str());
+ ready_checker->ready_ = true;
+ ready_checker->Dispose();
+ return G_SOURCE_CONTINUE;
}
}
disposed_ = true;
return;
}
+
auto it = ready_path.find_last_of("/");
if (it == ready_path.npos) {
_LOGE("Invalid path %s", ready_path.c_str());
disposed_ = true;
return;
}
+
ready_path_ = ready_path.substr(0, it);
ready_file_ = ready_path.substr(it + 1);
wd_ = inotify_add_watch(fd_, ready_path_.c_str(), IN_CREATE);
Dispose();
return;
}
+
tag_ = g_io_add_watch(channel_, G_IO_IN, OnReceiveEvent, this);
if (tag_ == 0) {
_LOGE("Failed to add watch");
bool IsReady() const;
private:
- void Dispose();
- static gboolean OnReceiveEvent(GIOChannel* channel, GIOCondition cond,
- gpointer user_data);
-
- private:
std::string ready_path_;
std::string ready_file_;
int fd_ = 0;
int tag_ = 0;
bool ready_ = false;
bool disposed_ = false;
+
+ void Dispose();
+ static gboolean OnReceiveEvent(GIOChannel* channel, GIOCondition cond,
+ gpointer user_data);
};
} // namespace pkgmgr_common
"CREATE_DB",
"ERROR_REQ_TYPE"
};
- if (type <= ReqType::REQ_TYPE_NONE
- || type >= ReqType::MAX)
+ if (type <= ReqType::REQ_TYPE_NONE || type >= ReqType::MAX)
return convertArray[ReqType::MAX];
return convertArray[type];
int AbstractSocket::SendData(const void* buf, unsigned int size) {
auto buffer = static_cast<const unsigned char*>(buf);
unsigned int left = size;
+
while (left) {
ssize_t send_byte = send(fd_, buffer, left, MSG_NOSIGNAL);
if (send_byte < 0) {
int AbstractSocket::ReceiveData(void* buf, unsigned int size) {
bool is_blocking = true;
- if (fcntl(fd_, F_GETFL, 0) & O_NONBLOCK) is_blocking = false;
+
+ if (fcntl(fd_, F_GETFL, 0) & O_NONBLOCK)
+ is_blocking = false;
auto buffer = static_cast<unsigned char*>(buf);
unsigned int left = size;
return 0;
}
-int AbstractSocket::GetFd() { return fd_; }
+int AbstractSocket::GetFd() {
+ return fd_;
+}
-std::string AbstractSocket::GetPath() { return path_; }
+std::string AbstractSocket::GetPath() {
+ return path_;
+}
-pid_t AbstractSocket::GetPID() { return pid_; }
+pid_t AbstractSocket::GetPID() {
+ return pid_;
+}
-uid_t AbstractSocket::GetUID() { return uid_; }
+uid_t AbstractSocket::GetUID() {
+ return uid_;
+}
void AbstractSocket::SetOption() {
int size = 2048;
int ret = setsockopt(fd_, SOL_SOCKET, SO_SNDBUF, &size, sizeof(size));
+
if (ret < 0) {
LOGE("setsockopt() is failed. fd(%d), errno(%d)", fd_, errno);
return;
}
int AbstractSocket::Create() {
- if (fd_ != -1) return 0;
+ if (fd_ != -1)
+ return 0;
+
fd_ = ::socket(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0);
if (fd_ < 0) {
LOGE("socket() is failed. errno(%d)", errno);
uid_t GetUID();
protected:
- void SetOption();
- int Create();
-
- private:
- void GetFdInfo();
-
- protected:
std::string path_;
int fd_;
pid_t pid_ = -1;
uid_t uid_ = -1;
struct sockaddr_un addr_;
+ void SetOption();
+ int Create();
+
+ private:
+ void GetFdInfo();
};
} // namespace socket
namespace pkgmgr_common {
namespace socket {
-ClientSocket::ClientSocket(std::string path) : AbstractSocket(std::move(path)) {
-}
+ClientSocket::ClientSocket(std::string path)
+ : AbstractSocket(std::move(path)) {}
void ClientSocket::SetTimeout(int timeout_msec) {
- if (timeout_msec == -1) timeout_msec = 5000;
+ if (timeout_msec == -1)
+ timeout_msec = 5000;
if (timeout_msec < 0) {
LOGE("Invalid timeout_msec parameter");
struct timeval timeout = {
.tv_sec = static_cast<time_t>(timeout_msec / 1000),
.tv_usec = static_cast<suseconds_t>((timeout_msec % 1000) * 1000)};
+
int ret = setsockopt(fd_, SOL_SOCKET, SO_RCVTIMEO, &timeout,
sizeof(timeout));
if (ret < 0)
}
bool ClientSocket::Connect() {
- if (Create() < 0) return false;
+ if (Create() < 0)
+ return false;
+
SetTimeout(5000);
+
int ret = -1;
int retry_cnt = 3;
do {
int ClientSocket::TryConnection() {
int flags = fcntl(fd_, F_GETFL, 0);
+
if (fcntl(fd_, F_SETFL, flags | O_NONBLOCK) != 0) {
LOGE("Failed to set flags(%d) on fd(%d), errno(%d)",
flags | O_NONBLOCK, fd_, errno);
void SystemLocale::LanChangedCb(keynode_t* node, void* user_data) {
char* val = vconf_keynode_get_str(node);
+
if (val == nullptr)
return;
+
SystemLocale* sl = reinterpret_cast<SystemLocale*>(user_data);
sl->lang_ = val;
sl->SetLocale();
void UnRegisterEvent();
private:
- SystemLocale();
- ~SystemLocale();
- void SetLocale();
- static void LanChangedCb(keynode_t* node, void* user_data);
-
- private:
std::string lang_;
std::string locale_;
IEvent* listener_ = nullptr;
+
+ SystemLocale();
+ ~SystemLocale();
+ void SetLocale();
+ static void LanChangedCb(keynode_t* node, void* user_data);
};
} // namespace pkgmgr_common
return PMINFO_R_OK;
}
-
-API int certinfo_internal_delete(sqlite3 *db, const char *pkgid)
-{
- char *query = NULL;
- int ret;
- sqlite3_stmt *stmt;
-
- if (db == NULL || pkgid == NULL)
- return PMINFO_R_EINVAL;
-
- query = sqlite3_mprintf("UPDATE package_cert_info "
- "SET package_count = package_count - 1 "
- "WHERE package=%Q", pkgid);
-
- ret = sqlite3_prepare_v2(db, query, strlen(query), &stmt, NULL);
- sqlite3_free(query);
- if (ret != SQLITE_OK) {
- _LOGE("prepare error: %s", sqlite3_errmsg(db));
- return PMINFO_R_ERROR;
- }
-
- ret = sqlite3_bind_text(stmt, 1, pkgid, -1, SQLITE_STATIC);
- if (ret != SQLITE_OK) {
- _LOGE("bind error: %s", sqlite3_errmsg(db));
- sqlite3_finalize(stmt);
- return PMINFO_R_ERROR;
- }
-
- ret = sqlite3_step(stmt);
- sqlite3_finalize(stmt);
- if (ret != SQLITE_DONE) {
- _LOGE("step error: %s", sqlite3_errmsg(db));
- return PMINFO_R_ERROR;
- }
-
- return PMINFO_R_OK;
-
-}
int appinfo_internal_filter_get_list(sqlite3 *db, pkgmgrinfo_appinfo_filter_h filter, uid_t db_uid, uid_t uid, const char *locale, GHashTable *list);
int certinfo_internal_get(sqlite3 *db, const char *pkgid, uid_t uid, pkgmgrinfo_certinfo_h certinfo);
int certinfo_internal_set(sqlite3 *db, const char *pkgid, pkgmgrinfo_instcertinfo_h handle, uid_t uid);
-int certinfo_internal_delete(sqlite3 *db, const char *pkgid);
int get_query_result(sqlite3 *db, const char *query, GList *param, GList **list, int *row, int *col);
int execute_write_queries(sqlite3 *db, GList *queries, GList *params_list);
int pkginfo_internal_filter_get_depends_on(sqlite3 *db, const char *pkgid, GList **list);