[MediaController] Client.GetPlaybackInfo native implementation

Change-Id: I2a4ea6204c5e8b2e41cb6afb530424aff9f39c77

diff --git a/src/mediacontroller/mediacontroller_client.cc b/src/mediacontroller/mediacontroller_client.cc
index 4d7dfb76024430483b5aba4e4aad5f0cc0d62588..12915b061dfc7502ba804414cc3d8f58ee0e6f65 100644 (file)
--- a/src/mediacontroller/mediacontroller_client.cc
+++ b/src/mediacontroller/mediacontroller_client.cc
@@ -137,5 +137,144 @@ PlatformResult MediaControllerClient::GetLatestServerInfo(
   return PlatformResult(ErrorCode::NO_ERROR);
 }
 
+PlatformResult MediaControllerClient::GetPlaybackInfo(
+    const std::string& server_name,
+    picojson::object* playback_info) {
+
+  int ret;
+
+  mc_playback_h playback_h;
+  ret = mc_client_get_server_playback_info(handle_,
+                                           server_name.c_str(),
+                                           &playback_h);
+  if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+    LOGGER(ERROR) << "mc_client_get_latest_server_info failed, error: " << ret;
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Error getting latest server info");
+  }
+
+  SCOPE_EXIT {
+    mc_client_destroy_playback(playback_h);
+  };
+
+  // playback state
+  mc_playback_states_e state;
+  ret = mc_client_get_playback_state(playback_h, &state);
+  if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+    LOGGER(ERROR) << "mc_client_get_playback_state failed, error: " << ret;
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Error getting playback state");
+  }
+  if (state == MEDIA_PLAYBACK_STATE_NONE) {
+    state = MEDIA_PLAYBACK_STATE_STOPPED;
+  }
+
+  std::string state_str;
+  PlatformResult result = Types::PlatformEnumToString(
+      Types::kMediaControllerPlaybackState,
+      static_cast<int>(state), &state_str);
+  if (!result) {
+    LOGGER(ERROR) << "PlatformEnumToString failed, error: " << result.message();
+    return result;
+  }
+
+  // playback position
+  unsigned long long position;
+  ret = mc_client_get_playback_position(playback_h, &position);
+  if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+    LOGGER(ERROR) << "mc_client_get_playback_position failed, error: " << ret;
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Error getting playback position");
+  }
+
+  // shuffle mode
+  mc_shuffle_mode_e shuffle;
+  ret = mc_client_get_server_shuffle_mode(
+      handle_, server_name.c_str(), &shuffle);
+  if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+    LOGGER(ERROR) << "mc_client_get_server_shuffle_mode failed, error: " << ret;
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Error getting shuffle mode");
+  }
+
+  // repeat mode
+  mc_repeat_mode_e repeat;
+  ret = mc_client_get_server_repeat_mode(
+      handle_, server_name.c_str(), &repeat);
+  if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+    LOGGER(ERROR) << "mc_client_get_server_repeat_mode failed, error: " << ret;
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Error getting repeat mode");
+  }
+
+  // metadata
+  picojson::value metadata = picojson::value(picojson::object());
+  result = GetMetadata(server_name, &metadata.get<picojson::object>());
+  if (!result) {
+    return result;
+  }
+
+  // fill return object
+  (*playback_info)["state"] = picojson::value(state_str);
+  (*playback_info)["position"] = picojson::value(static_cast<double>(position));
+  (*playback_info)["shuffleMode"] = picojson::value(shuffle == SHUFFLE_MODE_ON);
+  (*playback_info)["repeatMode"] = picojson::value(repeat == REPEAT_MODE_ON);
+  (*playback_info)["metadata"] = metadata;
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult MediaControllerClient::GetMetadata(
+    const std::string& server_name,
+    picojson::object* metadata) {
+  LOGGER(DEBUG) << "entered";
+
+  int ret;
+
+  mc_metadata_h metadata_h;
+  ret = mc_client_get_server_metadata(handle_, server_name.c_str(),
+                                      &metadata_h);
+  if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+    LOGGER(ERROR) << "mc_client_get_server_metadata failed, error: " << ret;
+    return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                          "Error getting metadata");
+  }
+
+  SCOPE_EXIT {
+    mc_client_destroy_metadata(metadata_h);
+  };
+
+  std::map<std::string, int> metadata_fields;
+  PlatformResult result = Types::GetPlatformEnumMap(
+      Types::kMediaControllerMetadataAttribute, &metadata_fields);
+  if (!result) {
+    LOGGER(ERROR) << "GetPlatformEnumMap failed, error: " << result.message();
+    return result;
+  }
+
+  char* value = nullptr;
+  SCOPE_EXIT {
+    free(value);
+  };
+  for (auto& field : metadata_fields) {
+    ret = mc_client_get_metadata(metadata_h,
+                                 static_cast<mc_meta_e>(field.second),
+                                 &value);
+    if (ret != MEDIA_CONTROLLER_ERROR_NONE) {
+      LOGGER(ERROR) << "mc_client_get_metadata failed for field '"
+          << field.first << "', error: " << ret;
+      return PlatformResult(ErrorCode::UNKNOWN_ERR,
+                            "Error getting metadata");
+    }
+    if (!value) {
+      value = strdup("");
+    }
+
+    (*metadata)[field.first] = picojson::value(std::string(value));
+  }
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
 } // namespace mediacontroller
 } // namespace extension

diff --git a/src/mediacontroller/mediacontroller_client.h b/src/mediacontroller/mediacontroller_client.h
index 37c2b6d215c9a568d455b1dd4d4e483bad0d45c1..939b0ea102b53fdc9a4398a4d074f87b2f230a2b 100644 (file)
--- a/src/mediacontroller/mediacontroller_client.h
+++ b/src/mediacontroller/mediacontroller_client.h
@@ -21,6 +21,10 @@ class MediaControllerClient {
   common::PlatformResult Init();
   common::PlatformResult FindServers(picojson::array* servers);
   common::PlatformResult GetLatestServerInfo(picojson::value* server_info);
+  common::PlatformResult GetPlaybackInfo(const std::string& server_name,
+                                         picojson::object* playback_info);
+  common::PlatformResult GetMetadata(const std::string& server_name,
+                                         picojson::object* metadata);
 
  private:
   mc_client_h handle_;

diff --git a/src/mediacontroller/mediacontroller_instance.cc b/src/mediacontroller/mediacontroller_instance.cc
index 5cc9724ec61322a4fc5e42abfb7254c393a21b7b..ffca63edcbff0653d30bdf9671c245e7d6e7efa4 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.cc
+++ b/src/mediacontroller/mediacontroller_instance.cc
@@ -64,6 +64,8 @@ MediaControllerInstance::MediaControllerInstance() {
       MediaControllerClientFindServers);
   REGISTER_SYNC("MediaControllerClient_getLatestServerInfo",
       MediaControllerClientGetLatestServerInfo);
+  REGISTER_SYNC("MediaControllerClient_getPlaybackInfo",
+      MediaControllerClientGetPlaybackInfo);
   REGISTER_SYNC("MediaControllerServerInfo_sendPlaybackState",
       MediaControllerServerInfoSendPlaybackState);
   REGISTER_ASYNC("MediaControllerServerInfo_sendPlaybackPosition",
@@ -312,6 +314,31 @@ void MediaControllerInstance::MediaControllerClientGetLatestServerInfo(
   ReportSuccess(server_info, out);
 }
 
+void MediaControllerInstance::MediaControllerClientGetPlaybackInfo(
+    const picojson::value& args,
+    picojson::object& out) {
+
+  if (!client_) {
+    ReportError(PlatformResult(ErrorCode::INVALID_STATE_ERR,
+                               "Client not initialized."), &out);
+    return;
+  }
+
+  CHECK_EXIST(args, "name", out)
+
+  picojson::value playback_info = picojson::value(picojson::object());
+  PlatformResult result = client_->GetPlaybackInfo(
+      args.get("name").get<std::string>(),
+      &playback_info.get<picojson::object>());
+
+  if (!result) {
+    ReportError(result, &out);
+    return;
+  }
+
+  ReportSuccess(playback_info, out);
+}
+
 void MediaControllerInstance::MediaControllerServerInfoSendPlaybackState(
     const picojson::value& args,
     picojson::object& out) {

diff --git a/src/mediacontroller/mediacontroller_instance.h b/src/mediacontroller/mediacontroller_instance.h
index 0b57c6855a071a086034444ed6282b96ed94c7cf..8751844ad45e4d697e0b15b23cedc2eb6fd2dbcd 100644 (file)
--- a/src/mediacontroller/mediacontroller_instance.h
+++ b/src/mediacontroller/mediacontroller_instance.h
@@ -36,6 +36,7 @@ class MediaControllerInstance : public common::ParsedInstance {
   void MediaControllerManagerGetClient(const picojson::value& args, picojson::object& out);
   void MediaControllerClientFindServers(const picojson::value& args, picojson::object& out);
   void MediaControllerClientGetLatestServerInfo(const picojson::value& args, picojson::object& out);
+  void MediaControllerClientGetPlaybackInfo(const picojson::value& args, picojson::object& out);
   void MediaControllerServerInfoSendPlaybackState(const picojson::value& args, picojson::object& out);
   void MediaControllerServerInfoSendPlaybackPosition(const picojson::value& args, picojson::object& out);
   void MediaControllerServerInfoSendRepeatMode(const picojson::value& args, picojson::object& out);

diff --git a/src/mediacontroller/mediacontroller_types.cc b/src/mediacontroller/mediacontroller_types.cc
index 179cd829081125674632ee76b2f3cf1e8e8cafa1..6b5c4445486fc5eb7b592992bd1177ed4c204b7d 100644 (file)
--- a/src/mediacontroller/mediacontroller_types.cc
+++ b/src/mediacontroller/mediacontroller_types.cc
@@ -48,16 +48,29 @@ const PlatformEnumMap Types::platform_enum_map_ = {
 
 PlatformEnumReverseMap Types::platform_enum_reverse_map_ = {};
 
-PlatformResult Types::StringToPlatformEnum(const std::string& field,
-                                           const std::string& value,
-                                           int* platform_enum) {
-  auto iter = platform_enum_map_.find(field);
+PlatformResult Types::GetPlatformEnumMap(const std::string& type,
+                                  std::map<std::string, int>* enum_map) {
+
+  auto iter = platform_enum_map_.find(type);
   if (iter == platform_enum_map_.end()) {
     return PlatformResult(ErrorCode::UNKNOWN_ERR,
-        std::string("Undefined platform enum type ") + field);
+                          std::string("Undefined platform enum type ") + type);
+  }
+
+  *enum_map = platform_enum_map_.at(type);
+
+  return PlatformResult(ErrorCode::NO_ERROR);
+}
+
+PlatformResult Types::StringToPlatformEnum(const std::string& type,
+                                           const std::string& value,
+                                           int* platform_enum) {
+  std::map<std::string, int> def;
+  PlatformResult result = GetPlatformEnumMap(type, &def);
+  if (!result) {
+    return result;
   }
 
-  auto def = platform_enum_map_.at(field);
   auto def_iter = def.find(value);
   if (def_iter != def.end()) {
     *platform_enum = def_iter->second;
@@ -65,11 +78,11 @@ PlatformResult Types::StringToPlatformEnum(const std::string& field,
   }
 
   std::string message =
-      "Platform enum value " + value + " not found for " + field;
+      "Platform enum value " + value + " not found for " + type;
   return PlatformResult(ErrorCode::INVALID_VALUES_ERR, message);
 }
 
-PlatformResult Types::PlatformEnumToString(const std::string& field,
+PlatformResult Types::PlatformEnumToString(const std::string& type,
                                            int value,
                                            std::string* platform_str) {
   // TODO(r.galka) can be replaced by Boost.Bimap
@@ -83,13 +96,13 @@ PlatformResult Types::PlatformEnumToString(const std::string& field,
     }
   }
 
-  auto it = platform_enum_reverse_map_.find(field);
+  auto it = platform_enum_reverse_map_.find(type);
   if (it == platform_enum_reverse_map_.end()) {
     return PlatformResult(ErrorCode::UNKNOWN_ERR,
-        std::string("Undefined platform enum type ") + field);
+        std::string("Undefined platform enum type ") + type);
   }
 
-  auto def = platform_enum_reverse_map_.at(field);
+  auto def = platform_enum_reverse_map_.at(type);
   auto def_it = def.find(value);
   if (def_it != def.end()) {
     *platform_str = def_it->second;
@@ -97,7 +110,7 @@ PlatformResult Types::PlatformEnumToString(const std::string& field,
   }
 
   std::string message = "Platform enum value " + std::to_string(value) +
-      " not found for " + field;
+      " not found for " + type;
   return PlatformResult(ErrorCode::INVALID_VALUES_ERR, message);
 }
 

diff --git a/src/mediacontroller/mediacontroller_types.h b/src/mediacontroller/mediacontroller_types.h
index 84f77c0fa1ea26ff710cb25727101a83e3bbef41..1a8209cff83b430f653fb0d6f5bf7c2c65c87b6a 100644 (file)
--- a/src/mediacontroller/mediacontroller_types.h
+++ b/src/mediacontroller/mediacontroller_types.h
@@ -23,11 +23,14 @@ class Types {
   static const std::string kMediaControllerPlaybackState;
   static const std::string kMediaControllerMetadataAttribute;
 
+  static common::PlatformResult GetPlatformEnumMap(
+      const std::string& type, std::map<std::string, int>* platform_str);
+
   static common::PlatformResult StringToPlatformEnum(const std::string& type,
                                                      const std::string& value,
                                                      int* platform_enum);
 
-  static common::PlatformResult PlatformEnumToString(const std::string& field,
+  static common::PlatformResult PlatformEnumToString(const std::string& type,
                                                      int value,
                                                      std::string* platform_str);