[Mediacontroller] Refactoring and replacing deprecated functions

+ The Native API changed many function signatures by adding 'd' at the end
  of verb. The new functions were applied.
+ New mc_playback_states_e enums were added.
+ Returned std::multimap is no longer copied using the
  Types::GetPlatformEnumMap method.
+ 2 metadata deprecated functions were replaced.
+ Instead of sending playback state, playback action is sent to change
  server's playback state on Native level (Web interface was not affected).

[Verification] MC TCT M&A 100%

Change-Id: I5866f7cf2b217480c116fbf91e683abd53a81d03
Signed-off-by: Szymon Jastrzebski <s.jastrzebsk@partner.samsung.com>

diff --git a/src/mediacontroller/mediacontroller_client.cc b/src/mediacontroller/mediacontroller_client.cc
index cce90a297b8f7a21510921c74adc99b860020810..f684dd7aa9b5e7a915239372e02b2d2c69146537 100644 (file)
--- a/src/mediacontroller/mediacontroller_client.cc
+++ b/src/mediacontroller/mediacontroller_client.cc
@@ -226,7 +226,7 @@ PlatformResult MediaControllerClient::GetMetadata(const std::string& server_name
   ScopeLogger();
   int ret;
 
-  mc_metadata_h metadata_h;
+  mc_metadata_h metadata_h = nullptr;
   ret = mc_client_get_server_metadata(handle_, server_name.c_str(), &metadata_h);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
@@ -235,7 +235,7 @@ PlatformResult MediaControllerClient::GetMetadata(const std::string& server_name
   }
 
   SCOPE_EXIT {
-    mc_client_destroy_metadata(metadata_h);
+    mc_metadata_destroy(metadata_h);
   };
 
   PlatformResult result = Types::ConvertMetadata(metadata_h, metadata);
@@ -249,11 +249,11 @@ PlatformResult MediaControllerClient::GetMetadata(const std::string& server_name
 PlatformResult MediaControllerClient::SetServerStatusChangeListener(const JsonCallback& callback) {
   ScopeLogger();
 
-  int ret = mc_client_set_server_update_cb(handle_, OnServerStatusUpdate, this);
+  int ret = mc_client_set_server_updated_cb(handle_, OnServerStatusUpdate, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
         ErrorCode::UNKNOWN_ERR, "Unable to set server status listener",
-        ("mc_client_set_server_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
+        ("mc_client_set_server_updated_cb() error: %d, message: %s", ret, get_error_message(ret)));
   }
 
   server_status_listener_ = callback;
@@ -263,11 +263,11 @@ PlatformResult MediaControllerClient::SetServerStatusChangeListener(const JsonCa
 
 PlatformResult MediaControllerClient::UnsetServerStatusChangeListener() {
   ScopeLogger();
-  int ret = mc_client_unset_server_update_cb(handle_);
+  int ret = mc_client_unset_server_updated_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
-    return LogAndCreateResult(
-        ErrorCode::UNKNOWN_ERR, "Unable to unset server status listener",
-        ("mc_client_unset_server_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to unset server status listener",
+                              ("mc_client_unset_server_updated_cb() error: %d, message: %s", ret,
+                               get_error_message(ret)));
   }
   server_status_listener_ = nullptr;
   return PlatformResult(ErrorCode::NO_ERROR);
@@ -305,9 +305,9 @@ PlatformResult MediaControllerClient::SetPlaybackInfoListener(const JsonCallback
     // The purpose of this lambda is to unset as many setters as we can in case of failure.
 
     int (*unsetters[])(mc_client_h) = {
-        mc_client_unset_playback_update_cb, mc_client_unset_shuffle_mode_update_cb,
-        mc_client_unset_repeat_mode_update_cb,
-        /*mc_client_unset_metadata_update_cb the last unsetter will never be used*/};
+        mc_client_unset_playback_updated_cb, mc_client_unset_shuffle_mode_updated_cb,
+        mc_client_unset_repeat_mode_updated_cb,
+        /*mc_client_unset_metadata_updated_cb the last unsetter will never be used*/};
 
     // This loop is no-op in case of success.
     for (int i = 0; i < failed_setter; ++i) {
@@ -318,35 +318,35 @@ PlatformResult MediaControllerClient::SetPlaybackInfoListener(const JsonCallback
     }
   };
 
-  int ret = mc_client_set_playback_update_cb(handle_, OnPlaybackUpdate, this);
+  int ret = mc_client_set_playback_updated_cb(handle_, OnPlaybackUpdate, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
-    return LogAndCreateResult(
-        ErrorCode::UNKNOWN_ERR, "Unable to register playback listener",
-        ("mc_client_set_playback_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register playback listener",
+                              ("mc_client_set_playback_updated_cb() error: %d, message: %s", ret,
+                               get_error_message(ret)));
   }
 
-  ret = mc_client_set_shuffle_mode_update_cb(handle_, OnShuffleModeUpdate, this);
+  ret = mc_client_set_shuffle_mode_updated_cb(handle_, OnShuffleModeUpdate, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     failed_setter = 1;
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register shuffle mode listener",
-                              ("mc_client_set_shuffle_mode_update_cb() error: %d, message: %s", ret,
-                               get_error_message(ret)));
+                              ("mc_client_set_shuffle_mode_updated_cb() error: %d, message: %s",
+                               ret, get_error_message(ret)));
   }
 
-  ret = mc_client_set_repeat_mode_update_cb(handle_, OnRepeatModeUpdate, this);
+  ret = mc_client_set_repeat_mode_updated_cb(handle_, OnRepeatModeUpdate, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     failed_setter = 2;
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register repeat mode listener",
-                              ("mc_client_set_repeat_mode_update_cb() error: %d, message: %s", ret,
+                              ("mc_client_set_repeat_mode_updated_cb() error: %d, message: %s", ret,
                                get_error_message(ret)));
   }
 
-  ret = mc_client_set_metadata_update_cb(handle_, OnMetadataUpdate, this);
+  ret = mc_client_set_metadata_updated_cb(handle_, OnMetadataUpdate, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     failed_setter = 3;
-    return LogAndCreateResult(
-        ErrorCode::UNKNOWN_ERR, "Unable to register metadata listener",
-        ("mc_client_set_metadata_update_cb() error: %d, message: %s", ret, get_error_message(ret)));
+    return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Unable to register metadata listener",
+                              ("mc_client_set_metadata_updated_cb() error: %d, message: %s", ret,
+                               get_error_message(ret)));
   }
 
   playback_info_listener_ = callback;
@@ -360,10 +360,10 @@ PlatformResult MediaControllerClient::UnsetPlaybackInfoListener() {
   // In the Javascript layer, the removePlaybackInfoChangeListener() method always succeeds, so we
   // do not need to catch the returned value.
 
-  mc_client_unset_playback_update_cb(handle_);
-  mc_client_unset_shuffle_mode_update_cb(handle_);
-  mc_client_unset_repeat_mode_update_cb(handle_);
-  mc_client_unset_metadata_update_cb(handle_);
+  mc_client_unset_playback_updated_cb(handle_);
+  mc_client_unset_shuffle_mode_updated_cb(handle_);
+  mc_client_unset_repeat_mode_updated_cb(handle_);
+  mc_client_unset_metadata_updated_cb(handle_);
 
   playback_info_listener_ = nullptr;
 
@@ -540,19 +540,27 @@ PlatformResult MediaControllerClient::SendPlaybackState(const std::string& serve
                                                         const std::string& state) {
   ScopeLogger();
   int state_e;
+  // In Native API, since Tizen 5.0 an action instead of a state is sent to change the state of a
+  // server. In Web API the names were not refactored.
   PlatformResult result =
-      Types::StringToPlatformEnum(Types::kMediaControllerPlaybackState, state, &state_e);
+      Types::StringToPlatformEnum(Types::kMediaControllerPlaybackAction, state, &state_e);
   if (!result) {
     return result;
   }
 
+  /* TODO: Prepare an ACR and propose use case for request_id.
+  char* request_id = nullptr;
+  SCOPE_EXIT {
+    free(request_id);
+  };*/
   int ret;
-  ret = mc_client_send_playback_state_command(handle_, server_name.c_str(),
-                                              static_cast<mc_playback_states_e>(state_e));
+  ret = mc_client_send_playback_action_cmd(handle_, server_name.c_str(),
+                                           static_cast<mc_playback_action_e>(state_e),
+                                           /*&request_id*/ nullptr);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error sending playback state",
-                              ("mc_client_send_playback_state_command() error: %d, message: %s",
-                               ret, get_error_message(ret)));
+                              ("mc_client_send_playback_action_cmd() error: %d, message: %s", ret,
+                               get_error_message(ret)));
   }
 
   return PlatformResult(ErrorCode::NO_ERROR);

diff --git a/src/mediacontroller/mediacontroller_server.cc b/src/mediacontroller/mediacontroller_server.cc
index b2a3e83e6ccd7eb098df177789ba7ad3681aa3f8..123297c7ccc8c1f3846081d280db499d8e2d2a83 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.cc
+++ b/src/mediacontroller/mediacontroller_server.cc
@@ -326,7 +326,7 @@ PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
     // The purpose of this lambda is to unset as many setters as we can in case of failure.
 
     int (*unsetters[])(mc_server_h) = {
-        mc_server_unset_playback_state_command_received_cb,
+        mc_server_unset_playback_action_cmd_received_cb,
         mc_server_unset_playback_position_cmd_received_cb,
         mc_server_unset_shuffle_mode_cmd_received_cb,
         /*mc_server_unset_repeat_mode_cmd_received_cb the last unsetter will never be used*/};
@@ -340,11 +340,13 @@ PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
     }
   };
 
-  int ret = mc_server_set_playback_state_command_received_cb(handle_, OnPlaybackStateCommand, this);
+  // In Native API, since Tizen 5.0 an action instead of a state is sent to change the state of a
+  // server. In Web API the names were not refactored.
+  int ret = mc_server_set_playback_action_cmd_received_cb(handle_, OnPlaybackActionCommand, this);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
         ErrorCode::UNKNOWN_ERR, "Unable to set playback state command listener",
-        ("mc_server_set_playback_state_command_received_cb() error: %d, message: %s", ret,
+        ("mc_server_set_playback_action_cmd_received_cb() error: %d, message: %s", ret,
          get_error_message(ret)));
   }
 
@@ -382,11 +384,11 @@ PlatformResult MediaControllerServer::SetChangeRequestPlaybackInfoListener(
 PlatformResult MediaControllerServer::UnsetChangeRequestPlaybackInfoListener() {
   ScopeLogger();
 
-  int ret = mc_server_unset_playback_state_command_received_cb(handle_);
+  int ret = mc_server_unset_playback_action_cmd_received_cb(handle_);
   if (MEDIA_CONTROLLER_ERROR_NONE != ret) {
     return LogAndCreateResult(
         ErrorCode::UNKNOWN_ERR, "Unable to unset playback state command listener",
-        ("mc_server_unset_playback_state_command_received_cb() error: %d, message: %s", ret,
+        ("mc_server_unset_playback_action_cmd_received_cb() error: %d, message: %s", ret,
          get_error_message(ret)));
   }
 
@@ -419,25 +421,32 @@ PlatformResult MediaControllerServer::UnsetChangeRequestPlaybackInfoListener() {
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
-void MediaControllerServer::OnPlaybackStateCommand(const char* client_name,
-                                                   mc_playback_states_e state_e, void* user_data) {
+void MediaControllerServer::OnPlaybackActionCommand(const char* client_name, const char* request_id,
+                                                    mc_playback_action_e action, void* user_data) {
   ScopeLogger();
 
   MediaControllerServer* server = static_cast<MediaControllerServer*>(user_data);
 
-  if (server->playback_state_ == state_e) {
-    LoggerD("The media playback state did not change, skipping");
+  // Here, we need to convert mc_playback_action_e enum to mc_playback_states_e enum.
+  std::string state;
+  PlatformResult result = Types::PlatformEnumToString(Types::kMediaControllerPlaybackAction,
+                                                      static_cast<int>(action), &state);
+  if (!result) {
+    LoggerW("PlatformEnumToString failed, error: %s", result.message().c_str());
     return;
   }
-
-  std::string state;
-  PlatformResult result = Types::PlatformEnumToString(Types::kMediaControllerPlaybackState,
-                                                      static_cast<int>(state_e), &state);
+  int state_e = 0;
+  result = Types::StringToPlatformEnum(Types::kMediaControllerPlaybackState, state, &state_e);
   if (!result) {
     LoggerE("PlatformEnumToString failed, error: %s", result.message().c_str());
     return;
   }
 
+  if (server->playback_state_ == state_e) {
+    LoggerD("The media playback state did not change, skipping");
+    return;
+  }
+
   picojson::value data = picojson::value(picojson::object());
   picojson::object& data_o = data.get<picojson::object>();
 

diff --git a/src/mediacontroller/mediacontroller_server.h b/src/mediacontroller/mediacontroller_server.h
index 2fc1803a67d3a428500f00bbec83893e01611e3a..9ffa5f285adb10ca21ba9d7157cbd363e10f7bce 100644 (file)
--- a/src/mediacontroller/mediacontroller_server.h
+++ b/src/mediacontroller/mediacontroller_server.h
@@ -60,8 +60,8 @@ class MediaControllerServer {
 
   JsonCallback command_listener_;
 
-  static void OnPlaybackStateCommand(const char* client_name, mc_playback_states_e state_e,
-                                     void* user_data);
+  static void OnPlaybackActionCommand(const char* client_name, const char* request_id,
+                                      mc_playback_action_e action, void* user_data);
   static void OnPlaybackPositionCommand(const char* client_name, const char* request_id,
                                         unsigned long long position, void* user_data);
   static void OnShuffleModeCommand(const char* client_name, const char* request_id,

diff --git a/src/mediacontroller/mediacontroller_types.cc b/src/mediacontroller/mediacontroller_types.cc
index f56c431bebfd2a39b6edc16846c2ee33b89edd60..5b9689b246b1760a7acf1c597cc6df740808176a 100644 (file)
--- a/src/mediacontroller/mediacontroller_types.cc
+++ b/src/mediacontroller/mediacontroller_types.cc
@@ -30,6 +30,7 @@ using common::ErrorCode;
 
 const std::string Types::kMediaControllerServerState = "MediaControllerServerState";
 const std::string Types::kMediaControllerPlaybackState = "MediaControllerPlaybackState";
+const std::string Types::kMediaControllerPlaybackAction = "MediaControllerPlaybackAction";
 const std::string Types::kMediaControllerMetadataAttribute = "MediaControllerMetadataAttribute";
 
 const PlatformEnumMap Types::platform_enum_map_ = {{kMediaControllerServerState,
@@ -40,10 +41,25 @@ const PlatformEnumMap Types::platform_enum_map_ = {{kMediaControllerServerState,
                                                     {{"PLAY", MC_PLAYBACK_STATE_PLAYING},
                                                      {"PAUSE", MC_PLAYBACK_STATE_PAUSED},
                                                      {"STOP", MC_PLAYBACK_STATE_STOPPED},
+                                                     // Deprecated values of MC_PLAYBACK_STATE enum
+                                                     // still have to be supported, because native
+                                                     // applications/API might still use them.
                                                      {"NEXT", MC_PLAYBACK_STATE_NEXT_FILE},
+                                                     {"NEXT", MC_PLAYBACK_STATE_MOVING_TO_NEXT},
                                                      {"PREV", MC_PLAYBACK_STATE_PREV_FILE},
+                                                     {"PREV", MC_PLAYBACK_STATE_MOVING_TO_PREVIOUS},
                                                      {"FORWARD", MC_PLAYBACK_STATE_FAST_FORWARD},
-                                                     {"REWIND", MC_PLAYBACK_STATE_REWIND}}},
+                                                     {"FORWARD", MC_PLAYBACK_STATE_FAST_FORWARDING},
+                                                     {"REWIND", MC_PLAYBACK_STATE_REWIND},
+                                                     {"REWIND", MC_PLAYBACK_STATE_REWINDING}}},
+                                                   {kMediaControllerPlaybackAction,
+                                                    {{"PLAY", MC_PLAYBACK_ACTION_PLAY},
+                                                     {"PAUSE", MC_PLAYBACK_ACTION_PAUSE},
+                                                     {"STOP", MC_PLAYBACK_ACTION_STOP},
+                                                     {"NEXT", MC_PLAYBACK_ACTION_NEXT},
+                                                     {"PREV", MC_PLAYBACK_ACTION_PREV},
+                                                     {"FORWARD", MC_PLAYBACK_ACTION_FAST_FORWARD},
+                                                     {"REWIND", MC_PLAYBACK_ACTION_REWIND}}},
                                                    {kMediaControllerMetadataAttribute,
                                                     {{"title", MC_META_MEDIA_TITLE},
                                                      {"artist", MC_META_MEDIA_ARTIST},
@@ -60,7 +76,7 @@ const PlatformEnumMap Types::platform_enum_map_ = {{kMediaControllerServerState,
 PlatformEnumReverseMap Types::platform_enum_reverse_map_ = {};
 
 PlatformResult Types::GetPlatformEnumMap(const std::string& type,
-                                         std::map<std::string, int>* enum_map) {
+                                         std::multimap<std::string, int> const** enum_map) {
   ScopeLogger();
 
   auto iter = platform_enum_map_.find(type);
@@ -69,7 +85,7 @@ PlatformResult Types::GetPlatformEnumMap(const std::string& type,
                               std::string("Undefined platform enum type ") + type);
   }
 
-  *enum_map = platform_enum_map_.at(type);
+  *enum_map = &iter->second;
 
   return PlatformResult(ErrorCode::NO_ERROR);
 }
@@ -78,14 +94,14 @@ PlatformResult Types::StringToPlatformEnum(const std::string& type, const std::s
                                            int* platform_enum) {
   ScopeLogger();
 
-  std::map<std::string, int> def;
+  std::multimap<std::string, int> const* def = nullptr;
   PlatformResult result = GetPlatformEnumMap(type, &def);
   if (!result) {
     return result;
   }
 
-  auto def_iter = def.find(value);
-  if (def_iter != def.end()) {
+  auto def_iter = def->find(value);
+  if (def_iter != def->end()) {
     *platform_enum = def_iter->second;
     return PlatformResult(ErrorCode::NO_ERROR);
   }
@@ -171,7 +187,7 @@ PlatformResult Types::ConvertPlaybackPosition(mc_playback_h playback_h, double*
 PlatformResult Types::ConvertMetadata(mc_metadata_h metadata_h, picojson::object* metadata) {
   ScopeLogger();
 
-  std::map<std::string, int> metadata_fields;
+  std::multimap<std::string, int> const* metadata_fields = nullptr;
   PlatformResult result =
       GetPlatformEnumMap(Types::kMediaControllerMetadataAttribute, &metadata_fields);
   if (!result) {
@@ -184,12 +200,12 @@ PlatformResult Types::ConvertMetadata(mc_metadata_h metadata_h, picojson::object
     free(value);
   };
 
-  for (auto& field : metadata_fields) {
-    int ret = mc_client_get_metadata(metadata_h, static_cast<mc_meta_e>(field.second), &value);
+  for (auto& field : *metadata_fields) {
+    int ret = mc_metadata_get(metadata_h, static_cast<mc_meta_e>(field.second), &value);
     if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
       return LogAndCreateResult(ErrorCode::UNKNOWN_ERR, "Error getting metadata",
-                                ("mc_client_get_metadata(%s) error: %d, message: %s",
-                                 field.first.c_str(), ret, get_error_message(ret)));
+                                ("mc_metadata_get(%s) error: %d, message: %s", field.first.c_str(),
+                                 ret, get_error_message(ret)));
     }
 
     (*metadata)[field.first] = picojson::value(std::string(value ? value : ""));

diff --git a/src/mediacontroller/mediacontroller_types.h b/src/mediacontroller/mediacontroller_types.h
index 20966aaf9d085e6bd46404178dc57a71bea4cee3..57e59201bc2c39bae4b617ebdc601f1335e4f947 100644 (file)
--- a/src/mediacontroller/mediacontroller_types.h
+++ b/src/mediacontroller/mediacontroller_types.h
@@ -27,7 +27,7 @@
 namespace extension {
 namespace mediacontroller {
 
-typedef std::map<std::string, std::map<std::string, int>> PlatformEnumMap;
+typedef std::map<std::string, std::multimap<std::string, int>> PlatformEnumMap;
 typedef std::map<std::string, std::map<int, std::string>> PlatformEnumReverseMap;
 typedef std::function<void(picojson::value*)> JsonCallback;
 
@@ -35,10 +35,11 @@ class Types {
  public:
   static const std::string kMediaControllerServerState;
   static const std::string kMediaControllerPlaybackState;
+  static const std::string kMediaControllerPlaybackAction;
   static const std::string kMediaControllerMetadataAttribute;
 
-  static common::PlatformResult GetPlatformEnumMap(const std::string& type,
-                                                   std::map<std::string, int>* platform_str);
+  static common::PlatformResult GetPlatformEnumMap(
+      const std::string& type, std::multimap<std::string, int> const** platform_str);
 
   static common::PlatformResult StringToPlatformEnum(const std::string& type,
                                                      const std::string& value, int* platform_enum);