Removing logs in trivial function and adding when they are missed will be part of another commit
PS2 Rebase
PS3 Change some left Loggers
PS4 After using clang
PS5 Utilizing changes in ScopeLogger
PS6 Cleaning up
PS8 Adding missing logs - not formatted
PS9 Clang
PS10 Rebase
[Verification] Code compiles
10 random packages has 100% passrate:
alarm, systemsetting, systeminfo, security, content, filesystem, iotcon,
push, capability, privillege
Change-Id: I7972fee44dd13277d9ef7693433aad7b0321dd68
Signed-off-by: Szymon Jastrzebski <s.jastrzebsk@partner.samsung.com>
Signed-off-by: Michal Bistyga <m.bistyga@samsung.com>
}
AccountInstance::AccountInstance() {
- LoggerD("Enter");
+ ScopeLogger();
manager_ = new AccountManager;
subscribe_ = NULL;
}
AccountInstance::~AccountInstance() {
- LoggerD("Enter");
+ ScopeLogger();
delete manager_;
if (subscribe_) {
account_unsubscribe_notification(subscribe_);
}
AccountManager* AccountInstance::GetAccountManager() {
- LoggerD("Enter");
+ ScopeLogger();
return manager_;
}
void AccountInstance::AccountSetExtendedData(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountWrite, &out);
}
void AccountInstance::AccountGetExtendedData(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountRead, &out);
int callback_id = static_cast<int>(args.get("callbackId").get<double>());
auto get_extended_data = [this, account_id](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, get_extended_dat");
this->manager_->GetExtendedData(account_id, result->get<picojson::object>());
};
auto get_extended_data_result = [this,
callback_id](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, get_extended_dat_result");
result->get<picojson::object>()["callbackId"] =
picojson::value{static_cast<double>(callback_id)};
Instance::PostMessage(this, result->serialize().c_str());
void AccountInstance::AccountGetExtendedDataSync(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountRead, &out);
}
void AccountInstance::AccountManagerAdd(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountWrite, &out);
manager_->AddAccount(args, out);
}
void AccountInstance::AccountManagerRemove(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountWrite, &out);
manager_->RemoveAccount(args, out);
}
void AccountInstance::AccountManagerUpdate(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountWrite, &out);
manager_->UpdateAccount(args, out);
}
void AccountInstance::AccountManagerGetAccount(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountRead, &out);
void AccountInstance::AccountManagerGetAccounts(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountRead, &out);
LoggerD("application ID: [%s]", application_id.c_str());
auto get_accounts = [this, application_id](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function get_accounts");
this->manager_->GetAccountsInfo(application_id, result->get<picojson::object>());
};
auto get_accounts_result = [this, callback_id](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, get_accounts_result");
result->get<picojson::object>()["callbackId"] =
picojson::value{static_cast<double>(callback_id)};
Instance::PostMessage(this, result->serialize().c_str());
void AccountInstance::AccountManagerGetProvider(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountRead, &out);
void AccountInstance::AccountManagerGetProviders(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountRead, &out);
LoggerD("capability [%s]", capability.c_str());
auto get_providers = [this, capability](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, get_providers");
this->manager_->GetProvidersInfo(capability, result->get<picojson::object>());
};
auto get_providers_result = [this, callback_id](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, get_providers_result");
result->get<picojson::object>()["callbackId"] =
picojson::value{static_cast<double>(callback_id)};
Instance::PostMessage(this, result->serialize().c_str());
}
void AccountInstance::InvokeListener(picojson::object& param) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value result = picojson::value(param);
Instance::PostMessage(this, result.serialize().c_str());
}
static bool AccountEventCb(const char* event_type, int account_id, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
AccountInstance* instance = static_cast<AccountInstance*>(user_data);
if (!instance) {
void AccountInstance::AccountManagerAddAccountListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountRead, &out);
if (!subscribe_) {
void AccountInstance::AccountManagerRemoveAccountListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAccountRead, &out);
namespace {
static bool ProviderCapabilitiesCb(char* app_id, char* key, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array* array_data = static_cast<picojson::array*>(user_data);
if (!array_data) {
}
static bool AccountProvidersGetCb(account_type_h provider, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array* array_data = static_cast<picojson::array*>(user_data);
if (!array_data) {
}
static bool GetAccountsCallback(account_h handle, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array* array_data = static_cast<picojson::array*>(user_data);
if (!array_data) {
}
static bool GetCustomAllCallback(char* key, char* value, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array* array_data = static_cast<picojson::array*>(user_data);
if (!array_data) {
} // namespace
AccountManager::AccountManager() {
- LoggerD("Enter");
+ ScopeLogger();
}
AccountManager::~AccountManager() {
- LoggerD("Enter");
+ ScopeLogger();
}
std::string AccountManager::GetErrorMsg(int error) {
}
void AccountManager::GetAccountsInfo(const std::string& application_id, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array array_data;
int ret = ACCOUNT_ERROR_NONE;
}
void AccountManager::GetAccountInfo(int account_id, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
account_h account = NULL;
SCOPE_EXIT {
}
bool AccountManager::GetProviderInfo(const std::string& provider_id, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
account_type_h provider = NULL;
SCOPE_EXIT {
}
bool AccountManager::ConvertAccountToObject(account_h account, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
char* provider_id = NULL;
char* icon_path = NULL;
}
bool AccountManager::ConvertProviderToObject(account_type_h provider, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
char* provider_id = NULL;
char* display_name = NULL;
}
void AccountManager::GetProvidersInfo(const std::string& capability, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array array_data;
int ret = ACCOUNT_ERROR_NONE;
void AccountManager::GetExtendedData(int account_id, const std::string& key,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
account_h account = nullptr;
SCOPE_EXIT {
}
void AccountManager::GetExtendedData(int account_id, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
account_h account = nullptr;
SCOPE_EXIT {
void AccountManager::SetExtendedData(int account_id, const std::string& key,
const std::string& value, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
account_h account = nullptr;
SCOPE_EXIT {
}
void AccountManager::AddAccount(const picojson::value& data, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
account_h account_handle = NULL;
int account_id;
}
void AccountManager::RemoveAccount(const picojson::value& data, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
int account_id = static_cast<int>(data.get("accountId").get<double>());
int ret = account_delete_from_db_by_id(account_id);
}
void AccountManager::UpdateAccount(const picojson::value& data, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
int account_id = static_cast<int>(data.get("accountId").get<double>());
const std::string& user_name = data.get("userName").get<std::string>();
const std::string& icon_uri = data.get("iconUri").get<std::string>();
using namespace common;
AlarmInstance::AlarmInstance() {
- LoggerD("Entered");
+ ScopeLogger();
using namespace std::placeholders;
RegisterSyncHandler("AlarmManager_add", std::bind(&AlarmManager::Add, &manager_, _1, _2));
}
AlarmInstance::~AlarmInstance() {
- LoggerD("Entered");
+ ScopeLogger();
}
} // namespace Alarm
}
AlarmManager::AlarmManager() {
+ ScopeLogger();
}
AlarmManager::~AlarmManager() {
+ ScopeLogger();
}
void AlarmManager::Add(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAlarm, &out);
if (!args.contains("alarm")) {
}
void AlarmManager::Remove(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAlarm, &out);
int id = 0;
}
void AlarmManager::RemoveAll(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAlarm, &out);
int ret = alarm_cancel_all();
}
PlatformResult AlarmManager::GetAlarm(int id, picojson::object& obj) {
- LoggerD("Entered");
+ ScopeLogger();
if (id <= 0) {
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Invalid id.",
}
void AlarmManager::Get(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
int id = 0;
}
static bool AlarmIterateCB(int alarm_id, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
std::vector<int>* alarm_ids = reinterpret_cast<std::vector<int>*>(user_data);
}
void AlarmManager::GetAll(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
std::vector<int> alarm_ids;
int ret = alarm_foreach_registered_alarm(AlarmIterateCB, &alarm_ids);
}
void AlarmManager::GetRemainingSeconds(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
struct tm date;
struct tm current;
}
void AlarmManager::GetNextScheduledDate(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
int id = 0;
using namespace common;
PlatformResult AppControlToService(const picojson::object& obj, app_control_h* app_control) {
- LoggerD("Entered");
+ ScopeLogger();
const auto it_end = obj.end();
PlatformResult AppControlToServiceExtraData(const picojson::object& app_obj,
app_control_h* app_control) {
- LoggerD("Entered");
+ ScopeLogger();
const auto it_key = app_obj.find("key");
const auto it_value = app_obj.find("value");
}
void Application::GetRequestedAppControl(const picojson::value& args, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string& encoded_bundle = RequestedApplicationControl::GetEncodedBundle();
extern const char kSource_application_api[];
common::Extension* CreateExtension() {
- LoggerD("Enter");
+ ScopeLogger();
ApplicationExtension* e = new ApplicationExtension();
return e;
}
ApplicationExtension::ApplicationExtension() {
- LoggerD("Enter");
+ ScopeLogger();
SetExtensionName(kApplication);
SetJavaScriptAPI(kSource_application_api);
}
ApplicationExtension::~ApplicationExtension() {
- LoggerD("Enter");
+ ScopeLogger();
}
common::Instance* ApplicationExtension::CreateInstance() {
- LoggerD("Enter");
+ ScopeLogger();
return new extension::application::ApplicationInstance();
}
using namespace common;
ApplicationInstance::ApplicationInstance() : manager_(*this) {
- LoggerD("Entered");
+ ScopeLogger();
app_id_ = CurrentApplication::GetInstance().GetApplicationId();
LoggerD("app_id: %s", app_id_.c_str());
}
ApplicationInstance::~ApplicationInstance() {
- LoggerD("Entered");
+ ScopeLogger();
}
void ApplicationInstance::GetCurrentApplication(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
manager_.GetCurrentApplication(app_id_, &out);
}
void ApplicationInstance::GetAppContext(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
manager_.GetAppContext(args, &out);
}
void ApplicationInstance::GetAppInfo(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string app_id = app_id_;
const auto& id = args.get("id");
}
void ApplicationInstance::GetAppCerts(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAppManagerCertificate, &out);
}
void ApplicationInstance::GetAppSharedURI(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string app_id = app_id_;
const auto& id = args.get("id");
}
void ApplicationInstance::GetAppMetaData(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeApplicationInfo, &out);
void ApplicationInstance::AddAppInfoEventListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: addAppInfoEventListener() is deprecated and will be removed from next "
"release. "
void ApplicationInstance::RemoveAppInfoEventListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: removeAppInfoEventListener() is deprecated and will be removed from "
"next release. "
void ApplicationInstance::GetRequestedAppControl(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
current_application_.GetRequestedAppControl(args, &out);
}
void ApplicationInstance::ReplyResult(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
current_application_.app_control().ReplyResult(args, &out);
}
void ApplicationInstance::ReplyFailure(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
current_application_.app_control().ReplyFailure(&out);
}
void ApplicationInstance::GetSize(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeApplicationInfo, &out);
}
void ApplicationInstance::Kill(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeAppManagerKill, &out);
}
void ApplicationInstance::Launch(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeApplicationLaunch, &out);
}
void ApplicationInstance::LaunchAppControl(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeApplicationLaunch, &out);
}
void ApplicationInstance::FindAppControl(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
manager_.FindAppControl(args);
}
void ApplicationInstance::GetAppsContext(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
manager_.GetAppsContext(args);
}
void ApplicationInstance::GetAppsInfo(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
manager_.GetAppsInfo(args);
}
void ApplicationInstance::BroadcastEvent(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
manager_.BroadcastEventHelper(args, out, false);
}
void ApplicationInstance::BroadcastTrustedEvent(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
manager_.BroadcastEventHelper(args, out, true);
}
void ApplicationInstance::AddEventListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string& event_name = args.get("name").get<std::string>();
}
void ApplicationInstance::RemoveEventListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string& event_name = args.get("name").get<std::string>();
: pkgmgr_client_handle_(nullptr),
pkgmgr_client_uninstall_handle_(nullptr),
instance_(instance) {
- LoggerD("Enter");
+ ScopeLogger();
}
ApplicationManager::~ApplicationManager() {
- LoggerD("Enter");
+ ScopeLogger();
StopAppInfoEventListener();
}
void ApplicationManager::GetCurrentApplication(const std::string& app_id, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
// obtain handle to application info
pkgmgrinfo_appinfo_h handle;
}
void Invoke(const std::shared_ptr<picojson::value>& response) {
- LoggerD("Entered");
+ ScopeLogger();
if (timeout_id_ > 0) {
// cancel terminate callback
}
void LaunchCheckTerminate() {
- LoggerD("Entered");
+ ScopeLogger();
timeout_id_ = g_timeout_add(3000, CheckTerminate, this);
LoggerD("END");
}
private:
static gboolean CheckTerminate(gpointer user_data) {
- LoggerD("Entered");
+ ScopeLogger();
TerminateHandler* that = static_cast<TerminateHandler*>(user_data);
LoggerD("PID: %d", that->pid_);
void ApplicationManager::AsyncResponse(PlatformResult& result,
std::shared_ptr<picojson::value>* response) {
- LoggerD("Enter");
+ ScopeLogger();
LogAndReportError(result, &(*response)->get<picojson::object>());
TaskQueue::GetInstance().Async<picojson::value>(
}
void ApplicationManager::Kill(const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
}
auto kill = [this, callback_id, context_id]() -> void {
- LoggerD("Entered Kill async");
+ ScopeLogger("Kill async");
std::shared_ptr<picojson::value> response =
std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
}
void ApplicationManager::Launch(const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
int callback_id = -1;
const auto& callback = args.get(kCallbackId);
const std::string& id = app_id.get<std::string>();
auto launch = [id](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, launch");
PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
const char* app_id = id.c_str();
const int retry_count = 3;
}
void ApplicationManager::LaunchAppControl(const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
int callback_id = -1;
const auto& callback = args.get(kCallbackId);
auto launch = [this, app_control_ptr, app_id, launch_mode_str,
reply_callback](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Entered");
+ ScopeLogger("Entered into asynchronous function, launch");
if (!app_id.empty()) {
LoggerD("app_id: %s", app_id.c_str());
};
auto launch_response = [this](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Entered launch_response");
+ ScopeLogger("launch_response");
Instance::PostMessage(&this->instance_, response->serialize().c_str());
};
// public CAPI did not handling APP_CONTROL_ERROR_APP_NOT_FOUND
int app_control_foreach_app_matched_internal(app_control_h app_control,
app_control_app_matched_cb callback, void* user_data) {
+ ScopeLogger();
typedef struct {
app_control_h app_control;
app_control_app_matched_cb callback;
// internal impl of app_control_cb_broker_foreach_app_matched()
auto app_control_cb_broker_foreach_app_matched_internal = [](const char* package,
void* data) -> int {
+ ScopeLogger(
+ "Entered into asynchronous function, app_control_cb_broker_foreach_app_matched_internal's "
+ "argument");
foreach_context_launchable_app_t_internal* foreach_context;
app_control_app_matched_cb app_matched_cb;
}
void ApplicationManager::FindAppControl(const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
int callback_id = -1;
const auto& callback = args.get(kCallbackId);
}
auto find = [app_control_ptr](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, find");
auto app_control_matched = [](app_control_h app_control, const char* appid,
void* user_data) -> bool {
+ ScopeLogger("Entered into asynchronous function, app_control_matched");
if (nullptr == appid) {
LoggerD("appid is NULL");
return false;
};
auto find_response = [this](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, find_response");
Instance::PostMessage(&this->instance_, response->serialize().c_str());
};
}
void ApplicationManager::GetAppsContext(const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
int callback_id = -1;
const auto& callback = args.get(kCallbackId);
}
void ApplicationManager::GetAppContext(const picojson::value& args, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
pid_t pid = 0;
const auto& context_id = args.get("contextId");
}
void ApplicationManager::GetAppsInfo(const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
int callback_id = -1;
const auto& callback = args.get(kCallbackId);
}
auto get_apps_info = [](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get_apps_info");
picojson::object& response_obj = response->get<picojson::object>();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
.first->second.get<picojson::array>();
auto app_info_cb = [](pkgmgrinfo_appinfo_h handle, void* user_data) -> int {
+ ScopeLogger("Entered into asynchronous function, app_info_cb");
if (nullptr == user_data) {
return -1;
}
auto get_apps_info_response =
[this, callback_id](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get_apps_info_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair(kCallbackId, picojson::value(static_cast<double>(callback_id))));
Instance::PostMessage(&this->instance_, response->serialize().c_str());
}
void ApplicationManager::GetAppInfo(const std::string& app_id, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
pkgmgrinfo_appinfo_h handle = nullptr;
}
char* ApplicationManager::GetPackageId(const std::string& app_id) {
- LoggerD("Entered");
+ ScopeLogger();
app_info_h handle;
char* pkg_id = nullptr;
}
void ApplicationManager::GetAppCerts(const std::string& app_id, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
char* package_id = nullptr;
}
void ApplicationManager::GetAppSharedUri(const std::string& app_id, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
char* package_id = nullptr;
}
void ApplicationManager::GetAppMetaData(const std::string& app_id, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
pkgmgrinfo_appinfo_h handle = nullptr;
static int ClientStatusListener(unsigned int target_uid, int id, const char* type,
const char* package, const char* key, const char* val,
const void* msg, void* data) {
- LoggerD("Entered");
+ ScopeLogger();
ApplicationListChangedBroker* that = static_cast<ApplicationListChangedBroker*>(data);
if (0 == strcasecmp(key, kStartKey)) {
static int AppUninstallListener(uid_t target_uid, int id, const char* type, const char* package,
const char* key, const char* val, const void* msg, void* data) {
- LoggerD("Entered");
+ ScopeLogger();
ApplicationListChangedBroker* that = static_cast<ApplicationListChangedBroker*>(data);
}
void AddApplicationInstance(ApplicationInstance* app_instance) {
- LoggerD("Entered");
+ ScopeLogger();
app_instance_list_.push_back(app_instance);
}
void RemoveApplicationInstance(ApplicationInstance* app_instance) {
- LoggerD("Entered");
+ ScopeLogger();
for (auto it = app_instance_list_.begin(); it != app_instance_list_.end(); it++) {
if (*it == app_instance) {
app_instance_list_.erase(it);
private:
void HandleStart(const char* event_type, const char* package) {
- LoggerD("Entered");
+ ScopeLogger();
app_list_.clear();
set_event_type(event_type);
}
void HandleEnd(const char* package) {
- LoggerD("Entered");
+ ScopeLogger();
if (Event::kUninstalled == event_type_) {
return;
}
void GetApplicationIdsFromPackage(const char* package) {
- LoggerD("Entered");
+ ScopeLogger();
package_info_h package_info = nullptr;
int ret = package_info_create(package, &package_info);
}
void set_event_type(const char* type) {
- LoggerD("Entered");
+ ScopeLogger();
if (0 == strcasecmp(type, kInstallEvent)) {
event_type_ = Event::kInstalled;
} else if (0 == strcasecmp(type, kUpdateEvent)) {
static bool ApplicationIdCallback(package_info_app_component_type_e comp_type, const char* app_id,
void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
if (nullptr != app_id) {
static_cast<ApplicationListChangedBroker*>(user_data)->app_list_.push_back(app_id);
}
}
void HandleUninstallStart() {
- LoggerD("Entered");
+ ScopeLogger();
app_list_.clear();
set_event_type(kUninstallEvent);
}
void AddUninstalledAppId(const char* app_id) {
- LoggerD("Entered");
+ ScopeLogger();
if (nullptr != app_id) {
app_list_.push_back(app_id);
}
}
void HandleUninstallEnd() {
- LoggerD("Entered");
+ ScopeLogger();
for (auto& app_id : app_list_) {
picojson::value value = picojson::value(picojson::object());
picojson::object& data_obj = value.get<picojson::object>();
static ApplicationListChangedBroker g_application_list_changed_broker;
void ApplicationManager::StartAppInfoEventListener(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
if (nullptr == pkgmgr_client_handle_ || nullptr == pkgmgr_client_uninstall_handle_) {
if (nullptr == pkgmgr_client_handle_) {
}
void ApplicationManager::StopAppInfoEventListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (nullptr != pkgmgr_client_handle_ || nullptr != pkgmgr_client_uninstall_handle_) {
if (nullptr != pkgmgr_client_handle_) {
void ApplicationManager::GetApplicationInformationSize(const picojson::value& args,
picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& package_id = args.get("packageId");
if (!package_id.is<std::string>()) {
void ApplicationManager::BroadcastEventHelper(const picojson::value& args, picojson::object& out,
bool trusted) {
- LoggerD("Entered");
+ ScopeLogger();
int ret;
std::string event_str = args.get("name").get<std::string>();
}
void ApplicationManager::OnEvent(const char* event_name, bundle* event_data, void* user_data) {
- LoggerD("Entered");
- LOGGER(DEBUG) << event_name;
+ ScopeLogger("Event name is: '%f'", event_name);
ApplicationManager* manager = static_cast<ApplicationManager*>(user_data);
PlatformResult ApplicationManager::StartEventListener(const std::string& event_name,
const JsonCallback& callback) {
- LoggerD("Entered");
+ ScopeLogger();
int ret;
event_handler_h event_handler;
}
void ApplicationManager::StopEventListener(const std::string& event_name) {
- LoggerD("Entered");
+ ScopeLogger();
int ret;
event_handler_h event_handler;
void ApplicationUtils::CreateApplicationInformation(const pkgmgrinfo_appinfo_h handle,
picojson::object* app_info) {
- LoggerD("Enter");
+ ScopeLogger();
char* tmp_str = nullptr;
int ret = 0;
ret = pkgmgrinfo_appinfo_foreach_category(
handle,
[](const char* category, void* user_data) -> int {
+ ScopeLogger("Entered into asynchronous function");
picojson::array* categories_array = static_cast<picojson::array*>(user_data);
if ((nullptr != category) && (nullptr != categories_array)) {
bool ApplicationUtils::CreateApplicationContext(const app_context_h handle,
picojson::object* app_context) {
+ ScopeLogger();
char* app_id = nullptr;
int ret = app_context_get_app_id(handle, &app_id);
void ApplicationUtils::CreateApplicationContext(pid_t pid, const std::string& app_id,
picojson::object* app_context) {
- LoggerD("Enter");
+ ScopeLogger();
app_context->insert(std::make_pair("id", picojson::value(std::to_string(pid))));
app_context->insert(std::make_pair("appId", picojson::value(app_id)));
}
void ApplicationUtils::CreateApplicationCertificate(const char* cert_type, const char* cert_value,
picojson::object* app_certificate) {
- LoggerD("Enter");
+ ScopeLogger();
app_certificate->insert(std::make_pair("type", picojson::value(cert_type)));
app_certificate->insert(std::make_pair("value", picojson::value(cert_value)));
}
void ApplicationUtils::CreateApplicationMetaData(const char* key, const char* value,
picojson::object* app_meta_data) {
- LoggerD("Enter");
+ ScopeLogger();
app_meta_data->insert(std::make_pair("key", picojson::value(key)));
app_meta_data->insert(std::make_pair("value", picojson::value(value)));
}
PlatformResult ApplicationUtils::ApplicationControlToService(
const picojson::object& app_control_obj, app_control_h* app_control) {
- LoggerD("Enter");
+ ScopeLogger();
const auto it_operation = app_control_obj.find("operation");
const auto it_uri = app_control_obj.find("uri");
const auto it_mime = app_control_obj.find("mime");
PlatformResult ApplicationUtils::ApplicationControlDataToServiceExtraData(
const picojson::object& app_control_data, app_control_h app_control) {
- LoggerD("Enter");
+ ScopeLogger();
const auto it_key = app_control_data.find("key");
const auto it_value = app_control_data.find("value");
void ApplicationUtils::ServiceToApplicationControl(app_control_h app_control,
picojson::object* app_control_obj) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = 0;
char* tmp_str = nullptr;
void ApplicationUtils::ServiceExtraDataToApplicationControlData(
app_control_h app_control, const std::string& key, picojson::object* app_control_data) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = 0;
bool is_array = false;
bool ApplicationUtils::ServiceToApplicationControlDataArray(app_control_h app_control,
picojson::array* data) {
+ ScopeLogger();
int ret = app_control_foreach_extra_data(app_control, ServiceExtraDataCallback, data);
return APP_CONTROL_ERROR_NONE == ret;
}
bool ApplicationUtils::ServiceExtraDataCallback(app_control_h app_control, const char* key,
void* user_data) {
+ ScopeLogger();
picojson::array* data = static_cast<picojson::array*>(user_data);
data->push_back(picojson::value(picojson::object()));
namespace application {
PlatformResult RequestedApplicationControl::set_bundle(const std::string& encoded_bundle) {
- LoggerD("Entered");
+ ScopeLogger();
if (encoded_bundle != bundle_) {
bundle_ = encoded_bundle;
}
void RequestedApplicationControl::set_app_control(app_control_h app_control) {
- LoggerD("Entered");
+ ScopeLogger();
app_control_.reset(app_control, app_control_destroy);
}
void RequestedApplicationControl::ToJson(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
if (app_control_) {
out->insert(std::make_pair("callerAppId", picojson::value(caller_app_id_)));
}
void RequestedApplicationControl::ReplyResult(const picojson::value& args, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& data_arr = args.get("data");
if (!data_arr.is<picojson::array>()) {
}
void RequestedApplicationControl::ReplyFailure(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
// read input data
const std::string& encoded_bundle = GetEncodedBundle();
}
std::string RequestedApplicationControl::GetEncodedBundle() {
- LoggerD("Entered");
+ ScopeLogger();
std::string result;
std::size_t size = 512;
}
PlatformResult RequestedApplicationControl::VerifyCallerPresence() {
- LoggerD("Entered");
+ ScopeLogger();
if (caller_app_id_.empty()) {
return LogAndCreateResult(ErrorCode::NOT_FOUND_ERR, "Cannot find caller.",
m_is_error(false),
m_is_canceled(false),
m_err_code(ErrorCode::NO_ERROR) {
- LoggerD("Entered");
+ ScopeLogger();
}
OperationCallbackData::~OperationCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
if (m_op_id > -1) {
ArchiveManager::getInstance().eraseElementFromArchiveFileMap(m_op_id);
}
}
void OperationCallbackData::setError(const ErrorCode& err_code, const std::string& err_message) {
- LoggerD("Entered");
+ ScopeLogger("Setting error, code is: [%d]", err_code);
// store only first error
if (!m_is_error) {
m_err_code = err_code;
}
bool OperationCallbackData::isError() const {
- LoggerD("Entered");
return m_is_error;
}
bool OperationCallbackData::isCanceled() const {
- LoggerD("Enter");
return m_is_canceled;
}
void OperationCallbackData::setOperationId(long op_id) {
- LoggerD("Entered");
m_op_id = op_id;
}
long OperationCallbackData::getOperationId() const {
- LoggerD("Entered");
return m_op_id;
}
void OperationCallbackData::setCallbackId(double cid) {
- LoggerD("Enter");
m_cid = cid;
}
double OperationCallbackData::getCallbackId() const {
- LoggerD("Enter");
return m_cid;
}
void OperationCallbackData::setHandle(long handle) {
- LoggerD("Enter");
m_handle = handle;
}
long OperationCallbackData::getHandle() const {
- LoggerD("Enter");
return m_handle;
}
void OperationCallbackData::setIsCanceled(bool canceled) {
- LoggerD("Enter");
m_is_canceled = canceled;
}
void OperationCallbackData::PostMessage(const char* msg) {
- LoggerD("Enter");
+ ScopeLogger();
Instance::PostMessage(&instance_, msg);
}
const ErrorCode& OperationCallbackData::getErrorCode() const {
- LoggerD("Entered");
return m_err_code;
}
const std::string& OperationCallbackData::getErrorMessage() const {
- LoggerD("Entered");
return m_err_message;
}
ArchiveCallbackType OperationCallbackData::getCallbackType() const {
- LoggerD("Entered");
return m_callback_type;
}
ArchiveFilePtr OperationCallbackData::getArchiveFile() const {
- LoggerD("Enter");
return m_caller_instance;
}
void OperationCallbackData::setArchiveFile(ArchiveFilePtr caller) {
- LoggerD("Enter");
m_caller_instance = caller;
}
OpenCallbackData::OpenCallbackData(ArchiveInstance& instance)
: OperationCallbackData(OPEN_CALLBACK_DATA, instance) {
- LoggerD("Entered");
+ ScopeLogger();
}
OpenCallbackData::~OpenCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
PlatformResult OpenCallbackData::executeOperation(ArchiveFilePtr archive_file_ptr) {
- LoggerE("Entered");
+ ScopeLogger();
filesystem::FilePtr file = archive_file_ptr->getFile();
if (!file) {
GetEntriesCallbackData::GetEntriesCallbackData(ArchiveInstance& instance)
: OperationCallbackData(GET_ENTRIES_CALLBACK_DATA, instance) {
- LoggerD("Entered");
+ ScopeLogger();
}
GetEntriesCallbackData::~GetEntriesCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
ArchiveFileEntryPtrMapPtr GetEntriesCallbackData::getEntries() const {
- LoggerD("Entered");
return m_entries;
}
void GetEntriesCallbackData::setEntries(ArchiveFileEntryPtrMapPtr entries) {
- LoggerD("Entered");
m_entries = entries;
}
PlatformResult GetEntriesCallbackData::executeOperation(ArchiveFilePtr archive_file_ptr) {
- LoggerD("Entered");
+ ScopeLogger();
setEntries(archive_file_ptr->getEntryMap());
GetEntryByNameCallbackData::GetEntryByNameCallbackData(ArchiveInstance& instance)
: OperationCallbackData(GET_ENTRY_BY_NAME_CALLBACK_DATA, instance) {
- LoggerD("Entered");
+ ScopeLogger();
}
GetEntryByNameCallbackData::~GetEntryByNameCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
const std::string& GetEntryByNameCallbackData::getName() const {
- LoggerD("Entered");
return m_name;
}
void GetEntryByNameCallbackData::setName(const std::string& name) {
- LoggerD("Entered");
m_name = name;
}
ArchiveFileEntryPtr GetEntryByNameCallbackData::getFileEntry() const {
- LoggerD("Entered");
+ ScopeLogger();
return m_file_entry;
}
void GetEntryByNameCallbackData::setFileEntry(ArchiveFileEntryPtr entry) {
- LoggerD("Entered");
m_file_entry = entry;
}
PlatformResult GetEntryByNameCallbackData::executeOperation(ArchiveFilePtr archive_file_ptr) {
- LoggerD("Entered");
+ ScopeLogger();
ArchiveFileEntryPtrMapPtr entries = archive_file_ptr->getEntryMap();
auto it = entries->find(getName());
BaseProgressCallback::BaseProgressCallback(ArchiveCallbackType callback_type,
ArchiveInstance& instance)
: OperationCallbackData(callback_type, instance), m_overwrite(false) {
- LoggerD("Entered");
+ ScopeLogger();
}
BaseProgressCallback::~BaseProgressCallback() {
- LoggerD("Entered");
+ ScopeLogger();
}
bool BaseProgressCallback::getOverwrite() const {
- LoggerD("Entered");
return m_overwrite;
}
void BaseProgressCallback::setOverwrite(bool overwrite) {
- LoggerD("Entered");
m_overwrite = overwrite;
}
};
void BaseProgressCallback::callSuccessCallbackOnMainThread() {
- LoggerD("Entered");
+ ScopeLogger();
guint id = g_idle_add(BaseProgressCallback::callSuccessCallbackCB, static_cast<void*>(this));
if (!id) {
}
gboolean BaseProgressCallback::callSuccessCallbackCB(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
BaseProgressCallback* callback = static_cast<BaseProgressCallback*>(data);
if (!callback) {
void BaseProgressCallback::callProgressCallback(long operationId, double value,
const std::string& filename, double callbackId) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value val = picojson::value(picojson::object());
picojson::object& obj = val.get<picojson::object>();
void BaseProgressCallback::callProgressCallbackOnMainThread(const double progress,
ArchiveFileEntryPtr current_entry) {
- LoggerD("Entered");
+ ScopeLogger();
ProgressHolder* ph = new (std::nothrow) ProgressHolder();
}
gboolean BaseProgressCallback::callProgressCallbackCB(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
ProgressHolder* ph = static_cast<ProgressHolder*>(data);
if (!ph) {
AddProgressCallback::AddProgressCallback(ArchiveInstance& instance)
: BaseProgressCallback(ADD_PROGRESS_CALLBACK, instance) {
- LoggerD("Entered");
+ ScopeLogger();
}
AddProgressCallback::~AddProgressCallback() {
- LoggerD("Entered");
+ ScopeLogger();
}
ArchiveFileEntryPtr AddProgressCallback::getFileEntry() const {
- LoggerD("Entered");
return m_file_entry;
}
void AddProgressCallback::setFileEntry(ArchiveFileEntryPtr file_entry) {
- LoggerD("Entered");
m_file_entry = file_entry;
}
void AddProgressCallback::setBasePath(const std::string& path) {
- LoggerD("Entered");
+ ScopeLogger();
m_base_path = path;
m_base_virt_path = common::FilesystemProvider::Create().GetVirtualPath(m_base_path);
std::string::size_type pos = m_base_virt_path.find(filesystem::Path::getSeparator());
}
const std::string& AddProgressCallback::getBasePath() {
- LoggerD("Entered");
return m_base_path;
}
const std::string& AddProgressCallback::getBaseVirtualPath() {
- LoggerD("Entered");
return m_base_virt_path;
}
PlatformResult AddProgressCallback::executeOperation(ArchiveFilePtr archive_file_ptr) {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_file_entry) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not add file to archive",
m_files_extracted(0),
m_progress_overall(0),
m_overall_decompressed(0) {
- LoggerD("Entered");
+ ScopeLogger();
}
ExtractAllProgressCallback::~ExtractAllProgressCallback() {
- LoggerD("Entered");
+ ScopeLogger();
}
filesystem::FilePtr ExtractAllProgressCallback::getDirectory() const {
- LoggerD("Entered");
return m_directory;
}
void ExtractAllProgressCallback::setDirectory(filesystem::FilePtr directory) {
- LoggerD("Entered");
m_directory = directory;
}
void ExtractAllProgressCallback::startedExtractingFile(unsigned long current_file_size) {
- LoggerD("Entered");
-
m_current_file_size = current_file_size;
m_current_file_extracted_bytes = 0;
}
void ExtractAllProgressCallback::extractedPartOfFile(unsigned long bytes_decompressed) {
- LoggerD("Entered");
+ ScopeLogger();
m_current_file_extracted_bytes += bytes_decompressed;
updateOverallProgress(bytes_decompressed);
}
void ExtractAllProgressCallback::finishedExtractingFile() {
- LoggerD("Entered");
+ ScopeLogger();
m_current_file_size = 0;
m_current_file_extracted_bytes = 0;
}
void ExtractAllProgressCallback::updateOverallProgress(unsigned long bytes_decompressed) {
- LoggerD("Entered");
+ ScopeLogger();
m_overall_decompressed += bytes_decompressed;
m_progress_overall = static_cast<double>(m_overall_decompressed + m_files_extracted) /
}
double ExtractAllProgressCallback::getCurrentFileProgress() const {
- LoggerD("Entered");
+ ScopeLogger();
if (m_current_file_size > 0) {
return static_cast<double>(m_current_file_extracted_bytes) /
}
double ExtractAllProgressCallback::getOverallProgress() const {
- LoggerD("Entered");
-
return m_progress_overall;
}
PlatformResult ExtractAllProgressCallback::executeOperation(ArchiveFilePtr archive_file_ptr) {
- LoggerD("Entered");
return archive_file_ptr->extractAllTask(this);
}
void ExtractAllProgressCallback::setExpectedDecompressedSize(unsigned long exp_dec_size) {
- LoggerD("Entered");
-
m_expected_decompressed_size = exp_dec_size;
}
unsigned long ExtractAllProgressCallback::getExpectedDecompressedSize() const {
- LoggerD("Entered");
-
return m_expected_decompressed_size;
}
void ExtractAllProgressCallback::setNumberOfFilesToExtract(unsigned long files_count) {
- LoggerD("Entered");
-
m_files_to_extract = files_count;
}
unsigned long ExtractAllProgressCallback::getNumberOfFilesToExtract() const {
- LoggerD("Entered");
-
return m_files_to_extract;
}
const char* OPERATION_CANCELED_EXCEPTION = "OperationCanceledException";
OperationCanceledException::OperationCanceledException(const char* message) {
- LoggerD("Entered");
+ ScopeLogger();
}
//----------------------------------------------------------------------------------------
ExtractEntryProgressCallback::ExtractEntryProgressCallback(ArchiveInstance& instance)
: ExtractAllProgressCallback(instance), m_strip_name(false) {
- LoggerD("Entered");
+ ScopeLogger();
m_callback_type = EXTRACT_ENTRY_PROGRESS_CALLBACK;
}
ExtractEntryProgressCallback::~ExtractEntryProgressCallback() {
- LoggerD("Entered");
+ ScopeLogger();
}
ArchiveFileEntryPtr ExtractEntryProgressCallback::getArchiveFileEntry() {
- LoggerD("Entered");
return m_archive_file_entry;
}
void ExtractEntryProgressCallback::setArchiveFileEntry(ArchiveFileEntryPtr afentry) {
- LoggerD("Entered");
m_archive_file_entry = afentry;
}
void ExtractEntryProgressCallback::setStripName(bool strip_name) {
- LoggerD("Entered");
m_strip_name = strip_name;
}
bool ExtractEntryProgressCallback::getStripName() const {
- LoggerD("Entered");
return m_strip_name;
}
void ExtractEntryProgressCallback::setStripBasePath(const std::string& strip_base_path) {
- LoggerD("Entered");
m_strip_base_path = strip_base_path;
}
const std::string& ExtractEntryProgressCallback::getStripBasePath() const {
- LoggerD("Entered");
return m_strip_base_path;
}
PlatformResult ExtractEntryProgressCallback::executeOperation(ArchiveFilePtr archive_file_ptr) {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_archive_file_entry) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not extract archive file entry",
extern const char kSource_archive_api[];
common::Extension* CreateExtension() {
- LoggerD("Enter");
+ ScopeLogger();
return new ArchiveExtension;
}
ArchiveExtension::ArchiveExtension() {
- LoggerD("Enter");
+ ScopeLogger();
SetExtensionName("tizen.archive");
SetJavaScriptAPI(kSource_archive_api);
}
ArchiveExtension::~ArchiveExtension() {
- LoggerD("Enter");
+ ScopeLogger();
}
common::Instance* ArchiveExtension::CreateInstance() {
- LoggerD("Enter");
+ ScopeLogger();
return new extension::archive::ArchiveInstance();
}
namespace archive {
Permission::Permission(bool r, bool w, bool rw, bool a) {
- LoggerD("Enter");
+ ScopeLogger();
permission[0] = r;
permission[1] = w;
permission[2] = rw;
m_is_open(false),
m_overwrite(false),
m_created_as_new_empty_archive(false) {
- LoggerD("Entered");
+ ScopeLogger();
}
ArchiveFile::ArchiveFile(FileMode file_mode)
m_is_open(false),
m_overwrite(false),
m_created_as_new_empty_archive(false) {
- LoggerD("Enter");
+ ScopeLogger();
m_file_mode = file_mode;
}
ArchiveFile::~ArchiveFile() {
- LoggerD("Entered");
+ ScopeLogger();
if (m_entry_map) {
LoggerD("Unlinking old m_entry_map: %d ArchiveFileEntries", m_entry_map->size());
}
gboolean ArchiveFile::openTaskCompleteCB(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
auto callback = static_cast<OperationCallbackData*>(data);
if (!callback) {
}
gboolean ArchiveFile::callErrorCallback(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
auto callback = static_cast<OperationCallbackData*>(data);
if (!callback) {
}
void ArchiveFile::taskManagerThread(gpointer data, gpointer user_data) {
- LoggerD("Entered");
+ ScopeLogger();
ArchiveFileHolder* archive_file_holder = static_cast<ArchiveFileHolder*>(data);
if (!archive_file_holder) {
LoggerE("archive_file_holder is null");
}
PlatformResult ArchiveFile::addOperation(OperationCallbackData* callback) {
- LoggerD("Entered callback type:%d", callback->getCallbackType());
+ ScopeLogger("callback type: %d", (int)callback->getCallbackType());
const long operation_id = callback->getOperationId();
callback->setArchiveFile(shared_from_this());
}
PlatformResult ArchiveFile::extractAllTask(ExtractAllProgressCallback* callback) {
- LoggerD("Enter");
+ ScopeLogger();
filesystem::FilePtr directory = callback->getDirectory();
if (!directory) {
}
PlatformResult ArchiveFile::getEntries(GetEntriesCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not get list of files in archive",
("callback is NULL"));
}
gboolean ArchiveFile::getEntriesTaskCompleteCB(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
LoggerW("STUB Not calling success/error callback");
auto callback = static_cast<GetEntriesCallbackData*>(data);
}
PlatformResult ArchiveFile::extractAll(ExtractAllProgressCallback* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not extract all files from archive",
("callback is NULL"));
}
PlatformResult ArchiveFile::extractEntryTo(ExtractEntryProgressCallback* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not extract archive file entry",
("callback is NULL"));
}
PlatformResult ArchiveFile::add(AddProgressCallback* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not add file to archive",
("callback is NULL"));
}
void ArchiveFile::close() {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_open) {
LoggerD("Archive already closed");
}
PlatformResult ArchiveFile::getEntryByName(GetEntryByNameCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not get archive file entries by name",
("callback is NULL"));
}
gboolean ArchiveFile::getEntryByNameTaskCompleteCB(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
auto callback = static_cast<GetEntryByNameCallbackData*>(data);
if (!callback) {
}
filesystem::FilePtr ArchiveFile::getFile() const {
- LoggerD("Entered");
return m_file;
}
void ArchiveFile::setFile(filesystem::FilePtr file) {
- LoggerD("Entered");
m_file = file;
}
}
void ArchiveFile::setOverwrite(bool overwrite) {
- LoggerD("Entered");
m_overwrite = overwrite;
}
unsigned long ArchiveFile::getDecompressedSize() const {
- LoggerD("Entered");
return m_decompressed_size;
}
void ArchiveFile::setDecompressedSize(unsigned long decompressed_size) {
- LoggerD("Entered");
m_decompressed_size = decompressed_size;
}
bool ArchiveFile::isOpen() const {
- LoggerD("Entered");
return m_is_open;
}
void ArchiveFile::setIsOpen(bool is_open) {
- LoggerD("Entered");
m_is_open = is_open;
}
ArchiveFileEntryPtrMapPtr ArchiveFile::getEntryMap() const {
- LoggerD("Entered");
return m_entry_map;
}
void ArchiveFile::setEntryMap(ArchiveFileEntryPtrMapPtr entries) {
- LoggerD("Entered");
+ ScopeLogger();
if (m_entry_map) {
LoggerD("Unlinking old m_entry_map: %d ArchiveFileEntries", m_entry_map->size());
}
PlatformResult ArchiveFile::createUnZipObject(UnZipPtr* unzip) {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_open) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "File is not opened");
}
}
PlatformResult ArchiveFile::createZipObject(ZipPtr* zip) {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_open) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "File is not opened");
}
}
bool ArchiveFile::isAllowedOperation(const std::string& method_name) {
- LoggerD("Entered");
+ ScopeLogger();
PermissionMap::iterator it = s_permission_map.find(method_name);
if (it != s_permission_map.end()) {
return it->second.permission[m_file_mode];
}
FileMode ArchiveFile::getFileMode() const {
- LoggerD("Entered");
return m_file_mode;
}
void ArchiveFile::setFileMode(FileMode file_mode) {
- LoggerD("Entered");
m_file_mode = file_mode;
}
void ArchiveFile::setCreatedAsNewEmptyArchive(bool new_and_empty) {
- LoggerD("Entered");
m_created_as_new_empty_archive = new_and_empty;
}
bool ArchiveFile::isCreatedAsNewEmptyArchive() const {
- LoggerD("Entered");
return m_created_as_new_empty_archive;
}
PlatformResult ArchiveFile::updateListOfEntries() {
- LoggerD("Entered");
+ ScopeLogger();
// For explanation please see:
// ArchiveFile.h m_created_as_new_empty_archive description
//
bool ArchiveFile::isEntryWithNameInArchive(const std::string& name_in_zip, bool* out_is_directory,
std::string* out_matching_name) {
- LoggerD("Enter");
+ ScopeLogger();
if (!m_entry_map) {
LoggerW("m_entry_map is NULL");
m_compressed_size(0),
m_modified(0),
m_compression_level(s_default_compression_level) {
- LoggerD("Entered");
+ ScopeLogger();
}
ArchiveFileEntry::~ArchiveFileEntry() {
- LoggerD("Entered");
+ ScopeLogger();
}
unsigned long ArchiveFileEntry::getCompressedSize() const {
}
PlatformResult ArchiveFileEntry::extractTo(ExtractEntryProgressCallback* callback) {
+ ScopeLogger();
if (!m_archive) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not extract archive file entry",
("m_archive is NULL"));
} // namespace
ArchiveInstance::ArchiveInstance() {
- LoggerD("Entered");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
ArchiveInstance::~ArchiveInstance() {
- LoggerD("Entered");
+ ScopeLogger();
}
void ArchiveInstance::PostError(const PlatformResult& e, double callback_id) {
- LoggerD("Entered");
+ ScopeLogger();
LoggerE("Posting an error: %d, message: %s", e.error_code(), e.message().c_str());
}
void ArchiveInstance::Open(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
- LoggerD("%s", args.serialize().c_str());
+ ScopeLogger("%s", args.serialize().c_str());
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
}
void ArchiveInstance::Abort(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
- LoggerD("%s", args.serialize().c_str());
+ ScopeLogger("%s", args.serialize().c_str());
picojson::object data = args.get<picojson::object>();
picojson::value v_op_id = data.at(PARAM_OPERATION_ID);
}
unsigned int ConvertStringToCompressionLevel(const std::string& level) {
- LoggerD("Entered");
+ ScopeLogger();
if (kNoCompressionStr == level) {
return Z_NO_COMPRESSION;
}
void ArchiveInstance::Add(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
- LoggerD("%s", args.serialize().c_str());
+ ScopeLogger("%s", args.serialize().c_str());
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
}
void ArchiveInstance::ExtractAll(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
- LoggerD("%s", args.serialize().c_str());
+ ScopeLogger("%s", args.serialize().c_str());
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
}
void ArchiveInstance::GetEntries(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
- LoggerD("%s", args.serialize().c_str());
+ ScopeLogger("%s", args.serialize().c_str());
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemRead, &out);
}
void ArchiveInstance::GetEntryByName(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
- LoggerD("%s", args.serialize().c_str());
+ ScopeLogger("%s", args.serialize().c_str());
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemRead, &out);
}
void ArchiveInstance::Close(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
- LoggerD("%s", args.serialize().c_str());
+ ScopeLogger("%s", args.serialize().c_str());
picojson::object data = args.get<picojson::object>();
picojson::value v_handle = data.at(ARCHIVE_FILE_HANDLE);
}
void ArchiveInstance::Extract(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
- LoggerD("%s", args.serialize().c_str());
+ ScopeLogger("%s", args.serialize().c_str());
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
}
void ArchiveInstance::FetchVirtualRoots(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::array roots;
for (const auto& root : common::FilesystemProvider::Create().GetVirtualPaths()) {
using namespace filesystem;
ArchiveManager::ArchiveManager() : m_next_unique_id(0) {
- LoggerD("Initialize ArchiveManager");
+ ScopeLogger("Initialize ArchiveManager");
// create thread pool with max threads = 1 to make API calls async but
// only one call at time
m_pool = g_thread_pool_new(ArchiveFile::taskManagerThread, NULL, 1, true, NULL);
}
ArchiveManager::~ArchiveManager() {
- LoggerD("Deinitialize ArchiveManager");
+ ScopeLogger("Deinitialize ArchiveManager");
// finish only current task and wait for thread to stop
g_thread_pool_free(m_pool, true, true);
}
ArchiveManager& ArchiveManager::getInstance() {
- LoggerD("Entered");
+ ScopeLogger();
static ArchiveManager instance;
return instance;
}
}
void ArchiveManager::abort(long operation_id) {
- LoggerD("Entered");
+ ScopeLogger();
ArchiveFileMap::iterator it = m_archive_file_map.find(operation_id);
if (it != m_archive_file_map.end()) {
}
void ArchiveManager::erasePrivData(long handle) {
- LoggerD("Entered");
+ ScopeLogger();
ArchiveFileMap::iterator it = m_priv_map.find(handle);
if (it != m_priv_map.end()) {
}
long ArchiveManager::addPrivData(ArchiveFilePtr archive_file_ptr) {
- LoggerD("Entered");
+ ScopeLogger();
long handle = ++m_next_unique_id;
m_priv_map.insert(ArchiveFilePair(handle, archive_file_ptr));
}
PlatformResult ArchiveManager::open(OpenCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
// ArchiveFilePtr a_ptr = callback->getArchiveFile();
// std::string filename = callback->getFile();
}
void ArchiveManager::eraseElementFromArchiveFileMap(long operation_id) {
- LoggerD("Entered");
+ ScopeLogger();
ArchiveFileMap::iterator it = m_archive_file_map.find(operation_id);
if (it != m_archive_file_map.end()) {
m_archive_file_map.erase(it);
using namespace filesystem;
std::string bytesToReadableString(const size_t num_bytes) {
- LoggerD("Enter");
+ ScopeLogger();
std::stringstream ss;
static const size_t one_mb = 1024 * 1024;
static const size_t one_kb = 1024;
}
PlatformResult fileModeToString(FileMode fm, std::string* fm_str) {
- LoggerD("Enter");
+ ScopeLogger();
switch (fm) {
case FileMode::READ:
*fm_str = "r";
}
PlatformResult stringToFileMode(std::string fmString, FileMode* fm) {
- LoggerD("Enter");
+ ScopeLogger();
if (!fmString.compare("r")) {
*fm = FileMode::READ;
return PlatformResult(ErrorCode::NO_ERROR);
void getBasePathAndName(const std::string& filepath, std::string& out_basepath,
std::string& out_name) {
- LoggerD("Enter");
+ ScopeLogger();
const size_t filepath_len = filepath.length();
size_t name_end_index = filepath_len;
}
std::string removeDuplicatedSlashesFromPath(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
const size_t path_len = path.length();
std::string out;
}
bool isDirectoryPath(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
if (path.empty()) {
return false;
}
}
std::string removeTrailingDirectorySlashFromPath(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
if (!isDirectoryPath(path)) {
return path;
}
}
std::string stripBasePathFromPath(const std::string& fullpath) {
- LoggerD("Enter");
+ ScopeLogger();
const size_t location = fullpath.find_last_of("/\\");
if (std::string::npos == location) {
return fullpath;
static std::string errUnknown = "Unknown error";
const std::string& getArchiveErrorMessage(int errorCode) {
- LoggerD("Enter");
+ ScopeLogger();
/**
* All errors are defined in minizip library in files:
* zip.h and unzip.h
}
std::string getBasePathFromPath(const std::string& fullpath) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string tmp_path = removeTrailingDirectorySlashFromPath(fullpath);
const size_t location = tmp_path.find_last_of("/\\");
if (std::string::npos == location) {
}
std::string getArchiveLogMessage(const int errorCode, const std::string& hint) {
- LoggerD("Enter");
+ ScopeLogger();
std::stringstream ss;
ss << "Failed " << hint << " : " << getArchiveErrorMessage(errorCode) << ", " << errorCode;
return std::string(ss.str());
File::File(NodePtr node, const File::PermissionList& parentPermissions,
const std::string& original_location)
: m_node(node), m_parentPerms(parentPermissions) {
- LoggerD("original_location is fullPath: %s", original_location.c_str());
+ ScopeLogger("original_location is fullPath: %s", original_location.c_str());
m_original_fullpath = original_location;
}
File::~File() {
- LoggerD("Enter");
+ ScopeLogger();
}
NodePtr File::getNode() const {
#define MAX_NODE_LENGTH 256
PlatformResult Node::checkPermission(const PathPtr& path, const std::string& mode, NodeType type,
bool* granted) {
- LoggerD("Enter");
+ ScopeLogger();
*granted = false;
switch (type) {
}
PlatformResult Node::resolve(const PathPtr& path, NodePtr* node) {
- LoggerD("Entered path:[%s]", path->getFullPath().c_str());
+ ScopeLogger("path: %s", path->getFullPath().c_str());
struct stat info;
struct stat syminfo;
}
PlatformResult Node::getChild(const PathPtr& path, NodePtr* node) {
- LoggerD("Enter");
+ ScopeLogger();
if (m_type != NT_DIRECTORY) {
return LogAndCreateResult(ErrorCode::IO_ERR, "Not a directory.");
}
}
PlatformResult Node::getChildNames(Node::NameList* out_name_list) const {
- LoggerD("Enter");
+ ScopeLogger();
if (m_type != NT_DIRECTORY) {
return LogAndCreateResult(ErrorCode::IO_ERR, "Node is not directory.");
}
}
PlatformResult Node::getChildNodes(NodeList* out_node_list) const {
- LoggerD("Enter");
+ ScopeLogger();
if (m_type != NT_DIRECTORY) {
SLoggerE("Path %s Perm %d", m_path->getFullPath().c_str(), m_perms);
}
PlatformResult Node::createChild(const PathPtr& path, NodeType type, NodePtr* node, int options) {
- LoggerD("Enter");
+ ScopeLogger();
if (m_type != NT_DIRECTORY) {
return LogAndCreateResult(ErrorCode::IO_ERR, "Parent node is not a directory.");
}
}
PlatformResult Node::remove(int options) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result(ErrorCode::NO_ERROR);
switch (m_type) {
case NT_FILE:
}
PlatformResult Node::getSize(unsigned long long* size) const {
- LoggerD("Enter");
+ ScopeLogger();
if (m_type == NT_DIRECTORY) {
return LogAndCreateResult(ErrorCode::IO_ERR, "Getting size for directories is not supported.");
}
}
PlatformResult Node::getCreated(std::time_t* time) const {
- LoggerD("Enter");
+ ScopeLogger();
struct stat info;
PlatformResult result = stat(m_path, &info);
if (result.error_code() != ErrorCode::NO_ERROR) {
}
PlatformResult Node::getModified(std::time_t* time) const {
- LoggerD("Enter");
+ ScopeLogger();
struct stat info;
PlatformResult result = stat(m_path, &info);
if (result.error_code() != ErrorCode::NO_ERROR) {
}
PlatformResult Node::getParent(NodePtr* node) const {
- LoggerD("Enter");
+ ScopeLogger();
// LocationPaths roots = Manager::getInstance().getLocationPaths();
// for (LocationPaths::iterator it = roots.begin(); it != roots.end(); ++it) {
}
PlatformResult Node::getMode(int* mode) const {
- LoggerD("Enter");
+ ScopeLogger();
struct stat info;
PlatformResult result = stat(m_path, &info);
}
PlatformResult Node::exists(const PathPtr& path, bool* existed) {
- LoggerD("Enter");
+ ScopeLogger();
struct stat info;
memset(&info, 0, sizeof(struct stat));
}
PlatformResult Node::stat(const PathPtr& path, struct stat* out_info) {
- LoggerD("Enter");
+ ScopeLogger();
struct stat info;
memset(&info, 0, sizeof(struct stat));
}
Node::Node(const PathPtr& path, NodeType type) : m_path(path), m_type(type), m_perms(PERM_NONE) {
- LoggerD("Enter");
+ ScopeLogger();
}
PlatformResult Node::createAsFile(const PathPtr& path, NodePtr* node, int /* options */) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result = createAsFileInternal(path);
if (result.error_code() == ErrorCode::NO_ERROR) {
}
PlatformResult Node::createAsFileInternal(const PathPtr& path) {
- LoggerD("Enter");
+ ScopeLogger();
FILE* file = std::fopen(path->getFullPath().c_str(), "wb");
if (!file) {
}
PlatformResult Node::createAsDirectory(const PathPtr& path, NodePtr* node, int options) {
- LoggerD("Enter");
+ ScopeLogger();
// if (options & OPT_RECURSIVE) {
// auto parts = Utils::getParts(path);
}
PlatformResult Node::createAsDirectoryInternal(const PathPtr& path) {
- LoggerD("Enter");
+ ScopeLogger();
if (mkdir(path->getFullPath().c_str(), S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) != 0) {
return LogAndCreateResult(ErrorCode::IO_ERR, "Platform node could not be created.");
}
PlatformResult Node::removeAsFile(const PathPtr& path) {
- LoggerD("Enter");
+ ScopeLogger();
auto fullPath = path->getFullPath();
if (unlink(fullPath.c_str()) != 0) {
}
PlatformResult Node::removeAsDirectory(const PathPtr& path, bool recursive) {
- LoggerD("Enter");
+ ScopeLogger();
if (recursive) {
DIR* dir = opendir(path->getFullPath().c_str());
}
bool Node::isSubPath(std::string aDirPath, PathPtr aFilePath) {
- LoggerD("Enter");
+ ScopeLogger();
auto myPath = aDirPath;
if (!myPath.empty() && myPath[myPath.length() - 1] != Path::getSeparator()) {
myPath += Path::getSeparator();
const Path::SeparatorType Path::m_pathSeparator = '/';
std::string Path::replaceVirtualRootPath(const char* path) {
- LoggerD("Enter");
+ ScopeLogger();
const char* old_path = "/opt/usr/media";
char replace_path[MAX_PATH_SIZE] = {
}
PathPtr Path::create(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
auto result = std::shared_ptr<Path>(new Path());
result->reset(replaceVirtualRootPath(path.c_str()));
return result;
}
Path::Path() {
+ ScopeLogger();
}
void Path::reset(const std::string& str) {
- LoggerD("Enter");
+ ScopeLogger();
if (!isValid(str)) {
LoggerD("Invalid string %s", str.c_str());
LoggerW("throw NotFoundException");
m_unzip(NULL),
m_default_buffer_size(1024 * 1024),
m_is_open(false) {
- LoggerD("Entered");
+ ScopeLogger();
m_unzip = unzOpen(filename.c_str());
}
UnZip::~UnZip() {
- LoggerD("Enter");
+ ScopeLogger();
for (auto& x : path_access_map) {
LoggerD("Setting permission for path: %s [%d] ", x.first.c_str(), x.second);
if (chmod(x.first.c_str(), x.second) == -1) {
}
PlatformResult UnZip::close() {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_open) {
LoggerD("Unzip already closed - exiting");
return PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult UnZip::open(const std::string& filename, UnZipPtr* out_unzip) {
- LoggerD("Entered");
+ ScopeLogger();
UnZipPtr unzip = UnZipPtr(new UnZip(filename));
if (!unzip->m_unzip) {
PlatformResult UnZip::listEntries(unsigned long* decompressedSize,
ArchiveFileEntryPtrMapPtr* out_map) {
- LoggerD("Enter");
+ ScopeLogger();
if (!m_is_open) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Failed to get list of files in zip archive");
}
PlatformResult UnZip::extractAllFilesTo(const std::string& extract_path,
ExtractAllProgressCallback* callback) {
- LoggerD("Enter");
+ ScopeLogger();
if (!m_is_open) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Failed to extract zip archive");
}
};
PlatformResult UnZip::extractTo(ExtractEntryProgressCallback* callback) {
- LoggerD("Enter");
+ ScopeLogger();
if (!m_is_open) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Extract archive file entry failed");
}
PlatformResult UnZip::extractItFunction(const std::string& file_name, unz_file_info& file_info,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
ExtractDataHolder* h = static_cast<ExtractDataHolder*>(user_data);
if (!h) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not list content of zip archive",
OperationCallbackData* callback,
UnZip::IterateFunction itfunc,
unsigned int& num_file_or_folder_matched, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
int err = unzGoToFirstFile(m_unzip);
if (UNZ_OK != err) {
LoggerW("%s", getArchiveLogMessage(err, "unzGoToFirstFile()").c_str());
PlatformResult UnZip::extractCurrentFile(const std::string& extract_path,
const std::string& base_strip_path,
BaseProgressCallback* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (callback->isCanceled()) {
return LogAndCreateResult(ErrorCode::OPERATION_CANCELED_ERR, "Operation canceled");
PlatformResult generateArchiveStatistics(const std::string& file_name, unz_file_info& file_info,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
if (user_data) {
ArchiveStatistics* astats = static_cast<ArchiveStatistics*>(user_data);
astats->uncompressed_size += file_info.uncompressed_size;
PlatformResult UnZip::updateCallbackWithArchiveStatistics(ExtractAllProgressCallback* callback,
unz_global_info& out_global_info,
const std::string& optional_filter) {
- LoggerD("Enter");
+ ScopeLogger();
int err = unzGetGlobalInfo(m_unzip, &out_global_info);
if (UNZ_OK != err) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
using common::tools::GetErrorString;
FilePathStatus getPathStatus(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
if (path.empty()) {
return FPS_NOT_EXIST;
}
void divideToPathAndName(const std::string& filepath, std::string& out_path,
std::string& out_name) {
- LoggerD("Enter");
+ ScopeLogger();
size_t pos_last_dir = filepath.find_last_of("/\\");
if (pos_last_dir == std::string::npos) {
out_path = "";
}
void createMissingDirectories(const std::string& path, bool check_first = true) {
- LoggerD("Enter");
+ ScopeLogger();
if (check_first) {
const FilePathStatus path_status = getPathStatus(path);
// LoggerD("[%s] status: %d", path.c_str(), path_status);
}
void changeFileAccessAndModifyDate(const std::string& filepath, tm_unz tmu_date) {
- LoggerD("Enter");
+ ScopeLogger();
struct utimbuf ut;
struct tm newdate;
newdate.tm_sec = tmu_date.tm_sec;
PlatformResult UnZipExtractRequest::execute(UnZip& owner, const std::string& extract_path,
const std::string& base_strip_path,
BaseProgressCallback* callback) {
- LoggerD("Enter");
+ ScopeLogger();
UnZipExtractRequest req(owner, extract_path, base_strip_path, callback);
if (!req.m_callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Problem with callback functionality",
m_new_dir_status(FPS_NOT_EXIST),
m_is_directory_entry(false) {
- LoggerD("Enter");
+ ScopeLogger();
m_filename_inzip[0] = '\0';
}
PlatformResult UnZipExtractRequest::run() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult result = getCurrentFileInfo();
if (result.error_code() != ErrorCode::NO_ERROR) {
}
UnZipExtractRequest::~UnZipExtractRequest() {
- LoggerD("Enter");
+ ScopeLogger();
if (m_output_file) {
fclose(m_output_file);
}
PlatformResult UnZipExtractRequest::getCurrentFileInfo() {
- LoggerD("Entered");
+ ScopeLogger();
int err = unzGetCurrentFileInfo(m_owner.m_unzip, &m_file_info, m_filename_inzip,
sizeof(m_filename_inzip), NULL, 0, NULL, 0);
if (err != UNZ_OK) {
}
PlatformResult UnZipExtractRequest::handleDirectoryEntry() {
- LoggerD("Entered");
+ ScopeLogger();
if (FPS_DIRECTORY != m_new_dir_status) {
if (FPS_FILE == m_new_dir_status) {
if (m_callback->getOverwrite()) { // Is a file & overwrite is set:
}
PlatformResult UnZipExtractRequest::prepareOutputSubdirectory() {
- LoggerD("Entered");
+ ScopeLogger();
// This zip entry points to file - verify that parent directory in output dir exists
if (FPS_DIRECTORY != m_new_dir_status) {
if (FPS_FILE == m_new_dir_status) {
}
PlatformResult UnZipExtractRequest::handleFileEntry() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult result = prepareOutputSubdirectory();
if (result.error_code() != ErrorCode::NO_ERROR) {
using namespace common;
void Zip::generateZipFileInfo(const std::string& filename, zip_fileinfo& out_zi) {
- LoggerD("Enter");
+ ScopeLogger();
memset(&out_zi, 0, sizeof(zip_fileinfo));
Zip::Zip(const std::string& filename, ZipOpenMode open_mode)
: m_zipfile_name(filename), m_zip(NULL), m_default_buffer_size(1024 * 1024), m_is_open(false) {
- LoggerD("Entered");
+ ScopeLogger();
int append_mode = APPEND_STATUS_CREATE;
if (ZOM_CREATEAFTER == open_mode) {
}
Zip::~Zip() {
- LoggerD("Enter");
+ ScopeLogger();
close();
}
PlatformResult Zip::close() {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_open) {
LoggerD("Already closed - exiting.");
return PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult Zip::createNew(const std::string& filename, ZipPtr* out_zip) {
- LoggerD("Entered");
+ ScopeLogger();
ZipPtr zip = ZipPtr(new Zip(filename, ZOM_CREATE));
if (!zip->m_zip) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Opening/creating zip file failed",
}
PlatformResult Zip::open(const std::string& filename, ZipPtr* out_zip) {
- LoggerD("Entered");
+ ScopeLogger();
ZipPtr zip = ZipPtr(new Zip(filename, ZOM_ADDINZIP));
if (!zip->m_zip) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Opening/creating zip file failed",
}
PlatformResult Zip::addFile(AddProgressCallback*& callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not add file(-s) to archive",
("callback is NULL!"));
m_bytes_compressed(0),
m_compression_level(0),
m_new_file_in_zip_opened(false) {
- LoggerD("Enter");
+ ScopeLogger();
}
ZipAddRequest::~ZipAddRequest() {
- LoggerD("Enter");
+ ScopeLogger();
if (m_input_file) {
fclose(m_input_file);
m_input_file = NULL;
}
PlatformResult ZipAddRequest::execute(Zip& owner, AddProgressCallback*& callback) {
- LoggerD("Enter");
+ ScopeLogger();
ZipAddRequest req(owner, callback);
return req.run();
}
PlatformResult ZipAddRequest::run() {
- LoggerD("Enter");
+ ScopeLogger();
if (!m_callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Could not add file(-s) to archive",
("m_callback is NULL"));
void ZipAddRequest::addNodeAndSubdirsToList(filesystem::NodePtr src_node,
filesystem::NodeList& out_list_of_child_nodes) {
- LoggerD("Enter");
+ ScopeLogger();
out_list_of_child_nodes.push_back(src_node);
if (filesystem::NT_DIRECTORY == src_node->getType()) {
}
PlatformResult ZipAddRequest::addEmptyDirectoryToZipArchive(std::string name_in_zip) {
- LoggerD("Entered name_in_zip:%s", name_in_zip.c_str());
+ ScopeLogger("name_in_zip: %s", name_in_zip.c_str());
if (name_in_zip.length() == 0) {
LoggerW("Trying to create directory with empty name - \"\"");
}
PlatformResult ZipAddRequest::addToZipArchive(filesystem::NodePtr src_file_node) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string name_in_zip =
getNameInZipArchiveFor(src_file_node, m_callback->getFileEntry()->getStriped());
const std::string src_file_path = src_file_node->getPath()->getFullPath();
}
std::string removeDirCharsFromFront(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
for (size_t i = 0; i < path.length(); ++i) {
const char& cur = path[i];
if (cur != '/' && cur != '\\') {
}
std::string generateFullPathForZip(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
// Step 1: Remove / from begining
const size_t path_len = path.length();
}
std::string ZipAddRequest::getNameInZipArchiveFor(filesystem::NodePtr node, bool strip) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string node_full_path = node->getPath()->getFullPath();
std::string cut_path;
using namespace extension::badge;
BadgeInstance::BadgeInstance() : manager_(*this) {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
BadgeInstance::~BadgeInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
void BadgeInstance::BadgeManagerSetBadgeCount(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
std::string app_id = common::FromJson<std::string>(args.get<JsonObject>(), "appId");
}
void BadgeInstance::BadgeManagerGetBadgeCount(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
std::string app_id = common::FromJson<std::string>(args.get<JsonObject>(), "appId");
}
void BadgeInstance::BadgeManagerAddChangeListener(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
PlatformResult status = manager_.AddChangeListener(args.get<JsonObject>());
}
void BadgeInstance::BadgeManagerRemoveChangeListener(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
PlatformResult status = manager_.RemoveChangeListener(args.get<JsonObject>());
}
BadgeManager::~BadgeManager() {
- LoggerD("Enter");
+ ScopeLogger();
if (is_cb_registered_) {
if (!watched_applications_.empty()) watched_applications_.clear();
int ret = badge_unregister_changed_cb(badge_changed_cb);
}
PlatformResult BadgeManager::SetBadgeCount(const std::string &app_id, unsigned int count) {
- LoggerD("Enter");
+ ScopeLogger();
SLoggerD("app_id : %s ", app_id.c_str());
if (!IsAppInstalled(app_id)) {
}
PlatformResult BadgeManager::GetBadgeCount(const std::string &app_id, unsigned int *count) {
- LoggerD("Enter");
+ ScopeLogger();
SLoggerD("app_id : %s ", app_id.c_str());
Assert(count);
}
PlatformResult BadgeManager::AddChangeListener(const JsonObject &obj) {
- LoggerD("Enter");
+ ScopeLogger();
auto &items = FromJson<picojson::array>(obj, "appIdList");
for (auto item : items) {
watched_applications_.insert(common::JsonCast<std::string>(item));
}
PlatformResult BadgeManager::RemoveChangeListener(const JsonObject &obj) {
- LoggerD("Enter");
+ ScopeLogger();
auto &items = FromJson<picojson::array>(obj, "appIdList");
for (auto item : items) {
watched_applications_.erase(common::JsonCast<std::string>(item));
void BadgeManager::badge_changed_cb(unsigned int action, const char *pkgname, unsigned int count,
void *user_data) {
- LoggerD("Enter");
+ ScopeLogger();
BadgeManager *that = static_cast<BadgeManager *>(user_data);
if (action == BADGE_ACTION_UPDATE &&
that->watched_applications_.find(pkgname) != that->watched_applications_.end()) {
}
bool BadgeManager::IsAppInstalled(const std::string &app_id) {
- LoggerD("Enter");
+ ScopeLogger();
if (app_id.empty()) {
return false;
}
static bool IsValidAddress(const std::string& address) {
+ ScopeLogger();
static pcrecpp::RE re("(([0-9a-zA-Z]+):)+([0-9a-zA-Z]+)");
static std::string compare_address = "00:12:47:08:9A:A6";
}
static bool IsValidUUID(const std::string& uuid) {
+ ScopeLogger();
static pcrecpp::RE re("(([0-9a-zA-Z]+)-)+([0-9a-zA-Z]+)");
static std::string compare_uuid = "00001101-0000-1000-8000-00805F9B34FB";
}
void BluetoothAdapter::StateChangedCB(int result, bt_adapter_state_e state, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
if (!adapter) {
}
void BluetoothAdapter::NameChangedCB(char* name, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
if (!adapter) {
void BluetoothAdapter::VisibilityChangedCB(int result, bt_adapter_visibility_mode_e mode,
void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
if (!adapter) {
}
static bool ForeachBondedDevicesCB(bt_device_info_s* device_info, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
if (nullptr == user_data) {
LoggerD("user data is NULL.");
return false;
bt_adapter_device_discovery_state_e discovery_state,
bt_adapter_device_discovery_info_s* discovery_info,
void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
if (!adapter) {
requested_powered_(),
requested_visibility_(),
instance_(instance) {
- LoggerD("Entered");
+ ScopeLogger();
if (BT_ERROR_NONE == bt_initialize()) {
LoggerD("Bluetooth service is initialized.");
is_initialized_ = true;
}
BluetoothAdapter::~BluetoothAdapter() {
+ ScopeLogger();
bt_socket_unset_data_received_cb();
bt_socket_unset_connection_state_changed_cb();
}
std::string BluetoothAdapter::get_name() const {
+ ScopeLogger();
char* name = nullptr;
std::string str_name = "";
if (BT_ERROR_NONE == bt_adapter_get_name(&name)) {
}
bool BluetoothAdapter::get_visible() const {
+ ScopeLogger();
bt_adapter_visibility_mode_e mode;
if (BT_ERROR_NONE == bt_adapter_get_visibility(&mode, NULL)) {
}
void BluetoothAdapter::SetName(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
}
void BluetoothAdapter::SetPowered(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: setPowered() is deprecated and will be removed from next release. "
"Let the user turn on/off Bluetooth through the Settings application instead.");
}
void BluetoothAdapter::SetVisible(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothManager,
&out);
}
void BluetoothAdapter::DiscoverDevices(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothGap,
&out);
}
void BluetoothAdapter::StopDiscovery(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothGap,
&out);
}
void BluetoothAdapter::GetKnownDevices(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothGap,
&out);
}
void BluetoothAdapter::GetDevice(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothGap,
&out);
const auto& address = FromJson<std::string>(args, "address");
auto get_device = [this, address](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function");
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
if (!IsValidAddress(address)) {
ret = LogAndCreateResult(ErrorCode::NOT_FOUND_ERR, "Wrong address");
auto get_device_response =
[this, callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function");
instance_.SyncResponse(callback_handle, response);
};
public:
BondingHandler(BluetoothInstance& instance, double callback_handle, const std::string& address)
: instance_(instance), callback_handle_(callback_handle), address_(address) {
+ ScopeLogger();
}
void set_address(const std::string& address) {
}
void Invoke(const PlatformResult& result, const std::shared_ptr<picojson::value>& response) {
- LoggerD("Entered");
+ ScopeLogger();
if (result.IsError()) {
LogAndReportError(result, &response->get<picojson::object>());
};
void BluetoothAdapter::CreateBonding(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothGap,
&out);
const auto& address = FromJson<std::string>(args, "address");
auto create_bonding = [address, callback_handle, this]() -> void {
+ ScopeLogger("Entered into asynchronous function, create_bonding");
PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
if (!IsValidAddress(address)) {
result = LogAndCreateResult(ErrorCode::NOT_FOUND_ERR, "Wrong address",
if (result.IsSuccess() && this->get_powered()) {
auto bond_create_callback = [](int callback_result, bt_device_info_s* device_info,
void* user_data) {
- LoggerD("bond_create_callback");
+ ScopeLogger("Entered into asynchronous function, bond_create_callback");
BondingHandler* handler = static_cast<BondingHandler*>(user_data);
if (!handler) {
}
void BluetoothAdapter::DestroyBonding(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothGap,
&out);
const auto& address = FromJson<std::string>(args, "address");
auto destroy_bonding = [address, callback_handle, this]() -> void {
+ ScopeLogger("Entered into asynchronous function, destroy_bonding");
PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
if (!IsValidAddress(address)) {
result = LogAndCreateResult(ErrorCode::NOT_FOUND_ERR, "Wrong address",
void BluetoothAdapter::RegisterRFCOMMServiceByUUID(const picojson::value& data,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothSpp,
&out);
const auto& name = FromJson<std::string>(args, "name");
auto rfcomm = [this, uuid, name](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, rfcomm");
PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
if (!this->is_initialized()) {
result = LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
auto rfcomm_response =
[this, callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, rfcomm_response");
instance_.SyncResponse(callback_handle, response);
};
}
void BluetoothAdapter::UnregisterUUID(const std::string& uuid, int callback_handle) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
if (!IsValidUUID(uuid)) {
void BluetoothAdapter::GetBluetoothProfileHandler(const picojson::value& data,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& args = util::GetArguments(data);
auto profile = FromJson<std::string>(args, "profileType");
}
void BluetoothAdapter::GetName(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
ReportSuccess(picojson::value(get_name()), out);
}
void BluetoothAdapter::GetAddress(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!is_initialized_) {
LogAndReportError(
}
void BluetoothAdapter::GetPowered(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
ReportSuccess(picojson::value(is_powered_), out);
}
void BluetoothAdapter::GetVisible(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
ReportSuccess(picojson::value(get_visible()), out);
}
void BluetoothAdapter::OnSocketConnected(int result, bt_socket_connection_state_e state,
bt_socket_connection_s* connection, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
BluetoothAdapter* object = static_cast<BluetoothAdapter*>(user_data);
}
void BluetoothAdapter::OnSocketReceivedData(bt_socket_received_data_s* data, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
BluetoothAdapter* object = static_cast<BluetoothAdapter*>(user_data);
void BluetoothAdapter::ConnectToServiceByUUID(const std::string& address, const std::string& uuid,
double callback_handle) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
}
void BluetoothAdapter::InvokeSocketEvent(int id, const char* event) {
+ ScopeLogger();
picojson::value value = picojson::value(picojson::object());
picojson::object& value_obj = value.get<picojson::object>();
value_obj.insert(std::make_pair("id", picojson::value(std::to_string(id))));
}
void BluetoothAdapter::InvokeSocketOnMessageEvent(int id) {
+ ScopeLogger();
InvokeSocketEvent(id, "onmessage");
}
void BluetoothAdapter::InvokeSocketOnCloseEvent(int id) {
+ ScopeLogger();
InvokeSocketEvent(id, "onclose");
}
void BluetoothAdapter::RemoveSocket(int socket) {
+ ScopeLogger();
const auto data_it = socket_data_.find(socket);
if (data_it != socket_data_.end()) {
}
void BluetoothAdapter::StoreSocketData(bt_socket_received_data_s* data) {
- LoggerD("Entered");
+ ScopeLogger();
auto& data_store = socket_data_[data->socket_fd];
}
const std::list<char>& BluetoothAdapter::ReadSocketData(int socket) {
- LoggerD("Entered");
+ ScopeLogger();
return socket_data_[socket];
}
void BluetoothAdapter::ClearSocketData(int socket) {
- LoggerD("Entered");
+ ScopeLogger();
const auto data_it = socket_data_.find(socket);
}
void BluetoothAdapter::IsServiceConnected(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& args = util::GetArguments(data);
const auto& uuid = FromJson<std::string>(args, "uuid");
{BT_MAJOR_SERVICE_CLASS_INFORMATION, 0x0400}};
unsigned long BluetoothClass::GetMajorValue(bt_major_device_class_e major) {
- LoggerD("Enter");
+ ScopeLogger();
auto iter = g_major_enum_map.find(major);
if (iter != g_major_enum_map.end()) {
return iter->second;
}
unsigned long BluetoothClass::GetMinorValue(bt_minor_device_class_e minor) {
- LoggerD("Enter");
+ ScopeLogger();
auto iter = g_minor_enum_map.find(minor);
if (iter != g_minor_enum_map.end()) {
return iter->second;
}
std::vector<unsigned long> BluetoothClass::getServiceValues(int serviceMask) {
- LoggerD("Enter");
+ ScopeLogger();
std::vector<unsigned long> ret;
for (auto iter = g_service_enum_map.begin(); iter != g_service_enum_map.end(); iter++) {
if (iter->first & serviceMask) {
}
static void ToJsonFromBTClass(bt_class_s bluetooth_class, picojson::object* device) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object& bt =
device->insert(std::make_pair(kDeviceClass, picojson::value(picojson::object())))
}
static void ToJsonFromUUID(char** service_uuid, int service_count, picojson::object* device) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::array& array =
device->insert(std::make_pair(kDeviceUuids, picojson::value(picojson::array())))
}
BluetoothDevice::BluetoothDevice(BluetoothAdapter& adapter) : adapter_(adapter) {
+ ScopeLogger();
}
void BluetoothDevice::ToJson(bt_device_info_s* info, picojson::object* device) {
- LoggerD("Entered");
+ ScopeLogger();
device->insert(std::make_pair(kDeviceName, picojson::value(std::string(info->remote_name))));
device->insert(
std::make_pair(kDeviceAddress, picojson::value(std::string(info->remote_address))));
}
void BluetoothDevice::ToJson(bt_adapter_device_discovery_info_s* info, picojson::object* device) {
- LoggerD("Entered");
+ ScopeLogger();
device->insert(std::make_pair(kDeviceName, picojson::value(info->remote_name)));
device->insert(std::make_pair(kDeviceAddress, picojson::value(info->remote_address)));
}
void BluetoothDevice::ConnectToServiceByUUID(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothSpp,
&out);
}
void BluetoothDevice::GetBoolValue(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& args = util::GetArguments(data);
const auto& address = FromJson<std::string>(args, "address");
}
BluetoothGATTService::BluetoothGATTService(BluetoothInstance& instance) : instance_(instance) {
- LoggerD("Entered");
+ ScopeLogger();
}
BluetoothGATTService::~BluetoothGATTService() {
- LoggerD("Entered");
+ ScopeLogger();
for (auto it : gatt_characteristic_) {
// unregister callback, ignore errors
}
bt_gatt_client_h BluetoothGATTService::GetGattClient(const std::string& address) {
- LoggerD("Entered");
+ ScopeLogger();
bt_gatt_client_h client = nullptr;
// this method should be used to inform this object that some device was disconnected
void BluetoothGATTService::TryDestroyClient(const std::string& address) {
+ ScopeLogger();
auto it = gatt_clients_.find(address);
if (gatt_clients_.end() != it) {
LoggerD("destroying client for address: %s", it->first.c_str());
PlatformResult BluetoothGATTService::GetSpecifiedGATTService(const std::string& address,
const std::string& uuid,
picojson::object* result) {
- LoggerD("Entered");
+ ScopeLogger();
bt_gatt_client_h client = GetGattClient(address);
}
void BluetoothGATTService::GetServices(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
bt_gatt_h handle = (bt_gatt_h) static_cast<long>(args.get("handle").get<double>());
const std::string& address = args.get("address").get<std::string>();
PlatformResult BluetoothGATTService::GetServicesHelper(bt_gatt_h handle, const std::string& address,
picojson::array* array) {
- LoggerD("Entered");
+ ScopeLogger();
if (!IsStillConnected(address)) {
return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR, "Device is not connected",
int ret = bt_gatt_service_foreach_included_services(
handle,
[](int total, int index, bt_gatt_h gatt_handle, void* data) {
- LoggerD("Enter");
+ ScopeLogger(
+ "Entered into asynchronous function, argument in "
+ "bt_gatt_service_foreach_included_services");
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
}
void BluetoothGATTService::GetCharacteristics(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
bt_gatt_h handle = (bt_gatt_h) static_cast<long>(args.get("handle").get<double>());
const std::string& uuid = args.get("uuid").get<std::string>();
const std::string& address,
const std::string& uuid,
picojson::array* array) {
- LoggerD("Entered");
+ ScopeLogger();
if (!IsStillConnected(address)) {
return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR, "Device is not connected",
int ret = bt_gatt_service_foreach_characteristics(
handle,
[](int total, int index, bt_gatt_h gatt_handle, void* data) {
- LoggerD("Enter");
+ ScopeLogger(
+ "Entered into asynchronous function, bt_gatt_service_foreach_characteristics's "
+ "argument");
Data* user_data = static_cast<Data*>(data);
picojson::array* array = user_data->array;
PlatformResult* platform_result = user_data->platform_res;
int ret = bt_gatt_characteristic_foreach_descriptors(
gatt_handle,
[](int total, int index, bt_gatt_h desc_handle, void* data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array& desc_array = *(static_cast<picojson::array*>(data));
picojson::value desc = picojson::value(picojson::object());
}
void BluetoothGATTService::ReadValue(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
bt_gatt_h handle = (bt_gatt_h) static_cast<long>(args.get("handle").get<double>());
auto read_value = [](int result, bt_gatt_h handle, void* user_data) -> void {
+ ScopeLogger("Entered into asynchronous function, read_value");
Data* data = static_cast<Data*>(user_data);
double callback_handle = data->callback_handle;
BluetoothGATTService* service = data->service;
}
void BluetoothGATTService::WriteValue(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
bt_gatt_h handle = (bt_gatt_h) static_cast<long>(args.get("handle").get<double>());
auto write_value = [](int result, bt_gatt_h handle, void* user_data) -> void {
+ ScopeLogger("Entered into asynchronous function, write_value");
Data* data = static_cast<Data*>(user_data);
double callback_handle = data->callback_handle;
BluetoothGATTService* service = data->service;
void BluetoothGATTService::AddValueChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& address = args.get("address").get<std::string>();
if (!IsStillConnected(address)) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Device is not connected"), &out,
void BluetoothGATTService::RemoveValueChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& address = args.get("address").get<std::string>();
if (!IsStillConnected(address)) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Device is not connected"), &out,
common::PlatformResult BluetoothGATTService::GetServiceAllUuids(const std::string& address,
picojson::array* array) {
- LoggerD("Entered");
+ ScopeLogger();
bt_gatt_client_h client = GetGattClient(address);
}
auto foreach_callback = [](int total, int index, bt_gatt_h gatt_handle, void* user_data) -> bool {
- LoggerD("Entered foreach_callback, total: %d, index: %d", total, index);
+ ScopeLogger("Entered into asynchronous function, foreach_callback, total: %d, index: %d", total,
+ index);
char* uuid = nullptr;
int ret = bt_gatt_get_uuid(gatt_handle, &uuid);
void BluetoothGATTService::OnCharacteristicValueChanged(bt_gatt_h characteristic, char* value,
int length, void* user_data) {
- LoggerD("Entered, characteristic: [%p], len: [%d], user_data: [%p]", characteristic, length,
- user_data);
+ ScopeLogger("characteristic: [%p], len: [%d], user_data: [%p]", characteristic, length,
+ user_data);
auto service = static_cast<BluetoothGATTService*>(user_data);
BluetoothHealthApplication::BluetoothHealthApplication(BluetoothHealthProfileHandler& handler)
: handler_(handler) {
+ ScopeLogger();
}
void BluetoothHealthApplication::Unregister(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothHealth,
&out);
void BluetoothHealthApplication::ToJson(short data_type, const std::string& name, const char* id,
picojson::object* out) {
+ ScopeLogger();
out->insert(std::make_pair(kDataType, picojson::value(static_cast<double>(data_type))));
out->insert(std::make_pair(kName, picojson::value(name)));
out->insert(std::make_pair(kId, picojson::value(id)));
} // namespace
void BluetoothHealthChannel::Close(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothHealth,
&out);
}
void BluetoothHealthChannel::SendData(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothHealth,
&out);
void BluetoothHealthChannel::ToJson(unsigned int channel, bt_hdp_channel_type_e type,
picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
const char* type_str = "UNKNOWN";
switch (type) {
void BluetoothHealthChannel::ToJson(unsigned int channel, bt_hdp_channel_type_e type,
bt_device_info_s* device_info, const char* app_id,
picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
ToJson(channel, type, out);
auto& device = out->insert(std::make_pair(kPeer, picojson::value(picojson::object())))
.first->second.get<picojson::object>();
BluetoothHealthProfileHandler::BluetoothHealthProfileHandler(BluetoothInstance& instance)
: instance_(instance) {
// initialize listeners
- LoggerD("Entered");
+ ScopeLogger();
if (BT_ERROR_NONE != bt_hdp_set_connection_state_changed_cb(OnConnected, OnDisconnected, this)) {
LoggerE("bt_hdp_set_connection_state_changed_cb() failed");
}
}
BluetoothHealthProfileHandler::~BluetoothHealthProfileHandler() {
- LoggerD("Entered");
+ ScopeLogger();
bt_hdp_unset_connection_state_changed_cb();
bt_hdp_unset_data_received_cb();
void BluetoothHealthProfileHandler::OnConnected(int result, const char* remote_address,
const char* app_id, bt_hdp_channel_type_e type,
unsigned int channel, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
BluetoothHealthProfileHandler* object = static_cast<BluetoothHealthProfileHandler*>(user_data);
void BluetoothHealthProfileHandler::OnDisconnected(int result, const char* /* remote_address */,
unsigned int channel, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
BluetoothHealthProfileHandler* object = static_cast<BluetoothHealthProfileHandler*>(user_data);
void BluetoothHealthProfileHandler::OnDataReceived(unsigned int channel, const char* data,
unsigned int size, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
BluetoothHealthProfileHandler* object = static_cast<BluetoothHealthProfileHandler*>(user_data);
void BluetoothHealthProfileHandler::RegisterSinkApp(const picojson::value& data,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothHealth,
&out);
auto register_app = [data_type, name,
this](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult platform_result = PlatformResult(ErrorCode::NO_ERROR);
char* app_id = nullptr;
auto register_app_response =
[this, callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, register_app_response");
instance_.SyncResponse(callback_handle, response);
};
void BluetoothHealthProfileHandler::ConnectToSource(const picojson::value& data,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothHealth,
&out);
void BluetoothHealthProfileHandler::UnregisterSinkAppAsync(const std::string& app_id,
int callback_handle) {
- LoggerD("Entered");
+ ScopeLogger();
auto unregister_app = [app_id, this](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Entered");
+ ScopeLogger("Entered into asynchronous function, uregister_app");
PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
auto iter = this->registered_health_apps_.find(app_id);
auto unregister_app_response =
[this, callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, unregister_app_response");
instance_.SyncResponse(callback_handle, response);
};
bluetooth_le_adapter_(*this),
bluetooth_gatt_service_(*this),
bluetooth_le_device_(*this, bluetooth_gatt_service_) {
- LoggerD("Entered");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
BluetoothInstance::~BluetoothInstance() {
- LoggerD("Entered");
+ ScopeLogger();
}
namespace {
void BluetoothInstance::AsyncResponse(double callback_handle,
const std::shared_ptr<picojson::value>& response) {
- LoggerD("Entered");
+ ScopeLogger();
common::TaskQueue::GetInstance().Async<picojson::value>(
[this, callback_handle](const std::shared_ptr<picojson::value>& response) {
SyncResponse(callback_handle, response);
}
void BluetoothInstance::AsyncResponse(double callback_handle, const PlatformResult& result) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<picojson::value> response =
std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
TaskQueue::GetInstance().Async<picojson::value>(
[this, callback_handle](const std::shared_ptr<picojson::value>& response) {
+ ScopeLogger("Entered into asynchronous response");
SyncResponse(callback_handle, response);
},
response);
void BluetoothInstance::SyncResponse(double callback_handle,
const std::shared_ptr<picojson::value>& response) {
- LoggerD("Entered");
+ ScopeLogger();
auto& obj = response->get<picojson::object>();
obj[JSON_CALLBACK_ID] = picojson::value(callback_handle);
Instance::PostMessage(this, response->serialize().c_str());
}
void BluetoothInstance::FireEvent(const std::string& event, picojson::value& value) {
- LoggerD("Entered");
+ ScopeLogger();
auto& obj = value.get<picojson::object>();
obj[JSON_LISTENER_ID] = picojson::value(event);
Instance::PostMessage(this, value.serialize().c_str());
}
void BluetoothInstance::FireEvent(const std::string& event, const picojson::value& value) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value v{value};
FireEvent(event, v);
}
void BluetoothInstance::FireEvent(const std::string& event,
const std::shared_ptr<picojson::value>& value) {
- LoggerD("Entered");
+ ScopeLogger();
FireEvent(event, *value.get());
}
class ParsedDataHolder {
public:
ParsedDataHolder() : valid_(false) {
+ ScopeLogger();
}
virtual ~ParsedDataHolder() {
+ ScopeLogger();
}
bool valid() const {
}
void Parse(const std::string& d) {
+ ScopeLogger();
const char* p_data = d.c_str();
int size = d.length();
if (size > 2 && (d.find("0x", 0) == 0 || d.find("0X", 0) == 0)) {
private:
static bool ParseUUID(const picojson::value& obj, BluetoothLEServiceData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& uuid = obj.get("uuid");
if (uuid.is<std::string>()) {
out->uuid_ = uuid.get<std::string>();
}
static bool ParseData(const picojson::value& obj, BluetoothLEServiceData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& data = obj.get("data");
if (data.is<std::string>()) {
out->data_.Parse(data.get<std::string>());
}
static bool Construct(const picojson::value& obj, BluetoothLEManufacturerData* out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!obj.is<picojson::object>() || !ParseId(obj, out) || !ParseData(obj, out)) {
return false;
}
private:
static bool ParseId(const picojson::value& obj, BluetoothLEManufacturerData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& id = obj.get("id");
if (id.is<std::string>()) {
out->id_ = id.get<std::string>();
}
static bool ParseData(const picojson::value& obj, BluetoothLEManufacturerData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& val_data = obj.get("data");
include_name_(false),
appearance_(0), // 0 means unknown
include_tx_power_level_(false) {
+ ScopeLogger();
}
bool include_name() const {
}
static bool Construct(const picojson::value& obj, BluetoothLEAdvertiseData* out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!obj.is<picojson::object>() || !ParseIncludeName(obj, out) ||
!ParseServiceUUIDs(obj, out) || !ParseSolicitationUUIDs(obj, out) ||
!ParseAppearance(obj, out) || !ParseIncludeTxPowerLevel(obj, out) ||
private:
static bool ParseIncludeName(const picojson::value& obj, BluetoothLEAdvertiseData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& include_name = obj.get("includeName");
if (include_name.is<bool>()) {
out->include_name_ = include_name.get<bool>();
}
static bool ParseServiceUUIDs(const picojson::value& obj, BluetoothLEAdvertiseData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& service_uuids = obj.get("uuids");
if (service_uuids.is<picojson::array>()) {
for (const auto& i : service_uuids.get<picojson::array>()) {
}
static bool ParseSolicitationUUIDs(const picojson::value& obj, BluetoothLEAdvertiseData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& solicitation_uuids = obj.get("solicitationuuids");
if (solicitation_uuids.is<picojson::array>()) {
for (const auto& i : solicitation_uuids.get<picojson::array>()) {
}
static bool ParseAppearance(const picojson::value& obj, BluetoothLEAdvertiseData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& appearance = obj.get("appearance");
if (appearance.is<double>()) {
out->appearance_ = static_cast<decltype(appearance_)>(appearance.get<double>());
}
static bool ParseIncludeTxPowerLevel(const picojson::value& obj, BluetoothLEAdvertiseData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& include_tx_power_level = obj.get("includeTxPowerLevel");
if (include_tx_power_level.is<bool>()) {
out->include_tx_power_level_ = include_tx_power_level.get<bool>();
}
static bool ParseServiceData(const picojson::value& obj, BluetoothLEAdvertiseData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& service_data = obj.get("serviceData");
BluetoothLEServiceData data;
if (BluetoothLEServiceData::Construct(service_data, &data)) {
}
static bool ParseManufacturerData(const picojson::value& obj, BluetoothLEAdvertiseData* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& manufacturer_data = obj.get("manufacturerData");
BluetoothLEManufacturerData data;
if (BluetoothLEManufacturerData::Construct(manufacturer_data, &data)) {
BluetoothLEAdapter::BluetoothLEAdapter(BluetoothInstance& instance)
: instance_(instance), enabled_(false), scanning_(false), bt_advertiser_(nullptr) {
- LoggerD("Entered");
+ ScopeLogger();
bt_adapter_le_state_e le_state = BT_ADAPTER_LE_DISABLED;
}
BluetoothLEAdapter::~BluetoothLEAdapter() {
- LoggerD("Entered");
+ ScopeLogger();
bt_adapter_le_unset_state_changed_cb();
if (scanning_) {
bt_adapter_le_stop_scan();
}
void BluetoothLEAdapter::StartScan(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
}
void BluetoothLEAdapter::StopScan(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
}
void BluetoothLEAdapter::StartAdvertise(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
}
void BluetoothLEAdapter::StopAdvertise(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
void BluetoothLEAdapter::OnStateChanged(int result, bt_adapter_le_state_e adapter_le_state,
void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
auto adapter = static_cast<BluetoothLEAdapter*>(user_data);
void BluetoothLEAdapter::OnScanResult(int result, bt_adapter_le_device_scan_result_info_s* info,
void* user_data) {
- LoggerD("Entered, result: %d, info: %p, data: %p", result, info, user_data);
+ ScopeLogger("result: %d, info: %p, data: %p", result, info, user_data);
auto adapter = static_cast<BluetoothLEAdapter*>(user_data);
void BluetoothLEAdapter::OnAdvertiseResult(int result, bt_advertiser_h advertiser,
bt_adapter_le_advertising_state_e adv_state,
void* user_data) {
- LoggerD("Entered, result: %d, advertiser: %p, adv_state: %d, user_data: %p", result, advertiser,
- adv_state, user_data);
+ ScopeLogger("result: %d, advertiser: %p, adv_state: %d, user_data: %p", result, advertiser,
+ adv_state, user_data);
auto adapter = static_cast<BluetoothLEAdapter*>(user_data);
BluetoothLEDevice::BluetoothLEDevice(BluetoothInstance& instance, BluetoothGATTService& service)
: instance_(instance), service_(service), is_listener_set_(false) {
- LoggerD("Entered");
+ ScopeLogger();
int ret = bt_gatt_set_connection_state_changed_cb(GattConnectionState, this);
if (BT_ERROR_NONE != ret && BT_ERROR_ALREADY_DONE != ret) {
LoggerE("Can't add connection state listener: %d", ret);
}
BluetoothLEDevice::~BluetoothLEDevice() {
- LoggerD("Entered");
+ ScopeLogger();
int ret = bt_gatt_unset_connection_state_changed_cb();
if (ret != BT_ERROR_NONE) {
LoggerW("Failed to unset listener: %d", ret);
static void UUIDsToJson(char** service_uuid, int service_count, const std::string& field,
picojson::object* le_device) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::array& array =
le_device->insert(std::make_pair(field, picojson::value(picojson::array())))
static void ServiceDataToJson(bt_adapter_le_service_data_s* service_data_list,
int service_data_list_count, picojson::object* le_device) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::array& array =
le_device->insert(std::make_pair(kServiceData, picojson::value(picojson::array())))
static void ManufacturerToJson(int manufacturer_id, char* manufacturer_data, int manufacturer_count,
picojson::object* le_device) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value response = picojson::value(picojson::object());
picojson::object& response_obj = response.get<picojson::object>();
PlatformResult BluetoothLEDevice::ToJson(bt_adapter_le_device_scan_result_info_s* info,
picojson::object* le_device) {
- LoggerD("Entered");
+ ScopeLogger();
le_device->insert(
std::make_pair(kDeviceAddress, picojson::value(std::string(info->remote_address))));
}
void BluetoothLEDevice::Connect(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
}
void BluetoothLEDevice::Disconnect(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
}
void BluetoothLEDevice::GetService(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothAdmin,
&out);
void BluetoothLEDevice::AddConnectStateChangeListener(const picojson::value& data,
picojson::object& out) {
- LoggerD("Entered");
-
is_listener_set_ = true;
ReportSuccess(out);
void BluetoothLEDevice::RemoveConnectStateChangeListener(const picojson::value& data,
picojson::object& out) {
- LoggerD("Entered");
-
is_listener_set_ = false;
ReportSuccess(out);
}
void BluetoothLEDevice::GetServiceAllUuids(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& args = util::GetArguments(data);
const auto& address = common::FromJson<std::string>(args, "address");
void BluetoothLEDevice::GattConnectionState(int result, bool connected, const char* remote_address,
void* user_data) {
- LoggerD("Entered: %s connected: %d", remote_address, connected);
+ ScopeLogger("%s connected: %d", remote_address, connected);
auto le_device = static_cast<BluetoothLEDevice*>(user_data);
if (!le_device) {
}
void BluetoothServiceHandler::Unregister(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothSpp,
&out);
using namespace common::tools;
BluetoothSocket::BluetoothSocket(BluetoothAdapter& adapter) : adapter_(adapter) {
+ ScopeLogger();
}
void BluetoothSocket::WriteData(const picojson::value& data, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothSpp,
&out);
}
void BluetoothSocket::ReadData(const picojson::value& data, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothSpp,
&out);
}
void BluetoothSocket::Close(const picojson::value& data, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_BACKWARD_COMPABILITY_PRIVILEGE_ACCESS(Privilege::kBluetooth, Privilege::kBluetoothSpp,
&out);
}
picojson::value BluetoothSocket::ToJson(bt_socket_connection_s* connection) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value ret = picojson::value(picojson::object());
auto& ret_obj = ret.get<picojson::object>();
} // namespace
BookmarkInstance::BookmarkInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
BookmarkInstance::~BookmarkInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
bool BookmarkInstance::bookmark_foreach(Context& ctx, bp_bookmark_info_fmt& info) {
- LoggerD("Enter");
+ ScopeLogger();
int ids_count = 0;
int* ids = NULL;
BookmarkObject item;
}
PlatformResult BookmarkInstance::BookmarkUrlExists(const char* url, bool* exists) {
- LoggerD("Enter");
+ ScopeLogger();
int ids_count = 0;
int* ids = nullptr;
char* compare_url = nullptr;
PlatformResult BookmarkInstance::BookmarkTitleExistsInParent(const char* title, int parent,
bool* exists) {
- LoggerD("Enter");
+ ScopeLogger();
int ids_count = 0;
int compare_parent = -1;
int* ids = nullptr;
}
void BookmarkInstance::BookmarkGet(const picojson::value& arg, picojson::object& o) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeBookmarkRead, &o);
- LoggerD("Enter");
Context ctx = {0};
bp_bookmark_info_fmt info = {0};
picojson::value::array arr;
}
void BookmarkInstance::BookmarkAdd(const picojson::value& arg, picojson::object& o) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeBookmarkWrite, &o);
- LoggerD("Enter");
int saved_id = -1;
const auto& title = arg.get(kTitle).get<std::string>();
}
void BookmarkInstance::BookmarkRemove(const picojson::value& arg, picojson::object& o) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeBookmarkWrite, &o);
- LoggerD("Enter");
int id = common::stol(common::FromJson<std::string>(arg.get<picojson::object>(), kId));
int ntv_ret = bp_bookmark_adaptor_delete(id);
}
void BookmarkInstance::BookmarkRemoveAll(const picojson::value& msg, picojson::object& o) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeBookmarkWrite, &o);
- LoggerD("Enter");
int ntv_ret = bp_bookmark_adaptor_reset();
if (ntv_ret < 0) {
LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to remove bookmark"), &o);
}
void BookmarkInstance::BookmarkGetRootId(const picojson::value& msg, picojson::object& o) {
- LoggerD("Enter");
+ ScopeLogger();
int rootId(0);
int ntv_ret = bp_bookmark_adaptor_get_root(&rootId);
if (ntv_ret < 0) {
using namespace common;
Calendar::Calendar(CalendarInstance& instance) : current_db_version_(0), instance_(instance) {
+ ScopeLogger();
}
Calendar::~Calendar() {
+ ScopeLogger();
int ret;
if (listeners_registered_.find("EVENT") != listeners_registered_.end()) {
}
PlatformResult Calendar::Get(const picojson::object& args, picojson::object& out) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult Calendar::Add(const picojson::object& args, picojson::object& out) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult Calendar::AddBatch(const picojson::object& args, picojson::array& array) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult Calendar::Update(const picojson::object& args, picojson::object& /*out*/) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult Calendar::UpdateBatch(const picojson::object& args, picojson::array& array) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult Calendar::Remove(const picojson::object& args, picojson::object& out) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult Calendar::SetDefaultFilter(calendar_query_h* calendar_query, int type, int id) {
- LoggerD("Entered");
+ ScopeLogger();
const long UNIFIED_CALENDAR_ID = 0;
int error_code = 0;
}
PlatformResult Calendar::Find(const picojson::object& args, picojson::array& array) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
FilterVisitor visitor;
visitor.SetOnAttributeFilter([&](const std::string& name, AttributeMatchFlag match_flag,
const picojson::value& match_value) {
+ ScopeLogger("Entered into asynchronous function, visitor.SetOnAttributeFilter' argument");
int value = 0;
calendar_filter_h calendar_filter = nullptr;
return PlatformResult(ErrorCode::NO_ERROR);
});
visitor.SetOnCompositeFilterBegin([&](CompositeFilterType type) {
+ ScopeLogger(
+ "Entered into asynchronous function, visitor.SetOnCompositeFilterBegin's argument");
intermediate_filters.push_back(std::vector<CalendarFilterPtr>());
return PlatformResult(ErrorCode::NO_ERROR);
});
visitor.SetOnCompositeFilterEnd([&](CompositeFilterType calType) {
+ ScopeLogger("Entered into asynchronous function, visitor.SetOnCompositeFilterEnd's argument");
if (intermediate_filters.size() == 0) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Reached stack size equal to 0!");
}
visitor.SetOnAttributeRangeFilter([&](const std::string& name, const JsonValue& initial_value,
const JsonValue& end_value) {
+ ScopeLogger(
+ "Entered into asynchronous function, visitor.SetOnAttributeRangeFilter's argument");
unsigned int propertyId = 0;
if (name == "startDate" || name == "endDate" || name == "dueDate") {
PlatformResult status =
}
PlatformResult Calendar::RemoveBatch(const picojson::object& args, picojson::array& array) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult Calendar::AddChangeListener(const picojson::object& args, picojson::object& out) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult Calendar::RemoveChangeListener(const picojson::object& args, picojson::object& out) {
+ ScopeLogger();
if (!CalendarManager::GetInstance().IsConnected()) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
void Calendar::ChangeCallback(const char* view_uri, void* user_data) {
- LoggerD("enter");
+ ScopeLogger();
Calendar* c = static_cast<Calendar*>(user_data);
using namespace extension::calendar;
CalendarInstance::CalendarInstance() : calendar_(*this) {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
CalendarInstance::~CalendarInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
void CalendarInstance::CalendarGet(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
JsonValue val{JsonObject{}};
}
void CalendarInstance::CalendarAdd(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
JsonValue val{JsonObject{}};
}
void CalendarInstance::CalendarAddBatch(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
const double callback_id = args.get("callbackId").get<double>();
};
auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
- LoggerD("CalendarAddBatch->get_response");
+ ScopeLogger("Entered into asynchronous function, CalendarAddBatch->get_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
LoggerD("callback is %s", response->serialize().c_str());
}
void CalendarInstance::CalendarUpdate(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
JsonValue val{JsonObject{}};
}
void CalendarInstance::CalendarUpdateBatch(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
- LoggerD("CalendarUpdateBatch->get");
+ ScopeLogger("Entered into asynchronous function, CalendarUpdateBatch->get");
+
JsonValue result = JsonValue(JsonArray());
PlatformResult status =
calendar_.UpdateBatch(common::JsonCast<JsonObject>(args), result.get<JsonArray>());
};
auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
- LoggerD("CalendarUpdateBatch->get_response");
+ ScopeLogger("Entered into asynchronous function, CalendarUpdateBatch->get_response");
+
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
LoggerD("callback is %s", response->serialize().c_str());
}
void CalendarInstance::CalendarRemove(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
JsonValue val{JsonObject{}};
}
void CalendarInstance::CalendarRemoveBatch(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
- LoggerD("CalendarRemoveBatch->get");
+ ScopeLogger("Entered into asynchronous function, CalendarRemoveBatch->get");
+
JsonValue result = JsonValue(JsonArray());
PlatformResult status =
calendar_.RemoveBatch(common::JsonCast<JsonObject>(args), result.get<JsonArray>());
};
auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
- LoggerD("CalendarRemoveBatch->get_response");
+ ScopeLogger("Entered into asynchronous function, CalendarRemoveBatch->get_response");
+
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
LoggerD("callback is %s", response->serialize().c_str());
}
void CalendarInstance::CalendarFind(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
- LoggerD("CalendarFind->get");
+ ScopeLogger("Entered into asynchronous function, CalendarFind->get");
+
JsonValue result = JsonValue(JsonArray());
PlatformResult status =
calendar_.Find(common::JsonCast<JsonObject>(args), result.get<JsonArray>());
};
auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
- LoggerD("CalendarFind->get_response");
+ ScopeLogger("Entered into asynchronous function, CalendarFind->get_response");
+
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
- LoggerD("callback isssssss %s", response->serialize().c_str());
+ LoggerD("callback is %s", response->serialize().c_str());
Instance::PostMessage(this, response->serialize().c_str());
};
}
void CalendarInstance::CalendarAddChangeListener(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
JsonValue val{JsonObject{}};
}
void CalendarInstance::CalendarRemoveChangeListener(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
JsonValue val{JsonObject{}};
// CalendarManager
void CalendarInstance::CalendarManagerAddCalendar(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
JsonValue val{JsonObject{}};
}
void CalendarInstance::CalendarManagerGetCalendar(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
JsonValue val{JsonObject{}};
}
void CalendarInstance::CalendarManagerGetCalendars(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarRead, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
- LoggerD("CalendarManagerGetCalendars->get");
+ ScopeLogger("Entered into asynchronous function, CalendarManagerGetCalendars->get");
+
JsonValue result = JsonValue(JsonArray());
PlatformResult status = CalendarManager::GetInstance().GetCalendars(
};
auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
- LoggerD("CalendarManagerGetCalendars->get_response");
+ ScopeLogger("Entered into asynchronous function, CalendarManagerGetCalendars->get_response");
+
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
LoggerD("callback is %s", response->serialize().c_str());
}
void CalendarInstance::CalendarManagerRemoveCalendar(const JsonValue& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCalendarWrite, &out);
JsonValue val{JsonObject{}};
PlatformEnumReverseMap CalendarItem::platform_enum_reverse_map_ = {};
PlatformResult CalendarItem::Create(int type, calendar_record_h* handle) {
- LoggerD("Enter");
+ ScopeLogger();
std::string value_str;
PlatformResult status = CalendarRecord::TypeToUri(type, &value_str);
if (status.IsError()) {
}
PlatformResult CalendarItem::Remove(int type, int id) {
- LoggerD("Enter");
+ ScopeLogger();
std::string view_uri;
PlatformResult status = CalendarRecord::TypeToUri(type, &view_uri);
if (status.IsError()) {
PlatformResult CalendarItem::GetPlatformProperty(int type, const std::string& property,
unsigned int* value) {
- LoggerD("Enter");
+ ScopeLogger();
if (platform_property_map_.find(property) == platform_property_map_.end()) {
std::string message = std::string("Undefined property ") + property;
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
PlatformResult CalendarItem::StringToPlatformEnum(const std::string& field,
const std::string& value, int* platform_enum) {
- LoggerD("Enter");
+ ScopeLogger();
auto iter = platform_enum_map_.find(field);
if (iter == platform_enum_map_.end()) {
std::string message = std::string("Undefined platform enum type ") + field;
PlatformResult CalendarItem::PlatformEnumToString(const std::string& field, int value,
std::string* platform_str) {
- LoggerD("Enter");
+ ScopeLogger();
// @todo can be replaced by Boost.Bimap
if (platform_enum_reverse_map_.empty()) {
for (auto& def : platform_enum_map_) {
PlatformResult CalendarItem::SetString(int type, calendar_record_h rec, const std::string& property,
const picojson::object& in, bool optional) {
- LoggerD("set: %s", property.c_str());
+ ScopeLogger("set: %s", property.c_str());
if (optional && IsNull(in, property.c_str())) {
return PlatformResult(ErrorCode::NO_ERROR);
PlatformResult CalendarItem::SetString(int type, calendar_record_h rec, const std::string& property,
const std::string& value) {
- LoggerD("set: %s", property.c_str());
+ ScopeLogger("set: %s", property.c_str());
unsigned int prop;
PlatformResult status = GetPlatformProperty(type, property, &prop);
PlatformResult CalendarItem::GetString(int type, calendar_record_h rec, const std::string& property,
std::string* value) {
- LoggerD("get: %s", property.c_str());
+ ScopeLogger("set: %s", property.c_str());
unsigned int prop;
PlatformResult status = GetPlatformProperty(type, property, &prop);
PlatformResult CalendarItem::SetInt(int type, calendar_record_h rec, const std::string& property,
const picojson::object& in, bool optional) {
- LoggerD("set: %s", property.c_str());
+ ScopeLogger("set: %s", property.c_str());
if (optional && IsNull(in, property.c_str())) {
return PlatformResult(ErrorCode::NO_ERROR);
PlatformResult CalendarItem::SetInt(int type, calendar_record_h rec, const std::string& property,
int value) {
- LoggerD("set: %s", property.c_str());
+ ScopeLogger("set: %s" + property);
unsigned int prop;
PlatformResult status = GetPlatformProperty(type, property, &prop);
PlatformResult CalendarItem::GetInt(int type, calendar_record_h rec, const std::string& property,
int* value) {
- LoggerD("get: %s", property.c_str());
+ ScopeLogger("set: %s" + property);
unsigned int prop;
PlatformResult status = GetPlatformProperty(type, property, &prop);
PlatformResult CalendarItem::SetEnum(int type, calendar_record_h rec, const std::string& property,
const picojson::object& in, const std::string& enum_name) {
- LoggerD("Enter");
+ ScopeLogger();
std::string value = common::FromJson<std::string>(in, property.c_str());
int value_int;
PlatformResult CalendarItem::SetEnum(calendar_record_h rec, unsigned int property,
const std::string& enum_name, const std::string& value) {
- LoggerD("Enter");
+ ScopeLogger();
int value_int;
PlatformResult status = StringToPlatformEnum(enum_name, value, &value_int);
if (status.IsError()) {
PlatformResult CalendarItem::GetEnum(int type, calendar_record_h rec, const std::string& property,
const std::string& enum_name, std::string* enum_str) {
+ ScopeLogger();
int value;
PlatformResult status = GetInt(type, rec, property, &value);
if (status.IsError()) {
PlatformResult CalendarItem::GetEnum(calendar_record_h rec, unsigned int property,
const std::string& enum_name, std::string* enum_str) {
- LoggerD("Enter");
+ ScopeLogger();
int value;
PlatformResult status = CalendarRecord::GetInt(rec, property, &value);
if (status.IsError()) {
PlatformResult CalendarItem::SetDouble(int type, calendar_record_h rec, const std::string& property,
double value) {
- LoggerD("set: %s", property.c_str());
+ ScopeLogger("set: %s", property.c_str());
unsigned int prop;
PlatformResult status = GetPlatformProperty(type, property, &prop);
PlatformResult CalendarItem::GetDouble(int type, calendar_record_h rec, const std::string& property,
double* value) {
- LoggerD("get: %s", property.c_str());
+ ScopeLogger("get: %s", property.c_str());
unsigned int prop;
PlatformResult status = GetPlatformProperty(type, property, &prop);
PlatformResult CalendarItem::SetCaltime(int type, calendar_record_h rec,
const std::string& property, calendar_time_s value,
bool throw_on_error) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned int prop;
PlatformResult status = GetPlatformProperty(type, property, &prop);
if (status.IsError()) {
PlatformResult CalendarItem::SetCaltime(calendar_record_h rec, unsigned int property,
calendar_time_s value, bool throw_on_error) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_set_caltime(rec, property, value);
if (CALENDAR_ERROR_NONE != ret) {
PlatformResult CalendarItem::GetCaltime(int type, calendar_record_h rec,
const std::string& property, calendar_time_s* cal_time,
bool throw_on_error) {
- LoggerD("get: %s", property.c_str());
+ ScopeLogger("set: %s" + property);
unsigned int prop;
PlatformResult status = GetPlatformProperty(type, property, &prop);
PlatformResult CalendarItem::GetCaltime(calendar_record_h rec, unsigned int property,
calendar_time_s* cal_time, bool throw_on_error) {
- LoggerD("Enter");
+ ScopeLogger();
if (property != -1u) {
int ret = calendar_record_get_caltime(rec, property, cal_time);
if (CALENDAR_ERROR_NONE != ret) {
PlatformResult CalendarItem::SetLli(calendar_record_h rec, unsigned int property,
long long int value, bool throw_on_error) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_set_lli(rec, property, value);
if (CALENDAR_ERROR_NONE != ret) {
PlatformResult CalendarItem::GetLli(int type, calendar_record_h rec, const std::string& property,
long long int* lli) {
- LoggerD("get: %s", property.c_str());
+ ScopeLogger("set: %s" + property);
unsigned int prop;
PlatformResult status = GetPlatformProperty(type, property, &prop);
PlatformResult CalendarItem::GetLli(calendar_record_h rec, unsigned int property,
long long int* value, bool throw_on_error) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_get_lli(rec, property, value);
if (CALENDAR_ERROR_NONE != ret) {
LoggerW("Can't get lli value form record: %d", ret);
}
Date CalendarItem::DateFromJson(const picojson::object& in) {
- LoggerD("json date %s", picojson::value(in).serialize().c_str());
+ ScopeLogger("json date " + picojson::value(in).serialize());
Date date = {(long long int)common::FromJson<double>(in, "UTCTimestamp"),
(int)common::FromJson<double>(in, "year"),
}
Date CalendarItem::DateFromJson(const picojson::object& in, const char* obj_name) {
- LoggerD("Enter");
+ ScopeLogger();
return DateFromJson(common::FromJson<picojson::object>(in, obj_name));
}
picojson::value CalendarItem::DateToJson(Date* date) {
- LoggerD("timestamp: %lld", date->utc_timestamp_);
+ ScopeLogger("timestamp: %lld", date->utc_timestamp_);
picojson::value date_val = picojson::value(picojson::object());
picojson::object& date_obj = date_val.get<picojson::object>();
PlatformResult CalendarItem::CategoriesFromJson(int type, calendar_record_h rec,
const picojson::array& value) {
- LoggerD("Enter");
+ ScopeLogger();
std::string categories = "";
for (auto iter = value.begin(); iter != value.end(); ++iter) {
if (iter == value.begin()) {
PlatformResult CalendarItem::CategoriesToJson(int type, calendar_record_h rec,
picojson::array* value) {
- LoggerD("Enter");
+ ScopeLogger();
std::string categories;
PlatformResult status = GetString(type, rec, "categories", &categories);
if (status.IsError()) {
PlatformResult CalendarItem::AttendeesFromJson(int type, calendar_record_h rec,
const picojson::array& value) {
- LoggerD("Enter");
+ ScopeLogger();
// Remove the preset child attendees before adding new ones.
unsigned int property;
if (type == CALENDAR_BOOK_TYPE_EVENT) {
PlatformResult CalendarItem::AttendeesToJson(int type, calendar_record_h rec,
picojson::array* out) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned int property;
if (type == CALENDAR_BOOK_TYPE_EVENT) {
property = _calendar_event.calendar_attendee;
PlatformResult CalendarItem::AlarmsFromJson(int type, calendar_record_h rec,
const picojson::array& alarms) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned int property;
if (type == CALENDAR_BOOK_TYPE_EVENT) {
property = _calendar_event.calendar_alarm;
}
PlatformResult CalendarItem::AlarmsToJson(int type, calendar_record_h rec, picojson::array* out) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned int property;
if (type == CALENDAR_BOOK_TYPE_EVENT) {
property = _calendar_event.calendar_alarm;
PlatformResult CalendarItem::RecurrenceRuleFromJson(calendar_record_h rec,
const picojson::object& rrule) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string& frequency = common::FromJson<std::string>(rrule, "frequency");
PlatformResult status = SetEnum(rec, _calendar_event.freq, kRecurrenceRuleFrequency, frequency);
if (status.IsError()) {
}
std::string CalendarItem::ExceptionsFromJson(const picojson::array& exceptions) {
- LoggerD("Enter");
+ ScopeLogger();
std::string result;
Date date;
for (auto iter = exceptions.begin(); iter != exceptions.end(); ++iter) {
PlatformResult CalendarItem::RecurrenceRuleToJson(calendar_record_h rec,
picojson::object* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::object& out = *out_ptr;
std::string enum_str;
}
calendar_time_s CalendarItem::DateToPlatform(const Date& date, bool is_all_day) {
- LoggerD("Enter");
+ ScopeLogger();
calendar_time_s cal;
if (is_all_day) {
PlatformResult CalendarItem::DateFromPlatform(int type, calendar_record_h rec,
const std::string& property,
Date* date_from_platform) {
- LoggerD("Enter");
+ ScopeLogger();
calendar_time_s cal;
PlatformResult status = GetCaltime(type, rec, property + "_time", &cal);
if (status.IsError()) {
PlatformResult CalendarItem::DateFromPlatform(calendar_record_h rec, unsigned int property,
Date* date_from_platform) {
- LoggerD("Enter");
+ ScopeLogger();
calendar_time_s cal;
PlatformResult status = GetCaltime(rec, property, &cal);
if (status.IsError()) {
}
PlatformResult CalendarItem::FromJson(int type, calendar_record_h rec, const picojson::object& in) {
- LoggerD("Enter");
+ ScopeLogger();
if (in.empty()) {
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Empty Calendar object.");
}
}
PlatformResult CalendarItem::ToJson(int type, calendar_record_h rec, picojson::object* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
if (NULL == rec) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Calendar record is null");
}
}
picojson::array CalendarItem::StringToArray(const std::string& string) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array out = picojson::array();
size_t cstr_length = string.length() + 1;
using namespace common;
CalendarManager::CalendarManager() {
- LoggerD("Enter");
+ ScopeLogger();
if (CALENDAR_ERROR_NONE == calendar_connect()) {
LoggerD("Calendar DB connected");
is_connected_ = true;
}
CalendarManager::~CalendarManager() {
- LoggerD("Enter");
+ ScopeLogger();
if (is_connected_) {
if (CALENDAR_ERROR_NONE == calendar_disconnect()) {
LoggerD("Calendar DB disconnected");
}
CalendarManager& CalendarManager::GetInstance() {
- LoggerD("Enter");
+ ScopeLogger();
static CalendarManager instance;
return instance;
}
}
PlatformResult CalendarManager::GetCalendars(const JsonObject& args, JsonArray& array) {
- LoggerD("Enter");
+ ScopeLogger();
if (!is_connected_) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult CalendarManager::GetCalendar(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!is_connected_) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult CalendarManager::AddCalendar(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!is_connected_) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
}
PlatformResult CalendarManager::RemoveCalendar(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!is_connected_) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "DB Connection failed.");
}
EXPORT_NATIVE_PLUGIN(webapi::calendar::CalendarPlugin);
CalendarPlugin::CalendarPlugin() {
+ ScopeLogger();
manager_ = &CalendarManager::GetInstance();
calendar_ = &Calendar::GetInstance();
}
CalendarPlugin::~CalendarPlugin() {
+ ScopeLogger();
manager_ = nullptr;
}
void CalendarPlugin::OnLoad() {
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
using namespace common;
PlatformResult CalendarRecord::CheckReturn(int ret, const std::string& error_name) {
- LoggerD("Enter");
+ ScopeLogger();
if (CALENDAR_ERROR_NONE != ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_name,
("%s : %d (%s)", error_name.c_str(), ret, get_error_message(ret)));
}
void CalendarRecord::QueryDeleter(calendar_query_h handle) {
- LoggerD("Enter");
+ ScopeLogger();
if (handle) {
if (CALENDAR_ERROR_NONE != calendar_query_destroy(handle)) {
LoggerW("calendar_query_destroy failed");
}
void CalendarRecord::Deleter(calendar_record_h handle) {
- LoggerD("Enter");
+ ScopeLogger();
if (handle) {
if (CALENDAR_ERROR_NONE != calendar_record_destroy(handle, true)) {
LoggerW("calendar_record_destroy failed");
}
void CalendarRecord::ListDeleter(calendar_list_h handle) {
- LoggerD("Enter");
+ ScopeLogger();
if (handle) {
if (CALENDAR_ERROR_NONE != calendar_list_destroy(handle, true)) {
LoggerW("calendar_list_destroy failed");
PlatformResult CalendarRecord::GetString(calendar_record_h rec, unsigned int property,
std::string* str, bool throw_on_error) {
- LoggerD("Enter");
+ ScopeLogger();
char* value = NULL;
int ret = calendar_record_get_str(rec, property, &value);
if (CALENDAR_ERROR_NONE != ret) {
PlatformResult CalendarRecord::SetString(calendar_record_h record, unsigned int property,
const std::string& value, bool throw_on_error) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_set_str(record, property, value.empty() ? NULL : value.c_str());
if (CALENDAR_ERROR_NONE != ret) {
PlatformResult CalendarRecord::GetInt(calendar_record_h rec, unsigned int property, int* value,
bool throw_on_error) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_get_int(rec, property, value);
if (CALENDAR_ERROR_NONE != ret) {
LoggerE("Can't get int value form record: %d (%s)", ret, get_error_message(ret));
PlatformResult CalendarRecord::SetInt(calendar_record_h record, unsigned int property, int value,
bool throw_on_error) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_set_int(record, property, value);
if (CALENDAR_ERROR_NONE != ret) {
}
std::string CalendarRecord::TypeToString(int type) {
- LoggerD("Enter");
+ ScopeLogger();
if (CALENDAR_BOOK_TYPE_EVENT == type) {
return kCalendarTypeEvent;
}
}
std::string CalendarRecord::TypeToString(const char* view_uri) {
- LoggerD("Enter");
+ ScopeLogger();
if (0 == strcmp(view_uri, _calendar_event._uri)) {
return kCalendarTypeEvent;
}
}
int CalendarRecord::TypeToInt(const std::string& type) {
- LoggerD("Enter");
+ ScopeLogger();
if (kCalendarTypeEvent == type) {
return CALENDAR_BOOK_TYPE_EVENT;
}
}
int CalendarRecord::TypeToInt(const char* view_uri) {
- LoggerD("Enter");
+ ScopeLogger();
if (0 == strcmp(view_uri, _calendar_event._uri)) {
return CALENDAR_BOOK_TYPE_EVENT;
}
}
PlatformResult CalendarRecord::TypeToUri(const std::string& type, std::string* uri) {
- LoggerD("Enter");
+ ScopeLogger();
if (kCalendarTypeEvent == type) {
*uri = _calendar_event._uri;
} else if (kCalendarTypeTask == type) {
}
PlatformResult CalendarRecord::TypeToUri(int type, std::string* uri) {
- LoggerD("Enter");
+ ScopeLogger();
if (CALENDAR_BOOK_TYPE_EVENT == type) {
*uri = _calendar_event._uri;
} else if (CALENDAR_BOOK_TYPE_TODO == type) {
}
PlatformResult CalendarRecord::Create(const char* view_uri, calendar_record_h* handle) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_create(view_uri, handle);
if (CALENDAR_ERROR_NONE != ret || nullptr == handle) {
return LogAndCreateResult(
}
PlatformResult CalendarRecord::CreateCalendar(calendar_record_h* handle) {
- LoggerD("Enter");
+ ScopeLogger();
return Create(_calendar_book._uri, handle);
}
PlatformResult CalendarRecord::GetById(int id, const char* view_uri, calendar_record_h* handle) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_db_get_record(view_uri, id, handle);
if (CALENDAR_ERROR_NONE != ret || nullptr == handle) {
return LogAndCreateResult(ErrorCode::NOT_FOUND_ERR, "Fail to get record with given id",
}
PlatformResult CalendarRecord::Insert(calendar_record_h rec, int* record_id) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_db_insert_record(rec, record_id);
if (CALENDAR_ERROR_NONE != ret) {
PlatformResult CalendarRecord::AddChildRecord(calendar_record_h rec, unsigned int property,
calendar_record_h child) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_add_child_record(rec, property, child);
if (CALENDAR_ERROR_NONE != ret) {
if (child) {
}
void CalendarRecord::RemoveChildRecords(calendar_record_h rec, unsigned int property_id) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned int count = 0;
if (CALENDAR_ERROR_NONE != calendar_record_get_child_record_count(rec, property_id, &count)) {
PlatformResult CalendarRecord::GetChildRecordCount(calendar_record_h rec, unsigned int property,
bool throw_on_error, unsigned int* value) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_get_child_record_count(rec, property, value);
if (CALENDAR_ERROR_NONE != ret) {
LoggerE("Can't get child record count: %d (%s)", ret, get_error_message(ret));
PlatformResult CalendarRecord::GetChildRecordAt(calendar_record_h rec, unsigned int property,
calendar_record_h* result, int index) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = calendar_record_get_child_record_at_p(rec, property, index, result);
if (CALENDAR_ERROR_NONE != ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Get child record at failed.",
}
PlatformResult CalendarRecord::CalendarToJson(calendar_record_h rec, picojson::object* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::object& out = *out_ptr;
if (NULL == rec) {
}
PlatformResult CalendarRecord::CalendarFromJson(calendar_record_h rec, const picojson::object& in) {
- LoggerD("Enter");
+ ScopeLogger();
if (in.empty()) {
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Empty Calendar object.");
}
namespace {
static void get_sim_msisdn_cb(TapiHandle* handle, int result, void* data, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
TelSimMsisdnList_t* list;
std::promise<std::string>* prom = reinterpret_cast<std::promise<std::string>*>(user_data);
CallHistory::CallHistory(CallHistoryInstance& instance)
: m_is_listener_set(false), instance_(instance), utils_(*this) {
- LoggerD("Entered");
+ ScopeLogger();
if (CONTACTS_ERROR_NONE == contacts_connect()) {
LoggerD("Successful to connect Call history DB");
} else {
}
CallHistory::~CallHistory() {
- LoggerD("Entered");
+ ScopeLogger();
if (m_is_listener_set) {
int ret =
}
void CallHistory::FindThread(const picojson::object& args, CallHistory* call_history) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<picojson::value> response{new picojson::value(picojson::object())};
auto find_response = [call_history,
callback_id](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, find_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
Instance::PostMessage(&call_history->instance_, response->serialize().c_str());
}
void CallHistory::LoadPhoneNumbers(const picojson::object& args, CallHistory* call_history) {
- LoggerD("Entered");
+ ScopeLogger();
CallHistory::LockedVector phone_numbers = call_history->getPhoneNumbers();
if (0 != phone_numbers.size()) {
LoggerD("m_phone_numbers is already filled. Returning.");
}
void CallHistory::find(const picojson::object& args) {
- LoggerD("Entered");
+ ScopeLogger();
std::thread(LoadPhoneNumbers, args, this).detach();
std::thread(FindThread, args, this).detach();
}
PlatformResult CallHistory::remove(const picojson::object& args) {
- LoggerD("Entered");
+ ScopeLogger();
const auto it_uid = args.find("uid");
const auto it_args_end = args.end();
}
common::PlatformResult CallHistory::removeBatch(const picojson::object& args) {
- LoggerD("Entered");
+ ScopeLogger();
const auto it_uid = args.find("uid");
const auto it_args_end = args.end();
auto remove_batch_response =
[this, callback_id](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, remove_batch_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
Instance::PostMessage(&this->instance_, response->serialize().c_str());
}
void CallHistory::removeAll(const picojson::object& args) {
- LoggerD("Entered");
+ ScopeLogger();
const double callback_id = args.find("callbackId")->second.get<double>();
auto remove_all_response =
[this, callback_id](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, remove_all_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
Instance::PostMessage(&this->instance_, response->serialize().c_str());
}
void CallHistory::changeListenerCB(const char* view_uri, char* changes, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
CallHistory* h = static_cast<CallHistory*>(user_data);
}
PlatformResult CallHistory::startCallHistoryChangeListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_listener_set) {
int ret =
}
PlatformResult CallHistory::stopCallHistoryChangeListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (m_is_listener_set) {
int ret =
contacts_db_remove_changed_cb_with_info(_contacts_phone_log._uri, changeListenerCB, this);
}
PlatformResult CallHistory::setMissedDirection(int uid) {
- LoggerD("Entered");
+ ScopeLogger();
contacts_record_h record = nullptr;
SCOPE_EXIT {
using namespace common;
CallHistoryInstance::CallHistoryInstance() : history_(*this) {
- LoggerD("Entered");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
CallHistoryInstance::~CallHistoryInstance() {
+ ScopeLogger();
}
void CallHistoryInstance::Find(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCallHistoryRead, &out);
history_.find(args.get<picojson::object>());
ReportSuccess(out);
}
void CallHistoryInstance::Remove(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCallHistoryWrite, &out);
PlatformResult result = history_.remove(args.get<picojson::object>());
if (result.IsSuccess()) {
}
void CallHistoryInstance::RemoveBatch(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCallHistoryWrite, &out);
PlatformResult result = history_.removeBatch(args.get<picojson::object>());
if (result.IsSuccess()) {
}
void CallHistoryInstance::RemoveAll(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCallHistoryWrite, &out);
history_.removeAll(args.get<picojson::object>());
ReportSuccess(out);
}
void CallHistoryInstance::AddChangeListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCallHistoryRead, &out);
PlatformResult result = history_.startCallHistoryChangeListener();
if (result.IsSuccess()) {
}
void CallHistoryInstance::RemoveChangeListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeCallHistoryRead, &out);
PlatformResult result = history_.stopCallHistoryChangeListener();
if (result.IsSuccess()) {
}
void CallHistoryInstance::SetMissedDirection(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!args.contains("uid")) {
LoggerD("args doesn't contain attribute 'uid'");
}
void CallHistoryInstance::CallHistoryChange(picojson::object& data) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value event = picojson::value(data);
picojson::object& obj = event.get<picojson::object>();
obj["listenerId"] = picojson::value("CallHistoryChangeCallback");
}
CallHistoryUtils::CallHistoryUtils(CallHistory& history) : history_(history) {
+ ScopeLogger();
}
void CallHistoryUtils::parseRecordList(contacts_list_h* record_list, picojson::array& array) {
- LoggerD("Entered");
+ ScopeLogger();
contacts_record_h record = NULL;
int total = 0;
}
void CallHistoryUtils::parseRecord(contacts_record_h* record, picojson::object& obj) {
- LoggerD("Entered");
+ ScopeLogger();
int int_data;
}
void CallHistoryUtils::parseLogType(contacts_phone_log_type_e log_type, picojson::object& obj) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value val = picojson::value(picojson::array());
picojson::array& features = val.get<picojson::array>();
}
void CallHistoryUtils::parseRemoteParties(contacts_record_h* record, picojson::object& obj) {
- LoggerD("Entered");
+ ScopeLogger();
char* char_data = NULL;
int int_data;
}
void CallHistoryUtils::parseCallingParty(contacts_record_h* record, picojson::object& obj) {
- LoggerD("Entered");
+ ScopeLogger();
int sim_count = 0;
{
}
unsigned int CallHistoryUtils::convertAttributeName(const std::string& attribute_name) {
- LoggerD("Entered");
+ ScopeLogger();
if (STR_RP_REMOTEPARTY == attribute_name) {
return _contacts_phone_log.address;
}
static FilterTypeEnum getFilterType(const picojson::object& filter) {
- LoggerD("Entered");
+ ScopeLogger();
const auto it_end = filter.end();
}
static CompositeTypeEnum getCompositeType(const picojson::object& filter) {
- LoggerD("Entered");
+ ScopeLogger();
CompositeTypeEnum type = NONE;
const std::string& str_type = filter.find("type")->second.get<std::string>();
}
static contacts_match_str_flag_e getMatchFlag(const std::string& match_flag) {
- LoggerD("Entered");
+ ScopeLogger();
if (STR_FILTER_FULLSTRING == match_flag) {
return CONTACTS_MATCH_FULLSTRING;
} else if (STR_FILTER_CONTAINS == match_flag) {
}
static std::time_t toTimeT(const std::string& value) {
- LoggerD("Entered");
+ ScopeLogger();
struct tm date;
if (nullptr == strptime(value.c_str(), "%Y-%m-%dT%H:%M:%S", &date)) {
LOGW("Couldn't convert supplied date.");
}
static void visitAttribute(std::stack<contacts_filter_h>& stack, const picojson::object filter) {
- LoggerD("Entered");
+ ScopeLogger();
contacts_filter_h filter_top = stack.top();
contacts_filter_h sub_filter = NULL;
static void visitAttributeRange(std::stack<contacts_filter_h>& stack,
const picojson::object filter) {
- LoggerD("Entered");
+ ScopeLogger();
unsigned int prop_id = 0;
const auto it_attr_name = filter.find("attributeName");
static void generateFilter(std::stack<contacts_filter_h>& stack, const picojson::object filter,
CompositeTypeEnum type) {
- LoggerD("Entered");
+ ScopeLogger();
switch (getFilterType(filter)) {
case FILTER_ATTRIBUTE: {
visitAttribute(stack, filter);
}
void CallHistoryUtils::createFilter(contacts_filter_h filter, const picojson::object filter_obj) {
- LoggerD("Entered");
+ ScopeLogger();
std::stack<contacts_filter_h> filter_stack;
filter_stack.push(filter);
generateFilter(filter_stack, filter_obj, CompositeTypeEnum::NONE);
namespace dbus {
Connection& Connection::getInstance() {
- LoggerD("Entered");
+ ScopeLogger();
static Connection instance;
return instance;
}
}
Connection::Connection() {
+ ScopeLogger();
m_dbus = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &m_error);
if (!m_dbus || m_error) {
LoggerE("Could not get connection");
}
- LoggerD("Connection set");
}
Connection::~Connection() {
};
int32_t Extension::Detail::XW_Initialize(XW_Extension extension, XW_GetInterface get_interface) {
- LoggerD("Enter");
+ ScopeLogger();
g_extension = CreateExtension();
if (!g_extension) {
LoggerE("Can't initialize extension: CreateExtension() returned NULL.");
}
void Extension::Detail::OnInstanceCreated(XW_Instance xw_instance) {
- LoggerD("Enter");
+ ScopeLogger();
if (!g_extension) {
return;
}
}
void Extension::Detail::OnShutdown(XW_Extension) {
- LoggerD("Enter");
+ ScopeLogger();
delete g_extension;
g_extension = nullptr;
}
namespace common {
const picojson::value& FindValue(const picojson::object& in, const char* name) {
- LoggerD("Enter");
+ ScopeLogger();
auto it = in.find(name);
if (it == in.end()) {
throw common::UnknownException(std::string("Failed to find required JSON property: ") + name +
namespace common {
CurrentApplication& CurrentApplication::GetInstance() {
- LoggerD("Enter");
+ ScopeLogger();
static CurrentApplication current_application;
return current_application;
}
pid_t CurrentApplication::GetProcessId() const {
- LoggerD("Enter");
+ ScopeLogger();
return pid_;
}
std::string CurrentApplication::GetApplicationId() const {
- LoggerD("Enter");
+ ScopeLogger();
return app_id_;
}
std::string CurrentApplication::GetPackageId() const {
- LoggerD("Enter");
+ ScopeLogger();
return package_id_;
}
std::string CurrentApplication::GetRoot() const {
- LoggerD("Enter");
+ ScopeLogger();
return root_;
}
app_id_(FetchApplicationId()),
package_id_(FetchPackageId()),
root_(FetchRoot()) {
- LoggerD("Enter");
+ ScopeLogger();
}
std::string CurrentApplication::FetchApplicationId() const {
- LoggerD("Enter");
+ ScopeLogger();
std::string app_id;
char* tmp_str = nullptr;
}
std::string CurrentApplication::FetchPackageId() const {
- LoggerD("Enter");
+ ScopeLogger();
std::string package_id;
app_info_h app_info;
int err = app_info_create(app_id_.c_str(), &app_info);
}
std::string CurrentApplication::FetchRoot() const {
- LoggerD("Enter");
+ ScopeLogger();
char* path = nullptr;
path = app_get_data_path();
const XW_Internal_PermissionsInterface* g_permission = NULL;
bool InitializeInterfaces(XW_GetInterface get_interface) {
- LoggerD("Enter");
+ ScopeLogger();
static bool initialized = false;
if (!initialized) {
namespace common {
Extension::Extension() : xw_extension_(g_xw_extension_) {
- LoggerD("Enter");
+ ScopeLogger();
}
Extension::~Extension() {
- LoggerD("Enter");
+ ScopeLogger();
}
void Extension::SetExtensionName(const char* name) {
- LoggerD("Enter");
+ ScopeLogger();
g_core->SetExtensionName(xw_extension_, name);
}
void Extension::SetJavaScriptAPI(const char* api) {
- LoggerD("Enter");
+ ScopeLogger();
g_core->SetJavaScriptAPI(xw_extension_, api);
}
void Extension::SetExtraJSEntryPoints(const char** entry_points) {
- LoggerD("Enter");
+ ScopeLogger();
if (g_entry_points) g_entry_points->SetExtraJSEntryPoints(xw_extension_, entry_points);
}
bool Extension::RegisterPermissions(const char* perm_table) {
- LoggerD("Enter");
+ ScopeLogger();
if (g_permission) return g_permission->RegisterPermissions(xw_extension_, perm_table);
return false;
}
bool Extension::CheckAPIAccessControl(const char* api_name) {
- LoggerD("Enter");
+ ScopeLogger();
if (g_permission) return g_permission->CheckAPIAccessControl(xw_extension_, api_name);
return false;
}
Instance* Extension::CreateInstance() {
- LoggerD("Enter");
+ ScopeLogger();
return NULL;
}
std::string Extension::GetRuntimeVariable(const char* var_name, unsigned len) {
- LoggerD("Enter");
+ ScopeLogger();
if (!g_runtime) return "";
std::vector<char> res(len + 1, 0);
// static
void Extension::OnInstanceCreated(XW_Instance xw_instance, Instance* instance) {
- LoggerD("Enter");
+ ScopeLogger();
Assert(!g_core->GetInstanceData(xw_instance));
if (!instance) return;
instance->xw_instance_ = xw_instance;
// static
void Extension::OnInstanceDestroyed(XW_Instance xw_instance) {
- LoggerD("Enter");
+ ScopeLogger();
Instance* instance = reinterpret_cast<Instance*>(g_core->GetInstanceData(xw_instance));
if (!instance) return;
instance->xw_instance_ = 0;
// static
void Extension::HandleMessage(XW_Instance xw_instance, const char* msg) {
- LoggerD("Enter");
+ ScopeLogger();
Instance* instance = reinterpret_cast<Instance*>(g_core->GetInstanceData(xw_instance));
if (!instance) return;
instance->HandleMessage(msg);
// static
void Extension::HandleSyncMessage(XW_Instance xw_instance, const char* msg) {
- LoggerD("Enter");
+ ScopeLogger();
Instance* instance = reinterpret_cast<Instance*>(g_core->GetInstanceData(xw_instance));
if (!instance) return;
instance->HandleSyncMessage(msg);
XW_Initialize_Func initialize,
XW_CreatedInstanceCallback created_instance,
XW_ShutdownCallback shutdown) {
- LoggerD("Enter");
+ ScopeLogger();
Assert(extension);
if (!InitializeInterfaces(get_interface)) {
std::unordered_set<Instance*> Instance::all_instances_;
Instance::Instance() : xw_instance_(0) {
- LoggerD("Enter");
+ ScopeLogger();
{ all_instances_.insert(this); }
}
Instance::~Instance() {
- LoggerD("Enter");
+ ScopeLogger();
{ all_instances_.erase(this); }
Assert(xw_instance_ == 0);
}
void Instance::PostMessage(Instance* that, const char* msg) {
- LoggerD("Enter");
+ ScopeLogger();
if (that && all_instances_.end() != all_instances_.find(that)) {
that->PostMessage(msg);
} else {
}
void Instance::PostMessage(const char* msg) {
- LoggerD("Enter");
+ ScopeLogger();
if (!xw_instance_) {
LoggerE(
"Ignoring PostMessage() in the constructor or after the "
}
void Instance::SendSyncReply(const char* reply) {
- LoggerD("Enter");
+ ScopeLogger();
if (!xw_instance_) {
LoggerE(
"Ignoring SendSyncReply() in the constructor or after the "
}
ParsedInstance::ParsedInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
ParsedInstance::~ParsedInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
void ParsedInstance::RegisterHandler(const std::string& name, const NativeHandler& func) {
- LoggerD("Enter");
+ ScopeLogger();
handler_map_.insert(std::make_pair(name, func));
}
void ParsedInstance::RegisterSyncHandler(const std::string& name, const NativeHandler& func) {
- LoggerD("Enter");
+ ScopeLogger();
handler_map_.insert(std::make_pair("#SYNC#" + name, func));
}
void ParsedInstance::ReportSuccess(picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
tools::ReportSuccess(out);
}
void ParsedInstance::ReportSuccess(const picojson::value& result, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
tools::ReportSuccess(result, out);
}
void ParsedInstance::ReportError(picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
tools::ReportError(out);
}
void ParsedInstance::ReportError(const PlatformException& ex, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
tools::ReportError(ex, out);
}
void ParsedInstance::ReportError(const PlatformResult& error, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
tools::ReportError(error, out);
}
void ParsedInstance::HandleMessage(const char* msg) {
- LoggerD("Enter");
+ ScopeLogger();
HandleMessage(msg, false);
}
void ParsedInstance::HandleSyncMessage(const char* msg) {
- LoggerD("Enter");
+ ScopeLogger();
HandleMessage(msg, true);
}
void ParsedInstance::HandleMessage(const char* msg, bool is_sync) {
- LoggerD("Enter");
+ ScopeLogger();
try {
picojson::value value;
std::string err;
}
void ParsedInstance::HandleException(const PlatformException& ex) {
- LoggerD("Enter");
+ ScopeLogger();
LoggerE("Exception: %s", ex.message().c_str());
picojson::value result = picojson::value(picojson::object());
ReportError(ex, result.get<picojson::object>());
namespace common {
IFilesystemProvider::IFilesystemProvider() {
- LoggerD("enter");
+ ScopeLogger();
}
IFilesystemProvider::~IFilesystemProvider() {
- LoggerD("enter");
+ ScopeLogger();
}
FilesystemProvider::FilesystemProvider() : provider_(FilesystemProviderDeviced::Create()) {
}
FilesystemProvider& FilesystemProvider::Create() {
- LoggerD("Entered");
+ ScopeLogger();
static FilesystemProvider instance;
return instance;
}
FilesystemProvider::~FilesystemProvider() {
- LoggerD("Entered");
+ ScopeLogger();
}
void FilesystemProvider::RegisterDeviceChangeState(DeviceChangeStateFun callback) {
- LoggerD("Entered");
+ ScopeLogger();
provider_.RegisterDeviceChangeState(callback);
}
void FilesystemProvider::UnregisterDeviceChangeState() {
- LoggerD("Entered");
+ ScopeLogger();
provider_.UnregisterDeviceChangeState();
}
Storages FilesystemProvider::GetStorages() {
- LoggerD("Entered");
+ ScopeLogger();
return provider_.GetStorages();
}
VirtualRoots FilesystemProvider::GetVirtualPaths() {
- LoggerD("Entered");
+ ScopeLogger();
return provider_.GetVirtualPaths();
}
VirtualStorages FilesystemProvider::GetAllStorages() {
- LoggerD("Entered");
+ ScopeLogger();
return provider_.GetAllStorages();
}
std::string FilesystemProvider::GetRealPath(const std::string& path_or_uri) {
- LoggerD("Entered");
+ ScopeLogger();
return FilesystemProviderStorage::Create().GetRealPath(path_or_uri);
}
std::string FilesystemProvider::GetVirtualPath(const std::string& real_path) const {
- LoggerD("Entered");
+ ScopeLogger();
return FilesystemProviderStorage::Create().GetVirtualPath(real_path);
}
};
FilesystemProviderDeviced::~FilesystemProviderDeviced() {
- LoggerD("Entered");
+ ScopeLogger();
UnregisterDeviceChangeState();
}
block_signal_subscribe_id_(0),
virtual_roots_provider_(FilesystemProviderStorage::Create()),
is_initialized_(false) {
- LoggerD("Entered");
+ ScopeLogger();
GError* error = nullptr;
}
FilesystemProviderDeviced& FilesystemProviderDeviced::Create() {
- LoggerD("Entered");
+ ScopeLogger();
static FilesystemProviderDeviced instance;
const gchar* interface_name,
const gchar* signal_name, GVariant* parameters,
gpointer user_data) {
- LoggerD("Entered");
+ ScopeLogger();
FilesystemProviderDeviced* instance = static_cast<FilesystemProviderDeviced*>(user_data);
DeviceListElem elem;
}
void FilesystemProviderDeviced::BlockSignalCallback(DeviceListElem elem) {
- LoggerD("Entered");
+ ScopeLogger();
StorageState previous_state = StorageState::kUnmounted;
auto it = previous_device_state_map_.find(elem.syspath);
if (it == previous_device_state_map_.end()) {
}
void FilesystemProviderDeviced::RegisterDeviceChangeState(DeviceChangeStateFun _callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!is_initialized_) {
LoggerE("DeviceD Core api not initialized");
}
void FilesystemProviderDeviced::UnregisterDeviceChangeState() {
- LoggerD("Entered");
+ ScopeLogger();
if (!is_initialized_) {
LoggerE("DeviceD Core api not initialized");
}
std::shared_ptr<Storage> FilesystemProviderDeviced::GetStorage(const DeviceListElem& elem) {
- LoggerD("Entered");
+ ScopeLogger();
return std::make_shared<Storage>(GetIdFromUUID(elem.fs_uuid_enc),
(elem.block_type ? StorageType::kMmc : StorageType::kUsbDevice),
(elem.state ? StorageState::kMounted : StorageState::kUnmounted),
}
std::string FilesystemProviderDeviced::GetNameFromPath(const char* const char_path) {
- LoggerD("Entered");
+ ScopeLogger();
std::string path = char_path;
std::string name = "removable_";
std::size_t last_slash_pos = path.find_last_of("/");
}
int FilesystemProviderDeviced::GetIdFromUUID(const char* const char_uuid) {
- LoggerD("Entered");
+ ScopeLogger();
return (int)std::hash<std::string>()(std::string(char_uuid));
}
Storages FilesystemProviderDeviced::GetStorages() {
- LoggerD("Entered");
+ ScopeLogger();
if (!is_initialized_) {
LoggerE("DeviceD Core api not initialized");
return Storages();
}
Storages FilesystemProviderDeviced::GetStoragesFromGVariant(GVariant* variant) {
- LoggerD("Entered");
+ ScopeLogger();
Storages storages;
GVariantIter* iter;
}
VirtualRoots FilesystemProviderDeviced::GetVirtualPaths() {
- LoggerD("Entered");
+ ScopeLogger();
if (!is_initialized_) {
LoggerE("DeviceD Core api not initialized");
}
VirtualStorages FilesystemProviderDeviced::GetAllStorages() {
- LoggerD("Entered");
+ ScopeLogger();
if (!is_initialized_) {
LoggerE("DeviceD Core api not initialized");
namespace common {
StorageState TranslateCoreStorageState(storage_state_e coreStorageState) {
- LoggerD("Entered");
+ ScopeLogger();
StorageState state = StorageState::kUnknown;
if (coreStorageState == STORAGE_STATE_REMOVED) {
state = StorageState::kUnmounted;
}
void OnStorageChange(int storage_id, storage_state_e state, void* user_data) {
- LoggerD("Entered, id: %d", storage_id);
+ ScopeLogger("id: %d", storage_id);
FilesystemProviderStorage* provider = static_cast<FilesystemProviderStorage*>(user_data);
for (auto& storage : provider->GetStorages()) {
bool OnForeachStorage(int storage_id, storage_type_e type, storage_state_e state, const char* path,
void* user_data) {
- LoggerD("Entered, id: %d", storage_id);
+ ScopeLogger("id: %d", storage_id);
FilesystemProviderStorage* provider = static_cast<FilesystemProviderStorage*>(user_data);
// handling only internal storages (external are handled with deviced api)
}
FilesystemProviderStorage::FilesystemProviderStorage() {
- LoggerD("Entered");
+ ScopeLogger();
int err = storage_foreach_device_supported(OnForeachStorage, this);
if (err != STORAGE_ERROR_NONE) {
LoggerE("Unknown Error on getting storage paths");
}
FilesystemProviderStorage& FilesystemProviderStorage::Create() {
- LoggerD("Entered");
+ ScopeLogger();
static FilesystemProviderStorage fs;
return fs;
}
FilesystemProviderStorage::~FilesystemProviderStorage() {
- LoggerD("Entered");
+ ScopeLogger();
}
void FilesystemProviderStorage::FillVirtualPaths(int storage_id) {
}
void FilesystemProviderStorage::RegisterDeviceChangeState(DeviceChangeStateFun callback) {
- LoggerD("Entered");
+ ScopeLogger();
listener_ = callback;
}
void FilesystemProviderStorage::UnregisterDeviceChangeState() {
- LoggerD("Entered");
+ ScopeLogger();
listener_ = nullptr;
}
Storages FilesystemProviderStorage::GetStorages() {
- LoggerD("Entered");
+ ScopeLogger();
return storages_;
}
VirtualRoots FilesystemProviderStorage::GetVirtualPaths() {
- LoggerD("Entered");
+ ScopeLogger();
return virtual_paths_;
}
std::string FilesystemProviderStorage::GetRealPath(const std::string& path_or_uri) {
- LoggerD("Enter");
+ ScopeLogger();
std::string realpath;
std::size_t pos = path_or_uri.find(kFileUriPrefix);
if (pos != std::string::npos) {
}
std::string FilesystemProviderStorage::GetVirtualPath(const std::string& real_path) const {
- LoggerD("Enter");
+ ScopeLogger();
for (const auto& kv : virtual_paths_) {
if (0 == real_path.compare(0, kv.path_.size(), kv.path_)) {
return std::string(real_path).replace(0, kv.path_.size(), kv.name_);
}
VirtualStorages FilesystemProviderStorage::GetAllStorages() {
- LoggerD("Entered");
+ ScopeLogger();
VirtualStorages vs;
for (auto storage : storages_) {
vs.push_back(storage);
VirtualRoot::VirtualRoot(std::string const& name, std::string const& path, StorageType type,
StorageState state)
: name_(name), path_(path), type_(type), state_(state) {
- LoggerD("Entered");
+ ScopeLogger();
}
Storage::Storage(int id, StorageType type, StorageState state, std::string const& path,
std::string const& name)
: VirtualRoot(name, path, type, state), id_(id) {
- LoggerD("Enter");
+ ScopeLogger();
if (name_ == "") {
switch (type) {
case StorageType::kInternal:
}
picojson::value VirtualRoot::ToJson() const {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value v{picojson::object{}};
picojson::object& obj = v.get<picojson::object>();
}
picojson::value Storage::ToJson() const {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value value = VirtualRoot::ToJson();
picojson::object& obj = value.get<picojson::object>();
obj["storage_id"] = picojson::value(static_cast<double>(id_));
}
Storage::Storage(Storage const& other) : VirtualRoot(other) {
- LoggerD("Entered");
+ ScopeLogger();
this->id_ = other.id_;
}
VirtualRoot::VirtualRoot(VirtualRoot const& other) {
- LoggerD("Entered");
+ ScopeLogger();
this->path_ = other.path_;
this->name_ = other.name_;
this->state_ = other.state_;
}
std::string VirtualRoot::ToString(StorageType type) {
- LoggerD("Entered");
+ ScopeLogger();
switch (type) {
case StorageType::kInternal:
return "INTERNAL";
}
std::string VirtualRoot::ToString(StorageState state) {
- LoggerD("Entered");
+ ScopeLogger();
switch (state) {
case StorageState::kUnmounted:
return "REMOVED";
PlatformResult AttributeMatchFlagFromString(const std::string &str,
AttributeMatchFlag *filter_match_flag) {
- LoggerD("Enter");
+ ScopeLogger();
if (str == "EXACTLY") {
*filter_match_flag = AttributeMatchFlag::kExactly;
} else if (str == "FULLSTRING") {
PlatformResult CompositeFilterTypeFromString(const std::string &str,
CompositeFilterType *comp_filter_type) {
- LoggerD("Enter");
+ ScopeLogger();
if (str == "UNION") {
*comp_filter_type = CompositeFilterType::kUnion;
} else if (str == "INTERSECTION") {
}
void FilterVisitor::SetOnAttributeFilter(const AttributeFilterOnVisit &func) {
- LoggerD("Enter");
+ ScopeLogger();
m_attributeFilterOnVisit = func;
}
void FilterVisitor::SetOnAttributeRangeFilter(const AttributeRangeFilterOnVisit &func) {
- LoggerD("Enter");
+ ScopeLogger();
m_attributeRangeFilterOnVisit = func;
}
void FilterVisitor::SetOnCompositeFilterBegin(const CompositeFilterOnBegin &func) {
- LoggerD("Enter");
+ ScopeLogger();
m_compositeFilterOnBegin = func;
}
void FilterVisitor::SetOnCompositeFilterEnd(const CompositeFilterOnEnd &func) {
- LoggerD("Enter");
+ ScopeLogger();
m_compositeFilterOnEnd = func;
}
PlatformResult FilterVisitor::Visit(const picojson::object &filter) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string &filterType = FromJson<std::string>(filter, "filterType");
if (filterType == "AttributeFilter") {
PlatformResult status = VisitAttributeFilter(filter);
}
PlatformResult FilterVisitor::VisitAttributeFilter(const picojson::object &filter) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string &attribute_name = FromJson<std::string>(filter, "attributeName");
AttributeMatchFlag match_flag;
}
PlatformResult FilterVisitor::VisitAttributeRangeFilter(const picojson::object &filter) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string &attributeName = FromJson<std::string>(filter, "attributeName");
const picojson::value &initialValue = FindValue(filter, "initialValue");
const picojson::value &endValue = FindValue(filter, "endValue");
}
PlatformResult FilterVisitor::VisitCompositeFilter(const picojson::object &filter) {
- LoggerD("Enter");
+ ScopeLogger();
CompositeFilterType filter_type;
PlatformResult status =
CompositeFilterTypeFromString(FromJson<std::string>(filter, "type"), &filter_type);
PlatformResult::PlatformResult(const ErrorCode& error_code, const std::string& message)
: error_code_(error_code), message_(message) {
- LoggerD("Enter");
+ ScopeLogger();
if (ErrorCode::NO_ERROR != error_code) {
LoggerE("PlatformResult: %d, message: %s", error_code, message.c_str());
}
picojson::value PlatformResult::ToJSON() const {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value::object obj;
obj["code"] = picojson::value(static_cast<double>(error_code_));
if (!message_.empty()) obj["message"] = picojson::value(message_);
namespace tools {
void ReportSuccess(picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
out.insert(std::make_pair("status", picojson::value("success")));
}
void ReportSuccess(const picojson::value& result, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
out.insert(std::make_pair("status", picojson::value("success")));
out.insert(std::make_pair("result", result));
}
class AccessControlImpl {
public:
AccessControlImpl() : initialized_(false) {
- LoggerD("Privilege access checked using DB.");
+ ScopeLogger("Privilege access checked using DB.");
const char* kWrtDBPath = "/opt/dbspace/.wrt.db";
sqlite3* db = nullptr;
}
bool CheckAccess(const std::vector<std::string>& privileges) {
- LoggerD("Enter");
+ ScopeLogger();
if (!initialized_) {
return false;
}
}
bool CheckAccess(const std::vector<std::string>& privileges) {
- LoggerD("Enter");
+ ScopeLogger();
return true;
}
class AccessControlImpl {
public:
AccessControlImpl() : cynara_(nullptr) {
- LoggerD("Privilege access checked using Cynara.");
+ ScopeLogger("Privilege access checked using Cynara.");
char* smack_label = nullptr;
int len = smack_new_label_from_self(&smack_label);
}
PlatformResult CheckAccess(const std::vector<std::string>& privileges) {
- LoggerD("Enter");
+ ScopeLogger();
// Local cache of mapped privilege strings. This routine can be called many times, especially
// during application launch, generating a high overhead of retrieving mapped privileges from
}
PlatformResult GetPkgApiVersion(std::string* api_version) {
- LoggerD("Entered");
+ ScopeLogger();
// Local cache of API version string. This can be expensive to retrieve from
// underlying databases and this routine can be called many times during
}
bool IsAppVersionEarlierThan(const std::string& ver) {
- LoggerD("Enter");
+ ScopeLogger();
std::string app_ver;
auto res = GetPkgApiVersion(&app_ver);
if (!res) {
}
bool IsPathValid(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
/*
* Directory dot-referencing is not allowed
}
PlatformResult CheckFileStatus(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
struct stat buf;
}
PlatformResult CheckFileAvailability(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
if (!IsPathValid(path)) {
return PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid path: " + path);
} // anonymous namespace
PlatformResult AddressBookGet(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookAdd(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookUpdate(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookRemove(const JsonObject& args, JsonObject&) {
- LoggerE("entered");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookAddBatch(const JsonObject& args, JsonArray& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookUpdateBatch(const JsonObject& args, JsonArray& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookRemoveBatch(const JsonObject& args) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookFind(const JsonObject& args, JsonArray& array) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (!status) return status;
}
PlatformResult AddressBookAddGroup(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookGetGroup(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookUpdateGroup(const JsonObject& args, JsonObject&) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookRemoveGroup(const JsonObject& args, JsonObject&) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult AddressBookGetGroups(const JsonObject& args, JsonArray& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
namespace {
void AddressBookListenerCallback(const char* view_uri, void* user_data) {
- LoggerD("entered");
+ ScopeLogger();
(void)view_uri;
PlatformResult status = ContactUtil::CheckDBConnection();
PlatformResult AddressBookStartListening(ContactInstance& instance, const JsonObject&,
JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
int current_state = 0;
}
PlatformResult AddressBookStopListening(ContactInstance& instance) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
using namespace common;
ContactInstance::ContactInstance() : current_state_(0), is_listening_(false) {
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
ContactInstance::~ContactInstance() {
+ ScopeLogger();
if (is_listening_) {
AddressBook::AddressBookStopListening(*this);
set_is_listening(false);
}
void ContactInstance::AddressBookGet(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
JsonValue val{JsonObject{}};
PlatformResult status =
}
void ContactInstance::AddressBookAdd(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status =
}
void ContactInstance::AddressBookAddBatch(const JsonValue& args, JsonObject& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
JsonValue result = JsonValue(JsonArray());
PlatformResult status = AddressBook::AddressBookAddBatch(common::JsonCast<JsonObject>(args),
result.get<JsonArray>());
};
auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
+ ScopeLogger("Entered into asynchronous function, get_response");
JsonObject& obj = response->get<JsonObject>();
obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
Instance::PostMessage(this, response->serialize().c_str());
}
void ContactInstance::AddressBookRemoveBatch(const JsonValue& args, JsonObject& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
PlatformResult status = AddressBook::AddressBookRemoveBatch(common::JsonCast<JsonObject>(args));
if (status.IsSuccess())
};
auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
+ ScopeLogger("Entered into asynchronous function, get_response");
JsonObject& obj = response->get<JsonObject>();
obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
Instance::PostMessage(this, response->serialize().c_str());
}
void ContactInstance::AddressBookUpdateBatch(const JsonValue& args, JsonObject& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
JsonValue result = JsonValue(JsonArray());
PlatformResult status = AddressBook::AddressBookUpdateBatch(common::JsonCast<JsonObject>(args),
result.get<JsonArray>());
};
auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
+ ScopeLogger("Entered into asynchronous function, get_response");
JsonObject& obj = response->get<JsonObject>();
obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
Instance::PostMessage(this, response->serialize().c_str());
}
void ContactInstance::AddressBookUpdate(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status =
}
void ContactInstance::AddressBookRemove(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status =
}
void ContactInstance::AddressBookFind(const JsonValue& args, JsonObject& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
JsonValue result = JsonValue(JsonArray());
PlatformResult status =
AddressBook::AddressBookFind(JsonCast<JsonObject>(args), result.get<JsonArray>());
};
auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
+ ScopeLogger("Entered into asynchronous function, get_response");
JsonObject& obj = response->get<JsonObject>();
obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
Instance::PostMessage(this, response->serialize().c_str());
}
void ContactInstance::AddressBookAddGroup(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status =
}
void ContactInstance::AddressBookGetGroup(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
JsonValue val{JsonObject{}};
PlatformResult status =
}
void ContactInstance::AddressBookUpdateGroup(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status = AddressBook::AddressBookUpdateGroup(common::JsonCast<JsonObject>(args),
}
void ContactInstance::AddressBookRemoveGroup(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status = AddressBook::AddressBookRemoveGroup(common::JsonCast<JsonObject>(args),
}
void ContactInstance::AddressBookGetGroups(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
JsonValue val{JsonArray{}};
PlatformResult status =
}
void ContactInstance::ContactManagerGetAddressBooks(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
JsonValue result = JsonValue(JsonArray());
PlatformResult status = ContactManager::ContactManagerGetAddressBooks(
common::JsonCast<JsonObject>(args), result.get<JsonArray>());
};
auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
+ ScopeLogger("Entered into asynchronous function, get_response");
JsonObject& obj = response->get<JsonObject>();
obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
Instance::PostMessage(this, response->serialize().c_str());
}
void ContactInstance::ContactManagerGetAddressBook(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
JsonValue val{JsonObject{}};
PlatformResult status = ContactManager::ContactManagerGetAddressBook(
}
void ContactInstance::ContactManagerAddAddressBook(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status = ContactManager::ContactManagerAddAddressBook(
}
void ContactInstance::ContactManagerRemoveAddressBook(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status = ContactManager::ContactManagerRemoveAddressBook(
}
void ContactInstance::AddressBookStartListening(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
JsonValue val{JsonObject{}};
PlatformResult status = AddressBook::AddressBookStartListening(
}
void ContactInstance::AddressBookStopListening(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
JsonValue val{JsonObject{}};
PlatformResult status = AddressBook::AddressBookStopListening(*this);
}
void ContactInstance::ContactManagerGet(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
JsonValue val{JsonObject{}};
PlatformResult status =
}
void ContactInstance::ContactManagerUpdate(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status = ContactManager::ContactManagerUpdate(common::JsonCast<JsonObject>(args),
}
void ContactInstance::ContactManagerUpdateBatch(const JsonValue& args, JsonObject& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
PlatformResult status =
ContactManager::ContactManagerUpdateBatch(common::JsonCast<JsonObject>(args));
};
auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
+ ScopeLogger("Entered into asynchronous function, get_response");
JsonObject& obj = response->get<JsonObject>();
obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
Instance::PostMessage(this, response->serialize().c_str());
}
void ContactInstance::ContactManagerRemove(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status = ContactManager::ContactManagerRemove(common::JsonCast<JsonObject>(args),
}
void ContactInstance::ContactManagerRemoveBatch(const JsonValue& args, JsonObject& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
PlatformResult status =
ContactManager::ContactManagerRemoveBatch(common::JsonCast<JsonObject>(args));
};
auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
+ ScopeLogger("Entered into asynchronous function, get_response");
JsonObject& obj = response->get<JsonObject>();
obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
Instance::PostMessage(this, response->serialize().c_str());
}
void ContactInstance::ContactManagerFind(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [this, args](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
JsonValue result = JsonValue(JsonArray());
PlatformResult status = ContactManager::ContactManagerFind(common::JsonCast<JsonObject>(args),
};
auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
+ ScopeLogger("Entered into asynchronous function, get_response");
JsonObject& obj = response->get<JsonObject>();
obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
Instance::PostMessage(this, response->serialize().c_str());
}
void ContactInstance::ContactManagerFindByUsageCount(const JsonValue& args, JsonObject& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
const double callback_id = args.get("callbackId").get<double>();
auto get = [this, args](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
JsonValue result = JsonValue(JsonArray());
PlatformResult status = ContactManager::ContactManagerFindByUsageCount(
};
auto get_response = [this, callback_id](const std::shared_ptr<JsonValue>& response) {
+ ScopeLogger("Entered into asynchronous function, get_response");
JsonObject& obj = response->get<JsonObject>();
obj["callbackId"] = picojson::value(static_cast<double>(callback_id));
Instance::PostMessage(this, response->serialize().c_str());
}
void ContactInstance::ContactManagerImportFromVCard(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
JsonValue val{JsonObject{}};
PlatformResult status = ContactManager::ContactManagerImportFromVCard(
common::JsonCast<JsonObject>(args), val.get<JsonObject>());
}
void ContactInstance::ContactManagerStartListening(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
JsonValue val{JsonObject{}};
PlatformResult status = ContactManager::ContactManagerStartListening(
}
void ContactInstance::ContactManagerStopListening(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactRead, &out);
JsonValue val{JsonObject{}};
PlatformResult status = ContactManager::ContactManagerStopListening(
}
void ContactInstance::PersonLink(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status =
}
void ContactInstance::PersonUnlink(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
JsonValue val{JsonObject{}};
PlatformResult status =
}
void ContactInstance::PersonResetUsageCount(const JsonValue& args, JsonObject& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContactWrite, &out);
PlatformResult status = Person::PersonResetUsageCount(common::JsonCast<JsonObject>(args));
if (status.IsSuccess()) {
using namespace common;
PlatformResult ContactManagerGetAddressBooks(const JsonObject& args, JsonArray& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult ContactManagerGetAddressBook(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
namespace {
PlatformResult ContactManagerGetInternal(int person_id, JsonObject* out) {
- LoggerD("Enter");
+ ScopeLogger();
contacts_record_h contacts_record = nullptr;
int error_code = contacts_db_get_record(_contacts_person._uri, person_id, &contacts_record);
}
PlatformResult ContactManagerAddAddressBook(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult ContactManagerRemoveAddressBook(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult ContactManagerGet(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult ContactManagerUpdate(const JsonObject& args, JsonObject&) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult ContactManagerUpdateBatch(const JsonObject& args) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult ContactManagerRemove(const JsonObject& args, JsonObject&) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult ContactManagerRemoveBatch(const JsonObject& args) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult ContactManagerFind(const JsonObject& args, JsonArray& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult ContactManagerFindByUsageCount(const JsonObject& args, JsonArray& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
contacts_query_h contacts_query = nullptr;
}
PlatformResult ContactManagerImportFromVCard(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
// I'm not sure how to call it. Should it be 'Contact', 'vCard' or what?
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
void ContactManagerListenerCallback(const char* view_uri, char* changes, void* user_data) {
- LoggerD("ContactManagerListenerCallback");
+ ScopeLogger("ContactManagerListenerCallback");
(void)view_uri;
PlatformResult ContactManagerStartListening(ContactInstance& instance, const JsonObject& /*args*/,
JsonObject& /*out*/) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
PlatformResult ContactManagerStopListening(ContactInstance& instance, const JsonObject& /*args*/,
JsonObject& /*out*/) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
is_filter_set_(false),
is_sort_mode_set_(false),
is_sort_mode_asc_(false) {
- LoggerD("Entered");
+ ScopeLogger();
}
void ContactSearchEngine::SetAddressBookId(long id) {
- LoggerD("Entered");
+ ScopeLogger();
addressbook_id_ = id;
is_addressbook_id_is_set_ = true;
}
common::PlatformResult ContactSearchEngine::ApplyFilter(const picojson::value& filter, int depth) {
- LoggerD("Entered");
+ ScopeLogger();
if (!filter.is<picojson::object>()) {
return LogAndCreateResult(ErrorCode::TYPE_MISMATCH_ERR, "Failed to set filter");
}
PlatformResult ContactSearchEngine::SetSortMode(const picojson::value& sort_mode) {
- LoggerD("Entered");
+ ScopeLogger();
if (!sort_mode.is<picojson::object>()) {
return LogAndCreateResult(ErrorCode::TYPE_MISMATCH_ERR, "Failed to set sort mode");
}
common::PlatformResult ContactSearchEngine::Find(picojson::array* out) {
- LoggerD("Entered");
+ ScopeLogger();
if (is_filter_set_) {
if (is_sort_mode_set_) {
common::AttributeMatchFlag match_flag,
const picojson::value& match_value,
int depth) {
- LoggerD("Entered");
+ ScopeLogger();
LongSetPtr id_set = LongSetPtr(new LongSet());
const picojson::value& initial_value,
const picojson::value& end_value,
int depth) {
- LoggerD("Entered");
+ ScopeLogger();
bool initial_value_set = (!IsNull(initial_value));
bool end_value_set = (!IsNull(end_value));
PlatformResult ContactSearchEngine::GetAllContactsSorted(
const FilterPropertyStruct& attribute_properties, bool is_ascending, picojson::array* out) {
- LoggerD("Entered");
+ ScopeLogger();
LongVectorPtr sorted_ids = LongVectorPtr(new LongVector());
SortContacts(attribute_properties, sorted_ids, is_ascending);
}
PlatformResult ContactSearchEngine::GetAllContacts(picojson::array* out) {
- LoggerD("Entered");
+ ScopeLogger();
contacts_list_h list = nullptr;
int error_code = 0;
template <typename Iterator>
PlatformResult ContactSearchEngine::GetContacts(Iterator begin, Iterator end,
picojson::array* out) {
- LoggerD("Entered");
+ ScopeLogger();
for (auto iter = begin; iter != end; ++iter) {
const auto id = *iter;
contacts_filter_h filter,
unsigned int property_id,
LongSetPtr result) {
- LoggerD("Entered");
+ ScopeLogger();
int error_code = contacts_query_set_filter(query, filter);
auto status = ContactUtil::ErrorChecker(error_code, "Failed contacts_query_set_filter");
PlatformResult ContactSearchEngine::QueryAttributeBool(
const FilterPropertyStruct& attribute_properties, LongSetPtr result, bool match_value) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
PlatformResult ContactSearchEngine::QueryAttributeInt(
const FilterPropertyStruct& attribute_properties, LongSetPtr result,
contacts_match_int_flag_e match, int match_value) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
PlatformResult ContactSearchEngine::QueryAttributeString(
const FilterPropertyStruct& attribute_properties, LongSetPtr result,
contacts_match_str_flag_e match, const char* match_value) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
PlatformResult ContactSearchEngine::QueryAttributeDate(
const std::string& attr_name, const FilterPropertyStruct& attribute_properties,
LongSetPtr result, contacts_match_int_flag_e match, int match_value) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
PlatformResult ContactSearchEngine::QueryAttributeRangeBool(
const FilterPropertyStruct& attribute_properties, LongSetPtr result, bool initial_value_is_set,
bool initial_value, bool end_value_is_set, bool end_value) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
PlatformResult ContactSearchEngine::QueryAttributeRangeInt(
const FilterPropertyStruct& attribute_properties, LongSetPtr result, bool initial_value_is_set,
int initial_value, bool end_value_is_set, int end_value) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
PlatformResult ContactSearchEngine::QueryAttributeRangeString(
const FilterPropertyStruct& attribute_properties, LongSetPtr result, const char* initial_value,
const char* end_value) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
const std::string& attr_name, const FilterPropertyStruct& attribute_properties,
LongSetPtr result, bool initial_value_is_set, int initial_value, bool end_value_is_set,
int end_value) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
PlatformResult ContactSearchEngine::SortContacts(const FilterPropertyStruct& attribute_properties,
LongVectorPtr result, bool is_ascending,
LongSetPtr ids) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
PlatformResult ContactSearchEngine::SortContacts(const FilterPropertyStruct& attribute_properties,
LongVectorPtr result, bool is_ascending) {
- LoggerD("Entered");
+ ScopeLogger();
const char* view_uri = attribute_properties.view_uri;
unsigned int property_contact_id = attribute_properties.property_contact_id;
}
PlatformResult ErrorChecker(int err, const char* message) {
- LoggerD("Enter");
+ ScopeLogger();
if (CONTACTS_ERROR_NONE != err) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, message);
}
}
PlatformResult GetStrFromRecord(contacts_record_h record, unsigned int property_id, char** value) {
- LoggerD("Enter");
+ ScopeLogger();
int err = contacts_record_get_str_p(record, property_id, value);
if (CONTACTS_ERROR_NONE != err) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error during getting contact record",
}
PlatformResult GetIntFromRecord(contacts_record_h record, unsigned int property_id, int* value) {
- LoggerD("Enter");
+ ScopeLogger();
int err = contacts_record_get_int(record, property_id, value);
if (CONTACTS_ERROR_NONE != err) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error during getting contact record",
}
PlatformResult GetBoolFromRecord(contacts_record_h record, unsigned int property_id, bool* value) {
- LoggerD("Enter");
+ ScopeLogger();
int err = contacts_record_get_bool(record, property_id, value);
if (CONTACTS_ERROR_NONE != err) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error during getting contact record",
PlatformResult SetStrInRecord(contacts_record_h record, unsigned int property_id,
const char* value) {
- LoggerD("Enter");
+ ScopeLogger();
int err = contacts_record_set_str(record, property_id, value);
if (CONTACTS_ERROR_NONE != err) {
return LogAndCreateResult(
}
PlatformResult SetIntInRecord(contacts_record_h record, unsigned int property_id, int value) {
- LoggerD("Enter");
+ ScopeLogger();
int err = contacts_record_set_int(record, property_id, value);
if (CONTACTS_ERROR_NONE != err) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error during setting contact record",
}
PlatformResult SetBoolInRecord(contacts_record_h record, unsigned int property_id, bool value) {
- LoggerD("Enter");
+ ScopeLogger();
int err = contacts_record_set_bool(record, property_id, value);
if (CONTACTS_ERROR_NONE != err) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error during setting contact record",
}
PlatformResult ClearAllContactRecord(contacts_record_h contacts_record, unsigned int property_id) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
PlatformResult GetNumberOfChildRecord(contacts_record_h contacts_record, unsigned int property_id,
int* child_count) {
- LoggerD("Enter");
+ ScopeLogger();
Assert(child_count);
int err = contacts_record_get_child_record_count(contacts_record, property_id, child_count);
PlatformResult ImportContactNameFromContactsRecord(contacts_record_h contacts_record,
JsonObject* out_ptr, bool* is_contact_name) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
if (!contacts_record) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Contacts record is null");
PlatformResult ExportContactNameToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
PlatformResult ImportContactEmailAddressFromContactsRecord(contacts_record_h contacts_record,
unsigned int index,
JsonObject* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ExportContactEmailAddressToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
contacts_record_h c_email_record_h = nullptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ImportContactPhoneNumberFromContactsRecord(contacts_record_h contacts_record,
unsigned int index, JsonObject* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
contacts_record_h child_record = nullptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
PlatformResult ExportContactPhoneNumberToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
contacts_record_h phone_record = nullptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ImportContactOrganizationFromContactsRecord(contacts_record_h contacts_record,
unsigned int index,
JsonObject* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ExportContactOrganizationToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
PlatformResult ImportContactWebSiteFromContactsRecord(contacts_record_h contacts_record,
unsigned int index, JsonObject* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ExportContactWebSiteToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
PlatformResult ImportContactAnniversariesFromContactsRecord(contacts_record_h contacts_record,
unsigned int index, JsonObject* out_ptr,
bool* ret) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ExportContactAnniversariesToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
PlatformResult ImportContactRelationshipFromContactsRecord(contacts_record_h contacts_record,
unsigned int index,
JsonObject* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ExportContactRelationshipToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
PlatformResult ImportContactExtensionFromContactsRecord(contacts_record_h contacts_record,
unsigned int index, JsonObject* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
picojson::value(data1 ? JsonValue{static_cast<double>(data1)} : JsonValue{})));
auto insert_data = [&](unsigned int id, const std::string& label) {
+ ScopeLogger("Entered into asynchronous function, insert_data");
char* data = nullptr;
status = ContactUtil::GetStrFromRecord(child_record, id, &data);
if (status && data) {
PlatformResult ExportContactExtensionToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
}
auto set_data = [&](int id, const char* label) {
+ ScopeLogger("Entered into asynchronous function, set_data");
+
if (!IsNull(in, label)) {
status =
ContactUtil::SetStrInRecord(child_record, id, FromJson<JsonString>(in, label).c_str());
PlatformResult ImportContactInstantMessengerFromContactsRecord(contacts_record_h contacts_record,
unsigned int index,
JsonObject* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ExportContactInstantMessengerToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
PlatformResult ImportContactAddressFromContactsRecord(contacts_record_h contacts_record,
unsigned int index, JsonObject* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ExportContactAddressToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
PlatformResult ImportContactNotesFromContactsRecord(contacts_record_h contacts_record,
unsigned int index, JsonValue* val) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
PlatformResult ExportNotesToContactsRecord(contacts_record_h contacts_record,
const std::string& value) {
- LoggerD("Enter");
+ ScopeLogger();
contacts_record_h notes_record = nullptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ImportGroupIdsFromContactsRecord(contacts_record_h contacts_record,
unsigned int index, JsonValue* val) {
- LoggerD("Enter");
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
}
PlatformResult ExportGroupIdsToContactsRecord(contacts_record_h contacts_record, int value) {
- LoggerD("Enter");
+ ScopeLogger();
contacts_record_h notes_record = nullptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ImportContactFromContactsRecord(contacts_record_h contacts_record,
JsonObject* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
JsonObject& out = *out_ptr;
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
PlatformResult ExportContactToContactsRecord(contacts_record_h contacts_record,
const JsonObject& in) {
+ ScopeLogger();
// contacts_record is protected by unique_ptr and its ownership is not passed
// here
if (!contacts_record) {
* @param[out] contacts_record_h Record which is updated
*/
PlatformResult ExportPersonToContactsRecord(contacts_record_h record, const JsonObject& args) {
+ ScopeLogger();
if (nullptr == record) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Platform person object did not set");
}
PlatformResult UpdateAdditionalInformation(const contacts_record_h contacts_record,
JsonObject* out_ptr) {
+ ScopeLogger();
JsonObject& out = *out_ptr;
int int_value = -1;
PlatformResult status =
}
PlatformResult CheckDBConnection() {
+ ScopeLogger();
static bool _connected = false;
if (_connected) return PlatformResult(ErrorCode::NO_ERROR);
};
PlatformResult PersonLink(const JsonObject& args, JsonObject&) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult PersonUnlink(const JsonObject& args, JsonObject& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult GetUsageCount(const JsonObject& args, JsonObject& out) {
- LoggerD("Entered");
+ ScopeLogger();
// Retrieve person_id
long person_id = common::stol(FromJson<JsonString>(args, kGetUsageCountArgPersonId));
}
PlatformResult PersonResetUsageCount(const JsonObject& args) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = ContactUtil::CheckDBConnection();
if (status.IsError()) return status;
}
PlatformResult PersonPropertyFromString(const std::string& name, PersonProperty* person_prop) {
- LoggerD("Enter");
+ ScopeLogger();
auto iter = personPropertyMap.find(name);
if (iter == personPropertyMap.end()) {
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Invalid property name",
};
std::string escapeValueString(const std::string& data) {
- LoggerD("Enter");
+ ScopeLogger();
std::string out;
// If string won't be resized, then it will be faster
out.reserve(data.size());
} // namespace
PlatformResult ContentFilter::MapField(const std::string& name, std::string* result) {
- LoggerD("Enter");
+ ScopeLogger();
auto it = attributeNameMap.find(name);
if (it != attributeNameMap.end()) {
*result = it->second;
PlatformResult ContentFilter::BuildQuery(const picojson::object& jsFilter,
std::string* queryToCall) {
- LoggerD("Enter");
+ ScopeLogger();
std::vector<std::vector<std::string>> partialqueries;
partialqueries.push_back(std::vector<std::string>());
visitor.SetOnAttributeFilter([&](const std::string& name, AttributeMatchFlag match_flag,
const picojson::value& match_value) {
- LoggerD("entered OnAttributeFilter");
+ ScopeLogger("Entered into asynchronous function, visitor.SetOnAttributeFilter's argument");
std::string query;
std::string matchValue;
});
visitor.SetOnCompositeFilterBegin([&](CompositeFilterType type) {
- LoggerD("entered OnCompositeFilterBegin");
+ ScopeLogger("Entered into asynchronous function, visitor.SetOnCompositeFilterBegin's argument");
partialqueries.push_back(std::vector<std::string>());
return PlatformResult(ErrorCode::NO_ERROR);
});
visitor.SetOnCompositeFilterEnd([&](CompositeFilterType calType) {
- LoggerD("entered OnCompositeFilterEnd");
+ ScopeLogger("Entered into asynchronous function, visitor.SetOnCompositeFilterEnd's argument");
std::string finalQuery;
std::string separator;
visitor.SetOnAttributeRangeFilter([&](const std::string& name,
const picojson::value& initial_value,
const picojson::value& end_value) {
- LoggerD("entered OnAttributeFilter");
+ ScopeLogger("Entered into asynchronous function, visitor.SetOnAttributeRangeFilter's argument");
std::string query = "";
std::string paramName;
listener_handle_(nullptr),
listener_data_(nullptr),
callback_data_(nullptr) {
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
ContentInstance::~ContentInstance() {
- LoggerD("entered");
+ ScopeLogger();
if (noti_handle_) {
media_content_remove_db_updated_cb(noti_handle_);
}
static gboolean CompletedCallback(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("entered");
+ ScopeLogger();
picojson::object out;
out["callbackId"] = picojson::value(user_data->callbackId);
}
static void* WorkThread(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("entered");
+ ScopeLogger();
int ret = MEDIA_CONTENT_ERROR_NONE;
ContentCallbacks cbType = user_data->cbType;
}
static void ScanDirectoryCallback(media_content_error_e error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
ReplyCallbackData* cbData = (ReplyCallbackData*)user_data;
media_content_db_update_type_e update_type,
media_content_type_e media_type, char* uuid, char* path,
char* mime_type, void* user_data) {
- LoggerD("Entered file change callback");
+ ScopeLogger("File change callback");
if (error != MEDIA_CONTENT_ERROR_NONE) {
LOGGER(ERROR) << "Media content changed callback error: " << error;
media_content_db_update_type_e update_type,
media_content_type_e media_type, char* uuid, char* path,
char* mime_type, void* user_data) {
- LoggerD("Entered directory change callback");
+ ScopeLogger("Directory change callback");
if (error != MEDIA_CONTENT_ERROR_NONE) {
LOGGER(ERROR) << "Media content changed v2 callback error: " << error;
static PlatformResult prepareDirectoryChangeResponse(media_content_db_update_type_e update_type,
char* uuid, picojson::object& obj) {
- LoggerD("Media item is a directory");
+ ScopeLogger("Media item is a directory");
if (MEDIA_CONTENT_DELETE == update_type) {
ReportSuccess(picojson::value(std::string(uuid)), obj);
static PlatformResult prepareFileChangeResponse(media_content_db_update_type_e update_type,
char* uuid, picojson::object& obj) {
- LoggerD("Media item is a file");
+ ScopeLogger("Media item is a file");
if (MEDIA_CONTENT_DELETE == update_type) {
ReportSuccess(picojson::value(std::string(uuid)), obj);
media_content_db_update_type_e update_type,
media_content_type_e media_type, char* uuid, char* path,
char* mime_type, void* user_data) {
- LoggerD("Entered directory and file change callback");
+ ScopeLogger("directory and file change callback");
if (MEDIA_CONTENT_ERROR_NONE != error) {
LoggerE("Failed to perform contentChangeCallback: %d", error);
}
void ContentInstance::ContentManagerUpdate(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
if (ContentManager::getInstance()->isConnected()) {
void ContentInstance::ContentManagerUpdatebatch(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
- LoggerE("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
double callbackId = args.get("callbackId").get<double>();
}
void ContentInstance::ContentManagerGetdirectories(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_EXIST(args, "callbackId", out)
double callbackId = args.get("callbackId").get<double>();
common::TaskQueue::GetInstance().Queue<ReplyCallbackData>(WorkThread, CompletedCallback, cbData);
}
void ContentInstance::ContentManagerFind(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
// CHECK_PRIVILEGE_ACCESS(kPrivilegeContentRead, &out);
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
}
void ContentInstance::ContentManagerScanfile(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
CHECK_EXIST(args, "callbackId", out)
void ContentInstance::ContentManagerScanDirectory(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
CHECK_EXIST(args, "callbackId", out)
void ContentInstance::ContentManagerCancelScanDirectory(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
CHECK_EXIST(args, "contentDirURI", out)
void ContentInstance::ContentManagerAddChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
callback_data_ = new ReplyCallbackData();
callback_data_->instance = this;
void ContentInstance::ContentManagerRemoveChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult result = ContentManager::getInstance()->removeChangeListener(listener_handle_);
void ContentInstance::ContentManagerSetchangelistener(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: setChangeListener() is deprecated and will be removed from next "
"release. "
void ContentInstance::ContentManagerUnsetchangelistener(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: unsetChangeListener() is deprecated and will be removed from next "
"release. "
void ContentInstance::ContentManagerGetplaylists(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
// CHECK_PRIVILEGE_ACCESS(kPrivilegeContentRead, &out);
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
}
void ContentInstance::ContentManagerCreateplaylist(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
CHECK_EXIST(args, "callbackId", out)
}
void ContentInstance::ContentManagerRemoveplaylist(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
double callbackId = args.get("callbackId").get<double>();
void ContentInstance::ContentManagerCreateThumbnail(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
common::PlatformResult result = common::PlatformResult(common::ErrorCode::NO_ERROR);
void ContentInstance::ContentManagerPlaylistAdd(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
if (ContentManager::getInstance()->isConnected()) {
void ContentInstance::ContentManagerPlaylistAddbatch(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
double callbackId = args.get("callbackId").get<double>();
void ContentInstance::ContentManagerPlaylistGet(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
// CHECK_PRIVILEGE_ACCESS(kPrivilegeContentRead, &out);
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
void ContentInstance::ContentManagerPlaylistRemove(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
if (ContentManager::getInstance()->isConnected()) {
void ContentInstance::ContentManagerPlaylistRemovebatch(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
double callbackId = args.get("callbackId").get<double>();
void ContentInstance::ContentManagerPlaylistSetorder(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
double callbackId = args.get("callbackId").get<double>();
void ContentInstance::ContentManagerPlaylistMove(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
double callbackId = args.get("callbackId").get<double>();
void ContentInstance::ContentManagerAudioGetLyrics(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
- LOGGER(DEBUG) << "entered";
+ ScopeLogger();
picojson::object lyrics;
if (ContentManager::getInstance()->isConnected()) {
}
void ContentInstance::PlaylistGetName(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
int ret;
CHECK_EXIST(args, "id", out)
int id = static_cast<int>(args.get("id").get<double>());
}
void ContentInstance::PlaylistSetName(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
int ret;
}
void ContentInstance::PlaylistGetThumbnailUri(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
int ret;
CHECK_EXIST(args, "id", out)
int id = static_cast<int>(args.get("id").get<double>());
}
void ContentInstance::PlaylistSetThumbnailUri(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeContentWrite, &out);
int ret;
void ContentInstance::PlaylistGetNumberOfTracks(const picojson::value& args,
picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_EXIST(args, "id", out)
int id = static_cast<int>(args.get("id").get<double>());
int count = 0;
};
std::string get_date(char* tmpStr) {
- LoggerD("Enter");
+ ScopeLogger();
if (tmpStr) {
struct tm* result = (struct tm*)calloc(1, sizeof(struct tm));
if (nullptr != result) {
}
void ContentToJson(media_info_h info, picojson::object& o) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
int tmpInt = 0;
bool tmpBool = false;
}
void ContentDirToJson(media_folder_h folder, picojson::object& o) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
char* tmpStr = NULL;
media_content_storage_e storage_type;
}
static int setContent(media_info_h media, const picojson::value& content) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
std::string name = content.get("name").to_str();
}
static void FolderToJson(media_folder_h folder, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
char* name = NULL;
char* id = NULL;
}
static bool media_foreach_directory_cb(media_folder_h folder, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array* array = static_cast<picojson::array*>(user_data);
picojson::object json;
FolderToJson(folder, &json);
}
static bool media_foreach_content_cb(media_info_h media, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value::array* contents = static_cast<picojson::value::array*>(user_data);
picojson::value::object o;
ContentToJson(media, o);
}
static bool playlist_foreach_cb(media_playlist_h playlist, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value::array* playlists = static_cast<picojson::value::array*>(user_data);
picojson::value::object o;
if (playlist != NULL) {
static bool playlist_content_member_cb(int playlist_member_id, media_info_h media,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value::array* contents = static_cast<picojson::value::array*>(user_data);
picojson::value::object o;
}
void CreateThumbnailCallback(media_content_error_e err, const char* path, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned int* callbackId = (unsigned int*)user_data;
if (nullptr == callbackId) {
}
ContentManager::ContentManager() {
- LoggerD("ContentManager called");
+ ScopeLogger("ContentManager called");
if (media_content_connect() == MEDIA_CONTENT_ERROR_NONE) {
m_dbConnected = true;
} else {
}
ContentManager::~ContentManager() {
- LoggerD("Enter");
+ ScopeLogger();
if (m_dbConnected) {
if (media_content_disconnect() == MEDIA_CONTENT_ERROR_NONE) {
m_dbConnected = false;
}
ContentManager* ContentManager::getInstance() {
- LoggerD("Enter");
+ ScopeLogger();
static ContentManager instance;
return &instance;
}
ContentInstance* ContentManager::getContentInstance() {
- LoggerD("Enter");
+ ScopeLogger();
return m_contentInstance;
}
void ContentManager::setContentInstance(ContentInstance* const content_instance) {
- LoggerD("Enter");
+ ScopeLogger();
m_contentInstance = content_instance;
}
bool ContentManager::isConnected() {
- LoggerD("Enter");
+ ScopeLogger();
return m_dbConnected;
}
void ContentManager::getDirectories(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
filter_h filter = NULL;
ret = media_filter_create(&filter);
}
void ContentManager::find(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
int count, offset;
}
int ContentManager::scanFile(std::string& uri) {
- LoggerD("Enter");
+ ScopeLogger();
return media_content_scan_file(uri.c_str());
}
PlatformResult ContentManager::scanDirectory(media_scan_completed_cb callback,
ReplyCallbackData* cbData) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string& contentDirURI = cbData->args.get("contentDirURI").get<std::string>();
std::string real_path = common::FilesystemProvider::Create().GetRealPath(contentDirURI);
const bool recursive = cbData->args.get("recursive").get<bool>();
}
PlatformResult ContentManager::cancelScanDirectory(const std::string& content_dir_uri) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = media_content_cancel_scan_folder(content_dir_uri.c_str());
if (ret != MEDIA_CONTENT_ERROR_NONE) {
PlatformResult ContentManager::addChangeListener(media_content_noti_h* noti_handle,
media_content_db_update_cb callback,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = media_content_add_db_updated_cb(callback, user_data, noti_handle);
}
PlatformResult ContentManager::removeChangeListener(media_content_noti_h noti_handle) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = media_content_remove_db_updated_cb(noti_handle);
PlatformResult ContentManager::setChangeListener(media_content_db_update_cb callback,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = media_content_set_db_updated_cb(callback, user_data);
if (ret != MEDIA_CONTENT_ERROR_NONE) {
}
PlatformResult ContentManager::unSetChangeListener() {
- LoggerD("Enter");
+ ScopeLogger();
int ret = media_content_unset_db_updated_cb();
if (ret != MEDIA_CONTENT_ERROR_NONE) {
void ContentManager::createPlaylist(std::string name,
const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
media_playlist_h playlist = NULL;
int ret = media_playlist_insert_to_db(name.c_str(), &playlist);
}
void ContentManager::getPlaylists(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
filter_h filter = nullptr;
media_filter_create(&filter);
void ContentManager::removePlaylist(std::string playlistId,
const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
int id = std::atoi(playlistId.c_str());
if (id == 0) {
PlatformResult err = LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "PlaylistId is wrong.");
}
int ContentManager::update(picojson::value args) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
picojson::value content = args.get("content");
}
int ContentManager::updateBatch(picojson::value args) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = 0;
std::vector<picojson::value> contents = args.get("contents").get<picojson::array>();
}
int ContentManager::playlistAdd(std::string playlist_id, std::string content_id) {
- LoggerD("Enter");
+ ScopeLogger();
media_playlist_h playlist = NULL;
int ret = media_playlist_get_playlist_from_db(std::stoi(playlist_id), &playlist);
}
int ContentManager::playlistRemove(std::string playlist_id, int member_id) {
- LoggerD("Enter");
+ ScopeLogger();
media_playlist_h playlist = NULL;
int ret = media_playlist_get_playlist_from_db(std::stoi(playlist_id), &playlist);
}
void ContentManager::playlistAddbatch(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
std::string playlist_id = user_data->args.get("playlistId").get<std::string>();
media_playlist_h playlist = NULL;
}
void ContentManager::playlistGet(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
media_playlist_h playlist = NULL;
media_content_order_e order = MEDIA_CONTENT_ORDER_ASC;
const std::string playOrder("play_order");
}
void ContentManager::playlistRemovebatch(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
media_playlist_h playlist = NULL;
SCOPE_EXIT {
}
void ContentManager::playlistSetOrder(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
media_playlist_h playlist = NULL;
SCOPE_EXIT {
}
void ContentManager::playlistMove(const std::shared_ptr<ReplyCallbackData>& user_data) {
- LoggerD("Enter");
+ ScopeLogger();
media_playlist_h playlist = NULL;
SCOPE_EXIT {
}
int ContentManager::getLyrics(const picojson::value& args, picojson::object& result) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = METADATA_EXTRACTOR_ERROR_NONE;
const std::string& contentURI = args.get("contentURI").to_str();
}
media_playlist_h getPlaylistHandle(int id) {
- LoggerD("Entered");
+ ScopeLogger();
media_playlist_h playlist_handle = nullptr;
int ret_code = media_playlist_get_playlist_from_db(id, &playlist_handle);
if (MEDIA_CONTENT_ERROR_NONE != ret_code || playlist_handle == nullptr) {
}
void destroyMediaPlaylistHandle(media_playlist_h& playlist_handle) {
- LoggerD("Entered");
+ ScopeLogger();
if (playlist_handle) {
int ret_code = media_playlist_destroy(playlist_handle);
playlist_handle = nullptr;
}
int ContentManager::getPlaylistName(int id, std::string* result) {
- LoggerD("Entered");
+ ScopeLogger();
media_playlist_h playlist_handle = getPlaylistHandle(id);
PlaylistUniquePtr playlist_ptr(playlist_handle, destroyMediaPlaylistHandle);
}
int updatePlaylistInDB(media_playlist_h playlist_handle) {
- LoggerD("Entered");
+ ScopeLogger();
int ret_code = media_playlist_update_to_db(playlist_handle);
if (MEDIA_CONTENT_ERROR_NONE != ret_code) {
LoggerE("media_playlist_update_to_db failed");
}
int ContentManager::setPlaylistName(int id, const std::string& name) {
- LoggerD("Entered");
+ ScopeLogger();
if (name.empty()) {
LoggerE("Cannot set empty playlist name!");
return MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
}
int ContentManager::getThumbnailUri(int id, std::string* result) {
- LoggerD("Entered");
+ ScopeLogger();
media_playlist_h playlist_handle = getPlaylistHandle(id);
PlaylistUniquePtr playlist_ptr(playlist_handle, destroyMediaPlaylistHandle);
}
int ContentManager::setThumbnailUri(int id, const std::string& thb_uri) {
- LoggerD("Entered");
+ ScopeLogger();
// Allow setting empty URI, unfortunately Core API does not allow to set empty
// path so we need to set one empty space. This is probably issue of Core API.
}
int ContentManager::getNumberOfTracks(int id, int* result) {
- LoggerD("Entered");
+ ScopeLogger();
int count = 0;
const int ret_code = media_playlist_get_media_count_from_db(id, nullptr, &count);
}
common::PlatformResult ContentManager::createThumbnail(const picojson::value& args) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned int* callbackId =
new unsigned int(static_cast<unsigned int>(args.get("callbackId").get<double>()));
static std::map<int, DatacontrolInformation*> IdMap;
DatacontrolInstance::DatacontrolInstance() {
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
#define REGISTER_SYNC(c, x) \
}
DatacontrolInstance::~DatacontrolInstance() {
+ ScopeLogger();
}
static void ReplyAsync(DatacontrolInstance* instance, int callbackId, bool isSuccess,
picojson::object* param) {
- LoggerD("Enter");
+ ScopeLogger();
(*param)["callbackId"] = picojson::value(static_cast<double>(callbackId));
(*param)["status"] = picojson::value(isSuccess ? "success" : "error");
}
static bool SQLColumnName(result_set_cursor cursor, int columnIndex, picojson::value& name) {
- LoggerD("Enter");
+ ScopeLogger();
char buffer[4096];
int result = data_control_sql_get_column_name(cursor, columnIndex, buffer);
if (result != DATA_CONTROL_ERROR_NONE) {
}
static bool SQLColumnValue(result_set_cursor cursor, int columnIndex, picojson::value& val) {
- LoggerD("Enter");
+ ScopeLogger();
data_control_sql_column_type_e type = DATA_CONTROL_SQL_COLUMN_TYPE_UNDEFINED;
int result = data_control_sql_get_column_item_type(cursor, columnIndex, &type);
if (result != DATA_CONTROL_ERROR_NONE) {
static void MAPAddResponseCallback(int requestId, data_control_h handle, bool providerResult,
const char* error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
DatacontrolInformation* info = IdMap[requestId];
if (info == NULL) {
LoggerE("Invalid context");
static void MAPSetResponseCallback(int requestId, data_control_h handle, bool providerResult,
const char* error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
DatacontrolInformation* info = IdMap[requestId];
if (info == NULL) {
LoggerE("Invalid context");
static void MAPGetResponseCallback(int requestId, data_control_h handle, char** result_value_list,
int result_value_count, bool providerResult, const char* error,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
DatacontrolInformation* info = IdMap[requestId];
if (info == NULL) {
LoggerE("Invalid context");
static void MAPRemoveReponseCallback(int requestId, data_control_h handle, bool providerResult,
const char* error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
DatacontrolInformation* info = IdMap[requestId];
if (info == NULL) {
LoggerE("Invalid context");
static void SQLSelectResponseCallback(int requestId, data_control_h handle,
result_set_cursor cursor, bool providerResult,
const char* error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
DatacontrolInformation* info = IdMap[requestId];
if (info == NULL) {
LoggerE("Invalid context");
static void SQLInsertResponseCallback(int requestId, data_control_h handle,
long long inserted_row_id, bool providerResult,
const char* error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
DatacontrolInformation* info = IdMap[requestId];
if (info == NULL) {
LoggerE("Invalid context");
static void SQLUpdateResponseCallback(int requestId, data_control_h handle, bool providerResult,
const char* error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
DatacontrolInformation* info = IdMap[requestId];
if (info == NULL) {
LoggerE("Invalid context");
static void SQLDeleteResponseCallback(int requestId, data_control_h handle, bool providerResult,
const char* error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
DatacontrolInformation* info = IdMap[requestId];
if (info == NULL) {
LoggerE("Invalid context");
int DatacontrolInstance::RunMAPDataControlJob(const std::string& providerId,
const std::string& dataId, int callbackId,
int userRequestId, DataControlJob job) {
- LoggerD("Enter");
+ ScopeLogger();
int result = DATA_CONTROL_ERROR_NONE;
std::unique_ptr<DatacontrolInformation> info{new DatacontrolInformation()};
info->callbackId = callbackId;
int DatacontrolInstance::RunSQLDataControlJob(const std::string& providerId,
const std::string& dataId, int callbackId,
int userRequestId, DataControlJob job) {
- LoggerD("Enter");
+ ScopeLogger();
int result = DATA_CONTROL_ERROR_NONE;
std::unique_ptr<DatacontrolInformation> info{new DatacontrolInformation()};
info->callbackId = callbackId;
void DatacontrolInstance::DataControlManagerGetdatacontrolconsumer(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDatacontrol, &out);
CHECK_EXIST(args, "providerId", out)
}
void DatacontrolInstance::SQLDataControlConsumerInsert(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDatacontrol, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "reqId", out)
}
void DatacontrolInstance::SQLDataControlConsumerUpdate(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDatacontrol, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "reqId", out)
int result = RunSQLDataControlJob(
providerId, dataId, callbackId, reqId,
[&updateData, &where](data_control_h& handle, int* requestId) -> int {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array columns = updateData["columns"].get<picojson::array>();
picojson::array values = updateData["values"].get<picojson::array>();
void DatacontrolInstance::SQLDataControlConsumerRemove(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDatacontrol, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "reqId", out)
void DatacontrolInstance::SQLDataControlConsumerSelect(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDatacontrol, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "reqId", out)
int result = RunSQLDataControlJob(
providerId, dataId, callbackId, reqId, [&columns, &where, order, page, maxNumberPerPage](
data_control_h& handle, int* requestId) -> int {
- LoggerD("Enter");
+ ScopeLogger();
std::vector<const char*> temp;
for (auto& s : columns) temp.push_back(s.get<std::string>().c_str());
int columnCount = static_cast<int>(temp.size());
}
void DatacontrolInstance::MappedDataControlConsumerAddvalue(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDatacontrol, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "reqId", out)
}
void DatacontrolInstance::MappedDataControlConsumerRemovevalue(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDatacontrol, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "reqId", out)
}
void DatacontrolInstance::MappedDataControlConsumerGetvalue(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDatacontrol, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "reqId", out)
}
void DatacontrolInstance::MappedDataControlConsumerUpdatevalue(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDatacontrol, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "reqId", out)
} // namespace
DownloadInstance::DownloadInstance() {
- LoggerD("Entered");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&DownloadInstance::x, this, _1, _2));
}
DownloadInstance::~DownloadInstance() {
- LoggerD("Entered");
+ ScopeLogger();
int ret;
for (DownloadCallbackMap::iterator it = download_callbacks.begin();
it != download_callbacks.end(); ++it) {
}
bool DownloadInstance::CheckInstance(DownloadInstance* instance) {
- LoggerD("Entered");
+ ScopeLogger();
for (auto vec_instance : instances_) {
if (vec_instance == instance) {
return true;
}
void DownloadInstance::OnStateChanged(int download_id, download_state_e state, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
downCbPtr->state = state;
}
gboolean DownloadInstance::OnProgressChanged(void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
std::lock_guard<std::mutex> lock(instances_mutex_);
if (!CheckInstance(downCbPtr->instance)) {
}
void DownloadInstance::OnStart(int download_id, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
unsigned long long totalSize;
CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
}
gboolean DownloadInstance::OnFinished(void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
char* fullPath = NULL;
CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
}
gboolean DownloadInstance::OnPaused(void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
std::lock_guard<std::mutex> lock(instances_mutex_);
if (!CheckInstance(downCbPtr->instance)) {
}
gboolean DownloadInstance::OnCanceled(void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
std::lock_guard<std::mutex> lock(instances_mutex_);
if (!CheckInstance(downCbPtr->instance)) {
}
gboolean DownloadInstance::OnFailed(void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
download_error_e error;
picojson::object out;
void DownloadInstance::progress_changed_cb(int download_id, long long unsigned received,
void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
CallbackPtr downCbPtr = static_cast<CallbackPtr>(user_data);
downCbPtr->received = received;
downCbPtr->downloadId = download_id;
}
void DownloadInstance::DownloadManagerStart(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeDownload, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "url", out)
}
void DownloadInstance::DownloadManagerCancel(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "downloadId", out)
int downloadId, ret;
}
void DownloadInstance::DownloadManagerPause(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "downloadId", out)
int downloadId, ret;
}
void DownloadInstance::DownloadManagerResume(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "downloadId", out)
int downloadId, ret;
}
void DownloadInstance::DownloadManagerGetstate(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "downloadId", out)
int downloadId, ret;
std::string stateValue;
void DownloadInstance::DownloadManagerGetmimetype(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "downloadId", out)
int downloadId, ret;
}
bool DownloadInstance::GetDownloadID(const int callback_id, int& download_id) {
- LoggerD("Entered");
+ ScopeLogger();
if (diMap.find(callback_id) != diMap.end()) {
download_id = diMap.find(callback_id)->second->download_id;
} else {
void DownloadInstance::DownloadManagerGetdownloadrequest(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
// Nothing to do
}
void DownloadInstance::DownloadManagerSetlistener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
// Nothing to do
}
namespace exif {
GCSPosition::GCSPosition() {
- LoggerD("Enter");
+ ScopeLogger();
}
GCSPosition::GCSPosition(Rational _degrees, Rational _minutes, Rational _seconds)
: degrees(_degrees), minutes(_minutes), seconds(_seconds) {
- LoggerD("Enter");
+ ScopeLogger();
}
bool GCSPosition::isValid() const {
- LoggerD("Enter");
+ ScopeLogger();
if (!(degrees.isValid() && minutes.isValid() && seconds.isValid())) {
return false;
}
}
double GCSPosition::toDouble() const {
- LoggerD("Enter");
+ ScopeLogger();
const double degrees_value = degrees.toDouble();
const double minutes_value = minutes.toDouble();
const double seconds_value = seconds.toDouble();
}
Rationals GCSPosition::toRationalsVector() const {
- LoggerD("Enter");
+ ScopeLogger();
Rationals vec;
vec.push_back(degrees);
vec.push_back(minutes);
}
std::string GCSPosition::toDebugString() const {
- LoggerD("Enter");
+ ScopeLogger();
std::stringstream ss;
ss << degrees.toString() << "d ";
ss << minutes.toString() << "m ";
}
GCSPosition GCSPosition::createFromDouble(double value) {
- LoggerD("Entered value:%f");
+ ScopeLogger("value: %f", value);
if (value < 0) {
LoggerW("Trying to create GCSPosition with double < 0: %f", value);
return GCSPosition();
ExifGPSLocation::ExifGPSLocation()
: m_longitude_ref(GPS_LOCATION_WEST), m_latitude_ref(GPS_LOCATION_NORTH) {
for (int i = 0; i < EXIF_GPS_LOCATION_ATTRIBUTE_NUMBER_OF_ATTRIBUTES; ++i) {
- LoggerD("Enter");
+ ScopeLogger();
m_is_set[i] = false;
}
LoggerE("ExifGPSLocation::ExifGPSLocation()");
}
ExifGPSLocation::ExifGPSLocation(double longitude, double latitude) {
- LoggerD("Enter");
+ ScopeLogger();
for (int i = 0; i < EXIF_GPS_LOCATION_ATTRIBUTE_NUMBER_OF_ATTRIBUTES; ++i) {
m_is_set[i] = false;
}
}
void ExifGPSLocation::setLongitude(const GCSPosition& longitude) {
- LoggerD("Enter");
+ ScopeLogger();
if (!longitude.isValid()) {
LoggerW("longitude is not valid!");
return;
}
const GCSPosition& ExifGPSLocation::getLongitude() const {
- LoggerD("Enter");
+ ScopeLogger();
return m_longitude;
}
void ExifGPSLocation::setLongitudeRef(GPSLocationDirectionLongitude ref) {
- LoggerD("Enter");
+ ScopeLogger();
m_is_set[EXIF_GPS_LOCATION_ATTRIBUTE_LONGITUDE_REF] = true;
m_longitude_ref = ref;
}
GPSLocationDirectionLongitude ExifGPSLocation::getLongitudeRef() const {
- LoggerD("Enter");
+ ScopeLogger();
return m_longitude_ref;
}
void ExifGPSLocation::setLatitude(const GCSPosition& latitude) {
- LoggerD("Enter");
+ ScopeLogger();
if (!latitude.isValid()) {
LoggerW("latitude is not valid!");
return;
}
const GCSPosition& ExifGPSLocation::getLatitude() const {
- LoggerD("Enter");
+ ScopeLogger();
return m_latitude;
}
void ExifGPSLocation::setLatitudeRef(GPSLocationDirectionLatitude ref) {
- LoggerD("Enter");
+ ScopeLogger();
m_is_set[EXIF_GPS_LOCATION_ATTRIBUTE_LATITUDE_REF] = true;
m_latitude_ref = ref;
}
GPSLocationDirectionLatitude ExifGPSLocation::getLatitudeRef() const {
- LoggerD("Enter");
+ ScopeLogger();
return m_latitude_ref;
}
bool ExifGPSLocation::isSet(ExifGPSLocationAttributes attribute) const {
- LoggerD("Enter");
+ ScopeLogger();
return m_is_set[attribute];
}
void ExifGPSLocation::unset(ExifGPSLocationAttributes attribute) {
- LoggerD("Enter");
+ ScopeLogger();
m_is_set[attribute] = false;
}
void ExifGPSLocation::unsetAll() {
- LoggerD("Enter");
+ ScopeLogger();
m_is_set[EXIF_GPS_LOCATION_ATTRIBUTE_LONGITUDE] = false;
m_is_set[EXIF_GPS_LOCATION_ATTRIBUTE_LONGITUDE_REF] = false;
m_longitude = GCSPosition();
}
bool ExifGPSLocation::isComplete() const {
- LoggerD("Enter");
+ ScopeLogger();
return m_is_set[EXIF_GPS_LOCATION_ATTRIBUTE_LONGITUDE] &&
m_is_set[EXIF_GPS_LOCATION_ATTRIBUTE_LONGITUDE_REF] &&
m_is_set[EXIF_GPS_LOCATION_ATTRIBUTE_LATITUDE] &&
}
bool ExifGPSLocation::isValid() const {
- LoggerD("Enter");
+ ScopeLogger();
return isComplete() && m_latitude.isValid() && m_longitude.isValid();
}
double ExifGPSLocation::getLongitudeValue() const {
- LoggerD("Enter");
+ ScopeLogger();
const double longitude_dir = (m_longitude_ref == GPS_LOCATION_WEST) ? -1.0f : 1.0f;
const double longitude = m_longitude.toDouble() * longitude_dir;
return longitude;
}
double ExifGPSLocation::getLatitudeValue() const {
- LoggerD("Enter");
+ ScopeLogger();
const double latitude_dir = (m_latitude_ref == GPS_LOCATION_SOUTH) ? -1.0f : 1.0f;
const double latitude = m_latitude.toDouble() * latitude_dir;
return latitude;
}
IsoSpeedRatingsVector jsonArray2vector(const picojson::value& a) {
- LoggerD("Enter");
+ ScopeLogger();
if (!a.is<picojson::array>()) {
return IsoSpeedRatingsVector();
}
} // namespace
ExifInformation::ExifInformation() {
- LoggerD("Enter");
+ ScopeLogger();
for (int attr = 0; attr < EXIF_INFORMATION_ATTRIBUTE_NUMBER_OF_ATTRIBUTES; attr++) {
unset(static_cast<ExifInformationAttribute>(attr));
}
}
ExifInformation::ExifInformation(const picojson::value& args) {
- LoggerD("Enter");
+ ScopeLogger();
for (int attr = 0; attr < EXIF_INFORMATION_ATTRIBUTE_NUMBER_OF_ATTRIBUTES; attr++) {
unset(static_cast<ExifInformationAttribute>(attr));
}
}
ExifInformation::~ExifInformation() {
- LoggerD("Enter");
+ ScopeLogger();
}
const std::string& ExifInformation::getUri() {
- LoggerD("Entered");
return m_uri;
}
void ExifInformation::setUri(const std::string& uri) {
- LoggerD("Entered");
- LoggerD("URI: %s", uri.c_str());
m_is_set[EXIF_INFORMATION_ATTRIBUTE_URI] = true;
m_uri = uri;
+ LoggerD("URI: %s", uri.c_str());
}
unsigned long ExifInformation::getWidth() const {
- LoggerD("Entered");
return m_width;
}
void ExifInformation::setWidth(unsigned long width) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_WIDTH] = true;
m_width = width;
}
unsigned long ExifInformation::getHeight() const {
- LoggerD("Entered");
return m_height;
}
void ExifInformation::setHeight(unsigned long height) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_HEIGHT] = true;
m_height = height;
}
const std::string& ExifInformation::getDeviceMaker() {
- LoggerD("Entered");
return m_device_maker;
}
void ExifInformation::setDeviceMaker(const std::string& device_maker) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_DEVICE_MAKER] = true;
m_device_maker = device_maker;
}
const std::string& ExifInformation::getDeviceModel() {
- LoggerD("Entered");
return m_device_model;
}
void ExifInformation::setDeviceModel(const std::string& device_model) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_DEVICE_MODEL] = true;
m_device_model = device_model;
}
time_t ExifInformation::getOriginalTime() const {
- LoggerD("Entered");
return m_original_time;
}
void ExifInformation::setOriginalTime(time_t original_time) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_ORIGINAL_TIME] = true;
m_original_time = original_time;
}
const std::string& ExifInformation::getOrientationString() {
- LoggerD("Entered");
return ExifUtil::orientationToString(m_orientation);
}
ImageOrientation ExifInformation::getOrientation() {
- LoggerD("Entered");
return m_orientation;
}
void ExifInformation::setOrientation(const std::string& orientation) {
- LoggerD("Entered");
+ ScopeLogger();
setOrientation(ExifUtil::stringToOrientation(orientation));
}
void ExifInformation::setOrientation(ImageOrientation orientation) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_ORIENTATION] = true;
m_orientation = orientation;
}
const Rational& ExifInformation::getFNumber() const {
- LoggerD("Entered");
return m_f_number;
}
void ExifInformation::setFNumber(Rational f_number) {
- LoggerD("Entered");
if (!f_number.isValid()) {
LoggerW("Trying to set invalid F-Number: %s", f_number.toString().c_str());
return;
}
const std::vector<long long int>& ExifInformation::getIsoSpeedRatings() {
- LoggerD("Entered");
return m_iso_speed_ratings;
}
void ExifInformation::setIsoSpeedRatings(const std::vector<long long int>& iso_speed_ratings) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_ISO_SPEED_RATINGS] = true;
m_iso_speed_ratings = iso_speed_ratings;
}
const Rational& ExifInformation::getExposureTime() {
- LoggerD("Entered");
return m_exposure_time;
}
void ExifInformation::setExposureTime(const Rational& exposure_time) {
- LoggerD("Entered");
if (!exposure_time.isValid() || 0 == exposure_time.nominator) {
LoggerW("Trying to set invalid exposure time: [%s]", exposure_time.toString().c_str());
return;
}
const std::string& ExifInformation::getExposureProgramString() {
- LoggerD("Entered");
+ ScopeLogger();
return ExifUtil::exposureProgramToString(m_exposure_program);
;
}
ExposureProgram ExifInformation::getExposureProgram() {
- LoggerD("Entered");
return m_exposure_program;
}
void ExifInformation::setExposureProgram(const std::string& exposure_program) {
- LoggerD("Entered");
+ ScopeLogger();
setExposureProgram(ExifUtil::stringToExposureProgram(exposure_program));
}
void ExifInformation::setExposureProgram(ExposureProgram exposure_program) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_EXPOSURE_PROGRAM] = true;
m_exposure_program = exposure_program;
}
bool ExifInformation::getFlash() const {
- LoggerD("Entered");
return m_flash;
}
void ExifInformation::setFlash(bool flash) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_FLASH] = true;
m_flash = flash;
}
const Rational& ExifInformation::getFocalLength() const {
- LoggerD("Entered");
return m_focal_length;
}
void ExifInformation::setFocalLength(Rational focal_length) {
- LoggerD("Entered");
if (!focal_length.isValid()) {
LoggerW("Trying to set invalid focal length: %s", focal_length.toString().c_str());
return;
}
const std::string& ExifInformation::getWhiteBalanceModeString() {
- LoggerD("Entered");
return ExifUtil::whiteBalanceToString(m_white_balance);
}
WhiteBalanceMode ExifInformation::getWhiteBalanceMode() {
- LoggerD("Entered");
return m_white_balance;
}
void ExifInformation::setWhiteBalanceMode(const std::string& white_balance) {
- LoggerD("Entered");
+ ScopeLogger();
setWhiteBalanceMode(ExifUtil::stringToWhiteBalance(white_balance));
}
void ExifInformation::setWhiteBalanceMode(WhiteBalanceMode white_balance) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_WHITE_BALANCE] = true;
m_white_balance = white_balance;
}
ExifGPSLocation& ExifInformation::getGPSExifLocation() {
- LoggerD("Entered");
return m_gps_location;
}
void ExifInformation::setGPSLocation(ExifGPSLocation gps_location) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_GPS_LOCATION] = true;
m_gps_location = gps_location;
}
void ExifInformation::unsetGPSLocation() {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_GPS_LOCATION] = false;
m_gps_location.unsetAll();
}
const Rational& ExifInformation::getGpsAltitude() const {
- LoggerD("Entered");
return m_gps_altitude;
}
void ExifInformation::setGpsAltitude(Rational gps_altitude) {
- LoggerD("Entered");
if (!gps_altitude.isValid()) {
LoggerW("Trying to set invalid gps altitude: %s", gps_altitude.toString().c_str());
return;
}
GpsAltitudeRef ExifInformation::getGpsAltitudeRef() const {
- LoggerD("Entered");
return m_gps_altitude_ref;
}
void ExifInformation::setGpsAltitudeRef(const GpsAltitudeRef ref) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_GPS_ALTITUDE_REF] = true;
m_gps_altitude_ref = ref;
}
void ExifInformation::setGpsAltitudeWithRef(double gps_altitude) {
- LoggerD("Entered");
+ ScopeLogger();
setGpsAltitude(Rational::createFromDouble(fabs(gps_altitude)));
if (gps_altitude >= 0.0) {
}
double ExifInformation::getGpsAltitudeWithRef() const {
- LoggerD("Entered");
-
if (!m_is_set[EXIF_INFORMATION_ATTRIBUTE_GPS_ALTITUDE_REF] ||
GPS_ALTITUDE_REF_ABOVE_SEA == m_gps_altitude_ref) {
return m_gps_altitude.toDouble();
}
const std::string& ExifInformation::getGpsProcessingMethod() const {
- LoggerD("Entered");
return m_gps_processing_method;
}
const std::string& ExifInformation::getGpsProcessingMethodType() const {
- LoggerD("Entered");
return m_gps_processing_method_type;
}
void ExifInformation::setGpsProcessingMethod(const std::string& type,
const std::string& processing_method) {
- LoggerD("Entered");
if (type != EXIF_UNDEFINED_TYPE_ASCII && type != EXIF_UNDEFINED_TYPE_JIS &&
type != EXIF_UNDEFINED_TYPE_UNICODE && type != EXIF_UNDEFINED_TYPE_UNDEFINED) {
LoggerW("Trying to set invalid GPSProcessingMethod type: [%s] len:%d", type.c_str(),
}
void ExifInformation::setGpsTime(time_t time) {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_GPS_TIME] = true;
m_gps_time = time;
}
time_t ExifInformation::getGpsTime() {
- LoggerD("Entered");
return m_gps_time;
}
void ExifInformation::unsetGPStime() {
- LoggerD("Entered");
m_is_set[EXIF_INFORMATION_ATTRIBUTE_GPS_TIME] = false;
m_gps_time = 0;
}
const std::string& ExifInformation::getUserComment() {
- LoggerD("Entered");
return m_user_comment;
}
const std::string& ExifInformation::getUserCommentType() {
- LoggerD("Entered");
return m_user_comment_type;
}
void ExifInformation::setUserComment(const std::string& type, const std::string& user_comment) {
- LoggerD("Entered");
if (type != EXIF_UNDEFINED_TYPE_ASCII && type != EXIF_UNDEFINED_TYPE_JIS &&
type != EXIF_UNDEFINED_TYPE_UNICODE && type != EXIF_UNDEFINED_TYPE_UNDEFINED) {
LoggerW("Trying to set invalid user comment type: [%s] len:%d", type.c_str(), type.length());
}
bool ExifInformation::isSet(ExifInformationAttribute attribute) const {
- LoggerD("Entered");
return m_is_set[attribute];
}
void ExifInformation::unset(ExifInformationAttribute attribute) {
- LoggerD("Entered");
if (attribute >= EXIF_INFORMATION_ATTRIBUTE_NUMBER_OF_ATTRIBUTES) {
return;
}
}
void ExifInformation::set(std::string attributeName, const picojson::value& v) {
- LoggerD("Entered | name: %s", attributeName.c_str());
+ ScopeLogger(attributeName);
switch (str2int(attributeName.c_str())) {
case str2int(EI_URI): {
}
void ExifInformation::removeNulledAttributesFromExifData(ExifData* exif_data) {
- LoggerD("Entered");
+ ScopeLogger();
AssertMsg(exif_data, "exif_data is NULL");
if (!isSet(EXIF_INFORMATION_ATTRIBUTE_WIDTH)) {
}
PlatformResult ExifInformation::updateAttributesInExifData(ExifData* exif_data) {
- LoggerD("Entered");
+ ScopeLogger();
common::PlatformResult ret(common::ErrorCode::NO_ERROR);
}
PlatformResult ExifInformation::saveToFile(const std::string& file_path) {
- LoggerD("Entered");
- LoggerD("Using JpegFile to read: [%s] and Exif if present", file_path.c_str());
+ ScopeLogger("Using JpegFile to read: [%s] and Exif if present", file_path.c_str());
JpegFilePtr jpg_file;
PlatformResult result = JpegFile::loadFile(file_path, &jpg_file);
using common::ErrorCode;
ExifInstance::ExifInstance() {
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
ExifInstance::~ExifInstance() {
+ ScopeLogger();
}
void ExifInstance::ExifManagerGetExifInfo(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
const std::string& uri = args.get("uri").get<std::string>();
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
JsonValue result = JsonValue(JsonObject());
PlatformResult status(ErrorCode::NO_ERROR);
};
auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
Instance::PostMessage(this, response->serialize().c_str());
auto data = std::shared_ptr<JsonValue>(new JsonValue(JsonObject()));
common::TaskQueue::GetInstance().Queue<JsonValue>(get, get_response, data);
-
- LoggerD("exit");
}
void ExifInstance::ExifManagerSaveExifInfo(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
JsonValue result = JsonValue(JsonObject());
PlatformResult status(ErrorCode::NO_ERROR);
};
auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
Instance::PostMessage(this, response->serialize().c_str());
}
void ExifInstance::ExifManagerGetThumbnail(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string& uri = args.get("uri").get<std::string>();
const double callback_id = args.get("callbackId").get<double>();
auto get = [=](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get");
PlatformResult status(ErrorCode::NO_ERROR);
const std::string& file_path = ExifUtil::convertUriToPath(uri);
};
auto get_response = [callback_id, this](const std::shared_ptr<JsonValue>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, get_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
Instance::PostMessage(this, response->serialize().c_str());
namespace exif {
void ExifTagSaver::removeExifEntryWithTag(const ExifTag tag, ExifData* exif_data) {
- LoggerD("Entered tag:%d (0x%x)", tag, tag);
+ ScopeLogger("tag:%d (0x%x)", tag, exif_data);
ExifEntry* exif_entry = exif_data_get_entry(exif_data, tag);
if (!exif_entry) {
LoggerE("Exif entry with tag:%d (0x%x) is not present", tag, tag);
}
common::PlatformResult ExifTagSaver::saveToExif(long int value, ExifTag tag, ExifData* exif_data) {
- LoggerD("Entered");
+ ScopeLogger();
ExifEntry* entry = prepareEntry(exif_data, tag);
if (!entry) {
common::PlatformResult ExifTagSaver::saveToExif(const std::string& value, ExifTag tag,
ExifData* exif_data, ExifFormat format,
bool add_zero_character) {
- LoggerD("Entered");
+ ScopeLogger();
ExifEntry* entry = prepareEntry(exif_data, tag);
if (!entry) {
return LogAndCreateResult(common::ErrorCode::UNKNOWN_ERR, "Exif entry is null");
common::PlatformResult ExifTagSaver::saveToExif(const Rational& value, ExifTag tag,
ExifData* exif_data) {
- LoggerD("Entered");
+ ScopeLogger();
ExifEntry* entry = prepareEntry(exif_data, tag);
if (!entry) {
return LogAndCreateResult(common::ErrorCode::UNKNOWN_ERR, "Exif entry is null");
common::PlatformResult ExifTagSaver::saveToExif(const Rationals& value, ExifTag tag,
ExifData* exif_data) {
- LoggerD("Entered");
+ ScopeLogger();
ExifEntry* entry = prepareEntry(exif_data, tag);
if (!entry) {
return LogAndCreateResult(common::ErrorCode::UNKNOWN_ERR, "Exif entry is null");
common::PlatformResult ExifTagSaver::saveToExif(std::vector<long long int>& value,
ExifFormat store_as, ExifTag tag,
ExifData* exif_data) {
- LoggerD("Entered");
+ ScopeLogger();
ExifEntry* entry = prepareEntry(exif_data, tag);
if (!entry) {
return LogAndCreateResult(common::ErrorCode::UNKNOWN_ERR, "Exif entry is null");
ExifData* exif_data) {
common::PlatformResult ret(common::ErrorCode::NO_ERROR);
- LoggerD("Entered");
+ ScopeLogger();
if (gps_info.isSet(EXIF_GPS_LOCATION_ATTRIBUTE_LATITUDE)) {
auto latitude = gps_info.getLatitude();
LoggerD("Saving latitude: %s", latitude.toDebugString().c_str());
}
ExifEntry* ExifTagSaver::prepareEntry(ExifData* exif_data, ExifTag tag) {
- LoggerD("Entered m_tag:%d", tag);
+ ScopeLogger("tag:%d (0x%x)", tag, exif_data);
ExifEntry* exif_entry = exif_data_get_entry(exif_data, tag);
if (!exif_entry) {
ExifEntry* ExifTagSaver::createNewTag(ExifData* exif_data, ExifIfd ifd, ExifFormat format,
ExifTag tag) {
- LoggerD("Creating new tag: %d", tag);
+ ScopeLogger("Creating new tag: %d", tag);
ExifEntry* new_entry = exif_entry_new();
if (new_entry == nullptr) {
}
common::PlatformResult ExifTagSaver::deduceIfdSection(ExifTag tag, ExifIfd* exif_ifd) {
- LoggerD("Entered");
+ ScopeLogger();
switch (static_cast<unsigned int>(tag)) {
// Tags in IFD_0 Section
}
common::PlatformResult ExifTagSaver::deduceDataFormat(ExifTag tag, ExifFormat* exif_format) {
- LoggerD("Entered");
+ ScopeLogger();
switch (static_cast<unsigned int>(tag)) {
// Tags with byte type:
const ExifByte ExifTypeInfo::SRationalId = 10;
ExifUtil::ExifUtil() {
+ ScopeLogger();
}
ExifUtil::~ExifUtil() {
+ ScopeLogger();
}
ImageOrientation ExifUtil::stringToOrientation(const std::string& orientation) {
- LoggerD("Entered");
+ ScopeLogger();
if (ORIENTATION_NORMAL == orientation) {
return ImageOrientation::EXIF_ORIENTATION_NORMAL;
}
}
const std::string& ExifUtil::orientationToString(ImageOrientation orientation) {
- LoggerD("Entered");
+ ScopeLogger();
switch (orientation) {
case ImageOrientation::EXIF_ORIENTATION_NORMAL:
return ORIENTATION_NORMAL;
}
WhiteBalanceMode ExifUtil::stringToWhiteBalance(const std::string& white_balance) {
- LoggerD("Entered");
+ ScopeLogger();
if (WHITE_BALANCE_MODE_AUTO == white_balance) {
return WhiteBalanceMode::EXIF_WHITE_BALANCE_MODE_AUTO;
}
}
const std::string& ExifUtil::whiteBalanceToString(WhiteBalanceMode value) {
- LoggerD("Entered");
+ ScopeLogger();
switch (value) {
case WhiteBalanceMode::EXIF_WHITE_BALANCE_MODE_AUTO:
return WHITE_BALANCE_MODE_AUTO;
}
ExposureProgram ExifUtil::stringToExposureProgram(const std::string& exposure_program) {
- LoggerD("Entered");
+ ScopeLogger();
if (EXPOSURE_PROGRAM_NOT_DEFINED == exposure_program) {
return EXIF_EXPOSURE_PROGRAM_NOT_DEFINED;
}
}
const std::string& ExifUtil::exposureProgramToString(ExposureProgram value) {
- LoggerD("Entered");
+ ScopeLogger();
switch (value) {
case ExposureProgram::EXIF_EXPOSURE_PROGRAM_NOT_DEFINED:
return EXPOSURE_PROGRAM_NOT_DEFINED;
// in: uri = file://TZ_USER_IMAGES/exif.jpg
// out: path = TZ_USER_IMAGES/exif.jpg
std::string ExifUtil::convertUriToPath(const std::string& str) {
+ ScopeLogger();
std::string path = ltrim(str);
std::string prefix = path.substr(0, URI_PREFIX.size());
}
std::string ExifUtil::ltrim(const std::string& s) {
+ ScopeLogger();
std::string str = s;
std::string::iterator i;
for (i = str.begin(); i != str.end(); ++i) {
}
time_t ExifUtil::exifDateTimeOriginalToTimeT(const char* string) {
+ ScopeLogger();
int year, month, day, hour, min, sec;
if (sscanf(string, "%5d:%5d:%5d %5d:%5d:%5d", &year, &month, &day, &hour, &min, &sec) >= 6) {
return convertToTimeT(year, month, day, hour, min, sec);
}
std::string ExifUtil::timeTToExifDateTimeOriginal(time_t time) {
+ ScopeLogger();
int year, month, day, hour, min, sec;
extractFromTimeT(time, year, month, day, hour, min, sec);
}
const Rationals ExifUtil::timeTToExifGpsTimeStamp(time_t time) {
+ ScopeLogger();
int year, month, day, hour, min, sec;
extractFromTimeT(time, year, month, day, hour, min, sec);
}
std::string ExifUtil::timeTToExifGpsDateStamp(time_t time) {
+ ScopeLogger();
int year, month, day, hour, min, sec;
extractFromTimeT(time, year, month, day, hour, min, sec);
}
size_t ExifUtil::getSizeOfExifFormatType(ExifFormat format) {
+ ScopeLogger();
std::size_t size_per_member = 0;
switch (format) {
case EXIF_FORMAT_BYTE:
}
void ExifUtil::printExifEntryInfo(ExifEntry* entry, ExifData* exif_data) {
+ ScopeLogger();
char buf[2000];
std::stringstream ss;
void ExifUtil::extractFromTimeT(const time_t time, int& out_year, int& out_month, int& out_day,
int& out_hour, int& out_min, int& out_sec) {
+ ScopeLogger();
struct tm utc;
gmtime_r(&time, &utc);
}
time_t ExifUtil::convertToTimeT(int year, int month, int day, int hour, int min, int sec) {
+ ScopeLogger();
struct tm timeinfo = {0};
time_t tmp_time = 0;
tzset();
};
Rational GetRationalFromEntry(ExifEntry* entry, ExifData* exif_data) {
- LoggerD("Entered");
+ ScopeLogger();
if (EXIF_FORMAT_RATIONAL == entry->format && entry->components >= 1 && entry->data) {
const ExifByteOrder order = exif_data_get_byte_order(exif_data);
return Rational(exif_get_rational(entry->data, order));
bool GetRationalsFromEntry(ExifEntry* entry, ExifData* exif_data, unsigned long required_count,
Rationals& out_rationals) {
- LoggerD("Entered");
+ ScopeLogger();
if (EXIF_FORMAT_RATIONAL == entry->format && entry->components >= required_count && entry->data) {
const ExifByteOrder order = exif_data_get_byte_order(exif_data);
unsigned char* ptr = entry->data;
bool GetGCSPositionFromEntry(ExifEntry* entry, ExifData* exif_data, GCSPosition& out_pos) {
// RATIONAL - 3
- LoggerD("Entered");
+ ScopeLogger();
if (EXIF_FORMAT_RATIONAL == entry->format && entry->components >= 3 && entry->data) {
const ExifByteOrder order = exif_data_get_byte_order(exif_data);
out_pos.degrees = Rational(exif_get_rational(entry->data, order));
}
bool DecomposeExifUndefined(ExifEntry* entry, std::string& type, std::string& value) {
- LoggerD("Entered");
+ ScopeLogger();
if (!entry || !entry->data) {
LoggerW("exif entry is NULL/empty");
return false;
PlatformResult GetExifInfo::ProcessEntry(ExifEntry* entry, ExifData* exif_data,
JsonObject* result_obj) {
- LoggerD("Entered");
+ ScopeLogger();
char buf[2000];
exif_entry_get_value(entry, buf, sizeof(buf));
ExifUtil::printExifEntryInfo(entry, exif_data);
}
void GetExifInfo::ContentForeachFunctionProxy(ExifEntry* entry, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
ExifDataHolder* holder = static_cast<ExifDataHolder*>(user_data);
if (!holder) {
LoggerE("holder is NULL");
}
void GetExifInfo::DataForeachFunction(ExifContent* content, void* user_data) {
+ ScopeLogger();
exif_content_foreach_entry(content, ContentForeachFunctionProxy, user_data);
}
PlatformResult GetExifInfo::LoadFromURI(const std::string& uri, JsonValue* result) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string& file_path = ExifUtil::convertUriToPath(uri);
ExifData* ed = exif_data_new_from_file(file_path.c_str());
if (!ed) {
m_padding_data_size(0),
m_in_file(NULL),
m_out_file(NULL) {
+ ScopeLogger();
}
JpegFile::~JpegFile() {
+ ScopeLogger();
delete[] m_in_data;
m_in_data = NULL;
m_in_data_size = 0;
}
PlatformResult JpegFile::loadFile(const std::string& path, JpegFilePtr* jpg_ptr) {
- LoggerD("Entered");
+ ScopeLogger();
JpegFile* new_jpg = new (std::nothrow) JpegFile();
if (!new_jpg) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Memory allocation failed",
}
PlatformResult JpegFile::load(const std::string& path) {
- LoggerD("Entered file: %s", path.c_str());
+ ScopeLogger("file: %s", path.c_str());
m_source_file_path = path;
std::string JpegFile::getPartOfFile(const std::size_t offset, const std::size_t num_bytes_before,
const std::size_t num_bytes_after) {
- LoggerD("Entered");
+ ScopeLogger();
auto start = offset - num_bytes_before;
if (offset < num_bytes_before) {
start = 0;
}
common::PlatformResult JpegFile::generateListOfSections() {
- LoggerD("Entered");
+ ScopeLogger();
// JPEG starts with:
// FFD8 (2 bytes) - SOI Marker
bool JpegFile::searchForTagInBuffer(const unsigned char* buffer_start,
const unsigned char* buffer_end, const JpegMarker marker,
std::size_t& out_index) {
- LoggerD("Entered start:%p end:%p marker:0x%x", buffer_start, buffer_end, marker);
+ ScopeLogger("start:%p end:%p marker:0x%x", buffer_start, buffer_end, marker);
if (!buffer_start) {
LoggerE("buffer_start is NULL");
}
PlatformResult JpegFile::setNewExifData(ExifData* new_exif_data) {
- LoggerD("Entered");
+ ScopeLogger();
AssertMsg(new_exif_data, "Trying to set NULL exif_data!");
JpegFileSectionPtr exif = getExifSection();
}
ExifData* JpegFile::getExifData() {
- LoggerD("Entered");
+ ScopeLogger();
JpegFileSectionPtr exif = getExifSection();
if (!exif) {
return NULL;
}
PlatformResult JpegFile::saveToFile(const std::string& out_path) {
- LoggerD("Entered out_path:%s", out_path.c_str());
+ ScopeLogger("out_path:%s", out_path.c_str());
PlatformResult status = saveToFilePriv(out_path);
if (status) return status;
}
PlatformResult JpegFile::saveToFilePriv(const std::string& out_path) {
- LoggerD("Entered out_path:%s", out_path.c_str());
+ ScopeLogger("out_path:%s", out_path.c_str());
m_out_file = fopen(out_path.c_str(), "wb");
if (!m_out_file) {
}
JpegFileSectionPtr JpegFile::getExifSection() {
- LoggerD("Entered");
+ ScopeLogger();
std::size_t num_exif_sections = 0;
JpegFileSectionPtr first_exif_section;
} // namespace
Rational::Rational() : nominator(0), denominator(0) {
+ ScopeLogger();
}
Rational::Rational(ExifLong nom, ExifLong denom) : nominator(nom), denominator(denom) {
+ ScopeLogger();
}
Rational::Rational(const ExifRational& exif_rational)
: nominator(exif_rational.numerator), denominator(exif_rational.denominator) {
+ ScopeLogger();
}
Rational Rational::createFromDouble(const double value, const long precision) {
- LoggerD("Entered value:%f precision:%d", value, precision);
+ ScopeLogger("value:%f precision:%d", value, precision);
if (value < 0.0) {
LoggerW("Trying to create negative Rational: %f!", value);
return Rational();
}
Rational Rational::createFromExposureTimeString(const std::string& exp_time) {
- LoggerD("Entered");
+ ScopeLogger();
if (exp_time.length() == 0) {
return Rational::createInvalid(); // lets assume that empty string means 0,
// however exposure time = 0 is
}
std::string Rational::toExposureTimeString() const {
- LoggerD("Entered");
+ ScopeLogger();
if (!isValid() || 0 == nominator) {
return std::string();
}
FeedbackInstance::FeedbackInstance()
: m_feedbackMapsPtr(new FeedbackMaps),
m_feedbackManagerPtr(new FeedbackManager(this->m_feedbackMapsPtr)) {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&FeedbackInstance::x, this, _1, _2));
}
FeedbackInstance::~FeedbackInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
void FeedbackInstance::IsPatternSupported(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
const auto pattern = args.get("pattern").get<std::string>();
const auto type = args.get("type").get<std::string>();
}
void FeedbackInstance::Play(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeHaptic, &out);
}
void FeedbackInstance::Stop(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeHaptic, &out);
{"BT_DISCONNECTED", FEEDBACK_PATTERN_BT_DISCONNECTED},
{"LIST_REORDER", FEEDBACK_PATTERN_LIST_REORDER},
{"LIST_SLIDER", FEEDBACK_PATTERN_LIST_SLIDER},
- {"VOLUME_KEY", FEEDBACK_PATTERN_VOLUME_KEY}} {};
+ {"VOLUME_KEY", FEEDBACK_PATTERN_VOLUME_KEY}} {
+ ScopeLogger();
+};
FeedbackMaps::~FeedbackMaps() {
+ ScopeLogger();
}
feedback_pattern_e const &FeedbackMaps::getPatternFromMap(const std::string &pattern) {
}
FeedbackManager::FeedbackManager(std::shared_ptr<FeedbackMaps> maps) : m_feedbackMapsPtr(maps) {
- LoggerD("Entered");
+ ScopeLogger();
// feedback API initialization
int ret = feedback_initialize();
if (ret != FEEDBACK_ERROR_NONE) {
}
FeedbackManager::~FeedbackManager() {
- LoggerD("Entered");
+ ScopeLogger();
// feedback library deinitialization
int ret = feedback_deinitialize();
common::PlatformResult FeedbackManager::isPatternSupported(const std::string &pattern,
const std::string &type,
bool *patternStatus) {
- LoggerD("Entered");
+ ScopeLogger();
auto &pattern_e = m_feedbackMapsPtr->getPatternFromMap(pattern);
auto &type_e = m_feedbackMapsPtr->getTypeFromMap(type);
}
common::PlatformResult FeedbackManager::play(const std::string &pattern, const std::string &type) {
- LoggerD("Entered");
+ ScopeLogger();
int ret = 0;
if (type == "any") {
ret = feedback_play(m_feedbackMapsPtr->getPatternFromMap(pattern));
}
common::PlatformResult FeedbackManager::stop() {
- LoggerD("Entered");
+ ScopeLogger();
int ret = feedback_stop();
if (ret != FEEDBACK_ERROR_NONE && ret != FEEDBACK_ERROR_NOT_SUPPORTED) {
}
PlatformResult FeedbackManager::CodeToResult(const int errorCode, const std::string &message) {
- LoggerD("Entered");
+ ScopeLogger();
switch (errorCode) {
case FEEDBACK_ERROR_NOT_SUPPORTED:
}
const std::string FeedbackManager::getFeedbackErrorMessage(const int error_code) {
- LoggerD("Error code : %d", error_code);
+ ScopeLogger("Error code : %d", error_code);
switch (error_code) {
case FEEDBACK_ERROR_OPERATION_FAILED:
*/
bool FilesystemBuffer::DecodeData(const std::string& data) {
- LoggerD("Enter");
+ ScopeLogger();
if (data.length() % 4) {
LoggerE("Buffer has invalid length");
return false;
}
std::string FilesystemBuffer::EncodeData() const {
- LoggerD("Enter");
+ ScopeLogger();
std::string out;
for (size_t i = 0; i < size(); i += 3) {
}
FilesystemFile::FilesystemFile(const std::string& path_) : path(path_) {
+ ScopeLogger();
}
bool FilesystemFile::Read(FilesystemBuffer* data, size_t offset, size_t length) {
- LoggerD("Enter");
+ ScopeLogger();
if (!data) {
LoggerE("Missing output buffer");
return false;
}
bool FilesystemFile::Write(const FilesystemBuffer& data, size_t offset, bool rewrite) {
- LoggerD("Enter");
+ ScopeLogger();
FILE* file = nullptr;
if (rewrite) {
using namespace extension::filesystem;
FilesystemInstance::FilesystemInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
FilesystemInstance::~FilesystemInstance() {
- LoggerD("enter");
+ ScopeLogger();
FilesystemManager::GetInstance().StopListening();
FilesystemManager::GetInstance().RemoveListener();
}
}
void FilesystemInstance::FileCreateSync(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
CHECK_EXIST(args, "location", out)
const std::string& location = args.get("location").get<std::string>();
auto onSuccess = [&](const FilesystemStat& data) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
ReportSuccess(data.toJSON(), out);
};
auto onError = [&](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
PrepareError(e, out);
};
}
void FilesystemInstance::FileRename(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "oldPath", out)
const std::string& newPath = args.get("newPath").get<std::string>();
auto onSuccess = [this, callback_id](const FilesystemStat& data) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
};
auto onError = [this, callback_id](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
}
void FilesystemInstance::FileRead(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "location", out)
CHECK_EXIST(args, "offset", out)
size_t length = static_cast<size_t>(args.get("length").get<double>());
auto onSuccess = [this, callback_id](const std::string& data) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
};
auto onError = [this, callback_id](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
}
void FilesystemInstance::FileReadSync(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemRead, &out);
CHECK_EXIST(args, "location", out)
CHECK_EXIST(args, "offset", out)
size_t length = static_cast<size_t>(args.get("length").get<double>());
auto onSuccess = [this, &out](const std::string& data) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
ReportSuccess(picojson::value(data), out);
};
auto onError = [this, &out](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
PrepareError(e, out);
};
}
void FilesystemInstance::FileWrite(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "location", out)
CHECK_EXIST(args, "data", out)
bool rewrite = static_cast<size_t>(args.get("rewrite").get<bool>());
auto onSuccess = [this, callback_id]() {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
};
auto onError = [this, callback_id](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
}
void FilesystemInstance::FileWriteSync(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
CHECK_EXIST(args, "location", out)
CHECK_EXIST(args, "data", out)
bool rewrite = static_cast<size_t>(args.get("rewrite").get<bool>());
auto onSuccess = [this, &out]() {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
ReportSuccess(out);
};
auto onError = [this, &out](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
PrepareError(e, out);
};
}
void FilesystemInstance::FileStat(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemRead, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "location", out)
const std::string& location = args.get("location").get<std::string>();
auto onSuccess = [this, callback_id](const FilesystemStat& data) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
};
auto onError = [this, callback_id](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
}
void FilesystemInstance::FileStatSync(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemRead, &out);
CHECK_EXIST(args, "location", out)
const std::string& location = args.get("location").get<std::string>();
auto onSuccess = [&](const FilesystemStat& data) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
ReportSuccess(data.toJSON(), out);
};
auto onError = [&](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
PrepareError(e, out);
};
void FilesystemInstance::FilesystemFetchVirtualRoots(const picojson::value& args,
picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
auto onSuccess = [&](const std::vector<common::VirtualRoot>& result) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::array roots;
for (const auto& root : result) {
roots.push_back(root.ToJson());
};
auto onError = [&](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
PrepareError(e, out);
};
void FilesystemInstance::FileSystemManagerFetchStorages(const picojson::value& args,
picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
auto onSuccess = [&](const common::Storages& result) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::array storages;
storages.reserve(result.size());
for (const auto storage : result) {
};
auto onError = [&](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
PrepareError(e, out);
};
FilesystemManager::GetInstance().FetchStorages(onSuccess, onError);
}
void FilesystemInstance::StartListening(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
FilesystemManager::GetInstance().StartListening();
ReportSuccess(out);
}
void FilesystemInstance::StopListening(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
FilesystemManager::GetInstance().StopListening();
ReportSuccess(out);
}
void FilesystemInstance::onFilesystemStateChangeSuccessCallback(const common::Storage& storage) {
- LoggerD("entered");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
}
void FilesystemInstance::onFilesystemStateChangeErrorCallback() {
- LoggerD("enter");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
LogAndReportError(UnknownException(std::string("Failed to registerd listener")), obj);
void FilesystemInstance::FileSystemManagerMakeDirectory(const picojson::value& args,
picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "location", out)
const std::string& location = args.get("location").get<std::string>();
auto onResult = [this, callback_id](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onResult");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
};
auto onAction = [location, onResult]() {
+ ScopeLogger("Entered into asynchronous function, onAction");
FilesystemManager::GetInstance().MakeDirectory(location, onResult);
};
void FilesystemInstance::FileSystemManagerMakeDirectorySync(const picojson::value& args,
picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
CHECK_EXIST(args, "location", out)
const std::string& location = args.get("location").get<std::string>();
auto onResult = [&](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onResult");
if (e == FilesystemError::DirectoryExists)
ReportSuccess(out);
else
}
void FilesystemInstance::ReadDir(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemRead, &out);
CHECK_EXIST(args, "pathToDir", out)
CHECK_EXIST(args, "callbackId", out)
const std::string& pathToDir = args.get("pathToDir").get<std::string>();
auto onSuccess = [this, callback_id](const std::vector<std::string>& paths) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::value result = picojson::value(picojson::array());
;
picojson::array& statPaths = result.get<picojson::array>();
};
auto onError = [this, callback_id](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
}
void FilesystemInstance::UnlinkFile(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
CHECK_EXIST(args, "pathToFile", out)
const std::string& pathToFile = args.get("pathToFile").get<std::string>();
auto onSuccess = [this, callback_id]() {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::value result = picojson::value();
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
};
auto onError = [this, callback_id](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
}
void FilesystemInstance::RemoveDirectory(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
CHECK_EXIST(args, "pathToDelete", out)
const std::string& pathToDelete = args.get("pathToDelete").get<std::string>();
auto onSuccess = [this, callback_id]() {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::value result = picojson::value();
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
};
auto onError = [this, callback_id](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
}
void FilesystemInstance::CopyTo(const picojson::value& args, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeFilesystemWrite, &out);
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "originFilePath", out)
const bool& overwrite = args.get("overwrite").get<bool>();
auto onSuccess = [this, callback_id]() {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
picojson::value result = picojson::value();
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
};
auto onError = [this, callback_id](FilesystemError e) {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, onError");
picojson::value response = picojson::value(picojson::object());
picojson::object& obj = response.get<picojson::object>();
obj["callbackId"] = picojson::value(callback_id);
}
void FilesystemInstance::PrepareError(const FilesystemError& error, picojson::object& out) {
- LoggerD("enter");
+ ScopeLogger();
switch (error) {
case FilesystemError::None:
LogAndReportError(UnknownException("PLATFORM ERROR"), out);
void FilesystemInstance::FileSystemManagerGetCanonicalPath(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
// TODO: any privilege needed?
CHECK_EXIST(args, "path", out);
const std::string& path = args.get("path").get<std::string>();
auto onSuccess = [&](const std::string& canonicalPath) {
- LoggerD("Enter");
+ ScopeLogger("Entered into asynchronous function, onSuccess");
ReportSuccess(picojson::value(canonicalPath), out);
};
auto onError = [&](FilesystemError e) {
- LoggerD("Enter");
+ ScopeLogger("Entered into asynchronous function, onError");
PrepareError(e, out);
};
}
FilesystemError copyFile(const std::string& originPath, const std::string& destPath) {
- LoggerD("enter src %s dst %s", originPath.c_str(), destPath.c_str());
+ ScopeLogger("src %s dst %s", originPath.c_str(), destPath.c_str());
std::ifstream src(originPath, std::ios::in | std::ios::binary);
std::ofstream dst(destPath, std::ios::out | std::ios::binary);
}
FilesystemError copyDirectory(const std::string& originPath, const std::string& destPath) {
- LoggerD("enter src %s dst %s", originPath.c_str(), destPath.c_str());
+ ScopeLogger("src %s dst %s", originPath.c_str(), destPath.c_str());
FilesystemStat destStat = FilesystemStat::getStat(destPath);
int status;
FilesystemError perform_deep_copy(const std::string& originPath, const std::string& destPath,
bool overwrite) {
- LoggerD("enter src %s dst %s", originPath.c_str(), destPath.c_str());
+ ScopeLogger("rc %s dst %s", originPath.c_str(), destPath.c_str());
FilesystemStat originStat = FilesystemStat::getStat(originPath);
FilesystemStat destStat = FilesystemStat::getStat(destPath);
int status;
}
FilesystemError make_directory_worker(const std::string& path) {
- LoggerD("enter: %s", path.c_str());
+ ScopeLogger("path %s", path.c_str());
auto fsstat = FilesystemStat::getStat(path);
if (fsstat.valid) {
if (fsstat.isDirectory) {
void FilesystemManager::FetchStorages(
const std::function<void(const common::Storages&)>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("Entered");
+ ScopeLogger();
success_cb(fs_provider_.GetStorages());
}
FilesystemManager::FilesystemManager()
: listener_(nullptr), fs_provider_(common::FilesystemProvider::Create()) {
- LoggerD("enter");
+ ScopeLogger();
}
FilesystemManager::~FilesystemManager() {
- LoggerD("enter");
+ ScopeLogger();
}
FilesystemManager& FilesystemManager::GetInstance() {
- LoggerD("enter");
+ ScopeLogger();
static FilesystemManager instance;
return instance;
}
void FilesystemManager::StatPath(const std::string& path,
const std::function<void(const FilesystemStat&)>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("enter");
+ ScopeLogger();
FilesystemStat statData = FilesystemStat::getStat(path);
if (!statData.valid) {
error_cb(statData.error);
void FilesystemManager::GetVirtualRoots(
const std::function<void(const common::VirtualRoots&)>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("enter");
+ ScopeLogger();
success_cb(fs_provider_.GetVirtualPaths());
}
void FilesystemManager::CreateFile(const std::string& path,
const std::function<void(const FilesystemStat&)>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("enter");
+ ScopeLogger();
const mode_t create_mode = S_IRWXU | S_IRWXG | S_IRWXO;
int status;
status = TEMP_FAILURE_RETRY(open(path.c_str(), O_RDWR | O_CREAT, create_mode));
void FilesystemManager::MakeDirectory(const std::string& path,
const std::function<void(FilesystemError)>& result_cb) {
- LoggerD("enter");
+ ScopeLogger();
result_cb(make_directory_worker(path));
}
void FilesystemManager::Rename(const std::string& oldPath, const std::string& newPath,
const std::function<void(const FilesystemStat&)>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("enter");
+ ScopeLogger();
int status = rename(oldPath.c_str(), newPath.c_str());
if (0 != status) {
void FilesystemManager::ReadDir(
const std::string& path, const std::function<void(const std::vector<std::string>&)>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("entered");
+ ScopeLogger();
std::vector<std::string> fileList;
DIR* dp = nullptr;
void FilesystemManager::UnlinkFile(const std::string& path, const std::function<void()>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("enter");
+ ScopeLogger();
if (unlink(path.c_str()) != 0) {
LoggerE("Error occured while deleting file");
error_cb(FilesystemError::Other);
void FilesystemManager::RemoveDirectory(const std::string& path,
const std::function<void()>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("enter");
+ ScopeLogger();
const int maxDirOpened = 64;
if (nftw(path.c_str(), unlink_with_base_dir_cb, maxDirOpened, FTW_DEPTH | FTW_PHYS) != 0) {
LoggerE("Error occured");
void FilesystemManager::FileRead(const std::string& path, size_t offset, size_t length,
const std::function<void(const std::string&)>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("enter");
+ ScopeLogger();
FilesystemFile file(path);
FilesystemBuffer buffer;
if (!file.Read(&buffer, offset, length)) {
void FilesystemManager::FileWrite(const std::string& path, const std::string& data, size_t offset,
bool rewrite, const std::function<void()>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("enter");
+ ScopeLogger();
FilesystemFile file(path);
FilesystemBuffer buffer;
// Decode buffer data
}
void FilesystemManager::StartListening() {
- LoggerD("Entered");
+ ScopeLogger();
auto set = std::bind(&FilesystemManager::OnStorageDeviceChanged, this, std::placeholders::_1,
std::placeholders::_2, std::placeholders::_3);
}
void FilesystemManager::StopListening() {
- LoggerD("Entered");
+ ScopeLogger();
fs_provider_.UnregisterDeviceChangeState();
}
void FilesystemManager::OnStorageDeviceChanged(common::Storage const& _storage,
common::StorageState _old,
common::StorageState _new) {
- LoggerD("Entered");
+ ScopeLogger();
if (listener_) {
listener_->onFilesystemStateChangeSuccessCallback(_storage);
}
const std::string& destinationFilePath, const bool overwrite,
const std::function<void()>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("enter");
+ ScopeLogger();
FilesystemError retval = perform_deep_copy(originFilePath, destinationFilePath, overwrite);
if (FilesystemError::None == retval) {
success_cb();
}
void FilesystemManager::AddListener(FilesystemStateChangeListener* listener) {
- LoggerD("enter");
+ ScopeLogger();
listener_ = listener;
}
void FilesystemManager::RemoveListener() {
- LoggerD("enter");
+ ScopeLogger();
listener_ = NULL;
}
void FilesystemManager::GetCanonicalPath(const std::string& path,
const std::function<void(const std::string&)>& success_cb,
const std::function<void(FilesystemError)>& error_cb) {
- LoggerD("Enter");
+ ScopeLogger();
char* canonicalPath = nullptr;
SCOPE_EXIT {
mtime(0),
size(0),
nlink(0) {
+ ScopeLogger();
}
picojson::value FilesystemStat::toJSON() const {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value retval = picojson::value(picojson::object());
picojson::object& obj = retval.get<picojson::object>();
}
FilesystemStat FilesystemStat::getStat(const std::string& path) {
- LoggerD("Enter");
+ ScopeLogger();
struct stat aStatObj;
FilesystemStat _result;
- LoggerD("enter");
-
if (0 != stat(path.c_str(), &aStatObj)) {
if (ENOENT == errno) {
LoggerI("File/directory: %s not found", path.c_str());
namespace FilesystemUtils {
std::string get_storage_dir_path(int id, storage_directory_e typeToCheck) {
- LoggerD("Enter");
+ ScopeLogger();
char* platformPath = NULL;
int result = storage_get_directory(id, typeToCheck, &platformPath);
if (STORAGE_ERROR_NONE != result) {
}
std::string get_dirname(const std::string& path) {
+ ScopeLogger();
char* dir = g_path_get_dirname(path.c_str());
if (dir) {
std::string dir_result(dir);
}
std::string get_basename(const std::string& path) {
+ ScopeLogger();
// basename will modify content: pass a copy
std::string buf = path.c_str();
return std::string(basename(const_cast<char*>(buf.c_str())));
using common::TaskQueue;
HumanActivityMonitorInstance::HumanActivityMonitorInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
HumanActivityMonitorInstance::~HumanActivityMonitorInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
PlatformResult HumanActivityMonitorInstance::Init() {
- LoggerD("Enter");
+ ScopeLogger();
if (!manager_) {
manager_ = std::make_shared<HumanActivityMonitorManager>();
const PlatformResult& result = manager_->Init();
void HumanActivityMonitorInstance::HumanActivityMonitorManagerGetHumanActivityData(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "type", out)
CHECK_PRIVILEGE_ACCESS(kPrivilegeHealthInfo, &out);
const auto callback_id = args.get("callbackId").get<double>();
auto get = [this, type, callback_id]() -> void {
+ ScopeLogger("Entered into asynchronous function, get");
picojson::value response = picojson::value(picojson::object());
picojson::object& response_obj = response.get<picojson::object>();
response_obj["callbackId"] = picojson::value(callback_id);
void HumanActivityMonitorInstance::HumanActivityMonitorManagerStart(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "type", out)
CHECK_PRIVILEGE_ACCESS(kPrivilegeHealthInfo, &out);
const auto listener_id = args.get("listenerId").get<std::string>();
JsonCallback cb = [this, listener_id](picojson::value* data) -> void {
+ ScopeLogger("Entered into asynchronous function, cb");
if (!data) {
LOGGER(ERROR) << "No data passed to json callback";
return;
void HumanActivityMonitorInstance::HumanActivityMonitorManagerStop(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "type", out)
CHECK_PRIVILEGE_ACCESS(kPrivilegeHealthInfo, &out);
void HumanActivityMonitorInstance::HumanActivityMonitorManagerAddActivityRecognitionListener(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeHealthInfo, &out);
CHECK_EXIST(args, "type", out)
const auto& listener_id = args.get("listenerId").get<std::string>();
JsonCallback cb = [this, listener_id](picojson::value* data) -> void {
+ ScopeLogger("Entered into asynchronous function, cb");
if (!data) {
LOGGER(ERROR) << "No data passed to json callback";
return;
void HumanActivityMonitorInstance::HumanActivityMonitorManagerRemoveActivityRecognitionListener(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeHealthInfo, &out);
CHECK_EXIST(args, "watchId", out)
void HumanActivityMonitorInstance::HumanActivityMonitorManagerStartRecorder(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeHealthInfo, &out);
CHECK_EXIST(args, "type", out)
void HumanActivityMonitorInstance::HumanActivityMonitorManagerStopRecorder(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "type", out)
const auto& type = args.get("type").get<std::string>();
void HumanActivityMonitorInstance::HumanActivityMonitorManagerReadRecorderData(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeHealthInfo, &out);
CHECK_EXIST(args, "type", out)
CHECK_EXIST(args, "query", out)
const auto callback_id = args.get("callbackId").get<double>();
auto get = [this, type, query, callback_id]() -> void {
+ ScopeLogger("Entered into asynchronous function, get");
picojson::value response = picojson::value(picojson::object());
picojson::object& response_obj = response.get<picojson::object>();
response_obj["callbackId"] = picojson::value(callback_id);
};
static int64_t getCurrentTimeStamp(unsigned long long evTime) {
- LoggerD("Enter");
+ ScopeLogger();
struct timespec t;
unsigned long long systemCurrentTime = 0;
unsigned long long realCurrentTime = 0;
}
JsonCallback& event_callback() {
- ScopeLogger(type());
return event_callback_;
}
ScopeLogger();
auto convert_pedometer = [](sensor_event_s* event, picojson::object* data) -> PlatformResult {
- ScopeLogger("convert_pedometer");
+ ScopeLogger("Entered into asynchronous function, convert_pedometer");
const auto pedometer_data = (PedometerDataWrapper*)event;
};
auto convert_hrm = [](sensor_event_s* event, picojson::object* data) -> PlatformResult {
- ScopeLogger("convert_hrm");
+ ScopeLogger("Entered into asynchronous function, convert_hrm");
LOGGER(DEBUG) << "Sensor event:";
LOGGER(DEBUG) << " |- accuracy: " << event->accuracy;
};
auto convert_sleep = [](sensor_event_s* event, picojson::object* data) -> PlatformResult {
- ScopeLogger("convert_sleep");
+ ScopeLogger("Entered into asynchronous function, convert_sleep");
if (event->value_count < 1) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "To few values of SLEEP event");
};
auto convert_recorded_pedometer = [](void* data, picojson::object* obj) -> PlatformResult {
- ScopeLogger("convert_recorded_pedometer");
+ ScopeLogger("Entered into asynchronous function, convert_recorded_pedometer");
SensorRecorderDataMap map_int{{SENSOR_RECORDER_DATA_STEPS, kRecordedTotalStepCount},
{SENSOR_RECORDER_DATA_WALK_STEPS, kRecordedWalkStepCount},
};
auto convert_recorded_hrm = [](void* data, picojson::object* obj) -> PlatformResult {
- ScopeLogger("convert_recorded_hrm");
+ ScopeLogger("Entered into asynchronous function, convert_recorded_hrm");
SensorRecorderDataMap map_int{
{SENSOR_RECORDER_DATA_HEART_RATE, kRecordedHeartRate},
};
auto convert_recorded_sleep_monitor = [](void* data, picojson::object* obj) -> PlatformResult {
- ScopeLogger("convert_recorded_sleep_monitor");
+ ScopeLogger("Entered into asynchronous function, convert_recorded_sleep_monitor");
SensorRecorderDataMap map_int{{SENSOR_RECORDER_DATA_SLEEP_STATE, kStatus}};
};
auto convert_recorded_pressure = [](void* data, picojson::object* obj) -> PlatformResult {
- ScopeLogger("convert_recorded_pressure");
+ ScopeLogger("Entered into asynchronous function, convert_recorded_pressure");
SensorRecorderDataMap map_double{{SENSOR_RECORDER_DATA_MAX_PRESSURE, kRecordedMax},
{SENSOR_RECORDER_DATA_MIN_PRESSURE, kRecordedMin},
namespace inputdevice {
InputDeviceInstance::InputDeviceInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
InputDeviceInstance::~InputDeviceInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
} // namespace inputdevice
bool IfExists(CallbackData* data);
private:
- CallbackDataManager() {};
- CallbackDataManager(const CallbackDataManager &) = delete;
- CallbackDataManager(const CallbackDataManager &&) = delete;
- CallbackDataManager& operator=(const CallbackDataManager &) = delete;
- CallbackDataManager& operator=(const CallbackDataManager &&) = delete;
- ~CallbackDataManager() {};
+ CallbackDataManager(){};
+ CallbackDataManager(const CallbackDataManager&) = delete;
+ CallbackDataManager(const CallbackDataManager&&) = delete;
+ CallbackDataManager& operator=(const CallbackDataManager&) = delete;
+ CallbackDataManager& operator=(const CallbackDataManager&&) = delete;
+ ~CallbackDataManager(){};
std::vector<CallbackData*> callback_;
std::mutex callback_mtx_;
};
if (!resource->request_listener) {
resource->request_listener = [this, id](const common::TizenResult&, const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, resource->request_listener");
picojson::value request{picojson::object{}};
auto& obj = request.get<picojson::object>();
IotconUtils::ToObservePolicy(args.find(kObservePolicy)->second.get<std::string>().c_str());
ptr->observe_listener = [this, ptr](const common::TizenResult& res, const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, ptr->observe_listener");
picojson::value response{picojson::object{}};
auto& obj = response.get<picojson::object>();
ptr->cache_change_listener = [this, ptr](const common::TizenResult& res,
const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, ptr->cache_change_listener");
picojson::value response{picojson::object{}};
auto& obj = response.get<picojson::object>();
}
ptr->state_listener = [this, ptr](const common::TizenResult& res, const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, ptr->state_listener");
picojson::value response{picojson::object{}};
auto& obj = response.get<picojson::object>();
long long id = GetId(args);
auto response = [this, id](const common::TizenResult& res, const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, response");
picojson::value response{picojson::object{}};
auto& obj = response.get<picojson::object>();
long long id = presence->id;
presence->presence_listener = [this, id](const common::TizenResult&, const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, presence->presence_listener");
picojson::value response{picojson::object{}};
auto& obj = response.get<picojson::object>();
long long id = GetId(args);
auto response = [this, id](const common::TizenResult& res, const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, response");
picojson::value response{picojson::object{}};
auto& obj = response.get<picojson::object>();
long long id = GetId(args);
auto response = [this, id](const common::TizenResult& res, const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, response");
picojson::value response{picojson::object{}};
auto& obj = response.get<picojson::object>();
ScopeLogger();
auto listener = [this](const char* pin, long watchId) {
+ ScopeLogger("Entered into asynchronous function, listener");
picojson::object obj;
obj[kId] = picojson::value{(double)watchId};
obj["pin"] = picojson::value{pin};
ScopeLogger();
return [this, token, resource](const common::TizenResult& result, const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, returned value");
auto value = IotconClientManager::GetInstance().RemoveRemoteResource(resource);
auto& obj = value.get<picojson::object>();
namespace iotcon {
IotconManager::IotconManager() : nextWatchId(1) {
+ ScopeLogger();
}
IotconManager& IotconManager::GetInstance() {
+ ScopeLogger();
static IotconManager instance;
return instance;
}
ResourceInfoPtr* res_pointer) const {
ScopeLogger();
- auto it = std::find_if(resource_map_.begin(), resource_map_.end(),
- [resource](const ResourceInfoMap::value_type& p) -> bool {
- return p.second->handle == resource;
- });
+ auto it =
+ std::find_if(resource_map_.begin(), resource_map_.end(),
+ [resource](const ResourceInfoMap::value_type& p) -> bool {
+ ScopeLogger("Entered into asynchronous function, std::find_if's argument");
+ return p.second->handle == resource;
+ });
if (it == resource_map_.end()) {
return LogAndCreateTizenError(NotFoundError, "Resource with specified handle does not exist");
ScopeLogger();
if (interfaces) {
- auto result = ConvertIotconError(
- iotcon_resource_interfaces_foreach(interfaces,
- [](const char* iface, void* user_data) -> bool {
- ScopeLogger("iotcon_resource_interfaces_foreach");
-
- if (iface) {
-
auto arr = static_cast<picojson::array*>(user_data);
- arr->push_back(picojson::value(iface));
- }
-
- // always continue with iteration
- return true;
- },
- arr));
+ auto result = ConvertIotconError(iotcon_resource_interfaces_foreach(
+ interfaces,
+ [](const char* iface, void* user_data) -> bool {
+ ScopeLogger("Entered into asynchronous function, iotcon_resource_interfaces_foreach");
+
+ if (iface) {
+ auto arr = static_cast<picojson::array*>(user_data);
+ arr->push_back(picojson::value(iface));
+ }
+
+ // always continue with iteration
+ return true;
+ },
+ arr));
if (!result) {
LogAndReturnTizenError(result, ("iotcon_resource_interfaces_foreach() failed"));
}
auto result = ConvertIotconError(iotcon_representation_foreach_children(
representation,
[](iotcon_representation_h child, void* user_data) -> bool {
+ ScopeLogger(
+ "Entered into asynchronous function, iotcon_representation_foreach_children's "
+ "argument");
auto arr = static_cast<picojson::array*>(user_data);
arr->push_back(picojson::value{picojson::object{}});
auto result = RepresentationToJson(child, &arr->back().get<picojson::object>());
auto result = ConvertIotconError(iotcon_attributes_foreach(
attributes,
[](iotcon_attributes_h attributes, const char* key, void* user_data) -> bool {
+ ScopeLogger("Entered into asynchronous function, iotcon_attributes_foreach's argument");
iotcon_type_e type = IOTCON_TYPE_NONE;
auto result = ConvertIotconError(iotcon_attributes_get_type(attributes, key, &type));
break;
case IOTCON_TYPE_INT:
- result = ConvertIotconError(
- iotcon_list_foreach_int(list,
- [](int, int value, void* user_data) -> bool {
- auto out = static_cast<picojson::array*>(user_data);
- out->push_back(picojson::value{static_cast<double>(value)});
- // always continue with iteration
- return true;
- },
- out));
+ result = ConvertIotconError(iotcon_list_foreach_int(
+ list,
+ [](int, int value, void* user_data) -> bool {
+ ScopeLogger("Entered into asynchronous function, iotcon_list_foreach_int's argument");
+ auto out = static_cast<picojson::array*>(user_data);
+ out->push_back(picojson::value{static_cast<double>(value)});
+ // always continue with iteration
+ return true;
+ },
+ out));
if (!result) {
LogAndReturnTizenError(result, ("iotcon_list_foreach_int() failed"));
}
break;
case IOTCON_TYPE_BOOL:
- result = ConvertIotconError(
- iotcon_list_foreach_bool(list,
- [](int, bool value, void* user_data) -> bool {
- auto out = static_cast<picojson::array*>(user_data);
- out->push_back(picojson::value{value});
- // always continue with iteration
- return true;
- },
- out));
+ result = ConvertIotconError(iotcon_list_foreach_bool(
+ list,
+ [](int, bool value, void* user_data) -> bool {
+ ScopeLogger(
+ "Entered into asynchronous function, iotcon_list_foreach_bool's argument");
+ auto out = static_cast<picojson::array*>(user_data);
+ out->push_back(picojson::value{value});
+ // always continue with iteration
+ return true;
+ },
+ out));
if (!result) {
LogAndReturnTizenError(result, ("iotcon_list_foreach_bool() failed"));
}
break;
case IOTCON_TYPE_DOUBLE:
- result = ConvertIotconError(
- iotcon_list_foreach_double(list,
- [](int, double value, void* user_data) -> bool {
- auto out = static_cast<picojson::array*>(user_data);
- out->push_back(picojson::value{value});
- // always continue with iteration
- return true;
- },
- out));
+ result = ConvertIotconError(iotcon_list_foreach_double(
+ list,
+ [](int, double value, void* user_data) -> bool {
+ ScopeLogger(
+ "Entered into asynchronous function, iotcon_list_foreach_double's argument");
+ auto out = static_cast<picojson::array*>(user_data);
+ out->push_back(picojson::value{value});
+ // always continue with iteration
+ return true;
+ },
+ out));
if (!result) {
LogAndReturnTizenError(result, ("iotcon_list_foreach_double() failed"));
}
break;
case IOTCON_TYPE_STR:
- result = ConvertIotconError(
- iotcon_list_foreach_str(list,
- [](int, const char* value, void* user_data) -> bool {
- if (value) {
- auto out = static_cast<picojson::array*>(user_data);
- out->push_back(picojson::value{value});
- }
- // always continue with iteration
- return true;
- },
- out));
+ result = ConvertIotconError(iotcon_list_foreach_str(
+ list,
+ [](int, const char* value, void* user_data) -> bool {
+ if (value) {
+ ScopeLogger(
+ "Entered into asynchronous function, iotcon_list_foreach_str's argument");
+ auto out = static_cast<picojson::array*>(user_data);
+ out->push_back(picojson::value{value});
+ }
+ // always continue with iteration
+ return true;
+ },
+ out));
if (!result) {
LogAndReturnTizenError(result, ("iotcon_list_foreach_str() failed"));
}
result = ConvertIotconError(iotcon_list_foreach_byte_str(
list,
[](int, const unsigned char* value, int length, void* user_data) -> bool {
+ ScopeLogger(
+ "Entered into asynchronous function, iotcon_list_foreach_byte_str's argument");
if (length) {
std::unique_ptr<char[]> data{new char[2 * length]};
common::tools::BinToHex(value, length, data.get(), 2 * length);
result = ConvertIotconError(iotcon_list_foreach_list(
list,
[](int, iotcon_list_h list, void* user_data) -> bool {
+ ScopeLogger(
+ "Entered into asynchronous function, iotcon_list_foreach_list's argument");
picojson::value value{picojson::array{}};
auto result = StateListToJson(list, &value.get<picojson::array>());
if (result) {
result = ConvertIotconError(iotcon_list_foreach_attributes(
list,
[](int, iotcon_attributes_h attributes, void* user_data) -> bool {
+ ScopeLogger(
+ "Entered into asynchronous function, iotcon_list_foreach_attributes' argument");
picojson::value value{picojson::object{}};
auto result = AttributesToJson(attributes, &value.get<picojson::object>());
if (result) {
auto result = ConvertIotconError(iotcon_options_foreach(
options,
[](unsigned short id, const char* data, void* user_data) -> bool {
+ ScopeLogger("Entered into asynchronous function, iotcon_options_foreach's argument");
if (data) {
picojson::value v{picojson::object{}};
auto& obj = v.get<picojson::object>();
{
// filter
picojson::value v{picojson::object{}};
- auto result = ConvertIotconError(
- iotcon_query_foreach(query,
- [](const char* key, const char* value, void* user_data) -> bool {
- if (key && value) {
- auto obj = static_cast<picojson::object*>(user_data);
- obj->insert(std::make_pair(key, picojson::value{value}));
- }
- // always continue with iteration
- return true;
- },
- &v.get<picojson::object>()));
+ auto result = ConvertIotconError(iotcon_query_foreach(
+ query,
+ [](const char* key, const char* value, void* user_data) -> bool {
+
+ ScopeLogger("Entered into asynchronous function, iotcon_query_foreach's argument");
+ if (key && value) {
+ auto obj = static_cast<picojson::object*>(user_data);
+ obj->insert(std::make_pair(key, picojson::value{value}));
+ }
+ // always continue with iteration
+ return true;
+ },
+ &v.get<picojson::object>()));
if (!result) {
LogAndReturnTizenError(result, ("iotcon_query_foreach() failed"));
}
const std::string kSpace = " ";
void GetGenericAliasList(AliasListFunction func, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
ckmc_alias_list_s* alias_list = nullptr;
int ret = func(&alias_list);
} // namespace
KeyManagerInstance::KeyManagerInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
void KeyManagerInstance::GetDataAliasList(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
GetGenericAliasList(ckmc_get_data_alias_list, &out);
}
}
void KeyManagerInstance::SaveData(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
std::string data_raw = args.get("rawData").get<std::string>();
std::string alias = args.get("aliasName").get<std::string>();
}
auto save_data = [data_raw, password, alias](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, save_data");
unsigned char* data = new unsigned char[data_raw.size()];
std::copy(data_raw.begin(), data_raw.end(), data);
};
auto save_data_result = [this, callback_id](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, save_data_result");
result->get<picojson::object>()["callbackId"] = picojson::value{callback_id};
Instance::PostMessage(this, result->serialize().c_str());
};
}
void KeyManagerInstance::GetData(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
const auto& data_alias = args.get("name").get<std::string>();
const auto& password_value = args.get("password");
}
KeyManagerInstance::~KeyManagerInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
void KeyManagerInstance::RemoveAlias(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string& alias = args.get("aliasName").get<std::string>();
int ret = ckmc_remove_alias(alias.c_str());
}
void KeyManagerInstance::SetPermission(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string& data_name = args.get("aliasName").get<std::string>();
const std::string& id = args.get("packageId").get<std::string>();
auto set_permissions = [data_name, id,
permissions](const std::shared_ptr<picojson::value>& response) -> void {
+
+ ScopeLogger("Entered into asynchronous function, set_permissions");
int ret = ckmc_set_permission(data_name.c_str(), id.c_str(), permissions);
if (CKMC_ERROR_NONE != ret) {
auto set_permissions_response =
[this, callback_id](const std::shared_ptr<picojson::value>& response) -> void {
+ ScopeLogger("Entered into asynchronous function, set_permissions_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
Instance::PostMessage(this, response->serialize().c_str());
using common::ErrorCode;
MediaControllerClient::MediaControllerClient() : handle_(nullptr) {
- LoggerD("Enter");
+ ScopeLogger();
}
MediaControllerClient::~MediaControllerClient() {
- LoggerD("Enter");
+ ScopeLogger();
if (handle_) {
int ret = mc_client_destroy(handle_);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
}
PlatformResult MediaControllerClient::Init() {
- LoggerD("Enter");
+ ScopeLogger();
int ret = mc_client_create(&handle_);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
return LogAndCreateResult(
}
PlatformResult MediaControllerClient::FindServers(picojson::array* servers) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
ret = mc_client_foreach_server(handle_, FindServersCallback, servers);
}
bool MediaControllerClient::FindServersCallback(const char* server_name, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array* servers = static_cast<picojson::array*>(user_data);
picojson::value server = picojson::value(picojson::object());
}
PlatformResult MediaControllerClient::GetLatestServerInfo(picojson::value* server_info) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
char* name = nullptr;
PlatformResult MediaControllerClient::GetPlaybackInfo(const std::string& server_name,
picojson::object* playback_info) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
mc_playback_h playback_h;
PlatformResult MediaControllerClient::GetMetadata(const std::string& server_name,
picojson::object* metadata) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
mc_metadata_h metadata_h;
}
PlatformResult MediaControllerClient::SetServerStatusChangeListener(JsonCallback callback) {
- LoggerD("Enter");
+ ScopeLogger();
if (callback && server_status_listener_) {
return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR, "Listener already registered");
}
void MediaControllerClient::OnServerStatusUpdate(const char* server_name, mc_server_state_e state,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerClient* client = static_cast<MediaControllerClient*>(user_data);
if (!client->server_status_listener_) {
}
PlatformResult MediaControllerClient::SetPlaybackInfoListener(JsonCallback callback) {
- LoggerD("Enter");
+ ScopeLogger();
if (callback && playback_info_listener_) {
return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR, "Listener already registered");
}
void MediaControllerClient::OnPlaybackUpdate(const char* server_name, mc_playback_h playback,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerClient* client = static_cast<MediaControllerClient*>(user_data);
if (!client->playback_info_listener_) {
void MediaControllerClient::OnShuffleModeUpdate(const char* server_name, mc_shuffle_mode_e mode,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerClient* client = static_cast<MediaControllerClient*>(user_data);
if (!client->playback_info_listener_) {
void MediaControllerClient::OnRepeatModeUpdate(const char* server_name, mc_repeat_mode_e mode,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerClient* client = static_cast<MediaControllerClient*>(user_data);
if (!client->playback_info_listener_) {
void MediaControllerClient::OnMetadataUpdate(const char* server_name, mc_metadata_h metadata_h,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerClient* client = static_cast<MediaControllerClient*>(user_data);
if (!client->playback_info_listener_) {
const picojson::value& data,
const std::string& reply_id,
const JsonCallback& reply_cb) {
- LoggerD("Enter");
+ ScopeLogger();
bundle* bundle = bundle_create();
SCOPE_EXIT {
bundle_free(bundle);
void MediaControllerClient::OnCommandReply(const char* server_name, int result_code, bundle* bundle,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerClient* client = static_cast<MediaControllerClient*>(user_data);
picojson::value reply = picojson::value(picojson::object());
PlatformResult MediaControllerClient::SendPlaybackState(const std::string& server_name,
const std::string& state) {
- LoggerD("Enter");
+ ScopeLogger();
int state_e;
PlatformResult result =
Types::StringToPlatformEnum(Types::kMediaControllerPlaybackState, state, &state_e);
using common::TaskQueue;
MediaControllerInstance::MediaControllerInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using namespace std::placeholders;
#define REGISTER_SYNC(c, x) \
}
MediaControllerInstance::~MediaControllerInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
#define CHECK_EXIST(args, name, out) \
void MediaControllerInstance::MediaControllerManagerCreateServer(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMediaControllerServer, &out);
void MediaControllerInstance::MediaControllerServerUpdatePlaybackState(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "state", out)
if (!server_) {
void MediaControllerInstance::MediaControllerServerUpdatePlaybackPosition(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Server not initialized."), &out,
("Failed: server_"));
void MediaControllerInstance::MediaControllerServerUpdateShuffleMode(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Server not initialized."), &out,
("Failed: server_"));
void MediaControllerInstance::MediaControllerServerUpdateRepeatMode(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Server not initialized."), &out,
void MediaControllerInstance::MediaControllerServerUpdateMetadata(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Server not initialized."), &out,
("Failed: server_"));
void MediaControllerInstance::MediaControllerServerAddChangeRequestPlaybackInfoListener(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Server not initialized."), &out,
("Failed: server_"));
void MediaControllerInstance::MediaControllerServerRemoveChangeRequestPlaybackInfoListener(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Server not initialized."), &out,
("Failed: server_"));
void MediaControllerInstance::MediaControllerServerAddCommandListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Server not initialized."), &out,
("Failed: server_"));
void MediaControllerInstance::MediaControllerServerReplyCommand(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Server not initialized."), &out,
("Failed: server_"));
void MediaControllerInstance::MediaControllerServerRemoveCommandListener(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!server_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Server not initialized."), &out,
("Failed: server_"));
void MediaControllerInstance::MediaControllerManagerGetClient(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMediaControllerClient, &out);
void MediaControllerInstance::MediaControllerClientFindServers(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
void MediaControllerInstance::MediaControllerClientGetLatestServerInfo(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
void MediaControllerInstance::MediaControllerClientGetPlaybackInfo(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
void MediaControllerInstance::MediaControllerServerInfoSendPlaybackState(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
void MediaControllerInstance::MediaControllerServerInfoSendPlaybackPosition(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
void MediaControllerInstance::MediaControllerServerInfoSendShuffleMode(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
void MediaControllerInstance::MediaControllerServerInfoSendRepeatMode(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
void MediaControllerInstance::MediaControllerServerInfoSendCommand(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
void MediaControllerInstance::MediaControllerServerInfoAddServerStatusChangeListener(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
void MediaControllerInstance::MediaControllerServerInfoRemoveServerStatusChangeListener(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
void MediaControllerInstance::MediaControllerServerInfoAddPlaybackInfoChangeListener(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (!client_) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR, "Client not initialized."), &out,
("Failed: client_"));
using common::ErrorCode;
MediaControllerServer::MediaControllerServer() : handle_(nullptr) {
- LoggerD("Enter");
+ ScopeLogger();
}
MediaControllerServer::~MediaControllerServer() {
- LoggerD("Enter");
+ ScopeLogger();
if (handle_) {
int ret;
}
PlatformResult MediaControllerServer::Init() {
- LoggerD("Enter");
+ ScopeLogger();
int ret = mc_server_create(&handle_);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
}
PlatformResult MediaControllerServer::SetPlaybackState(const std::string& state) {
- LoggerD("Enter");
+ ScopeLogger();
int state_int;
PlatformResult result =
}
PlatformResult MediaControllerServer::SetPlaybackPosition(double position) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = mc_server_set_playback_position(handle_, static_cast<unsigned long long>(position));
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
}
PlatformResult MediaControllerServer::SetShuffleMode(bool mode) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = mc_server_update_shuffle_mode(handle_, mode ? MC_SHUFFLE_MODE_ON : MC_SHUFFLE_MODE_OFF);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
}
PlatformResult MediaControllerServer::SetRepeatMode(bool mode) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = mc_server_update_repeat_mode(handle_, mode ? MC_REPEAT_MODE_ON : MC_REPEAT_MODE_OFF);
if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
}
PlatformResult MediaControllerServer::SetMetadata(const picojson::object& metadata) {
- LoggerD("Enter");
+ ScopeLogger();
int attribute_int, ret;
for (picojson::object::const_iterator i = metadata.begin(); i != metadata.end(); ++i) {
void MediaControllerServer::OnCommandReceived(const char* client_name, const char* command,
bundle* bundle, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerServer* server = static_cast<MediaControllerServer*>(user_data);
PlatformResult MediaControllerServer::CommandReply(const std::string& client_name,
const std::string& reply_id,
const picojson::value& data) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
}
PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(JsonCallback callback) {
- LoggerD("Enter");
+ ScopeLogger();
if (callback && change_request_playback_info_listener_) {
return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR, "Listener already registered");
void MediaControllerServer::OnPlaybackStateCommand(const char* client_name,
mc_playback_states_e state_e, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerServer* server = static_cast<MediaControllerServer*>(user_data);
void MediaControllerServer::OnPlaybackPositionCommand(const char* client_name,
unsigned long long position,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerServer* server = static_cast<MediaControllerServer*>(user_data);
void MediaControllerServer::OnShuffleModeCommand(const char* client_name, mc_shuffle_mode_e mode,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerServer* server = static_cast<MediaControllerServer*>(user_data);
void MediaControllerServer::OnRepeatModeCommand(const char* client_name, mc_repeat_mode_e mode,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MediaControllerServer* server = static_cast<MediaControllerServer*>(user_data);
PlatformResult Types::GetPlatformEnumMap(const std::string& type,
std::map<std::string, int>* enum_map) {
- LoggerD("Enter");
+ ScopeLogger();
auto iter = platform_enum_map_.find(type);
if (iter == platform_enum_map_.end()) {
PlatformResult Types::StringToPlatformEnum(const std::string& type, const std::string& value,
int* platform_enum) {
- LoggerD("Enter");
+ ScopeLogger();
std::map<std::string, int> def;
PlatformResult result = GetPlatformEnumMap(type, &def);
PlatformResult Types::PlatformEnumToString(const std::string& type, int value,
std::string* platform_str) {
- LoggerD("Enter");
+ ScopeLogger();
if (platform_enum_reverse_map_.empty()) {
for (auto& def : platform_enum_map_) {
}
PlatformResult Types::ConvertPlaybackState(mc_playback_h playback_h, std::string* state) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
mc_playback_states_e state_e;
}
PlatformResult Types::ConvertPlaybackPosition(mc_playback_h playback_h, double* position) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
}
PlatformResult Types::ConvertMetadata(mc_metadata_h metadata_h, picojson::object* metadata) {
- LoggerD("Enter");
+ ScopeLogger();
std::map<std::string, int> metadata_fields;
PlatformResult result =
{MEDIA_KEY_REWIND, "MEDIA_REWIND"}, {MEDIA_KEY_PLAYPAUSE, "MEDIA_PLAY_PAUSE"}};
MediaKeyInstance::MediaKeyInstance() {
- LoggerD("Entered");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&MediaKeyInstance::x, this, _1, _2));
}
MediaKeyInstance::~MediaKeyInstance() {
- LoggerD("Entered");
+ ScopeLogger();
MediaKeyManager::GetInstance().UnregisterMediaKeyEventListener();
}
void MediaKeyInstance::SetMediaKeyEventListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
common::PlatformResult result =
MediaKeyManager::GetInstance().RegisterMediaKeyEventListener(this);
void MediaKeyInstance::UnsetMediaKeyEventListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
common::PlatformResult result = MediaKeyManager::GetInstance().UnregisterMediaKeyEventListener();
if (result.IsError()) {
LogAndReportError(result, &out, ("Failed to remove media key event listener"));
}
void MediaKeyInstance::OnPressedMediaKeyEventCallback(media_key_e type) {
- LoggerD("Enter");
+ ScopeLogger();
PostEvent("onPressedMediaKeyEventCallback", type);
}
void MediaKeyInstance::OnReleasedMediaKeyEventCallback(media_key_e type) {
- LoggerD("Enter");
+ ScopeLogger();
PostEvent("onReleasedMediaKeyEventCallback", type);
}
void MediaKeyInstance::PostEvent(const std::string& eventCallback, media_key_e type) {
- LoggerD("Enter");
+ ScopeLogger();
auto k = kMediaKeyTypeMap.find(type);
if (k != kMediaKeyTypeMap.end()) {
picojson::value event = picojson::value(picojson::object());
using common::UnknownException;
using common::ErrorCode;
MediaKeyListener::~MediaKeyListener() {
- LoggerD("Enter");
+ ScopeLogger();
}
MediaKeyManager& MediaKeyManager::GetInstance() {
MediaKeyManager::MediaKeyManager()
: m_media_key_listener(nullptr), m_media_key_listener_registered(false) {
- LoggerD("Enter");
+ ScopeLogger();
}
common::PlatformResult MediaKeyManager::RegisterMediaKeyEventListener(MediaKeyListener* listener) {
- LoggerD("Enter");
+ ScopeLogger();
if (!m_media_key_listener_registered) {
LoggerD("before calling media_key_reserve");
int ret = media_key_reserve(MediaKeyEventCallback, NULL);
return common::PlatformResult(ErrorCode::NO_ERROR);
}
common::PlatformResult MediaKeyManager::UnregisterMediaKeyEventListener() {
- LoggerD("Enter");
+ ScopeLogger();
if (m_media_key_listener_registered) {
int ret = media_key_release();
if (MEDIA_KEY_ERROR_NONE != ret) {
void MediaKeyManager::MediaKeyEventCallback(media_key_e key, media_key_event_e status,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
if (!GetInstance().m_media_key_listener) {
LoggerD("Listener is null. Ignoring");
return;
using common::QuotaExceededException;
MessageportInstance::MessageportInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
#define REGISTER_SYNC(c, x) \
}
MessageportInstance::~MessageportInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
enum MessageportCallbacks {
static void BundleJsonIterator(const char* key, const int type, const bundle_keyval_t* kv,
void* d) {
- LoggerD("Enter");
+ ScopeLogger();
void* basic_val = nullptr;
size_t basic_size = 0;
static void OnReceiveLocalMessage(int local_port_id, const char* remote_app_id,
const char* remote_port, bool trusted_remote_port,
bundle* message, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
MessageportInstance* object = static_cast<MessageportInstance*>(user_data);
picojson::value::object o;
picojson::value::array data;
void MessageportInstance::MessagePortManagerRequestlocalmessageport(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "localMessagePortName", out)
int portId;
void MessageportInstance::MessagePortManagerRequesttrustedlocalmessageport(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "localMessagePortName", out)
int portId;
void MessageportInstance::MessagePortManagerRequestremotemessageport(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "remoteMessagePortName", out)
const std::string& remoteMessagePortName = args.get("remoteMessagePortName").get<std::string>();
void MessageportInstance::MessagePortManagerRequesttrustedremotemessageport(
const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "remoteMessagePortName", out)
const std::string& remoteMessagePortName = args.get("remoteMessagePortName").get<std::string>();
void MessageportInstance::RemoteMessagePortSendmessage(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string& appId = args.get("appId").get<std::string>();
const std::string& message_port_name = args.get("messagePortName").get<std::string>();
std::vector<picojson::value> data = args.get("data").get<picojson::array>();
: common::dbus::Proxy(proxy_path, proxy_iface,
kDBusNameSignalEmail, // specify email signal details
kDBusPathNetworkStatus, kDBusIfaceNetworkStatus) {
+ ScopeLogger();
}
EmailSignalProxy::~EmailSignalProxy() {
+ ScopeLogger();
}
void EmailSignalProxy::signalCallback(GDBusConnection* connection, const gchar* sender_name,
std::shared_ptr<MessageAttachment> attachment) {
struct ScopedEmailAttachmentData {
ScopedEmailAttachmentData() : data(NULL) {
+ ScopeLogger();
}
~ScopedEmailAttachmentData() {
+ ScopeLogger();
if (data) {
email_free_attachment_data(&data, 1);
}
LoadAttachmentProxy::LoadAttachmentProxy(const std::string& path, const std::string& iface)
: EmailSignalProxy(path, iface) {
+ ScopeLogger();
}
LoadAttachmentProxy::~LoadAttachmentProxy() {
+ ScopeLogger();
}
PlatformResult LoadAttachmentProxy::create(const std::string& path, const std::string& iface,
LoadAttachmentProxyPtr* load_attachment_proxy) {
+ ScopeLogger();
load_attachment_proxy->reset(new LoadAttachmentProxy(path, iface));
if ((*load_attachment_proxy)->isNotProxyGot()) {
load_attachment_proxy->reset();
}
void LoadAttachmentProxy::addCallback(MessageAttachmentCallbackData* callbackOwned) {
+ ScopeLogger();
if (callbackOwned->getMessageAttachment()) {
LoggerD("Registered callback for attachment_id: %d mail_id:%d op_handle:%d nth:%d",
callbackOwned->getMessageAttachment()->getId(),
}
void LoadAttachmentProxy::removeCallback(MessageAttachmentCallbackData* callback) {
+ ScopeLogger();
if (callback->getMessageAttachment()) {
LoggerD("Removed callback for attachment_id: %d mail_id:%d op_handle:%d nth:%d",
callback->getMessageAttachment()->getId(),
}
MessageAttachmentCallbackData* LoadAttachmentProxy::findCallback(const int nth, const int mail_id) {
+ ScopeLogger();
CallbackSet::iterator it = m_callback_set.begin();
for (; it != m_callback_set.end(); ++it) {
MessageAttachmentCallbackData* callback = *it;
void LoadAttachmentProxy::handleEmailSignal(const int status, const int mail_id,
const std::string& source, const int op_handle,
const int error_code) {
+ ScopeLogger();
if (NOTI_DOWNLOAD_ATTACH_FINISH != status && NOTI_DOWNLOAD_ATTACH_FAIL != status) {
return;
}
LoadBodyProxy::LoadBodyProxy(const std::string& path, const std::string& iface)
: EmailSignalProxy(path, iface) {
+ ScopeLogger();
}
LoadBodyProxy::~LoadBodyProxy() {
+ ScopeLogger();
}
PlatformResult LoadBodyProxy::create(const std::string& path, const std::string& iface,
LoadBodyProxyPtr* load_body_proxy) {
+ ScopeLogger();
load_body_proxy->reset(new LoadBodyProxy(path, iface));
if ((*load_body_proxy)->isNotProxyGot()) {
load_body_proxy->reset();
}
MessageBodyCallbackData* LoadBodyProxy::findCallbackByOpHandle(const int op_handle) {
+ ScopeLogger();
CallbackSet::iterator it = m_callback_set.begin();
for (; it != m_callback_set.end(); ++it) {
MessageBodyCallbackData* callback = *it;
void LoadBodyProxy::handleEmailSignal(const int status, const int mail_id,
const std::string& source, const int op_handle,
const int error_code) {
+ ScopeLogger();
switch (status) {
// We should handle this signal since it is DOWNLOAD_BODY_*
case NOTI_DOWNLOAD_BODY_START:
: common::dbus::Proxy(kDBusPathEmailStorageChange, kDBusIfaceEmailStorageChange,
kDBusNameSignalEmail, kDBusPathEmailStorageChange,
kDBusIfaceEmailStorageChange) {
+ ScopeLogger();
}
MessageProxy::~MessageProxy() {
+ ScopeLogger();
}
PlatformResult MessageProxy::create(MessageProxyPtr* message_proxy) {
+ ScopeLogger();
message_proxy->reset(new MessageProxy());
if ((*message_proxy)->isNotProxyGot()) {
message_proxy->reset();
void MessageProxy::signalCallback(GDBusConnection* connection, const gchar* sender_name,
const gchar* object_path, const gchar* interface_name,
const gchar* signal_name, GVariant* parameters) {
- LoggerD("Enter");
+ ScopeLogger();
int status, account_id, object_id, thread_id;
char* name;
g_variant_get(parameters, "(iiisi)", &status, &account_id, &object_id, &name, &thread_id);
PlatformResult MessageProxy::handleEmailEvent(int account_id, int mail_id, int thread_id,
int event) {
- LoggerD("Enter");
+ ScopeLogger();
if (ChangeListenerContainer::getInstance().isEmailListenerRegistered()) {
LoggerD("Listener registered - perform action");
}
std::vector<int> getMailIds(const std::string& idsString) {
+ ScopeLogger();
std::stringstream idsStream(idsString);
std::string item;
std::vector<int> ids;
}
void MessageProxy::handleEmailRemoveEvent(int account_id, const std::string& idsString) {
- LoggerD("Enter");
+ ScopeLogger();
std::vector<int> ids = getMailIds(idsString);
if (ids.empty()) {
LoggerD("Mail id list is empty.");
void MessageProxy::notifyEmailManager(const std::string& idsString,
email_noti_on_storage_event status) {
- LoggerD("Enter");
+ ScopeLogger();
std::vector<int> ids = getMailIds(idsString);
if (ids.empty()) {
LoggerD("Mail id list is empty.");
}
void MessageProxy::handleThreadRemoveEvent(int account_id, int thread_id) {
- LoggerD("Enter");
+ ScopeLogger();
// event is called after thread is removed, so we just set thread id and type
ConversationPtr conv = std::make_shared<MessageConversation>();
conv->setConversationId(thread_id);
}
PlatformResult MessageProxy::handleMailboxEvent(int account_id, int mailbox_id, int event) {
- LoggerD("Enter");
+ ScopeLogger();
EventFolders* eventFolder = new EventFolders();
eventFolder->service_type = MessageType::EMAIL;
eventFolder->service_id = account_id;
using namespace common;
SendProxy::SendProxy() : EmailSignalProxy(kDBusPathNetworkStatus, kDBusIfaceNetworkStatus) {
+ ScopeLogger();
}
SendProxy::~SendProxy() {
+ ScopeLogger();
}
PlatformResult SendProxy::create(SendProxyPtr* send_proxy) {
+ ScopeLogger();
send_proxy->reset(new SendProxy());
if ((*send_proxy)->isNotProxyGot()) {
send_proxy->reset();
void SendProxy::handleEmailSignal(const int status, const int account_id, const std::string& source,
const int mail_id, const int error_code) {
- LoggerD("Enter");
+ ScopeLogger();
switch (status) {
case NOTI_SEND_FINISH:
case NOTI_SEND_FAIL:
SyncProxy::SyncProxy(const std::string& path, const std::string& iface)
: EmailSignalProxy(path, iface) {
+ ScopeLogger();
}
SyncProxy::~SyncProxy() {
+ ScopeLogger();
}
PlatformResult SyncProxy::create(const std::string& path, const std::string& iface,
SyncProxyPtr* sync_proxy) {
+ ScopeLogger();
sync_proxy->reset(new SyncProxy(path, iface));
if ((*sync_proxy)->isNotProxyGot()) {
sync_proxy->reset();
}
void SyncProxy::addCallback(long op_id, CallbackUserData* callbackOwned) {
+ ScopeLogger();
m_callback_map.insert(std::make_pair(op_id, callbackOwned));
}
CallbackUserData* SyncProxy::getCallback(long op_id) {
+ ScopeLogger();
CallbackUserData* cb = nullptr;
const auto it = m_callback_map.find(op_id);
}
void SyncProxy::removeCallback(long op_id) {
+ ScopeLogger();
auto it = m_callback_map.find(op_id);
if (it != m_callback_map.end()) {
delete it->second;
void SyncProxy::handleEmailSignal(const int status, const int mail_id, const std::string& source,
const int op_handle, const int error_code) {
+ ScopeLogger();
if (NOTI_DOWNLOAD_START != status && NOTI_DOWNLOAD_FINISH != status &&
NOTI_DOWNLOAD_FAIL != status) {
// Nothing to do: this status is not related to sync nor syncFolder request
PlatformResult SyncProxy::findSyncCallbackByOpHandle(const int op_handle,
SyncProxy::CallbackMap::iterator* it) {
+ ScopeLogger();
*it = m_callback_map.begin();
for (; *it != m_callback_map.end(); ++(*it)) {
SyncCallbackData* cb = dynamic_cast<SyncCallbackData*>((*it)->second);
using namespace common;
AbstractFilter::AbstractFilter(FilterType filter_type) : m_filter_type(filter_type) {
+ ScopeLogger();
}
AbstractFilter::~AbstractFilter() {
+ ScopeLogger();
}
FilterType AbstractFilter::getFilterType() const {
bool FilterUtils::isStringMatching(const std::string& key, const std::string& value,
tizen::FilterMatchFlag flag) {
+ ScopeLogger();
switch (flag) {
case tizen::ENDSWITH: {
if (key.empty()) {
bool FilterUtils::isAnyStringMatching(const std::string& key,
const std::vector<std::string>& values,
tizen::FilterMatchFlag flag) {
+ ScopeLogger();
for (auto it = values.begin(); it != values.end(); ++it) {
if (isStringMatching(key, *it, flag)) {
return true;
bool FilterUtils::isTimeStampInRange(const time_t& time_stamp, tizen::AnyPtr& initial_value,
tizen::AnyPtr& end_value) {
+ ScopeLogger();
time_t from_time = 0;
time_t to_time = 0;
Any::Any(picojson::value value)
: // m_context(context),
m_value(value) {
+ ScopeLogger();
// JSValueProtect(m_context, m_value);
}
Any::~Any() {
+ ScopeLogger();
// JSValueUnprotect(m_context, m_value);
}
AttributeFilter::AttributeFilter(const std::string &attribute_name)
: AbstractFilter(ATTRIBUTE_FILTER), m_attribute_name(attribute_name), m_match_flag(EXACTLY) {
+ ScopeLogger();
}
AttributeFilter::~AttributeFilter() {
+ ScopeLogger();
}
std::string AttributeFilter::getAttributeName() const {
}
bool AttributeFilter::isMatching(const FilterableObject *const filtered_object) const {
+ ScopeLogger();
if (!filtered_object) {
LoggerE("Invalid object: NULL!");
return false;
AttributeRangeFilter::AttributeRangeFilter(const std::string &attribute_name)
: m_attribute_name(attribute_name) {
+ ScopeLogger();
m_filter_type = ATTRIBUTE_RANGE_FILTER;
}
AttributeRangeFilter::~AttributeRangeFilter() {
+ ScopeLogger();
}
std::string AttributeRangeFilter::getAttributeName() const {
m_type(type)
// m_context(NULL)
{
+ ScopeLogger();
}
CompositeFilter::~CompositeFilter() {
+ ScopeLogger();
}
CompositeFilterType CompositeFilter::getType() const {
FilterIterator::FilterIterator(AbstractFilterPtr filter)
: m_root_filter(filter), m_current_state(FIS_NOT_VALID) {
+ ScopeLogger();
if (!m_root_filter) {
LoggerE("Trying to create FilterIterator with NULL filter");
m_root_filter = AbstractFilterPtr(new AbstractFilter());
}
void FilterIterator::operator++(int) {
+ ScopeLogger();
this->operator++();
}
void FilterIterator::operator++() {
+ ScopeLogger();
if (FIS_ATTRIBUTE_FILTER == m_current_state || FIS_ATTRIBUTE_RANGE_FILTER == m_current_state) {
if (m_composite_stack.empty()) {
// We are not inside composite filter iteration -> reached THE END
}
void FilterIterator::goToNextInCurCompositeFilter() {
+ ScopeLogger();
CompositeIterState& cur_cs = m_composite_stack.top();
AbstractFilterPtrVector sub_filters = cur_cs.filter->getFilters();
const size_t next_filter_index = cur_cs.cur_sub_filter_index + 1;
}
void FilterIterator::setReachedEnd() {
+ ScopeLogger();
m_current_state = FIS_END;
m_current_filter = AbstractFilterPtr();
}
void FilterIterator::goToNext(AbstractFilterPtr next) {
+ ScopeLogger();
switch (next->getFilterType()) {
case ATTRIBUTE_FILTER: {
m_current_state = FIS_ATTRIBUTE_FILTER;
SortMode::SortMode(const std::string &attribute_name, SortModeOrder order)
: m_attribute_name(attribute_name), m_order(order) {
- LoggerD("SortMode attributeName: %s, SortMode order: %s", attribute_name.c_str(),
- (order == SortModeOrder::DESC) ? "DESC" : "ASC");
+ ScopeLogger("SortMode attributeName: %s, SortMode order: %s", attribute_name.c_str(),
+ (order == SortModeOrder::DESC) ? "DESC" : "ASC");
}
SortMode::~SortMode() {
+ ScopeLogger();
}
std::string SortMode::getAttributeName() const {
cid_(cid),
queue_(queue),
result_(common::ErrorCode::NO_ERROR) {
- LoggerD("Entered");
+ ScopeLogger();
if (!keep) {
// this is not listener, add callbackId
AddJsonData(JSON_CALLBACK_ID, picojson::value(static_cast<double>(cid_)));
}
CallbackUserData::~CallbackUserData() {
- LoggerD("Entered");
+ ScopeLogger();
}
bool CallbackUserData::IsError() const {
- LoggerD("Entered");
+ ScopeLogger();
return result_.IsError();
}
void CallbackUserData::SetError(const common::PlatformResult& error) {
- LoggerD("Entered");
+ ScopeLogger();
// keep only the first error
if (!IsError()) {
ReportError(error, &obj_);
}
void CallbackUserData::SetSuccess(const picojson::value& data /* = picojson::value()*/) {
- LoggerD("Entered");
+ ScopeLogger();
// do not allow to overwrite the error
if (!IsError()) {
ReportSuccess(data, obj_);
}
void CallbackUserData::SetAction(const char* action, const picojson::value& data) {
- LoggerD("Entered");
+ ScopeLogger();
AddJsonData(JSON_ACTION, picojson::value(action));
// ReportSuccess cannot be used here, update of this field is necessary (this is a special case)
}
void CallbackUserData::AddToQueue() {
- LoggerD("Entered");
+ ScopeLogger();
queue_.add(cid_, PostPriority::HIGH);
}
void CallbackUserData::Post() {
- LoggerD("Entered");
+ ScopeLogger();
queue_.resolve(cid_, json_.serialize());
}
}
bool CallbackUserData::HasQueue(const PostQueue& q) const {
- LoggerD("Entered");
+ ScopeLogger();
return &q == &queue_;
}
void CallbackUserData::AddJsonData(const char* key, const picojson::value& value) {
- LoggerD("Entered");
+ ScopeLogger();
// always overwrite
obj_[key] = value;
}
class ChangeListenerContainer::ChangeListeners {
public:
ChangeListeners() {
- LoggerD("Entered");
+ ScopeLogger();
groups_[SMS] = std::shared_ptr<ListenerGroup>(new ListenerGroup());
groups_[MMS] = std::shared_ptr<ListenerGroup>(new ListenerGroup());
template <class CallbackType>
long Add(const std::shared_ptr<CallbackType>& c) {
- LoggerD("Entered");
+ ScopeLogger();
auto it = groups_.find(c->getServiceType());
}
void Remove(long id) {
- LoggerD("Entered");
+ ScopeLogger();
for (auto& it : groups_) {
if (it.second->Remove(id)) {
template <class CallbackType, class EventType>
void Call(typename CallbackType::Signature m, EventType* e) const {
- LoggerD("Entered");
+ ScopeLogger();
auto it = groups_.find(e->service_type);
}
bool HasListeners(MessageType type) const {
- LoggerD("Entered");
+ ScopeLogger();
auto it = groups_.find(type);
class Listener {
public:
long Add(const std::shared_ptr<CallbackType>& c) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(mutex_);
auto id = GetNextId();
}
bool Remove(long id) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(mutex_);
return (0 != callbacks_.erase(id));
template <class EventType>
void Call(typename CallbackType::Signature m, EventType* e) const {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(mutex_);
}
bool HasListeners() const {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(mutex_);
return !callbacks_.empty();
}
bool Remove(long id) {
- LoggerD("Entered");
+ ScopeLogger();
bool ret = false;
}
bool HasListeners() const {
- LoggerD("Entered");
+ ScopeLogger();
return message_callbacks_.HasListeners() || conversation_callbacks_.HasListeners() ||
folder_callbacks_.HasListeners();
}
};
static long GetNextId() {
- LoggerD("Entered");
+ ScopeLogger();
static std::mutex mutex;
static long next_id = 0;
}
ChangeListenerContainer& ChangeListenerContainer::getInstance() {
- LoggerD("Entered");
+ ScopeLogger();
EmailManager::getInstance(); // make sure that callbacks are registered in email-service
// ShortMsgManager::getInstance(); //make sure that callbacks are registered in msg-service
static ChangeListenerContainer clc;
}
ChangeListenerContainer::ChangeListenerContainer() : listeners_(new ChangeListeners()) {
- LoggerD("Entered");
+ ScopeLogger();
}
// --- Listeners registration functions ---
long ChangeListenerContainer::addMessageChangeListener(
const std::shared_ptr<MessagesChangeCallback>& callback) {
- LoggerD("Entered");
+ ScopeLogger();
return listeners_->Add(callback);
}
long ChangeListenerContainer::addConversationChangeListener(
const std::shared_ptr<ConversationsChangeCallback>& callback) {
- LoggerD("Entered");
+ ScopeLogger();
return listeners_->Add(callback);
}
long ChangeListenerContainer::addFolderChangeListener(
const std::shared_ptr<FoldersChangeCallback>& callback) {
- LoggerD("Entered");
+ ScopeLogger();
return listeners_->Add(callback);
}
// --- listeners removal ---
void ChangeListenerContainer::removeChangeListener(long id) {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Remove(id);
}
// --- Callback invoking functions ---
// -- for message --
void ChangeListenerContainer::callMessageAdded(EventMessages* event) const {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Call<MessagesChangeCallback>(&MessagesChangeCallback::added, event);
}
void ChangeListenerContainer::callMessageUpdated(EventMessages* event) const {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Call<MessagesChangeCallback>(&MessagesChangeCallback::updated, event);
}
void ChangeListenerContainer::callMessageRemoved(EventMessages* event) const {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Call<MessagesChangeCallback>(&MessagesChangeCallback::removed, event);
}
// -- for conversation --
void ChangeListenerContainer::callConversationAdded(EventConversations* event) const {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Call<ConversationsChangeCallback>(&ConversationsChangeCallback::added, event);
}
void ChangeListenerContainer::callConversationUpdated(EventConversations* event) const {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Call<ConversationsChangeCallback>(&ConversationsChangeCallback::updated, event);
}
void ChangeListenerContainer::callConversationRemoved(EventConversations* event) const {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Call<ConversationsChangeCallback>(&ConversationsChangeCallback::removed, event);
}
// -- for folder --
void ChangeListenerContainer::callFolderAdded(EventFolders* event) const {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Call<FoldersChangeCallback>(&FoldersChangeCallback::added, event);
}
void ChangeListenerContainer::callFolderUpdated(EventFolders* event) const {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Call<FoldersChangeCallback>(&FoldersChangeCallback::updated, event);
}
void ChangeListenerContainer::callFolderRemoved(EventFolders* event) const {
- LoggerD("Entered");
+ ScopeLogger();
listeners_->Call<FoldersChangeCallback>(&FoldersChangeCallback::removed, event);
}
bool ChangeListenerContainer::isEmailListenerRegistered() const {
- LoggerD("Entered");
+ ScopeLogger();
return listeners_->HasListeners(EMAIL);
}
m_offset(0),
m_account_id(0),
m_service_type(UNDEFINED) {
- LoggerD("Entered");
+ ScopeLogger();
}
ConversationCallbackData::~ConversationCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void ConversationCallbackData::setFilter(AbstractFilterPtr filter) {
m_id(service_id),
m_msg_type(service_type),
m_is_act(true) {
- LoggerD("Entered");
+ ScopeLogger();
m_callback_data.SetListenerId("ConversationsChangeListener");
}
ConversationsChangeCallback::~ConversationsChangeCallback() {
- LoggerD("Entered");
+ ScopeLogger();
}
ConversationPtrVector ConversationsChangeCallback::filterConversations(
AbstractFilterPtr filter, const ConversationPtrVector& source_conversations) {
- LoggerD("Entered");
+ ScopeLogger();
if (filter) {
LoggerD("filter pointer is valid");
ConversationPtrVector filtered_conversations;
}
void ConversationsChangeCallback::added(const ConversationPtrVector& conversations) {
- LoggerD("Entered conversations.size()=%d", conversations.size());
+ ScopeLogger("conversations.size() = %d", conversations.size());
if (!m_is_act) {
return;
}
}
void ConversationsChangeCallback::updated(const ConversationPtrVector& conversations) {
- LoggerD("Entered conversations.size()=%d", conversations.size());
+ ScopeLogger("conversations.size() = %d", conversations.size());
if (!m_is_act) {
return;
}
}
void ConversationsChangeCallback::removed(const ConversationPtrVector& conversations) {
- LoggerD("Entered conversations.size()=%d", conversations.size());
+ ScopeLogger("conversations.size() = %d", conversations.size());
if (!m_is_act) {
return;
}
} // anonymous namespace
EmailManager::EmailManager() : m_slot_size(-1), m_is_initialized(false) {
- LoggerD("Entered");
+ ScopeLogger();
}
EmailManager& EmailManager::getInstance() {
- LoggerD("Entered");
+ ScopeLogger();
static EmailManager instance;
return instance;
}
}
PlatformResult EmailManager::InitializeEmailService() {
- LoggerD("Entered");
+ ScopeLogger();
EmailManager& instance = EmailManager::getInstance();
if (!instance.m_is_initialized) {
}
EmailManager::~EmailManager() {
- LoggerD("Entered");
+ ScopeLogger();
}
PlatformResult EmailManager::addDraftMessagePlatform(int account_id,
std::shared_ptr<Message> message) {
- LoggerD("Entered");
+ ScopeLogger();
return addMessagePlatform(account_id, message, EMAIL_MAILBOX_TYPE_DRAFT);
}
PlatformResult EmailManager::addOutboxMessagePlatform(int account_id,
std::shared_ptr<Message> message) {
+ ScopeLogger();
return addMessagePlatform(account_id, message, EMAIL_MAILBOX_TYPE_OUTBOX);
}
PlatformResult EmailManager::addMessagePlatform(int account_id, std::shared_ptr<Message> message,
email_mailbox_type_e mailbox_type) {
- LoggerD("Entered");
+ ScopeLogger();
email_mail_data_t* mail_data = NULL;
email_mail_data_t* mail_data_final = NULL;
int err = EMAIL_ERROR_NONE;
}
static gboolean addDraftMessageCompleteCB(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
MessageCallbackUserData* callback = static_cast<MessageCallbackUserData*>(data);
if (!callback) {
LoggerE("Callback is null");
}
void EmailManager::addDraftMessage(MessageCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
//**** sending email ****
static gboolean sendEmailCompleteCB(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
MessageRecipientsCallbackData* callback = static_cast<MessageRecipientsCallbackData*>(data);
if (!callback) {
}
PlatformResult EmailManager::sendMessage(MessageRecipientsCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
void EmailManager::sendStatusCallback(int mail_id, email_noti_on_network_event status,
int error_code) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(m_mutex);
// find first request for this mail_id
}
email_mail_data_t* EmailManager::loadMessage(int msg_id) {
- LoggerD("Entered");
+ ScopeLogger();
email_mail_data_t* mail_data = NULL;
int err = email_get_mail_data(msg_id, &mail_data);
if (EMAIL_ERROR_NONE != err) {
}
EmailManager::SendReqMapIterator EmailManager::getSendRequest(int mail_id) {
- LoggerD("Entered");
+ ScopeLogger();
for (auto it = m_sendRequests.begin(); it != m_sendRequests.end(); it++) {
if (it->second->getMessage()->getId() == mail_id) {
return it;
}
void EmailManager::freeMessage(email_mail_data_t* mail_data) {
- LoggerD("Entered");
+ ScopeLogger();
if (!mail_data) {
return;
}
}
void EmailManager::loadMessageBody(MessageBodyCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
return;
}
PlatformResult EmailManager::loadMessageAttachment(MessageAttachmentCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Callback is null");
//#################################### sync: ###################################
void EmailManager::sync(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
SyncCallbackData* callback = static_cast<SyncCallbackData*>(data);
//################################## syncFolder: ###############################
void EmailManager::syncFolder(SyncFolderCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
//################################## stopSync: #################################
void EmailManager::stopSync(long op_id) {
- LoggerD("Entered");
+ ScopeLogger();
SyncCallbackData* callback = static_cast<SyncCallbackData*>(m_proxy_sync->getCallback(op_id));
//################################## ^stopSync #################################
void EmailManager::RemoveSyncCallback(long op_id) {
- LoggerD("Entered");
+ ScopeLogger();
m_proxy_sync->removeCallback(op_id);
}
void EmailManager::RemoveCallbacksByQueue(const PostQueue& q) {
- LoggerD("Entered");
+ ScopeLogger();
for (auto it = m_sendRequests.begin(); it != m_sendRequests.end();) {
if (it->second->HasQueue(q)) {
}
void removeEmailCompleteCB(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
return;
EmailManager::DeleteReqVector::iterator EmailManager::getDeleteRequest(
const std::vector<int>& ids) {
- LoggerD("Entered");
+ ScopeLogger();
for (auto idIt = ids.begin(); idIt != ids.end(); ++idIt) {
for (auto reqIt = m_deleteRequests.begin(); reqIt != m_deleteRequests.end(); ++reqIt) {
MessagePtrVector msgs = reqIt->callback->getMessages();
void EmailManager::removeStatusCallback(const std::vector<int>& ids,
email_noti_on_storage_event status) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(m_mutex);
DeleteReqVector::iterator it = getDeleteRequest(ids);
if (it != m_deleteRequests.end()) {
}
PlatformResult EmailManager::RemoveMessagesPlatform(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
int error;
email_mail_data_t* mail = NULL;
}
void EmailManager::removeMessages(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
PlatformResult EmailManager::UpdateMessagesPlatform(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
int error;
email_mail_data_t* mail = NULL;
SCOPE_EXIT {
}
void EmailManager::updateMessages(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
PlatformResult EmailManager::FindMessagesPlatform(FindMsgCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
email_mail_data_t* mailList = NULL;
int mailListCount = 0;
}
void EmailManager::findMessages(FindMsgCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
PlatformResult EmailManager::FindConversationsPlatform(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
int convListCount = 0;
std::lock_guard<std::mutex> lock(m_mutex);
}
void EmailManager::findConversations(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
long EmailManager::getUniqueOpId() {
- LoggerD("Entered");
+ ScopeLogger();
// mutex is created only on first call (first call added to constructor
// to initialize mutex correctly)
static std::mutex op_id_mutex;
}
PlatformResult EmailManager::FindFoldersPlatform(FoldersCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
int ret = EMAIL_ERROR_UNKNOWN;
int account_id = ACCOUNT_ID_NOT_INITIALIZED;
email_mailbox_t* mailboxes = NULL;
}
void EmailManager::findFolders(FoldersCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
PlatformResult EmailManager::RemoveConversationsPlatform(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
int error;
std::lock_guard<std::mutex> lock(m_mutex);
std::vector<std::shared_ptr<MessageConversation>> conversations = callback->getConversations();
}
void EmailManager::removeConversations(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
std::string EmailManager::getMessageStatus(int id) {
- LoggerD("Entered");
+ ScopeLogger();
email_mail_data_t* mail = nullptr;
MessageStatus status = MessageStatus::STATUS_UNDEFINED;
m_offset(0),
m_account_id(0),
m_service_type(UNDEFINED) {
- LoggerD("Entered");
+ ScopeLogger();
}
FindMsgCallbackUserData::~FindMsgCallbackUserData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void FindMsgCallbackUserData::setFilter(AbstractFilterPtr filter) {
namespace messaging {
FoldersCallbackData::~FoldersCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void FoldersCallbackData::addFolder(std::shared_ptr<MessageFolder> folder) {
+ ScopeLogger();
m_folders.push_back(folder);
}
m_id(service_id),
m_msg_type(service_type),
m_is_act(true) {
- LoggerD("Entered");
+ ScopeLogger();
m_callback_data.SetListenerId("FoldersChangeListener");
}
FoldersChangeCallback::~FoldersChangeCallback() {
- LoggerD("Entered");
+ ScopeLogger();
}
FolderPtrVector FoldersChangeCallback::filterFolders(tizen::AbstractFilterPtr filter,
const FolderPtrVector& source_folders) {
- LoggerD("Entered");
+ ScopeLogger();
if (filter) {
LoggerD("filter pointer is valid");
FolderPtrVector filtered_folders;
}
void FoldersChangeCallback::added(const FolderPtrVector& folders) {
- LoggerD("Entered folders.size()=%d", folders.size());
+ ScopeLogger("folders.size() = %d", folders.size());
if (!m_is_act) {
return;
}
}
void FoldersChangeCallback::updated(const FolderPtrVector& folders) {
- LoggerD("Entered folders.size()=%d", folders.size());
+ ScopeLogger("folders.size() = %d", folders.size());
if (!m_is_act) {
return;
}
}
void FoldersChangeCallback::removed(const FolderPtrVector& folders) {
- LoggerD("Entered folders.size()=%d", folders.size());
+ ScopeLogger("folders.size() = %d", folders.size());
if (!m_is_act) {
return;
}
m_service_id_set(false),
m_status(STATUS_UNDEFINED),
m_sim_index(TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN) {
- LoggerD("Message constructor (%p)", this);
+ ScopeLogger("Message constructor (%p)", this);
}
Message::~Message() {
- LoggerD("Message destructor (%p)", this);
+ ScopeLogger("Message destructor (%p)", this);
}
// *** attribute getters
}
int Message::getFolderId() const {
- LoggerD("Entered");
return m_folder_id;
}
int Message::getFolderIdForUser() const {
- LoggerD("Entered");
+ ScopeLogger();
// WIDL states:
// For SMS and MMS, folderId can be one of these values:
// - INBOX = 1,
// *** attributes setters
void Message::setId(int id) {
- LoggerD("Entered");
+ ScopeLogger();
m_id = id;
m_id_set = true;
m_body->setMessageId(m_id);
}
void Message::setOldId(int id) {
- LoggerD("Entered");
+ ScopeLogger();
m_old_id = id;
}
void Message::setConversationId(int id) {
- LoggerD("Entered");
+ ScopeLogger();
m_conversation_id = id;
m_conversation_id_set = true;
}
void Message::setFolderId(int id) {
- LoggerD("Entered");
+ ScopeLogger();
m_folder_id = id;
m_folder_id_set = true;
}
// type setting not allowed - no setter for type
void Message::setTimeStamp(time_t timestamp) {
- LoggerD("Entered");
+ ScopeLogger();
m_timestamp = timestamp;
m_timestamp_set = true;
}
void Message::setFrom(std::string from) {
- LoggerD("Entered");
+ ScopeLogger();
m_from = from;
m_from_set = true;
}
void Message::setTO(std::vector<std::string>& to) {
- LoggerD("Entered");
+ ScopeLogger();
// Recipient's format validation should be done by Core API service
m_to = to;
}
void Message::setBody(std::shared_ptr<MessageBody>& body) {
- LoggerD("Entered");
// while replacing message body old body should have some invalid id mark
m_body->setMessageId(-1);
}
void Message::setIsRead(bool read) {
- LoggerD("Entered");
m_is_read = read;
}
// has attachment can't be set explicity -> no setter for this flag
void Message::setIsHighPriority(bool highpriority) {
- LoggerD("Entered");
// High priority field is used only in MessageEmail
m_high_priority = highpriority;
}
}
void Message::setInResponseTo(int inresp) {
- LoggerD("Entered");
m_in_response = inresp;
m_in_response_set = true;
}
void Message::setMessageStatus(MessageStatus status) {
- LoggerD("Entered");
m_status = status;
}
}
void Message::setServiceId(int service_id) {
- LoggerD("Entered");
m_service_id = service_id;
m_service_id_set = true;
}
void Message::setSimIndex(TelNetworkDefaultDataSubs_t sim_index) {
- LoggerD("Entered");
m_sim_index = sim_index;
}
}
std::string Message::convertEmailRecipients(const std::vector<std::string>& recipients) {
- LoggerD("Entered");
+ ScopeLogger();
std::string address = "";
unsigned size = recipients.size();
for (unsigned i = 0; i < size; ++i) {
}
PlatformResult saveToTempFile(const std::string& data, std::string* file_name) {
- LoggerD("Entered");
+ ScopeLogger();
char buf[] = "XXXXXX";
mode_t mask = umask(S_IWGRP | S_IWOTH);
}
PlatformResult copyFileToTemp(const std::string& sourcePath, std::string* result_path) {
- LoggerD("Entered");
+ ScopeLogger();
char buf[] = "XXXXXX";
std::string fileName, attPath, tmpPath;
}
PlatformResult removeDirFromTemp(const std::string& dirPath) {
- LoggerD("Entered");
+ ScopeLogger();
if (EINA_TRUE != ecore_file_recursive_rm(dirPath.c_str())) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
"Unknown error while deleting temp directory.");
PlatformResult Message::convertPlatformEmail(std::shared_ptr<Message> message,
email_mail_data_t** result_mail_data) {
- LoggerD("Entered");
+ ScopeLogger();
email_mail_data_t* mail_data = nullptr;
if (EMAIL != message->getType()) {
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Invalid type.");
PlatformResult addSingleEmailAttachment(std::shared_ptr<Message> message,
std::shared_ptr<MessageAttachment> att,
AttachmentType attType) {
- LoggerD("Entered");
+ ScopeLogger();
std::string dirPath = "";
PlatformResult ret = copyFileToTemp(att->getFilePath(), &dirPath);
if (ret.IsError()) return ret;
}
PlatformResult Message::addEmailAttachments(std::shared_ptr<Message> message) {
- LoggerD("Entered");
+ ScopeLogger();
int attachment_data_count = 0, error;
email_mail_data_t* mail = NULL;
PlatformResult Message::addSMSRecipientsToStruct(const std::vector<std::string>& recipients,
msg_struct_t& msg) {
- LoggerD("Entered");
+ ScopeLogger();
const unsigned size = recipients.size();
for (unsigned int i = 0; i < size; ++i) {
char* address = const_cast<char*>(recipients.at(i).c_str());
PlatformResult Message::addMMSRecipientsToStruct(const std::vector<std::string>& recipients,
msg_struct_t& msg, int type) {
- LoggerD("Entered");
+ ScopeLogger();
const unsigned size = recipients.size();
for (unsigned int i = 0; i < size; ++i) {
msg_struct_t tmpAddr = NULL;
PlatformResult Message::addMMSBodyAndAttachmentsToStruct(const AttachmentPtrVector& attach,
msg_struct_t& mms_struct,
Message* message) {
- LoggerD("Entered with %d attachments", attach.size());
+ ScopeLogger("attachments.size() = %zd", attach.size());
int size = attach.size();
for (int i = 0; i < size; i++) {
PlatformResult Message::convertPlatformShortMessageToStruct(Message* message, msg_handle_t handle,
msg_struct_t* result_msg) {
- LoggerD("Entered");
+ ScopeLogger();
int ntv_ret = 0;
// Set message if is read
msg_set_bool_value(msg, MSG_MESSAGE_READ_BOOL, message->getIsRead());
- LoggerD("End");
*result_msg = msg;
msg_ptr.release(); // release ownership
return PlatformResult(ErrorCode::NO_ERROR);
}
std::string Message::getShortMsgSenderFromStruct(msg_struct_t& msg) {
- LoggerD("Entered");
+ ScopeLogger();
msg_list_handle_t addr_list = NULL;
msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_HND, (void**)&addr_list);
PlatformResult Message::getSMSRecipientsFromStruct(msg_struct_t& msg,
std::vector<std::string>* result_address) {
- LoggerD("Entered");
+ ScopeLogger();
std::vector<std::string> address;
msg_list_handle_t addr_list = NULL;
int ntv_ret = msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_HND, (void**)&addr_list);
PlatformResult Message::getMMSRecipientsFromStruct(msg_struct_t& msg, int type,
std::vector<std::string>* result_address) {
- LoggerD("Entered");
+ ScopeLogger();
std::vector<std::string> address;
msg_list_handle_t addr_list = NULL;
int ntv_ret = msg_get_list_handle(msg, MSG_MESSAGE_ADDR_LIST_HND, (void**)&addr_list);
}
PlatformResult Message::setMMSBodyAndAttachmentsFromStruct(Message* message, msg_struct_t& msg) {
- LoggerD("Entered message(%p)", message);
+ ScopeLogger("message(%p)", message);
int tempInt = 0;
char infoStr[MSG_FILEPATH_LEN_MAX + 1];
PlatformResult Message::convertPlatformShortMessageToObject(msg_struct_t msg,
Message** result_message) {
- LoggerD("Entered");
+ ScopeLogger();
std::unique_ptr<Message> message;
int infoInt;
bool infoBool;
}
PlatformResult Message::findShortMessageById(const int id, MessagePtr* message) {
- LoggerD("Entered");
+ ScopeLogger();
msg_struct_t msg;
PlatformResult ret = ShortMsgManager::getInstance().getMessage(id, &msg);
if (ret.IsError()) {
}
std::vector<std::string> Message::split(const std::string& input, char delimiter) {
- LoggerD("Entered");
+ ScopeLogger();
std::vector<std::string> ret;
std::stringstream stream(input);
std::string item;
}
std::vector<std::string> Message::getEmailRecipientsFromStruct(const char* recipients) {
- LoggerD("Entered");
+ ScopeLogger();
std::vector<std::string> tmp = Message::split(recipients, ';');
for (std::vector<std::string>::iterator it = tmp.begin(); it != tmp.end(); ++it) {
*it = MessagingUtil::ltrim(*it);
}
std::shared_ptr<MessageBody> Message::convertEmailToMessageBody(email_mail_data_t& mail) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<MessageBody> body(new MessageBody());
body->updateBody(mail);
return body;
PlatformResult Message::convertEmailToMessageAttachment(email_mail_data_t& mail,
AttachmentPtrVector* att) {
- LoggerD("Entered");
+ ScopeLogger();
email_attachment_data_t* attachment = NULL;
int attachmentCount = 0;
PlatformResult Message::convertPlatformEmailToObject(email_mail_data_t& mail,
std::shared_ptr<Message>* result) {
- LoggerD("Entered");
+ ScopeLogger();
Message* message = new MessageEmail();
PlatformResult ret = message->updateEmailMessage(mail);
if (ret.IsError()) {
bool Message::isMatchingAttribute(const std::string& attribute_name,
const FilterMatchFlag match_flag, AnyPtr match_value) const {
- LoggerD("Entered");
+ ScopeLogger();
auto key = match_value->toString();
LoggerD("attribute_name:%s match_flag:%d matchValue:%s", attribute_name.c_str(), match_flag,
key.c_str());
bool Message::isMatchingAttributeRange(const std::string& attribute_name, AnyPtr initial_value,
AnyPtr end_value) const {
- LoggerD("Entered attribute_name: %s", attribute_name.c_str());
+ ScopeLogger(attribute_name);
using namespace MESSAGE_FILTER_ATTRIBUTE;
if (TIMESTAMP == attribute_name) {
initializeMIMETypeEnumToStringMap();
MessageAttachment::MessageAttachment() {
- LoggerD("MessageAttachment constructor (%p)", this);
+ ScopeLogger("MessageAttachment constructor (%p)", this);
m_id = -1;
m_isIdSet = false;
m_messageId = -1;
}
MessageAttachment::~MessageAttachment() {
- LoggerD("MessageAttachment destructor (%p)", this);
+ ScopeLogger("MessageAttachment destructor (%p)", this);
}
// id
}
std::string MessageAttachment::getShortFileName() const {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_isFilePathSet) {
return "";
}
}
void MessageAttachment::setFilePath(const std::string& value) {
- LoggerD("Entered");
+ ScopeLogger();
m_filePath = common::FilesystemProvider::Create().GetRealPath(value);
m_isFilePathSet = true;
}
std::map<unsigned int, std::string>& MessageAttachment::initializeMIMETypeEnumToStringMap() {
- LoggerD("Entered");
+ ScopeLogger();
static std::map<unsigned int, std::string> enumToString;
// 0
enumToString[MIME_ASTERISK] = "*/*";
}
std::map<std::string, unsigned int>& MessageAttachment::initializeMIMETypeStringToEnumMap() {
- LoggerD("Entered");
+ ScopeLogger();
static std::map<std::string, unsigned int> stringToEnum;
// 0
stringToEnum["*/*"] = MIME_ASTERISK;
}
unsigned int MessageAttachment::MIMETypeStringToEnum(std::string str) {
- LoggerD("Entered");
+ ScopeLogger();
std::map<std::string, unsigned int>::iterator it = MIMETypeStringToEnumMap.find(str);
if (it != MIMETypeStringToEnumMap.end()) {
return it->second;
}
std::string MessageAttachment::MIMETypeEnumToString(unsigned int num) {
- LoggerD("Entered");
+ ScopeLogger();
std::map<unsigned int, std::string>::iterator it = MIMETypeEnumToStringMap.find(num);
if (it != MIMETypeEnumToStringMap.end()) {
return it->second;
}
void MessageAttachment::updateWithAttachmentData(const email_attachment_data_t& attachment_data) {
- LoggerD("Entered");
+ ScopeLogger();
setId(attachment_data.attachment_id);
setMessageId(attachment_data.mail_id);
if (attachment_data.attachment_mime_type) {
MessageBody::MessageBody()
: m_messageId(1), m_messageId_set(false), m_loaded(false), m_plainBody(""), m_htmlBody("") {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageBody::~MessageBody() {
- LoggerD("Entered");
+ ScopeLogger();
}
// messageId
}
PlatformResult MessageBody::updateBody(email_mail_data_t& mail) {
- LoggerD("Entered");
+ ScopeLogger();
setMessageId(mail.mail_id);
setLoaded(mail.body_download_status);
MessageCallbackUserData::MessageCallbackUserData(PostQueue& queue, long cid)
: CallbackUserData(queue, cid), m_account_id(0) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageCallbackUserData::~MessageCallbackUserData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void MessageCallbackUserData::setMessage(std::shared_ptr<Message> message) {
m_unread_messages(0),
m_is_read(false),
m_last_message_id(-1) {
- LoggerD("Message Conversation constructor.");
+ ScopeLogger("Message Conversation constructor.");
}
MessageConversation::~MessageConversation() {
- LoggerD("Message Conversation destructor.");
+ ScopeLogger("Message Conversation destructor.");
}
// *** attributes getters
int MessageConversation::getConversationId() const {
PlatformResult MessageConversation::convertMsgConversationToObject(
unsigned int threadId, msg_handle_t handle, std::shared_ptr<MessageConversation>* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<MessageConversation> conversation(new MessageConversation());
msg_struct_t msgInfo = NULL;
PlatformResult MessageConversation::convertEmailConversationToObject(
unsigned int threadId, std::shared_ptr<MessageConversation>* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<MessageConversation> conversation(new MessageConversation());
email_mail_list_item_t* resultMail = NULL;
bool MessageConversation::isMatchingAttribute(const std::string& attribute_name,
const FilterMatchFlag match_flag,
AnyPtr match_value) const {
- LoggerD("Entered");
+ ScopeLogger();
auto key = match_value->toString();
LoggerD("attribute_name: %s match_flag:%d match_value:%s", attribute_name.c_str(), match_flag,
key.c_str());
bool MessageConversation::isMatchingAttributeRange(const std::string& attribute_name,
AnyPtr initial_value, AnyPtr end_value) const {
- LoggerD("Entered attribute_name: %s", attribute_name.c_str());
+ ScopeLogger("attribute_name: " + attribute_name);
using namespace CONVERSATION_FILTER_ATTRIBUTE;
}
std::string MessageConversation::SanitizeUtf8String(const std::string& input) {
- LoggerD("Entered");
+ ScopeLogger();
std::string result = input;
const gchar* end = nullptr;
using namespace common;
MessageEmail::MessageEmail() : Message() {
- LoggerD("MessageEmail constructor.");
+ ScopeLogger();
this->m_type = MessageType(EMAIL);
}
MessageEmail::~MessageEmail() {
- LoggerD("MessageEmail destructor.");
+ ScopeLogger();
}
// *** overridden methods
int MessageEmail::getFolderIdForUser() const {
- LoggerD("Entered");
+ ScopeLogger();
// in case of e-mails we're using platform IDs directly
return m_folder_id;
}
void MessageEmail::setCC(std::vector<std::string> &cc) {
- LoggerD("Entered");
+ ScopeLogger();
// CC recipient's format validation should be done by email service
m_cc = cc;
}
void MessageEmail::setBCC(std::vector<std::string> &bcc) {
- LoggerD("Entered");
+ ScopeLogger();
// BCC recipient's format validation should be done by email service
m_bcc = bcc;
}
void MessageEmail::setSubject(std::string subject) {
- LoggerD("Entered");
+ ScopeLogger();
m_subject = subject;
}
void MessageEmail::setIsHighPriority(bool highpriority) {
- LoggerD("Entered");
+ ScopeLogger();
m_high_priority = highpriority;
}
void MessageEmail::setMessageAttachments(AttachmentPtrVector &attachments) {
- LoggerD("Entered");
+ ScopeLogger();
m_attachments = attachments;
m_has_attachment = true;
}
PlatformResult MessageEmail::updateEmailMessage(email_mail_data_t &mail) {
- LoggerD("Entered");
+ ScopeLogger();
std::vector<std::string> recp_list;
setId(mail.mail_id);
m_path(path),
m_type(type),
m_synchronizable(synchronizable) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageFolder::MessageFolder(email_mailbox_t mailbox) {
- LoggerD("Entered");
+ ScopeLogger();
m_id = std::to_string(mailbox.mailbox_id);
m_parent_id_set = false;
m_service_id = std::to_string(mailbox.account_id);
}
MessageFolderType MessageFolder::convertPlatformFolderType(email_mailbox_type_e folderType) {
- LoggerD("Entered");
+ ScopeLogger();
switch (folderType) {
case email_mailbox_type_e::EMAIL_MAILBOX_TYPE_INBOX:
return MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX;
bool MessageFolder::isMatchingAttribute(const std::string& attribute_name,
const FilterMatchFlag match_flag,
AnyPtr match_value) const {
- LoggerD("Entered");
+ ScopeLogger();
auto key = match_value->toString();
LoggerD("attribute_name: %s match_flag:%d match_value:%s", attribute_name.c_str(), match_flag,
key.c_str());
bool MessageFolder::isMatchingAttributeRange(const std::string& attribute_name,
AnyPtr initial_value, AnyPtr end_value) const {
- LoggerD("Entered");
+ ScopeLogger();
LoggerD("attribute_name: %s NOT SUPPORTED", attribute_name.c_str());
return false;
}
namespace messaging {
MessageMMS::MessageMMS() : Message() {
- LoggerD("MessageMMS constructor.");
+ ScopeLogger();
this->m_type = MessageType(MessageType(MMS));
}
MessageMMS::~MessageMMS() {
- LoggerD("MessageMMS destructor.");
+ ScopeLogger();
}
// *** overrided methods
void MessageMMS::setCC(std::vector<std::string> &cc) {
- LoggerD("Entered");
+ ScopeLogger();
// CC recipient's format validation should be done by email service
m_cc = cc;
}
void MessageMMS::setBCC(std::vector<std::string> &bcc) {
- LoggerD("Entered");
+ ScopeLogger();
// BCC recipient's format validation should be done by email service
m_bcc = bcc;
}
void MessageMMS::setMessageAttachments(AttachmentPtrVector &attachments) {
- LoggerD("Entered");
+ ScopeLogger();
m_attachments = attachments;
m_has_attachment = true;
}
bool MessageMMS::getHasAttachment() const {
- LoggerD("MessageMMS::getHasAttachment()");
+ ScopeLogger("MessageMMS::getHasAttachment()");
return m_has_attachment;
}
m_account_id(-1),
m_sim_index(TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN),
m_default_sim_index(TAPI_NETWORK_DEFAULT_DATA_SUBS_UNKNOWN) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageRecipientsCallbackData::~MessageRecipientsCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void MessageRecipientsCallbackData::setMessage(std::shared_ptr<Message> message) {
}
bool MessageRecipientsCallbackData::setSimIndex(int sim_index) {
- LoggerD("Entered");
+ ScopeLogger();
char** cp_list = tel_get_cp_name_list();
int sim_count = 0;
if (cp_list) {
BaseMessageServiceCallbackData::BaseMessageServiceCallbackData(PostQueue& queue, long cid)
: CallbackUserData(queue, cid), m_op_handle(-1) {
- LoggerD("Entered");
+ ScopeLogger();
}
BaseMessageServiceCallbackData::~BaseMessageServiceCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void BaseMessageServiceCallbackData::setOperationHandle(const int op_handle) {
//#################### MessageBodyCallbackData ####################
MessageBodyCallbackData::~MessageBodyCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void MessageBodyCallbackData::setMessage(std::shared_ptr<Message> message) {
MessageAttachmentCallbackData::MessageAttachmentCallbackData(PostQueue& queue, long cid)
: BaseMessageServiceCallbackData(queue, cid), m_nth(0) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageAttachmentCallbackData::~MessageAttachmentCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void MessageAttachmentCallbackData::setMessageAttachment(
m_limit(0),
m_op_id(-1),
m_account_id(-1) {
- LoggerD("Entered");
+ ScopeLogger();
}
SyncCallbackData::~SyncCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void SyncCallbackData::setLimit(const unsigned long limit) {
//#################### SyncFolderCallbackData ####################
SyncFolderCallbackData::~SyncFolderCallbackData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void SyncFolderCallbackData::setMessageFolder(std::shared_ptr<MessageFolder> message_folder) {
MessageService::MessageService(int id, MessageType msgType, const std::string& name)
: m_id(id), m_msg_type(msgType), m_name(name) {
- LoggerD("Entered");
+ ScopeLogger();
switch (msgType) {
case MessageType::SMS:
case MessageType::MMS:
}
MessageService::~MessageService() {
- LoggerD("Entered");
+ ScopeLogger();
}
picojson::object MessageService::toPicoJS() const {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object picojs = picojson::object();
picojs[JSON_SERVICE_ID] = picojson::value(std::to_string(m_id));
picojs[JSON_SERVICE_TYPE] = picojson::value(getMsgServiceTypeString());
MessageServiceEmail::MessageServiceEmail(int id, std::string name)
: MessageService(id, MessageType::EMAIL, name) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageServiceEmail::~MessageServiceEmail() {
- LoggerD("Entered");
+ ScopeLogger();
for (auto id : registered_callbacks_) {
// this may internally fail, because we don't have information about
}
static gboolean sendMessageTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
auto ret =
EmailManager::getInstance().sendMessage(static_cast<MessageRecipientsCallbackData*>(data));
}
PlatformResult MessageServiceEmail::sendMessage(MessageRecipientsCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
}
static gboolean loadMessageBodyTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
EmailManager::getInstance().loadMessageBody(static_cast<MessageBodyCallbackData*>(data));
}
PlatformResult MessageServiceEmail::loadMessageBody(MessageBodyCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
}
}
static gboolean loadMessageAttachmentTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
auto callback = static_cast<MessageAttachmentCallbackData*>(data);
}
PlatformResult MessageServiceEmail::loadMessageAttachment(MessageAttachmentCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
guint id = g_idle_add(loadMessageAttachmentTask, static_cast<void*>(callback));
if (!id) {
delete callback;
}
static gboolean syncTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
EmailManager::getInstance().sync(data);
}
PlatformResult MessageServiceEmail::sync(SyncCallbackData* callback, long* operation_id) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
}
static gboolean syncFolderTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
EmailManager::getInstance().syncFolder(static_cast<SyncFolderCallbackData*>(data));
PlatformResult MessageServiceEmail::syncFolder(SyncFolderCallbackData* callback,
long* operation_id) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
}
}
static gboolean stopSyncTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
if (!data) {
LoggerE("opId is null");
}
PlatformResult MessageServiceEmail::stopSync(long op_id) {
- LoggerD("Entered");
+ ScopeLogger();
registered_callbacks_.erase(op_id);
long* data = new long(op_id);
MessageServiceShortMsg::MessageServiceShortMsg(int id, MessageType msgType)
: MessageService(id, msgType, MessagingUtil::messageTypeToString(msgType)) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageServiceShortMsg::~MessageServiceShortMsg() {
- LoggerD("Entered");
+ ScopeLogger();
}
static gboolean sendMessageThread(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
auto ret =
ShortMsgManager::getInstance().sendMessage(static_cast<MessageRecipientsCallbackData*>(data));
}
PlatformResult MessageServiceShortMsg::sendMessage(MessageRecipientsCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
}
}
static gboolean loadMessageBodyTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
MessageBodyCallbackData* callback = static_cast<MessageBodyCallbackData*>(data);
if (!callback) {
LoggerE("callback is NULL");
}
PlatformResult MessageServiceShortMsg::loadMessageBody(MessageBodyCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
}
}
MessageServiceShortMsg* MessageServiceShortMsg::GetMmsMessageService() {
+ ScopeLogger();
return new (std::nothrow)
MessageServiceShortMsg(MessageServiceAccountId::MMS_ACCOUNT_ID, MessageType::MMS);
}
MessageServiceShortMsg* MessageServiceShortMsg::GetSmsMessageService() {
+ ScopeLogger();
return new (std::nothrow)
MessageServiceShortMsg(MessageServiceAccountId::SMS_ACCOUNT_ID, MessageType::SMS);
}
namespace messaging {
MessageSMS::MessageSMS() : Message() {
- LoggerD("MessageSMS constructor.");
+ ScopeLogger();
this->m_type = MessageType(MessageType(SMS));
}
MessageSMS::~MessageSMS() {
- LoggerD("MessageSMS destructor.");
+ ScopeLogger();
}
} // messaging
namespace messaging {
MessageStorage::MessageStorage(int id, MessageType msgType) : m_id(id), m_msg_type(msgType) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageStorage::~MessageStorage() {
- LoggerD("Entered");
+ ScopeLogger();
for (auto id : registered_listeners_) {
ChangeListenerContainer::getInstance().removeChangeListener(id);
}
int MessageStorage::getMsgServiceId() const {
- LoggerD("Entered");
+ ScopeLogger();
return m_id;
}
MessageType MessageStorage::getMsgServiceType() const {
- LoggerD("Entered");
+ ScopeLogger();
return m_msg_type;
}
}
long MessageStorage::addMessagesChangeListener(std::shared_ptr<MessagesChangeCallback> callback) {
- LoggerD("Entered");
+ ScopeLogger();
long id = ChangeListenerContainer::getInstance().addMessageChangeListener(callback);
registered_listeners_.insert(id);
return id;
long MessageStorage::addConversationsChangeListener(
std::shared_ptr<ConversationsChangeCallback> callback) {
- LoggerD("Entered");
+ ScopeLogger();
long id = ChangeListenerContainer::getInstance().addConversationChangeListener(callback);
registered_listeners_.insert(id);
return id;
}
long MessageStorage::addFoldersChangeListener(std::shared_ptr<FoldersChangeCallback> callback) {
- LoggerD("Entered");
+ ScopeLogger();
long id = ChangeListenerContainer::getInstance().addFolderChangeListener(callback);
registered_listeners_.insert(id);
return id;
}
void MessageStorage::removeChangeListener(long watchId) {
- LoggerD("Entered");
+ ScopeLogger();
ChangeListenerContainer::getInstance().removeChangeListener(watchId);
registered_listeners_.erase(watchId);
}
namespace messaging {
MessageStorageEmail::MessageStorageEmail(int id) : MessageStorage(id, MessageType::EMAIL) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageStorageEmail::~MessageStorageEmail() {
- LoggerD("Entered");
+ ScopeLogger();
}
static gboolean addDraftMessageTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
MessageCallbackUserData* callback = static_cast<MessageCallbackUserData*>(data);
EmailManager::getInstance().addDraftMessage(callback);
}
void MessageStorageEmail::addDraftMessage(MessageCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean removeMessagesTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
MessagesCallbackUserData* callback = static_cast<MessagesCallbackUserData*>(data);
EmailManager::getInstance().removeMessages(callback);
}
void MessageStorageEmail::removeMessages(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean updateMessagesTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
MessagesCallbackUserData* callback = static_cast<MessagesCallbackUserData*>(data);
EmailManager::getInstance().updateMessages(callback);
}
void MessageStorageEmail::updateMessages(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean findMessagesTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
FindMsgCallbackUserData* callback = static_cast<FindMsgCallbackUserData*>(data);
EmailManager::getInstance().findMessages(callback);
}
void MessageStorageEmail::findMessages(FindMsgCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean findConversationsTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
ConversationCallbackData* callback = static_cast<ConversationCallbackData*>(data);
EmailManager::getInstance().findConversations(callback);
}
void MessageStorageEmail::findConversations(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean removeConversationsTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
ConversationCallbackData* callback = static_cast<ConversationCallbackData*>(data);
EmailManager::getInstance().removeConversations(callback);
}
void MessageStorageEmail::removeConversations(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean findFoldersTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
FoldersCallbackData* callback = static_cast<FoldersCallbackData*>(data);
EmailManager::getInstance().findFolders(callback);
}
void MessageStorageEmail::findFolders(FoldersCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
MessageStorageShortMsg::MessageStorageShortMsg(int id, MessageType msgType)
: MessageStorage(id, msgType) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessageStorageShortMsg::~MessageStorageShortMsg() {
- LoggerD("Entered");
+ ScopeLogger();
}
static gboolean addDraftMessageTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
MessageCallbackUserData* callback = static_cast<MessageCallbackUserData*>(data);
ShortMsgManager::getInstance().addDraftMessage(callback);
}
void MessageStorageShortMsg::addDraftMessage(MessageCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean removeMessagesTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
MessagesCallbackUserData* callback = static_cast<MessagesCallbackUserData*>(data);
ShortMsgManager::getInstance().removeMessages(callback);
}
void MessageStorageShortMsg::removeMessages(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean updateMessagesTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
MessagesCallbackUserData* callback = static_cast<MessagesCallbackUserData*>(data);
ShortMsgManager::getInstance().updateMessages(callback);
}
void MessageStorageShortMsg::updateMessages(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean findMessagesTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
FindMsgCallbackUserData* callback = static_cast<FindMsgCallbackUserData*>(data);
ShortMsgManager::getInstance().findMessages(callback);
}
void MessageStorageShortMsg::findMessages(FindMsgCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean findConversationsTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
ConversationCallbackData* callback = static_cast<ConversationCallbackData*>(data);
ShortMsgManager::getInstance().findConversations(callback);
}
void MessageStorageShortMsg::findConversations(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean removeConversationsTask(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
ConversationCallbackData* callback = static_cast<ConversationCallbackData*>(data);
ShortMsgManager::getInstance().removeConversations(callback);
}
void MessageStorageShortMsg::removeConversations(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
static gboolean findFoldersCB(void* data) {
- LoggerD("Entered");
+ ScopeLogger();
FoldersCallbackData* callback = static_cast<FoldersCallbackData*>(data);
}
void MessageStorageShortMsg::findFolders(FoldersCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
return;
MessagesCallbackUserData::MessagesCallbackUserData(PostQueue& queue, long cid,
bool keep /* = false*/)
: CallbackUserData(queue, cid, keep), m_service_type(UNDEFINED) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessagesCallbackUserData::~MessagesCallbackUserData() {
- LoggerD("Entered");
+ ScopeLogger();
}
void MessagesCallbackUserData::addMessage(std::shared_ptr<Message> msg) {
- LoggerD("Entered");
+ ScopeLogger();
m_messages.push_back(msg);
}
namespace {
std::string limitedString(const std::string& src, const size_t max_len = 40) {
- LoggerD("Entered");
+ ScopeLogger();
if (src.length() > max_len) {
return src.substr(0, max_len);
} else {
m_service_id(service_id),
m_msg_type(service_type),
m_is_act(true) {
- LoggerD("Entered");
+ ScopeLogger();
m_callback_data.SetListenerId("MessagesChangeListener");
}
MessagesChangeCallback::~MessagesChangeCallback() {
- LoggerD("Entered");
+ ScopeLogger();
}
MessagePtrVector MessagesChangeCallback::filterMessages(tizen::AbstractFilterPtr filter,
const MessagePtrVector& source_messages,
const int service_id) {
- LoggerD("Entered sourceMessages.size():%d filter:%s", source_messages.size(),
- (filter ? "PRESENT" : "NULL"));
+ ScopeLogger("sourceMessages.size() = %d filter %s", source_messages.size(),
+ (filter ? "PRESENT" : "NULL"));
if (filter) {
MessagePtrVector filtered_messages;
}
void MessagesChangeCallback::added(const MessagePtrVector& msgs) {
- LoggerD("Entered num messages: %d", msgs.size());
+ ScopeLogger("event: msgs.size() = %d", msgs.size());
if (!m_is_act) {
return;
}
}
void MessagesChangeCallback::updated(const MessagePtrVector& msgs) {
- LoggerD("Entered num messages: %d", msgs.size());
+ ScopeLogger("event: msgs.size() = %d", msgs.size());
if (!m_is_act) {
return;
}
}
void MessagesChangeCallback::removed(const MessagePtrVector& msgs) {
- LoggerD("Enter event: msgs.size() = %d", msgs.size());
+ ScopeLogger("event: msgs.size() = %d", msgs.size());
if (!m_is_act) {
return;
}
AttributeInfo::AttributeInfo()
: sql_name(), sql_type(UNDEFINED_TYPE), any_type(PrimitiveType_NoType) {
- LoggerD("Entered");
+ ScopeLogger();
}
AttributeInfo::AttributeInfo(const std::string& in_sql_name, const SQLAttributeType in_sql_type,
const tizen::PrimitiveType in_any_type)
: sql_name(in_sql_name), sql_type(in_sql_type), any_type(in_any_type) {
- LoggerD("Entered");
+ ScopeLogger();
}
AttributeInfo::AttributeInfo(const AttributeInfo& other)
: sql_name(other.sql_name), sql_type(other.sql_type), any_type(other.any_type) {
- LoggerD("Entered");
+ ScopeLogger();
}
AttributeInfo& AttributeInfo::operator=(const AttributeInfo& other) {
}
MessagingDatabaseManager::MessagingDatabaseManager() {
- LoggerD("Entered");
+ ScopeLogger();
// Attributes map for short messages ==========================================
m_msg_attr_map.insert(
std::make_pair("id", AttributeInfo("A.MSG_ID", INTEGER, PrimitiveType_String)));
}
MessagingDatabaseManager::~MessagingDatabaseManager() {
- LoggerD("Entered");
+ ScopeLogger();
}
MessagingDatabaseManager& MessagingDatabaseManager::getInstance() {
- LoggerD("Entered");
+ ScopeLogger();
static MessagingDatabaseManager instance;
return instance;
}
__thread sqlite3_stmt* stmt = NULL;
msg_error_t MessagingDatabaseManager::connect() {
- LoggerD("Entered");
+ ScopeLogger();
if (NULL == sqlHandle) {
char strDBName[64];
}
msg_error_t MessagingDatabaseManager::disconnect() {
- LoggerD("Entered");
+ ScopeLogger();
msg_error_t err = 0;
if (NULL != sqlHandle) {
err = db_util_close(sqlHandle);
msg_error_t MessagingDatabaseManager::getTable(std::string sqlQuery, char*** results,
int* resultsCount) {
- LoggerD("Entered");
+ ScopeLogger();
msg_error_t err = 0;
*resultsCount = 0;
}
void MessagingDatabaseManager::freeTable(char*** results) {
- LoggerD("Entered");
+ ScopeLogger();
if (*results) {
sqlite3_free_table(*results);
*results = NULL;
}
int MessagingDatabaseManager::cellToInt(char** array, int cellId) {
- LoggerD("Entered");
+ ScopeLogger();
if (NULL == array) {
LoggerD("Array is NULL");
return 0;
std::string MessagingDatabaseManager::getMatchString(tizen::AnyPtr match_value,
const PrimitiveType type) const {
- LoggerD("Entered");
+ ScopeLogger();
if (!match_value) {
LoggerD("Warning: match value is NULL");
return std::string();
AttributeInfoMap& attribute_map,
MessageType msgType,
std::string* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::ostringstream sqlQuery;
AttributeFilterPtr attr_filter = castToAttributeFilter(filter);
PlatformResult MessagingDatabaseManager::getAttributeRangeFilterQuery(
AbstractFilterPtr filter, AttributeInfoMap& attribute_map, MessageType msg_type,
std::string* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::ostringstream sql_query, converter;
std::string initial_value, end_value;
AttributeInfoMap& attribute_map,
MessageType msg_type,
std::string* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::ostringstream sql_query;
CompositeFilterPtr comp_filter = castToCompositeFilter(filter);
long limit, long offset,
AttributeInfoMap& attribute_map,
MessageType msg_type, std::string* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::ostringstream sql_query;
// Service type query
PlatformResult MessagingDatabaseManager::findShortMessages(FindMsgCallbackUserData* callback,
std::vector<int>* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::ostringstream sqlQuery;
int attributesCount = 1; // It has to be set manually each time when the query is changed
int cellId = attributesCount;
PlatformResult MessagingDatabaseManager::findEmails(FindMsgCallbackUserData* callback,
std::pair<int, email_mail_data_t*>* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::ostringstream sqlWhereClause;
int resultsCount;
email_mail_data_t* results;
PlatformResult MessagingDatabaseManager::findShortMessageConversations(
ConversationCallbackData* callback, std::vector<int>* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::ostringstream sqlQuery;
int attributesCount = 1; // It has to be set manually each time when the query is changed
int cellId = attributesCount;
PlatformResult MessagingDatabaseManager::findEmailConversations(
ConversationCallbackData* callback, std::vector<EmailConversationInfo>* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::ostringstream sqlWhereClause;
int resultsCount;
email_mail_data_t* results;
}
MessagingExtension::MessagingExtension() {
- LoggerD("Entered");
+ ScopeLogger();
SetExtensionName(kMessaging);
SetJavaScriptAPI(kSource_messaging_api);
const char* entry_points[] = {kMessage, kMessageAttachment, NULL};
}
MessagingExtension::~MessagingExtension() {
- LoggerD("Entered");
+ ScopeLogger();
}
common::Instance* MessagingExtension::CreateInstance() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = extension::messaging::EmailManager::InitializeEmailService();
if (ret.IsError()) {
LoggerE("Initializing the email service failed (%s)", ret.message().c_str());
}
MessagingInstance::MessagingInstance() : manager_(*this), queue_(*this) {
- LoggerD("Entered");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
#define REGISTER_ASYNC(c, x) RegisterSyncHandler(c, std::bind(&MessagingInstance::x, this, _1, _2));
}
MessagingInstance::~MessagingInstance() {
- LoggerD("Entered");
+ ScopeLogger();
}
#define POST_AND_RETURN(ret, json, obj) \
}
void MessagingInstance::GetMessageServices(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageServiceSendMessage(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageServiceLoadMessageBody(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageServiceLoadMessageAttachment(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
}
void MessagingInstance::MessageServiceSync(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageServiceSyncFolder(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
}
void MessagingInstance::MessageServiceStopSync(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, STOP_SYNC_ARGS_OPID, out);
picojson::object data = args.get<picojson::object>();
}
void MessagingInstance::MessageStorageAddDraft(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageStorageFindMessages(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageStorageRemoveMessages(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageStorageUpdateMessages(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageStorageFindConversations(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageStorageRemoveConversations(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingWrite, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageStorageFindFolders(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
CHECK_EXIST(args, JSON_CALLBACK_ID, out);
void MessagingInstance::MessageStorageAddMessagesChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
void MessagingInstance::MessageStorageAddConversationsChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
void MessagingInstance::MessageStorageAddFolderChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
void MessagingInstance::MessageStorageRemoveChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeMessagingRead, &out);
void MessagingInstance::MessageGetMessageStatus(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object data = args.get<picojson::object>();
const int id = stoi(data.at("id").get<std::string>());
sms_service(nullptr),
mms_service(nullptr),
instance_(instance) {
- LoggerD("Entered");
+ ScopeLogger();
}
MessagingManager::MessagingManager(MessagingInstance& instance) : instance_(instance) {
- LoggerD("Entered");
+ ScopeLogger();
int ret = msg_open_msg_handle(&m_msg_handle);
if (ret != MSG_SUCCESS) {
LoggerE("Cannot get message handle: %d", ret);
}
MessagingManager::~MessagingManager() {
- LoggerD("Entered");
+ ScopeLogger();
int ret = msg_close_msg_handle(&m_msg_handle);
if (ret != MSG_SUCCESS) {
LoggerW("Cannot close message handle: %d", ret);
}
static gboolean callbackCompleted(const std::shared_ptr<MsgManagerCallbackData>& user_data) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<picojson::value> response = user_data->json;
common::Instance::PostMessage(&user_data->instance_, response->serialize().c_str());
return false;
}
static void* getMsgServicesThread(const std::shared_ptr<MsgManagerCallbackData>& user_data) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<picojson::value> response = user_data->json;
picojson::object& obj = response->get<picojson::object>();
}
void MessagingManager::getMessageServices(const std::string& type, double callbackId) {
- LoggerD("Entered");
+ ScopeLogger();
auto json = std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
picojson::object& obj = json->get<picojson::object>();
}
MessageService* MessagingManager::getMessageService(const int id) {
+ ScopeLogger();
if (id == m_sms_service.first) {
return m_sms_service.second;
} else if (id == m_mms_service.first) {
} // namespace
std::string MessagingUtil::messageFolderTypeToString(MessageFolderType type) {
- LoggerD("Entered");
+ ScopeLogger();
switch (type) {
case MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX:
return FOLDER_TYPE_INBOX;
}
MessageFolderType MessagingUtil::stringToMessageFolderType(std::string type) {
- LoggerD("Entered");
+ ScopeLogger();
if (FOLDER_TYPE_INBOX == type) {
return MessageFolderType::MESSAGE_FOLDER_TYPE_INBOX;
}
}
PlatformResult MessagingUtil::stringToMessageType(const std::string& str, MessageType* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto it = stringToTypeMap.find(str);
if (it == stringToTypeMap.end()) {
}
common::PlatformResult MessagingUtil::messageTypeToString(MessageType type, std::string* out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto it = typeToStringMap.find(type);
if (it == typeToStringMap.end()) {
}
std::string MessagingUtil::messageTypeToString(MessageType type) {
- LoggerD("Entered");
+ ScopeLogger();
std::string type_str;
PlatformResult platform_result = messageTypeToString(type, &type_str);
Assert(platform_result);
}
std::string MessagingUtil::ltrim(const std::string& input) {
- LoggerD("Entered");
+ ScopeLogger();
std::string str = input;
std::string::iterator i;
for (i = str.begin(); i != str.end(); ++i) {
}
std::string MessagingUtil::extractSingleEmailAddress(const std::string& address) {
- LoggerD("Entered");
+ ScopeLogger();
std::size_t found_begin = address.rfind('<');
std::size_t found_end = address.rfind('>');
// if both '<' and '>' bracket found and '<' is before '>'
std::vector<std::string> MessagingUtil::extractEmailAddresses(
const std::vector<std::string>& addresses) {
- LoggerD("Entered");
+ ScopeLogger();
std::vector<std::string> extractedAddresses;
for (auto it = addresses.begin(); it != addresses.end(); ++it) {
extractedAddresses.push_back(MessagingUtil::extractSingleEmailAddress(*it));
PlatformResult MessagingUtil::loadFileContentToString(const std::string& file_path,
std::string* result) {
- LoggerD("Entered");
+ ScopeLogger();
std::ifstream input_file;
input_file.open(file_path, std::ios::in);
namespace {
std::string GetFilename(const std::string& file_path) {
- LoggerD("Entered");
+ ScopeLogger();
const auto start = file_path.find_last_of("/\\");
const auto basename = file_path.substr(std::string::npos == start ? 0 : start + 1);
return basename.substr(0, basename.find_last_of("."));
}
std::string PerformConversion(const std::string& input, const gchar* from_charset) {
- LoggerD("Entered");
+ ScopeLogger();
GIConv cd = g_iconv_open("UTF-8//IGNORE", from_charset);
std::string MessagingUtil::ConvertToUtf8(const std::string& file_path,
const std::string& contents) {
- LoggerD("Entered");
+ ScopeLogger();
// in case of messages, encoding of the file contents is stored as its filename
// is case of draft messages, it is not...
}
std::string MessagingUtil::messageStatusToString(MessageStatus status) {
- LoggerD("Converting MessageStatus %d to string.", (int)status);
+ ScopeLogger("Converting MessageStatus %d to string.", (int)status);
switch (status) {
case STATUS_SENT:
return SENT;
}
picojson::value MessagingUtil::messageBodyToJson(std::shared_ptr<MessageBody> body) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object b;
b[MESSAGE_BODY_ATTRIBUTE_MESSAGE_ID] = picojson::value(std::to_string(body->getMessageId()));
b[MESSAGE_BODY_ATTRIBUTE_LOADED] = picojson::value(body->getLoaded());
}
picojson::value MessagingUtil::messageToJson(std::shared_ptr<Message> message) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object o;
std::vector<picojson::value> array;
picojson::value MessagingUtil::conversationToJson(
std::shared_ptr<MessageConversation> conversation) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object o;
o[MESSAGE_CONVERSATION_ATTRIBUTE_ID] =
}
picojson::value MessagingUtil::folderToJson(std::shared_ptr<MessageFolder> folder) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object o;
PlatformResult MessagingUtil::jsonToMessage(const picojson::value& json,
std::shared_ptr<Message>* result_message) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<Message> message;
picojson::object data = json.get<picojson::object>();
std::string type = data.at("type").get<std::string>();
}
std::shared_ptr<MessageBody> MessagingUtil::jsonToMessageBody(const picojson::value& json) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<MessageBody> body = std::shared_ptr<MessageBody>(new MessageBody());
picojson::object data = json.get<picojson::object>();
}
std::shared_ptr<MessageFolder> MessagingUtil::jsonToMessageFolder(const picojson::value& json) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object data = json.get<picojson::object>();
}
tizen::SortModePtr MessagingUtil::jsonToSortMode(const picojson::object& json) {
- LoggerD("Entered");
+ ScopeLogger();
using namespace tizen;
const auto it = json.find(JSON_TO_SORT);
PlatformResult MessagingUtil::jsonToAbstractFilter(const picojson::object& json,
tizen::AbstractFilterPtr* result) {
- LoggerD("Entered");
+ ScopeLogger();
const auto it = json.find(JSON_TO_FILTER);
PlatformResult MessagingUtil::jsonFilterToAbstractFilter(const picojson::object& filter,
tizen::AbstractFilterPtr* result) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& type = filter.at(JSON_FILTER_TYPE).get<std::string>();
if (JSON_FILTER_ATTRIBUTE_TYPE == type) {
PlatformResult MessagingUtil::jsonFilterToAttributeFilter(const picojson::object& filter,
tizen::AbstractFilterPtr* result) {
- LoggerD("Entered");
+ ScopeLogger();
using namespace tizen;
PlatformResult MessagingUtil::jsonFilterToAttributeRangeFilter(const picojson::object& filter,
tizen::AbstractFilterPtr* result) {
- LoggerD("Entered");
+ ScopeLogger();
auto name = getValueFromJSONObject<std::string>(filter, JSON_TO_ATTRIBUTE_NAME);
PlatformResult MessagingUtil::jsonFilterToCompositeFilter(const picojson::object& filter,
tizen::AbstractFilterPtr* result) {
- LoggerD("Entered");
+ ScopeLogger();
using namespace tizen;
std::shared_ptr<MessageAttachment> MessagingUtil::jsonToMessageAttachment(
const picojson::value& json) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object data = json.get<picojson::object>();
int attachmentId =
picojson::value MessagingUtil::messageAttachmentToJson(
std::shared_ptr<MessageAttachment> attachment) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object o;
o[MESSAGE_ATTACHMENT_ATTRIBUTE_ID] = attachment->isIdSet()
PlatformResult MessagingUtil::jsonToMessageConversation(
const picojson::value& json, std::shared_ptr<MessageConversation>* result_conversation) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<MessageConversation> conversation;
picojson::object data = json.get<picojson::object>();
std::string type = data.at("type").get<std::string>();
}
PostQueue::PostQueue(MessagingInstance& instance) : instance_(instance) {
- LoggerD("Entered: [%p]", this);
+ ScopeLogger("this: [%p]", this);
}
PostQueue::~PostQueue() {
- LoggerD("Entered: [%p]", this);
+ ScopeLogger("this: [%p]", this);
EmailManager::getInstance().RemoveCallbacksByQueue(*this);
}
void PostQueue::addAndResolve(const long cid, PostPriority priority, const std::string& json) {
- LoggerD("Entered");
+ ScopeLogger();
std::shared_ptr<PostTask> t(new PostTask(priority));
t->attach(json);
}
void PostQueue::add(const long cid, PostPriority priority) {
- LoggerD("Entered");
+ ScopeLogger();
tasks_mutex_.lock();
tasks_.push_back(std::make_pair(cid, std::shared_ptr<PostTask>(new PostTask(priority))));
}
void PostQueue::resolve(const long cid, const std::string& json) {
- LoggerD("Entered: [%p]", this);
+ ScopeLogger("this: [%p]", this);
tasks_mutex_.lock();
}
void PostQueue::resolve(PostPriority p) {
- LoggerD("Entered: [%p]", this);
+ ScopeLogger("this: [%p]", this);
TasksCollection::iterator i;
}
PostQueue::PostTask::PostTask() {
- LoggerD("Entered");
+ ScopeLogger();
priority_ = PostPriority::LOW;
state_ = TaskState::NEW;
}
PostQueue::PostTask::PostTask(PostPriority p) {
- LoggerD("Entered");
+ ScopeLogger();
priority_ = p;
state_ = TaskState::NEW;
}
PostQueue::PostTask::~PostTask() {
- LoggerD("Entered");
+ ScopeLogger();
}
void PostQueue::PostTask::attach(const std::string& j) {
- LoggerD("Entered");
+ ScopeLogger();
if (TaskState::DONE == state_) {
return;
}
}
void PostQueue::PostTask::resolve() {
- LoggerD("Entered");
+ ScopeLogger();
if (TaskState::READY == state_) {
state_ = TaskState::DONE;
}
namespace messaging {
ShortMsgManager& ShortMsgManager::getInstance() {
- LoggerD("Entered");
+ ScopeLogger();
static ShortMsgManager instance;
return instance;
}
static gboolean sendMessageCompleteCB(void* data) {
- LoggerD("Entered callback:%p", data);
+ ScopeLogger("callback:%p", data);
MessageRecipientsCallbackData* callback = static_cast<MessageRecipientsCallbackData*>(data);
if (!callback) {
}
static gboolean addDraftMessageCompleteCB(void* data) {
- LoggerD("Enter");
+ ScopeLogger();
auto callback = static_cast<MessageCallbackUserData*>(data);
if (!callback) {
LoggerE("Callback is null");
}
PlatformResult ShortMsgManager::addDraftMessagePlatform(std::shared_ptr<Message> message) {
- LoggerD("Add new message(%p)", message.get());
+ ScopeLogger("Add new message(%p)", message.get());
// Save platform msg to get ID
msg_struct_t platform_msg = nullptr;
}
PlatformResult ShortMsgManager::SendMessagePlatform(MessageRecipientsCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(m_mutex);
PlatformResult platform_result(ErrorCode::NO_ERROR);
}
PlatformResult ShortMsgManager::sendMessage(MessageRecipientsCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Callback is null");
}
void ShortMsgManager::sendStatusCallback(msg_struct_t sent_status) {
- LoggerD("Entered");
+ ScopeLogger();
int reqId = 0;
int status = MSG_NETWORK_NOT_SEND;
}
static void sent_status_cb(msg_handle_t handle, msg_struct_t sent_status, void* data) {
- LoggerD("Entered");
+ ScopeLogger();
ShortMsgManager::getInstance().sendStatusCallback(sent_status);
return;
PlatformResult ShortMsgManager::callProperEventMessages(
EventMessages* event, msg_storage_change_type_t storageChangeType) {
- LoggerD(
- "Entered event.items.size()=%d event.removed_conversations.size()=%d"
+ ScopeLogger(
+ "event.items.size()=%d event.removed_conversations.size()=%d"
" sChangeType:%d",
event->items.size(), event->removed_conversations.size(), storageChangeType);
void ShortMsgManager::storage_change_cb(msg_handle_t handle,
msg_storage_change_type_t storageChangeType,
msg_id_list_s* pMsgIdList, void* data) {
- LoggerD("Entered handle:%p sChangeType:%d numMsgs:%d", handle, storageChangeType,
- pMsgIdList->nCount);
+ ScopeLogger("handle:%p sChangeType:%d numMsgs:%d", handle, storageChangeType, pMsgIdList->nCount);
if (MSG_STORAGE_CHANGE_CONTACT == storageChangeType) {
LoggerD("storageChangeType is MSG_STORAGE_CHANGE_CONTACT, ignoring");
}
void ShortMsgManager::registerStatusCallback(msg_handle_t msg_handle) {
- LoggerD("Entered");
+ ScopeLogger();
m_msg_handle = msg_handle;
// set message sent status callback
if (MSG_SUCCESS != msg_reg_sent_status_callback(m_msg_handle, &sent_status_cb, NULL)) {
}
void ShortMsgManager::addDraftMessage(MessageCallbackUserData* callback) {
- LoggerD("Enter");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
void ShortMsgManager::removeMessages(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
void ShortMsgManager::updateMessages(MessagesCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
PlatformResult ShortMsgManager::getMessage(int msg_id, msg_struct_t* out_msg) {
- LoggerD("Entered");
+ ScopeLogger();
msg_struct_t sendOpt = msg_create_struct(MSG_STRUCT_SENDOPT);
msg_struct_t msg = msg_create_struct(MSG_STRUCT_MESSAGE_INFO);
PlatformResult ShortMsgManager::getConversationsForMessages(
MessagePtrVector messages, msg_storage_change_type_t storageChangeType,
ConversationPtrVector* result) {
- LoggerD("Entered messages.size()=%d storageChangeType=%d", messages.size(), storageChangeType);
+ ScopeLogger("messages.size()=%d storageChangeType=%d", messages.size(), storageChangeType);
std::unordered_set<int> unique_conv_ids;
ConversationPtrVector convs;
}
void ShortMsgManager::findMessages(FindMsgCallbackUserData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
void ShortMsgManager::findConversations(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
void ShortMsgManager::removeConversations(ConversationCallbackData* callback) {
- LoggerD("Entered");
+ ScopeLogger();
if (!callback) {
LoggerE("Callback is null");
}
ShortMsgManager::ShortMsgManager() : m_msg_handle(NULL) {
- LoggerD("Entered");
+ ScopeLogger();
}
ShortMsgManager::~ShortMsgManager() {
- LoggerD("Entered");
+ ScopeLogger();
LoggerD("m_sms_removed_messages.size() = %d", m_sms_removed_messages.size());
LoggerD("m_mms_removed_messages.size() = %d", m_mms_removed_messages.size());
LoggerD("m_sms_removed_msg_id_conv_id_map.size() = %d", m_sms_removed_msg_id_conv_id_map.size());
LoggerD("m_mms_removed_conv_id_object_map.size() = %d", m_mms_removed_conv_id_object_map.size());
}
std::string ShortMsgManager::getMessageStatus(int id) {
- LoggerD("Entered");
+ ScopeLogger();
msg_struct_t send_opt = nullptr;
msg_struct_t msg = nullptr;
using namespace extension::networkbearerselection;
NetworkBearerSelectionInstance::NetworkBearerSelectionInstance() {
- LoggerD("Entered");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
NetworkBearerSelectionInstance::~NetworkBearerSelectionInstance() {
- LoggerD("Entered");
+ ScopeLogger();
NetworkBearerSelectionManager::GetInstance()->RemoveListener(this);
}
void NetworkBearerSelectionInstance::NetworkBearerSelectionRequestRouteToHost(
const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kNbsPrivileges, &out);
auto request = [=]() -> void {
auto response = [this, domain_name, id](const common::PlatformResult result) -> void {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value value{picojson::object{}};
picojson::object& obj = value.get<picojson::object>();
void NetworkBearerSelectionInstance::NetworkBearerSelectionReleaseRouteToHost(
const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kNbsPrivileges, &out);
auto release = [=]() -> void {
auto response = [this, domain_name, id](const common::PlatformResult result) -> void {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value value{picojson::object{}};
picojson::object& obj = value.get<picojson::object>();
}
void NetworkBearerSelectionInstance::onNBSEvent(const std::string& status) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
void NetworkBearerSelectionInstance::addDomainListener(const std::string& domain_name,
int listener_id) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(m_listener_mutex_);
listenerMap.insert(std::make_pair(domain_name, listener_id));
}
void NetworkBearerSelectionInstance::removeDomainListener(const std::string& domain_name) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(m_listener_mutex_);
listenerMap.erase(domain_name);
NetworkBearerSelectionEvent(const std::string& dm, const ReplyCallback& cb)
: domain_name(dm), callback(cb) {
+ ScopeLogger();
}
};
void NetworkBearerSelectionManager::AddListener(NetworkBearerSelectionInstance* listener) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(m_mutex_);
m_listeners_.push_back(listener);
}
void NetworkBearerSelectionManager::RemoveListener(NetworkBearerSelectionInstance* listener) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(m_mutex_);
m_listeners_.remove(listener);
}
NetworkBearerSelectionManager* NetworkBearerSelectionManager::GetInstance() {
- LoggerD("Entered");
+ ScopeLogger();
static NetworkBearerSelectionManager instance;
return &instance;
m_profile_handle_(nullptr),
m_profile_name_(),
m_is_connection_opened_(false) {
- LoggerD("Entered");
+ ScopeLogger();
int ret = connection_create(&m_connection_handle_);
if (CONNECTION_ERROR_NONE == ret) {
}
NetworkBearerSelectionManager::~NetworkBearerSelectionManager() {
- LoggerD("Entered");
+ ScopeLogger();
for (auto it = m_domain_names_.begin(); it != m_domain_names_.end(); ++it) {
if (!removeDomainRoute(it)) {
void NetworkBearerSelectionManager::connection_state_changed_callback(
connection_profile_state_e state, void* user_data) {
- LoggerD("Entered [%d]", state);
+ ScopeLogger("state: %d", state);
if (CONNECTION_PROFILE_STATE_CONNECTED == state) {
NetworkBearerSelectionManager::GetInstance()->makeSuccessCallback();
void NetworkBearerSelectionManager::connection_opened_callback(connection_error_e result,
void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
NetworkBearerSelectionEvent* event = static_cast<NetworkBearerSelectionEvent*>(user_data);
if (!event) {
LoggerE("Event not found");
void NetworkBearerSelectionManager::connection_closed_callback(connection_error_e result,
void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
NetworkBearerSelectionEvent* event = static_cast<NetworkBearerSelectionEvent*>(user_data);
if (!event) {
LoggerE("Event not found");
}
PlatformResult NetworkBearerSelectionManager::getCellularState() {
- LoggerD("Entered");
+ ScopeLogger();
connection_cellular_state_e state;
void NetworkBearerSelectionManager::callResultCallback(const ReplyCallback& reply,
const PlatformResult result) {
- LoggerD("Entered");
+ ScopeLogger();
std::thread(reply, result).detach();
}
void NetworkBearerSelectionManager::requestRouteToHost(const std::string& domain_name,
const ReplyCallback& reply) {
- LoggerD("Entered");
+ ScopeLogger();
connection_profile_h profile_h = nullptr;
char* current_profile_name_c = nullptr;
bool NetworkBearerSelectionManager::removeDomainRoute(
const std::map<std::string, int>::iterator& iter) {
- LoggerD("Entered");
+ ScopeLogger();
const char* domain_name = iter->first.c_str();
char* interface_name = nullptr;
void NetworkBearerSelectionManager::releaseRouteToHost(const std::string& domain_name,
const ReplyCallback& reply) {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_profile_handle_) {
callResultCallback(reply,
}
bool NetworkBearerSelectionManager::registerStateChangeListener(const std::string& domain_name) {
- LoggerD("Entered");
+ ScopeLogger();
char* interface_name = nullptr;
char* gateway = nullptr;
}
bool NetworkBearerSelectionManager::deregisterStateChangeListener(const std::string& domain_name) {
- LoggerD("Entered");
+ ScopeLogger();
if (m_profile_handle_) {
int ret = connection_profile_unset_state_changed_cb(m_profile_handle_);
}
void NetworkBearerSelectionManager::makeSuccessCallback() {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(m_mutex_);
for (NetworkBearerSelectionInstance* listener : m_listeners_) {
}
void NetworkBearerSelectionManager::makeDisconnectCallback() {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(m_mutex_);
for (NetworkBearerSelectionInstance* listener : m_listeners_) {
}
void NetworkBearerSelectionManager::destroyProfileHandler() {
- LoggerD("Entered");
+ ScopeLogger();
if (m_profile_handle_) {
if (CONNECTION_ERROR_NONE != connection_profile_destroy(m_profile_handle_)) {
}
ErrorCode NetworkBearerSelectionManager::GetNBSErrorCode(int error_code) {
- LoggerD("Entered");
+ ScopeLogger();
switch (error_code) {
case CONNECTION_ERROR_NOT_SUPPORTED:
}
bool NetworkBearerSelectionManager::createProfileHandler() {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_connection_handle_) {
LoggerE("Connection handle is not created");
AIDData::AIDData(std::string se_type, std::string aid, bool read_only)
: se_type_(se_type), aid_(aid), read_only_(read_only) {
- LoggerD("Entered");
+ ScopeLogger();
}
picojson::value AIDData::toJSON() const {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value retval = picojson::value(picojson::object());
picojson::object& obj = retval.get<picojson::object>();
void HCEEventCallback(nfc_se_h handle, nfc_hce_event_type_e event_type, unsigned char* apdu,
unsigned int apdu_len, void* /*user_data*/) {
- LoggerD("Entered");
+ ScopeLogger();
NFCAdapter::GetInstance()->SetSEHandle(handle);
picojson::value response = picojson::value(picojson::object());
m_se_handle(nullptr),
m_is_hce_listener_set(false),
responder_(nullptr) {
- LoggerD("Entered");
+ ScopeLogger();
// NFC library initialization
int ret = nfc_manager_initialize();
if (ret != NFC_ERROR_NONE) {
}
NFCAdapter::~NFCAdapter() {
- LoggerD("Entered");
+ ScopeLogger();
if (m_is_listener_set) {
nfc_manager_unset_se_event_cb();
}
}
void NFCAdapter::SetResponder(IResponder* responder) {
- LoggerD("Entered");
+ ScopeLogger();
responder_ = responder;
}
void NFCAdapter::RespondAsync(const char* msg) {
- LoggerD("Entered");
+ ScopeLogger();
if (GetInstance()->responder_) {
AssertMsg(GetInstance()->responder_, "Handler variable should be set");
GetInstance()->responder_->RespondAsync(msg);
}
static picojson::value CreateEventError(double callbackId, const PlatformResult& ret) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
}
static picojson::value createEventSuccess(double callbackId) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
tools::ReportSuccess(obj);
}
static gboolean setPoweredCompleteCB(void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
double* callbackId = static_cast<double*>(user_data);
picojson::value event = createEventSuccess(*callbackId);
NFCAdapter::GetInstance()->RespondAsync(event.serialize().c_str());
static void targetDetectedCallback(nfc_discovered_type_e type, nfc_p2p_target_h target,
void* /*user_data*/) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
obj[JSON_LISTENER_ID] = picojson::value(PEER_LISTENER);
}
NFCAdapter* NFCAdapter::GetInstance() {
- LoggerD("Entered");
+ ScopeLogger();
static NFCAdapter instance;
return &instance;
}
bool NFCAdapter::GetPowered() {
- LoggerD("Entered");
+ ScopeLogger();
return nfc_manager_is_activated();
}
#ifndef APP_CONTROL_SETTINGS_SUPPORT
static void NFCSetActivationCompletedCallback(nfc_error_e error, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
double* callbackId = static_cast<double*>(user_data);
if (NFC_ERROR_NONE != error) {
#endif
static void se_event_callback(nfc_se_event_e se_event, void* /*user_data*/) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
tools::ReportSuccess(obj);
static void transaction_event_callback(nfc_se_type_e type, unsigned char* _aid, int aid_size,
unsigned char* param, int param_size, void* /*user_data*/) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value response = picojson::value(picojson::object());
picojson::object& response_obj = response.get<picojson::object>();
tools::ReportSuccess(response_obj);
#ifdef APP_CONTROL_SETTINGS_SUPPORT
static void PostMessage(double* callbackId) {
+ ScopeLogger();
LoggerE("Posting error message.");
picojson::value event =
CreateEventError(*callbackId, PlatformResult(ErrorCode::UNKNOWN_ERR, "SetPowered failed."));
#endif
PlatformResult NFCAdapter::SetPowered(const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
double* callbackId = new double(args.get(JSON_CALLBACK_ID).get<double>());
bool powered = args.get("powered").get<bool>();
ret = app_control_send_launch_request(
service,
[](app_control_h request, app_control_h reply, app_control_result_e result, void* user_data) {
+ ScopeLogger(
+ "Entered into asynchronous function, app_control_send_launch_request's argument");
double* callbackId = static_cast<double*>(user_data);
if (result != APP_CONTROL_RESULT_SUCCEEDED) {
LoggerE("NFC enable app control failed : %d", result);
}
PlatformResult NFCAdapter::GetCardEmulationMode(std::string* mode) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_se_card_emulation_mode_type_e card_mode;
int ret = nfc_se_get_card_emulation_mode(&card_mode);
}
PlatformResult NFCAdapter::SetCardEmulationMode(const std::string& mode) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_se_card_emulation_mode_type_e new_mode;
PlatformResult result = NFCUtil::ToCardEmulationMode(mode, &new_mode);
}
PlatformResult NFCAdapter::GetActiveSecureElement(std::string* type) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_se_type_e se_type = NFC_SE_TYPE_DISABLE;
int ret = nfc_manager_get_se_type(&se_type);
}
PlatformResult NFCAdapter::SetActiveSecureElement(std::string element) {
- LoggerD("Entered");
+ ScopeLogger();
// if given value is not correct secure element type then
// there's no sense to get current value for comparison
}
PlatformResult NFCAdapter::SetExclusiveModeForTransaction(bool exmode) {
- LoggerD("Entered");
+ ScopeLogger();
int ret = NFC_ERROR_NONE;
if (exmode) {
}
PlatformResult NFCAdapter::AddCardEmulationModeChangeListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_listener_set) {
int ret = nfc_manager_set_se_event_cb(se_event_callback, nullptr);
if (NFC_ERROR_NONE != ret) {
}
PlatformResult NFCAdapter::RemoveCardEmulationModeChangeListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (!nfc_manager_is_supported()) {
return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "NFC Not Supported");
}
}
PlatformResult NFCAdapter::AddTransactionEventListener(const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_se_type_e se_type = NFC_SE_TYPE_DISABLE;
PlatformResult result = NFCUtil::ToSecureElementType(args.get(JSON_TYPE).get<string>(), &se_type);
}
PlatformResult NFCAdapter::RemoveTransactionEventListener(const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_se_type_e se_type = NFC_SE_TYPE_DISABLE;
PlatformResult result = NFCUtil::ToSecureElementType(args.get(JSON_TYPE).get<string>(), &se_type);
}
PlatformResult NFCAdapter::AddActiveSecureElementChangeListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_listener_set) {
int ret = nfc_manager_set_se_event_cb(se_event_callback, nullptr);
if (NFC_ERROR_NONE != ret) {
}
PlatformResult NFCAdapter::RemoveActiveSecureElementChangeListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (!nfc_manager_is_supported()) {
return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "NFC Not Supported");
}
}
void NFCAdapter::SetPeerHandle(nfc_p2p_target_h handle) {
- LoggerD("Entered");
+ ScopeLogger();
m_peer_handle = handle;
}
nfc_p2p_target_h NFCAdapter::GetPeerHandle() {
- LoggerD("Entered");
+ ScopeLogger();
return m_peer_handle;
}
int NFCAdapter::GetPeerId() {
- LoggerD("Entered");
+ ScopeLogger();
return m_latest_peer_id;
}
void NFCAdapter::IncreasePeerId() {
- LoggerD("Entered");
+ ScopeLogger();
m_latest_peer_id++;
}
PlatformResult NFCAdapter::PeerIsConnectedGetter(int peer_id, bool* state) {
- LoggerD("Entered");
+ ScopeLogger();
if (m_latest_peer_id != peer_id || !m_peer_handle) {
*state = false;
return PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult NFCAdapter::SetPeerListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (!nfc_manager_is_supported()) {
return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "NFC Not Supported");
}
}
PlatformResult NFCAdapter::UnsetPeerListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (!nfc_manager_is_supported()) {
return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "NFC Not Supported");
}
static void targetReceivedCallback(nfc_p2p_target_h /*target*/, nfc_ndef_message_h message,
void* /*data*/) {
- LoggerD("Entered");
+ ScopeLogger();
unsigned char* raw_data = NULL;
unsigned int size;
if (NFC_ERROR_NONE != nfc_ndef_message_get_rawdata(message, &raw_data, &size)) {
}
PlatformResult NFCAdapter::SetReceiveNDEFListener(int peer_id) {
- LoggerD("Entered");
+ ScopeLogger();
// unregister previous NDEF listener
if (m_is_ndef_listener_set) {
int ret = nfc_p2p_unset_data_received_cb(m_peer_handle);
}
PlatformResult NFCAdapter::UnsetReceiveNDEFListener(int peer_id) {
- LoggerD("Entered");
+ ScopeLogger();
if (m_is_ndef_listener_set) {
// check if peer object is still connected
}
bool NFCAdapter::IsNDEFListenerSet() {
- LoggerD("Entered");
+ ScopeLogger();
return m_is_ndef_listener_set;
}
// NFCTag related functions
PlatformResult NFCAdapter::TagTypeGetter(int /*tag_id*/, std::string* type) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_tag_type_e nfc_type = NFC_UNKNOWN_TARGET;
}
PlatformResult NFCAdapter::TagIsSupportedNDEFGetter(int /*tag_id*/, bool* is_supported) {
- LoggerD("Entered");
+ ScopeLogger();
int err = nfc_tag_is_support_ndef(m_last_tag_handle, is_supported);
if (NFC_ERROR_NONE != err) {
}
PlatformResult NFCAdapter::TagNDEFSizeGetter(int /*tag_id*/, unsigned int* size) {
- LoggerD("Entered");
+ ScopeLogger();
int err = nfc_tag_get_ndef_size(m_last_tag_handle, size);
if (NFC_ERROR_NONE != err) {
static bool tagPropertiesGetterCb(const char* key, const unsigned char* value, int value_size,
void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
if (user_data) {
UCharVector tag_info = NFCUtil::ToVector(value, value_size);
(static_cast<NFCTagPropertiesT*>(user_data))->push_back(std::make_pair(key, tag_info));
}
PlatformResult NFCAdapter::TagPropertiesGetter(int /*tag_id*/, NFCTagPropertiesT* properties) {
- LoggerD("Entered");
+ ScopeLogger();
int err =
nfc_tag_foreach_information(m_last_tag_handle, tagPropertiesGetterCb, (void*)properties);
}
PlatformResult NFCAdapter::TagIsConnectedGetter(int tag_id, bool* state) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
}
int NFCAdapter::GetNextTagId() {
- LoggerD("Entered");
+ ScopeLogger();
return ++m_latest_tag_id;
}
static void tagEventCallback(nfc_discovered_type_e type, nfc_tag_h tag, void* /*data*/) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
}
PlatformResult NFCAdapter::SetTagListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_tag_listener_set) {
nfc_manager_set_tag_filter(NFC_TAG_FILTER_ALL_ENABLE);
}
void NFCAdapter::UnsetTagListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (m_is_tag_listener_set) {
nfc_manager_unset_tag_discovered_cb();
}
void NFCAdapter::SetTagHandle(nfc_tag_h tag) {
- LoggerD("Entered");
+ ScopeLogger();
m_last_tag_handle = tag;
}
static void tagReadNDEFCb(nfc_error_e result, nfc_ndef_message_h message, void* data) {
- LoggerD("Entered");
+ ScopeLogger();
if (!data) {
// Can not continue if unable to get callbackId
}
PlatformResult NFCAdapter::TagReadNDEF(int tag_id, const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
bool is_connected = false;
PlatformResult result = TagIsConnectedGetter(tag_id, &is_connected);
}
PlatformResult NFCAdapter::TagWriteNDEF(int tag_id, const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
bool is_connected = false;
PlatformResult result = TagIsConnectedGetter(tag_id, &is_connected);
}
static void tagTransceiveCb(nfc_error_e err, unsigned char* buffer, int buffer_size, void* data) {
- LoggerD("Entered");
+ ScopeLogger();
std::unique_ptr<unsigned char> buffer_ptr(buffer);
buffer = nullptr;
}
PlatformResult NFCAdapter::TagTransceive(int tag_id, const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
bool is_connected = false;
PlatformResult result = TagIsConnectedGetter(tag_id, &is_connected);
if (result.IsError()) {
}
PlatformResult NFCAdapter::GetCachedMessage(picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_ndef_message_h message_handle = NULL;
int result = nfc_manager_get_cached_message(&message_handle);
if (NFC_ERROR_INVALID_NDEF_MESSAGE == result || NFC_ERROR_NO_NDEF_MESSAGE == result) {
}
static void peerSentCallback(nfc_error_e result, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
double* callbackId = static_cast<double*>(user_data);
if (NFC_ERROR_NONE != result) {
}
static gboolean sendNDEFErrorCB(void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
peerSentCallback(NFC_ERROR_INVALID_NDEF_MESSAGE, user_data);
return false;
}
PlatformResult NFCAdapter::sendNDEF(int peer_id, const picojson::value& args) {
- LoggerD("Entered");
+ ScopeLogger();
bool is_connected = false;
PlatformResult result = PeerIsConnectedGetter(peer_id, &is_connected);
if (result.IsError()) {
}
void NFCAdapter::SetSEHandle(nfc_se_h handle) {
- LoggerD("Entered");
+ ScopeLogger();
m_se_handle = handle;
}
nfc_se_h NFCAdapter::GetSEHandle() {
- LoggerD("Entered");
+ ScopeLogger();
return m_se_handle;
}
PlatformResult NFCAdapter::AddHCEEventListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (!m_is_hce_listener_set) {
int ret = nfc_manager_set_hce_event_cb(HCEEventCallback, nullptr);
if (NFC_ERROR_NONE != ret) {
}
PlatformResult NFCAdapter::RemoveHCEEventListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (m_is_hce_listener_set) {
nfc_manager_unset_hce_event_cb();
m_is_hce_listener_set = false;
void NFCAdapter::SendHostAPDUResponse(const UCharVector& apdu,
const std::function<void()>& success_cb,
const std::function<void(const PlatformResult&)>& error_cb) {
- LoggerD("Entered");
+ ScopeLogger();
if (!nfc_manager_is_supported()) {
error_cb(LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "NFC Not Supported"));
PlatformResult NFCAdapter::IsActivatedHandlerForAID(const std::string& type, const std::string& aid,
bool* is_activated_handler) {
+ ScopeLogger();
AssertMsg(is_activated_handler, "Poiner can not be null!");
- LoggerD("Entered");
nfc_se_type_e se_type;
PlatformResult result = NFCUtil::ToSecureElementType(type, &se_type);
PlatformResult NFCAdapter::IsActivatedHandlerForCategory(
const std::string& type, nfc_card_emulation_category_type_e category,
bool* is_activated_handler) {
- LoggerD("Entered");
+ ScopeLogger();
AssertMsg(is_activated_handler, "Poiner can not be null!");
nfc_se_type_e se_type;
PlatformResult NFCAdapter::RegisterAID(const std::string& type, const std::string& aid,
nfc_card_emulation_category_type_e category) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_se_type_e se_type;
PlatformResult result = NFCUtil::ToSecureElementType(type, &se_type);
if (result.IsError()) {
PlatformResult NFCAdapter::UnregisterAID(const std::string& type, const std::string& aid,
nfc_card_emulation_category_type_e category) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_se_type_e se_type;
PlatformResult result = NFCUtil::ToSecureElementType(type, &se_type);
if (result.IsError()) {
}
static void SaveRow(nfc_se_type_e se_type, const char* aid, bool read_only, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
AssertMsg(aid, "Poiner can not be null!");
AssertMsg(user_data, "Poiner can not be null!");
AIDDataVector* aids = static_cast<AIDDataVector*>(user_data);
nfc_card_emulation_category_type_e category,
const std::function<void(const AIDDataVector&)>& success_cb,
const std::function<void(const PlatformResult&)>& error_cb) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_se_type_e se_type;
PlatformResult result = NFCUtil::ToSecureElementType(type, &se_type);
if (result.IsError()) {
}
NFCExtension::NFCExtension() {
- LoggerD("Entered");
+ ScopeLogger();
SetExtensionName("tizen.nfc");
SetJavaScriptAPI(kSource_nfc_api);
}
NFCExtension::~NFCExtension() {
- LoggerD("Entered");
+ ScopeLogger();
}
common::Instance* NFCExtension::CreateInstance() {
- LoggerD("Entered");
+ ScopeLogger();
return new extension::nfc::NFCInstance();
}
} // namespace
void NFCInstance::RespondAsync(const char* msg) {
- LoggerD("Entered");
+ ScopeLogger();
Instance::PostMessage(this, msg);
}
static bool isTagSupported() {
- LoggerD("Entered");
+ ScopeLogger();
bool supported = true;
if (system_info_get_platform_bool("http://tizen.org/feature/network.nfc.tag", &supported) !=
SYSTEM_INFO_ERROR_NONE) {
}
static bool isP2PSupported() {
- LoggerD("Entered");
+ ScopeLogger();
bool supported = true;
if (system_info_get_platform_bool("http://tizen.org/feature/network.nfc.p2p", &supported) !=
SYSTEM_INFO_ERROR_NONE) {
}
NFCInstance::NFCInstance() {
- LoggerD("Entered");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
#define REGISTER_ASYNC(c, x) RegisterSyncHandler(c, std::bind(&NFCInstance::x, this, _1, _2));
}
NFCInstance::~NFCInstance() {
- LoggerD("Entered");
+ ScopeLogger();
NFCAdapter::GetInstance()->SetResponder(nullptr);
}
void NFCInstance::GetDefaultAdapter(const picojson::value& args, picojson::object& out) {
// Default NFC adapter is created at JS level
// Here there's only check for NFC support
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCommon, &out);
}
void NFCInstance::SetExclusiveMode(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCommon, &out);
CHECK_EXIST(args, "exclusiveMode", out);
// TODO(g.rynkowski): Rewrite to asynchronous approach
void NFCInstance::SetPowered(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: setPowered() is deprecated and will be removed from next release. Let "
"the user turn NFC on/off "
}
void NFCInstance::GetPowered(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
bool ret = NFCAdapter::GetInstance()->GetPowered();
ReportSuccess(picojson::value(ret), out);
}
void NFCInstance::CardEmulationModeSetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
CHECK_EXIST(args, "emulationMode", out);
}
void NFCInstance::CardEmulationModeGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
std::string mode = "";
}
void NFCInstance::ActiveSecureElementSetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
CHECK_EXIST(args, "secureElement", out);
}
void NFCInstance::ActiveSecureElementGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
std::string ase = "";
}
void NFCInstance::SetTagListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
bool supported = isTagSupported();
if (supported) {
}
void NFCInstance::PeerIsConnectedGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "id", out);
int peer_id = (int)args.get("id").get<double>();
}
void NFCInstance::SetPeerListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
bool supported = isP2PSupported();
if (supported) {
}
void NFCInstance::UnsetTagListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
bool supported = isTagSupported();
if (supported) {
}
void NFCInstance::UnsetPeerListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
bool supported = isP2PSupported();
if (supported) {
void NFCInstance::AddCardEmulationModeChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
PlatformResult result = NFCAdapter::GetInstance()->AddCardEmulationModeChangeListener();
void NFCInstance::RemoveCardEmulationModeChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
PlatformResult result = NFCAdapter::GetInstance()->RemoveCardEmulationModeChangeListener();
}
void NFCInstance::AddTransactionEventListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
PlatformResult result = NFCAdapter::GetInstance()->AddTransactionEventListener(args);
void NFCInstance::RemoveTransactionEventListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
PlatformResult result = NFCAdapter::GetInstance()->RemoveTransactionEventListener(args);
void NFCInstance::AddActiveSecureElementChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
PlatformResult result = NFCAdapter::GetInstance()->AddActiveSecureElementChangeListener();
void NFCInstance::RemoveActiveSecureElementChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
PlatformResult result = NFCAdapter::GetInstance()->RemoveActiveSecureElementChangeListener();
}
void NFCInstance::GetCachedMessage(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCommon, &out);
picojson::value result = picojson::value(picojson::object());
void NFCInstance::SetExclusiveModeForTransaction(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
CHECK_EXIST(args, "transactionMode", out);
// TODO(g.rynkowski): Rewrite to asynchronous approach
void NFCInstance::ReadNDEF(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
CHECK_EXIST(args, "id", out);
// TODO(g.rynkowski): Rewrite to asynchronous approach
void NFCInstance::WriteNDEF(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
CHECK_EXIST(args, "id", out);
// TODO(g.rynkowski): Rewrite to asynchronous approach
void NFCInstance::Transceive(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcTag, &out);
CHECK_EXIST(args, "id", out);
}
void NFCInstance::SetReceiveNDEFListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
CHECK_EXIST(args, "id", out);
}
void NFCInstance::UnsetReceiveNDEFListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
CHECK_EXIST(args, "id", out);
// TODO(g.rynkowski): Rewrite to asynchronous approach
void NFCInstance::SendNDEF(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcP2P, &out);
CHECK_EXIST(args, "id", out);
}
void NFCInstance::ToByte(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
// Message related methods
void NFCInstance::NDEFMessageContructor(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
PlatformResult ret = NFCMessageUtils::ReportNDEFMessage(args, result_obj);
}
void NFCInstance::NDEFRecordContructor(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
PlatformResult ret = NFCMessageUtils::ReportNDEFRecord(args, result_obj);
}
void NFCInstance::NDEFRecordTextContructor(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
}
void NFCInstance::NDEFRecordURIContructor(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
PlatformResult ret = NFCMessageUtils::ReportNDEFRecordURI(args, result_obj);
}
void NFCInstance::NDEFRecordMediaContructor(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
// NFCTag attributes getters
void NFCInstance::TagTypeGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "id", out);
int tag_id = (int)args.get("id").get<double>();
}
void NFCInstance::TagIsSupportedNDEFGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
int tag_id = (int)args.get("id").get<double>();
LoggerD("Tag id: %d", tag_id);
}
void NFCInstance::TagNDEFSizeGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
int tag_id = (int)args.get("id").get<double>();
LoggerD("Tag id: %d", tag_id);
}
void NFCInstance::TagPropertiesGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
int tag_id = (int)args.get("id").get<double>();
LoggerD("Tag id: %d", tag_id);
}
void NFCInstance::TagIsConnectedGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "id", out);
int tag_id = (int)args.get("id").get<double>();
}
void NFCInstance::AddHCEEventListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
PlatformResult result = NFCAdapter::GetInstance()->AddHCEEventListener();
}
void NFCInstance::RemoveHCEEventListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
PlatformResult result = NFCAdapter::GetInstance()->RemoveHCEEventListener();
}
void NFCInstance::SendHostAPDUResponse(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
CHECK_EXIST(args, JSON_APDU, out);
const double& callback_id = args.get(JSON_CALLBACK_ID).get<double>();
auto success_cb = [this, callback_id]() -> void {
- LoggerD("Entered");
+ ScopeLogger("Entered into asynchronous function, success_cb");
picojson::value response = picojson::value(picojson::object());
picojson::object& response_obj = response.get<picojson::object>();
response_obj[JSON_CALLBACK_ID] = picojson::value(callback_id);
};
auto error_cb = [this, callback_id](const PlatformResult& error) -> void {
- LoggerD("Entered error_cb: %s", error.message().c_str());
+ ScopeLogger("Entered into asynchronous function, error_cb: %s", error.message().c_str());
picojson::value response = picojson::value(picojson::object());
picojson::object& response_obj = response.get<picojson::object>();
response_obj[JSON_CALLBACK_ID] = picojson::value(callback_id);
}
void NFCInstance::IsActivatedHandlerForAID(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
CHECK_EXIST(args, JSON_TYPE, out);
void NFCInstance::IsActivatedHandlerForCategory(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
CHECK_EXIST(args, JSON_TYPE, out);
}
void NFCInstance::RegisterAID(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
CHECK_EXIST(args, JSON_TYPE, out);
}
void NFCInstance::UnregisterAID(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
CHECK_EXIST(args, JSON_TYPE, out);
}
void NFCInstance::GetAIDsForCategory(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNfcCardEmulation, &out);
CHECK_EXIST(args, JSON_TYPE, out);
const double& callback_id = args.get(JSON_CALLBACK_ID).get<double>();
auto success_cb = [this, callback_id](const AIDDataVector& data) -> void {
- LoggerD("enter");
+ ScopeLogger("Entered into asynchronous function, success_cb");
picojson::array aids;
aids.reserve(data.size());
for (const auto& aid : data) {
};
auto error_cb = [this, callback_id](const PlatformResult& error) -> void {
- LoggerD("entered error_cb: %s", error.message().c_str());
+ ScopeLogger("Entered into asynchronous function, error_cb: %s", error.message().c_str());
picojson::value response = picojson::value(picojson::object());
picojson::object& response_obj = response.get<picojson::object>();
response_obj[JSON_CALLBACK_ID] = picojson::value(callback_id);
/* -------------------------------COMMON FUNCTIONS------------------------------------ */
void NFCMessageUtils::RemoveMessageHandle(nfc_ndef_message_h message_handle) {
- LoggerD("Entered");
+ ScopeLogger();
if (message_handle) {
int result = nfc_ndef_message_destroy(message_handle);
if (NFC_ERROR_NONE != result) {
}
static void removeRecordHandle(nfc_ndef_record_h record_handle) {
- LoggerD("Entered");
+ ScopeLogger();
if (record_handle) {
int result = nfc_ndef_record_destroy(record_handle);
if (NFC_ERROR_NONE != result) {
static PlatformResult getTnfFromHandle(nfc_ndef_record_h handle, nfc_ndef_message_h message_handle,
short* tnf) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_record_tnf_e record_tnf;
int result = nfc_ndef_record_get_tnf(handle, &record_tnf);
if (NFC_ERROR_NONE != result) {
static PlatformResult getTypeNameFromHandle(nfc_ndef_record_h handle,
nfc_ndef_message_h message_handle, UCharVector* type) {
- LoggerD("Entered");
+ ScopeLogger();
unsigned char* type_name;
int type_size, result;
static PlatformResult getIdFromHandle(nfc_ndef_record_h handle, nfc_ndef_message_h message_handle,
UCharVector* id) {
- LoggerD("Entered");
+ ScopeLogger();
unsigned char* tmp_id;
int id_size, result;
static PlatformResult getPayloadFromHandle(nfc_ndef_record_h handle,
nfc_ndef_message_h message_handle,
UCharVector* payload) {
- LoggerD("Entered");
+ ScopeLogger();
unsigned char* tmp_payload;
unsigned int payload_size;
int result;
}
static nfc_encode_type_e convertToNfcEncodeUTF(const std::string& encode_string) {
- LoggerD("Entered");
+ ScopeLogger();
if (NFC_TEXT_UTF16 == encode_string) {
return NFC_ENCODE_UTF_16;
} else {
}
static std::string convertEncodingToString(nfc_encode_type_e encoding) {
- LoggerD("Entered");
+ ScopeLogger();
if (encoding == NFC_ENCODE_UTF_16) {
return NFC_TEXT_UTF16;
} else {
/* -------------------------------MESSAGE FUNCTIONS------------------------------------ */
PlatformResult NFCMessageUtils::ToNdefRecords(const nfc_ndef_message_h message,
picojson::array& array) {
- LoggerD("Entered");
+ ScopeLogger();
if (NULL != message) {
int count;
int result = nfc_ndef_message_get_record_count(message, &count);
PlatformResult NFCMessageUtils::ReportNdefMessageFromData(unsigned char* data, unsigned long size,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_ndef_message_h message = NULL;
int result = nfc_ndef_message_create_from_rawdata(&message, data, size);
PlatformResult NFCMessageUtils::ReportNDEFMessage(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const picojson::array& raw_data =
FromJson<picojson::array>(args.get<picojson::object>(), "rawData");
const int size = static_cast<int>(args.get("rawDataSize").get<double>());
static PlatformResult NdefRecordGetHandle(picojson::value& record,
nfc_ndef_record_h* record_handle) {
- LoggerD("Entered");
+ ScopeLogger();
if (!record.is<picojson::object>() || !record.contains("tnf") || !record.contains("type") ||
!record.contains("id") || !record.contains("payload")) {
return LogAndCreateResult(ErrorCode::TYPE_MISMATCH_ERR, "Record is empty");
PlatformResult NFCMessageUtils::NDEFMessageToStruct(const picojson::array& records_array,
const int size, nfc_ndef_message_h* message) {
- LoggerD("Entered");
+ ScopeLogger();
if (!size) {
LoggerE("No records in message");
return PlatformResult(ErrorCode::NO_ERROR);
PlatformResult NFCMessageUtils::NDEFMessageToByte(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
// input
const picojson::array& records_array =
FromJson<picojson::array>(args.get<picojson::object>(), "records");
/* -------------------------------RECORD FUNCTIONS------------------------------------ */
static void ConstructRecordJson(short _tnf, const UCharVector& _type_name, const UCharVector& _id,
const UCharVector& _payload, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
out.insert(std::make_pair("tnf", picojson::value(std::to_string(_tnf))));
picojson::value type_array = picojson::value(picojson::array());
PlatformResult NFCMessageUtils::ConstructNdefRecordFromRecordHandle(nfc_ndef_record_h record_handle,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
short _tnf;
PlatformResult ret = getTnfFromHandle(record_handle, NULL, &_tnf);
PlatformResult NFCMessageUtils::ReportNdefRecordFromMessage(nfc_ndef_message_h message_handle,
const int index,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_ndef_record_h record_handle = NULL;
int result = nfc_ndef_message_get_record(message_handle, index, &record_handle);
if (NFC_ERROR_NONE != result) {
PlatformResult NFCMessageUtils::ReportNDEFRecord(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const picojson::array& raw_data =
FromJson<picojson::array>(args.get<picojson::object>(), "rawData");
const int size = static_cast<int>(args.get("rawDataSize").get<double>());
/* -------------------------------RECORD TEXT FUNCTIONS------------------------------------ */
static PlatformResult getTextFromHandle(nfc_ndef_record_h handle, nfc_ndef_message_h message_handle,
std::string* text) {
- LoggerD("Entered");
+ ScopeLogger();
char* tmp_text = NULL;
int result = nfc_ndef_record_get_text(handle, &tmp_text);
if (NFC_ERROR_NONE != result) {
static PlatformResult getLanguageCodeFromHandle(nfc_ndef_record_h handle,
nfc_ndef_message_h message_handle,
std::string* language) {
- LoggerD("Entered");
+ ScopeLogger();
char* language_code = NULL;
int result = nfc_ndef_record_get_langcode(handle, &language_code);
if (NFC_ERROR_NONE != result) {
static PlatformResult getEncodingFromHandle(nfc_ndef_record_h handle,
nfc_ndef_message_h message_handle,
nfc_encode_type_e* encoding_type) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_encode_type_e encoding;
int result = nfc_ndef_record_get_encode_type(handle, &encoding);
if (NFC_ERROR_NONE != result) {
const std::string& language_code,
const std::string& encoding_str,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_encode_type_e encoding = convertToNfcEncodeUTF(encoding_str);
nfc_ndef_record_h handle = NULL;
PlatformResult NFCMessageUtils::ReportNdefRecordTextFromMessage(nfc_ndef_message_h message_handle,
const int index,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_ndef_record_h record_handle = NULL;
// This function just return the pointer of record.
int result = nfc_ndef_message_get_record(message_handle, index, &record_handle);
PlatformResult NFCMessageUtils::ReportNDEFRecordText(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string& text = args.get("text").get<std::string>();
const std::string& language_code = args.get("languageCode").get<std::string>();
const std::string& encoding_str = args.get("encoding").get<std::string>();
/* -------------------------------RECORD URI FUNCTIONS------------------------------------ */
static PlatformResult getURIFromHandle(nfc_ndef_record_h handle, nfc_ndef_message_h message_handle,
std::string* uri_handle) {
- LoggerD("Entered");
+ ScopeLogger();
char* uri = NULL;
int result = nfc_ndef_record_get_uri(handle, &uri);
if (NFC_ERROR_NONE != result || !uri) {
}
static PlatformResult ReportNDEFRecordURIFromURI(const std::string& uri, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_ndef_record_h handle = NULL;
int result = nfc_ndef_record_create_uri(&handle, uri.c_str());
PlatformResult NFCMessageUtils::ReportNdefRecordURIFromMessage(nfc_ndef_message_h message_handle,
const int index,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_ndef_record_h record_handle = NULL;
// This function just return the pointer of record.
int result = nfc_ndef_message_get_record(message_handle, index, &record_handle);
PlatformResult NFCMessageUtils::ReportNDEFRecordURI(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string& uri = args.get("uri").get<std::string>();
return ReportNDEFRecordURIFromURI(uri, out);
/* -------------------------------RECORD MEDIA FUNCTIONS------------------------------------ */
static PlatformResult getMimeTypeFromHandle(nfc_ndef_record_h handle,
nfc_ndef_message_h message_handle, std::string* mime) {
- LoggerD("Entered");
+ ScopeLogger();
char* mime_type = NULL;
int result = nfc_ndef_record_get_mime_type(handle, &mime_type);
if (NFC_ERROR_NONE != result) {
PlatformResult NFCMessageUtils::ReportNdefRecordMediaFromMessage(nfc_ndef_message_h message_handle,
const int index,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
nfc_ndef_record_h record_handle = NULL;
// This function just return the pointer of record.
int result = nfc_ndef_message_get_record(message_handle, index, &record_handle);
PlatformResult NFCMessageUtils::ReportNDEFRecordMedia(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string& mime_type = args.get("mimeType").get<std::string>();
const picojson::array& raw_data = FromJson<picojson::array>(args.get<picojson::object>(), "data");
namespace nfc {
UCharVector NFCUtil::ToVector(const unsigned char* ch, const int size) {
- LoggerD("Entered");
+ ScopeLogger();
UCharVector vec(ch, ch + size / sizeof(char));
return vec;
}
PlatformResult NFCUtil::CodeToResult(const int errorCode, const std::string& message) {
- LoggerD("Entered");
+ ScopeLogger();
switch (errorCode) {
case NFC_ERROR_INVALID_PARAMETER:
case NFC_ERROR_INVALID_NDEF_MESSAGE:
}
std::string NFCUtil::getNFCErrorString(const int error_code) {
- LoggerD("Error code : %d", error_code);
+ ScopeLogger("Error code : %d", error_code);
switch (error_code) {
case NFC_ERROR_ALREADY_ACTIVATED:
case NFC_ERROR_ALREADY_DEACTIVATED:
}
const std::string NFCUtil::getNFCErrorMessage(const int error_code) {
- LoggerD("Error code : %d", error_code);
+ ScopeLogger("Error code : %d", error_code);
switch (error_code) {
case NFC_ERROR_ALREADY_ACTIVATED:
case NFC_ERROR_ALREADY_DEACTIVATED:
}
std::string NFCUtil::ToStringNFCTag(nfc_tag_type_e tag_type) {
- LoggerD("Entered");
+ ScopeLogger();
switch (tag_type) {
case NFC_GENERIC_PICC:
return GENERIC_TARGET;
}
PlatformResult NFCUtil::ToNfcTagString(const std::string& type_string, nfc_tag_type_e* tag_type) {
- LoggerD("Entered");
+ ScopeLogger();
if (GENERIC_TARGET == type_string) {
*tag_type = NFC_GENERIC_PICC;
} else if (ISO14443_A == type_string) {
PlatformResult NFCUtil::ToStringCardEmulationMode(const nfc_se_card_emulation_mode_type_e card_mode,
std::string* mode) {
- LoggerD("Entered");
+ ScopeLogger();
switch (card_mode) {
case NFC_SE_CARD_EMULATION_MODE_OFF:
*mode = OFF;
PlatformResult NFCUtil::ToCardEmulationMode(const std::string& mode_string,
nfc_se_card_emulation_mode_type_e* mode) {
- LoggerD("Entered");
+ ScopeLogger();
if (mode_string == ALWAYS_ON) {
*mode = NFC_SE_CARD_EMULATION_MODE_ON;
} else if (mode_string == OFF) {
}
PlatformResult NFCUtil::ToStringSecureElementType(const nfc_se_type_e se_type, std::string* type) {
- LoggerD("Entered");
+ ScopeLogger();
switch (se_type) {
case NFC_SE_TYPE_ESE:
*type = DATA_NFC_SE_TYPE_ESE;
}
PlatformResult NFCUtil::ToSecureElementType(const std::string& type_string, nfc_se_type_e* type) {
- LoggerD("Entered");
+ ScopeLogger();
if (type_string == DATA_NFC_SE_TYPE_ESE) {
*type = NFC_SE_TYPE_ESE;
} else if (type_string == DATA_NFC_SE_TYPE_UICC) {
}
void NFCUtil::setDefaultFilterValues(std::vector<nfc_tag_type_e>& filter) {
- LoggerD("Entered");
+ ScopeLogger();
filter.push_back(NFC_GENERIC_PICC);
filter.push_back(NFC_ISO14443_A_PICC);
filter.push_back(NFC_ISO14443_3A_PICC);
// Convertion of enum to HCEEventType(characters sequence).
const char* NFCUtil::ToStr(nfc_hce_event_type_e event_type) {
- LoggerD("Entered");
+ ScopeLogger();
switch (event_type) {
case NFC_HCE_EVENT_DEACTIVATED:
return "DEACTIVATED";
// Convertion of enum to SecureElementType(characters sequence).
// Warning! DISABLE and SDCARD are not mentioned at widl spec.
const char* NFCUtil::ToStr(nfc_se_type_e se_type) {
- LoggerD("Entered");
+ ScopeLogger();
switch (se_type) {
case NFC_SE_TYPE_DISABLE:
return "DISABLE";
// Convertion CardEmulationCategoryType(characters sequence) to enum.
nfc_card_emulation_category_type_e NFCUtil::StringToCategory(const std::string& category_type) {
- LoggerD("Entered");
+ ScopeLogger();
if (category_type == "PAYMENT") return NFC_CARD_EMULATION_CATEGORY_PAYMENT;
if (category_type == "OTHER") return NFC_CARD_EMULATION_CATEGORY_OTHER;
AssertMsg(false, "That category type is incorrect.");
}
unsigned char* NFCUtil::DoubleArrayToUCharArray(const picojson::array& array_in) {
- LoggerD("Entered");
+ ScopeLogger();
unsigned char* result_array = new unsigned char[array_in.size()];
for (std::size_t i = 0; i < array_in.size(); ++i) {
result_array[i] = static_cast<unsigned char>(array_in.at(i).get<double>());
}
UCharVector NFCUtil::DoubleArrayToUCharVector(const picojson::array& array_in) {
- LoggerD("Entered");
+ ScopeLogger();
return ToVector(NFCUtil::DoubleArrayToUCharArray(array_in), array_in.size());
}
picojson::array NFCUtil::FromUCharArray(unsigned char* array, unsigned int apdu_len) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::array apdu_array;
apdu_array.reserve(apdu_len);
for (unsigned int i = 0; i < apdu_len; ++i)
using namespace common;
NotificationInstance::NotificationInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
#define REGISTER_SYNC(c, x) \
}
NotificationInstance::~NotificationInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
#define CHECK_EXIST(args, name, out) \
void NotificationInstance::NotificationManagerPost(const picojson::value& args,
picojson::object& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
- LoggerD("Enter");
picojson::value val{picojson::object{}};
PlatformResult status = manager_->Post(args.get<picojson::object>(), val.get<picojson::object>());
void NotificationInstance::NotificationManagerUpdate(const picojson::value& args,
picojson::object& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
- LoggerD("Enter");
PlatformResult status = manager_->Update(args.get<picojson::object>());
if (status.IsSuccess()) {
void NotificationInstance::NotificationManagerRemove(const picojson::value& args,
picojson::object& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
- LoggerD("Enter");
PlatformResult status = manager_->Remove(args.get<picojson::object>());
if (status.IsSuccess()) {
void NotificationInstance::NotificationManagerRemoveAll(const picojson::value& args,
picojson::object& out) {
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeNotification, &out);
- LoggerD("Enter");
PlatformResult status = manager_->RemoveAll();
if (status.IsSuccess()) {
void NotificationInstance::NotificationManagerGet(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value val{picojson::object{}};
PlatformResult status = manager_->Get(args.get<picojson::object>(), val.get<picojson::object>());
void NotificationInstance::NotificationManagerGetAll(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value val{picojson::array{}};
PlatformResult status = manager_->GetAll(val.get<picojson::array>());
void NotificationInstance::NotificationManagerPlayLEDCustomEffect(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeLED, &out);
PlatformResult status = manager_->PlayLEDCustomEffect(args.get<picojson::object>());
void NotificationInstance::NotificationManagerStopLEDCustomEffect(const picojson::value& /*args*/,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeLED, &out);
PlatformResult status = manager_->StopLEDCustomEffect();
using namespace common;
NotificationManager::NotificationManager() {
- LoggerD("Enter");
+ ScopeLogger();
}
NotificationManager::~NotificationManager() {
- LoggerD("Enter");
+ ScopeLogger();
}
NotificationManager* NotificationManager::GetInstance() {
- LoggerD("Enter");
+ ScopeLogger();
static NotificationManager instance;
return &instance;
}
PlatformResult NotificationManager::Post(const picojson::object& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
return StatusNotification::FromJson(args, false, &out);
}
PlatformResult NotificationManager::Update(const picojson::object& args) {
- LoggerD("Enter");
+ ScopeLogger();
return StatusNotification::FromJson(args, true, NULL);
}
PlatformResult NotificationManager::Remove(const picojson::object& args) {
- LoggerD("Enter");
+ ScopeLogger();
int id = std::stoi(FromJson<std::string>(args, "id"));
int ret = notification_delete_by_priv_id(NULL, NOTIFICATION_TYPE_NONE, id);
}
PlatformResult NotificationManager::RemoveAll() {
- LoggerD("Enter");
+ ScopeLogger();
int ret = notification_delete_all(NOTIFICATION_TYPE_NOTI);
if (ret != NOTIFICATION_ERROR_NONE) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Notification noti remove all failed",
}
PlatformResult NotificationManager::Get(const picojson::object& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
int id;
try {
id = std::stoi(FromJson<std::string>(args, "id"));
}
PlatformResult NotificationManager::GetAll(picojson::array& out) {
- LoggerD("Enter");
+ ScopeLogger();
notification_h noti = nullptr;
notification_list_h noti_list = nullptr;
notification_list_h noti_list_iter = nullptr;
}
PlatformResult NotificationManager::PlayLEDCustomEffect(const picojson::object& args) {
- LoggerD("Enter");
+ ScopeLogger();
int timeOn = FromJson<double>(args, "timeOn");
int timeOff = FromJson<double>(args, "timeOff");
}
PlatformResult NotificationManager::StopLEDCustomEffect() {
- LoggerD("Enter");
+ ScopeLogger();
int ret = device_led_stop_custom();
if (ret != DEVICE_ERROR_NONE) {
{3, NOTIFICATION_IMAGE_TYPE_LIST_4}};
StatusNotification::StatusNotification() {
+ ScopeLogger();
}
StatusNotification::~StatusNotification() {
+ ScopeLogger();
}
bool StatusNotification::IsColorFormatNumberic(const std::string& color) {
- LoggerD("Enter");
+ ScopeLogger();
std::string hexCode = "0123456789abcdef";
if (color.length() != 7 || '#' != color[0]) {
return false;
PlatformResult StatusNotification::SetLayout(notification_h noti_handle,
const std::string& noti_type) {
- LoggerD("Enter");
+ ScopeLogger();
notification_ly_type_e noti_layout = NOTIFICATION_LY_NONE;
if (noti_type == "SIMPLE") {
}
static bool ServiceExtraDataCb(app_control_h service, const char* key, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
if (nullptr == user_data || nullptr == key) {
LoggerE("User data or key not exist");
return true;
PlatformResult StatusNotification::Create(notification_type_e noti_type,
notification_h* noti_handle) {
- LoggerD("Enter");
+ ScopeLogger();
*noti_handle = notification_create(noti_type);
if (!*noti_handle) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Cannot make new notification object");
PlatformResult StatusNotification::StatusTypeFromPlatform(notification_type_e noti_type,
notification_ly_type_e noti_layout,
std::string* type) {
- LoggerD("Enter");
+ ScopeLogger();
if (noti_type == NOTIFICATION_TYPE_NOTI) {
if (noti_layout == NOTIFICATION_LY_NOTI_EVENT_SINGLE ||
noti_layout == NOTIFICATION_LY_NOTI_EVENT_MULTIPLE) {
PlatformResult StatusNotification::StatusTypeToPlatform(const std::string& type,
notification_type_e* noti_type) {
- LoggerD("Enter");
+ ScopeLogger();
if (type == "SIMPLE" || type == "THUMBNAIL") {
*noti_type = NOTIFICATION_TYPE_NOTI;
} else if (type == "ONGOING" || type == "PROGRESS") {
PlatformResult StatusNotification::GetImage(notification_h noti_handle,
notification_image_type_e image_type,
std::string* image_path) {
- LoggerD("Enter");
+ ScopeLogger();
char* path = NULL;
*image_path = "";
PlatformResult StatusNotification::SetImage(notification_h noti_handle,
notification_image_type_e image_type,
const std::string& image_path) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = notification_set_image(noti_handle, image_type, image_path.c_str());
if (ret != NOTIFICATION_ERROR_NONE) {
return LogAndCreateResult(
PlatformResult StatusNotification::GetText(notification_h noti_handle,
notification_text_type_e text_type,
std::string* noti_text) {
- LoggerD("Enter");
+ ScopeLogger();
char* text = NULL;
*noti_text = "";
PlatformResult StatusNotification::SetText(notification_h noti_handle,
notification_text_type_e text_type,
const std::string& noti_text) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = notification_set_text(noti_handle, text_type, noti_text.c_str(), NULL,
NOTIFICATION_VARIABLE_TYPE_NONE);
if (ret != NOTIFICATION_ERROR_NONE) {
PlatformResult StatusNotification::GetNumber(notification_h noti_handle,
notification_text_type_e text_type, long* number) {
- LoggerD("Enter");
+ ScopeLogger();
std::string text;
PlatformResult status = GetText(noti_handle, text_type, &text);
if (status.IsError()) return status;
PlatformResult StatusNotification::GetDetailInfos(notification_h noti_handle,
picojson::array* out) {
- LoggerD("Enter");
+ ScopeLogger();
if (info_map_.size() != info_sub_map_.size()) {
return LogAndCreateResult(ErrorCode::VALIDATION_ERR,
"Different notification information types element size");
PlatformResult StatusNotification::SetDetailInfos(notification_h noti_handle,
const picojson::array& value) {
- LoggerD("Enter");
+ ScopeLogger();
size_t idx = 0;
size_t info_map_size = info_map_.size();
}
PlatformResult StatusNotification::GetLedColor(notification_h noti_handle, std::string* led_color) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned int color = 0;
notification_led_op_e type = NOTIFICATION_LED_OP_ON;
PlatformResult StatusNotification::SetLedColor(notification_h noti_handle,
const std::string& led_color) {
- LoggerD("Enter");
+ ScopeLogger();
std::string color_str = led_color;
std::transform(color_str.begin(), color_str.end(), color_str.begin(), ::tolower);
PlatformResult StatusNotification::GetLedPeriod(notification_h noti_handle,
unsigned long* on_period,
unsigned long* off_period) {
- LoggerD("Enter");
+ ScopeLogger();
int on_time = 0;
int off_time = 0;
PlatformResult StatusNotification::SetLedOnPeriod(notification_h noti_handle,
unsigned long on_period) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned long off_period = 0;
PlatformResult status = GetLedPeriod(noti_handle, nullptr, &off_period);
if (status.IsError()) return status;
PlatformResult StatusNotification::SetLedOffPeriod(notification_h noti_handle,
unsigned long off_period) {
- LoggerD("Enter");
+ ScopeLogger();
unsigned long on_period = 0;
PlatformResult status = GetLedPeriod(noti_handle, &on_period, nullptr);
if (status.IsError()) return status;
}
PlatformResult StatusNotification::GetThumbnails(notification_h noti_handle, picojson::array* out) {
- LoggerD("Enter");
+ ScopeLogger();
std::string text;
size_t thumbnails_map_size = thumbnails_map_.size();
for (size_t idx = 0; idx < thumbnails_map_size; ++idx) {
PlatformResult StatusNotification::SetThumbnails(notification_h noti_handle,
const picojson::array& value) {
- LoggerD("Enter");
+ ScopeLogger();
size_t idx = 0;
size_t thumbnails_map_size = thumbnails_map_.size();
PlatformResult StatusNotification::GetSoundPath(notification_h noti_handle,
std::string* sound_path) {
- LoggerD("Enter");
+ ScopeLogger();
*sound_path = "";
const char* path = NULL;
PlatformResult StatusNotification::SetSoundPath(notification_h noti_handle,
const std::string& sound_path) {
- LoggerD("Enter");
+ ScopeLogger();
int ret =
notification_set_sound(noti_handle, NOTIFICATION_SOUND_TYPE_USER_DATA, sound_path.c_str());
if (ret != NOTIFICATION_ERROR_NONE) {
}
PlatformResult StatusNotification::GetVibration(notification_h noti_handle, bool* vibration) {
- LoggerD("Enter");
+ ScopeLogger();
notification_vibration_type_e vib_type = NOTIFICATION_VIBRATION_TYPE_NONE;
if (notification_get_vibration(noti_handle, &vib_type, NULL) != NOTIFICATION_ERROR_NONE) {
}
PlatformResult StatusNotification::SetVibration(notification_h noti_handle, bool vibration) {
- LoggerD("Enter");
+ ScopeLogger();
bool platform_vibration;
PlatformResult status = GetVibration(noti_handle, &platform_vibration);
if (status.IsError()) return status;
PlatformResult StatusNotification::GetApplicationControl(app_control_h app_handle,
picojson::object* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::object& out = *out_ptr;
char* operation = NULL;
PlatformResult StatusNotification::SetApplicationControl(app_control_h app_handle,
const picojson::object& app_ctrl) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value val(app_ctrl);
const std::string& operation = common::FromJson<std::string>(app_ctrl, "operation");
}
PlatformResult StatusNotification::GetApplicationId(app_control_h app_handle, std::string* app_id) {
- LoggerD("Enter");
+ ScopeLogger();
char* app_id_str = NULL;
SCOPE_EXIT {
free(app_id_str);
PlatformResult StatusNotification::SetApplicationId(app_control_h app_handle,
const std::string& app_id) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = app_control_set_app_id(app_handle, app_id.c_str());
if (ret != APP_CONTROL_ERROR_NONE) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Set applicaiton ID error",
PlatformResult StatusNotification::GetProgressValue(notification_h noti_handle,
const std::string& progess_type,
double* progress_value) {
- LoggerD("Enter");
+ ScopeLogger();
double tmp_progress_value = 0.0;
if (progess_type == kProgressTypeByte) {
PlatformResult StatusNotification::SetProgressValue(notification_h noti_handle,
const std::string& progress_type,
double progress_value, bool is_update) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
if (progress_type == kProgressTypeByte) {
}
PlatformResult StatusNotification::GetPostedTime(notification_h noti_handle, time_t* posted_time) {
- LoggerD("Enter");
+ ScopeLogger();
*posted_time = 0;
if (notification_get_insert_time(noti_handle, posted_time) != NOTIFICATION_ERROR_NONE) {
}
PlatformResult StatusNotification::GetNotiHandle(int id, notification_h* noti_handle) {
- LoggerD("Enter");
+ ScopeLogger();
*noti_handle = notification_load(NULL, id);
if (NULL == *noti_handle) {
return LogAndCreateResult(ErrorCode::NOT_FOUND_ERR, "Not found or removed notification id");
PlatformResult StatusNotification::GetAppControl(notification_h noti_handle,
app_control_h* app_control) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = notification_get_launch_option(noti_handle, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL,
static_cast<void*>(app_control));
if (ret != NOTIFICATION_ERROR_NONE) {
}
PlatformResult StatusNotification::CreateAppControl(app_control_h* app_control) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = app_control_create(app_control);
if (ret != APP_CONTROL_ERROR_NONE) {
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Application create error",
PlatformResult StatusNotification::SetAppControl(notification_h noti_handle,
app_control_h app_control) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = notification_set_launch_option(noti_handle, NOTIFICATION_LAUNCH_OPTION_APP_CONTROL,
static_cast<void*>(app_control));
if (ret != APP_CONTROL_ERROR_NONE) {
PlatformResult StatusNotification::ToJson(int id, notification_h noti_handle,
app_control_h app_handle, picojson::object* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::object& out = *out_ptr;
out["id"] = picojson::value(std::to_string(id));
PlatformResult StatusNotification::FromJson(const picojson::object& args, bool is_update,
picojson::object* out_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::object noti_obj = common::FromJson<picojson::object>(args, "notification");
const std::string& status_type = common::FromJson<std::string>(noti_obj, "statusType");
extern const char kSource_package_api[];
common::Extension* CreateExtension() {
- LoggerD("Enter");
+ ScopeLogger();
return new PackageExtension;
}
PackageExtension::PackageExtension() {
- LoggerD("Enter");
+ ScopeLogger();
SetExtensionName("tizen.package");
SetJavaScriptAPI(kSource_package_api);
}
PackageExtension::~PackageExtension() {
- LoggerD("Enter");
+ ScopeLogger();
}
common::Instance* PackageExtension::CreateInstance() {
- LoggerD("Enter");
+ ScopeLogger();
return new extension::package::PackageInstance;
}
out["error"] = exception.ToJSON();
static int PackageInfoGetListCb(const pkgmgrinfo_pkginfo_h info, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array* array_data = static_cast<picojson::array*>(user_data);
if (!array_data) {
}
void PackageInfoProvider::GetPackagesInfo(picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
clock_t start_time, end_time;
start_time = clock();
}
void PackageInfoProvider::GetPackageInfo(picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
char* package_id = NULL;
if (GetCurrentPackageId(&package_id)) {
}
void PackageInfoProvider::GetPackageInfo(const char* package_id, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
if (strlen(package_id) <= 0) {
LoggerE("Wrong Package ID");
static bool PackageAppInfoCb(package_info_app_component_type_e comp_type, const char* app_id,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::array* array_data = static_cast<picojson::array*>(user_data);
if (!array_data) {
bool PackageInfoProvider::ConvertToPackageToObject(const pkgmgrinfo_pkginfo_h info,
picojson::object& out) {
+ ScopeLogger();
int ret = 0;
char* id = NULL;
namespace {
void GetSize(const std::string& id, int service_mode, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
pkgmgr_client* pc = pkgmgr_client_new(PC_REQUEST);
int size = pkgmgr_client_usr_request_service(PM_REQUEST_GET_SIZE, service_mode, pc, NULL,
id.c_str(), getuid(), NULL, NULL, NULL);
} // namespace
void PackageInfoProvider::GetTotalSize(const std::string& id, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
GetSize(id, PM_GET_TOTAL_SIZE, out);
}
void PackageInfoProvider::GetDataSize(const std::string& id, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
GetSize(id, PM_GET_DATA_SIZE, out);
}
bool PackageInfoProvider::GetCurrentPackageId(char** package_id) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = 0;
char* app_id = NULL;
class PackageUserData {
public:
PackageUserData(PackageInstance* ins, int id, PackageThreadWorkType task) {
+ ScopeLogger();
instance_ = ins;
callback_id_ = id;
work_ = task;
typedef std::shared_ptr<PackageUserData> PackageUserDataPtr;
static void* PackageThreadWork(const PackageUserDataPtr& userData) {
- LoggerD("Enter");
+ ScopeLogger();
switch (userData->work_) {
case PackageThreadWorkGetPackagesInfo: {
}
static gboolean PackageAfterWork(const PackageUserDataPtr& userData) {
- LoggerD("Enter");
+ ScopeLogger();
userData->data_["callbackId"] = picojson::value(static_cast<double>(userData->callback_id_));
picojson::value result = picojson::value(userData->data_);
package_manager_event_type_e event_type,
package_manager_event_state_e event_state, int progress,
package_manager_error_e error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
PackageInstance* instance = static_cast<PackageInstance*>(user_data);
if (!instance) {
package_manager_event_type_e event_type,
package_manager_event_state_e event_state, int progress,
package_manager_error_e error, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
PackageInstance* instance = static_cast<PackageInstance*>(user_data);
if (!instance) {
}
static std::string ltrim(const std::string& s) {
+ ScopeLogger();
std::string str = s;
std::string::iterator i;
for (i = str.begin(); i != str.end(); ++i) {
}
static std::string convertUriToPath(const std::string& uri) {
+ ScopeLogger();
std::string result;
std::string schema("file://");
std::string str = ltrim(uri);
}
PackageInstance::PackageInstance() {
- LoggerD("Enter");
+ ScopeLogger();
int ret = package_manager_request_create(&request_);
if (ret != PACKAGE_MANAGER_ERROR_NONE) {
}
PackageInstance::~PackageInstance() {
- LoggerD("Enter");
+ ScopeLogger();
package_manager_request_unset_event_cb(request_);
package_manager_request_destroy(request_);
package_manager_destroy(manager_);
}
void PackageInstance::RegisterCallback(int request_id, int callback_id) {
- LoggerD("Enter");
+ ScopeLogger();
callbacks_map_[request_id] = callback_id;
}
void PackageInstance::DeregisterCallback(int request_id) {
- LoggerD("Enter");
+ ScopeLogger();
callbacks_map_.erase(request_id);
}
void PackageInstance::InvokeCallback(int request_id, picojson::object& param) {
- LoggerD("Enter");
+ ScopeLogger();
int callback_id = callbacks_map_[request_id];
}
void PackageInstance::PackageManagerInstall(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePackageInstall, &out);
}
void PackageInstance::PackageManagerUninstall(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePackageInstall, &out);
}
void PackageInstance::PackageManagerGetpackagesinfo(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePackageInfo, &out);
}
void PackageInstance::PackageManagerGetpackageinfo(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePackageInfo, &out);
void PackageInstance::PackageManagerGetTotalSize(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
const auto& id = args.get("id");
void PackageInstance::PackageManagerGetDataSize(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
const auto& id = args.get("id");
}
void PackageInstance::InvokeListener(picojson::object& param) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value result = picojson::value(param);
Instance::PostMessage(this, result.serialize().c_str());
}
void PackageInstance::PackageManagerSetpackageinfoeventlistener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePackageInfo, &out);
void PackageInstance::PackageManagerUnsetpackageinfoeventlistener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePackageInfo, &out);
}
void PackageInstance::InvokeErrorCallbackAsync(int callback_id, const PlatformException& ex) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::object param;
LogAndReportError(ex, param);
}
PowerExtension::PowerExtension() {
+ ScopeLogger();
SetExtensionName("tizen.power");
SetJavaScriptAPI(kSource_power_api);
}
PowerExtension::~PowerExtension() {
+ ScopeLogger();
}
common::Instance* PowerExtension::CreateInstance() {
using namespace extension::power;
PowerInstance::PowerInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
PowerInstance::~PowerInstance() {
- LoggerD("Enter");
+ ScopeLogger();
PowerManager::GetInstance()->RemoveListener(this);
}
void PowerInstance::PowerManagerRequest(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePower, &out);
const std::string& resource = args.get("resource").get<std::string>();
}
void PowerInstance::PowerManagerRelease(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string& resource = args.get("resource").get<std::string>();
PlatformResult result = PowerManager::GetInstance()->Release(kPowerResourceMap.at(resource));
if (result.IsError())
void PowerInstance::PowerManagerGetscreenbrightness(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
double brightness;
PlatformResult result = PowerManager::GetInstance()->GetScreenBrightness(&brightness);
if (result.IsError())
void PowerInstance::PowerManagerSetscreenbrightness(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePower, &out);
CHECK_EXIST(args, "brightness", out)
}
void PowerInstance::PowerManagerIsscreenon(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
bool state = false;
PlatformResult result = PowerManager::GetInstance()->IsScreenOn(&state);
if (result.IsError())
void PowerInstance::PowerManagerRestorescreenbrightness(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result = PowerManager::GetInstance()->RestoreScreenBrightness();
if (result.IsError())
LogAndReportError(result, &out);
}
void PowerInstance::PowerManagerTurnscreenon(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: turnScreenOn() is deprecated and will be removed from next release. "
"Use request() instead.");
}
void PowerInstance::PowerManagerTurnscreenoff(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: turnScreenOff() is deprecated and will be removed from next release. "
"Use release() instead.");
}
void PowerInstance::OnScreenStateChanged(PowerState prev_state, PowerState new_state) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
obj["cmd"] = picojson::value("ScreenStateChanged");
should_be_read_from_cache_(false),
set_custom_brightness_(false),
current_requested_state_(POWER_STATE_NONE) {
- LoggerD("Enter");
+ ScopeLogger();
display_state_e platform_state = DISPLAY_STATE_NORMAL;
int ret = device_display_get_state(&platform_state);
}
PowerManager::~PowerManager() {
- LoggerD("Enter");
+ ScopeLogger();
int ret =
device_remove_callback(DEVICE_CALLBACK_DISPLAY_STATE, PowerManager::OnPlatformStateChangedCB);
if (DEVICE_ERROR_NONE != ret) LoggerE("device_remove_callback failed (%d)", ret);
}
PowerManager* PowerManager::GetInstance() {
- LoggerD("Enter");
+ ScopeLogger();
static PowerManager instance;
return &instance;
}
void PowerManager::OnPlatformStateChangedCB(device_callback_e type, void* value, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
PowerManager* object = static_cast<PowerManager*>(user_data);
if (object == NULL) {
LoggerE("User data is NULL");
}
void PowerManager::AddListener(PowerManagerListener* listener) {
- LoggerD("Enter");
+ ScopeLogger();
auto it = std::find(listeners_.begin(), listeners_.end(), listener);
if (it == listeners_.end()) listeners_.push_back(listener);
}
void PowerManager::RemoveListener(PowerManagerListener* listener) {
- LoggerD("Enter");
+ ScopeLogger();
listeners_.remove(listener);
}
PlatformResult PowerManager::Request(PowerResource resource, PowerState state) {
- LoggerD("Enter");
+ ScopeLogger();
if (resource == POWER_RESOURCE_SCREEN && state == POWER_STATE_CPU_AWAKE)
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "invalid PowerState");
if (resource == POWER_RESOURCE_CPU && state != POWER_STATE_CPU_AWAKE)
}
PlatformResult PowerManager::Release(PowerResource resource) {
- LoggerD("Enter");
+ ScopeLogger();
int ret;
if (POWER_RESOURCE_SCREEN == resource) {
ret = device_power_release_lock(POWER_LOCK_DISPLAY);
}
PlatformResult PowerManager::GetScreenBrightness(double* output) {
- LoggerD("Enter");
+ ScopeLogger();
int brightness = 0;
auto error_code = GetPlatformBrightness(&brightness);
}
PlatformResult PowerManager::SetScreenBrightness(double brightness) {
- LoggerD("Enter");
+ ScopeLogger();
if (brightness > 1 || brightness < 0)
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR,
"brightness should be 0 <= brightness <= 1");
}
PlatformResult PowerManager::IsScreenOn(bool* state) {
- LoggerD("Enter");
+ ScopeLogger();
display_state_e platform_state = DISPLAY_STATE_NORMAL;
int ret = device_display_get_state(&platform_state);
}
PlatformResult PowerManager::SetScreenState(bool onoff) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = device_display_change_state(onoff ? DISPLAY_STATE_NORMAL : DISPLAY_STATE_SCREEN_OFF);
if (DEVICE_ERROR_NONE != ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Platform error while changing screen state",
}
PlatformResult PowerManager::RestoreScreenBrightness() {
- LoggerD("Enter");
+ ScopeLogger();
int result = 0;
auto error_code = PowerPlatformProxy::GetInstance().SetBrightnessFromSettings(&result);
if (!error_code || DEVICE_ERROR_NONE != result) {
}
PlatformResult PowerManager::SetPlatformBrightness(int brightness) {
- LoggerD("Enter");
+ ScopeLogger();
if (current_state_ == POWER_STATE_SCREEN_DIM) {
current_brightness_ = brightness;
LoggerD("Current state is not normal state the value is saved in cache: %d", brightness);
}
PlatformResult PowerManager::GetPlatformBrightness(int* result) {
- LoggerD("Entered");
+ ScopeLogger();
int brightness = 0;
}
PlatformResult PowerManager::RestoreSettedBrightness() {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result(ErrorCode::NO_ERROR);
int is_custom_mode = 0;
vconf_get_int(VCONFKEY_PM_CUSTOM_BRIGHTNESS_STATUS, &is_custom_mode);
}
void PowerManager::BroadcastScreenState(PowerState current) {
- LoggerD("Enter");
+ ScopeLogger();
if (current_state_ == current) return;
PowerState prev_state = current_state_;
PowerPlatformProxy::PowerPlatformProxy()
: gdbus_op_(common::gdbus::GDBusPowerWrapper::kDefaultBusName,
common::gdbus::GDBusPowerWrapper::kDefaultObjectPath) {
- LoggerD("Entered");
+ ScopeLogger();
}
PowerPlatformProxy::~PowerPlatformProxy() {
- LoggerD("Entered");
+ ScopeLogger();
}
PowerPlatformProxy& PowerPlatformProxy::GetInstance() {
- LoggerD("Entered");
+ ScopeLogger();
static PowerPlatformProxy instance;
return instance;
}
common::PlatformResult PowerPlatformProxy::LockState(int* result) {
- LoggerD("Entered PPP LockState");
+ ScopeLogger();
if (!gdbus_op_.LockState(result)) {
LoggerE("%s", gdbus_op_.GetLastError().c_str());
return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get reply from gdbus");
}
common::PlatformResult PowerPlatformProxy::UnlockState(int* result) {
- LoggerD("Entered PPP UnlockState");
+ ScopeLogger();
if (!gdbus_op_.UnlockState(result)) {
LoggerE("%s", gdbus_op_.GetLastError().c_str());
return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get reply from gdbus");
}
common::PlatformResult PowerPlatformProxy::SetBrightnessFromSettings(int* result) {
- LoggerD("Entered PPP SetBrightnessFromSettings");
+ ScopeLogger();
if (!gdbus_op_.ReleaseBrightness(result)) {
LoggerE("%s", gdbus_op_.GetLastError().c_str());
return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get reply from gdbus");
}
common::PlatformResult PowerPlatformProxy::SetBrightness(int val, int* result) {
- LoggerD("Entered PPP SetBrightness");
+ ScopeLogger();
if (!gdbus_op_.HoldBrightness(val, result)) {
LoggerE("%s", gdbus_op_.GetLastError().c_str());
return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get reply from gdbus");
}
common::PlatformResult PowerPlatformProxy::GetBrightness(int* result) {
- LoggerD("Entered PPP GetBrightness");
+ ScopeLogger();
if (!gdbus_op_.CurrentBrightness(result)) {
LoggerE("%s", gdbus_op_.GetLastError().c_str());
return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get reply from gdbus");
}
common::PlatformResult PowerPlatformProxy::IsCustomBrightness(int* result) {
- LoggerD("Entered PPP IsCustomBrightness");
+ ScopeLogger();
if (!gdbus_op_.CustomBrightness(result)) {
LoggerE("%s", gdbus_op_.GetLastError().c_str());
return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get reply from gdbus");
const auto& key = args.find(kKey)->second.get<std::string>();
common::PostCallback callback = [this](const common::TizenResult&, const picojson::value& v) {
+ ScopeLogger("Entered into asynchronous function, callback");
Post(kPreferenceChangeListenerToken, common::TizenSuccess{v});
};
const char* kValue = "value";
common::TizenResult MakeErrResult(int ret, const char* err_msg) {
+ ScopeLogger();
LoggerE("%s", err_msg);
switch (ret) {
case PREFERENCE_ERROR_INVALID_PARAMETER:
}
int GetValueInternal(const std::string& key, picojson::value* val) {
+ ScopeLogger();
char* result_str = nullptr;
int ret = preference_get_string(key.c_str(), &result_str);
ScopeLogger();
auto get_all = [](const common::PostCallback& callback) -> void {
+ ScopeLogger("Entered into asynchronous function, get_all");
picojson::value response{picojson::array{}};
auto* array = &response.get<picojson::array>();
} // namespace
PushInstance::PushInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
void PushInstance::registerService(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
common::PlatformResult result = impl->registerService(args.get("callbackId").get<double>());
}
void PushInstance::registerApplication(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
common::PlatformResult result = impl->registerApplication(args.get("callbackId").get<double>());
}
void PushInstance::unregisterService(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
void PushInstance::unregisterApplication(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
void PushInstance::connectService(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
void PushInstance::connect(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
void PushInstance::disconnectService(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
void PushInstance::disconnect(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
void PushInstance::getRegistrationId(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
void PushInstance::getUnreadNotifications(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
void PushInstance::getPushMessage(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegePush, &out);
}
void PushInstance::onPushState(push_service_state_e state, common::PlatformResult result) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value res{picojson::object()};
picojson::object& dict = res.get<picojson::object>();
void PushInstance::onPushRegister(double callbackId, common::PlatformResult result,
const std::string& id) {
+ ScopeLogger();
picojson::value res{picojson::object()};
picojson::object& dict = res.get<picojson::object>();
}
void PushInstance::onPushNotify(push_service_notification_h noti) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value res{picojson::object()};
picojson::object& dict = res.get<picojson::object>();
}
void PushInstance::onDeregister(double callbackId, common::PlatformResult result) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value res{picojson::object()};
picojson::object& dict = res.get<picojson::object>();
}
PushInstance::~PushInstance() {
- LoggerD("Enter");
+ ScopeLogger();
if (impl) {
delete impl;
impl = nullptr;
app_control_(nullptr),
operation_(nullptr),
m_ignoreNotificationEvents(true) {
- LoggerD("Enter");
+ ScopeLogger();
initPkgId();
InitAppControl();
}
PushManager::~PushManager() {
- LoggerD("Enter");
+ ScopeLogger();
m_listener = nullptr;
if (m_handle) {
}
void PushManager::initPkgId() {
- LoggerD("Enter");
+ ScopeLogger();
int pid = getpid();
char* temp = nullptr;
int ret = app_manager_get_app_id(pid, &temp);
}
void PushManager::InitAppControl() {
- LoggerD("Enter");
+ ScopeLogger();
const auto encoded_bundle = PushManagerCommon::GetEncodedBundle();
}
bool PushManager::checkRegistered_2_4() {
- LoggerD("Enter");
+ ScopeLogger();
bool result = false;
char* temp = NULL;
int ret = push_service_get_registration_id(m_handle, &temp);
}
PlatformResult PushManager::connectService() {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_CONNECTION();
m_ignoreNotificationEvents = false;
return common::PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult PushManager::connect() {
- LoggerD("Enter");
+ ScopeLogger();
if (!m_handle) {
int ret = push_service_connect(m_pkgId.c_str(), onPushState, onPushNotify, this, &m_handle);
}
PlatformResult PushManager::disconnectService() {
- LoggerD("Enter");
+ ScopeLogger();
// disconnecting from push server
if (m_handle) {
push_service_disconnect(m_handle);
}
PlatformResult PushManager::disconnect() {
- LoggerD("Enter");
+ ScopeLogger();
if (m_handle) {
push_service_disconnect(m_handle);
m_handle = nullptr;
}
PlatformResult PushManager::registerService(double callbackId) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_CONNECTION();
PushManagerHolder* holder = new PushManagerHolder{this, callbackId};
}
PlatformResult PushManager::registerApplication(double callbackId) {
- LoggerD("Enter");
+ ScopeLogger();
PushManagerHolder* holder = new PushManagerHolder{this, callbackId};
}
common::PlatformResult PushManager::unregisterService(double callbackId) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_CONNECTION();
PushManagerHolder* holder = new PushManagerHolder{this, callbackId};
}
common::PlatformResult PushManager::unregisterApplication(double callbackId) {
- LoggerD("Enter");
+ ScopeLogger();
PushManagerHolder* holder = new PushManagerHolder{this, callbackId};
int ret = push_service_deregister(m_handle, onDeregister, holder);
}
common::PlatformResult PushManager::getRegistrationId(std::string& id) {
- LoggerD("Enter");
+ ScopeLogger();
char* temp = nullptr;
int ret = push_service_get_registration_id(m_handle, &temp);
if (PUSH_SERVICE_ERROR_NONE != ret) {
}
common::PlatformResult PushManager::getUnreadNotifications() {
- LoggerD("Enter");
+ ScopeLogger();
if (!m_handle) {
return LogAndCreateResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR,
"Not connected with push service");
}
PlatformResult PushManager::getPushMessage(picojson::value* out) {
- LoggerD("Enter");
+ ScopeLogger();
push_service_notification_h handle = nullptr;
int ret = push_service_app_control_to_notification(app_control_, operation_, &handle);
}
void PushManager::onPushState(push_service_state_e state, const char* err, void* user_data) {
- LoggerD("Enter %d, err: %s", state, err);
+ ScopeLogger("state: %d; err: %s", (int)state, err);
PushManager* impl = static_cast<PushManager*>(user_data);
if (nullptr == impl || !impl->m_listener) {
LoggerW("Listener not set, ignoring");
}
void PushManager::onPushNotify(push_service_notification_h noti, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
PushManager* impl = static_cast<PushManager*>(user_data);
if (nullptr == impl || !impl->m_listener) {
LoggerW("Listener not set, ignoring");
void PushManager::onApplicationRegister(push_service_result_e result, const char* msg,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
PushManagerHolder* holder = static_cast<PushManagerHolder*>(user_data);
// automatically releases memory
// TODO duplicated code due to different error handling in 2.4 API. remove on next release
void PushManager::onApplicationRegister_2_4(push_service_result_e result, const char* msg,
void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
PushManagerHolder* holder = static_cast<PushManagerHolder*>(user_data);
// automatically releases memory
}
void PushManager::onDeregister(push_service_result_e result, const char* msg, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
PushManagerHolder* holder = static_cast<PushManagerHolder*>(user_data);
// automatically releases memory
PushManager* impl = dynamic_cast<PushManager*>(holder->impl);
// TODO duplicated code due to different error handling in 2.4 API. remove on next release
void PushManager::onDeregister_2_4(push_service_result_e result, const char* msg, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
PushManagerHolder* holder = static_cast<PushManagerHolder*>(user_data);
// automatically releases memory
PushManager* impl = dynamic_cast<PushManager*>(holder->impl);
}
gboolean PushManager::onFakeDeregister_2_4(gpointer user_data) {
- LoggerD("Enter");
+ ScopeLogger();
PushManagerHolder* holder = static_cast<PushManagerHolder*>(user_data);
// automatically releases memory
std::unique_ptr<PushManagerHolder> holder_ptr(holder);
using common::ErrorCode;
std::string PushManagerCommon::StateToString(push_service_state_e state) {
- LoggerD("Entered");
+ ScopeLogger();
switch (state) {
case PUSH_SERVICE_STATE_REGISTERED:
}
std::string PushManagerCommon::GetEncodedBundle() {
- LoggerD("Entered");
+ ScopeLogger();
std::string result;
std::size_t size = 512;
void PushManagerCommon::notificationToJson(push_service_notification_h noti,
picojson::object* obj) {
- LoggerD("Enter");
+ ScopeLogger();
char* temp = nullptr;
int ret = push_service_get_notification_data(noti, &temp);
// 3.0 version errors mappings
ErrorCode PushManagerCommon::ConvertPushError(int e) {
- LoggerD("Enter");
+ ScopeLogger();
ErrorCode error;
switch (e) {
// Different error code mappings for 2.4 implementation
ErrorCode PushManagerCommon::ConvertPushError_2_4(int e) {
- LoggerD("Enter");
+ ScopeLogger();
ErrorCode error;
switch (e) {
using namespace extension::radio;
RadioInstance::RadioInstance() : manager_(*this) {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
REGISTER_ASYNC("FMRadio_ScanStart", ScanStart);
REGISTER_ASYNC("FMRadio_ScanStop", ScanStop);
#undef REGISTER_ASYNC
-
- LoggerD("RadioInstance()");
}
RadioInstance::~RadioInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
void RadioInstance::MuteGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
ReportSuccess(picojson::value(manager_.IsMuted()), out);
}
void RadioInstance::MuteSetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.SetMute(args.get("mute").get<bool>());
ReportSuccess(out);
}
void RadioInstance::AntennaGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
ReportSuccess(picojson::value(manager_.HasAntenna()), out);
}
void RadioInstance::StateGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
ReportSuccess(picojson::value(manager_.GetState()), out);
}
void RadioInstance::FrequencyGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
ReportSuccess(picojson::value(manager_.GetFrequency()), out);
}
void RadioInstance::SignalStrengthGetter(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
ReportSuccess(picojson::value(manager_.GetSignalStrength()), out);
}
void RadioInstance::SeekUp(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.SeekUp(args.get("callbackId").get<double>());
ReportSuccess(out);
}
void RadioInstance::SeekDown(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.SeekDown(args.get("callbackId").get<double>());
ReportSuccess(out);
}
void RadioInstance::Start(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result = manager_.Start(args.get("frequency").get<double>());
}
void RadioInstance::Stop(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result = manager_.Stop();
}
void RadioInstance::ScanStart(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.ScanStart(args.get("callbackId").get<double>());
ReportSuccess(out);
}
void RadioInstance::ScanStop(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.ScanStop(args.get("callbackId").get<double>());
ReportSuccess(out);
}
void RadioInstance::SetFMRadioInterruptedListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result = manager_.SetFMRadioInterruptedListener();
void RadioInstance::UnsetFMRadioInterruptedListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result = manager_.UnsetFMRadioInterruptedListener();
}
void RadioInstance::SetAntennaChangeListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result = manager_.SetAntennaChangeListener();
}
void RadioInstance::UnsetAntennaChangeListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult result = manager_.UnsetAntennaChangeListener();
static const double FREQ_LOWER = 87.5;
static void AddCallbackID(double callbackId, picojson::object* obj) {
+ ScopeLogger();
obj->insert(std::make_pair("callbackId", picojson::value(callbackId)));
}
PlatformResult GetPlatformResult(const std::string& str, int err) {
- LoggerD("Enter");
+ ScopeLogger();
string message = str + " : " + to_string(err);
}
PlatformResult CheckError(const std::string& str, int err) {
+ ScopeLogger();
LoggerE("%s() error %d", str.c_str(), err);
switch (err) {
}
string TranslateInterruptedCode(int code) {
- LoggerD("Enter");
+ ScopeLogger();
#define STRINGIFY(c) \
case c: \
return #c
}
void RadioSeekCallback(int frequency, void* user_data) {
- LoggerD("Enter, freq: %d", frequency);
+ ScopeLogger("freq: %d", frequency);
RadioData* data = static_cast<RadioData*>(user_data);
}
void ScanStartCallback(int frequency, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
RadioScanData* data = static_cast<RadioScanData*>(user_data);
data->frequencies_.push_back(frequency);
}
void PostAsyncSuccess(FMRadioManager* manager, double callbackId, picojson::value* event) {
+ ScopeLogger();
manager->PostResultSuccess(callbackId, event);
delete event;
}
void ScanCompleteCallback(void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
RadioScanData* data = static_cast<RadioScanData*>(user_data);
}
void ScanStopCallback(void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
RadioData* data = static_cast<RadioData*>(user_data);
common::TaskQueue::GetInstance().Async(
}
void RadioInterruptedCallback(radio_interrupted_code_e code, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value event{picojson::object()};
auto& obj = event.get<picojson::object>();
}
void RadioAntennaCallback(runtime_info_key_e key, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
bool connected = false;
const auto err = runtime_info_get_value_bool(key, &connected);
} // namespace
bool FMRadioManager::IsMuted() {
- LoggerD("Enter");
+ ScopeLogger();
bool muted = false;
const auto err = radio_is_muted(radio_instance_, &muted);
}
void FMRadioManager::SetMute(bool mute) {
- LoggerD("Enter");
+ ScopeLogger();
const auto err = radio_set_mute(radio_instance_, mute);
}
bool FMRadioManager::HasAntenna() {
- LoggerD("Enter");
+ ScopeLogger();
bool connected = false;
const auto err = runtime_info_get_value_bool(RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED, &connected);
}
const char* FMRadioManager::GetState() {
- LoggerD("Enter");
+ ScopeLogger();
radio_state_e state;
}
PlatformResult FMRadioManager::SetFrequency(double frequency) {
- LoggerD("Enter");
+ ScopeLogger();
return CheckError("radio_set_frequency", radio_set_frequency(radio_instance_, TokHz(frequency)));
}
double FMRadioManager::GetFrequency() {
- LoggerD("Enter");
+ ScopeLogger();
int frequency = 0;
const auto err = radio_get_frequency(radio_instance_, &frequency);
}
double FMRadioManager::GetSignalStrength() {
- LoggerD("Enter");
+ ScopeLogger();
int strength = 0;
const auto err = radio_get_signal_strength(radio_instance_, &strength);
FMRadioManager::FMRadioManager(RadioInstance& instance)
: instance_(instance), radio_instance_(nullptr), scan_data(nullptr) {
- LoggerD("Enter");
+ ScopeLogger();
const auto err = radio_create(&radio_instance_);
}
FMRadioManager::~FMRadioManager() {
- LoggerD("Enter");
+ ScopeLogger();
if (radio_instance_) {
const auto err = radio_destroy(radio_instance_);
}
PlatformResult FMRadioManager::Start(double frequency) {
- LoggerD("Enter, frequency: %f", frequency);
+ ScopeLogger("freq: %d", frequency);
radio_state_e state;
const auto err = radio_get_state(radio_instance_, &state);
}
PlatformResult FMRadioManager::Stop() {
- LoggerD("Enter");
+ ScopeLogger();
radio_state_e state;
const auto err = radio_get_state(radio_instance_, &state);
}
void FMRadioManager::SeekUp(double callback_id) {
- LoggerD("Enter");
+ ScopeLogger();
RadioData* user_data = new RadioData(*this);
user_data->callback_id_ = callback_id;
}
void FMRadioManager::SeekDown(double callback_id) {
- LoggerD("Enter");
+ ScopeLogger();
RadioData* user_data = new RadioData(*this);
user_data->callback_id_ = callback_id;
}
void FMRadioManager::ScanStart(double callback_id) {
- LoggerD("Enter");
+ ScopeLogger();
radio_state_e state;
auto err = radio_get_state(radio_instance_, &state);
}
void FMRadioManager::ScanStop(double callback_id) {
- LoggerD("Enter");
+ ScopeLogger();
RadioScanData* user_data = new RadioScanData(*this);
user_data->callback_id_ = callback_id;
}
common::PlatformResult FMRadioManager::SetFMRadioInterruptedListener() {
- LoggerD("Enter");
+ ScopeLogger();
const auto err = radio_set_interrupted_cb(radio_instance_, RadioInterruptedCallback, this);
return CheckError("radio_set_interrupted_cb", err);
}
common::PlatformResult FMRadioManager::UnsetFMRadioInterruptedListener() {
- LoggerD("Enter");
+ ScopeLogger();
const auto err = radio_unset_interrupted_cb(radio_instance_);
return CheckError("radio_unset_interrupted_cb", err);
}
common::PlatformResult FMRadioManager::SetAntennaChangeListener() {
- LoggerD("Enter");
+ ScopeLogger();
const auto err = runtime_info_set_changed_cb(RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED,
RadioAntennaCallback, this);
}
common::PlatformResult FMRadioManager::UnsetAntennaChangeListener() {
- LoggerD("Enter");
+ ScopeLogger();
const auto err = runtime_info_unset_changed_cb(RUNTIME_INFO_KEY_AUDIO_JACK_CONNECTED);
return CheckError("runtime_info_unset_changed_cb", err);
}
void FMRadioManager::PostMessage(const std::string& msg) const {
- LoggerD("Enter");
+ ScopeLogger();
Instance::PostMessage(&instance_, msg.c_str());
}
void FMRadioManager::PostResultSuccess(double callbackId, picojson::value* event) const {
+ ScopeLogger();
auto& obj = event->get<picojson::object>();
tools::ReportSuccess(obj);
}
void FMRadioManager::PostResultCallbackSuccess(double callbackId) const {
+ ScopeLogger();
picojson::value event{picojson::object()};
PostResultSuccess(callbackId, &event);
}
void FMRadioManager::PostResultFailure(double callbackId, const PlatformResult& result) const {
+ ScopeLogger();
picojson::value event{picojson::object()};
auto& obj = event.get<picojson::object>();
CHECK_PRIVILEGE(kPrivilegeSecureElement);
auto get_readers = [this](const common::AsyncToken& token) -> void {
+ ScopeLogger("Entered into asynchronous function, get_readers");
TizenResult result = TizenSuccess();
int* readers = nullptr;
int reader = static_cast<int>(args.find(kHandle)->second.get<double>());
auto open_session = [this, reader](const common::AsyncToken& token) -> void {
+ ScopeLogger("Entered into asynchronous function, open_session");
TizenResult result = TizenSuccess();
int session = 0;
const picojson::array v_aid = args.find(kAid)->second.get<picojson::array>();
auto open_basic_channel = [this, session, v_aid](const common::AsyncToken& token) -> void {
+ ScopeLogger("Entered into asynchronous function, open_basic_channel");
TizenResult result = TizenSuccess();
int channel = 0;
unsigned char P2 = 0;
const picojson::array v_aid = args.find(kAid)->second.get<picojson::array>();
auto open_basic_logical = [this, session, v_aid](const common::AsyncToken& token) -> void {
+ ScopeLogger("Entered into asynchronous function, open_basic_logical");
TizenResult result = TizenSuccess();
int channel = 0;
unsigned char P2 = 0;
const auto& v_cmd = args.find(kCommand)->second.get<picojson::array>();
auto transmit = [this, channel, v_cmd](const common::AsyncToken& token) -> void {
+ ScopeLogger("Entered into asynchronous function, transmit");
TizenResult result = TizenSuccess();
size_t v_cmd_size = v_cmd.size();
using namespace common;
SensorInstance::SensorInstance() : service_(*this) {
- LoggerD("Entered");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
SensorInstance::~SensorInstance() {
- LoggerD("Entered");
+ ScopeLogger();
}
void SensorInstance::GetAvailableSensors(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
service_.GetAvailableSensors(out);
}
void SensorInstance::SensorStop(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
service_.SensorStop(args, out);
}
void SensorInstance::SensorSetChangeListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
service_.SensorSetChangeListener(args, out);
}
void SensorInstance::SensorUnsetChangeListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
service_.SensorUnsetChangeListener(args, out);
}
void SensorInstance::SensorStart(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
service_.SensorStart(args, out);
}
void SensorInstance::SensorGetData(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
service_.GetSensorData(args, out);
}
void SensorInstance::GetSensorHardwareInfo(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
service_.GetSensorHardwareInfo(args, out);
}
static std::map<std::string, sensor_type_e> string_to_type_map;
static std::string GetAccuracyString(int accuracy) {
- LoggerD("Entered");
+ ScopeLogger();
switch (static_cast<sensor_data_accuracy_e>(accuracy)) {
case SENSOR_DATA_ACCURACY_BAD:
return "ACCURACY_BAD";
void ReportSensorData(sensor_type_e sensor_type, sensor_event_s* sensor_event,
picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
switch (sensor_type) {
case SENSOR_LIGHT: {
}
std::string GetSensorErrorMessage(const int error_code) {
- LoggerD("Entered");
+ ScopeLogger();
switch (error_code) {
case SENSOR_ERROR_IO_ERROR:
}
PlatformResult GetSensorPlatformResult(const int error_code, const std::string& hint) {
- LoggerD("Entered");
+ ScopeLogger();
std::string message = hint + " : " + GetSensorErrorMessage(error_code);
}
bool DefaultEventComparator(sensor_event_s* l, sensor_event_s* r, const unsigned int value_count) {
+ ScopeLogger();
for (unsigned int i = 0; i < value_count; ++i) {
if (l->values[i] != r->values[i]) {
return false;
instance_(instance),
is_change_listener_set_(false),
is_starting_(false) {
+ ScopeLogger();
type_to_string_map.insert(std::make_pair(type_enum, name));
string_to_type_map.insert(std::make_pair(name, type_enum));
-
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ LoggerD("type_to_string_map is: %s", type_to_string_map[type()].c_str());
}
SensorData::~SensorData() {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
if (listener_) {
sensor_destroy_listener(listener_);
}
void SensorData::SensorCallback(sensor_h sensor, sensor_event_s* event, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
SensorData* that = static_cast<SensorData*>(user_data);
return;
}
- LoggerD("Entered: %s", type_to_string_map[that->type()].c_str());
+ LoggerD("sensor type: %s", type_to_string_map[that->type()].c_str());
{
std::lock_guard<std::mutex> lock(that->change_listener_mutex_);
if (!that->delayed_success_callbacks_.empty()) {
for_each(that->delayed_success_callbacks_.begin(), that->delayed_success_callbacks_.end(),
[](std::function<void()>& callback) {
- LoggerD("Calling delayed start succcess callback");
+ ScopeLogger(
+ "Entered into asynchronous function, calling delayed start succcess callback");
callback();
});
that->delayed_success_callbacks_.erase(that->delayed_success_callbacks_.begin(),
}
PlatformResult SensorData::CheckInitialization() {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
std::lock_guard<std::mutex> lock(initialization_mutex_);
if (!handle_) {
}
PlatformResult SensorData::IsSupported(bool* supported) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
if (!is_supported_) {
bool is_supported = false;
}
PlatformResult SensorData::IsSupportedImpl(bool* supported) const {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
bool is_supported = false;
int ret = sensor_is_supported(type_enum_, &is_supported);
}
bool SensorData::is_supported() {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
if (!is_supported_) {
bool is_supported = false;
}
bool SensorData::UpdateEvent(sensor_event_s* event) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
if (comparator_(&previous_event_, event, sensor_value_count_)) {
// previous and current events are the same -> no update
}
PlatformResult SensorData::AddDelayedStartSuccessCb(const std::function<void()>& successCb) {
- LoggerD("Entered");
+ ScopeLogger("Entered");
delayed_success_callbacks_.push_back(successCb);
if (!is_change_listener_set_ && !is_starting_) {
PlatformResult SensorData::Start(
const std::shared_ptr<picojson::value>& result,
const std::function<void(const std::shared_ptr<picojson::value>&)>& report_result) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
auto res = CheckInitialization();
if (!res) {
}
auto delayed_success_callback = [this, result, report_result]() {
- LoggerD("Delayed success callback");
+ ScopeLogger("Entered into asynchronous function, delayed succcess callback");
ReportSuccess(result->get<picojson::object>());
report_result(result);
};
}
PlatformResult SensorData::Stop() {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
auto res = CheckInitialization();
}
PlatformResult SensorData::SetChangeListener(unsigned int interval, unsigned int batch_latency) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
auto res = CheckInitialization();
}
PlatformResult SensorData::UnsetChangeListener() {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
auto res = CheckInitialization();
}
PlatformResult SensorData::GetSensorData(picojson::object* data) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
auto res = CheckInitialization();
}
PlatformResult SensorData::GetHardwareInfo(picojson::object* data) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
auto res = CheckInitialization();
};
auto native_result = [](int ret) -> PlatformResult {
+ ScopeLogger("Entered into asynchronous function, native_result");
switch (ret) {
case SENSOR_ERROR_IO_ERROR:
return PlatformResult(ErrorCode::IO_ERR);
HrmSensorData::HrmSensorData(SensorInstance& instance)
: SensorData(instance, SENSOR_CUSTOM, "HRM_RAW", 1) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
// For amount of retrieved values from sensors please refer to native guides.
AddSensor(new SensorData(instance, SENSOR_HRM_LED_IR, "LED_IR", 1));
AddSensor(new SensorData(instance, SENSOR_HRM_LED_RED, "LED_RED", 1));
}
HrmSensorData::~HrmSensorData() {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
}
void HrmSensorData::AddSensor(SensorData* sensor) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
hrm_sensors_.insert(std::make_pair(sensor->type(), std::shared_ptr<SensorData>(sensor)));
}
PlatformResult HrmSensorData::CallMember(PlatformResult (SensorData::*member)()) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
bool is_any_supported = false;
for (const auto& sensor : hrm_sensors_) {
if (sensor.second->is_supported()) {
const std::function<void(const std::shared_ptr<picojson::value>&)>&),
const std::shared_ptr<picojson::value>& result,
const std::function<void(const std::shared_ptr<picojson::value>&)>& work) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
bool is_any_supported = false;
for (const auto& sensor : hrm_sensors_) {
if (sensor.second->is_supported()) {
}
PlatformResult HrmSensorData::IsSupportedImpl(bool* supported) const {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
bool result = false;
bool hrm_supported = false;
PlatformResult HrmSensorData::Start(
const std::shared_ptr<picojson::value>& result,
const std::function<void(const std::shared_ptr<picojson::value>&)>& work) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
return CallMember(&SensorData::Start, result, work);
}
PlatformResult HrmSensorData::Stop() {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
return CallMember(&SensorData::Stop);
}
PlatformResult HrmSensorData::SetChangeListener(unsigned int interval, unsigned int batch_latency) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
for (const auto& sensor : hrm_sensors_) {
if (sensor.second->is_supported()) {
auto res = sensor.second->SetChangeListener(interval, batch_latency);
}
PlatformResult HrmSensorData::UnsetChangeListener() {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
return CallMember(&SensorData::UnsetChangeListener);
}
PlatformResult HrmSensorData::GetSensorData(picojson::object* data) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
for (const auto& sensor : hrm_sensors_) {
if (sensor.second->is_supported()) {
// HRMRawSensor.getHRMRawSensorData() can return only one value,
}
PlatformResult HrmSensorData::GetHardwareInfo(picojson::object* data) {
- LoggerD("Entered: %s", type_to_string_map[type()].c_str());
+ ScopeLogger(type_to_string_map[type()]);
for (const auto& sensor : hrm_sensors_) {
if (sensor.second->is_supported()) {
return sensor.second->GetHardwareInfo(data);
}
SensorService::SensorService(SensorInstance& instance) : instance_(instance) {
- LoggerD("Entered");
+ ScopeLogger();
// For amount of retrieved values from sensors please refer to native guides.
AddSensor(new SensorData(instance, SENSOR_LIGHT, "LIGHT", 1));
}
SensorService::~SensorService() {
- LoggerD("Entered");
+ ScopeLogger();
}
void SensorService::GetAvailableSensors(picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
bool is_supported = false;
}
void SensorService::SensorStart(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "callbackId", out)
int callback_id = static_cast<int>(args.get("callbackId").get<double>());
const std::string type_str =
sensor_type_e type_enum = string_to_type_map[type_str];
auto start_result = [this, callback_id](const std::shared_ptr<picojson::value>& result) {
- LoggerD("Entered");
+ ScopeLogger("Entered into asynchronous function, start_result");
result->get<picojson::object>()["callbackId"] =
picojson::value{static_cast<double>(callback_id)};
Instance::PostMessage(&instance_, result->serialize().c_str());
auto start = [this, type_enum, type_str,
start_result](const std::shared_ptr<picojson::value>& result) {
- LoggerD("Entered");
+
+ ScopeLogger("Entered into asynchronous function, start");
auto sensor_data = GetSensor(type_enum);
if (!sensor_data) {
LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Sensor data is null"),
}
void SensorService::SensorStop(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string type_str =
args.contains(kSensorTypeTag) ? args.get(kSensorTypeTag).get<std::string>() : "";
LoggerD("input type: %s", type_str.c_str());
}
void SensorService::SensorSetChangeListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string type_str =
args.contains(kSensorTypeTag) ? args.get(kSensorTypeTag).get<std::string>() : "";
const auto interval = args.contains(kInterval) ? args.get(kInterval).get<double>() : 100.0;
}
void SensorService::SensorUnsetChangeListener(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const std::string type_str =
args.contains(kSensorTypeTag) ? args.get(kSensorTypeTag).get<std::string>() : "";
LoggerD("input type: %s", type_str.c_str());
}
std::shared_ptr<SensorData> SensorService::GetSensor(sensor_type_e type_enum) {
- LoggerD("Entered");
+ ScopeLogger();
auto sensor = sensors_.find(type_enum);
if (sensors_.end() == sensor) {
}
void SensorService::AddSensor(SensorData* sensor) {
- LoggerD("Entered");
+ ScopeLogger();
sensors_.insert(std::make_pair(sensor->type(), std::shared_ptr<SensorData>(sensor)));
}
void SensorService::GetSensorData(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "callbackId", out);
CHECK_EXIST(args, "type", out);
sensor_type_e sensor_type = string_to_type_map[args.get("type").get<std::string>()];
auto get_data = [this, sensor_type](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, get_data");
picojson::object& object = result->get<picojson::object>();
auto sensor_data = this->GetSensor(sensor_type);
};
auto get_data_result = [this, callback_id](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, get_data_result");
result->get<picojson::object>()["callbackId"] =
picojson::value{static_cast<double>(callback_id)};
}
void SensorService::GetSensorHardwareInfo(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
CHECK_EXIST(args, "callbackId", out);
CHECK_EXIST(args, "type", out);
sensor_type_e sensor_type = string_to_type_map[args.get("type").get<std::string>()];
auto get_info = [this, sensor_type](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, get_info");
picojson::object& object = result->get<picojson::object>();
auto sensor_data = this->GetSensor(sensor_type);
};
auto get_info_result = [this, callback_id](const std::shared_ptr<picojson::value>& result) {
+ ScopeLogger("Entered into asynchronous function, get_info_result");
result->get<picojson::object>()["callbackId"] =
picojson::value{static_cast<double>(callback_id)};
Instance::PostMessage(&instance_, result->serialize().c_str());
using namespace extension::sound;
SoundInstance::SoundInstance() : manager_(*this) {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
SoundInstance::~SoundInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
#define CHECK_EXIST(args, name, out) \
}
void SoundInstance::SoundManagerGetSoundMode(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
std::string sound_mode_type;
PlatformResult status = manager_.GetSoundMode(&sound_mode_type);
}
void SoundInstance::SoundManagerSetVolume(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeSound, &out);
PlatformResult status = manager_.SetVolume(args.get<picojson::object>());
}
void SoundInstance::SoundManagerGetVolume(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
double volume;
PlatformResult status = manager_.GetVolume(args.get<picojson::object>(), &volume);
void SoundInstance::SoundManagerSetSoundModeChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = manager_.SetSoundModeChangeListener(this);
if (status.IsSuccess()) {
picojson::object& out) {
PlatformResult status = manager_.UnsetSoundModeChangeListener();
- LoggerD("Enter");
+ ScopeLogger();
if (status.IsSuccess()) {
ReportSuccess(out);
}
void SoundInstance::OnSoundModeChange(const std::string& newmode) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value event = picojson::value(picojson::object());
picojson::object& obj = event.get<picojson::object>();
picojson::value result = picojson::value(newmode);
void SoundInstance::SoundManagerSetVolumeChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = manager_.SetVolumeChangeListener();
if (status.IsSuccess()) {
void SoundInstance::SoundManagerUnsetVolumeChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
PlatformResult status = manager_.UnsetVolumeChangeListener();
if (status.IsSuccess()) {
void SoundInstance::SoundManagerGetConnectedDeviceList(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
manager_.GetDeviceList(SOUND_DEVICE_ALL_MASK, out);
}
void SoundInstance::SoundManagerGetActivatedDeviceList(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
manager_.GetDeviceList(SOUND_DEVICE_STATE_ACTIVATED_MASK, out);
}
void SoundInstance::SoundManagerAddDeviceStateChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult result = manager_.AddDeviceStateChangeListener();
if (result.IsSuccess()) {
void SoundInstance::SoundManagerRemoveDeviceStateChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult result = manager_.RemoveDeviceStateChangeListener();
if (result.IsSuccess()) {
{"VOICE", SOUND_TYPE_VOICE}, {"RINGTONE", SOUND_TYPE_RINGTONE}};
PlatformResult SoundManager::StrToPlatformEnum(const std::string& key, sound_type_e* sound_type) {
- LoggerD("Enter");
+ ScopeLogger();
if (platform_enum_map_.find(key) == platform_enum_map_.end()) {
std::string message = "Platform enum value not found for key " + key;
return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
}
PlatformResult SoundManager::PlatformEnumToStr(const sound_type_e value, std::string* sound_type) {
- LoggerD("Enter");
+ ScopeLogger();
for (auto& item : platform_enum_map_) {
if (item.second == value) {
*sound_type = item.first;
}
std::string SoundManager::SoundDeviceTypeToString(sound_device_type_e type) {
- LoggerD("Enter");
+ ScopeLogger();
switch (type) {
case SOUND_DEVICE_BUILTIN_SPEAKER:
return "SPEAKER";
}
std::string SoundManager::SoundIOTypeToString(sound_device_io_direction_e type) {
- LoggerD("Enter");
+ ScopeLogger();
switch (type) {
case SOUND_DEVICE_IO_DIRECTION_IN:
return "IN";
sound_device_state_listener_id_(0),
instance_(instance),
soundModeListener(nullptr) {
+ ScopeLogger();
FillMaxVolumeMap();
}
SoundManager::~SoundManager() {
- LoggerD("Enter");
+ ScopeLogger();
UnsetSoundModeChangeListener();
}
void SoundManager::FillMaxVolumeMap() {
- LoggerD("Enter");
+ ScopeLogger();
int max = 100;
int ret;
}
PlatformResult SoundManager::GetMaxVolume(sound_type_e type, int* max_volume) {
- LoggerD("Enter");
+ ScopeLogger();
auto it = max_volume_map_.find(type);
if (it == max_volume_map_.end()) {
std::string sound_type;
}
double SoundManager::ConvertToSystemVolume(int max_volume, int volume) {
- LoggerD("Enter");
+ ScopeLogger();
return round(static_cast<double>(volume) * 100 / max_volume) / 100;
}
void SoundManager::VolumeChangeCallback(sound_type_e type, unsigned int value) {
- LoggerD("VolumeChangeCallback: type: %d, value: %d", type, value);
+ ScopeLogger("VolumeChangeCallback: type: %d, value: %d", type, value);
// Prepare response
picojson::value response = picojson::value(picojson::object());
}
PlatformResult SoundManager::GetSoundMode(std::string* sound_mode_type) {
- LoggerD("Enter");
+ ScopeLogger();
int isEnableSound = 0;
int isEnableVibrate = 0;
}
PlatformResult SoundManager::SetVolume(const picojson::object& args) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string& type = FromJson<std::string>(args, "type");
double volume = FromJson<double>(args, "volume");
}
PlatformResult SoundManager::GetVolume(const picojson::object& args, double* volume) {
- LoggerD("Enter");
+ ScopeLogger();
const std::string& type = FromJson<std::string>(args, "type");
int value = 0;
}
void SoundManager::soundModeChangedCb(keynode_t*, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
if (nullptr == user_data) {
LoggerE("Invalid callback data!");
PlatformResult SoundManager::SetSoundModeChangeListener(
SoundManagerSoundModeChangedListener* listener) {
- LoggerD("Enter");
+ ScopeLogger();
soundModeListener = listener;
if (soundModeChangeListening) return PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult SoundManager::UnsetSoundModeChangeListener() {
- LoggerD("Enter");
+ ScopeLogger();
soundModeListener = nullptr;
if (!soundModeChangeListening) {
return PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult SoundManager::SetVolumeChangeListener() {
- LoggerD("Enter");
+ ScopeLogger();
if (!is_volume_change_listener_) {
int ret = sound_manager_add_volume_changed_cb(
[](sound_type_e type, unsigned int value, void* ud) {
+ ScopeLogger(
+ "Entered into asynchronous function, sound_manager_add_volume_changed_cb's argument");
return static_cast<SoundManager*>(ud)->VolumeChangeCallback(type, value);
},
static_cast<void*>(this), &volume_change_listener_id_);
}
PlatformResult SoundManager::UnsetVolumeChangeListener() {
- LoggerD("Enter");
+ ScopeLogger();
if (!is_volume_change_listener_) {
return PlatformResult(ErrorCode::NO_ERROR);
}
}
void SoundManager::GetDeviceList(sound_device_mask_e mask, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
sound_device_list_h device_list = nullptr;
sound_device_h device = nullptr;
PlatformResult SoundManager::GetDeviceInfo(sound_device_h device, bool is_connected,
bool check_connection, picojson::object* obj) {
- LoggerD("Entered");
+ ScopeLogger();
// get id
int id = 0;
PlatformResult SoundManager::IsDeviceConnected(sound_device_type_e type,
sound_device_io_direction_e direction,
picojson::object* obj) {
- LoggerD("Entered");
+ ScopeLogger();
sound_device_mask_e mask = SOUND_DEVICE_ALL_MASK;
switch (direction) {
}
void SoundManager::DeviceChangeCB(sound_device_h device, bool is_connected, bool check_connection) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value response = picojson::value(picojson::object());
picojson::object& response_obj = response.get<picojson::object>();
std::make_pair("listenerId", picojson::value("SoundDeviceStateChangeCallback")));
auto call_response = [this, response]() -> void {
+ ScopeLogger("Entered into asynchronous function, call_response");
Instance::PostMessage(&instance_, response.serialize().c_str());
};
}
void DeviceConnectionChangedCB(sound_device_h device, bool is_connected, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
SoundManager* h = static_cast<SoundManager*>(user_data);
h->DeviceChangeCB(device, is_connected, false);
}
void DeviceStateChangedCB(sound_device_h device, sound_device_state_e unused, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
SoundManager* h = static_cast<SoundManager*>(user_data);
h->DeviceChangeCB(device, false, true);
}
PlatformResult SoundManager::AddDeviceStateChangeListener() {
- LoggerD("Entered");
+ ScopeLogger();
int ret = SOUND_MANAGER_ERROR_NONE;
sound_device_mask_e mask = SOUND_DEVICE_ALL_MASK;
}
PlatformResult SoundManager::RemoveDeviceStateChangeListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (is_sound_device_change_listener_) {
int ret =
using common::ErrorCode;
PlatformResult SysteminfoUtils::GetVconfInt(const char *key, int *value) {
+ ScopeLogger();
if (0 == vconf_get_int(key, value)) {
LoggerD("value[%s]: %d", key, *value);
return PlatformResult(ErrorCode::NO_ERROR);
PlatformResult SysteminfoUtils::GetRuntimeInfoString(system_settings_key_e key,
std::string *platform_string) {
+ ScopeLogger();
char *platform_c_string;
int err = system_settings_get_value_string(key, &platform_c_string);
if (SYSTEM_SETTINGS_ERROR_NONE == err) {
}
PlatformResult SysteminfoUtils::CheckTelephonySupport() {
+ ScopeLogger();
bool supported = false;
PlatformResult ret =
SystemInfoDeviceCapability::GetValueBool("tizen.org/feature/network.telephony", &supported);
}
PlatformResult SysteminfoUtils::CheckCameraFlashSupport() {
+ ScopeLogger();
bool supported = false;
PlatformResult ret =
SystemInfoDeviceCapability::GetValueBool("tizen.org/feature/camera.back.flash", &supported);
}
PlatformResult SysteminfoUtils::CheckIfEthernetNetworkSupported() {
- LoggerD("Entered");
+ ScopeLogger();
connection_h connection_handle = nullptr;
connection_ethernet_state_e connection_state = CONNECTION_ETHERNET_STATE_DEACTIVATED;
}
PlatformResult SysteminfoUtils::GetTotalMemory(long long *result) {
- LoggerD("Entered");
+ ScopeLogger();
unsigned int value = 0;
}
PlatformResult SysteminfoUtils::GetAvailableMemory(long long *result) {
- LoggerD("Entered");
+ ScopeLogger();
unsigned int value = 0;
PlatformResult SysteminfoUtils::RegisterVconfCallback(const char *in_key, vconf_callback_fn cb,
void *event_ptr) {
+ ScopeLogger();
if (0 != vconf_notify_key_changed(in_key, cb, event_ptr)) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Failed to register vconf callback",
("Failed to register vconf callback: %s", in_key));
}
PlatformResult SysteminfoUtils::UnregisterVconfCallback(const char *in_key, vconf_callback_fn cb) {
+ ScopeLogger();
if (0 != vconf_ignore_key_changed(in_key, cb)) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Failed to unregister vconf callback",
("Failed to unregister vconf callback: %s", in_key));
PlatformResult SysteminfoUtils::RegisterTapiChangeCallback(TapiHandle *handle, const char *noti_id,
tapi_notification_cb callback,
void *user_data) {
+ ScopeLogger();
int ntv_ret = tel_register_noti_event(handle, noti_id, callback, user_data);
if (TAPI_API_SUCCESS != ntv_ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Failed to register tapi callback",
PlatformResult SysteminfoUtils::UnregisterTapiChangeCallback(TapiHandle *handle,
const char *noti_id) {
+ ScopeLogger();
int ntv_ret = tel_deregister_noti_event(handle, noti_id);
if (TAPI_API_SUCCESS != ntv_ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Failed to unregister tapi callback",
} // namespace
PlatformResult SystemInfoDeviceCapability::GetValueBool(const char* key, bool* value) {
+ ScopeLogger();
bool platform_result = false;
int ret = system_info_get_platform_bool(key, &platform_result);
if (SYSTEM_INFO_ERROR_NONE != ret) {
}
PlatformResult SystemInfoDeviceCapability::GetValueInt(const char* key, int* value) {
+ ScopeLogger();
int platform_result = 0;
int ret = system_info_get_platform_int(key, &platform_result);
if (SYSTEM_INFO_ERROR_NONE != ret) {
}
PlatformResult SystemInfoDeviceCapability::GetValueString(const char* key, std::string* str_value) {
+ ScopeLogger();
char* value = nullptr;
int ret = system_info_get_platform_string(key, &value);
static PlatformResult CheckStringCapability(const std::string& key, std::string* value,
bool* fetched) {
- LoggerD("Entered CheckStringCapability");
+ ScopeLogger();
*fetched = false;
if (kTizenFeatureOpenglesTextureFormat == key) {
PlatformResult ret = SystemInfoDeviceCapability::GetOpenglesTextureFormat(value);
}
static PlatformResult CheckBoolCapability(const std::string& key, bool* bool_value, bool* fetched) {
- LoggerD("Entered CheckBoolCapability");
+ ScopeLogger();
*fetched = false;
if (kTizenFeatureBluetoothAlwaysOn == key) {
*bool_value = SystemInfoDeviceCapability::IsBluetoothAlwaysOn();
static PlatformResult CheckIntCapability(const std::string& key, std::string* value,
bool* fetched) {
- LoggerD("Entered CheckIntCapability");
+ ScopeLogger();
int result = 0;
if (key == kTizenFeatureCpuFrequency) {
PlatformResult ret = SystemInfoDeviceCapability::GetPlatformCoreCpuFrequency(&result);
PlatformResult SystemInfoDeviceCapability::GetCapability(const std::string& key,
picojson::value* result) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::object& result_obj = result->get<picojson::object>();
std::string value = "";
}
PlatformResult SystemInfoDeviceCapability::IsInputKeyboardLayout(bool* result) {
+ ScopeLogger();
std::string input_keyboard_layout = "";
PlatformResult ret =
GetValueString("tizen.org/feature/input.keyboard.layout", &input_keyboard_layout);
}
PlatformResult SystemInfoDeviceCapability::GetOpenglesTextureFormat(std::string* result) {
+ ScopeLogger();
bool bool_result = false;
PlatformResult ret = GetValueBool("tizen.org/feature/opengles", &bool_result);
if (!bool_result) {
}
PlatformResult SystemInfoDeviceCapability::GetPlatfomCoreCpuArch(std::string* return_value) {
+ ScopeLogger();
std::string result;
bool bool_result = false;
std::string arch = "";
}
PlatformResult SystemInfoDeviceCapability::GetPlatfomCoreFpuArch(std::string* return_value) {
+ ScopeLogger();
std::string result;
bool bool_result = false;
PlatformResult ret = GetValueBool("tizen.org/feature/platform.core.fpu.arch.sse2", &bool_result);
}
PlatformResult SystemInfoDeviceCapability::GetProfile(std::string* return_value) {
+ ScopeLogger();
std::string profile = "";
PlatformResult ret = GetValueString("tizen.org/feature/profile", &profile);
if (ret.IsError()) {
}
bool SystemInfoDeviceCapability::IsBluetoothAlwaysOn() {
+ ScopeLogger();
#ifdef PROFILE_MOBILE_FULL
return false;
#elif PROFILE_MOBILE
}
PlatformResult SystemInfoDeviceCapability::GetPlatformCoreCpuFrequency(int* return_value) {
- LoggerD("Entered");
+ ScopeLogger();
std::string freq;
std::string file_name;
}
PlatformResult SystemInfoDeviceCapability::IsNativeOspCompatible(bool* result) {
- LoggerD("Enter");
+ ScopeLogger();
return GetValueBool(kTizenFeaturePlatformNativeOspCompatible, result);
}
PlatformResult SystemInfoDeviceCapability::GetNativeAPIVersion(std::string* return_value) {
- LoggerD("Enter");
+ ScopeLogger();
return GetValueString(kTizenFeaturePlatformNativeApiVersion, return_value);
}
PlatformResult SystemInfoDeviceCapability::GetPlatformVersionName(std::string* result) {
- LoggerD("Enter");
+ ScopeLogger();
// Because of lack of 'http://tizen.org/feature/platform.version.name'
// key on platform we use 'http://tizen.org/system/platform.name'.
}
SysteminfoInstance::SysteminfoInstance() : manager_(this) {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
SysteminfoInstance::~SysteminfoInstance() {
- LoggerD("Entered");
+ ScopeLogger();
}
void SysteminfoInstance::GetCapabilities(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: getCapabilities() is deprecated and will be removed from next release. "
"Use getCapability() instead.");
}
void SysteminfoInstance::GetCapability(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.GetCapability(args, &out);
}
void SysteminfoInstance::GetPropertyValue(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.GetPropertyValue(args, &out);
}
void SysteminfoInstance::GetPropertyValueArray(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.GetPropertyValueArray(args, &out);
}
void SysteminfoInstance::AddPropertyValueChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.AddPropertyValueChangeListener(args, &out);
}
void SysteminfoInstance::RemovePropertyValueChangeListener(const picojson::value& args,
picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.RemovePropertyValueChangeListener(args, &out);
}
void SysteminfoInstance::GetTotalMemory(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.GetTotalMemory(args, &out);
}
void SysteminfoInstance::GetAvailableMemory(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.GetAvailableMemory(args, &out);
}
void SysteminfoInstance::GetCount(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
manager_.GetCount(args, &out);
}
void SysteminfoInstance::SetBrightness(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeLED, &out);
CHECK_EXIST(args, "brightness", out)
}
void SysteminfoInstance::GetBrightness(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeLED, &out);
int brightness = 0;
}
void SysteminfoInstance::GetMaxBrightness(const picojson::value& args, picojson::object& out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeLED, &out);
int brightness = 0;
// Callback static functions
static void OnBatteryChangedCb(keynode_t* node, void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdBattery);
}
static gboolean OnCpuChangedCb(gpointer event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallCpuListenerCallback();
return G_SOURCE_CONTINUE;
}
static gboolean OnStorageChangedCb(gpointer event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallStorageListenerCallback();
return G_SOURCE_CONTINUE;
}
static void OnMmcChangedCb(keynode_t* node, void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdStorage);
}
static void OnDisplayChangedCb(keynode_t* node, void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdDisplay);
}
static void OnDeviceAutoRotationChangedCb(keynode_t* node, void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdDeviceOrientation);
}
static void OnDeviceOrientationChangedCb(sensor_t sensor, unsigned int event_type,
sensor_data_t* data, void* user_data) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(user_data);
manager->CallListenerCallback(kPropertyIdDeviceOrientation);
}
static void OnLocaleChangedCb(keynode_t* node, void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdLocale);
}
static void OnNetworkChangedCb(connection_type_e type, void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdNetwork);
}
static void OnNetworkValueChangedCb(const char* ipv4_address, const char* ipv6_address,
void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdWifiNetwork);
manager->CallListenerCallback(kPropertyIdEthernetNetwork);
}
static void OnCellularNetworkValueChangedCb(keynode_t* node, void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdCellularNetwork, kDefaultListenerIndex);
}
static void OnTapiValueChangedCb(TapiHandle* handle, const char* noti_id, void* data,
void* user_data) {
- LoggerD("Enter");
- LoggerD("Changed key: %s", noti_id);
+ ScopeLogger("Changed key: %s", noti_id);
SysteminfoManager* manager = static_cast<SysteminfoManager*>(user_data);
int index = manager->GetChangedTapiIndex(handle);
LoggerD("Changed SIM index is: %d", index);
}
static void OnPeripheralChangedCb(keynode_t* node, void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdPeripheral);
}
static void OnMemoryChangedCb(keynode_t* node, void* event_ptr) {
- LoggerD("Enter");
+ ScopeLogger();
SysteminfoManager* manager = static_cast<SysteminfoManager*>(event_ptr);
manager->CallListenerCallback(kPropertyIdMemory);
}
static void OnBrightnessChangedCb(device_callback_e type, void* value, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
if (type == DEVICE_CALLBACK_FLASH_BRIGHTNESS) {
SysteminfoManager* manager = static_cast<SysteminfoManager*>(user_data);
manager->CallListenerCallback(kPropertyIdCameraFlash);
}
static void OnWifiLevelChangedCb(wifi_manager_rssi_level_e rssi_level, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
LoggerD("Level %d", rssi_level);
SysteminfoManager* manager = static_cast<SysteminfoManager*>(user_data);
manager->SetWifiLevel(rssi_level);
class SysteminfoManager::AsynchronousOperation {
public:
AsynchronousOperation(int count_ = 0) : count_(count_) {
+ ScopeLogger();
}
~AsynchronousOperation() {
+ ScopeLogger();
std::unique_lock<std::mutex> lock(mutex_);
while (0 != count_) {
storage_event_id_(0),
connection_handle_(nullptr),
async_op_(new AsynchronousOperation()) {
- LoggerD("Entered");
+ ScopeLogger();
int error = wifi_manager_initialize(&wifi_manager_);
if (WIFI_MANAGER_ERROR_NONE != error) {
}
SysteminfoManager::~SysteminfoManager() {
- LoggerD("Enter");
+ ScopeLogger();
DisconnectSensor(sensor_handle_);
if (IsListenerRegistered(kPropertyIdBattery)) {
}
void SysteminfoManager::GetCapabilities(const picojson::value& args, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
}
void SysteminfoManager::GetCapability(const picojson::value& args, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "key", out)
const std::string& key = args.get("key").get<std::string>();
LoggerD("Getting capability with key: %s ", key.c_str());
}
void SysteminfoManager::GetPropertyValue(const picojson::value& args, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "property", out)
const double callback_id = args.get("callbackId").get<double>();
auto get = [this, prop_id,
callback_id](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Getting");
+ ScopeLogger("Entered into asynchronous function, get");
picojson::value result = picojson::value(picojson::object());
PlatformResult ret = prop_manager_.GetPropertyValue(prop_id, false, &result);
async_op_->finish();
auto get_response = [this,
callback_id](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Getting response");
+ ScopeLogger("Entered into asynchronous function, get_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value{static_cast<double>(callback_id)}));
LoggerD("message: %s", response->serialize().c_str());
}
void SysteminfoManager::GetPropertyValueArray(const picojson::value& args, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "callbackId", out)
CHECK_EXIST(args, "property", out)
const double callback_id = args.get("callbackId").get<double>();
auto get = [this, prop_id,
callback_id](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Getting");
+ ScopeLogger("Entered into asynchronous function, get");
picojson::value result = picojson::value(picojson::object());
PlatformResult ret = prop_manager_.GetPropertyValue(prop_id, true, &result);
auto get_response = [this,
callback_id](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Getting response");
+ ScopeLogger("Entered into asynchronous function, get_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
Instance::PostMessage(instance_, response->serialize().c_str());
}
void SysteminfoManager::GetTotalMemory(const picojson::value& args, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
}
void SysteminfoManager::GetAvailableMemory(const picojson::value& args, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
}
void SysteminfoManager::GetCount(const picojson::value& args, picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_EXIST(args, "property", out)
const std::string& property = args.get("property").get<std::string>();
LoggerD("Getting count of property with id: %s ", property.c_str());
void SysteminfoManager::AddPropertyValueChangeListener(const picojson::value& args,
picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
// Check type of property for which listener should be registered
CHECK_EXIST(args, "property", out)
const std::string& property_name = args.get("property").get<std::string>();
void SysteminfoManager::RemovePropertyValueChangeListener(const picojson::value& args,
picojson::object* out) {
- LoggerD("Enter");
+ ScopeLogger();
// Check type of property for which listener should be removed
CHECK_EXIST(args, "property", out)
}
bool SysteminfoManager::IsIpChangeCallbackNotRegistered() {
- LoggerD("Entered");
+ ScopeLogger();
return !(IsListenerRegistered(kPropertyIdWifiNetwork) ||
IsListenerRegistered(kPropertyIdEthernetNetwork) ||
IsListenerRegistered(kPropertyIdCellularNetwork));
}
PlatformResult SysteminfoManager::RegisterIpChangeCallback() {
- LoggerD("Entered");
+ ScopeLogger();
connection_h handle;
PlatformResult ret(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(GetConnectionHandle(handle))
}
PlatformResult SysteminfoManager::UnregisterIpChangeCallback() {
- LoggerD("Entered");
+ ScopeLogger();
connection_h handle;
PlatformResult ret(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(GetConnectionHandle(handle))
}
PlatformResult SysteminfoManager::RegisterBatteryListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(SysteminfoUtils::RegisterVconfCallback(VCONFKEY_SYSMAN_BATTERY_CAPACITY,
OnBatteryChangedCb, this))
}
PlatformResult SysteminfoManager::UnregisterBatteryListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(SysteminfoUtils::UnregisterVconfCallback(VCONFKEY_SYSMAN_BATTERY_CAPACITY,
OnBatteryChangedCb))
}
PlatformResult SysteminfoManager::RegisterCpuListener() {
- LoggerD("Entered");
+ ScopeLogger();
cpu_event_id_ =
g_timeout_add_seconds(kPropertyWatcherTime, OnCpuChangedCb, static_cast<void*>(this));
LoggerD("Added callback for CPU");
}
PlatformResult SysteminfoManager::UnregisterCpuListener() {
- LoggerD("Entered");
+ ScopeLogger();
g_source_remove(cpu_event_id_);
cpu_event_id_ = 0;
LoggerD("Removed callback for CPU");
}
PlatformResult SysteminfoManager::RegisterStorageListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(
SysteminfoUtils::RegisterVconfCallback(VCONFKEY_SYSMAN_MMC_STATUS, OnMmcChangedCb, this))
}
PlatformResult SysteminfoManager::UnregisterStorageListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(
SysteminfoUtils::UnregisterVconfCallback(VCONFKEY_SYSMAN_MMC_STATUS, OnMmcChangedCb))
}
PlatformResult SysteminfoManager::RegisterDisplayListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(SysteminfoUtils::RegisterVconfCallback(VCONFKEY_SETAPPL_LCD_BRIGHTNESS,
OnDisplayChangedCb, this))
}
PlatformResult SysteminfoManager::UnregisterDisplayListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(
SysteminfoUtils::UnregisterVconfCallback(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, OnDisplayChangedCb))
}
PlatformResult SysteminfoManager::RegisterDeviceOrientationListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(SysteminfoUtils::RegisterVconfCallback(
VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, OnDeviceAutoRotationChangedCb, this))
}
PlatformResult SysteminfoManager::UnregisterDeviceOrientationListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(SysteminfoUtils::UnregisterVconfCallback(
VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, OnDeviceAutoRotationChangedCb))
}
PlatformResult SysteminfoManager::RegisterLocaleListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(
SysteminfoUtils::RegisterVconfCallback(VCONFKEY_REGIONFORMAT, OnLocaleChangedCb, this))
}
PlatformResult SysteminfoManager::UnregisterLocaleListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(
SysteminfoUtils::UnregisterVconfCallback(VCONFKEY_REGIONFORMAT, OnLocaleChangedCb))
}
PlatformResult SysteminfoManager::RegisterNetworkListener() {
- LoggerD("Entered");
+ ScopeLogger();
connection_h handle;
PlatformResult ret(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(GetConnectionHandle(handle))
}
PlatformResult SysteminfoManager::UnregisterNetworkListener() {
- LoggerD("Entered");
+ ScopeLogger();
connection_h handle;
PlatformResult ret(ErrorCode::NO_ERROR);
CHECK_LISTENER_ERROR(GetConnectionHandle(handle))
}
PlatformResult SysteminfoManager::RegisterWifiNetworkListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (IsIpChangeCallbackNotRegistered()) {
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult SysteminfoManager::UnregisterWifiNetworkListener() {
- LoggerD("Entered");
+ ScopeLogger();
// if there is no other ip-relateded listeners left, unregister
if (IsIpChangeCallbackNotRegistered()) {
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult SysteminfoManager::RegisterEthernetNetworkListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = SysteminfoUtils::CheckIfEthernetNetworkSupported();
if (ret.IsError()) {
return ret;
}
PlatformResult SysteminfoManager::UnregisterEthernetNetworkListener() {
- LoggerD("Entered");
+ ScopeLogger();
if (IsIpChangeCallbackNotRegistered()) {
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
}
PlatformResult SysteminfoManager::RegisterCellularNetworkListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = SysteminfoUtils::CheckTelephonySupport();
if (ret.IsError()) {
return ret;
}
PlatformResult SysteminfoManager::UnregisterCellularNetworkListener() {
- LoggerD("Entered");
+ ScopeLogger();
// if there is no other ip-relateded listeners left, unregister
if (!IsListenerRegistered(kPropertyIdCellularNetwork)) {
}
PlatformResult SysteminfoManager::RegisterPeripheralListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
int value = 0;
/* if (-1 != vconf_get_int(VCONFKEY_MIRACAST_WFD_SOURCE_STATUS, &value)) {
}
PlatformResult SysteminfoManager::UnregisterPeripheralListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
int value = 0;
/* if (-1 != vconf_get_int(VCONFKEY_MIRACAST_WFD_SOURCE_STATUS, &value)) {
}
PlatformResult SysteminfoManager::RegisterMemoryListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
int value = 0;
if (-1 != vconf_get_int(VCONFKEY_SYSMAN_LOW_MEMORY, &value)) {
}
PlatformResult SysteminfoManager::UnregisterMemoryListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
int value = 0;
if (-1 != vconf_get_int(VCONFKEY_SYSMAN_LOW_MEMORY, &value)) {
}
PlatformResult SysteminfoManager::RegisterCameraFlashListener() {
- LoggerD("Entered");
+ ScopeLogger();
int ret = device_add_callback(DEVICE_CALLBACK_FLASH_BRIGHTNESS, OnBrightnessChangedCb, this);
if (DEVICE_ERROR_NONE != ret) {
return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error occured",
}
PlatformResult SysteminfoManager::UnregisterCameraFlashListener() {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
int ntv_ret = device_remove_callback(DEVICE_CALLBACK_FLASH_BRIGHTNESS, OnBrightnessChangedCb);
if (DEVICE_ERROR_NONE != ntv_ret) {
}
void SysteminfoManager::SetBrightness(const picojson::value& args, picojson::object* out) {
- LoggerD("entered");
+ ScopeLogger();
CHECK_EXIST(args, "brightness", out)
}
void SysteminfoManager::GetBrightness(const picojson::value& args, picojson::object* out) {
- LoggerD("entered");
+ ScopeLogger();
int brightness = 0;
int result = device_flash_get_brightness(&brightness);
}
void SysteminfoManager::GetMaxBrightness(const picojson::value& args, picojson::object* out) {
- LoggerD("entered");
+ ScopeLogger();
int brightness = 0;
int result = device_flash_get_max_brightness(&brightness);
PlatformResult SysteminfoManager::GetPropertyCount(const std::string& property,
unsigned long* count) {
- LoggerD("Enter");
+ ScopeLogger();
if ("BATTERY" == property || "CPU" == property || "STORAGE" == property ||
"DISPLAY" == property || "DEVICE_ORIENTATION" == property || "BUILD" == property ||
}
wifi_manager_rssi_level_e SysteminfoManager::GetWifiLevel() {
- LoggerD("Enter");
+ ScopeLogger();
return wifi_level_;
}
void SysteminfoManager::SetWifiLevel(wifi_manager_rssi_level_e level) {
- LoggerD("Entered");
+ ScopeLogger();
wifi_level_ = level;
}
int SysteminfoManager::GetSensorHandle() {
- LoggerD("Enter");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(sensor_mutex_);
if (sensor_handle_ < 0) {
LoggerD("Connecting to sensor");
}
PlatformResult SysteminfoManager::ConnectSensor(int* result) {
- LoggerD("Entered");
+ ScopeLogger();
sensor_t sensor = sensord_get_sensor(AUTO_ROTATION_SENSOR);
int handle_orientation = sensord_connect(sensor);
if (handle_orientation < 0) {
}
void SysteminfoManager::DisconnectSensor(int handle_orientation) {
- LoggerD("Enter");
+ ScopeLogger();
if (handle_orientation >= 0) {
- LoggerD("Entered");
+ ScopeLogger();
bool state = sensord_stop(handle_orientation);
LoggerD("sensord_stop() returned state = %d", state);
state = sensord_disconnect(handle_orientation);
}
void SysteminfoManager::SetCpuInfoLoad(double load) {
- LoggerD("Enter");
+ ScopeLogger();
cpu_load_ = load;
}
void SysteminfoManager::SetAvailableCapacityInternal(unsigned long long capacity) {
- LoggerD("Entered");
+ ScopeLogger();
available_capacity_internal_ = capacity;
}
void SysteminfoManager::SetAvailableCapacityMmc(unsigned long long capacity) {
- LoggerD("Entered");
+ ScopeLogger();
available_capacity_mmc_ = capacity;
}
}
void SysteminfoManager::InitCameraTypes() {
- LoggerD("Enter");
+ ScopeLogger();
bool supported = false;
PlatformResult ret =
SystemInfoDeviceCapability::GetValueBool("tizen.org/feature/camera.back.flash", &supported);
}
std::string SysteminfoManager::GetCameraTypes(unsigned int index) {
- LoggerD("Enter");
+ ScopeLogger();
if (index >= camera_types_.size()) {
return "";
}
}
unsigned int SysteminfoManager::GetCameraTypesCount() {
- LoggerD("Enter");
+ ScopeLogger();
return camera_types_.size();
}
PlatformResult SysteminfoManager::GetConnectionHandle(connection_h& handle) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(connection_mutex_);
if (nullptr == connection_handle_) {
int error = connection_create(&connection_handle_);
}
bool SysteminfoManager::IsListenerRegistered(const std::string& property_id) {
- LoggerD("Entered");
+ ScopeLogger();
return (registered_listeners_.find(property_id) != registered_listeners_.end());
}
void SysteminfoManager::PostListenerResponse(const std::string& property_id,
const picojson::value& result, int property_index) {
- LoggerD("Entered");
+ ScopeLogger();
const std::shared_ptr<picojson::value>& response =
std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
response->get<picojson::object>()[kPropertyIdString] = picojson::value(property_id);
}
void SysteminfoManager::CallListenerCallback(const std::string& property_id, int property_index) {
- LoggerD("Enter");
+ ScopeLogger();
if (IsListenerRegistered(property_id)) {
LoggerD("listener for %s property is registered, calling it", property_id.c_str());
}
void SysteminfoManager::CallCpuListenerCallback() {
- LoggerD("Enter");
+ ScopeLogger();
std::string property_id = kPropertyIdCpu;
if (IsListenerRegistered(property_id)) {
LoggerD("listener for %s property is registered, calling it", property_id.c_str());
}
void SysteminfoManager::CallStorageListenerCallback() {
- LoggerD("Enter");
+ ScopeLogger();
std::string property_id = kPropertyIdStorage;
if (IsListenerRegistered(property_id)) {
LoggerD("listener for %s property is registered, calling it", property_id.c_str());
SysteminfoPropertiesManager::SysteminfoPropertiesManager(SysteminfoManager& manager)
: manager_(manager) {
- LoggerD("Entered");
+ ScopeLogger();
}
SysteminfoPropertiesManager::~SysteminfoPropertiesManager() {
- LoggerD("Entered");
+ ScopeLogger();
}
PlatformResult SysteminfoPropertiesManager::GetPropertyValue(const std::string& property,
bool is_array_type,
picojson::value* res) {
- LoggerD("Entered getPropertyValue");
+ ScopeLogger();
if (!is_array_type) {
picojson::object& res_obj = res->get<picojson::object>();
PlatformResult SysteminfoPropertiesManager::ReportProperty(const std::string& property, int index,
picojson::object* res_obj) {
- LoggerD("Entered");
+ ScopeLogger();
if ("BATTERY" == property) {
return ReportBattery(res_obj);
} else if ("CPU" == property) {
/// BATTERY
PlatformResult SysteminfoPropertiesManager::ReportBattery(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
int value = 0;
int ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &value);
if (kVconfErrorNone != ret) {
/// CPU
PlatformResult SysteminfoPropertiesManager::ReportCpu(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
static CpuInfo cpu_info;
FILE* fp = nullptr;
fp = fopen("/proc/stat", "r");
/// DISPLAY
PlatformResult SysteminfoPropertiesManager::ReportDisplay(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
int screenWidth = 0;
int screenHeight = 0;
int dotsPerInchWidth = 0;
/// DEVICE_ORIENTATION
PlatformResult SysteminfoPropertiesManager::FetchIsAutoRotation(bool* result) {
- LoggerD("Entered");
+ ScopeLogger();
int is_auto_rotation = 0;
if (0 == vconf_get_bool(VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL, &is_auto_rotation)) {
}
PlatformResult SysteminfoPropertiesManager::FetchStatus(std::string* result) {
- LoggerD("Entered");
+ ScopeLogger();
int rotation = 0;
std::string status = kOrientationPortraitPrimary;
}
PlatformResult SysteminfoPropertiesManager::ReportDeviceOrientation(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
bool is_auto_rotation = false;
std::string status = "";
/// BUILD
PlatformResult SysteminfoPropertiesManager::ReportBuild(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string model = "";
PlatformResult ret =
SystemInfoDeviceCapability::GetValueString("tizen.org/system/model_name", &model);
/// LOCALE
PlatformResult SysteminfoPropertiesManager::ReportLocale(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string str_language = "";
PlatformResult ret =
SysteminfoUtils::GetRuntimeInfoString(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE, &str_language);
/// NETWORK
static PlatformResult GetNetworkTypeString(NetworkType type, std::string& type_string) {
- LoggerD("Entered");
+ ScopeLogger();
switch (type) {
case kNone:
type_string = kNetworkTypeNone;
PlatformResult SysteminfoPropertiesManager::ReportNetwork(picojson::object* out,
unsigned long count) {
- LoggerD("Entered with index property %d", count);
+ ScopeLogger("index property %d", count);
connection_h connection_handle = nullptr;
connection_type_e connection_type = CONNECTION_TYPE_DISCONNECTED;
int networkType = 0;
/// WIFI_NETWORK
static PlatformResult GetIpsWifi(wifi_manager_ap_h wifi_ap_handle, std::string* ip_addr_str,
std::string* ipv6_addr_str) {
- LoggerD("Entered");
+ ScopeLogger();
// getting ipv4 address
char* ip_addr = nullptr;
int error =
/// CELLULAR_NETWORK and ETHERNET_NETWORK
static PlatformResult GetIpsFromProfile(connection_profile_h profile_handle,
std::string* ip_addr_str, std::string* ipv6_addr_str) {
- LoggerD("Entered");
+ ScopeLogger();
// getting ipv4 address
char* ip_addr = nullptr;
int error =
}
PlatformResult SysteminfoPropertiesManager::ReportWifiNetwork(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
bool result_status = false;
std::string result_ssid;
/// ETHERNET_NETWORK
PlatformResult SysteminfoPropertiesManager::ReportEthernetNetwork(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string result_cable;
std::string result_status;
static PlatformResult FetchConnection(std::string* result_status, std::string* result_apn,
std::string* result_ip_address,
std::string* result_ipv6_address) {
- LoggerD("Entered");
+ ScopeLogger();
connection_type_e connection_type = CONNECTION_TYPE_DISCONNECTED;
connection_profile_h profile_handle = nullptr;
connection_h connection_handle = nullptr;
PlatformResult SysteminfoPropertiesManager::ReportCellularNetwork(picojson::object* out,
unsigned long count) {
- LoggerD("Entered with index property %d", count);
+ ScopeLogger("index property %lu", count);
PlatformResult ret = SysteminfoUtils::CheckTelephonySupport();
if (ret.IsError()) {
return ret;
/// NET_PROXY_NETWORK
PlatformResult SysteminfoPropertiesManager::ReportNetProxyNetwork(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
connection_type_e connection_type = CONNECTION_TYPE_DISCONNECTED;
connection_h connection_handle = nullptr;
std::string result_status;
/// SIM
PlatformResult SysteminfoPropertiesManager::ReportSim(picojson::object* out, unsigned long count) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult ret = SysteminfoUtils::CheckTelephonySupport();
if (ret.IsError()) {
return ret;
/// PERIPHERAL
PlatformResult SysteminfoPropertiesManager::ReportPeripheral(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
/* int wireless_display_status = 0;
PlatformResult ret = GetVconfInt(VCONFKEY_MIRACAST_WFD_SOURCE_STATUS, &wireless_display_status);
if (ret.IsSuccess()) {
/// MEMORY
PlatformResult SysteminfoPropertiesManager::ReportMemory(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string state = kMemoryStateNormal;
int status = 0;
PlatformResult ret = SysteminfoUtils::GetVconfInt(VCONFKEY_SYSMAN_LOW_MEMORY, &status);
}
static void CreateStorageInfo(const std::string& type, struct statvfs& fs, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
out->insert(std::make_pair("type", picojson::value(type)));
out->insert(std::make_pair(
"capacity", picojson::value(std::to_string(static_cast<unsigned long long>(fs.f_frsize) *
}
PlatformResult SysteminfoPropertiesManager::ReportStorage(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
struct statvfs fs;
picojson::value result = picojson::value(picojson::array());
PlatformResult SysteminfoPropertiesManager::ReportCameraFlash(picojson::object* out,
unsigned long index) {
- LoggerD("Entered");
+ ScopeLogger();
if (index < manager_.GetCameraTypesCount()) {
std::string camera = manager_.GetCameraTypes(index);
out->insert(std::make_pair("camera", picojson::value(camera)));
/// ADS
PlatformResult SysteminfoPropertiesManager::ReportAds(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string ads_id = "";
PlatformResult ret = SysteminfoUtils::GetRuntimeInfoString(SYSTEM_SETTINGS_KEY_ADS_ID, &ads_id);
if (ret.IsError()) {
const char* kSimStatusUnknown = "UNKNOWN";
void SimCphsValueCallback(TapiHandle* /*handle*/, int result, void* data, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
SimDetailsManager* sim_mgr = static_cast<SimDetailsManager*>(user_data);
TelSimAccessResult_t access_rt = static_cast<TelSimAccessResult_t>(result);
TelSimCphsNetName_t* cphs_info = static_cast<TelSimCphsNetName_t*>(data);
}
void SimMsisdnValueCallback(TapiHandle* /*handle*/, int result, void* data, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
SimDetailsManager* sim_mgr = static_cast<SimDetailsManager*>(user_data);
TelSimAccessResult_t access_rt = static_cast<TelSimAccessResult_t>(result);
TelSimMsisdnList_t* msisdn_info = static_cast<TelSimMsisdnList_t*>(data);
}
void SimSpnValueCallback(TapiHandle* /*handle*/, int result, void* data, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
SimDetailsManager* sim_mgr = static_cast<SimDetailsManager*>(user_data);
TelSimAccessResult_t access_rt = static_cast<TelSimAccessResult_t>(result);
TelSimSpn_t* spn_info = static_cast<TelSimSpn_t*>(data);
}
void SimIccidValueCallback(TapiHandle* /*handle*/, int result, void* data, void* user_data) {
- LoggerD("Entered");
+ ScopeLogger();
SimDetailsManager* sim_mgr = static_cast<SimDetailsManager*>(user_data);
TelSimAccessResult_t access_rt = static_cast<TelSimAccessResult_t>(result);
TelSimIccIdInfo_t* iccid_info = static_cast<TelSimIccIdInfo_t*>(data);
spn_(""),
sim_result_obj_(nullptr),
to_process_(0) {
+ ScopeLogger();
}
PlatformResult SimDetailsManager::GatherSimInformation(TapiHandle* handle, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> first_lock_sim(sim_info_mutex_);
ResetSimHolder(out);
}
void SimDetailsManager::FetchSimState(TapiHandle* tapi_handle) {
- LoggerD("Entered");
+ ScopeLogger();
if (nullptr == tapi_handle) {
LoggerE("Tapi handle is null");
state_ = kSimStatusUnknown;
}
PlatformResult SimDetailsManager::FetchSimSyncProps(TapiHandle* tapi_handle) {
- LoggerD("Entered");
+ ScopeLogger();
TelSimImsiInfo_t imsi;
int error = tel_get_sim_imsi(tapi_handle, &imsi);
if (TAPI_API_SUCCESS == error) {
}
void SimDetailsManager::ResetSimHolder(picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
sim_result_obj_ = out;
to_process_ = 0;
mcc_ = 0;
}
void SimDetailsManager::ReturnSimToJS() {
- LoggerD("Entered");
+ ScopeLogger();
if (nullptr != sim_result_obj_) {
sim_result_obj_->insert(std::make_pair("state", picojson::value(state_)));
sim_result_obj_->insert(std::make_pair("operatorName", picojson::value(operator_name_)));
}
void SimDetailsManager::TryReturn() {
- LoggerD("Entered");
+ ScopeLogger();
if (0 == to_process_) {
LoggerD("Returning property to JS");
ReturnSimToJS();
}
void SimDetailsManager::set_operator_name(const std::string& name) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(sim_to_process_mutex_);
operator_name_ = name;
--to_process_;
};
void SimDetailsManager::set_msisdn(const std::string& msisdn) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(sim_to_process_mutex_);
this->msisdn_ = msisdn;
--to_process_;
};
void SimDetailsManager::set_spn(const std::string& spn) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(sim_to_process_mutex_);
this->spn_ = spn;
--to_process_;
};
void SimDetailsManager::set_iccid(const std::string& iccid) {
- LoggerD("Entered");
+ ScopeLogger();
std::lock_guard<std::mutex> lock(sim_to_process_mutex_);
this->iccid_ = iccid;
--to_process_;
using namespace extension::systemsetting;
SystemSettingInstance::SystemSettingInstance() {
- LoggerD("Enter");
+ ScopeLogger();
using std::placeholders::_1;
using std::placeholders::_2;
}
SystemSettingInstance::~SystemSettingInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
void SystemSettingInstance::getProperty(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
const double callback_id = args.get("callbackId").get<double>();
const std::string& type = args.get("type").get<std::string>();
LoggerD("Getting property type: %s ", type.c_str());
auto get = [this, type](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Getting platform value");
+ ScopeLogger("Entered into asynchronous function, get");
picojson::value result = picojson::value(picojson::object());
PlatformResult status = getPlatformPropertyValue(type, &result);
if (status.IsSuccess()) {
auto get_response = [this,
callback_id](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Getting response");
+ ScopeLogger("Entered into asynchronous function, get_response");
picojson::object& obj = response->get<picojson::object>();
obj.insert(std::make_pair("callbackId", picojson::value(callback_id)));
Instance::PostMessage(this, response->serialize().c_str());
PlatformResult SystemSettingInstance::getPlatformPropertyValue(const std::string& settingType,
picojson::value* out) {
- LoggerD("Enter");
+ ScopeLogger();
picojson::object& result_obj = out->get<picojson::object>();
int ret = SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER;
}
void SystemSettingInstance::setProperty(const picojson::value& args, picojson::object& out) {
- LoggerD("Enter");
+ ScopeLogger();
CHECK_PRIVILEGE_ACCESS(kPrivilegeSetting, &out);
auto get = [this, type, value,
callback_id](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Setting platform value");
+ ScopeLogger("Entered into asynchronous function, get");
std::string real_path = common::FilesystemProvider::Create().GetRealPath(value);
PlatformResult status = setPlatformPropertyValue(type, real_path);
picojson::object& obj = response->get<picojson::object>();
PlatformResult SystemSettingInstance::setPlatformPropertyValue(const std::string& settingType,
const std::string& settingValue) {
- LoggerD("Enter");
+ ScopeLogger();
int ret = SYSTEM_SETTINGS_ERROR_INVALID_PARAMETER;
if (settingType == SETTING_HOME_SCREEN) {
ret = system_settings_set_value_string(SYSTEM_SETTINGS_KEY_WALLPAPER_HOME_SCREEN,
#include "time/time_instance.h"
common::Extension* CreateExtension() {
- LoggerD("Entered");
+ ScopeLogger();
return new TimeExtension;
}
extern const char kSource_time_api[];
TimeExtension::TimeExtension() {
- LoggerD("Entered");
+ ScopeLogger();
SetExtensionName("tizen.time");
SetJavaScriptAPI(kSource_time_api);
}
TimeExtension::~TimeExtension() {
- LoggerD("Entered");
+ ScopeLogger();
}
common::Instance* TimeExtension::CreateInstance() {
- LoggerD("Entered");
+ ScopeLogger();
return new extension::time::TimeInstance();
}
using std::placeholders::_1;
using std::placeholders::_2;
- LoggerD("Entered");
+ ScopeLogger();
#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&TimeInstance::x, this, _1, _2));
#define REGISTER_ASYNC(c, x) RegisterSyncHandler(c, std::bind(&TimeInstance::x, this, _1, _2));
}
TimeInstance::~TimeInstance() {
- LoggerD("Entered");
+ ScopeLogger();
}
void TimeInstance::TimeUtil_getAvailableTimezones(const picojson::value& /*args*/,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
picojson::value result = picojson::value(picojson::object());
picojson::object& result_obj = result.get<picojson::object>();
}
void TimeInstance::TimeUtil_getDateFormat(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!args.contains("shortformat")) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed."),
&out, ("Required parameter \"shortformat\" is missing"));
void TimeInstance::TimeUtil_getTimeFormat(const picojson::value& /* args */,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string format;
PlatformResult res = TimeUtilTools::GetTimeFormat(&format);
if (res.IsError()) {
void TimeInstance::TimeUtil_setDateTimeChangeListener(const picojson::value& /*args*/,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult res = manager_.RegisterVconfCallback(kTimeChange);
if (res.IsError()) {
LogAndReportError(res, &out, ("Failed to set date-time change listener."));
void TimeInstance::TimeUtil_unsetDateTimeChangeListener(const picojson::value& /*args*/,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult res = manager_.UnregisterVconfCallback(kTimeChange);
if (res.IsError()) {
LogAndReportError(res, &out, ("Failed to remove date-time change listener."));
void TimeInstance::TimeUtil_setTimezoneChangeListener(const picojson::value& /*args*/,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult res = manager_.RegisterVconfCallback(kTimezoneChange);
if (res.IsError()) {
LogAndReportError(res, &out, ("Failed to set timezone change listener."));
void TimeInstance::TimeUtil_unsetTimezoneChangeListener(const picojson::value& /*args*/,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
PlatformResult res = manager_.UnregisterVconfCallback(kTimezoneChange);
if (res.IsError()) {
LogAndReportError(res, &out, ("Failed to remove timezone change listener."));
}
void TimeInstance::TZDate_getLocalTimezone(const picojson::value& /*args*/, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string local_timezone = TimeManager::GetDefaultTimezone();
}
void TimeInstance::TZDate_GetTimezoneOffset(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!args.contains("timezone") || !args.contains("timestamp")) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed."),
&out, ("Required parameters are missing: \"timezone\", \"timestamp\""));
void TimeInstance::ToStringTemplate(const picojson::value& args, bool use_locale_fmt,
TimeUtilTools::DateTimeFormatType type, picojson::object* out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!args.contains("timezone") || !args.contains("timestamp")) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed."),
out, ("Required parameters are missing: \"timezone\", \"timestamp\""));
}
void TimeInstance::TZDate_toLocaleDateString(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
ToStringTemplate(args, true, TimeUtilTools::DateTimeFormatType::kDateFormat, &out);
}
void TimeInstance::TZDate_toLocaleTimeString(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
ToStringTemplate(args, true, TimeUtilTools::DateTimeFormatType::kTimeFormat, &out);
}
void TimeInstance::TZDate_toLocaleString(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
ToStringTemplate(args, true, TimeUtilTools::DateTimeFormatType::kDateTimeFormat, &out);
}
void TimeInstance::TZDate_toDateString(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
ToStringTemplate(args, false, TimeUtilTools::DateTimeFormatType::kDateFormat, &out);
}
void TimeInstance::TZDate_toTimeString(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
ToStringTemplate(args, false, TimeUtilTools::DateTimeFormatType::kTimeFormat, &out);
}
void TimeInstance::TZDate_toString(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
ToStringTemplate(args, false, TimeUtilTools::DateTimeFormatType::kDateTimeFormat, &out);
}
void TimeInstance::TZDate_getTimezoneAbbreviation(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
LoggerW(
"DEPRECATION WARNING: getTimezoneAbbreviation() is deprecated and will be removed from next "
"release.");
}
void TimeInstance::TZDate_isDST(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!args.contains("timezone") || !args.contains("timestamp")) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed."),
&out, ("Required parameters are missing: \"timezone\", \"timestamp\""));
void TimeInstance::TZDate_getPreviousDSTTransition(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!args.contains("timezone") || !args.contains("timestamp")) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed."),
&out, ("Required parameters are missing: \"timezone\", \"timestamp\""));
}
void TimeInstance::TZDate_getNextDSTTransition(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
if (!args.contains("timezone") || !args.contains("timestamp")) {
LogAndReportError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid parameter passed."),
&out, ("Required parameters are missing: \"timezone\", \"timestamp\""));
current_timezone_(GetDefaultTimezone()),
is_time_listener_registered_(false),
is_timezone_listener_registered_(false) {
- LoggerD("Entered");
+ ScopeLogger();
}
TimeManager::~TimeManager() {
- LoggerD("Entered");
+ ScopeLogger();
if (is_time_listener_registered_) {
UnregisterVconfCallback(kTimeChange);
}
PlatformResult TimeManager::GetTimezoneOffset(const std::string& timezone_id,
const std::string& timestamp_str, std::string* offset,
std::string* modifier) {
- LoggerD("Entered");
+ ScopeLogger();
std::unique_ptr<UnicodeString> unicode_id(new UnicodeString(timezone_id.c_str()));
std::unique_ptr<TimeZone> tz(TimeZone::createTimeZone(*unicode_id));
}
PlatformResult TimeManager::RegisterVconfCallback(ListenerType type) {
- LoggerD("Entered");
+ ScopeLogger();
if (!is_time_listener_registered_ && !is_timezone_listener_registered_) {
LoggerD("registering listener on platform");
if (0 != vconf_notify_key_changed(VCONFKEY_SYSTEM_TIME_CHANGED, OnTimeChangedCallback, this)) {
}
PlatformResult TimeManager::UnregisterVconfCallback(ListenerType type) {
- LoggerD("Entered");
+ ScopeLogger();
switch (type) {
case kTimeChange:
is_time_listener_registered_ = false;
}
void TimeManager::OnTimeChangedCallback(keynode_t* /*node*/, void* event_ptr) {
- LoggerD("Entered");
+ ScopeLogger();
TimeManager* manager = static_cast<TimeManager*>(event_ptr);
TimeInstance* instance = manager->GetTimeInstance();
std::string defaultTimezone = GetDefaultTimezone();
}
std::string TimeManager::GetDefaultTimezone() {
- LoggerD("Entered");
+ ScopeLogger();
std::unique_ptr<TimeZone> tz(TimeZone::createDefault());
}
std::string TimeManager::GetCurrentTimezone() {
- LoggerD("Entered");
return current_timezone_;
}
void TimeManager::SetCurrentTimezone(const std::string& new_timezone) {
- LoggerD("Entered");
current_timezone_ = new_timezone;
}
TimeInstance* TimeManager::GetTimeInstance() {
- LoggerD("Entered");
return instance_;
}
UDate TimeUtilTools::GetDSTTransition(UDate timestamp,
const std::shared_ptr<UnicodeString>& timezone_id,
DSTTransition tr_type) {
- LoggerD("Entered");
+ ScopeLogger();
UBool result = false;
UDate dst_transition_date = timestamp;
std::unique_ptr<VTimeZone> vtz(VTimeZone::createVTimeZoneByID(*timezone_id));
PlatformResult TimeUtilTools::IsDST(UDate timestamp,
const std::shared_ptr<UnicodeString>& timezone_id,
bool* result_bool) {
- LoggerD("Entered");
+ ScopeLogger();
UErrorCode ec = U_ZERO_ERROR;
std::unique_ptr<TimeZone> tz(TimeZone::createTimeZone(*timezone_id));
std::unique_ptr<icu::Calendar> calendar(Calendar::createInstance(*tz, ec));
PlatformResult TimeUtilTools::GetTimezoneAbbreviation(
UDate date, const std::shared_ptr<UnicodeString>& timezone_id, std::string* result_string) {
- LoggerD("Entered");
+ ScopeLogger();
UErrorCode ec = U_ZERO_ERROR;
UnicodeString str;
bool use_locale_fmt,
TimeUtilTools::DateTimeFormatType type,
std::string* result_string) {
- LoggerD("Entered");
+ ScopeLogger();
UErrorCode ec = U_ZERO_ERROR;
UnicodeString str;
PlatformResult TimeUtilTools::ToUTF8String(const UnicodeString& uni_str,
std::string* result_string) {
- LoggerD("Entered");
+ ScopeLogger();
int buffer_len = sizeof(UChar) * static_cast<int>(uni_str.length()) + 1;
std::unique_ptr<char, void (*)(void*)> result_buffer(static_cast<char*>(malloc(buffer_len)),
}
UnicodeString* TimeUtilTools::ToUnicodeString(const std::string& str) {
- LoggerD("Entered");
+ ScopeLogger();
return new UnicodeString(str.c_str());
}
PlatformResult TimeUtilTools::GetLocalTimeZone(std::string* result_string) {
- LoggerD("Entered");
+ ScopeLogger();
UnicodeString id;
std::unique_ptr<TimeZone> zone(TimeZone::createDefault());
zone->getID(id);
}
Locale* TimeUtilTools::GetDefaultLocale() {
- LoggerD("Entered");
+ ScopeLogger();
char* tempstr = vconf_get_str(VCONFKEY_REGIONFORMAT);
if (nullptr == tempstr) {
}
UnicodeString TimeUtilTools::GetDateTimeFormat(DateTimeFormatType type, bool use_locale_fmt) {
- LoggerD("Entered");
+ ScopeLogger();
UErrorCode ec = U_ZERO_ERROR;
Locale* default_locale = GetDefaultLocale();
}
PlatformResult TimeUtilTools::GetDateFormat(bool shortformat, std::string* result_string) {
- LoggerD("Entered");
+ ScopeLogger();
UnicodeString time_format = TimeUtilTools::GetDateTimeFormat(
(shortformat ? DateTimeFormatType::kDateShortFormat : DateTimeFormatType::kDateFormat), true);
time_format = time_format.findAndReplace("E", "D");
}
PlatformResult TimeUtilTools::GetTimeFormat(std::string* result_string) {
- LoggerD("Entered");
+ ScopeLogger();
UnicodeString time_format =
TimeUtilTools::GetDateTimeFormat(DateTimeFormatType::kTimeFormat, true);
time_format = time_format.findAndReplace("H", "h");
}
PlatformResult TimeUtilTools::GetAvailableTimezones(picojson::array* available_timezones) {
- LoggerD("Entered");
+ ScopeLogger();
UErrorCode ec = U_ZERO_ERROR;
std::unique_ptr<StringEnumeration> tz_enum(TimeZone::createEnumeration());
const char* str = nullptr;
namespace tvinputdevice {
TVInputDeviceInstance::TVInputDeviceInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
TVInputDeviceInstance::~TVInputDeviceInstance() {
- LoggerD("Enter");
+ ScopeLogger();
}
} // namespace tvinputdevice
extern const char kSource_utils_api[];
common::Extension* CreateExtension() {
- LoggerD("Entered");
+ ScopeLogger();
return new UtilsExtension;
}
UtilsExtension::UtilsExtension() {
- LoggerD("Entered");
+ ScopeLogger();
SetExtensionName("xwalk");
SetJavaScriptAPI(kSource_utils_api);
}
UtilsExtension::~UtilsExtension() {
- LoggerD("Entered");
+ ScopeLogger();
}
common::Instance* UtilsExtension::CreateInstance() {
- LoggerD("Entered");
+ ScopeLogger();
return new extension::utils::UtilsInstance();
}
using std::placeholders::_1;
using std::placeholders::_2;
- LoggerD("Entered");
+ ScopeLogger();
#define REGISTER_SYNC(c, x) RegisterSyncHandler(c, std::bind(&UtilsInstance::x, this, _1, _2));
#define REGISTER_ASYNC(c, x) RegisterSyncHandler(c, std::bind(&UtilsInstance::x, this, _1, _2));
}
void UtilsInstance::GetPkgApiVersion(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
std::string api_version;
PlatformResult ret = common::tools::GetPkgApiVersion(&api_version);
}
void UtilsInstance::CheckPrivilegeAccess(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& privilege = args.get("privilege").to_str();
CHECK_PRIVILEGE_ACCESS(privilege, &out);
ReportSuccess(out);
void UtilsInstance::CheckBackwardCompabilityPrivilegeAccess(const picojson::value& args,
picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& current_priv = args.get("current_privilege").to_str();
const auto& prev_priv = args.get("previous_privilege").to_str();
} // namespace
void UtilsInstance::ToLongLong(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& n = args.get("n");
long long output = 0;
}
void UtilsInstance::ToUnsignedLongLong(const picojson::value& args, picojson::object& out) {
- LoggerD("Entered");
+ ScopeLogger();
const auto& n = args.get("n");
unsigned long long output = 0;
}
WebSettingExtension::WebSettingExtension() {
- LoggerD("Entered");
+ ScopeLogger();
SetExtensionName("tizen.websetting");
SetJavaScriptAPI(kSource_websetting_api);
}
WebSettingExtension::~WebSettingExtension() {
- LoggerD("Entered");
+ ScopeLogger();
}
common::Instance* WebSettingExtension::CreateInstance() {
- LoggerD("Entered");
+ ScopeLogger();
return new common::ParsedInstance();
}
}
void bundleIterator(const char* key, const char* val, void* data) {
- LOGD("Entered, adding key-pair value: (%s) - (%s)", key, val);
+ ScopeLogger("adding key-pair value: %s; val: %s", key, val);
auto obj = static_cast<picojson::object*>(data);
obj->insert(std::make_pair(key, picojson::value(val)));
}
}
auto get_widgets = [this, pkgid](const common::AsyncToken& token) -> void {
+ ScopeLogger("Entered into asynchronous function, get_widget");
int ret = WIDGET_ERROR_NONE;
picojson::value response{picojson::array{}};
auto* array = &response.get<picojson::array>();
const auto& widget_id = args.find(kWidgetId)->second.get<std::string>();
auto get_instances = [this, widget_id](const common::AsyncToken& token) -> void {
+ ScopeLogger("Entered into asynchronous function, get_instances");
picojson::value response{picojson::array{}};
auto* array = &response.get<picojson::array>();
const auto& widget_id = args.find(kWidgetId)->second.get<std::string>();
auto get_variants = [this, widget_id](const common::AsyncToken& token) -> void {
+ ScopeLogger("Entered into asynchronous function, get_variants");
int count = 0;
int* type_array = nullptr;
int ret = widget_service_get_supported_size_types(widget_id.c_str(), &count, &type_array);
const auto& instance_id = args.find(kInstanceId)->second.get<std::string>();
auto get_content = [this, widget_id, instance_id](const common::AsyncToken& token) -> void {
+ ScopeLogger("Entered into asynchronous function, get_content");
bundle* bundle_data = bundle_create();
int ret = get_last_result();
projects / platform / core / api / webapi-plugins.git / commitdiff