[MediaController] Log refactoring.

[Verification] TCT pass rate (r20): 100% (162/162/0/0/0)

Change-Id: I50c590be2b39dbade4b94f9501bcc09bc926c0ad
Signed-off-by: Pawel Andruszkiewicz <p.andruszkie@samsung.com>

diff --git a/src/mediacontroller/mediacontroller_client.cc b/src/mediacontroller/mediacontroller_client.cc
index 7fe089460fc8fa3d8eb8a285096077f539dcac36..f48d8a17ff8e9cd537e511bf652865d0355f9676 100644 (file)
--- a/src/mediacontroller/mediacontroller_client.cc
+++ b/src/mediacontroller/mediacontroller_client.cc
@@ -49,9 +49,9 @@ PlatformResult MediaControllerClient::Init() {
   LoggerD("Enter");
   int ret = mc_client_create(&handle_);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "Unable to create media controller client, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Unable to create media controller client");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Unable to create media controller client",
+                              ("mc_client_create() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -64,9 +64,9 @@ PlatformResult MediaControllerClient::FindServers(picojson::array* servers) {
 
   ret = mc_client_foreach_server(handle_, FindServersCallback, servers);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "Unable to fetch active servers, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Unable to create media controller client");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Unable to fetch active servers, error",
+                              ("mc_client_foreach_server() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   // check latest server state - if exist
@@ -126,9 +126,9 @@ PlatformResult MediaControllerClient::GetLatestServerInfo(
   mc_server_state_e state;
   ret = mc_client_get_latest_server_info(handle_, &name, &state);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_client_get_latest_server_info failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error getting latest server info");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error getting latest server info",
+                              ("mc_client_get_latest_server_info() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   if (!name) {
@@ -164,9 +164,9 @@ PlatformResult MediaControllerClient::GetPlaybackInfo(
                                            server_name.c_str(),
                                            &playback_h);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_client_get_latest_server_info failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error getting latest server info");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error getting playback info",
+                              ("mc_client_get_server_playback_info() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   SCOPE_EXIT {
@@ -194,9 +194,9 @@ PlatformResult MediaControllerClient::GetPlaybackInfo(
   ret = mc_client_get_server_shuffle_mode(
       handle_, server_name.c_str(), &shuffle);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_client_get_server_shuffle_mode failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error getting shuffle mode");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error getting shuffle mode",
+                              ("mc_client_get_server_shuffle_mode() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   // repeat mode
@@ -204,9 +204,9 @@ PlatformResult MediaControllerClient::GetPlaybackInfo(
   ret = mc_client_get_server_repeat_mode(
       handle_, server_name.c_str(), &repeat);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_client_get_server_repeat_mode failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error getting repeat mode");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                             "Error getting repeat mode",
+                             ("mc_client_get_server_repeat_mode() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   // metadata
@@ -237,9 +237,9 @@ PlatformResult MediaControllerClient::GetMetadata(
   ret = mc_client_get_server_metadata(handle_, server_name.c_str(),
                                       &metadata_h);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_client_get_server_metadata failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error getting metadata");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error getting server metadata",
+                              ("mc_client_get_server_metadata() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   SCOPE_EXIT {
@@ -259,9 +259,8 @@ PlatformResult MediaControllerClient::SetServerStatusChangeListener(
 
   LoggerD("Enter");
   if (callback && server_status_listener_) {
-    LOGGER(ERROR) << "Listener already registered";
-    return PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                          "Listener already registered");
+    return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR,
+                              "Listener already registered");
   }
 
   server_status_listener_ = callback;
@@ -271,18 +270,18 @@ PlatformResult MediaControllerClient::SetServerStatusChangeListener(
 
     ret = mc_client_set_server_update_cb(handle_, OnServerStatusUpdate, this);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to set server status listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to set server status listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to set server status listener",
+                                ("mc_client_set_server_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
 
   } else { // unset platform callbacks
 
     ret = mc_client_unset_server_update_cb(handle_);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to unset server status listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to unset server status listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to unset server status listener",
+                                ("mc_client_unset_server_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
 
   }
@@ -324,9 +323,8 @@ PlatformResult MediaControllerClient::SetPlaybackInfoListener(
 
   LoggerD("Enter");
   if (callback && playback_info_listener_) {
-    LOGGER(ERROR) << "Listener already registered";
-    return PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                          "Listener already registered");
+    return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR,
+                              "Listener already registered");
   }
 
   playback_info_listener_ = callback;
@@ -336,60 +334,61 @@ PlatformResult MediaControllerClient::SetPlaybackInfoListener(
 
     ret = mc_client_set_playback_update_cb(handle_, OnPlaybackUpdate, this);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to register playback listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to register playback listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to register playback listener",
+                                ("mc_client_set_playback_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
 
     ret = mc_client_set_shuffle_mode_update_cb(handle_, OnShuffleModeUpdate, this);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to register shuffle mode listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to register shuffle mode listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to register shuffle mode listener",
+                                ("mc_client_set_shuffle_mode_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
 
     ret = mc_client_set_repeat_mode_update_cb(handle_, OnRepeatModeUpdate, this);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to register repeat mode listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to register repeat mode listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to register repeat mode listener",
+                                ("mc_client_set_repeat_mode_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
 
     ret = mc_client_set_metadata_update_cb(handle_, OnMetadataUpdate, this);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to register metadata listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to register metadata listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to register metadata listener",
+                                ("mc_client_set_metadata_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
 
   } else { // unset platform callbacks
 
     ret = mc_client_unset_playback_update_cb(handle_);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to unregister playback listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to unregister playback listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to unregister playback listener",
+                                ("mc_client_unset_playback_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
 
     ret = mc_client_unset_shuffle_mode_update_cb(handle_);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to unregister shuffle mode listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to unregister shuffle mode listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to unregister shuffle mode listener",
+                                ("mc_client_unset_shuffle_mode_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
 
     ret = mc_client_unset_repeat_mode_update_cb(handle_);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to unregister repeat mode listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to unregister repeat mode listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to unregister repeat mode listener",
+                                ("mc_client_unset_repeat_mode_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
 
     ret = mc_client_unset_metadata_update_cb(handle_);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
       LOGGER(ERROR) << "Unable to unregister metadata listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to unregister metadata listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to unregister metadata listener",
+                                ("mc_client_unset_metadata_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
   }
 
@@ -521,16 +520,16 @@ PlatformResult MediaControllerClient::SendCommand(
   int ret;
   ret = bundle_add(bundle, "replyId", reply_id.c_str());
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "bundle_add(replyId) failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Unable to add replyId to bundle");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Unable to add replyId to bundle",
+                              ("bundle_add(replyId) error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   ret = bundle_add(bundle, "data", data.serialize().c_str());
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "bundle_add(data) failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Unable to add data to bundle");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Unable to add data to bundle",
+                              ("bundle_add(data) error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   ret = mc_client_send_custom_command(handle_,
@@ -540,9 +539,9 @@ PlatformResult MediaControllerClient::SendCommand(
                                       OnCommandReply,
                                       this);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_client_send_custom_command failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error sending custom command");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error sending custom command",
+                              ("mc_client_send_custom_command() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   command_reply_callback_ = reply_cb;
@@ -611,10 +610,9 @@ PlatformResult MediaControllerClient::SendPlaybackState(
   ret = mc_client_send_playback_state_command(
       handle_, server_name.c_str(), static_cast<mc_playback_states_e>(state_e));
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_client_send_playback_state_command failed, error: "
-        << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error sending playback state");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error sending playback state",
+                              ("mc_client_send_playback_state_command() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -626,7 +624,7 @@ PlatformResult MediaControllerClient::SendPlaybackPosition(
 
   // TODO(r.galka) implement when dedicated method will be available in CAPI
 
-  return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR);
+  return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "Not supported");
 }
 
 PlatformResult MediaControllerClient::SendShuffleMode(
@@ -635,7 +633,7 @@ PlatformResult MediaControllerClient::SendShuffleMode(
 
   // TODO(r.galka) implement when dedicated method will be available in CAPI
 
-  return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR);
+  return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "Not supported");
 }
 
 PlatformResult MediaControllerClient::SendRepeatMode(
@@ -644,7 +642,7 @@ PlatformResult MediaControllerClient::SendRepeatMode(
 
   // TODO(r.galka) implement when dedicated method will be available in CAPI
 
-  return PlatformResult(ErrorCode::NOT_SUPPORTED_ERR);
+  return LogAndCreateResult(ErrorCode::NOT_SUPPORTED_ERR, "Not supported");
 }
 
 } // namespace mediacontroller

diff --git a/src/mediacontroller/mediacontroller_instance.cc b/src/mediacontroller/mediacontroller_instance.cc
index 18ed637eab7b701d319bac104a667baf7002cdc1..e4af4f2334cd0c5b830c58d8cd0a1c56b8e8c720 100755 (executable)
--- a/src/mediacontroller/mediacontroller_instance.cc
+++ b/src/mediacontroller/mediacontroller_instance.cc
@@ -101,7 +101,7 @@ MediaControllerInstance::~MediaControllerInstance() {
 
 #define CHECK_EXIST(args, name, out) \
     if (!args.contains(name)) { \
-      ReportError(PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, \
+      LogAndReportError(PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, \
           name" is required argument"), &out); \
       return; \
     }
@@ -121,7 +121,7 @@ void MediaControllerInstance::MediaControllerManagerCreateServer(
   const PlatformResult& result = server_->Init();
   if (!result) {
     server_.reset();
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed to create server."));
   }
 
   ReportSuccess(out);
@@ -134,16 +134,15 @@ void MediaControllerInstance::MediaControllerServerUpdatePlaybackState(
   CHECK_EXIST(args, "state", out)
 
   if (!server_) {
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-        "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+        "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
   const std::string& state = args.get("state").get<std::string>();
   const PlatformResult& result = server_->SetPlaybackState(state);
   if (!result) {
-    LoggerE("Failed server_->SetPlaybackState()");
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed server_->SetPlaybackState()"));
     return;
   }
 
@@ -156,9 +155,8 @@ void MediaControllerInstance::MediaControllerServerUpdatePlaybackPosition(
 
   LoggerD("Enter");
   if (!server_) {
-    LoggerE("Failed: server_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-        "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+        "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
@@ -167,8 +165,7 @@ void MediaControllerInstance::MediaControllerServerUpdatePlaybackPosition(
   double position = args.get("position").get<double>();
   const PlatformResult& result = server_->SetPlaybackPosition(position);
   if (!result) {
-    LoggerE("Failed: server_->SetPlaybackPosition()");
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed: server_->SetPlaybackPosition()"));
     return;
   }
 
@@ -181,9 +178,8 @@ void MediaControllerInstance::MediaControllerServerUpdateShuffleMode(
 
   LoggerD("Enter");
   if (!server_) {
-    LoggerE("Failed: server_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-        "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+        "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
@@ -193,8 +189,7 @@ void MediaControllerInstance::MediaControllerServerUpdateShuffleMode(
 
   const PlatformResult& result = server_->SetShuffleMode(mode);
   if (!result) {
-    LoggerE("Failed: server_->SetShuffleMode()");
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed: server_->SetShuffleMode()"));
     return;
   }
 
@@ -208,9 +203,8 @@ void MediaControllerInstance::MediaControllerServerUpdateRepeatMode(
   LoggerD("Enter");
 
   if (!server_) {
-    LoggerE("Failed: server_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-        "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+        "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
@@ -220,8 +214,7 @@ void MediaControllerInstance::MediaControllerServerUpdateRepeatMode(
 
   const PlatformResult& result = server_->SetRepeatMode(mode);
   if (!result) {
-    LoggerE("Failed: server_->SetRepeatMode()");
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed: server_->SetRepeatMode()"));
     return;
   }
 
@@ -234,9 +227,8 @@ void MediaControllerInstance::MediaControllerServerUpdateMetadata(
 
   LoggerD("Enter");
   if (!server_) {
-    LoggerE("Failed: server_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-        "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+        "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
@@ -247,8 +239,7 @@ void MediaControllerInstance::MediaControllerServerUpdateMetadata(
 
   const PlatformResult& result = server_->SetMetadata(metadata);
   if (!result) {
-    LoggerE("Failed: server_->SetMetadata()");
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed: server_->SetMetadata()"));
     return;
   }
 
@@ -261,9 +252,8 @@ void MediaControllerInstance::MediaControllerServerAddChangeRequestPlaybackInfoL
 
   LoggerD("Enter");
   if (!server_) {
-    LoggerE("Failed: server_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
@@ -293,9 +283,8 @@ void MediaControllerInstance::MediaControllerServerRemoveChangeRequestPlaybackIn
 
   LoggerD("Enter");
   if (!server_) {
-    LoggerE("Failed: server_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
@@ -308,9 +297,8 @@ void MediaControllerInstance::MediaControllerServerAddCommandListener(
 
   LoggerD("Enter");
   if (!server_) {
-    LoggerE("Failed: server_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
@@ -333,9 +321,8 @@ void MediaControllerInstance::MediaControllerServerReplyCommand(
 
   LoggerD("Enter");
   if (!server_) {
-    LoggerE("Failed: server_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
@@ -356,9 +343,8 @@ void MediaControllerInstance::MediaControllerServerRemoveCommandListener(
 
   LoggerD("Enter");
   if (!server_) {
-    LoggerE("Failed: server_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Server not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Server not initialized."), &out, ("Failed: server_"));
     return;
   }
 
@@ -381,8 +367,7 @@ void MediaControllerInstance::MediaControllerManagerGetClient(
   const PlatformResult& result = client_->Init();
   if (!result) {
     client_.reset();
-    LoggerE("Failed: client_->Init()");
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed: client_->Init()"));
   }
 
   ReportSuccess(out);
@@ -394,10 +379,8 @@ void MediaControllerInstance::MediaControllerClientFindServers(
 
   LoggerD("Enter");
   if (!client_) {
-    LoggerE("Failed: client_");
-
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -416,7 +399,7 @@ void MediaControllerInstance::MediaControllerClientFindServers(
     if (result) {
       ReportSuccess(servers, response_obj);
     } else {
-      ReportError(result, &response_obj);
+      LogAndReportError(result, &response_obj, ("Failed to find servers"));
     }
 
     Instance::PostMessage(this, response.serialize().c_str());
@@ -433,17 +416,15 @@ void MediaControllerInstance::MediaControllerClientGetLatestServerInfo(
 
   LoggerD("Enter");
   if (!client_) {
-    LoggerE("Failed: client_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
   picojson::value server_info = picojson::value();
   PlatformResult result = client_->GetLatestServerInfo(&server_info);
   if (!result) {
-    LoggerE("Failed: client_->GetLatestServerInfo");
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed: client_->GetLatestServerInfo"));
     return;
   }
 
@@ -456,8 +437,8 @@ void MediaControllerInstance::MediaControllerClientGetPlaybackInfo(
 
   LoggerD("Enter");
   if (!client_) {
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -469,8 +450,7 @@ void MediaControllerInstance::MediaControllerClientGetPlaybackInfo(
       &playback_info.get<picojson::object>());
 
   if (!result) {
-    LoggerE("Failed: client_->GetPlaybackInfo");
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed: client_->GetPlaybackInfo"));
     return;
   }
 
@@ -483,9 +463,8 @@ void MediaControllerInstance::MediaControllerServerInfoSendPlaybackState(
 
   LoggerD("Enter");
   if (!client_) {
-    LoggerE("Failed: client_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -505,8 +484,7 @@ void MediaControllerInstance::MediaControllerServerInfoSendPlaybackState(
     if (result) {
       ReportSuccess(response_obj);
     } else {
-      LoggerE("Failed: client_->SendPlaybackState");
-      ReportError(result, &response_obj);
+      LogAndReportError(result, &response_obj, ("Failed: client_->SendPlaybackState"));
     }
 
     Instance::PostMessage(this, response.serialize().c_str());
@@ -523,8 +501,8 @@ void MediaControllerInstance::MediaControllerServerInfoSendPlaybackPosition(
 
   LoggerD("Enter");
   if (!client_) {
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -544,8 +522,7 @@ void MediaControllerInstance::MediaControllerServerInfoSendPlaybackPosition(
     if (result) {
       ReportSuccess(response_obj);
     } else {
-      LoggerE("Failed: client_->SendPlaybackPosition");
-      ReportError(result, &response_obj);
+      LogAndReportError(result, &response_obj, ("Failed: client_->SendPlaybackPosition"));
     }
 
     Instance::PostMessage(this, response.serialize().c_str());
@@ -563,9 +540,8 @@ void MediaControllerInstance::MediaControllerServerInfoSendShuffleMode(
   LoggerD("Enter");
 
   if (!client_) {
-    LOGGER(ERROR) << "Client not initialized.";
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -585,7 +561,7 @@ void MediaControllerInstance::MediaControllerServerInfoSendShuffleMode(
     if (result) {
       ReportSuccess(response_obj);
     } else {
-      ReportError(result, &response_obj);
+      LogAndReportError(result, &response_obj, ("Failed to send shuffle mode."));
     }
 
     Instance::PostMessage(this, response.serialize().c_str());
@@ -602,9 +578,8 @@ void MediaControllerInstance::MediaControllerServerInfoSendRepeatMode(
 
   LoggerD("Enter");
   if (!client_) {
-    LOGGER(ERROR) << "Client not initialized.";
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -624,7 +599,7 @@ void MediaControllerInstance::MediaControllerServerInfoSendRepeatMode(
     if (result) {
       ReportSuccess(response_obj);
     } else {
-      ReportError(result, &response_obj);
+      LogAndReportError(result, &response_obj, ("Failed to send repeat mode."));
     }
 
     Instance::PostMessage(this, response.serialize().c_str());
@@ -641,9 +616,8 @@ void MediaControllerInstance::MediaControllerServerInfoSendCommand(
 
   LoggerD("Enter");
   if (!client_) {
-    LOGGER(ERROR) << "Client not initialized.";
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -672,7 +646,7 @@ void MediaControllerInstance::MediaControllerServerInfoSendCommand(
   if (result) {
     ReportSuccess(out);
   } else {
-    ReportError(result, &out);
+    LogAndReportError(result, &out, ("Failed to send command."));
   }
 }
 
@@ -682,8 +656,8 @@ void MediaControllerInstance::MediaControllerServerInfoAddServerStatusChangeList
 
   LoggerD("Enter");
   if (!client_) {
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -713,8 +687,8 @@ void MediaControllerInstance::MediaControllerServerInfoRemoveServerStatusChangeL
 
   LoggerD("Enter");
   if (!client_) {
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -727,9 +701,8 @@ void MediaControllerInstance::MediaControllerServerInfoAddPlaybackInfoChangeList
 
   LoggerD("Enter");
   if (!client_) {
-    LoggerE("client_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 
@@ -758,9 +731,8 @@ void MediaControllerInstance::MediaControllerServerInfoRemovePlaybackInfoChangeL
     picojson::object& out) {
 
   if (!client_) {
-    LoggerE("client_");
-    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                               "Client not initialized."), &out);
+    LogAndReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out, ("Failed: client_"));
     return;
   }
 

diff --git a/src/mediacontroller/mediacontroller_server.cc b/src/mediacontroller/mediacontroller_server.cc
index 95e919294f2444d53946a08860d5139ba8431d67..8e03479c9470cddca44ebf611cfd6782a1269c61 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.cc
+++ b/src/mediacontroller/mediacontroller_server.cc
@@ -68,18 +68,18 @@ PlatformResult MediaControllerServer::Init() {
 
   int ret = mc_server_create(&handle_);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "Unable to create media controller server, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Unable to create media controller server");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Unable to create media controller server",
+                              ("mc_server_create() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   ret = mc_server_set_custom_command_received_cb(handle_,
                                                  OnCommandReceived,
                                                  this);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "Unable to set command callback, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Unable to set command callback");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Unable to set command callback",
+                              ("mc_server_set_custom_command_received_cb() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -101,16 +101,16 @@ PlatformResult MediaControllerServer::SetPlaybackState(
   int ret = mc_server_set_playback_state(
       handle_, static_cast<mc_playback_states_e>(state_int));
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_server_set_playback_state failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error setting playback state");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error setting playback state",
+                              ("mc_server_set_playback_state() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   ret = mc_server_update_playback_info(handle_);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_server_update_playback_info failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error updating playback info");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error updating playback info",
+                              ("mc_server_update_playback_info() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -123,16 +123,16 @@ PlatformResult MediaControllerServer::SetPlaybackPosition(double position) {
   int ret = mc_server_set_playback_position(
       handle_, static_cast<unsigned long long>(position));
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_server_set_playback_position failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error setting playback position");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error setting playback position",
+                              ("mc_server_set_playback_position() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   ret = mc_server_update_playback_info(handle_);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_server_update_playback_info failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error updating playback info");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error updating playback info",
+                              ("mc_server_update_playback_info() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -146,9 +146,9 @@ PlatformResult MediaControllerServer::SetShuffleMode(bool mode) {
                                           mode ? MC_SHUFFLE_MODE_ON
                                                : MC_SHUFFLE_MODE_OFF);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_server_update_shuffle_mode failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error updating shuffle mode");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error updating shuffle mode",
+                              ("mc_server_update_shuffle_mode() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -162,8 +162,9 @@ PlatformResult MediaControllerServer::SetRepeatMode(bool mode) {
                                          mode ? MC_REPEAT_MODE_ON
                                               : MC_REPEAT_MODE_OFF);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_server_update_repeat_mode failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Error updating repeat mode");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error updating repeat mode",
+                              ("mc_server_update_repeat_mode() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -188,16 +189,17 @@ PlatformResult MediaControllerServer::SetMetadata(
     ret = mc_server_set_metadata(handle_, static_cast<mc_meta_e>(attribute_int),
                                  i->second.to_str().c_str());
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "set_metadata failed for '" << i->first
-                    << "', error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR, "Error setting metadata");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Error setting metadata",
+                                ("mc_server_set_metadata(%s) error: %d, message: %s", i->first.c_str(), ret, get_error_message(ret)));
     }
   }
 
   ret = mc_server_update_metadata(handle_);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_server_update_metadata failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Error updating metadata");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error updating metadata",
+                              ("mc_server_update_metadata() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -300,22 +302,23 @@ PlatformResult MediaControllerServer::CommandReply(
 
   ret = bundle_add(bundle, "replyId", reply_id.c_str());
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "bundle_add(replyId) failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Unable to add replyId to bundle");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Unable to add replyId to bundle",
+                              ("bundle_add(replyId) error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   ret = bundle_add(bundle, "data", data.serialize().c_str());
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "bundle_add(data) failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Unable to add data to bundle");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Unable to add data to bundle",
+                              ("bundle_add(data) error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   ret = mc_server_send_command_reply(handle_, client_name.c_str(), 0, bundle);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_server_send_command_reply failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR, "Error sending command reply");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error sending command reply",
+                              ("mc_server_send_command_reply() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -327,9 +330,8 @@ PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
   LoggerD("Enter");
 
   if (callback && change_request_playback_info_listener_) {
-    LOGGER(ERROR) << "Listener already registered";
-    return PlatformResult(ErrorCode::INVALID_STATE_ERR,
-                          "Listener already registered");
+    return LogAndCreateResult(ErrorCode::INVALID_STATE_ERR,
+                              "Listener already registered");
   }
 
   change_request_playback_info_listener_ = callback;
@@ -339,16 +341,16 @@ PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
     ret = mc_server_set_playback_state_command_received_cb(
         handle_, OnPlaybackStateCommand, this);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to set playback state command listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to set playback state command listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to set playback state command listener",
+                                ("mc_server_set_playback_state_command_received_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
   } else { // unset platform callbacks
     ret = mc_server_unset_playback_state_command_received_cb(handle_);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "Unable to unset playback state command listener, error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Unable to unset playback state command listener");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Unable to unset playback state command listener",
+                                ("mc_server_unset_playback_state_command_received_cb() error: %d, message: %s", ret, get_error_message(ret)));
     }
   }
 

diff --git a/src/mediacontroller/mediacontroller_types.cc b/src/mediacontroller/mediacontroller_types.cc
index a6e941ebbc7a9adb221b860425a4b25c03351eaa..375689dc39247bae6013ac9e2a57dd2a3fd775bd 100644 (file)
--- a/src/mediacontroller/mediacontroller_types.cc
+++ b/src/mediacontroller/mediacontroller_types.cc
@@ -71,8 +71,8 @@ PlatformResult Types::GetPlatformEnumMap(const std::string& type,
 
   auto iter = platform_enum_map_.find(type);
   if (iter == platform_enum_map_.end()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          std::string("Undefined platform enum type ") + type);
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              std::string("Undefined platform enum type ") + type);
   }
 
   *enum_map = platform_enum_map_.at(type);
@@ -100,7 +100,7 @@ PlatformResult Types::StringToPlatformEnum(const std::string& type,
 
   std::string message =
       "Platform enum value " + value + " not found for " + type;
-  return PlatformResult(ErrorCode::INVALID_VALUES_ERR, message);
+  return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
 }
 
 PlatformResult Types::PlatformEnumToString(const std::string& type,
@@ -120,7 +120,7 @@ PlatformResult Types::PlatformEnumToString(const std::string& type,
 
   auto it = platform_enum_reverse_map_.find(type);
   if (it == platform_enum_reverse_map_.end()) {
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
         std::string("Undefined platform enum type ") + type);
   }
 
@@ -133,7 +133,7 @@ PlatformResult Types::PlatformEnumToString(const std::string& type,
 
   std::string message = "Platform enum value " + std::to_string(value) +
       " not found for " + type;
-  return PlatformResult(ErrorCode::INVALID_VALUES_ERR, message);
+  return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, message);
 }
 
 PlatformResult Types::ConvertPlaybackState(mc_playback_h playback_h,
@@ -144,9 +144,9 @@ PlatformResult Types::ConvertPlaybackState(mc_playback_h playback_h,
   mc_playback_states_e state_e;
   ret = mc_client_get_playback_state(playback_h, &state_e);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_client_get_playback_state failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error getting playback state");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error getting playback state",
+                              ("mc_client_get_playback_state() error: %d, message: %s", ret, get_error_message(ret)));
   }
   if (state_e == MC_PLAYBACK_STATE_NONE) {
     state_e = MC_PLAYBACK_STATE_STOPPED;
@@ -172,9 +172,9 @@ PlatformResult Types::ConvertPlaybackPosition(mc_playback_h playback_h,
   unsigned long long pos;
   ret = mc_client_get_playback_position(playback_h, &pos);
   if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-    LOGGER(ERROR) << "mc_client_get_playback_position failed, error: " << ret;
-    return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                          "Error getting playback position");
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                              "Error getting playback position",
+                              ("mc_client_get_playback_position() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   *position = static_cast<double>(pos);
@@ -204,10 +204,9 @@ PlatformResult Types::ConvertMetadata(mc_metadata_h metadata_h,
                                  static_cast<mc_meta_e>(field.second),
                                  &value);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
-      LOGGER(ERROR) << "mc_client_get_metadata failed for field '"
-          << field.first << "', error: " << ret;
-      return PlatformResult(ErrorCode::UNKNOWN_ERR,
-                            "Error getting metadata");
+      return LogAndCreateResult(ErrorCode::UNKNOWN_ERR,
+                                "Error getting metadata",
+                                ("mc_client_get_metadata(%s) error: %d, message: %s", field.first.c_str(), ret, get_error_message(ret)));
     }
 
     (*metadata)[field.first] = picojson::value(std::string(value ? value : ""));