[Systeminfo] - refactoring logs

Change-Id: I6394c5ed21a52c9082b97a709307c4a84b28dec4
Signed-off-by: Andrzej Popowski <a.popowski@samsung.com>

diff --git a/src/systeminfo/systeminfo-utils.cpp b/src/systeminfo/systeminfo-utils.cpp
index ab4c7c22a3b8f35395af55d59d8a9926b82fde84..d94fc8314ff3658c005340aa4ba97e6d2884c4ce 100644 (file)
--- a/src/systeminfo/systeminfo-utils.cpp
+++ b/src/systeminfo/systeminfo-utils.cpp
@@ -43,8 +43,7 @@ PlatformResult SysteminfoUtils::GetVconfInt(const char *key, int *value) {
     return PlatformResult(ErrorCode::NO_ERROR);
   }
   const std::string error_msg = "Could not get " + std::string(key);
-  LoggerD("%s",error_msg.c_str());
-  return PlatformResult(ErrorCode::UNKNOWN_ERR, error_msg);
+  return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
 }
 
 PlatformResult SysteminfoUtils::GetRuntimeInfoString(system_settings_key_e key, std::string* platform_string) {
@@ -59,8 +58,7 @@ PlatformResult SysteminfoUtils::GetRuntimeInfoString(system_settings_key_e key,
   }
   const std::string error_msg = "Error when retrieving system setting information: "
       + std::to_string(err);
-  LoggerE("%s", error_msg.c_str());
-  return PlatformResult(ErrorCode::UNKNOWN_ERR, error_msg);
+  return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
 }
 
 PlatformResult SysteminfoUtils::CheckTelephonySupport() {
@@ -71,9 +69,8 @@ PlatformResult SysteminfoUtils::CheckTelephonySupport() {
     return ret;
   }
   if (!supported) {
-    LoggerD("Telephony is not supported on this device");
-    return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR,
-        "Telephony is not supported on this device");
+    return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR,
+                              "Telephony is not supported on this device");
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -86,9 +83,9 @@ PlatformResult SysteminfoUtils::CheckCameraFlashSupport() {
     return ret;
   }
   if (!supported) {
-    LoggerD("Back-facing camera with a flash is not supported on this device");
-    return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR,
-        "Back-facing camera with a flash is not supported on this device");
+    return LogAndCreateResult(
+              ErrorCode::NOT_SUPPORTED_ERR,
+              "Back-facing camera with a flash is not supported on this device");
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -101,8 +98,9 @@ PlatformResult SysteminfoUtils::CheckIfEthernetNetworkSupported() {
   int error = connection_create(&connection_handle);
   if (CONNECTION_ERROR_NONE != error) {
     std::string log_msg = "Cannot create connection: " + std::to_string(error);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("connection_create error: %d (%s)", error, get_error_message(error)));
   }
   std::unique_ptr<std::remove_pointer<connection_h>::type, int (*)(connection_h)> connection_handle_ptr(
     connection_handle, &connection_destroy);  // automatically release the memory
@@ -110,8 +108,9 @@ PlatformResult SysteminfoUtils::CheckIfEthernetNetworkSupported() {
   error = connection_get_ethernet_state(connection_handle, &connection_state);
   if (CONNECTION_ERROR_NOT_SUPPORTED == error) {
     std::string log_msg = "Cannot get ethernet connection state: Not supported";
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::NOT_SUPPORTED_ERR, log_msg,
+              ("connection_get_ethernet_state error: %d (%s)", error, get_error_message(error)));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -124,8 +123,9 @@ PlatformResult SysteminfoUtils::GetTotalMemory(long long* result) {
   int ret = device_memory_get_total(&value);
   if (ret != DEVICE_ERROR_NONE) {
     std::string log_msg = "Failed to get total memory: " + std::to_string(ret);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("device_memory_get_total error: %d (%s)", ret, get_error_message(ret)));
   }
 
   *result = static_cast<long long>(value*MEMORY_TO_BYTE);
@@ -140,8 +140,9 @@ PlatformResult SysteminfoUtils::GetAvailableMemory(long long* result) {
   int ret = device_memory_get_available(&value);
   if (ret != DEVICE_ERROR_NONE) {
     std::string log_msg = "Failed to get total memory: " + std::to_string(ret);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("device_memory_get_available error: %d (%s)", ret, get_error_message(ret)));
   }
 
   *result = static_cast<long long>(value*MEMORY_TO_BYTE);
@@ -151,16 +152,18 @@ PlatformResult SysteminfoUtils::GetAvailableMemory(long long* result) {
 PlatformResult SysteminfoUtils::RegisterVconfCallback(const char *in_key, vconf_callback_fn cb,
                                                           void* event_ptr) {
   if (0 != vconf_notify_key_changed(in_key, cb, event_ptr)) {
-    LoggerE("Failed to register vconf callback: %s", in_key);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to register vconf callback");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Failed to register vconf callback",
+              ("Failed to register vconf callback: %s", in_key));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 PlatformResult SysteminfoUtils::UnregisterVconfCallback(const char *in_key, vconf_callback_fn cb) {
   if (0 != vconf_ignore_key_changed(in_key, cb)) {
-    LoggerE("Failed to unregister vconf callback: %s", in_key);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to unregister vconf callback");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Failed to unregister vconf callback",
+              ("Failed to unregister vconf callback: %s", in_key));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -169,18 +172,24 @@ PlatformResult SysteminfoUtils::RegisterTapiChangeCallback(TapiHandle *handle,
                                                            const char *noti_id,
                                                            tapi_notification_cb callback,
                                                            void *user_data) {
-  if (TAPI_API_SUCCESS != tel_register_noti_event(handle, noti_id, callback, user_data)) {
-    LoggerE("Failed to register tapi callback with key: %s", noti_id);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to register tapi callback");
+  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",
+              ("Failed to register tapi callback with key: %s - %d (%s)",
+                  noti_id, ntv_ret, get_error_message(ntv_ret)));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
 PlatformResult SysteminfoUtils::UnregisterTapiChangeCallback(TapiHandle *handle,
                                                              const char *noti_id) {
-  if (TAPI_API_SUCCESS != tel_deregister_noti_event(handle, noti_id)) {
-    LoggerE("Failed to unregister tapi callback with key: %s", noti_id);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to unregister tapi callback");
+  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",
+              ("Failed to unregister tapi callback with key: %s - %d (%s)",
+                  noti_id, ntv_ret, get_error_message(ntv_ret)));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }

diff --git a/src/systeminfo/systeminfo_device_capability.cc b/src/systeminfo/systeminfo_device_capability.cc
index b7d9a6cb194c92bdeafb2085a1f9f2234d9be0b9..d2295b17aacf15d47845613d278f47be7144e591 100644 (file)
--- a/src/systeminfo/systeminfo_device_capability.cc
+++ b/src/systeminfo/systeminfo_device_capability.cc
@@ -86,8 +86,9 @@ PlatformResult SystemInfoDeviceCapability::GetValueBool(const char *key, bool* v
     if (SYSTEM_INFO_ERROR_NONE != ret) {
       std::string log_msg = "Platform error while getting bool value: ";
       log_msg += std::string(key) + " " + std::to_string(ret);
-      LoggerE("%s", log_msg.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, log_msg,
+                ("system_info_get_custom_bool error: %d (%s)", ret, get_error_message(ret)));
     }
   }
 
@@ -104,8 +105,9 @@ PlatformResult SystemInfoDeviceCapability::GetValueInt(const char *key, int* val
     if (SYSTEM_INFO_ERROR_NONE != ret) {
       std::string log_msg = "Platform error while getting int value: ";
       log_msg += std::string(key) + " " + std::to_string(ret);
-      LoggerE("%s", log_msg.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, log_msg,
+                ("system_info_get_custom_int error: %d (%s)", ret, get_error_message(ret)));
     }
   }
 
@@ -123,8 +125,9 @@ PlatformResult SystemInfoDeviceCapability::GetValueString(const char *key, std::
     if (SYSTEM_INFO_ERROR_NONE != ret) {
       std::string log_msg = "Platform error while getting string value: ";
       log_msg += std::string(key) + " " + std::to_string(ret);
-      LoggerE("%s", log_msg.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, log_msg,
+                ("system_info_get_custom_string error: %d (%s)", ret, get_error_message(ret)));
     }
   }
 
@@ -176,7 +179,8 @@ static PlatformResult CheckStringCapability(const std::string& key, std::string*
   } else {
     size_t prefix_len = strlen("http://");
     if (key.length() <= prefix_len) {
-      return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "Value for given key was not found");
+      return LogAndCreateResult(
+                ErrorCode::NOT_SUPPORTED_ERR, "Value for given key was not found");
     }
     PlatformResult ret = SystemInfoDeviceCapability::GetValueString(key.substr(prefix_len).c_str(), value);
     if (ret.IsError()){
@@ -205,7 +209,7 @@ static PlatformResult CheckBoolCapability(const std::string& key, bool* bool_val
   } else {
     size_t prefix_len = strlen("http://");
     if (key.length() <= prefix_len) {
-      return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "Value for given key was not found");
+      return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "Value for given key was not found");
     }
     PlatformResult ret = SystemInfoDeviceCapability::GetValueBool(
         key.substr(prefix_len).c_str(), bool_value);
@@ -229,7 +233,8 @@ static PlatformResult CheckIntCapability(const std::string& key, std::string* va
   } else {
     size_t prefix_len = strlen("http://");
     if (key.length() <= prefix_len) {
-      return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "Value for given key was not found");
+      return LogAndCreateResult(
+                ErrorCode::NOT_SUPPORTED_ERR, "Value for given key was not found");
     }
     PlatformResult ret = SystemInfoDeviceCapability::GetValueInt(
         key.substr(prefix_len).c_str(), &result);
@@ -282,8 +287,8 @@ PlatformResult SystemInfoDeviceCapability::GetCapability(const std::string& key,
   } else if (type == "string" || type == "int") {
     result_obj.insert(std::make_pair("value", picojson::value(value)));
   } else {
-    LoggerD("Value for given key was not found");
-    return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "Value for given key was not found");
+    return LogAndCreateResult(
+              ErrorCode::NOT_SUPPORTED_ERR, "Value for given key was not found");
   }
   result_obj.insert(std::make_pair("type", picojson::value(type)));
 
@@ -320,8 +325,7 @@ PlatformResult SystemInfoDeviceCapability::GetOpenglesTextureFormat(std::string*
   if (!bool_result) {
     // this exception is converted to "Undefined" value in JS layer
     std::string log_msg = "OpenGL-ES is not supported";
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, log_msg);
+    return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, log_msg);
   }
   std::string texture_format = "";
 
@@ -391,8 +395,7 @@ PlatformResult SystemInfoDeviceCapability::GetOpenglesTextureFormat(std::string*
   if (texture_format.empty()) {
     // this exception is converted to "Undefined" value in JS layer
     std::string log_msg = "Platform error while getting OpenGL-ES texture format";
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, log_msg);
   }
   *result = texture_format;
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -432,8 +435,7 @@ PlatformResult SystemInfoDeviceCapability::GetPlatfomCoreCpuArch(std::string* re
   }
 
   if (result.empty()) {
-    LoggerE("Platform error while retrieving platformCoreCpuArch: result is empty");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "platformCoreCpuArch result is empty");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "platformCoreCpuArch result is empty");
   }
   *return_value = result;
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -494,8 +496,7 @@ PlatformResult SystemInfoDeviceCapability::GetPlatfomCoreFpuArch(std::string* re
     result += kPlatformCoreVfpv3;
   }
   if (result.empty()) {
-    LoggerE("Platform error while retrieving platformCoreFpuArch: result is empty");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "platformCoreFpuArch result is empty");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "platformCoreFpuArch result is empty");
   }
   *return_value = result;
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -551,8 +552,9 @@ PlatformResult SystemInfoDeviceCapability::GetPlatformCoreCpuFrequency(int* retu
 
   std::ifstream cpuinfo_freq(file_name);
   if (!cpuinfo_freq.is_open()) {
-    LoggerE("Failed to get cpu frequency");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Unable to open file");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Unable to open file",
+              ("Failed to get cpu frequency"));
   }
 
 #ifdef TIZEN_IS_EMULATOR

diff --git a/src/systeminfo/systeminfo_instance.cc b/src/systeminfo/systeminfo_instance.cc
index 8cc81358efa4eeb010fa316bc5a9faeb394ddcc7..4ff3dcd0d9d1876024616255f7b3049055457d48 100644 (file)
--- a/src/systeminfo/systeminfo_instance.cc
+++ b/src/systeminfo/systeminfo_instance.cc
@@ -41,7 +41,7 @@ const std::string kListenerIdString = "listenerId";
 
 #define CHECK_EXIST(args, name, out) \
   if (!args.contains(name)) {\
-    ReportError(TypeMismatchException(name" is required argument"), out);\
+    LogAndReportError(TypeMismatchException(name" is required argument"), out);\
       return;\
     }
 }
@@ -130,11 +130,14 @@ void SysteminfoInstance::SetBrightness(const picojson::value& args, picojson::ob
   const double brightness = args.get("brightness").get<double>();
   int result = device_flash_set_brightness(brightness);
   if (result != DEVICE_ERROR_NONE) {
-    LoggerE("Error occured");
     if (DEVICE_ERROR_INVALID_PARAMETER == result) {
-      ReportError(PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Error occured"), &out);
+      LogAndReportError(
+          PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Error occured"), &out,
+          ("device_flash_set_brightness error: %d (%s)", result, get_error_message(result)));
     } else {
-      ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), &out);
+      LogAndReportError(
+          PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), &out,
+          ("device_flash_set_brightness error: %d (%s)", result, get_error_message(result)));
     }
     return;
   }
@@ -148,8 +151,9 @@ void SysteminfoInstance::GetBrightness(const picojson::value& args, picojson::ob
   int brightness = 0;
   int result = device_flash_get_brightness(&brightness);
   if (result != DEVICE_ERROR_NONE) {
-    LoggerE("Error occured");
-    ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), &out);
+    LogAndReportError(
+        PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), &out,
+        ("device_flash_get_brightness error: %d (%s)", result, get_error_message(result)));
     return;
   }
 
@@ -162,8 +166,9 @@ void SysteminfoInstance::GetMaxBrightness(const picojson::value& args, picojson:
   int brightness = 0;
   int result = device_flash_get_max_brightness(&brightness);
   if (result != DEVICE_ERROR_NONE) {
-    LoggerE("Error occured");
-    ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Not supported property"), &out);
+    LogAndReportError(
+        PlatformResult(ErrorCode::UNKNOWN_ERR, "Not supported property"), &out,
+        ("device_flash_get_max_brightness error: %d (%s)", result, get_error_message(result)));
     return;
   }
   ReportSuccess(picojson::value(std::to_string(brightness)), out);

diff --git a/src/systeminfo/systeminfo_manager.cc b/src/systeminfo/systeminfo_manager.cc
index 8ee72512608a659c528f130e9c2081195d485635..bac8f0bd44f779d535525c30575240f67fabb491 100644 (file)
--- a/src/systeminfo/systeminfo_manager.cc
+++ b/src/systeminfo/systeminfo_manager.cc
@@ -75,14 +75,14 @@ const std::string kPropertyIdCameraFlash= "CAMERA_FLASH";
 
 #define CHECK_EXIST(args, name, out) \
   if (!args.contains(name)) {\
-    ReportError(TypeMismatchException(name" is required argument"), *out);\
+    LogAndReportError(TypeMismatchException(name" is required argument"), *out);\
       return;\
     }
 
 #define DEFAULT_REPORT_BOOL_CAPABILITY(str_name, feature_name) \
   ret = SystemInfoDeviceCapability::GetValueBool(feature_name, &bool_value); \
   if (ret.IsError()) { \
-    ReportError(ret, out); \
+    LogAndReportError(ret, out); \
     return; \
   } \
   result_obj.insert(std::make_pair(str_name, picojson::value(bool_value)));
@@ -90,7 +90,7 @@ const std::string kPropertyIdCameraFlash= "CAMERA_FLASH";
 #define REPORT_BOOL_CAPABILITY(str_name, method) \
   ret = method(&bool_value); \
   if (ret.IsError()) { \
-    ReportError(ret, out); \
+    LogAndReportError(ret, out); \
     return; \
   } \
   result_obj.insert(std::make_pair(str_name, picojson::value(bool_value)));
@@ -98,7 +98,7 @@ const std::string kPropertyIdCameraFlash= "CAMERA_FLASH";
 #define DEFAULT_REPORT_INT_CAPABILITY(str_name, feature_name) \
   ret = SystemInfoDeviceCapability::GetValueInt(feature_name, &int_value); \
   if (ret.IsError()) { \
-    ReportError(ret, out); \
+    LogAndReportError(ret, out); \
     return; \
   } \
   result_obj.insert(std::make_pair(str_name, picojson::value(std::to_string(int_value))));
@@ -106,7 +106,7 @@ const std::string kPropertyIdCameraFlash= "CAMERA_FLASH";
 #define DEFAULT_REPORT_STRING_CAPABILITY(str_name, feature_name) \
   ret = SystemInfoDeviceCapability::GetValueString(feature_name, &str_value); \
   if (ret.IsError()) { \
-    ReportError(ret, out); \
+    LogAndReportError(ret, out); \
     return; \
   } \
   result_obj.insert(std::make_pair(str_name, picojson::value(str_value)));
@@ -114,7 +114,7 @@ const std::string kPropertyIdCameraFlash= "CAMERA_FLASH";
 #define REPORT_STRING_CAPABILITY(str_name, method) \
   ret = method(&str_value); \
   if (ret.IsError()) { \
-    ReportError(ret, out); \
+    LogAndReportError(ret, out); \
     return; \
   } \
   result_obj.insert(std::make_pair(str_name, picojson::value(str_value)));
@@ -395,7 +395,7 @@ void SysteminfoManager::GetCapability(const picojson::value& args, picojson::obj
     ReportSuccess(result, *out);
     LoggerD("Success");
   } else {
-    ReportError(ret, out);
+    LogAndReportError(ret, out);
   }
 }
 
@@ -412,7 +412,7 @@ void SysteminfoManager::GetPropertyValue(const picojson::value& args, picojson::
     picojson::value result = picojson::value(picojson::object());
     PlatformResult ret = prop_manager_.GetPropertyValue(prop_id, false, &result);
     if (ret.IsError()) {
-      ReportError(ret,&(response->get<picojson::object>()));
+      LogAndReportError(ret,&(response->get<picojson::object>()));
       return;
     }
     ReportSuccess(result, response->get<picojson::object>());
@@ -445,8 +445,9 @@ void SysteminfoManager::GetPropertyValueArray(const picojson::value& args, picoj
 
     PlatformResult ret = prop_manager_.GetPropertyValue(prop_id, true, &result);
     if (ret.IsError()) {
-      LoggerE("Failed: GetPropertyValue()");
-      ReportError(ret,&(response->get<picojson::object>()));
+      LogAndReportError(
+          ret, &(response->get<picojson::object>()),
+          ("Failed: GetPropertyValue()"));
       return;
     }
     ReportSuccess(result, response->get<picojson::object>());
@@ -472,8 +473,7 @@ void SysteminfoManager::GetTotalMemory(const picojson::value& args, picojson::ob
   long long return_value = 0;
   PlatformResult ret = SysteminfoUtils::GetTotalMemory(&return_value);
   if (ret.IsError()) {
-    LoggerD("Error");
-    ReportError(ret, out);
+    LogAndReportError(ret, out);
     return;
   }
   result_obj.insert(std::make_pair("totalMemory",
@@ -491,8 +491,7 @@ void SysteminfoManager::GetAvailableMemory(const picojson::value& args, picojson
   long long return_value = 0;
   PlatformResult ret = SysteminfoUtils::GetAvailableMemory(&return_value);
   if (ret.IsError()) {
-    LoggerD("Error");
-    ReportError(ret, out);
+    LogAndReportError(ret, out);
     return;
   }
   result_obj.insert(std::make_pair("availableMemory",
@@ -513,8 +512,8 @@ void SysteminfoManager::GetCount(const picojson::value& args, picojson::object*
   unsigned long count = 0;
   PlatformResult ret = GetPropertyCount(property, &count);
   if (ret.IsError()) {
-    LoggerE("Failed: GetCount()");
-    ReportError(ret, out);
+    LogAndReportError(ret, out,
+                      ("Failed: GetPropertyCount()"));
     return;
   }
   result_obj.insert(std::make_pair("count", picojson::value(static_cast<double>(count))));
@@ -544,9 +543,8 @@ void SysteminfoManager::AddPropertyValueChangeListener(const picojson::value& ar
     } else if (property_name == kPropertyIdDeviceOrientation) {
       ret = RegisterDeviceOrientationListener();
     } else if (property_name == kPropertyIdBuild) {
-      LoggerW("BUILD property's value is a fixed value");
       //should be accepted, but no registration is needed
-      ret = PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "BUILD property's value is a fixed value");
+      ret = LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "BUILD property's value is a fixed value");
     } else if (property_name == kPropertyIdLocale) {
       ret = RegisterLocaleListener();
     } else if (property_name == kPropertyIdNetwork) {
@@ -567,8 +565,7 @@ void SysteminfoManager::AddPropertyValueChangeListener(const picojson::value& ar
     } else if (property_name == kPropertyIdCameraFlash) {
       ret = RegisterCameraFlashListener();
     } else {
-      LoggerE("Not supported property");
-      ret = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Not supported property");
+      ret = LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Not supported property");
     }
     if (ret.IsSuccess()) {
       registered_listeners_.insert(property_name);
@@ -582,8 +579,7 @@ void SysteminfoManager::AddPropertyValueChangeListener(const picojson::value& ar
     LoggerD("Success");
     return;
   }
-  LoggerD("Error");
-  ReportError(ret, out);
+  LogAndReportError(ret, out);
 }
 
 void SysteminfoManager::RemovePropertyValueChangeListener(const picojson::value& args,
@@ -632,8 +628,7 @@ void SysteminfoManager::RemovePropertyValueChangeListener(const picojson::value&
     } else if (property_name == kPropertyIdCameraFlash) {
       ret = UnregisterCameraFlashListener();
     } else {
-      LoggerE("Not supported property");
-      ret = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Not supported property");
+      ret = LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Not supported property");
     }
   } else {
     LoggerD("Removing listener for property with id: %s is not needed, not registered",
@@ -644,8 +639,7 @@ void SysteminfoManager::RemovePropertyValueChangeListener(const picojson::value&
     LoggerD("Success");
     return;
   }
-  LoggerD("Error");
-  ReportError(ret, out);
+  LogAndReportError(ret, out);
 }
 
 #define CHECK_LISTENER_ERROR(method) \
@@ -670,8 +664,10 @@ PlatformResult SysteminfoManager::RegisterIpChangeCallback() {
                                                    OnNetworkValueChangedCb,
                                                    static_cast<void*>(this));
   if (CONNECTION_ERROR_NONE != error) {
-    LoggerE("Failed to register ip change callback: %d", error);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot register ip change callback");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot register ip change callback",
+              ("connection_set_ip_address_changed_cb error: %d (%s)",
+                  error, get_error_message(error)));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -683,8 +679,10 @@ PlatformResult SysteminfoManager::UnregisterIpChangeCallback() {
   CHECK_LISTENER_ERROR(GetConnectionHandle(handle))
   int error = connection_unset_ip_address_changed_cb(handle);
   if (CONNECTION_ERROR_NONE != error) {
-    LoggerE("Failed to unregister ip change callback: %d", error);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot unregister ip change callback");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot unregister ip change callback",
+              ("connection_unset_ip_address_changed_cb error: %d (%s)",
+                  error, get_error_message(error)));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -786,9 +784,9 @@ PlatformResult SysteminfoManager::RegisterDeviceOrientationListener() {
                                            BASE_GATHERING_INTERVAL, 0,
                                            OnDeviceOrientationChangedCb, this);
   if (!sensor_ret) {
-    LoggerE("Failed to register orientation change event listener");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Failed to register orientation change event listener");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Failed to register orientation change event listener",
+              ("sensord_register_event error: %d (%s)", sensor_ret, get_error_message(sensor_ret)));
   }
 
   LoggerD("Added callback for DEVICE_ORIENTATION");
@@ -803,9 +801,9 @@ PlatformResult SysteminfoManager::UnregisterDeviceOrientationListener() {
                                                OnDeviceAutoRotationChangedCb))
   bool sensor_ret = sensord_unregister_event(GetSensorHandle(), AUTO_ROTATION_EVENT_CHANGE_STATE);
   if (!sensor_ret) {
-    LoggerE("Failed to unregister orientation change event listener");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to unregister"
-                          " orientation change event listener");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Failed to unregister orientation change event listener",
+              ("sensord_unregister_event error: %d (%s)", sensor_ret, get_error_message(sensor_ret)));
   }
 
   LoggerD("Removed callback for DEVICE_ORIENTATION");
@@ -814,17 +812,20 @@ PlatformResult SysteminfoManager::UnregisterDeviceOrientationListener() {
 
 PlatformResult SysteminfoManager::RegisterLocaleListener() {
   LoggerD("Entered");
-  if (SYSTEM_SETTINGS_ERROR_NONE !=
-      system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY,
-                                     OnLocaleChangedCb, static_cast<void*>(this)) ) {
-    LoggerE("Country change callback registration failed");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Country change callback registration failed");
+  int ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_COUNTRY,
+                                     OnLocaleChangedCb, static_cast<void*>(this));
+  if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Country change callback registration failed",
+              ("system_settings_set_changed_cb error: %d (%s)", ret, get_error_message(ret)));
   }
-  if (SYSTEM_SETTINGS_ERROR_NONE !=
-      system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE,
-                                     OnLocaleChangedCb, static_cast<void*>(this)) ) {
-    LoggerE("Language change callback registration failed");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Language change callback registration failed");
+
+  ret = system_settings_set_changed_cb(SYSTEM_SETTINGS_KEY_LOCALE_LANGUAGE,
+                                     OnLocaleChangedCb, static_cast<void*>(this));
+  if (SYSTEM_SETTINGS_ERROR_NONE != ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Language change callback registration failed",
+              ("system_settings_set_changed_cb error: %d (%s)", ret, get_error_message(ret)));
   }
   LoggerD("Added callback for LOCALE");
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -849,9 +850,11 @@ PlatformResult SysteminfoManager::RegisterNetworkListener() {
   connection_h handle;
   PlatformResult ret(ErrorCode::NO_ERROR);
   CHECK_LISTENER_ERROR(GetConnectionHandle(handle))
-  if (CONNECTION_ERROR_NONE !=
-      connection_set_type_changed_cb(handle, OnNetworkChangedCb, static_cast<void*>(this))) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Registration of listener failed");
+  int ntv_ret = connection_set_type_changed_cb(handle, OnNetworkChangedCb, static_cast<void*>(this));
+  if (CONNECTION_ERROR_NONE != ntv_ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Registration of listener failed",
+              ("connection_set_type_changed_cb error: %d (%s)", ntv_ret, get_error_message(ntv_ret)));
   }
   LoggerD("Added callback for NETWORK");
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -862,8 +865,11 @@ PlatformResult SysteminfoManager::UnregisterNetworkListener() {
   connection_h handle;
   PlatformResult ret(ErrorCode::NO_ERROR);
   CHECK_LISTENER_ERROR(GetConnectionHandle(handle))
-  if (CONNECTION_ERROR_NONE != connection_unset_type_changed_cb(handle)) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Unregistration of listener failed");
+  int ntv_ret = connection_unset_type_changed_cb(handle);
+  if (CONNECTION_ERROR_NONE != ntv_ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Unregistration of listener failed",
+              ("connection_unset_type_changed_cb error: %d (%s)", ntv_ret, get_error_message(ntv_ret)));
   }
   LoggerD("Removed callback for NETWORK");
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -1051,9 +1057,12 @@ PlatformResult SysteminfoManager::UnregisterMemoryListener() {
 
 PlatformResult SysteminfoManager::RegisterCameraFlashListener() {
   LoggerD("Entered");
-  if (DEVICE_ERROR_NONE != device_add_callback(DEVICE_CALLBACK_FLASH_BRIGHTNESS,
-                                               OnBrightnessChangedCb, this)) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR);
+  int ret = device_add_callback(DEVICE_CALLBACK_FLASH_BRIGHTNESS,
+                                OnBrightnessChangedCb, this);
+  if (DEVICE_ERROR_NONE != ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Error occured",
+              ("device_add_callback error: %d (%s)", ret, get_error_message(ret)));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -1061,9 +1070,12 @@ PlatformResult SysteminfoManager::RegisterCameraFlashListener() {
 PlatformResult SysteminfoManager::UnregisterCameraFlashListener() {
   LoggerD("Entered");
   PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
-  if (DEVICE_ERROR_NONE != device_remove_callback(DEVICE_CALLBACK_FLASH_BRIGHTNESS,
-                                                  OnBrightnessChangedCb)) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR);
+  int ntv_ret = device_remove_callback(DEVICE_CALLBACK_FLASH_BRIGHTNESS,
+                                       OnBrightnessChangedCb);
+  if (DEVICE_ERROR_NONE != ntv_ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Error occured",
+              ("device_remove_callback error: %d (%s)", ntv_ret, get_error_message(ntv_ret)));
   }
   LoggerD("Removed callback for camera_flash");
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -1077,8 +1089,9 @@ void SysteminfoManager::SetBrightness(const picojson::value& args, picojson::obj
   const double brightness = args.get("brightness").get<double>();
   int result = device_flash_set_brightness(brightness);
   if (result != DEVICE_ERROR_NONE) {
-    LoggerE("Error occured");
-    ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), out);
+    LogAndReportError(
+        PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), out,
+        ("device_flash_set_brightness error: %d (%s)", result, get_error_message(result)));
     return;
   }
   ReportSuccess(*out);
@@ -1090,8 +1103,9 @@ void SysteminfoManager::GetBrightness(const picojson::value& args, picojson::obj
   int brightness = 0;
   int result = device_flash_get_brightness(&brightness);
   if (result != DEVICE_ERROR_NONE) {
-    LoggerE("Error occured");
-    ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), out);
+    LogAndReportError(
+        PlatformResult(ErrorCode::UNKNOWN_ERR, "Error occured"), out,
+        ("device_flash_get_brightness error: %d (%s)", result, get_error_message(result)));
     return;
   }
   ReportSuccess(picojson::value(std::to_string(brightness)), *out);
@@ -1103,8 +1117,10 @@ void SysteminfoManager::GetMaxBrightness(const picojson::value& args, picojson::
   int brightness = 0;
   int result = device_flash_get_max_brightness(&brightness);
   if (result != DEVICE_ERROR_NONE) {
-    LoggerE("Error occured");
-    ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Not supported property"), out);
+    LogAndReportError(
+        PlatformResult(ErrorCode::UNKNOWN_ERR, "Not supported property"), out,
+        ("device_flash_get_max_brightness error: %d (%s)",
+            result, get_error_message(result)));
     return;
   }
   ReportSuccess(picojson::value(std::to_string(brightness)), *out);
@@ -1136,8 +1152,9 @@ PlatformResult SysteminfoManager::GetPropertyCount(const std::string& property,
       *count = kDefaultPropertyCount;
     }
   } else {
-    LoggerD("Property with given id is not supported");
-    return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "Property with given id is not supported");
+    return LogAndCreateResult(
+              ErrorCode::NOT_SUPPORTED_ERR, "Property with given id is not supported",
+              ("Property %s with given id is not supported", property.c_str()));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -1170,15 +1187,13 @@ PlatformResult SysteminfoManager::ConnectSensor(int* result) {
   int handle_orientation = sensord_connect(sensor);
   if (handle_orientation < 0) {
     std::string log_msg = "Failed to connect auto rotation sensor";
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, log_msg);
   }
   bool ret = sensord_start(handle_orientation, 0);
   if(!ret) {
     sensord_disconnect(handle_orientation);
     std::string log_msg = "Failed to start auto rotation sensor";
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, log_msg);
   }
   LoggerD("Sensor starts successfully = %d", handle_orientation);
   *result = handle_orientation;
@@ -1304,8 +1319,9 @@ PlatformResult SysteminfoManager::GetConnectionHandle(connection_h& handle) {
   if (nullptr == connection_handle_) {
     int error = connection_create(&connection_handle_);
     if (CONNECTION_ERROR_NONE != error) {
-      LoggerE("Failed to create connection: %d", error);
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot create connection");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Cannot create connection",
+                ("connection_create error: %d (%s)", error, get_error_message(error)));
     }
   }
   handle = connection_handle_;

diff --git a/src/systeminfo/systeminfo_properties_manager.cc b/src/systeminfo/systeminfo_properties_manager.cc
index 8ffa60d50eb957e175384a224eb9ed786b7ea5a0..79c4c7ff1f3930829c99f1abad3840cede171214 100644 (file)
--- a/src/systeminfo/systeminfo_properties_manager.cc
+++ b/src/systeminfo/systeminfo_properties_manager.cc
@@ -135,7 +135,8 @@ PlatformResult SysteminfoPropertiesManager::GetPropertyValue(const std::string&
       array.push_back(result);
     }
     if (property_count == 0) {
-      return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "Property with given id is not supported");
+      return LogAndCreateResult(
+                ErrorCode::NOT_SUPPORTED_ERR, "Property with given id is not supported");
     }
   }
 
@@ -176,8 +177,8 @@ PlatformResult SysteminfoPropertiesManager::ReportProperty(const std::string& pr
   } else if ("CAMERA_FLASH" == property) {
     return ReportCameraFlash(res_obj, index);
   }
-  LoggerD("Property with given id is not supported");
-  return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, "Property with given id is not supported");
+  return LogAndCreateResult(
+            ErrorCode::NOT_SUPPORTED_ERR, "Property with given id is not supported");
 }
 
 /// BATTERY
@@ -187,8 +188,9 @@ PlatformResult SysteminfoPropertiesManager::ReportBattery(picojson::object* out)
   int ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CAPACITY, &value);
   if (kVconfErrorNone != ret) {
     std::string log_msg = "Platform error while getting battery detail: ";
-    LoggerE("%s%d", log_msg.c_str(), ret);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, (log_msg + std::to_string(ret)));
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, (log_msg + std::to_string(ret)),
+              ("vconf_get_int error: %d (%s)", ret, get_error_message(ret)));
   }
 
   out->insert(std::make_pair("level", picojson::value(static_cast<double>(value)/kRemainingBatteryChargeMax)));
@@ -196,8 +198,9 @@ PlatformResult SysteminfoPropertiesManager::ReportBattery(picojson::object* out)
   ret = vconf_get_int(VCONFKEY_SYSMAN_BATTERY_CHARGE_NOW, &value);
   if (kVconfErrorNone != ret) {
     std::string log_msg =  "Platform error while getting battery charging: ";
-    LoggerE("%s%d",log_msg.c_str(), ret);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, (log_msg + std::to_string(ret)));
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, (log_msg + std::to_string(ret)),
+              ("vconf_get_int error: %d (%s)", ret, get_error_message(ret)));
   }
   out->insert(std::make_pair("isCharging", picojson::value(0 != value)));
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -211,8 +214,7 @@ PlatformResult SysteminfoPropertiesManager::ReportCpu(picojson::object* out) {
   fp = fopen("/proc/stat", "r");
   if (nullptr == fp) {
     std::string error_msg("Can not open /proc/stat for reading");
-    LoggerE( "%s", error_msg.c_str() );
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, error_msg);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
   }
 
   long long usr = 0;
@@ -241,8 +243,7 @@ PlatformResult SysteminfoPropertiesManager::ReportCpu(picojson::object* out) {
     }
   } else {
     std::string error_msg( "Could not read /proc/stat" );
-    LoggerE( "%s", error_msg.c_str() );
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, error_msg);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
   }
 
   manager_.SetCpuInfoLoad(cpu_info.load);
@@ -265,27 +266,35 @@ PlatformResult SysteminfoPropertiesManager::ReportDisplay(picojson::object* out)
   double scaledBrightness;
 
   // FETCH RESOLUTION
-  if (SYSTEM_INFO_ERROR_NONE != system_info_get_platform_int(
-      "tizen.org/feature/screen.width", &screenWidth)) {
-    LoggerE("Cannot get value of screen width");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get value of screen width");
+  int ntv_ret = system_info_get_platform_int("tizen.org/feature/screen.width",
+                                             &screenWidth);
+  if (SYSTEM_INFO_ERROR_NONE != ntv_ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot get value of screen width",
+              ("system_info_get_platform_int error: %d (%s)",
+                  ntv_ret, get_error_message(ntv_ret)));
   }
-  if (SYSTEM_INFO_ERROR_NONE != system_info_get_platform_int(
-      "tizen.org/feature/screen.height", &screenHeight)) {
-    LoggerE("Cannot get value of screen height");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get value of screen height");
+  ntv_ret = system_info_get_platform_int("tizen.org/feature/screen.height",
+                                         &screenHeight);
+  if (SYSTEM_INFO_ERROR_NONE != ntv_ret) {
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot get value of screen height",
+              ("system_info_get_platform_int error: %d (%s)",
+                  ntv_ret, get_error_message(ntv_ret)));
   }
 
   //FETCH DOTS PER INCH
   int dots_per_inch=0;
-  if (SYSTEM_INFO_ERROR_NONE == system_info_get_platform_int(
-      "tizen.org/feature/screen.dpi", &dots_per_inch)) {
+  ntv_ret = system_info_get_platform_int("tizen.org/feature/screen.dpi",
+                                         &dots_per_inch);
+  if (SYSTEM_INFO_ERROR_NONE == ntv_ret) {
     dotsPerInchWidth = dots_per_inch;
     dotsPerInchHeight = dots_per_inch;
   } else {
-    LoggerE("Cannot get 'tizen.org/feature/screen.dpi' value");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Cannot get 'tizen.org/feature/screen.dpi' value");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot get 'tizen.org/feature/screen.dpi' value",
+              ("system_info_get_platform_int error: %d (%s)",
+                  ntv_ret, get_error_message(ntv_ret)));
   }
 
   //FETCH PHYSICAL WIDTH
@@ -308,11 +317,13 @@ PlatformResult SysteminfoPropertiesManager::ReportDisplay(picojson::object* out)
 
   //FETCH BRIGHTNESS
   int brightness;
-  if (kVconfErrorNone == vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness)) {
+  ntv_ret = vconf_get_int(VCONFKEY_SETAPPL_LCD_BRIGHTNESS, &brightness);
+  if (kVconfErrorNone == ntv_ret) {
     scaledBrightness = static_cast<double>(brightness)/kDisplayBrightnessDivideValue;
   } else {
-    LoggerE("Cannot get brightness value of display");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get brightness value of display");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot get brightness value of display",
+              ("vconf_get_int error: %d (%s)", ntv_ret, get_error_message(ntv_ret)));
   }
 
   out->insert(std::make_pair("resolutionWidth", picojson::value(std::to_string(screenWidth))));
@@ -340,9 +351,8 @@ PlatformResult SysteminfoPropertiesManager::FetchIsAutoRotation(bool* result) {
     return PlatformResult(ErrorCode::NO_ERROR);
   }
   else {
-    LoggerE("VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL check failed");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL check failed");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "VCONFKEY_SETAPPL_AUTO_ROTATE_SCREEN_BOOL check failed");
   }
 }
 
@@ -386,8 +396,9 @@ PlatformResult SysteminfoPropertiesManager::FetchStatus(std::string* result) {
       status = kOrientationLandscapeSecondary;
       break;
     default:
-      LoggerE("Received unexpected data: %u", rotation);
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Received unexpected data");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Received unexpected data",
+                ("Received unexpected data: %u", rotation));
   }
   *result = status;
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -487,8 +498,9 @@ static PlatformResult GetNetworkTypeString(NetworkType type, std::string& type_s
       type_string = kNetworkTypeUnknown;
       break;
     default:
-      LoggerE("Incorrect type: %d", type);
-      return PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, "Incorrect type");
+      return LogAndCreateResult(
+                ErrorCode::TYPE_MISMATCH_ERR, "Incorrect type",
+                ("Incorrect type: %d", type));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -504,8 +516,9 @@ PlatformResult SysteminfoPropertiesManager::ReportNetwork(picojson::object* out,
   int error = connection_create(&connection_handle);
   if (CONNECTION_ERROR_NONE != error) {
     std::string log_msg = "Cannot create connection: " + std::to_string(error);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("connection_create error: %d (%s)", error, get_error_message(error)));
   }
   std::unique_ptr<std::remove_pointer<connection_h>::type, int(*)(connection_h)>
   connection_handle_ptr(connection_handle, &connection_destroy);
@@ -514,8 +527,9 @@ PlatformResult SysteminfoPropertiesManager::ReportNetwork(picojson::object* out,
   error = connection_get_type(connection_handle, &connection_type);
   if (CONNECTION_ERROR_NONE != error) {
     std::string log_msg = "Cannot get connection type: " + std::to_string(error);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("connection_get_type error: %d (%s)", error, get_error_message(error)));
   }
 
   switch (connection_type) {
@@ -549,8 +563,9 @@ PlatformResult SysteminfoPropertiesManager::ReportNetwork(picojson::object* out,
       type =  kEthernet;
       break;
     default:
-      LoggerE("Incorrect type: %d", connection_type);
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Incorrect type");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Incorrect type",
+                ("Incorrect type: %d", connection_type));
   }
   std::string type_str = "";
   PlatformResult ret = GetNetworkTypeString(type, type_str);
@@ -571,8 +586,9 @@ static PlatformResult GetIpsWifi(wifi_ap_h wifi_ap_handle, std::string* ip_addr_
                                      WIFI_ADDRESS_FAMILY_IPV4,
                                      &ip_addr);
   if (WIFI_ERROR_NONE != error) {
-    LoggerE("Failed to get ip address: %d", error);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get ip address");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot get ip address",
+              ("wifi_ap_get_ip_address error: %d (%s)", error, get_error_message(error)));
   }
   *ip_addr_str = ip_addr;
   free(ip_addr);
@@ -583,8 +599,9 @@ static PlatformResult GetIpsWifi(wifi_ap_h wifi_ap_handle, std::string* ip_addr_
                                  WIFI_ADDRESS_FAMILY_IPV6,
                                  &ip_addr);
   if (WIFI_ERROR_NONE != error) {
-    LoggerE("Failed to get ipv6 address: %d", error);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get ipv6 address");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot get ipv6 address",
+              ("Failed to get ipv6 address: %d (%s)", error, get_error_message(error)));
   }
   *ipv6_addr_str = ip_addr;
   free(ip_addr);
@@ -601,8 +618,9 @@ static PlatformResult GetIpsFromProfile(connection_profile_h profile_handle, std
                                                 CONNECTION_ADDRESS_FAMILY_IPV4,
                                                 &ip_addr);
   if (CONNECTION_ERROR_NONE != error) {
-    LoggerE("Failed to get ip address: %d", error);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get ip address");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot get ip address",
+              ("Failed to get ip address: %d (%s)", error, get_error_message(error)));
   }
   *ip_addr_str = ip_addr;
   free(ip_addr);
@@ -617,8 +635,9 @@ static PlatformResult GetIpsFromProfile(connection_profile_h profile_handle, std
   } else if (CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED != error) {
     //core api returns error -97 = CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED
     //it will be supported in the future. For now let's ignore this error
-    LoggerE("Failed to get ipv6 address: %d", error);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get ipv6 address");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot get ipv6 address",
+              ("Failed to get ipv6 address: %d (%s)", error, get_error_message(error)));
   }
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -637,8 +656,9 @@ PlatformResult SysteminfoPropertiesManager::ReportWifiNetwork(picojson::object*
   int error = wifi_initialize();
   if (WIFI_ERROR_NONE != error) {
     std::string log_msg = "Initialize failed: " + std::string(get_error_message(error));
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("wifi_initialize error: %d (%s)", error, get_error_message(error)));
   } else {
     LoggerD("WIFI initialization succeed");
   }
@@ -652,8 +672,9 @@ PlatformResult SysteminfoPropertiesManager::ReportWifiNetwork(picojson::object*
   if (WIFI_ERROR_NONE != error) {
     std::string log_msg = "Checking if wifi is activated failed: " +
         std::string(get_error_message(error));
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("wifi_is_activated error: %d (%s)", error, get_error_message(error)));
   } else {
     LoggerD("WIFI activated check succeed");
   }
@@ -668,8 +689,9 @@ PlatformResult SysteminfoPropertiesManager::ReportWifiNetwork(picojson::object*
       if (WIFI_ERROR_NO_CONNECTION != error) {
         std::string log_msg = "Cannot get connected access point handle: " +
             std::string(get_error_message(error));
-        LoggerE("%s", log_msg.c_str());
-        return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+        return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, log_msg,
+                  ("wifi_get_connected_ap error: %d (%s)", error, get_error_message(error)));
       }
     } else {
       //if getting connected AP succeed, set status on true
@@ -691,8 +713,9 @@ PlatformResult SysteminfoPropertiesManager::ReportWifiNetwork(picojson::object*
       free(mac);
     } else {
       std::string log_msg = "Failed to get mac address: " + std::string(get_error_message(error));
-      LoggerE("%s", log_msg.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, log_msg,
+                ("wifi_get_mac_address error: %d (%s)", error, get_error_message(error)));
     }
 
     //refreshing access point information
@@ -700,8 +723,9 @@ PlatformResult SysteminfoPropertiesManager::ReportWifiNetwork(picojson::object*
     if (WIFI_ERROR_NONE != error) {
       std::string log_msg = "Failed to refresh access point information: " +
           std::string(get_error_message(error));
-      LoggerE("%s", log_msg.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, log_msg,
+                ("wifi_ap_refresh error: %d (%s)", error, get_error_message(error)));
     }
 
     //gathering ssid
@@ -712,8 +736,9 @@ PlatformResult SysteminfoPropertiesManager::ReportWifiNetwork(picojson::object*
       free(essid);
     } else {
       std::string log_msg = "Failed to get network ssid: " + std::string(get_error_message(error));
-      LoggerE("%s", log_msg.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, log_msg,
+                ("wifi_ap_get_essid error: %d (%s)", error, get_error_message(error)));
     }
 
     //gathering ips
@@ -734,8 +759,9 @@ PlatformResult SysteminfoPropertiesManager::ReportWifiNetwork(picojson::object*
       } else {
         std::string log_msg = "Failed to get signal strength: " +
             std::string(get_error_message(error));
-        LoggerE("%s", log_msg.c_str());
-        return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+        return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, log_msg,
+                  ("wifi_ap_get_rssi error: %d (%s)", error, get_error_message(error)));
       }
     } else {
       result_signal_strength = ((double) rssi_level)/WIFI_RSSI_LEVEL_4;
@@ -771,8 +797,9 @@ PlatformResult SysteminfoPropertiesManager::ReportEthernetNetwork(picojson::obje
   int error = connection_create(&connection_handle);
   if (CONNECTION_ERROR_NONE != error) {
     std::string log_msg = "Cannot create connection: " + std::to_string(error);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("connection_create error: %d (%s)", error, get_error_message(error)));
   }
   std::unique_ptr<std::remove_pointer<connection_h>::type, int (*)(connection_h)> connection_handle_ptr(
       connection_handle, &connection_destroy);  // automatically release the memory
@@ -781,12 +808,14 @@ PlatformResult SysteminfoPropertiesManager::ReportEthernetNetwork(picojson::obje
   if (CONNECTION_ERROR_NONE != error) {
     if (CONNECTION_ERROR_NOT_SUPPORTED == error) {
       std::string log_msg = "Cannot get ethernet connection state: Not supported";
-      LoggerE("%s", log_msg.c_str());
-      return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR, log_msg);
+      return LogAndCreateResult(
+                ErrorCode::NOT_SUPPORTED_ERR, log_msg,
+                ("connection_get_ethernet_state error: %d (%s)", error, get_error_message(error)));
     }
     std::string log_msg = "Cannot get ethernet connection state: " + std::to_string(error);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("connection_get_ethernet_state error: %d (%s)", error, get_error_message(error)));
   }
 
   switch (connection_state) {
@@ -811,8 +840,10 @@ PlatformResult SysteminfoPropertiesManager::ReportEthernetNetwork(picojson::obje
   error = connection_get_ethernet_cable_state(connection_handle, &cable_state);
   if (CONNECTION_ERROR_NONE != error) {
     std::string log_msg = "Cannot get ethernet cable state: " + std::to_string(error);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("connection_get_ethernet_cable_state error: %d (%s)",
+                  error, get_error_message(error)));
   }
 
   switch (cable_state) {
@@ -837,15 +868,17 @@ PlatformResult SysteminfoPropertiesManager::ReportEthernetNetwork(picojson::obje
     free(mac);
   } else {
     std::string log_msg = "Failed to get mac address: " + std::to_string(error);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("connection_get_mac_address error: %d (%s)", error, get_error_message(error)));
   }
 
   error = connection_get_type(connection_handle, &connection_type);
   if (CONNECTION_ERROR_NONE != error) {
     std::string log_msg = "Cannot get connection type: " + std::to_string(error);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("connection_get_type error: %d (%s)", error, get_error_message(error)));
   }
 
   if (CONNECTION_TYPE_ETHERNET == connection_type) {
@@ -853,8 +886,9 @@ PlatformResult SysteminfoPropertiesManager::ReportEthernetNetwork(picojson::obje
     error = connection_get_current_profile(connection_handle, &profile_handle);
     if (CONNECTION_ERROR_NONE != error) {
       std::string log_msg = "Cannot get connection profile: " + std::to_string(error);
-      LoggerE("%s", log_msg.c_str());
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, log_msg,
+                ("connection_get_current_profile %d (%s)", error, get_error_message(error)));
     }
     std::unique_ptr<std::remove_pointer<connection_profile_h>::type,
         int (*)(connection_profile_h)> profile_handle_ptr(
@@ -892,8 +926,7 @@ static PlatformResult FetchBasicSimProperties(TapiHandle *tapi_handle,
   tapi_res = tel_get_property_int(tapi_handle, TAPI_PROP_NETWORK_PLMN, &result_value);
   if (TAPI_API_SUCCESS != tapi_res) {
     std::string error_msg = "Cannot get mcc value, error: " + std::to_string(tapi_res);
-    LoggerE("%s", error_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, error_msg);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
   }
   *result_mcc = static_cast<unsigned short>(result_value) / kMccDivider;
   *result_mnc = static_cast<unsigned short>(result_value) % kMccDivider;
@@ -901,30 +934,26 @@ static PlatformResult FetchBasicSimProperties(TapiHandle *tapi_handle,
   tapi_res = tel_get_property_int(tapi_handle, TAPI_PROP_NETWORK_CELLID, &result_value);
   if (TAPI_API_SUCCESS != tapi_res) {
     std::string error_msg = "Cannot get cell_id value, error: " + std::to_string(tapi_res);
-    LoggerE("%s", error_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, error_msg);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
   }
   *result_cell_id = static_cast<unsigned short>(result_value);
 
   tapi_res = tel_get_property_int(tapi_handle, TAPI_PROP_NETWORK_LAC, &result_value);
   if (TAPI_API_SUCCESS != tapi_res) {
     std::string error_msg = "Cannot get lac value, error: " + std::to_string(tapi_res);
-    LoggerE("%s", error_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, error_msg);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
   }
   *result_lac = static_cast<unsigned short>(result_value);
 
   tapi_res = tel_get_property_int(tapi_handle, TAPI_PROP_NETWORK_ROAMING_STATUS, &result_value);
   if (TAPI_API_SUCCESS != tapi_res) {
     std::string error_msg = "Cannot get is_roaming value, error: " + std::to_string(tapi_res);
-    LoggerE("%s", error_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, error_msg);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, error_msg);
   }
   *result_is_roaming = (0 != result_value) ? true : false;
 
   if (0 != vconf_get_bool(VCONFKEY_TELEPHONY_FLIGHT_MODE, &result_value)) {
-    LoggerE("Cannot get is_flight_mode value");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get is_flight_mode value");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Cannot get is_flight_mode value");
   }
   *result_is_flight_mode = (0 != result_value) ? true : false;
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -942,8 +971,9 @@ static PlatformResult FetchConnection(TapiHandle *tapi_handle, std::string* resu
   int error = connection_create(&connection_handle);
   if (CONNECTION_ERROR_NONE != error) {
     std::string log_msg = "Cannot create connection: " + std::to_string(error);
-    LoggerE("%s", log_msg.c_str());
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, log_msg);
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, log_msg,
+              ("connection_create error: %d (%s)", error, get_error_message(error)));
   }
   std::unique_ptr<std::remove_pointer<connection_h>::type, int(*)(connection_h)>
   connection_handle_ptr(connection_handle, &connection_destroy);
@@ -951,8 +981,9 @@ static PlatformResult FetchConnection(TapiHandle *tapi_handle, std::string* resu
 
   error = connection_get_type(connection_handle, &connection_type);
   if (CONNECTION_ERROR_NONE != error) {
-    LoggerE("Failed to get connection type: %d", error);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get connection type");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Cannot get connection type",
+              ("Failed to get connection type: %d (%s)", error, get_error_message(error)));
   }
 
   char* apn = nullptr;
@@ -966,14 +997,16 @@ static PlatformResult FetchConnection(TapiHandle *tapi_handle, std::string* resu
     profile_handle_ptr(profile_handle, &connection_profile_destroy);
     // automatically release the memory
     if (CONNECTION_ERROR_NONE != error) {
-      LoggerE("Failed to get profile: %d", error);
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get profile");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Cannot get profile",
+                ("Failed to get profile: %d (%s)", error, get_error_message(error)));
     }
 
     error = connection_profile_get_cellular_apn(profile_handle, &apn);
     if (CONNECTION_ERROR_NONE != error) {
-      LoggerE("Failed to get apn name: %d", error);
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Cannot get apn name");
+      return LogAndCreateResult(
+                ErrorCode::UNKNOWN_ERR, "Cannot get apn name",
+                ("Failed to get apn name: %d (%s)", error, get_error_message(error)));
     }
     *result_apn = apn;
     free(apn);
@@ -1154,8 +1187,8 @@ PlatformResult SysteminfoPropertiesManager::ReportStorage(picojson::object* out)
 
 
   if (statfs(kStorageInternalPath.c_str(), &fs) < 0) {
-    LoggerE("There are no storage units detected");
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "There are no storage units detected");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "There are no storage units detected");
   }
   CreateStorageInfo(kTypeInternal, fs, &internal_obj);
   manager_.SetAvailableCapacityInternal(fs.f_bavail);
@@ -1163,8 +1196,8 @@ PlatformResult SysteminfoPropertiesManager::ReportStorage(picojson::object* out)
   if (0 == vconf_get_int(VCONFKEY_SYSMAN_MMC_STATUS, &sdcardState)) {
     if (VCONFKEY_SYSMAN_MMC_MOUNTED == sdcardState){
       if (statfs(kStorageSdcardPath.c_str(), &fs) < 0) {
-        LoggerE("MMC mounted, but not accessible");
-        return PlatformResult(ErrorCode::UNKNOWN_ERR, "MMC mounted, but not accessible");
+        return LogAndCreateResult(
+                  ErrorCode::UNKNOWN_ERR, "MMC mounted, but not accessible");
       }
       array.push_back(picojson::value(picojson::object()));
       picojson::object& external_obj = array.back().get<picojson::object>();
@@ -1184,9 +1217,8 @@ PlatformResult SysteminfoPropertiesManager::ReportCameraFlash(picojson::object*
     std::string camera = manager_.GetCameraTypes(index);
     out->insert(std::make_pair("camera", picojson::value(camera)));
   } else {
-    return PlatformResult(
-        ErrorCode::NOT_SUPPORTED_ERR,
-        "Camera is not supported on this device");
+    return LogAndCreateResult(
+              ErrorCode::NOT_SUPPORTED_ERR, "Camera is not supported on this device");
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);

diff --git a/src/systeminfo/systeminfo_sim_details_manager.cc b/src/systeminfo/systeminfo_sim_details_manager.cc
index 1c4cb0d77e982475530a3214e673509dfbfe931a..c07f7791eeb1df57fdb0b2f46003ac4969627842 100644 (file)
--- a/src/systeminfo/systeminfo_sim_details_manager.cc
+++ b/src/systeminfo/systeminfo_sim_details_manager.cc
@@ -238,8 +238,9 @@ PlatformResult SimDetailsManager::FetchSimSyncProps(TapiHandle *tapi_handle) {
     msin_ = imsi.szMsin;
   }
   else {
-    LoggerE("Failed to get sim imsi: %d", error);
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Failed to get sim imsi");
+    return LogAndCreateResult(
+              ErrorCode::UNKNOWN_ERR, "Failed to get sim imsi",
+              ("Failed to get sim imsi: %d (%s)", error, get_error_message(error)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);