[mediacontroller] Magic strings to constants.

Keys of args passed from JS to instance methods were used
as inline strings, rather than constants.

[Verification] MediaController TCT tests 20190920 100% pass.

Signed-off-by: Michal Michalski <m.michalski2@partner.samsung.com>
Change-Id: Icc3aa5bb5bd947cf6bb680d15f4edc077901361b

diff --git a/src/mediacontroller/mediacontroller_client.cc b/src/mediacontroller/mediacontroller_client.cc
index 9f77350..c9b609d 100644 (file)
--- a/src/mediacontroller/mediacontroller_client.cc
+++ b/src/mediacontroller/mediacontroller_client.cc
@@ -28,6 +28,8 @@
 namespace extension {
 namespace mediacontroller {
 
+using namespace attributes;
+
 using common::ErrorCode;
 using common::JsonToBundle;
 using common::PlatformResult;
@@ -128,13 +130,13 @@ PlatformResult MediaControllerClient::FindServers(picojson::array* servers) {
     return PlatformResult(ErrorCode::NO_ERROR);
   }
 
-  const std::string& latest_name = latest_server.get("name").get<std::string>();
+  const std::string& latest_name = latest_server.get(kName).get<std::string>();
 
   // update current server state in list
   for (auto& it : *servers) {
     picojson::object& server = it.get<picojson::object>();
-    if (server["name"].get<std::string>() == latest_name) {
-      server["state"] = latest_server.get("state");
+    if (server[kName].get<std::string>() == latest_name) {
+      server[kState] = latest_server.get(kState);
       break;
     }
   }
@@ -148,9 +150,9 @@ bool MediaControllerClient::FindServersCallback(const char* server_name, void* u
 
   picojson::value server = picojson::value(picojson::object());
   picojson::object& server_o = server.get<picojson::object>();
-  server_o["name"] = picojson::value(std::string(server_name));
+  server_o[kName] = picojson::value(std::string(server_name));
   // active by default in CAPI
-  server_o["state"] = picojson::value(std::string("ACTIVE"));
+  server_o[kState] = picojson::value(std::string("ACTIVE"));
 
   servers->push_back(server);
 
@@ -187,8 +189,8 @@ PlatformResult MediaControllerClient::GetLatestServerInfo(picojson::value* serve
 
   *server_info = picojson::value(picojson::object());
   picojson::object& obj = server_info->get<picojson::object>();
-  obj["name"] = picojson::value(std::string(name));
-  obj["state"] = picojson::value(state_str);
+  obj[kName] = picojson::value(std::string(name));
+  obj[kState] = picojson::value(state_str);
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -219,7 +221,7 @@ PlatformResult MediaControllerClient::GetPlaybackAbility(const std::string& serv
   }
 
   picojson::object& abilities_obj = abilities->get<picojson::object>();
-  abilities_obj["value"] = picojson::value(ability_str);
+  abilities_obj[kValue] = picojson::value(ability_str);
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -312,7 +314,7 @@ PlatformResult MediaControllerClient::GetSimpleAbility(const std::string& server
 
   *ability_val = picojson::value(picojson::object());
   picojson::object& obj = ability_val->get<picojson::object>();
-  obj["value"] = picojson::value(ability_str);
+  obj[kValue] = picojson::value(ability_str);
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -403,15 +405,15 @@ PlatformResult MediaControllerClient::GetPlaybackInfo(const std::string& server_
   }
 
   // fill return object
-  (*playback_info)["state"] = picojson::value(state);
-  (*playback_info)["position"] = picojson::value(position);
-  (*playback_info)["ageRating"] = picojson::value(rating);
-  (*playback_info)["contentType"] = picojson::value(contentType);
-  (*playback_info)["shuffleMode"] = picojson::value(shuffle == MC_SHUFFLE_MODE_ON);
-  (*playback_info)["repeatMode"] = picojson::value(repeat == MC_REPEAT_MODE_ON);
-  (*playback_info)["metadata"] = metadata;
-  (*playback_info)["index"] = picojson::value(std::string(index ? index : ""));
-  (*playback_info)["playlistName"] =
+  (*playback_info)[kState] = picojson::value(state);
+  (*playback_info)[kPosition] = picojson::value(position);
+  (*playback_info)[kAgeRating] = picojson::value(rating);
+  (*playback_info)[kContentType] = picojson::value(contentType);
+  (*playback_info)[kShuffleMode] = picojson::value(shuffle == MC_SHUFFLE_MODE_ON);
+  (*playback_info)[kRepeatMode] = picojson::value(repeat == MC_REPEAT_MODE_ON);
+  (*playback_info)[kMetadata] = metadata;
+  (*playback_info)[kIndex] = picojson::value(std::string(index ? index : ""));
+  (*playback_info)[kPlaylistName] =
       picojson::value(std::string(playlist_name ? playlist_name : ""));
 
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -507,8 +509,8 @@ void MediaControllerClient::OnServerStatusUpdate(const char* server_name, mc_ser
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["state"] = picojson::value(state_str);
-  data_o["name"] = picojson::value(server_name);
+  data_o[kState] = picojson::value(state_str);
+  data_o[kName] = picojson::value(server_name);
 
   client->server_status_listener_(&data);
 }
@@ -798,10 +800,10 @@ void MediaControllerClient::OnPlaybackUpdate(const char* server_name, mc_playbac
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("onplaybackchanged"));
-  data_o["state"] = picojson::value(state);
-  data_o["position"] = picojson::value(position);
-  data_o["name"] = picojson::value(server_name);
+  data_o[kAction] = picojson::value(std::string("onplaybackchanged"));
+  data_o[kState] = picojson::value(state);
+  data_o[kPosition] = picojson::value(position);
+  data_o[kName] = picojson::value(server_name);
 
   client->playback_info_listener_(&data);
 }
@@ -815,10 +817,10 @@ void MediaControllerClient::OnPlaybackAbilityUpdate(const char* server_name,
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("onplaybackabilitychanged"));
-  data_o["name"] = picojson::value(std::string(server_name));
+  data_o[kAction] = picojson::value(std::string("onplaybackabilitychanged"));
+  data_o[kName] = picojson::value(std::string(server_name));
   // only active servers can trigger listener, thus state is always "ACTIVE"
-  data_o["state"] = picojson::value(std::string("ACTIVE"));
+  data_o[kState] = picojson::value(std::string("ACTIVE"));
 
   client->ability_listener_(&data);
 }
@@ -831,9 +833,9 @@ void MediaControllerClient::OnDisplayModeAbilityUpdate(const char* server_name,
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("ondisplaymodeabilitychanged"));
-  data_o["name"] = picojson::value(std::string(server_name));
-  data_o["state"] = picojson::value(std::string("ACTIVE"));
+  data_o[kAction] = picojson::value(std::string("ondisplaymodeabilitychanged"));
+  data_o[kName] = picojson::value(std::string(server_name));
+  data_o[kState] = picojson::value(std::string("ACTIVE"));
 
   client->ability_listener_(&data);
 }
@@ -846,10 +848,10 @@ void MediaControllerClient::OnDisplayRotationAbilityUpdate(const char* server_na
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("ondisplayrotationabilitychanged"));
-  data_o["name"] = picojson::value(std::string(server_name));
+  data_o[kAction] = picojson::value(std::string("ondisplayrotationabilitychanged"));
+  data_o[kName] = picojson::value(std::string(server_name));
   // only active servers can trigger listener, thus state is always "ACTIVE"
-  data_o["state"] = picojson::value(std::string("ACTIVE"));
+  data_o[kState] = picojson::value(std::string("ACTIVE"));
 
   client->ability_listener_(&data);
 }
@@ -862,9 +864,9 @@ void MediaControllerClient::OnShuffleModeUpdate(const char* server_name, mc_shuf
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("onshufflemodechanged"));
-  data_o["mode"] = picojson::value(mode == MC_SHUFFLE_MODE_ON);
-  data_o["name"] = picojson::value(server_name);
+  data_o[kAction] = picojson::value(std::string("onshufflemodechanged"));
+  data_o[kMode] = picojson::value(mode == MC_SHUFFLE_MODE_ON);
+  data_o[kName] = picojson::value(server_name);
 
   client->playback_info_listener_(&data);
 }
@@ -893,12 +895,12 @@ void MediaControllerClient::OnSimpleAbilityUpdate(const char* server_name, mc_ab
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("onsimpleabilitychanged"));
-  data_o["name"] = picojson::value(std::string(server_name));
+  data_o[kAction] = picojson::value(std::string("onsimpleabilitychanged"));
+  data_o[kName] = picojson::value(std::string(server_name));
   // only active servers can trigger listener, thus state is always "ACTIVE"
-  data_o["state"] = picojson::value(std::string("ACTIVE"));
-  data_o["type"] = picojson::value(type_str);
-  data_o["ability"] = picojson::value(ability_str);
+  data_o[kState] = picojson::value(std::string("ACTIVE"));
+  data_o[kType] = picojson::value(type_str);
+  data_o[kAbility] = picojson::value(ability_str);
 
   client->ability_listener_(&data);
 }
@@ -911,13 +913,13 @@ void MediaControllerClient::OnRepeatModeUpdate(const char* server_name, mc_repea
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["name"] = picojson::value(server_name);
+  data_o[kName] = picojson::value(server_name);
   if (MC_REPEAT_MODE_ONE_MEDIA != mode) {
     // The onrepeatmodechanged event may be reported only with mode equal to true/false. The 3rd
     // mode is not supported by this event.
     common::tools::PrintDeprecationWarningFor("onrepeatmodechanged", "onrepeatstatechanged");
-    data_o["action"] = picojson::value(std::string("onrepeatmodechanged"));
-    data_o["mode"] = picojson::value(mode == MC_REPEAT_MODE_ON);
+    data_o[kAction] = picojson::value(std::string("onrepeatmodechanged"));
+    data_o[kMode] = picojson::value(mode == MC_REPEAT_MODE_ON);
     client->playback_info_listener_(&data);
   }
   std::string state;
@@ -926,8 +928,8 @@ void MediaControllerClient::OnRepeatModeUpdate(const char* server_name, mc_repea
     LoggerE("MediaControllerRepeatModeEnum.getName() failed, error: %s", result.message().c_str());
     return;
   }
-  data_o["action"] = picojson::value(std::string("onrepeatstatechanged"));
-  data_o["state"] = picojson::value(state);
+  data_o[kAction] = picojson::value(std::string("onrepeatstatechanged"));
+  data_o[kState] = picojson::value(state);
 
   client->playback_info_listener_(&data);
 }
@@ -947,9 +949,9 @@ void MediaControllerClient::OnMetadataUpdate(const char* server_name, mc_metadat
     return;
   }
 
-  data_o["action"] = picojson::value(std::string("onmetadatachanged"));
-  data_o["metadata"] = metadata;
-  data_o["name"] = picojson::value(server_name);
+  data_o[kAction] = picojson::value(std::string("onmetadatachanged"));
+  data_o[kMetadata] = metadata;
+  data_o[kName] = picojson::value(server_name);
 
   client->playback_info_listener_(&data);
 }
@@ -981,7 +983,7 @@ PlatformResult MediaControllerClient::SendSearchRequest(const std::string& serve
     const picojson::object& filter = filter_obj.get<picojson::object>();
 
     // contentType
-    std::string content_type_str = filter.at("contentType").get<std::string>();
+    std::string content_type_str = filter.at(kContentType).get<std::string>();
     mc_content_type_e content_type_e;
     PlatformResult result =
         types::MediaControllerContentTypeEnum.getValue(content_type_str, &content_type_e);
@@ -1006,7 +1008,7 @@ PlatformResult MediaControllerClient::SendSearchRequest(const std::string& serve
     SCOPE_EXIT {
       bundle_free(bundle_data);
     };
-    result = JsonToBundle(filter.at("extraData"), &bundle_data);
+    result = JsonToBundle(filter.at(kExtraData), &bundle_data);
     if (!result) {
       return LogAndCreateResult(ErrorCode::INVALID_VALUES_ERR, "Unable to add data to bundle",
                                 ("JsonToBundle() error message: %s", result.message().c_str()));
@@ -1015,8 +1017,8 @@ PlatformResult MediaControllerClient::SendSearchRequest(const std::string& serve
     // keyword
     // null is valid search keyword in case of NO_CATEGORY
     char* search_keyword = nullptr;
-    if (filter.at("keyword").is<std::string>()) {
-      search_keyword = (char*)filter.at("keyword").get<std::string>().c_str();
+    if (filter.at(kKeyword).is<std::string>()) {
+      search_keyword = (char*)filter.at(kKeyword).get<std::string>().c_str();
     }
     ret = mc_search_set_condition(search_request, content_type_e, search_category_e, search_keyword,
                                   bundle_data);
@@ -1090,9 +1092,9 @@ void MediaControllerClient::OnCommandReply(const char* server_name, const char*
     return;
   }
 
-  reply_o["data"] = data;
-  reply_o["name"] = picojson::value(server_name);
-  reply_o["code"] = picojson::value(static_cast<double>(result_code));
+  reply_o[kData] = data;
+  reply_o[kName] = picojson::value(server_name);
+  reply_o[kCode] = picojson::value(static_cast<double>(result_code));
 
   if (nullptr == request_id) {
     LoggerE("Request id is null.");
@@ -1100,7 +1102,7 @@ void MediaControllerClient::OnCommandReply(const char* server_name, const char*
     client->command_reply_callback_(&out);
     return;
   }
-  out_o["requestId"] = picojson::value(std::string(request_id));
+  out_o[kRequestId] = picojson::value(std::string(request_id));
 
   ReportSuccess(reply, out_o);
   client->command_reply_callback_(&out);
@@ -1253,13 +1255,13 @@ void MediaControllerClient::OnPlaylistUpdate(const char* server_name,
 
   if (MC_PLAYLIST_UPDATED == mode) {
     // Create or Update playlist
-    data_o["action"] = picojson::value(std::string("onplaylistupdated"));
+    data_o[kAction] = picojson::value(std::string("onplaylistupdated"));
   } else {
-    data_o["action"] = picojson::value(std::string("onplaylistdeleted"));
+    data_o[kAction] = picojson::value(std::string("onplaylistdeleted"));
   }
 
-  data_o["name"] = picojson::value(std::string(playlist_name));
-  data_o["serverName"] = picojson::value(std::string(server_name));
+  data_o[kName] = picojson::value(std::string(playlist_name));
+  data_o[kServerName] = picojson::value(std::string(server_name));
 
   client->playlist_update_listener_(&data);
 }
@@ -1361,8 +1363,8 @@ void MediaControllerClient::OnSubtitlesUpdate(const char* server_name, bool enab
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["enabled"] = picojson::value(enabled);
-  data_o["name"] = picojson::value(server_name);
+  data_o[kEnabled] = picojson::value(enabled);
+  data_o[kName] = picojson::value(server_name);
 
   client->subtitles_update_listener_(&data);
 }
@@ -1431,8 +1433,8 @@ void MediaControllerClient::OnMode360Update(const char* server_name, bool enable
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["enabled"] = picojson::value(enabled);
-  data_o["name"] = picojson::value(server_name);
+  data_o[kEnabled] = picojson::value(enabled);
+  data_o[kName] = picojson::value(server_name);
 
   client->mode360_update_listener_(&data);
 }
@@ -1526,8 +1528,8 @@ void MediaControllerClient::OnDisplayModeUpdate(const char* server_name, mc_disp
     return;
   }
 
-  data_o["displayMode"] = picojson::value(mode_str);
-  data_o["name"] = picojson::value(server_name);
+  data_o[kDisplayMode] = picojson::value(mode_str);
+  data_o[kName] = picojson::value(server_name);
 
   client->display_mode_update_listener_(&data);
 }
@@ -1633,8 +1635,8 @@ void MediaControllerClient::OnDisplayRotationUpdate(const char* server_name,
     return;
   }
 
-  data_o["displayRotation"] = picojson::value(display_rotation);
-  data_o["name"] = picojson::value(server_name);
+  data_o[kDisplayRotation] = picojson::value(display_rotation);
+  data_o[kName] = picojson::value(server_name);
 
   client->display_rotation_update_listener(&data);
 }

diff --git a/src/mediacontroller/mediacontroller_instance.cc b/src/mediacontroller/mediacontroller_instance.cc
index c6d355e..4add498 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.cc
+++ b/src/mediacontroller/mediacontroller_instance.cc
@@ -26,24 +26,17 @@
 
 #include "mediacontroller/mediacontroller_utils.h"
 
-namespace extension {
-namespace mediacontroller {
 
-namespace {
+#define MediaControllerUnknownErrorMsg "Unknown error occurred."
+#define MediaControllerServerUnknownErrorMsg "Failed: server_"
+#define MediaControllerClientUnknownErrorMsg "Failed: client_"
 
-const std::string kPrivilegeMediaControllerClient =
-    "http://tizen.org/privilege/mediacontroller.client";
-const std::string kPrivilegeMediaControllerServer =
-    "http://tizen.org/privilege/mediacontroller.server";
-// TODO subtitles const
-// TODO mode360 const
-// TODO displayMode const
-// TODO displayRotation const
 
-const char* kAbilityType = "abilityType";
-const char* kDisplayRotationAbility = "displayRotationAbility";
-const char* kServerName = "serverName";
-}  // namespace
+namespace extension {
+namespace mediacontroller {
+
+using namespace privileges;
+using namespace attributes;
 
 using common::ErrorCode;
 using common::PlatformResult;
@@ -272,15 +265,15 @@ void MediaControllerInstance::MediaControllerManagerCreateServer(const picojson:
 void MediaControllerInstance::MediaControllerServerUpdatePlaybackState(const picojson::value& args,
                                                                        picojson::object& out) {
   ScopeLogger();
-  CHECK_EXIST(args, "state", out)
+  CHECK_EXIST(args, kState, out)
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  const std::string& state = args.get("state").get<std::string>();
+  const std::string& state = args.get(kState).get<std::string>();
   const PlatformResult& result = server_->SetPlaybackState(state);
   if (!result) {
     LogAndReportError(result, &out, ("Failed server_->SetPlaybackState()"));
@@ -293,18 +286,18 @@ void MediaControllerInstance::MediaControllerServerUpdatePlaybackState(const pic
 void MediaControllerInstance::MediaControllerServerUpdateIconURI(const picojson::value& args,
                                                                  picojson::object& out) {
   ScopeLogger();
-  CHECK_EXIST(args, "iconURI", out);
+  CHECK_EXIST(args, kIconURI, out);
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
   const char* icon_uri = nullptr;
-  if (args.get("iconURI").is<std::string>()) {
-    icon_uri = args.get("iconURI").get<std::string>().c_str();
-  } else if (!args.get("iconURI").is<picojson::null>()) {
+  if (args.get(kIconURI).is<std::string>()) {
+    icon_uri = args.get(kIconURI).get<std::string>().c_str();
+  } else if (!args.get(kIconURI).is<picojson::null>()) {
     LogAndReportError(
         PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Icon URI must be a string or null."), &out,
         ("Icon URI is not a string or null."));
@@ -324,14 +317,14 @@ void MediaControllerInstance::MediaControllerServerUpdatePlaybackPosition(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "position", out)
+  CHECK_EXIST(args, kPosition, out)
 
-  double position = args.get("position").get<double>();
+  double position = args.get(kPosition).get<double>();
   const PlatformResult& result = server_->SetPlaybackPosition(position);
   if (!result) {
     LogAndReportError(result, &out, ("Failed: server_->SetPlaybackPosition()"));
@@ -346,13 +339,13 @@ void MediaControllerInstance::MediaControllerServerUpdatePlaybackAgeRating(
   ScopeLogger();
   if (!server_) {
     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Server handle not initialized."),
-                      &out, ("Failed: server_"));
+                      &out, (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "rating", out)
+  CHECK_EXIST(args, kRating, out)
 
-  const std::string& rating = args.get("rating").get<std::string>();
+  const std::string& rating = args.get(kRating).get<std::string>();
   const PlatformResult& result = server_->SetContentAgeRating(rating);
   if (!result) {
     LogAndReportError(result, &out, ("Failed: server_->SetContentAgeRating()"));
@@ -366,14 +359,14 @@ void MediaControllerInstance::MediaControllerServerUpdateShuffleMode(const picoj
                                                                      picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "mode", out)
+  CHECK_EXIST(args, kMode, out)
 
-  bool mode = args.get("mode").get<bool>();
+  bool mode = args.get(kMode).get<bool>();
 
   const PlatformResult& result = server_->SetShuffleMode(mode);
   if (!result) {
@@ -388,13 +381,13 @@ void MediaControllerInstance::MediaControllerServerUpdatePlaybackContentType(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "contentType", std::string, out);
-  std::string content_type = args.get("contentType").get<std::string>();
+  CHECK_ARGS(args, kContentType, std::string, out);
+  std::string content_type = args.get(kContentType).get<std::string>();
 
   PlatformResult result = server_->SetContentType(content_type);
   if (!result) {
@@ -411,14 +404,14 @@ void MediaControllerInstance::MediaControllerServerUpdateRepeatMode(const picojs
   common::tools::PrintDeprecationWarningFor("updateRepeatMode()", "updateRepeatState()");
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "mode", out)
+  CHECK_EXIST(args, kMode, out)
 
-  bool mode = args.get("mode").get<bool>();
+  bool mode = args.get(kMode).get<bool>();
 
   const PlatformResult& result = server_->SetRepeatMode(mode);
   if (!result) {
@@ -432,9 +425,9 @@ void MediaControllerInstance::MediaControllerServerUpdateRepeatMode(const picojs
 void MediaControllerInstance::MediaControllerServerUpdateRepeatState(const picojson::value& args,
                                                                      picojson::object& out) {
   ScopeLogger();
-  CHECK_EXIST(args, "state", out)
+  CHECK_EXIST(args, kState, out)
 
-  const std::string& state = args.get("state").get<std::string>();
+  const std::string& state = args.get(kState).get<std::string>();
 
   const PlatformResult& result = server_->SetRepeatState(state);
   if (!result) {
@@ -449,14 +442,14 @@ void MediaControllerInstance::MediaControllerServerUpdateMetadata(const picojson
                                                                   picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "metadata", out)
+  CHECK_EXIST(args, kMetadata, out)
 
-  const picojson::object& metadata = args.get("metadata").get<picojson::object>();
+  const picojson::object& metadata = args.get(kMetadata).get<picojson::object>();
 
   const PlatformResult& result = server_->SetMetadata(metadata);
   if (!result) {
@@ -471,12 +464,12 @@ void MediaControllerInstance::MediaControllerServerAddChangeRequestPlaybackInfoL
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "listenerId", out)
+  CHECK_EXIST(args, kListenerId, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (!data) {
@@ -485,7 +478,7 @@ void MediaControllerInstance::MediaControllerServerAddChangeRequestPlaybackInfoL
     }
 
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -502,8 +495,8 @@ void MediaControllerInstance::MediaControllerServerRemoveChangeRequestPlaybackIn
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
@@ -519,13 +512,13 @@ void MediaControllerInstance::MediaControllerServerAddSearchRequestListener(
 
   if (!server_) {
     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Server not initialized."), &out,
-                      ("Failed: server_"));
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
   JsonCallback on_request = [this, args](picojson::value* request) -> void {
     picojson::object& request_o = request->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
     Instance::PostMessage(this, request->serialize().c_str());
   };
 
@@ -544,7 +537,7 @@ void MediaControllerInstance::MediaControllerServerRemoveSearchRequestListener(
 
   if (!server_) {
     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Server not initialized."), &out,
-                      ("Failed: server_"));
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
@@ -559,14 +552,14 @@ void MediaControllerInstance::MediaControllerServerAddCommandListener(const pico
                                                                       picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
   JsonCallback on_command = [this, args](picojson::value* request) -> void {
     picojson::object& request_o = request->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, request->serialize().c_str());
   };
@@ -583,25 +576,25 @@ void MediaControllerInstance::MediaControllerServerReplyCommand(const picojson::
                                                                 picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "clientName", out);
-  CHECK_EXIST(args, "requestId", out);
-  CHECK_EXIST(args, "reply", out);
+  CHECK_EXIST(args, kClientName, out);
+  CHECK_EXIST(args, kRequestId, out);
+  CHECK_EXIST(args, kReply, out);
 
-  auto client_name = args.get("clientName").get<std::string>();
-  auto request_id = args.get("requestId").get<std::string>();
+  auto client_name = args.get(kClientName).get<std::string>();
+  auto request_id = args.get(kRequestId).get<std::string>();
 
-  auto reply = args.get("reply");
-  CHECK_EXIST(reply, "code", out);
-  CHECK_EXIST(reply, "data", out);
+  auto reply = args.get(kReply);
+  CHECK_EXIST(reply, kCode, out);
+  CHECK_EXIST(reply, kData, out);
 
   LoggerD("reply json: %s", reply.serialize().c_str());
-  int code = static_cast<int>(reply.get("code").get<double>());
-  auto data = reply.get("data");
+  int code = static_cast<int>(reply.get(kCode).get<double>());
+  auto data = reply.get(kData);
 
   auto result = server_->CommandReply(client_name, request_id, code, data);
   if (!result) {
@@ -616,8 +609,8 @@ void MediaControllerInstance::MediaControllerServerRemoveCommandListener(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
@@ -633,16 +626,16 @@ void MediaControllerInstance::MediaControllerServerCreatePlaylist(const picojson
                                                                   picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
   picojson::value playlist_info = picojson::value();
 
-  auto result = server_->CreatePlaylist(args.get("name").get<std::string>(), &playlist_info);
+  auto result = server_->CreatePlaylist(args.get(kName).get<std::string>(), &playlist_info);
   if (!result) {
     LogAndReportError(result, &out, ("Failed: server_->CreatePlaylist["));
     return;
@@ -655,20 +648,20 @@ void MediaControllerInstance::MediaControllerServerSavePlaylist(const picojson::
                                                                 picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "callbackId", out)
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_EXIST(args, kCallbackId, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
   auto save = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
-    auto result = server_->SavePlaylist(args.get("name").get<std::string>());
+    auto result = server_->SavePlaylist(args.get(kName).get<std::string>());
 
     if (result) {
       ReportSuccess(response_obj);
@@ -688,20 +681,20 @@ void MediaControllerInstance::MediaControllerServerDeletePlaylist(const picojson
                                                                   picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "callbackId", out)
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_EXIST(args, kCallbackId, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
   auto del = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
-    auto result = server_->DeletePlaylist(args.get("name").get<std::string>());
+    auto result = server_->DeletePlaylist(args.get(kName).get<std::string>());
 
     if (result) {
       ReportSuccess(response_obj);
@@ -721,16 +714,16 @@ void MediaControllerInstance::MediaControllerServerUpdatePlaybackItem(const pico
                                                                       picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "playlistName", std::string, out)
-  CHECK_ARGS(args, "index", std::string, out)
+  CHECK_ARGS(args, kPlaylistName, std::string, out)
+  CHECK_ARGS(args, kIndex, std::string, out)
 
-  auto result = server_->UpdatePlaybackItem(args.get("playlistName").get<std::string>(),
-                                            args.get("index").get<std::string>());
+  auto result = server_->UpdatePlaybackItem(args.get(kPlaylistName).get<std::string>(),
+                                            args.get(kIndex).get<std::string>());
   if (!result) {
     LogAndReportError(result, &out);
     return;
@@ -747,7 +740,7 @@ void MediaControllerInstance::MediaControllerServerGetAllPlaylists(const picojso
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
 
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
     std::string app_id = common::CurrentApplication::GetInstance().GetApplicationId();
 
@@ -767,7 +760,7 @@ void MediaControllerInstance::MediaControllerServerGetAllPlaylists(const picojso
       return;
     }
 
-    response_obj["result"] = picojson::value{playlists};
+    response_obj[kResult] = picojson::value{playlists};
     ReportSuccess(response_obj);
     Instance::PostMessage(this, response.serialize().c_str());
   };
@@ -782,18 +775,14 @@ void MediaControllerInstance::MediaControllerServerSavePlaybackAbilities(
   ScopeLogger();
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "PLAY", std::string, out)
-  CHECK_ARGS(args, "PAUSE", std::string, out)
-  CHECK_ARGS(args, "STOP", std::string, out)
-  CHECK_ARGS(args, "NEXT", std::string, out)
-  CHECK_ARGS(args, "PREV", std::string, out)
-  CHECK_ARGS(args, "FORWARD", std::string, out)
-  CHECK_ARGS(args, "REWIND", std::string, out)
+  for (auto e: types::MediaControllerPlaybackActionEnum) {
+    CHECK_ARGS(args, e.first, std::string, out);
+  }
   CHECK_ARGS(args, "TOGGLE_PLAY_PAUSE", std::string, out)
 
   const PlatformResult& result = server_->SavePlaybackAbilities(args);
@@ -810,16 +799,16 @@ void MediaControllerInstance::MediaControllerServerSetDisplayModeAbility(
   ScopeLogger();
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "mode", std::string, out)
-  CHECK_ARGS(args, "support", std::string, out)
+  CHECK_ARGS(args, kMode, std::string, out)
+  CHECK_ARGS(args, kSupport, std::string, out)
 
-  std::string support = args.get("support").get<std::string>();
-  std::string mode = args.get("mode").get<std::string>();
+  std::string support = args.get(kSupport).get<std::string>();
+  std::string mode = args.get(kMode).get<std::string>();
 
   const PlatformResult& result = server_->SetDisplayModeAbility(mode, support);
   if (!result) {
@@ -835,16 +824,16 @@ void MediaControllerInstance::MediaControllerServerSetDisplayRotationAbility(
   ScopeLogger();
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
   CHECK_ARGS(args, kDisplayRotationAbility, std::string, out)
-  CHECK_ARGS(args, "support", std::string, out)
+  CHECK_ARGS(args, kSupport, std::string, out)
 
   std::string display_rotation_ability = args.get(kDisplayRotationAbility).get<std::string>();
-  std::string support = args.get("support").get<std::string>();
+  std::string support = args.get(kSupport).get<std::string>();
   const PlatformResult& result =
       server_->SetDisplayRotationAbility(display_rotation_ability, support);
   if (!result) {
@@ -860,16 +849,16 @@ void MediaControllerInstance::MediaControllerServerSetSimpleAbility(const picojs
   ScopeLogger();
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
   CHECK_ARGS(args, kAbilityType, std::string, out)
-  CHECK_ARGS(args, "support", std::string, out)
+  CHECK_ARGS(args, kSupport, std::string, out)
 
   std::string ability_type = args.get(kAbilityType).get<std::string>();
-  std::string support = args.get("support").get<std::string>();
+  std::string support = args.get(kSupport).get<std::string>();
   const PlatformResult& result = server_->SetSimpleAbility(ability_type, support);
   if (!result) {
     LogAndReportError(result, &out, ("Failed server_->SetSimpleAbility()"));
@@ -904,12 +893,12 @@ void MediaControllerInstance::MediaControllerClientFindServers(const picojson::v
                                                                picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "callbackId", out)
+  CHECK_EXIST(args, kCallbackId, out)
 
   auto search = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
@@ -918,7 +907,7 @@ void MediaControllerInstance::MediaControllerClientFindServers(const picojson::v
     picojson::value servers = picojson::value(picojson::array());
     PlatformResult result = client_->FindServers(&servers.get<picojson::array>());
 
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
     if (result) {
       ReportSuccess(servers, response_obj);
     } else {
@@ -937,8 +926,8 @@ void MediaControllerInstance::MediaControllerClientGetLatestServerInfo(const pic
                                                                        picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -956,15 +945,15 @@ void MediaControllerInstance::MediaControllerClientGetPlaybackInfo(const picojso
                                                                    picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "name", out)
+  CHECK_EXIST(args, kName, out)
 
   picojson::value playback_info = picojson::value(picojson::object());
-  PlatformResult result = client_->GetPlaybackInfo(args.get("name").get<std::string>(),
+  PlatformResult result = client_->GetPlaybackInfo(args.get(kName).get<std::string>(),
                                                    &playback_info.get<picojson::object>());
 
   if (!result) {
@@ -980,15 +969,16 @@ void MediaControllerInstance::MediaControllerClientGetPlaybackAbility(const pico
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
+
   CHECK_ARGS(args, kServerName, std::string, out)
-  CHECK_ARGS(args, "action", std::string, out)
+  CHECK_ARGS(args, kAction, std::string, out)
 
   std::string server_name = args.get(kServerName).get<std::string>();
-  std::string action = args.get("action").get<std::string>();
+  std::string action = args.get(kAction).get<std::string>();
   picojson::value ability = picojson::value(picojson::object());
   PlatformResult result = client_->GetPlaybackAbility(server_name, action, &ability);
   if (!result) {
@@ -1004,16 +994,16 @@ void MediaControllerInstance::MediaControllerClientGetDisplayModeAbility(
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
   CHECK_ARGS(args, kServerName, std::string, out)
-  CHECK_ARGS(args, "mode", std::string, out)
+  CHECK_ARGS(args, kMode, std::string, out)
 
   std::string server_name = args.get(kServerName).get<std::string>();
-  std::string mode = args.get("mode").get<std::string>();
+  std::string mode = args.get(kMode).get<std::string>();
   std::string ability;
   PlatformResult result = client_->GetDisplayModeAbility(server_name, mode, &ability);
   if (!result) {
@@ -1029,8 +1019,8 @@ void MediaControllerInstance::MediaControllerClientGetDisplayRotationAbility(
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -1056,8 +1046,8 @@ void MediaControllerInstance::MediaControllerClientGetSimpleAbility(const picojs
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -1081,14 +1071,14 @@ void MediaControllerInstance::MediaControllerClientFindSubscribedServers(
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "callbackId", out)
+  CHECK_EXIST(args, kCallbackId, out)
 
-  picojson::value callback_id = args.get("callbackId");
+  picojson::value callback_id = args.get(kCallbackId);
 
   auto search = [this, callback_id]() -> void {
     picojson::value response = picojson::value(picojson::object());
@@ -1097,7 +1087,7 @@ void MediaControllerInstance::MediaControllerClientFindSubscribedServers(
     picojson::value servers = picojson::value(picojson::array());
     PlatformResult result = client_->FindSubscribedServers(&servers.get<picojson::array>());
 
-    response_obj["callbackId"] = callback_id;
+    response_obj[kCallbackId] = callback_id;
     if (result) {
       ReportSuccess(servers, response_obj);
     } else {
@@ -1116,22 +1106,22 @@ void MediaControllerInstance::MediaControllerServerInfoSendPlaybackState(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "callbackId", out)
-  CHECK_EXIST(args, "name", out)
-  CHECK_EXIST(args, "state", out)
+  CHECK_EXIST(args, kCallbackId, out)
+  CHECK_EXIST(args, kName, out)
+  CHECK_EXIST(args, kState, out)
 
   auto send = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
-    PlatformResult result = client_->SendPlaybackState(args.get("name").get<std::string>(),
-                                                       args.get("state").get<std::string>());
+    PlatformResult result = client_->SendPlaybackState(args.get(kName).get<std::string>(),
+                                                       args.get(kState).get<std::string>());
 
     if (result) {
       ReportSuccess(response_obj);
@@ -1151,22 +1141,22 @@ void MediaControllerInstance::MediaControllerServerInfoSendPlaybackPosition(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "callbackId", out)
-  CHECK_EXIST(args, "name", out)
-  CHECK_EXIST(args, "position", out)
+  CHECK_EXIST(args, kCallbackId, out)
+  CHECK_EXIST(args, kName, out)
+  CHECK_EXIST(args, kPosition, out)
 
   auto send = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
-    PlatformResult result = client_->SendPlaybackPosition(args.get("name").get<std::string>(),
-                                                          args.get("position").get<double>());
+    PlatformResult result = client_->SendPlaybackPosition(args.get(kName).get<std::string>(),
+                                                          args.get(kPosition).get<double>());
 
     if (result) {
       ReportSuccess(response_obj);
@@ -1187,22 +1177,22 @@ void MediaControllerInstance::MediaControllerServerInfoSendShuffleMode(const pic
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "callbackId", out)
-  CHECK_EXIST(args, "name", out)
-  CHECK_EXIST(args, "mode", out)
+  CHECK_EXIST(args, kCallbackId, out)
+  CHECK_EXIST(args, kName, out)
+  CHECK_EXIST(args, kMode, out)
 
   auto send = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
     PlatformResult result =
-        client_->SendShuffleMode(args.get("name").get<std::string>(), args.get("mode").get<bool>());
+        client_->SendShuffleMode(args.get(kName).get<std::string>(), args.get(kMode).get<bool>());
 
     if (result) {
       ReportSuccess(response_obj);
@@ -1223,22 +1213,22 @@ void MediaControllerInstance::MediaControllerServerInfoSendRepeatMode(const pico
   ScopeLogger();
   common::tools::PrintDeprecationWarningFor("sendRepeatMode()", "sendRepeatState()");
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "callbackId", out)
-  CHECK_EXIST(args, "name", out)
-  CHECK_EXIST(args, "mode", out)
+  CHECK_EXIST(args, kCallbackId, out)
+  CHECK_EXIST(args, kName, out)
+  CHECK_EXIST(args, kMode, out)
 
   auto send = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
     PlatformResult result =
-        client_->SendRepeatMode(args.get("name").get<std::string>(), args.get("mode").get<bool>());
+        client_->SendRepeatMode(args.get(kName).get<std::string>(), args.get(kMode).get<bool>());
 
     if (result) {
       ReportSuccess(response_obj);
@@ -1261,10 +1251,10 @@ void MediaControllerInstance::MediaControllerServerInfoSendRepeatState(const pic
   auto send = [this, args]() {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
-    PlatformResult result = client_->SendRepeatState(args.get("name").get<std::string>(),
-                                                     args.get("state").get<std::string>());
+    PlatformResult result = client_->SendRepeatState(args.get(kName).get<std::string>(),
+                                                     args.get(kState).get<std::string>());
 
     if (result) {
       ReportSuccess(response_obj);
@@ -1286,17 +1276,17 @@ void MediaControllerInstance::MediaControllerServerInfoSendSearchRequest(
 
   if (!client_) {
     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Client not initialized."), &out,
-                      ("Failed: client_"));
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "listenerId", out);
-  CHECK_EXIST(args, "name", out);
-  CHECK_EXIST(args, "request", out);
+  CHECK_EXIST(args, kListenerId, out);
+  CHECK_EXIST(args, kName, out);
+  CHECK_EXIST(args, kRequest, out);
 
   JsonCallback reply_cb = [this, args](picojson::value* reply) -> void {
     picojson::object& reply_obj = reply->get<picojson::object>();
-    reply_obj["listenerId"] = args.get("listenerId");
+    reply_obj[kListenerId] = args.get(kListenerId);
     Instance::PostMessage(this, reply->serialize().c_str());
   };
 
@@ -1305,12 +1295,12 @@ void MediaControllerInstance::MediaControllerServerInfoSendSearchRequest(
     free(request_id);
   };
 
-  PlatformResult result = client_->SendSearchRequest(args.get("name").get<std::string>(),
-                                                     args.get("request"), reply_cb, &request_id);
+  PlatformResult result = client_->SendSearchRequest(args.get(kName).get<std::string>(),
+                                                     args.get(kRequest), reply_cb, &request_id);
 
   if (result) {
     ReportSuccess(out);
-    out["requestId"] = picojson::value(std::string(request_id));
+    out[kRequestId] = picojson::value(std::string(request_id));
   } else {
     LogAndReportError(result, &out, ("Failed to send command."));
   }
@@ -1320,19 +1310,19 @@ void MediaControllerInstance::MediaControllerServerInfoSendCommand(const picojso
                                                                    picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "listenerId", out)
-  CHECK_EXIST(args, "name", out)
-  CHECK_EXIST(args, "command", out)
-  CHECK_EXIST(args, "data", out)
+  CHECK_EXIST(args, kListenerId, out)
+  CHECK_EXIST(args, kName, out)
+  CHECK_EXIST(args, kCommand, out)
+  CHECK_EXIST(args, kData, out)
 
   JsonCallback reply_cb = [this, args](picojson::value* reply) -> void {
     picojson::object& reply_obj = reply->get<picojson::object>();
-    reply_obj["listenerId"] = args.get("listenerId");
+    reply_obj[kListenerId] = args.get(kListenerId);
     Instance::PostMessage(this, reply->serialize().c_str());
   };
 
@@ -1341,13 +1331,13 @@ void MediaControllerInstance::MediaControllerServerInfoSendCommand(const picojso
     free(request_id);
   };
 
-  PlatformResult result = client_->SendCommand(args.get("name").get<std::string>(),
-                                               args.get("command").get<std::string>(),
-                                               args.get("data"), reply_cb, &request_id);
+  PlatformResult result = client_->SendCommand(args.get(kName).get<std::string>(),
+                                               args.get(kCommand).get<std::string>(),
+                                               args.get(kData), reply_cb, &request_id);
 
   if (result) {
     ReportSuccess(out);
-    out["requestId"] = picojson::value(std::string(request_id));
+    out[kRequestId] = picojson::value(std::string(request_id));
   } else {
     LogAndReportError(result, &out, ("Failed to send command."));
   }
@@ -1357,12 +1347,12 @@ void MediaControllerInstance::MediaControllerServerInfoAddServerStatusChangeList
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "listenerId", out)
+  CHECK_EXIST(args, kListenerId, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (nullptr == data) {
@@ -1371,7 +1361,7 @@ void MediaControllerInstance::MediaControllerServerInfoAddServerStatusChangeList
     }
 
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -1388,8 +1378,8 @@ void MediaControllerInstance::MediaControllerServerInfoRemoveServerStatusChangeL
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -1403,12 +1393,12 @@ void MediaControllerInstance::MediaControllerServerInfoAddPlaybackInfoChangeList
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "listenerId", out)
+  CHECK_EXIST(args, kListenerId, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (!data) {
@@ -1417,7 +1407,7 @@ void MediaControllerInstance::MediaControllerServerInfoAddPlaybackInfoChangeList
     }
 
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -1433,8 +1423,8 @@ void MediaControllerInstance::MediaControllerServerInfoAddPlaybackInfoChangeList
 void MediaControllerInstance::MediaControllerServerInfoRemovePlaybackInfoChangeListener(
     const picojson::value& args, picojson::object& out) {
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -1450,20 +1440,20 @@ void MediaControllerInstance::MediaControllerServerInfoSendPlaybackItem(const pi
 
   if (!client_) {
     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Client not initialized."), &out,
-                      ("Failed: client_"));
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "name", std::string, out)
-  CHECK_ARGS(args, "playlistName", std::string, out)
-  CHECK_ARGS(args, "index", std::string, out)
-  CHECK_ARGS(args, "state", std::string, out)
-  CHECK_ARGS(args, "position", double, out)
+  CHECK_ARGS(args, kName, std::string, out)
+  CHECK_ARGS(args, kPlaylistName, std::string, out)
+  CHECK_ARGS(args, kIndex, std::string, out)
+  CHECK_ARGS(args, kState, std::string, out)
+  CHECK_ARGS(args, kPosition, double, out)
 
   auto result = client_->SendPlaybackItem(
-      args.get("name").get<std::string>(), args.get("playlistName").get<std::string>(),
-      args.get("index").get<std::string>(), args.get("state").get<std::string>(),
-      args.get("position").get<double>());
+      args.get(kName).get<std::string>(), args.get(kPlaylistName).get<std::string>(),
+      args.get(kIndex).get<std::string>(), args.get(kState).get<std::string>(),
+      args.get(kPosition).get<double>());
   if (!result) {
     LogAndReportError(result, &out);
     return;
@@ -1476,12 +1466,12 @@ void MediaControllerInstance::MediaControllerServerInfoAddPlaylistUpdateListener
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "listenerId", out)
+  CHECK_EXIST(args, kListenerId, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (!data) {
@@ -1490,7 +1480,7 @@ void MediaControllerInstance::MediaControllerServerInfoAddPlaylistUpdateListener
     }
 
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -1507,8 +1497,8 @@ void MediaControllerInstance::MediaControllerServerInfoAddPlaylistUpdateListener
 void MediaControllerInstance::MediaControllerServerInfoRemovePlaylistUpdateListener(
     const picojson::value& args, picojson::object& out) {
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -1525,17 +1515,17 @@ void MediaControllerInstance::MediaControllerServerInfoGetAllPlaylists(const pic
                                                                        picojson::object& out) {
   ScopeLogger();
 
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
   auto get = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
 
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
     picojson::value playlists{picojson::array{}};
 
-    auto result = utils::GetAllPlaylists(args.get("name").get<std::string>(),
+    auto result = utils::GetAllPlaylists(args.get(kName).get<std::string>(),
                                          &playlists.get<picojson::array>());
 
     if (!result) {
@@ -1544,7 +1534,7 @@ void MediaControllerInstance::MediaControllerServerInfoGetAllPlaylists(const pic
       return;
     }
 
-    response_obj["result"] = picojson::value{playlists};
+    response_obj[kResult] = picojson::value{playlists};
     ReportSuccess(response_obj);
     Instance::PostMessage(this, response.serialize().c_str());
   };
@@ -1557,15 +1547,15 @@ void MediaControllerInstance::MediaControllerServerInfoGetAllPlaylists(const pic
 void MediaControllerInstance::MediaControllerServerInfoGetIconURI(const picojson::value& args,
                                                                   picojson::object& out) {
   ScopeLogger();
-  CHECK_ARGS(args, "name", std::string, out);
+  CHECK_ARGS(args, kName, std::string, out);
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  std::string server_name = args.get("name").get<std::string>();
+  std::string server_name = args.get(kName).get<std::string>();
 
   common::optional<std::string> icon_uri;
   PlatformResult status = client_->GetServerIconURI(server_name, &icon_uri);
@@ -1576,9 +1566,9 @@ void MediaControllerInstance::MediaControllerServerInfoGetIconURI(const picojson
 
   picojson::object result;
   if (icon_uri) {
-    result["iconURI"] = picojson::value(*icon_uri);
+    result[kIconURI] = picojson::value(*icon_uri);
   } else {
-    result["iconURI"] = picojson::value();
+    result[kIconURI] = picojson::value();
   }
 
   ReportSuccess(picojson::value(result), out);
@@ -1589,14 +1579,14 @@ void MediaControllerInstance::MediaControllerClientAddAbilityChangeListener(
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_EXIST(args, "listenerId", out)
+  CHECK_EXIST(args, kListenerId, out)
 
-  picojson::value listener_id = args.get("listenerId");
+  picojson::value listener_id = args.get(kListenerId);
 
   JsonCallback callback = [this, listener_id](picojson::value* data) -> void {
     if (!data) {
@@ -1605,7 +1595,7 @@ void MediaControllerInstance::MediaControllerClientAddAbilityChangeListener(
     }
 
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = listener_id;
+    request_o[kListenerId] = listener_id;
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -1624,8 +1614,8 @@ void MediaControllerInstance::MediaControllerClientRemoveAbilityChangeListener(
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -1643,8 +1633,8 @@ void MediaControllerInstance::MediaControllerAbilitiesInfoSubscribe(const picojs
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -1665,8 +1655,8 @@ void MediaControllerInstance::MediaControllerAbilitiesInfoUnsubscribe(const pico
   ScopeLogger();
 
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -1690,18 +1680,18 @@ void MediaControllerInstance::MediaControllerPlaylistAddItem(const picojson::val
   // mc_server_add_item_to_playlist need mc_server_h as parameter
   if (!server_) {
     LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Server not initialized."), &out,
-                      ("Failed: server_"));
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "index", std::string, out)
-  CHECK_ARGS(args, "metadata", picojson::object, out)
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_ARGS(args, kIndex, std::string, out)
+  CHECK_ARGS(args, kMetadata, picojson::object, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
-  const picojson::object& metadata = args.get("metadata").get<picojson::object>();
+  const picojson::object& metadata = args.get(kMetadata).get<picojson::object>();
 
   auto result = server_->MediaControllerPlaylistAddItem(
-      args.get("name").get<std::string>(), args.get("index").get<std::string>(), metadata);
+      args.get(kName).get<std::string>(), args.get(kIndex).get<std::string>(), metadata);
   if (!result) {
     LogAndReportError(result, &out);
     return;
@@ -1717,22 +1707,22 @@ void MediaControllerInstance::MediaControllerPlaylistGetItems(const picojson::va
   // MediaControllerPlaylistGetItems is implemented in MediaControllerServer because
   // mc_playlist_foreach_item need mc_playlist_h as parameter which is already stored in server
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
-  CHECK_EXIST(args, "callbackId", out)
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_EXIST(args, kCallbackId, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
   auto get = [this, args]() -> void {
     picojson::value response = picojson::value(picojson::object());
     picojson::object& response_obj = response.get<picojson::object>();
 
-    response_obj["callbackId"] = args.get("callbackId");
+    response_obj[kCallbackId] = args.get(kCallbackId);
 
     picojson::value items{picojson::array{}};
 
-    auto result = server_->MediaControllerPlaylistGetItems(args.get("name").get<std::string>(),
+    auto result = server_->MediaControllerPlaylistGetItems(args.get(kName).get<std::string>(),
                                                            &items.get<picojson::array>());
 
     if (!result) {
@@ -1742,7 +1732,7 @@ void MediaControllerInstance::MediaControllerPlaylistGetItems(const picojson::va
       return;
     }
 
-    response_obj["result"] = picojson::value{items};
+    response_obj[kResult] = picojson::value{items};
     ReportSuccess(response_obj);
     Instance::PostMessage(this, response.serialize().c_str());
   };
@@ -1758,14 +1748,14 @@ void MediaControllerInstance::MediaControllerSubtitlesUpdateEnabled(const picojs
   ScopeLogger();
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "enabled", bool, out);
+  CHECK_ARGS(args, kEnabled, bool, out);
 
-  const bool enabled = args.get("enabled").get<bool>();
+  const bool enabled = args.get(kEnabled).get<bool>();
   PlatformResult result = server_->UpdateSubtitlesEnabled(enabled);
   if (!result) {
     LogAndReportError(result, &out, ("Failed server_->UpdateSubtitlesEnabled()"));
@@ -1778,12 +1768,12 @@ void MediaControllerInstance::MediaControllerSubtitlesAddChangeRequestListener(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (!data) {
@@ -1791,7 +1781,7 @@ void MediaControllerInstance::MediaControllerSubtitlesAddChangeRequestListener(
       return;
     }
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -1809,8 +1799,8 @@ void MediaControllerInstance::MediaControllerSubtitlesRemoveChangeRequestListene
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
@@ -1826,16 +1816,16 @@ void MediaControllerInstance::MediaControllerSubtitlesInfoGetEnabled(const picoj
                                                                      picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
   bool enabled = false;
   PlatformResult result =
-      client_->GetSubtitlesEnabled(args.get("name").get<std::string>(), &enabled);
+      client_->GetSubtitlesEnabled(args.get(kName).get<std::string>(), &enabled);
 
   if (!result) {
     LogAndReportError(result, &out, ("Failed: client_->GetSubtitlesEnabled"));
@@ -1849,19 +1839,19 @@ void MediaControllerInstance::MediaControllerSubtitlesInfoSendRequest(const pico
                                                                       picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
-  CHECK_ARGS(args, "name", std::string, out)
-  CHECK_ARGS(args, "enabled", bool, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
+  CHECK_ARGS(args, kEnabled, bool, out)
 
   JsonCallback reply_cb = [this, args](picojson::value* reply) -> void {
     if (reply) {
       picojson::object& reply_obj = reply->get<picojson::object>();
-      reply_obj["listenerId"] = args.get("listenerId");
+      reply_obj[kListenerId] = args.get(kListenerId);
       Instance::PostMessage(this, reply->serialize().c_str());
     } else {
       LoggerW("No reply passed to json callback, ignoring");
@@ -1874,11 +1864,11 @@ void MediaControllerInstance::MediaControllerSubtitlesInfoSendRequest(const pico
   };
 
   PlatformResult result = client_->SendSubtitlesEnabled(
-      args.get("name").get<std::string>(), args.get("enabled").get<bool>(), reply_cb, &request_id);
+      args.get(kName).get<std::string>(), args.get(kEnabled).get<bool>(), reply_cb, &request_id);
 
   if (result) {
     ReportSuccess(out);
-    out["requestId"] = picojson::value(std::string(request_id));
+    out[kRequestId] = picojson::value(std::string(request_id));
   } else {
     LogAndReportError(result, &out, ("Failed to send command."));
   }
@@ -1888,12 +1878,12 @@ void MediaControllerInstance::MediaControllerSubtitlesInfoAddModeChangeListener(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (nullptr == data) {
@@ -1902,7 +1892,7 @@ void MediaControllerInstance::MediaControllerSubtitlesInfoAddModeChangeListener(
     }
 
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -1920,8 +1910,8 @@ void MediaControllerInstance::MediaControllerSubtitlesInfoRemoveModeChangeListen
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -1940,14 +1930,14 @@ void MediaControllerInstance::MediaControllerMode360UpdateEnabled(const picojson
   ScopeLogger();
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "enabled", bool, out)
+  CHECK_ARGS(args, kEnabled, bool, out)
 
-  const bool enabled = args.get("enabled").get<bool>();
+  const bool enabled = args.get(kEnabled).get<bool>();
   PlatformResult result = server_->UpdateMode360Enabled(enabled);
   if (!result) {
     LogAndReportError(result, &out, ("Failed server_->UpdateMode360Enabled()"));
@@ -1960,12 +1950,12 @@ void MediaControllerInstance::MediaControllerMode360AddChangeRequestListener(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (!data) {
@@ -1973,7 +1963,7 @@ void MediaControllerInstance::MediaControllerMode360AddChangeRequestListener(
       return;
     }
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -1991,8 +1981,8 @@ void MediaControllerInstance::MediaControllerMode360RemoveChangeRequestListener(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
@@ -2008,15 +1998,15 @@ void MediaControllerInstance::MediaControllerMode360InfoGetEnabled(const picojso
                                                                    picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
   bool enabled = false;
-  PlatformResult result = client_->GetMode360Enabled(args.get("name").get<std::string>(), &enabled);
+  PlatformResult result = client_->GetMode360Enabled(args.get(kName).get<std::string>(), &enabled);
 
   if (!result) {
     LogAndReportError(result, &out, ("Failed: client_->GetMode360Enabled"));
@@ -2030,19 +2020,19 @@ void MediaControllerInstance::MediaControllerMode360InfoSendRequest(const picojs
                                                                     picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
-  CHECK_ARGS(args, "name", std::string, out)
-  CHECK_ARGS(args, "enabled", bool, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
+  CHECK_ARGS(args, kEnabled, bool, out)
 
   JsonCallback reply_cb = [this, args](picojson::value* reply) -> void {
     if (reply) {
       picojson::object& reply_obj = reply->get<picojson::object>();
-      reply_obj["listenerId"] = args.get("listenerId");
+      reply_obj[kListenerId] = args.get(kListenerId);
       Instance::PostMessage(this, reply->serialize().c_str());
     } else {
       LoggerW("No reply passed to json callback, ignoring");
@@ -2055,11 +2045,11 @@ void MediaControllerInstance::MediaControllerMode360InfoSendRequest(const picojs
   };
 
   PlatformResult result = client_->SendMode360Enabled(
-      args.get("name").get<std::string>(), args.get("enabled").get<bool>(), reply_cb, &request_id);
+      args.get(kName).get<std::string>(), args.get(kEnabled).get<bool>(), reply_cb, &request_id);
 
   if (result) {
     ReportSuccess(out);
-    out["requestId"] = picojson::value(std::string(request_id));
+    out[kRequestId] = picojson::value(std::string(request_id));
   } else {
     LogAndReportError(result, &out, ("Failed to send command."));
   }
@@ -2069,12 +2059,12 @@ void MediaControllerInstance::MediaControllerMode360InfoAddModeChangeListener(
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (nullptr == data) {
@@ -2083,7 +2073,7 @@ void MediaControllerInstance::MediaControllerMode360InfoAddModeChangeListener(
     }
 
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -2101,8 +2091,8 @@ void MediaControllerInstance::MediaControllerMode360InfoRemoveModeChangeListener
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -2121,14 +2111,14 @@ void MediaControllerInstance::MediaControllerDisplayModeUpdateType(const picojso
   ScopeLogger();
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "type", std::string, out);
+  CHECK_ARGS(args, kType, std::string, out);
 
-  const std::string type = args.get("type").get<std::string>();
+  const std::string type = args.get(kType).get<std::string>();
   PlatformResult result = server_->UpdateDisplayModeType(type);
   if (!result) {
     LogAndReportError(result, &out, ("Failed server_->UpdateDisplayModeType()"));
@@ -2141,12 +2131,12 @@ void MediaControllerInstance::MediaControllerDisplayModeAddChangeRequestListener
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (!data) {
@@ -2154,7 +2144,7 @@ void MediaControllerInstance::MediaControllerDisplayModeAddChangeRequestListener
       return;
     }
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -2172,8 +2162,8 @@ void MediaControllerInstance::MediaControllerDisplayModeRemoveChangeRequestListe
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
@@ -2189,15 +2179,15 @@ void MediaControllerInstance::MediaControllerDisplayModeInfoGetType(const picojs
                                                                     picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
   std::string type;
-  PlatformResult result = client_->GetDisplayModeType(args.get("name").get<std::string>(), &type);
+  PlatformResult result = client_->GetDisplayModeType(args.get(kName).get<std::string>(), &type);
 
   if (!result) {
     LogAndReportError(result, &out, ("Failed: client_->GetDisplayModeType"));
@@ -2211,18 +2201,18 @@ void MediaControllerInstance::MediaControllerDisplayModeInfoSendType(const picoj
                                                                      picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
-  CHECK_ARGS(args, "name", std::string, out)
-  CHECK_ARGS(args, "type", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
+  CHECK_ARGS(args, kType, std::string, out)
 
   JsonCallback reply_cb = [this, args](picojson::value* reply) -> void {
     picojson::object& reply_obj = reply->get<picojson::object>();
-    reply_obj["listenerId"] = args.get("listenerId");
+    reply_obj[kListenerId] = args.get(kListenerId);
     Instance::PostMessage(this, reply->serialize().c_str());
   };
 
@@ -2232,12 +2222,12 @@ void MediaControllerInstance::MediaControllerDisplayModeInfoSendType(const picoj
   };
 
   PlatformResult result =
-      client_->SendDisplayModeType(args.get("name").get<std::string>(),
-                                   args.get("type").get<std::string>(), reply_cb, &request_id);
+      client_->SendDisplayModeType(args.get(kName).get<std::string>(),
+                                   args.get(kType).get<std::string>(), reply_cb, &request_id);
 
   if (result) {
     ReportSuccess(out);
-    out["requestId"] = picojson::value(std::string(request_id));
+    out[kRequestId] = picojson::value(std::string(request_id));
   } else {
     LogAndReportError(result, &out, ("Failed to send command."));
   }
@@ -2247,12 +2237,12 @@ void MediaControllerInstance::MediaControllerDisplayModeInfoAddModeChangeListene
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (nullptr == data) {
@@ -2261,7 +2251,7 @@ void MediaControllerInstance::MediaControllerDisplayModeInfoAddModeChangeListene
     }
 
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -2279,8 +2269,8 @@ void MediaControllerInstance::MediaControllerDisplayModeInfoRemoveModeChangeList
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
@@ -2299,14 +2289,14 @@ void MediaControllerInstance::MediaControllerDisplayRotationUpdate(const picojso
   ScopeLogger();
 
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "displayRotation", std::string, out)
+  CHECK_ARGS(args, kDisplayRotation, std::string, out)
 
-  const std::string display_rotation = args.get("displayRotation").get<std::string>();
+  const std::string display_rotation = args.get(kDisplayRotation).get<std::string>();
   PlatformResult result = server_->UpdateDisplayRotation(display_rotation);
   if (!result) {
     LogAndReportError(result, &out, ("Failed server_->UpdateDisplayRotation()"));
@@ -2319,12 +2309,12 @@ void MediaControllerInstance::MediaControllerDisplayRotationAddChangeRequestList
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (!data) {
@@ -2332,7 +2322,7 @@ void MediaControllerInstance::MediaControllerDisplayRotationAddChangeRequestList
       return;
     }
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -2350,8 +2340,8 @@ void MediaControllerInstance::MediaControllerDisplayRotationRemoveChangeRequestL
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!server_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: server_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerServerUnknownErrorMsg));
     return;
   }
 
@@ -2367,16 +2357,16 @@ void MediaControllerInstance::MediaControllerDisplayRotationInfoGet(const picojs
                                                                     picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "name", std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
 
   std::string rotation;
   PlatformResult result =
-      client_->GetDisplayRotation(args.get("name").get<std::string>(), &rotation);
+      client_->GetDisplayRotation(args.get(kName).get<std::string>(), &rotation);
 
   if (!result) {
     LogAndReportError(result, &out, ("Failed: client_->GetDisplayRotation"));
@@ -2390,19 +2380,19 @@ void MediaControllerInstance::MediaControllerDisplayRotationInfoSend(const picoj
                                                                      picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occurred."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
-  CHECK_ARGS(args, "name", std::string, out)
-  CHECK_ARGS(args, "displayRotation", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
+  CHECK_ARGS(args, kName, std::string, out)
+  CHECK_ARGS(args, kDisplayRotation, std::string, out)
 
   JsonCallback reply_cb = [this, args](picojson::value* reply) -> void {
     if (reply) {
       picojson::object& reply_obj = reply->get<picojson::object>();
-      reply_obj["listenerId"] = args.get("listenerId");
+      reply_obj[kListenerId] = args.get(kListenerId);
       Instance::PostMessage(this, reply->serialize().c_str());
     } else {
       LoggerW("No reply passed to json callback, ignoring");
@@ -2415,12 +2405,12 @@ void MediaControllerInstance::MediaControllerDisplayRotationInfoSend(const picoj
   };
 
   PlatformResult result = client_->SendDisplayRotation(
-      args.get("name").get<std::string>(), args.get("displayRotation").get<std::string>(), reply_cb,
+      args.get(kName).get<std::string>(), args.get(kDisplayRotation).get<std::string>(), reply_cb,
       &request_id);
 
   if (result) {
     ReportSuccess(out);
-    out["requestId"] = picojson::value(std::string(request_id));
+    out[kRequestId] = picojson::value(std::string(request_id));
   } else {
     LogAndReportError(result, &out, ("Failed to send display rotation command."));
   }
@@ -2430,12 +2420,12 @@ void MediaControllerInstance::MediaControllerDisplayRotationInfoAddChangeListene
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 
-  CHECK_ARGS(args, "listenerId", std::string, out)
+  CHECK_ARGS(args, kListenerId, std::string, out)
 
   JsonCallback callback = [this, args](picojson::value* data) -> void {
     if (nullptr == data) {
@@ -2444,7 +2434,7 @@ void MediaControllerInstance::MediaControllerDisplayRotationInfoAddChangeListene
     }
 
     picojson::object& request_o = data->get<picojson::object>();
-    request_o["listenerId"] = args.get("listenerId");
+    request_o[kListenerId] = args.get(kListenerId);
 
     Instance::PostMessage(this, data->serialize().c_str());
   };
@@ -2462,8 +2452,8 @@ void MediaControllerInstance::MediaControllerDisplayRotationInfoRemoveChangeList
     const picojson::value& args, picojson::object& out) {
   ScopeLogger();
   if (!client_) {
-    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error occured."), &out,
-                      ("Failed: client_"));
+    LogAndReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, MediaControllerUnknownErrorMsg), &out,
+                      (MediaControllerClientUnknownErrorMsg));
     return;
   }
 

diff --git a/src/mediacontroller/mediacontroller_server.cc b/src/mediacontroller/mediacontroller_server.cc
index 1d86a52..23f34da 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.cc
+++ b/src/mediacontroller/mediacontroller_server.cc
@@ -27,6 +27,8 @@
 namespace extension {
 namespace mediacontroller {
 
+using namespace attributes;
+
 using common::BundleJsonIterator;
 using common::ErrorCode;
 using common::PlatformResult;
@@ -332,8 +334,8 @@ void MediaControllerServer::OnSearchRequestReceived(const char* client_name, con
   auto request_json = picojson::value(picojson::object());
   auto& request_o = request_json.get<picojson::object>();
 
-  request_o["clientName"] = picojson::value(std::string(client_name));
-  request_o["requestId"] = picojson::value(std::string(request_id));
+  request_o[kClientName] = picojson::value(std::string(client_name));
+  request_o[kRequestId] = picojson::value(std::string(request_id));
 
   auto condition_cb = [](mc_content_type_e content_type, mc_search_category_e category,
                          const char* keyword, bundle* data, void* user_data) -> bool {
@@ -350,7 +352,7 @@ void MediaControllerServer::OnSearchRequestReceived(const char* client_name, con
               result.message().c_str());
       return false;
     }
-    object["contentType"] = picojson::value(temp);
+    object[kContentType] = picojson::value(temp);
 
     result = types::MediaControllerSearchCategoryEnum.getName(category, &temp);
     if (!result) {
@@ -358,13 +360,13 @@ void MediaControllerServer::OnSearchRequestReceived(const char* client_name, con
               result.message().c_str());
       return false;
     }
-    object["category"] = picojson::value(temp);
+    object[kCategory] = picojson::value(temp);
 
     if (keyword) {
-      object["keyword"] = picojson::value(std::string(keyword));
+      object[kKeyword] = picojson::value(std::string(keyword));
     } else {
       // null is valid search keyword in case of NO_CATEGORY
-      object["keyword"] = picojson::value();
+      object[kKeyword] = picojson::value();
     }
 
     picojson::value data_json;
@@ -373,7 +375,7 @@ void MediaControllerServer::OnSearchRequestReceived(const char* client_name, con
       LoggerE("BundleToJson failed with error message: %s", result.message().c_str());
       return false;
     }
-    object["extraData"] = data_json;
+    object[kExtraData] = data_json;
 
     filters->push_back(value);
     return true;
@@ -386,7 +388,7 @@ void MediaControllerServer::OnSearchRequestReceived(const char* client_name, con
     return;
   }
 
-  request_o["request"] = picojson::value(filters);
+  request_o[kRequest] = picojson::value(filters);
   server->search_request_listener_(&request_json);
 }
 
@@ -406,10 +408,10 @@ void MediaControllerServer::OnCommandReceived(const char* client_name, const cha
   picojson::value request = picojson::value(picojson::object());
   picojson::object& request_o = request.get<picojson::object>();
 
-  request_o["clientName"] = picojson::value(std::string(client_name));
-  request_o["command"] = picojson::value(std::string(command));
-  request_o["requestId"] = picojson::value(std::string(request_id));
-  request_o["data"] = data;
+  request_o[kClientName] = picojson::value(std::string(client_name));
+  request_o[kCommand] = picojson::value(std::string(command));
+  request_o[kRequestId] = picojson::value(std::string(request_id));
+  request_o[kData] = data;
 
   server->command_listener_(&request);
 }
@@ -522,7 +524,7 @@ PlatformResult MediaControllerServer::CreatePlaylist(const std::string& name,
 
   *playlist_info = picojson::value(picojson::object());
   picojson::object& obj = playlist_info->get<picojson::object>();
-  obj["name"] = picojson::value(name);
+  obj[kName] = picojson::value(name);
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -659,8 +661,8 @@ PlatformResult MediaControllerServer::MediaControllerPlaylistGetItems(const std:
     picojson::value value = picojson::value(picojson::object());
     picojson::object& obj = value.get<picojson::object>();
 
-    obj.insert(std::make_pair("index", picojson::value{index}));
-    obj.insert(std::make_pair("metadata", metadata_v));
+    obj.insert(std::make_pair(kIndex, picojson::value{index}));
+    obj.insert(std::make_pair(kMetadata, metadata_v));
     items->push_back(value);
 
     return true;
@@ -1011,9 +1013,9 @@ void MediaControllerServer::OnPlaybackActionCommand(const char* client_name, con
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("onplaybackstaterequest"));
-  data_o["state"] = picojson::value(action_str);
-  data_o["clientName"] = picojson::value(client_name);
+  data_o[kAction] = picojson::value(std::string("onplaybackstaterequest"));
+  data_o[kState] = picojson::value(action_str);
+  data_o[kClientName] = picojson::value(client_name);
 
   server->change_request_playback_info_listener_(&data);
 }
@@ -1034,9 +1036,9 @@ void MediaControllerServer::OnPlaybackPositionCommand(const char* client_name,
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("onplaybackpositionrequest"));
-  data_o["position"] = picojson::value(static_cast<double>(position));
-  data_o["clientName"] = picojson::value(client_name);
+  data_o[kAction] = picojson::value(std::string("onplaybackpositionrequest"));
+  data_o[kPosition] = picojson::value(static_cast<double>(position));
+  data_o[kClientName] = picojson::value(client_name);
 
   server->change_request_playback_info_listener_(&data);
 }
@@ -1055,9 +1057,9 @@ void MediaControllerServer::OnShuffleModeCommand(const char* client_name, const
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("onshufflemoderequest"));
-  data_o["mode"] = picojson::value(mode == MC_SHUFFLE_MODE_ON);
-  data_o["clientName"] = picojson::value(client_name);
+  data_o[kAction] = picojson::value(std::string("onshufflemoderequest"));
+  data_o[kMode] = picojson::value(mode == MC_SHUFFLE_MODE_ON);
+  data_o[kClientName] = picojson::value(client_name);
 
   server->change_request_playback_info_listener_(&data);
 }
@@ -1075,14 +1077,14 @@ void MediaControllerServer::OnRepeatModeCommand(const char* client_name, const c
 
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
-  data_o["clientName"] = picojson::value(client_name);
+  data_o[kClientName] = picojson::value(client_name);
 
   if (MC_REPEAT_MODE_ONE_MEDIA != mode) {
     // The onrepeatmoderequest event may be reported only with mode equal to true/false. The 3rd
     // mode is not supported by this event.
     common::tools::PrintDeprecationWarningFor("onrepeatmoderequest", "onrepeatstaterequest");
-    data_o["action"] = picojson::value(std::string("onrepeatmoderequest"));
-    data_o["mode"] = picojson::value(mode == MC_REPEAT_MODE_ON);
+    data_o[kAction] = picojson::value(std::string("onrepeatmoderequest"));
+    data_o[kMode] = picojson::value(mode == MC_REPEAT_MODE_ON);
     server->change_request_playback_info_listener_(&data);
   }
 
@@ -1092,8 +1094,8 @@ void MediaControllerServer::OnRepeatModeCommand(const char* client_name, const c
     LoggerE("MediaControllerRepeatModeEnum.getName() failed, error: %s", result.message().c_str());
     return;
   }
-  data_o["action"] = picojson::value(std::string("onrepeatstaterequest"));
-  data_o["state"] = picojson::value(state);
+  data_o[kAction] = picojson::value(std::string("onrepeatstaterequest"));
+  data_o[kState] = picojson::value(state);
 
   server->change_request_playback_info_listener_(&data);
 }
@@ -1117,12 +1119,12 @@ void MediaControllerServer::OnPlaybackItemCommand(const char* client_name, const
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["action"] = picojson::value(std::string("onplaybackitemrequest"));
-  data_o["playlistName"] = picojson::value(playlist_name);
-  data_o["index"] = picojson::value(index);
-  data_o["state"] = picojson::value(action_str);
-  data_o["position"] = picojson::value(static_cast<double>(position));
-  data_o["clientName"] = picojson::value(client_name);
+  data_o[kAction] = picojson::value(std::string("onplaybackitemrequest"));
+  data_o[kPlaylistName] = picojson::value(playlist_name);
+  data_o[kIndex] = picojson::value(index);
+  data_o[kState] = picojson::value(action_str);
+  data_o[kPosition] = picojson::value(static_cast<double>(position));
+  data_o[kClientName] = picojson::value(client_name);
 
   server->change_request_playback_info_listener_(&data);
 }
@@ -1149,9 +1151,9 @@ void MediaControllerServer::OnSubtitlesChangeCommand(const char* client_name,
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["enabled"] = picojson::value(enabled);
-  data_o["clientName"] = picojson::value(client_name);
-  data_o["requestId"] = picojson::value(std::string(request_id));
+  data_o[kEnabled] = picojson::value(enabled);
+  data_o[kClientName] = picojson::value(client_name);
+  data_o[kRequestId] = picojson::value(std::string(request_id));
 
   server->subtitles_change_request_listener_(&data);
 }
@@ -1207,9 +1209,9 @@ void MediaControllerServer::OnMode360ChangeCommand(const char* client_name, cons
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["enabled"] = picojson::value(enabled);
-  data_o["clientName"] = picojson::value(client_name);
-  data_o["requestId"] = picojson::value(std::string(request_id));
+  data_o[kEnabled] = picojson::value(enabled);
+  data_o[kClientName] = picojson::value(client_name);
+  data_o[kRequestId] = picojson::value(std::string(request_id));
 
   server->mode360_change_request_listener_(&data);
 }
@@ -1282,9 +1284,9 @@ void MediaControllerServer::OnDisplayModeChangeCommand(const char* client_name,
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["type"] = picojson::value(type);
-  data_o["clientName"] = picojson::value(client_name);
-  data_o["requestId"] = picojson::value(std::string(request_id));
+  data_o[kType] = picojson::value(type);
+  data_o[kClientName] = picojson::value(client_name);
+  data_o[kRequestId] = picojson::value(std::string(request_id));
 
   server->display_mode_change_request_listener_(&data);
 }
@@ -1362,9 +1364,9 @@ void MediaControllerServer::OnDisplayRotationChangeCommand(const char* client_na
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 
-  data_o["displayRotation"] = picojson::value(display_rotation);
-  data_o["clientName"] = picojson::value(client_name);
-  data_o["requestId"] = picojson::value(std::string(request_id));
+  data_o[kDisplayRotation] = picojson::value(display_rotation);
+  data_o[kClientName] = picojson::value(client_name);
+  data_o[kRequestId] = picojson::value(std::string(request_id));
   server->display_rotation_change_request_listener_(&data);
 }
 

diff --git a/src/mediacontroller/mediacontroller_utils.cc b/src/mediacontroller/mediacontroller_utils.cc
index 28fd445..34230ae 100644 (file)
--- a/src/mediacontroller/mediacontroller_utils.cc
+++ b/src/mediacontroller/mediacontroller_utils.cc
@@ -28,6 +28,57 @@ namespace mediacontroller {
 using common::ErrorCode;
 using common::PlatformResult;
 
+namespace privileges {
+
+const char* kPrivilegeMediaControllerClient =
+    "http://tizen.org/privilege/mediacontroller.client";
+const char* kPrivilegeMediaControllerServer =
+    "http://tizen.org/privilege/mediacontroller.server";
+
+} // privileges
+
+namespace attributes {
+
+const char* kAbility = "ability";
+const char* kAbilityType = "abilityType";
+const char* kAction = "action";
+const char* kAgeRating = "ageRating";
+const char* kCallbackId = "callbackId";
+const char* kCategory = "category";
+const char* kClientName = "clientName";
+const char* kCode = "code";
+const char* kCommand = "command";
+const char* kContentType = "contentType";
+const char* kData = "data";
+const char* kDisplayMode = "displayMode";
+const char* kDisplayRotation = "displayRotation";
+const char* kDisplayRotationAbility = "displayRotationAbility";
+const char* kEnabled = "enabled";
+const char* kExtraData = "extraData";
+const char* kIconURI = "iconURI";
+const char* kIndex = "index";
+const char* kKeyword = "keyword";
+const char* kListenerId = "listenerId";
+const char* kMetadata = "metadata";
+const char* kMode = "mode";
+const char* kName = "name";
+const char* kPlaylistName = "playlistName";
+const char* kPosition = "position";
+const char* kRating = "rating";
+const char* kRepeatMode = "repeatMode";
+const char* kReply = "reply";
+const char* kRequest = "request";
+const char* kRequestId = "requestId";
+const char* kResult = "result";
+const char* kServerName = "serverName";
+const char* kShuffleMode = "shuffleMode";
+const char* kState = "state";
+const char* kSupport = "support";
+const char* kType = "type";
+const char* kValue = "value";
+
+} // attributes
+
 namespace types {
 
 const common::PlatformEnum<mc_server_state_e> MediaControllerServerStateEnum{

diff --git a/src/mediacontroller/mediacontroller_utils.h b/src/mediacontroller/mediacontroller_utils.h
index 9655659..4b4885e 100644 (file)
--- a/src/mediacontroller/mediacontroller_utils.h
+++ b/src/mediacontroller/mediacontroller_utils.h
@@ -30,6 +30,58 @@ namespace mediacontroller {
 
 typedef std::function<void(picojson::value*)> JsonCallback;
 
+
+namespace privileges {
+
+extern const char* kPrivilegeMediaControllerClient;
+extern const char* kPrivilegeMediaControllerServer;
+
+} // privileges
+
+
+namespace attributes {
+
+extern const char* kAbility;
+extern const char* kAbilityType;
+extern const char* kAction;
+extern const char* kAgeRating;
+extern const char* kCallbackId;
+extern const char* kCategory;
+extern const char* kClientName;
+extern const char* kCode;
+extern const char* kCommand;
+extern const char* kContentType;
+extern const char* kData;
+extern const char* kDisplayMode;
+extern const char* kDisplayRotation;
+extern const char* kDisplayRotationAbility;
+extern const char* kEnabled;
+extern const char* kExtraData;
+extern const char* kIconURI;
+extern const char* kIndex;
+extern const char* kKeyword;
+extern const char* kListenerId;
+extern const char* kMetadata;
+extern const char* kMode;
+extern const char* kName;
+extern const char* kPlaylistName;
+extern const char* kPosition;
+extern const char* kRating;
+extern const char* kRepeatMode;
+extern const char* kReply;
+extern const char* kRequest;
+extern const char* kRequestId;
+extern const char* kResult;
+extern const char* kServerName;
+extern const char* kShuffleMode;
+extern const char* kState;
+extern const char* kSupport;
+extern const char* kType;
+extern const char* kValue;
+
+} // attributes
+
+
 namespace types {
 
 common::PlatformResult ConvertPlaybackState(mc_playback_h playback_h, std::string* state);